View parameter version details

using Google.Cloud.ParameterManager.V1;
using System.Text;

public class GetParameterVersionSample
{
    /// <summary>
    /// This function retrieves a parameter version using the Parameter Manager SDK for GCP.
    /// </summary>
    /// <param name="projectId">The ID of the project where the parameter is located.</param>
    /// <param name="parameterId">The ID of the parameter for which the version is to be retrieved.</param>
    /// <param name="versionId">The ID of the version to be retrieved.</param>
    /// <returns>The retrieved ParameterVersion object.</returns>
    public ParameterVersion GetParameterVersion(
        string projectId,
        string parameterId,
        string versionId)
    {
        // Create the client.
        ParameterManagerClient client = ParameterManagerClient.Create();

        // Build the resource name for the parameter version.
        ParameterVersionName parameterVersionName = new ParameterVersionName(projectId, "global", parameterId, versionId);

        // Call the API to get the parameter version.
        ParameterVersion parameterVersion = client.GetParameterVersion(parameterVersionName);

        // Print the retrieved parameter version name.
        Console.WriteLine($"Found regional parameter version {parameterVersion.Name} with state {(parameterVersion.Disabled ? "disabled" : "enabled")}");

        if (!parameterVersion.Disabled)
        {
            Console.WriteLine($"Payload: {Encoding.UTF8.GetString(parameterVersion.Payload.Data.ToByteArray())}");
        }

        // Return the retrieved parameter version.
        return parameterVersion;
    }
}

import (
	"context"
	"fmt"
	"io"

	parametermanager "cloud.google.com/go/parametermanager/apiv1"
	parametermanagerpb "cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
)

// getParamVersion get parameter version using the Parameter Manager SDK for GCP.
//
// w: The io.Writer object used to write the output.
// projectID: The ID of the project where the parameter is located.
// parameterID: The ID of the parameter for which the version details are to be retrieved.
// versionID: The ID of the version to be retrieved.
//
// The function returns an error if the parameter version retrieval fails.
func getParamVersion(w io.Writer, projectID, parameterID, versionID string) error {
	// Create a context and a Parameter Manager client.
	ctx := context.Background()
	client, err := parametermanager.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create Parameter Manager client: %w", err)
	}
	defer client.Close()

	// Construct the name of the parameter to get the parameter version.
	name := fmt.Sprintf("projects/%s/locations/global/parameters/%s/versions/%s", projectID, parameterID, versionID)

	// Build the request to get parameter version.
	req := &parametermanagerpb.GetParameterVersionRequest{
		Name: name,
	}

	// Call the API to get parameter version.
	version, err := client.GetParameterVersion(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get parameter version: %w", err)
	}

	// Find more details for the Parameter Version object here:
	// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
	fmt.Fprintf(w, "Found parameter version %s with disabled state in %v\n", version.Name, version.Disabled)
	if !version.Disabled {
		fmt.Fprintf(w, "Payload: %s\n", version.Payload.Data)
	}
	return nil
}

import com.google.cloud.parametermanager.v1.ParameterManagerClient;
import com.google.cloud.parametermanager.v1.ParameterVersion;
import com.google.cloud.parametermanager.v1.ParameterVersionName;
import java.io.IOException;

/**
 * This class demonstrates how to get a parameter version using the Parameter Manager SDK for GCP.
 */
public class GetParamVersion {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String parameterId = "your-parameter-id";
    String versionId = "your-version-id";

