List parameters and view parameter details

usingGoogle.Api.Gax ;
usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassListParametersSample
{
/// <summary>
/// This function lists parameter using the Parameter Manager SDK for GCP.
/// </summary>
/// <param name="projectId">The ID of the project where the parameter is located.</param>
/// <returns>A list of Parameter objects.</returns>
publicIEnumerable<Parameter>ListParameters(stringprojectId)
{
// Create the client.
ParameterManagerClient client=ParameterManagerClient .Create ();
// Build the parent resource name.
LocationName parent=newLocationName (projectId,"global");
// Call the API to list the parameters.
PagedEnumerable<ListParametersResponse,Parameter>response=client.ListParameters (parent);
// Print each parameter name.
foreach(Parameterparameterinresponse)
{
Console.WriteLine($"Found parameter {parameter.Name} with format {parameter.Format}");
}
// Return the list of parameters.
returnresponse;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
"google.golang.org/api/iterator"
)
// listParam lists parameters 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 parameters are located.
//
// The function returns an error if the parameter listing fails.
funclistParams(wio.Writer,projectIDstring)error{
// Create a context and a Parameter Manager client.
ctx:=context.Background()
client,err:=parametermanager.NewClient (ctx)
iferr!=nil{
returnfmt.Errorf("failed to create Parameter Manager client: %w",err)
}
deferclient.Close ()
// Construct the name of the list parameter.
parent:=fmt.Sprintf("projects/%s/locations/global",projectID)
// Build the request to list parameters.
req:=&parametermanagerpb.ListParametersRequest{
Parent:parent,
}
// Call the API to list parameters.
parameters:=client.ListParameters(ctx,req)
for{
parameter,err:=parameters.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnfmt.Errorf("failed to list parameters: %w",err)
}
fmt.Fprintf(w,"Found parameter %s with format %s \n",parameter.Name,parameter.Format.String())
}
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient.ListParametersPagedResponse ;
importjava.io.IOException;
/** Class to demonstrate listing parameter using the parameter manager SDK for GCP. */
publicclass ListParams{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
// Call the method to list parameters.
listParams(projectId);
}
// This is an example snippet for listing all parameters in given project.
publicstaticListParametersPagedResponse listParams(StringprojectId)throwsIOException{
// 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()){
StringlocationId="global";
// Build the parent name from the project.
LocationName location=LocationName .of(projectId,locationId);
// Get all parameters.
ListParametersPagedResponse response=client.listParameters(location.toString ());
// List all parameters.
response
.iterateAll()
.forEach(parameter->
System.out.printf("Found parameter %s with format %s\n",
parameter.getName(),parameter.getFormat()));
returnresponse;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Instantiates a client
constclient=newParameterManagerClient ();
asyncfunctionlistParams(){
// Construct the parent string for listing parameters globally
constparent=client.locationPath (projectId,'global');
constrequest={
parent:parent,
};
// Use listParametersAsync to handle pagination automatically
constparameters=awaitclient.listParametersAsync (request);
forawait(constparameterofparameters){
console.log(
`Found parameter ${parameter.name} with format ${parameter.format}`
);
}
returnparameters;
}
returnawaitlistParams();

// Import necessary classes for list a parameters.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\ListParametersRequest;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Lists a parameters using the Parameter Manager SDK for GCP.
 *
 * @param string $projectId The Google Cloud Project ID (e.g. 'my-project')
 */
function list_params(string $projectId): void
{
 // Create a client for the Parameter Manager service.
 $client = new ParameterManagerClient();
 // Build the resource name of the parameter.
 $parent = $client->locationName($projectId, 'global');
 // Prepare the request to list the parameters.
 $request = (new ListParametersRequest())
 ->setParent($parent);
 // Retrieve the parameter using the client.
 foreach ($client->listParameters($request) as $parameter) {
 printf('Found parameter %s with format %s' . PHP_EOL, $parameter->getName(), ParameterFormat::name($parameter->getFormat()));
 }
}

deflist_params(project_id: str) -> None:
"""
 Lists all parameters in the global location for the specified
 project using the Google Cloud Parameter Manager SDK.
 Args:
 project_id (str): The ID of the project
 where the parameters are located.
 Returns:
 None
 Example:
 list_params(
 "my-project"
 )
 """
 # Import the necessary library for Google Cloud Parameter Manager.
 fromgoogle.cloudimport parametermanager_v1
 # Create the Parameter Manager client.
 client = parametermanager_v1 .ParameterManagerClient ()
 # Build the resource name of the parent project in the global location.
 parent = client.common_location_path (project_id, "global")
 # List all parameters in the specified parent project.
 for parameter in client.list_parameters (parent=parent):
 print(f"Found parameter {parameter.name} with format {parameter.format_.name}")

require"google/cloud/parameter_manager"
##
# List a parameters
#
# @param project_id [String] The Google Cloud project (e.g. "my-project")
#
deflist_paramsproject_id:
# Create a Parameter Manager client.
client=Google::Cloud::ParameterManager .parameter_manager
# Build the resource name of the parent project.
parent=client.location_path project:project_id,location:"global"
# List the parameters.
param_list=client.list_parametersparent:parent
# Print out all parameters.
param_list.eachdo|param|
puts"Found parameter #{param.name} with format #{param.format }"
end
end

usingGoogle.Api.Gax ;
usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassListRegionalParametersSample
{
/// <summary>
/// This function lists all regional parameters 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>
/// <returns>A list of Parameter objects.</returns>
publicIEnumerable<Parameter>ListRegionalParameters(
stringprojectId,
stringlocationId)
{
// Define the regional endpoint
stringregionalEndpoint=$"parametermanager.{locationId}.rep.googleapis.com";
// Create the client with the regional endpoint
ParameterManagerClient client=newParameterManagerClientBuilder
{
Endpoint=regionalEndpoint
}.Build ();
// Build the parent resource name for the regional locationId
LocationName parent=newLocationName (projectId,locationId);
// Call the API to list the parameters
PagedEnumerable<ListParametersResponse,Parameter>response=client.ListParameters (parent);
// Print each parameter name
foreach(Parameterparameterinresponse)
{
Console.WriteLine($"Found regional parameter {parameter.Name} with format {parameter.Format}");
}
// Return the list of parameters
returnresponse;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
"google.golang.org/api/iterator"
"google.golang.org/api/option"
)
// listRegionalParam lists all parameters regional using the Parameter Manager SDK for GCP.
//
// 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 to be listed.
//
// The function returns an error if the parameter listing fails
funclistRegionalParam(wio.Writer,projectID,locationIDstring)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))
iferr!=nil{
returnfmt.Errorf("failed to create Parameter Manager client: %w",err)
}
deferclient.Close ()
// Construct the name of the parent resource to list parameters.
parent:=fmt.Sprintf("projects/%s/locations/%s",projectID,locationID)
// Build the request to list all parameters.
req:=&parametermanagerpb.ListParametersRequest{
Parent:parent,
}
// Call the API to list all parameters.
parameters:=client.ListParameters(ctx,req)
for{
parameter,err:=parameters.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnfmt.Errorf("failed to list parameters: %w",err)
}
fmt.Fprintf(w,"Found regional parameter %s with format %s\n",parameter.Name,parameter.Format.String())
}
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient.ListParametersPagedResponse ;
importcom.google.cloud.parametermanager.v1.ParameterManagerSettings ;
importjava.io.IOException;
/**
 * Class to demonstrate listing parameters for a specified region using the Parameter Manager SDK
 * for GCP.
 */
publicclass ListRegionalParams{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
StringlocationId="your-location-id";
// Call the method to list parameters regionally.
listRegionalParams(projectId,locationId);
}
// This is an example snippet that list all parameters in a given region.
publicstaticListParametersPagedResponse listRegionalParams(StringprojectId,StringlocationId)
throwsIOException{
// Endpoint to call the regional parameter manager server
StringapiEndpoint=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 parent name from the project.
LocationName location=LocationName .of(projectId,locationId);
// Get all parameters.
ListParametersPagedResponse response=client.listParameters(location.toString ());
// List all parameters.
response
.iterateAll()
.forEach(parameter->
System.out.printf("Found regional parameter %s with format %s\n",
parameter.getName(),parameter.getFormat()));
returnresponse;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const locationId = 'us-central1';
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Adding the endpoint to call the regional parameter manager server
constoptions={
apiEndpoint:`parametermanager.${locationId}.rep.googleapis.com`,
};
// Instantiates a client with regional endpoint
constclient=newParameterManagerClient (options);
asyncfunctionlistRegionalParams(){
// Construct the parent string for listing parameters in a specific region
constparent=client.locationPath (projectId,locationId);
constrequest={
parent:parent,
};
// Use listParametersAsync to handle pagination automatically
constparameters=awaitclient.listParametersAsync (request);
forawait(constparameterofparameters){
console.log(
`Found regional parameter ${parameter.name} with format ${parameter.format}`
);
}
returnparameters;
}
returnawaitlistRegionalParams();

// Import necessary classes for list a parameters.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\ListParametersRequest;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Lists a regional parameters 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')
 */
function list_regional_params(string $projectId, string $locationId): 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.
 $parent = $client->locationName($projectId, $locationId);
 // Prepare the request to list the parameters.
 $request = (new ListParametersRequest())
 ->setParent($parent);
 // Retrieve the parameter using the client.
 foreach ($client->listParameters($request) as $parameter) {
 printf('Found regional parameter %s with format %s' . PHP_EOL, $parameter->getName(), ParameterFormat::name($parameter->getFormat()));
 }
}