    // Call the method to get a parameter version.
    getParamVersion(projectId, parameterId, versionId);
  }

  // This is an example snippet for getting a parameter version.
  public static ParameterVersion getParamVersion(
      String projectId, String parameterId, String versionId) throws IOException {
    // Initialize the client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ParameterManagerClient client = ParameterManagerClient.create()) {
      String locationId = "global";

      // Build the parameter version name.
      ParameterVersionName parameterVersionName =
          ParameterVersionName.of(projectId, locationId, parameterId, versionId);

      // Get the parameter version.
      ParameterVersion parameterVersion =
          client.getParameterVersion(parameterVersionName.toString());
      // Find more details for the Parameter Version object here:
      // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
      System.out.printf(
          "Found parameter version %s with state %s\n",
          parameterVersion.getName(), (parameterVersion.getDisabled() ? "disabled" : "enabled"));
      if (!parameterVersion.getDisabled()) {
        System.out.printf("Payload: %s\n", parameterVersion.getPayload().getData().toStringUtf8());
      }
      return parameterVersion;
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const parameterId = 'my-parameter';
// const versionId = 'v1';

// Imports the Parameter Manager library
const {ParameterManagerClient} = require('@google-cloud/parametermanager');

// Instantiates a client
const client = new ParameterManagerClient();

async function getParamVersion() {
  // Construct the fully qualified parameter version name
  const name = client.parameterVersionPath(
    projectId,
    'global',
    parameterId,
    versionId
  );

  // Get the parameter version
  const [parameterVersion] = await client.getParameterVersion({
    name: name,
  });
  // Find more details for the Parameter Version object here:
  // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
  console.log(
    `Found parameter version ${parameterVersion.name} with state ${parameterVersion.disabled ? 'disabled' : 'enabled'}`
  );
  if (!parameterVersion.disabled) {
    console.log(
      `Payload: ${parameterVersion.payload.data.toString('utf-8')}`
    );
  }
  return parameterVersion;
}

return await getParamVersion();

// Import necessary classes for retrieve a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\GetParameterVersionRequest;

/**
 * Retrieves a parameter version using the Parameter Manager SDK for GCP.
 *
 * @param string $projectId The Google Cloud Project ID (e.g. 'my-project')
 * @param string $parameterId The Parameter ID (e.g. 'my-param')
 * @param string $versionId The Version ID (e.g. 'my-param-version')
 */
function get_param_version(string $projectId, string $parameterId, string $versionId): void
{
    // Create a client for the Parameter Manager service.
    $client = new ParameterManagerClient();

    // Build the resource name of the parameter version.
    $parameterVersionName = $client->parameterVersionName($projectId, 'global', $parameterId, $versionId);

    // Prepare the request to get the parameter version.
    $request = (new GetParameterVersionRequest())
        ->setName($parameterVersionName);

    // Retrieve the parameter version using the client.
    $parameterVersion = $client->getParameterVersion($request);

    // Print the retrieved parameter version details.
    printf('Found parameter version %s with state %s' . PHP_EOL, $parameterVersion->getName(), $parameterVersion->getDisabled() ? 'disabled' : 'enabled');
    if (!($parameterVersion->getDisabled())) {
        printf('Payload: %s' . PHP_EOL, $parameterVersion->getPayload()->getData());
    }
}

def get_param_version(
    project_id: str, parameter_id: str, version_id: str
) -> parametermanager_v1.ParameterVersion:
    """
    Retrieves the details of a specific version of an
    existing parameter in the specified
    project using the Google Cloud Parameter Manager SDK.

    Args:
        project_id (str): The ID of the project where the parameter is located.
        parameter_id (str): The ID of the parameter for
        which the version details are to be retrieved.
        version_id (str): The ID of the version to be retrieved.

    Returns:
        parametermanager_v1.ParameterVersion: An object
        representing the parameter version.

    Example:
        get_param_version(
            "my-project",
            "my-global-parameter",
            "v1"
        )
    """
    # Import the necessary library for Google Cloud Parameter Manager.
    from google.cloud import parametermanager_v1

    # Create the Parameter Manager client.
    client = parametermanager_v1.ParameterManagerClient()

    # Build the resource name of the parameter version.
    name = client.parameter_version_path(project_id, "global", parameter_id, version_id)

    # Define the request to get the parameter version details.
    request = parametermanager_v1.GetParameterVersionRequest(name=name)

    # Get the parameter version details.
    response = client.get_parameter_version(request=request)

    # Show parameter version details.
    # Find more details for the Parameter Version object here:
    # https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
    print(f"Found parameter version {response.name} with state {'disabled' if response.disabled else 'enabled'}")
    if not response.disabled:
        print(f"Payload: {response.payload.data.decode('utf-8')}")

require "google/cloud/parameter_manager"

##
# Retrieve a parameter version
#
# @param project_id [String] The Google Cloud project (e.g. "my-project")
# @param parameter_id [String] The parameter name (e.g. "my-parameter")
# @param version_id [String] The version name (e.g. "my-version")
#
def get_param_version project_id:, parameter_id:, version_id:
  # Create a Parameter Manager client.
  client = Google::Cloud::ParameterManager.parameter_manager

  # Build the resource name of the parent project.
  name = client.parameter_version_path project: project_id, location: "global", parameter: parameter_id,
                                       parameter_version: version_id

  # Retrieve the parameter version.
  param_version = client.get_parameter_version name: name

  # Print the retrieved parameter version name.
  puts "Found parameter version #{param_version.name} with state #{param_version.disabled ? 'disabled' : 'enabled'}"

  # Use a guard clause to return early if the parameter version is disabled.
  return if param_version.disabled

  puts "Payload: #{param_version.payload.data}"
end

using Google.Cloud.ParameterManager.V1;
using System.Text;

public class GetRegionalParameterVersionSample
{
    /// <summary>
    /// This function retrieves a regional parameter version using the Parameter Manager SDK for GCP.
    /// </summary>
    /// <param name="projectId">The ID of the project where the parameter is located.</param>
    /// <param name="locationId">The ID of the region where the parameter is located.</param>
    /// <param name="parameterId">The ID of the parameter for which the version is to be retrieved.</param>
    /// <param name="versionId">The ID of the version to be retrieved.</param>
    /// <returns>The retrieved ParameterVersion object.</returns>
    public ParameterVersion GetRegionalParameterVersion(
        string projectId,
        string locationId,
        string parameterId,
        string versionId)
    {
        // Define the regional endpoint
        string regionalEndpoint = $"parametermanager.{locationId}.rep.googleapis.com";

        // Create the client with the regional endpoint
        ParameterManagerClient client = new ParameterManagerClientBuilder
        {
            Endpoint = regionalEndpoint
        }.Build();

        // Build the resource name for the parameter version in the specified regional locationId
        ParameterVersionName parameterVersionName = new ParameterVersionName(projectId, locationId, parameterId, versionId);

        // Call the API to get the parameter version
        ParameterVersion parameterVersion = client.GetParameterVersion(parameterVersionName);



        // Print the retrieved parameter version name
        Console.WriteLine($"Found regional parameter version {parameterVersion.Name} with state {(parameterVersion.Disabled ? "disabled" : "enabled")}");

        if (!parameterVersion.Disabled)
        {
            Console.WriteLine($"Payload: {Encoding.UTF8.GetString(parameterVersion.Payload.Data.ToByteArray())}");
        }

        // Return the retrieved parameter version
        return parameterVersion;
    }
}

import (
	"context"
	"fmt"
	"io"

	parametermanager "cloud.google.com/go/parametermanager/apiv1"
	parametermanagerpb "cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
	"google.golang.org/api/option"
)

// getRegionalParamVersion gets a parameter version regional using the Parameter Manager SDK for GCP.
//
// w: The io.Writer object used to write the output.
// projectID: The ID of the project where the parameter is located.
// locationID: The ID of the region where the parameter is located.
// parameterID: The ID of the parameter for which the version is to be retrieved.
// versionID: The ID of the version to be retrieved.
//
// The function returns an error if the parameter version retrieval fails.
func getRegionalParamVersion(w io.Writer, projectID, locationID, parameterID, versionID string) error {
	// Create a new context.
	ctx := context.Background()

	// Create a Parameter Manager client.
	endpoint := fmt.Sprintf("parametermanager.%s.rep.googleapis.com:443", locationID)
	client, err := parametermanager.NewClient(ctx, option.WithEndpoint(endpoint))
	if err != nil {
		return fmt.Errorf("failed to create Parameter Manager client: %w", err)
	}
	defer client.Close()

	// Construct the name of the parameter version to retrieve.
	name := fmt.Sprintf("projects/%s/locations/%s/parameters/%s/versions/%s", projectID, locationID, parameterID, versionID)

	// Build the request to get the parameter version.
	req := &parametermanagerpb.GetParameterVersionRequest{
		Name: name,
	}

	// Call the API to get the parameter version.
	version, err := client.GetParameterVersion(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to get parameter version: %w", err)
	}

	// Find more details for the Parameter Version object here:
	// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
	fmt.Fprintf(w, "Found regional parameter version %s with disabled state in %v\n", version.Name, version.Disabled)
	if !version.Disabled {
		fmt.Fprintf(w, "Payload: %s\n", version.Payload.Data)
	}
	return nil
}

import com.google.cloud.parametermanager.v1.ParameterManagerClient;
import com.google.cloud.parametermanager.v1.ParameterManagerSettings;
import com.google.cloud.parametermanager.v1.ParameterVersion;
import com.google.cloud.parametermanager.v1.ParameterVersionName;
import java.io.IOException;

/**
 * This class demonstrates how to get a regional parameter version using the Parameter Manager SDK
 * for GCP.
 */
public class GetRegionalParamVersion {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "your-location-id";
    String parameterId = "your-parameter-id";
    String versionId = "your-version-id";

    // Call the method to get a regional parameter version.
    getRegionalParamVersion(projectId, locationId, parameterId, versionId);
  }

  // This is an example snippet that gets a regional parameter version.
  public static ParameterVersion getRegionalParamVersion(
      String projectId, String locationId, String parameterId, String versionId)
      throws IOException {
    // Endpoint to call the regional parameter manager server
    String apiEndpoint = String.format("parametermanager.%s.rep.googleapis.com:443", locationId);
    ParameterManagerSettings parameterManagerSettings =
        ParameterManagerSettings.newBuilder().setEndpoint(apiEndpoint).build();

    // Initialize the client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests.
    try (ParameterManagerClient client = ParameterManagerClient.create(parameterManagerSettings)) {
      // Build the parameter version name.
      ParameterVersionName parameterVersionName =
          ParameterVersionName.of(projectId, locationId, parameterId, versionId);

      // Get the parameter version.
      ParameterVersion parameterVersion =
          client.getParameterVersion(parameterVersionName.toString());
      // Find more details for the Parameter Version object here:
      // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
      System.out.printf(
          "Found regional parameter version %s with state %s\n",
          parameterVersion.getName(), (parameterVersion.getDisabled() ? "disabled" : "enabled"));
      if (!parameterVersion.getDisabled()) {
        System.out.printf("Payload: %s", parameterVersion.getPayload().getData().toStringUtf8());
      }
      return parameterVersion;
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const parameterId = 'my-parameter';
// const versionId = 'v1';

// Imports the Parameter Manager library
const {ParameterManagerClient} = require('@google-cloud/parametermanager');

// Adding the endpoint to call the regional parameter manager server
const options = {
  apiEndpoint: `parametermanager.${locationId}.rep.googleapis.com`,
};

// Instantiates a client with regional endpoint
const client = new ParameterManagerClient(options);

async function getRegionalParamVersion() {
  // Construct the fully qualified parameter version name
  const name = client.parameterVersionPath(
    projectId,
    locationId,
    parameterId,
    versionId
  );

  // Get the parameter version
  const [parameterVersion] = await client.getParameterVersion({
    name: name,
  });

  // Find more details for the Parameter Version object here:
  // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
  console.log(
    `Found regional parameter version ${parameterVersion.name} with state ${parameterVersion.disabled ? 'disabled' : 'enabled'}`
  );
  if (!parameterVersion.disabled) {
    console.log(
      `Payload: ${parameterVersion.payload.data.toString('utf-8')}`
    );
  }
  return parameterVersion;
}

return await getRegionalParamVersion();

// Import necessary classes for retrieve a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\GetParameterVersionRequest;

/**
 * Retrieves a regional parameter version using the Parameter Manager SDK for GCP.
 *
 * @param string $projectId The Google Cloud Project ID (e.g. 'my-project')
 * @param string $locationId The Parameter Location (e.g. 'us-central1')
 * @param string $parameterId The Parameter ID (e.g. 'my-param')
 * @param string $versionId The Version ID (e.g. 'my-param-version')
 */
function get_regional_param_version(string $projectId, string $locationId, string $parameterId, string $versionId): void
{
    // Specify regional endpoint.
    $options = ['apiEndpoint' => "parametermanager.$locationId.rep.googleapis.com"];

    // Create a client for the Parameter Manager service.
    $client = new ParameterManagerClient($options);

    // Build the resource name of the parameter version.
    $parameterVersionName = $client->parameterVersionName($projectId, $locationId, $parameterId, $versionId);

    // Prepare the request to get the parameter version.
    $request = (new GetParameterVersionRequest())
        ->setName($parameterVersionName);

    // Retrieve the parameter version using the client.
    $parameterVersion = $client->getParameterVersion($request);

    printf('Found regional parameter version %s with state %s' . PHP_EOL, $parameterVersion->getName(), $parameterVersion->getDisabled() ? 'disabled' : 'enabled');
    if (!($parameterVersion->getDisabled())) {
        printf('Payload: %s' . PHP_EOL, $parameterVersion->getPayload()->getData());
    }
}

def get_regional_param_version(
    project_id: str, location_id: str, parameter_id: str, version_id: str
) -> parametermanager_v1.ParameterVersion:
    """
    Retrieves the details of a specific version of an
    existing parameter in the specified region of the specified
    project using the Google Cloud Parameter Manager SDK.

    Args:
        project_id (str): The ID of the project where the parameter is located.
        location_id (str): The ID of the region where the parameter is located.
        parameter_id (str): The ID of the parameter for
        which version details are to be retrieved.
        version_id (str): The ID of the version to be retrieved.

    Returns:
        parametermanager_v1.ParameterVersion: An object
        representing the parameter version.

    Example:
        get_regional_param_version(
            "my-project",
            "us-central1",
            "my-regional-parameter",
            "v1"
        )
    """
    # Import the necessary library for Google Cloud Parameter Manager.
    from google.cloud import parametermanager_v1

    # Create the Parameter Manager client with the regional endpoint.
    api_endpoint = f"parametermanager.{location_id}.rep.googleapis.com"
    client = parametermanager_v1.ParameterManagerClient(
        client_options={"api_endpoint": api_endpoint}
    )

    # Build the resource name of the parameter version.
    name = client.parameter_version_path(
        project_id, location_id, parameter_id, version_id
    )

    # Define the request to get the parameter version details.
    request = parametermanager_v1.GetParameterVersionRequest(name=name)

    # Get the parameter version details.
    response = client.get_parameter_version(request=request)

    # Show parameter version details.
    # Find more details for the Parameter Version object here:
    # https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
    print(f"Found regional parameter version {response.name} with state {'disabled' if response.disabled else 'enabled'}")
    if not response.disabled:
        print(f"Payload: {response.payload.data.decode('utf-8')}")

require "google/cloud/parameter_manager"

##
# Retrieve a regional parameter version
#
# @param project_id [String] The Google Cloud project (e.g. "my-project")
# @param location_id [String] The location name (e.g. "us-central1")
# @param parameter_id [String] The parameter name (e.g. "my-parameter")
# @param version_id [String] The version name (e.g. "my-version")
#
def get_regional_param_version project_id:, location_id:, parameter_id:, version_id:
  # Endpoint for the regional parameter manager service.
  api_endpoint = "parametermanager.#{location_id}.rep.googleapis.com"

  # Create the Parameter Manager client.
  client = Google::Cloud::ParameterManager.parameter_manager do |config|
    config.endpoint = api_endpoint
  end

  # Build the resource name of the parent project.
  name = client.parameter_version_path project: project_id, location: location_id, parameter: parameter_id,
                                       parameter_version: version_id

  # Retrieve the parameter version.
  param_version = client.get_parameter_version name: name

  # Print the retrieved parameter version name.
  state = param_version.disabled ? "disabled" : "enabled"
  puts "Found regional parameter version #{param_version.name} with state #{state}"

  # Use a guard clause to return early if the parameter version is disabled.
  return if param_version.disabled

  puts "Payload: #{param_version.payload.data}"
end