deflist_regional_params(project_id: str, location_id: str) -> None:
"""
 Lists all parameters in the specified region for the specified
 project using the Google Cloud Parameter Manager SDK.
 Args:
 project_id (str): The ID of the project where
 the parameters are located.
 location_id (str): The ID of the region where
 the parameters are located.
 Returns:
 None
 Example:
 list_regional_params(
 "my-project",
 "us-central1"
 )
 """
 # Import the necessary library for Google Cloud Parameter Manager.
 fromgoogle.cloudimport 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 parent project in the specified region.
 parent = client.common_location_path (project_id, location_id)
 # List all parameters in the specified parent project and region.
 for parameter in client.list_parameters (parent=parent):
 print(f"Found regional parameter {parameter.name} with format {parameter.format_.name}")

require"google/cloud/parameter_manager"
##
# List a regional parameters
#
# @param project_id [String] The Google Cloud project (e.g. "my-project")
# @param location_id [String] The location name (e.g. "us-central1")
#
deflist_regional_paramsproject_id:,location_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.
parent=client.location_path project:project_id,location:location_id
# List the parameters.
param_list=client.list_parametersparent:parent
# Print out all parameters.
param_list.eachdo|param|
puts"Found regional parameter #{param.name} with format #{param.format }"
end
end

usingGoogle.Cloud.ParameterManager.V1 ;
publicclassGetParameterSample
{
/// <summary>
/// This function retrieves a parameter 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 to be retrieved.</param>
/// <returns>The retrieved Parameter object.</returns>
publicParameterGetParameter(
stringprojectId,
stringparameterId)
{
// Create the client.
ParameterManagerClient client=ParameterManagerClient .Create ();
// Build the resource name for the parameter.
ParameterName parameterName=newParameterName (projectId,"global",parameterId);
// Call the API to get the parameter.
Parameterparameter=client.GetParameter (parameterName);
// Print the retrieved parameter name.
Console.WriteLine($"Found the parameter {parameter.Name} with format {parameter.Format}");
// Return the retrieved parameter.
returnparameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
)
// getParam get parameter 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 to retrieved.
//
// The function returns an error if the parameter retrieval fails.
funcgetParam(wio.Writer,projectID,parameterIDstring)error{
// Create a context and a Parameter Manager client.
ctx:=context.Background()
client,err:=parametermanager.NewClient (ctx)
iferr!=nil{
returnfmt.Errorf("failed to create Parameter Manager client: %w",err)
}
deferclient.Close ()
// Construct the name of the parameter to get parameter.
name:=fmt.Sprintf("projects/%s/locations/global/parameters/%s",projectID,parameterID)
// Build the request to get parameter.
req:=&parametermanagerpb.GetParameterRequest{
Name:name,
}
// Call the API to get parameter.
param,err:=client.GetParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to get parameter: %w",err)
}
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
fmt.Fprintf(w,"Found parameter %s with format %s\n",param.Name,param.Format.String())
returnnil
}

importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterName ;
importjava.io.IOException;
/** This class demonstrates how to get a parameter using the Parameter Manager SDK for GCP. */
publicclass GetParam{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
StringparameterId="your-parameter-id";
// Call the method to get a parameter.
getParam(projectId,parameterId);
}
// This is an example snippet for getting a parameter.
publicstaticParameter getParam(StringprojectId,StringparameterId)throwsIOException{
// 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()){
StringlocationId="global";
// Build the parameter name.
ParameterName parameterName=ParameterName .of(projectId,locationId,parameterId);
// Get the parameter.
Parameter parameter=client.getParameter(parameterName.toString ());
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
System.out.printf(
"Found the parameter %s with format: %s\n",parameter.getName (),parameter.getFormat ());
returnparameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const parameterId = 'my-parameter';
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Instantiates a client
constclient=newParameterManagerClient ();
asyncfunctiongetParam(){
// Construct the fully qualified parameter name
constname=client.parameterPath (projectId,'global',parameterId);
// Get the parameter
const[parameter]=awaitclient.getParameter({
name:name,
});
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
console.log(
`Found parameter ${parameter.name} with format ${parameter.format}`
);
returnparameter;
}
returnawaitgetParam();

// Import necessary classes for retrieve a parameter version.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\GetParameterRequest;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Retrieves a parameter 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')
 */
function get_param(string $projectId, string $parameterId): void
{
 // Create a client for the Parameter Manager service.
 $client = new ParameterManagerClient();
 // Build the resource name of the parameter.
 $parameterName = $client->parameterName($projectId, 'global', $parameterId);
 // Prepare the request to get the parameter.
 $request = (new GetParameterRequest())
 ->setName($parameterName);
 // Retrieve the parameter using the client.
 $parameter = $client->getParameter($request);
 // Print the retrieved parameter details.
 printf('Found parameter %s with format %s' . PHP_EOL, $parameter->getName(), ParameterFormat::name($parameter->getFormat()));
}

defget_param(project_id: str, parameter_id: str) -> parametermanager_v1.Parameter:
"""
 Retrieves a parameter from the global location 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.
 parameter_id (str): The ID of the parameter to retrieve.
 Returns:
 parametermanager_v1.Parameter: An object representing the parameter.
 Example:
 get_param(
 "my-project",
 "my-global-parameter"
 )
 """
 # Import the necessary library for Google Cloud Parameter Manager.
 fromgoogle.cloudimport parametermanager_v1
 # Create the Parameter Manager client.
 client = parametermanager_v1.ParameterManagerClient()
 # Build the resource name of the parameter.
 name = client.parameter_path(project_id, "global", parameter_id)
 # Retrieve the parameter.
 parameter = client.get_parameter(name=name)
 # Show parameter details.
 # Find more details for the Parameter object here:
 # https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
 print(f"Found the parameter {parameter.name} with format {parameter.format_.name}")

require"google/cloud/parameter_manager"
##
# Retrieve a parameter
#
# @param project_id [String] The Google Cloud project (e.g. "my-project")
# @param parameter_id [String] The parameter name (e.g. "my-parameter")
#
defget_paramproject_id:,parameter_id:
# Create a Parameter Manager client.
client=Google::Cloud::ParameterManager .parameter_manager
# Build the resource name of the parent project.
name=client.parameter_path project:project_id,location:"global",parameter:parameter_id
# Retrieve the parameter.
param=client.get_parametername:name
# Print the retrieved parameter name.
puts"Found parameter #{param.name} with format #{param.format }"
end

usingGoogle.Cloud.ParameterManager.V1 ;
publicclassGetRegionalParameterSample
{
/// <summary>
/// This function retrieves a regional parameter 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 to be retrieved.</param>
/// <returns>The retrieved Parameter object.</returns>
publicParameterGetRegionalParameter(
stringprojectId,
stringlocationId,
stringparameterId)
{
// Define the regional endpoint
stringregionalEndpoint=$"parametermanager.{locationId}.rep.googleapis.com";
// Create the client with the regional endpoint
ParameterManagerClient client=newParameterManagerClientBuilder
{
Endpoint=regionalEndpoint
}.Build ();
// Build the resource name for the parameter in the specified regional locationId
ParameterName parameterName=newParameterName (projectId,locationId,parameterId);
// Call the API to get the parameter
Parameterparameter=client.GetParameter (parameterName);
// Print the retrieved parameter name
Console.WriteLine($"Found the regional parameter {parameter.Name} with format {parameter.Format}");
// Return the retrieved parameter
returnparameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
"google.golang.org/api/option"
)
// getRegionalParam gets a parameter 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 to be retrieved.
//
// The function returns an error if the parameter retrieval fails.
funcgetRegionalParam(wio.Writer,projectID,locationID,parameterIDstring)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))
iferr!=nil{
returnfmt.Errorf("failed to create Parameter Manager client: %w",err)
}
deferclient.Close ()
// Construct the name of the parameter to retrieve.
name:=fmt.Sprintf("projects/%s/locations/%s/parameters/%s",projectID,locationID,parameterID)
// Build the request to get the parameter.
req:=&parametermanagerpb.GetParameterRequest{
Name:name,
}
// Call the API to get the parameter.
param,err:=client.GetParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to get parameter: %w",err)
}
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
fmt.Fprintf(w,"Found regional parameter %s with format %s\n",param.Name,param.Format.String())
returnnil
}

importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterManagerSettings ;
importcom.google.cloud.parametermanager.v1.ParameterName ;
importjava.io.IOException;
/**
 * This class demonstrates how to get a regional parameter using the Parameter Manager SDK for GCP.
 */
publicclass GetRegionalParam{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
StringlocationId="your-location-id";
StringparameterId="your-parameter-id";
// Call the method to get a regional parameter.
getRegionalParam(projectId,locationId,parameterId);
}
// This is an example snippet that gets a regional parameter.
publicstaticParameter getRegionalParam(StringprojectId,StringlocationId,StringparameterId)
throwsIOException{
// Endpoint to call the regional parameter manager server
StringapiEndpoint=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 name.
ParameterName parameterName=ParameterName .of(projectId,locationId,parameterId);
// Get the parameter.
Parameter parameter=client.getParameter(parameterName.toString ());
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
System.out.printf(
"Found the regional parameter %s with format %s\n",
parameter.getName (),parameter.getFormat ());
returnparameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project';
// const locationId = 'us-central1';
// const parameterId = 'my-parameter';
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Adding the endpoint to call the regional parameter manager server
constoptions={
apiEndpoint:`parametermanager.${locationId}.rep.googleapis.com`,
};
// Instantiates a client with regional endpoint
constclient=newParameterManagerClient (options);
asyncfunctiongetRegionalParam(){
// Construct the fully qualified parameter name
constname=client.parameterPath (projectId,locationId,parameterId);
// Get the parameter
const[parameter]=awaitclient.getParameter({
name:name,
});
// Find more details for the Parameter object here:
// https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
console.log(
`Found regional parameter ${parameter.name} with format ${parameter.format}`
);
returnparameter;
}
returnawaitgetRegionalParam();

// Import necessary classes for retrieve a parameter version.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\GetParameterRequest;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Retrieves a regional parameter 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')
 */
function get_regional_param(string $projectId, string $locationId, string $parameterId): 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.
 $parameterName = $client->parameterName($projectId, $locationId, $parameterId);
 // Prepare the request to get the parameter.
 $request = (new GetParameterRequest())
 ->setName($parameterName);
 // Retrieve the parameter using the client.
 $parameter = $client->getParameter($request);
 // Print the retrieved parameter details.
 printf('Found regional parameter %s with format %s' . PHP_EOL, $parameter->getName(), ParameterFormat::name($parameter->getFormat()));
}

defget_regional_param(
 project_id: str, location_id: str, parameter_id: str
) -> parametermanager_v1.Parameter:
"""
 Retrieves a parameter from 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 to retrieve.
 Returns:
 parametermanager_v1.Parameter: An object representing the parameter.
 Example:
 get_regional_param(
 "my-project",
 "us-central1",
 "my-regional-parameter"
 )
 """
 # Import the necessary library for Google Cloud Parameter Manager.
 fromgoogle.cloudimport 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.
 name = client.parameter_path (project_id, location_id, parameter_id)
 # Retrieve the parameter.
 parameter = client.get_parameter (name=name)
 # Show parameter details.
 # Find more details for the Parameter object here:
 # https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
 print(f"Found the regional parameter {parameter.name} with format {parameter.format_.name}")

require"google/cloud/parameter_manager"
##
# Retrieve a regional parameter
#
# @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")
#
defget_regional_paramproject_id:,location_id:,parameter_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_path project:project_id,location:location_id,parameter:parameter_id
# Retrieve the parameter.
param=client.get_parametername:name
# Print the retrieved parameter name.
puts"Found regional parameter #{param.name} with format #{param.format }"
end