Create a parameter

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassCreateStructuredParameterSample
{
/// <summary>
/// This function creates a parameter of the specified format type using the Parameter Manager SDK for GCP.
/// </summary>
/// <param name="projectId">The ID of the project where the parameter is to be created.</param>
/// <param name="parameterId">The ID to assign to the new parameter. This ID must be unique within the project.</param>
/// <param name="format">The format type of the parameter (UNFORMATTED, YAML, JSON).</param>
/// <returns>The created Parameter object.</returns>
publicParameterCreateStructuredParameter(
stringprojectId,
stringparameterId,
ParameterFormat format)
{
// Create the client.
ParameterManagerClient client=ParameterManagerClient .Create ();
// Build the parent resource name. 
LocationName parent=newLocationName (projectId,"global");
// Build the parameter with the specified format.
Parameterparameter=newParameter
{
Format=format
};
// Call the API to create the parameter.
ParametercreatedParameter=client.CreateParameter (parent,parameter,parameterId);
// Print the created parameter name.
Console.WriteLine($"Created parameter {createdParameter.Name} with format {createdParameter.Format}");
// Return the created parameter.
returncreatedParameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
)
// createStructuredParam creates a new parameter with the specified format in Parameter Manager.
//
// 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 be created.
// format: The format type of the parameter (UNFORMATTED, YAML, JSON).
//
// The function returns an error if the parameter creation fails.
funccreateStructuredParam(wio.Writer,projectID,parameterIDstring,formatparametermanagerpb.ParameterFormat)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 create parameter.
parent:=fmt.Sprintf("projects/%s/locations/global",projectID)
// Build the request to create a new parameter with the specified format.
req:=&parametermanagerpb.CreateParameterRequest{
Parent:parent,
ParameterId:parameterID,
Parameter:&parametermanagerpb.Parameter{
Format:format,
},
}
// Call the API to create the parameter.
parameter,err:=client.CreateParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to create parameter: %w",err)
}
fmt.Fprintf(w,"Created parameter %s with format %s\n",parameter.Name,parameter.Format.String())
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterFormat ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importjava.io.IOException;
/**
 * Example class to create a new parameter with a specific format using the Parameter Manager SDK
 * for GCP.
 */
publicclass CreateStructuredParam{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="your-project-id";
StringparameterId="your-parameter-id";
ParameterFormat format=ParameterFormat .YAML;
// Call the method to create a parameter with the specified format.
createStructuredParameter(projectId,parameterId,format);
}
// This is an example snippet for creating a new parameter with a specific format.
publicstaticParameter createStructuredParameter(
StringprojectId,StringparameterId,ParameterFormat format)throwsIOException{
// Initialize the client that will be used to send requests.
try(ParameterManagerClient client=ParameterManagerClient .create()){
StringlocationId="global";
// Build the parent name from the project.
LocationName location=LocationName .of(projectId,locationId);
// Build the parameter to create with the provided format.
Parameter parameter=Parameter .newBuilder().setFormat (format).build();
// Create the parameter.
Parameter createdParameter=
client.createParameter(location.toString (),parameter,parameterId);
System.out.printf(
"Created parameter %s with format %s\n",
createdParameter.getName (),createdParameter.getFormat ());
returncreatedParameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const {protos} = require('@google-cloud/parametermanager');
// const projectId = 'YOUR_PROJECT_ID';
// const parameterId = 'YOUR_PARAMETER_ID';
// const formatType = protos.google.cloud.parametermanager.v1.ParameterFormat.JSON;
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Instantiates a client
constclient=newParameterManagerClient ();
asyncfunctioncreateStructuredParam(){
constparent=client.locationPath (projectId,'global');
constrequest={
parent:parent,
parameterId:parameterId,
parameter:{
format:formatType,
},
};
const[parameter]=awaitclient.createParameter(request);
console.log(
`Created parameter ${parameter.name} with format ${parameter.format}`
);
returnparameter;
}
returnawaitcreateStructuredParam();

// Import necessary classes for creating a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\CreateParameterRequest;
use Google\Cloud\ParameterManager\V1\Parameter;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Creates a parameter with the specified format.
 *
 * @param string $projectId The Google Cloud Project ID (e.g. 'my-project')
 * @param string $parameterId The Parameter ID (e.g. 'my-param')
 * @param string $format The format type of the parameter (UNFORMATTED, YAML, JSON)
 */
function create_structured_param(string $projectId, string $parameterId, string $format): void
{
 // Create a client for the Parameter Manager service.
 $client = new ParameterManagerClient();
 // Build the resource name of the parent object.
 $parent = $client->locationName($projectId, 'global');
 // Create a new Parameter object and set the format.
 $parameter = (new Parameter())
 ->setFormat(ParameterFormat::value($format));
 // Prepare the request with the parent, parameter ID, and the parameter object.
 $request = (new CreateParameterRequest())
 ->setParent($parent)
 ->setParameterId($parameterId)
 ->setParameter($parameter);
 // Call the API and handle any network failures with print statements.
 $newParameter = $client->createParameter($request);
 printf('Created parameter %s with format %s' . PHP_EOL, $newParameter->getName(), ParameterFormat::name($newParameter->getFormat()));
}

defcreate_structured_param(
 project_id: str, parameter_id: str, format_type: parametermanager_v1 .ParameterFormat
) -> parametermanager_v1.Parameter:
"""
 Creates a parameter in the global location of the specified
 project with specified format using the Google Cloud Parameter Manager SDK.
 Args:
 project_id (str): The ID of the project where
 the parameter is to be created.
 parameter_id (str): The ID to assign to the new parameter.
 This ID must be unique within the project.
 format_type (parametermanager_v1.ParameterFormat): The format type of
 the parameter (UNFORMATTED, YAML, JSON).
 Returns:
 parametermanager_v1.Parameter: An object representing the
 newly created parameter.
 Example:
 create_structured_param(
 "my-project",
 "my-global-parameter",
 parametermanager_v1.ParameterFormat.JSON
 )
 """
 # 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")
 # Define the parameter creation request with the specified format.
 request = parametermanager_v1 .CreateParameterRequest (
 parent=parent,
 parameter_id=parameter_id,
 parameter=parametermanager_v1 .Parameter (format_=format_type),
 )
 # Create the parameter.
 response = client.create_parameter (request=request)
 # Print the newly created parameter name.
 print(f"Created parameter {response.name} with format {response.format_.name}")

require"google/cloud/parameter_manager"
##
# Create 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")
# @param format [Google::Cloud::ParameterManager::V1::ParameterFormat::]
# The type of parameter format (UNFORMATTED, YAML, JSON)
#
defcreate_structured_paramproject_id:,parameter_id:,format:
# 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"
parameter={
format:format
}
# Create the parameter.
param=client.create_parameterparent:parent,parameter_id:parameter_id,parameter:parameter
# Print the new parameter name.
puts"Created parameter #{param.name} with format #{param.format }"
end

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassCreateStructuredRegionalParameterSample
{
/// <summary>
/// This function creates a regional parameter of the specified format type using the Parameter Manager SDK for GCP.
/// </summary>
/// <param name="projectId">The ID of the project where the parameter is to be created.</param>
/// <param name="locationId">The region where the parameter is to be created.</param>
/// <param name="parameterId">The ID to assign to the new parameter. This ID must be unique within the project.</param>
/// <param name="format">The format type of the parameter (UNFORMATTED, YAML, JSON).</param>
/// <returns>The created Parameter object.</returns>
publicParameterCreateStructuredRegionalParameter(
stringprojectId,
stringlocationId,
stringparameterId,
ParameterFormat format)
{
// 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);
// Build the parameter with the specified format
Parameterparameter=newParameter
{
Format=format
};
// Call the API to create the parameter
ParametercreatedParameter=client.CreateParameter (parent,parameter,parameterId);
// Print the created parameter name
Console.WriteLine($"Created regional parameter {createdParameter.Name} with format {createdParameter.Format}");
// Return the created parameter
returncreatedParameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
"google.golang.org/api/option"
)
// createStructuredRegionalParam creates a parameter regional of the format type given as a method argument 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 region where the parameter is to be created.
// parameterID: The ID of the parameter to be created.
// format: The format type of the parameter (UNFORMATTED, YAML, JSON).
//
// The function returns an error if the parameter creation fails.
funccreateStructuredRegionalParam(wio.Writer,projectID,locationID,parameterIDstring,formatparametermanagerpb.ParameterFormat)error{
// Create a context and a Parameter Manager client.
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 create parameter.
parent:=fmt.Sprintf("projects/%s/locations/%s",projectID,locationID)
// Create a parameter with the given format.
req:=&parametermanagerpb.CreateParameterRequest{
Parent:parent,
ParameterId:parameterID,
Parameter:&parametermanagerpb.Parameter{
Format:format,
},
}
parameter,err:=client.CreateParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to create parameter: %w",err)
}
fmt.Fprintf(w,"Created regional parameter %s with format %s\n",parameter.Name,parameter.Format.String())
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterFormat ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterManagerSettings ;
importjava.io.IOException;
/**
 * Example class to create a new regional parameter with a specific format using the Parameter
 * Manager SDK for GCP.
 */
publicclass CreateStructuredRegionalParam{
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";
ParameterFormat format=ParameterFormat .JSON;
// Call the method to create a regional parameter with the specified format.
createStructuredRegionalParam(projectId,locationId,parameterId,format);
}
// This is an example snippet that creates a regional parameter with a specific format.
publicstaticParameter createStructuredRegionalParam(
StringprojectId,StringlocationId,StringparameterId,ParameterFormat format)
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);
// Build the regional parameter to create with the provided format.
Parameter parameter=Parameter .newBuilder().setFormat (format).build();
// Create the regional parameter.
Parameter createdParameter=
client.createParameter(location.toString (),parameter,parameterId);
System.out.printf(
"Created regional parameter %s with format %s\n",
createdParameter.getName (),createdParameter.getFormat ());
returncreatedParameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const {protos} = require('@google-cloud/parametermanager');
// const projectId = 'YOUR_PROJECT_ID';
// const locationId = 'YOUR_LOCATION_ID';
// const parameterId = 'YOUR_PARAMETER_ID';
// const formatType = protos.google.cloud.parametermanager.v1.ParameterFormat.JSON;
// 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);
asyncfunctioncreateStructuredRegionalParam(){
constparent=client.locationPath (projectId,locationId);
constrequest={
parent:parent,
parameterId:parameterId,
parameter:{
format:formatType,
},
};
const[parameter]=awaitclient.createParameter(request);
console.log(
`Created regional parameter ${parameter.name} with format ${parameter.format}`
);
returnparameter;
}
returnawaitcreateStructuredRegionalParam();

// Import necessary classes for creating a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\CreateParameterRequest;
use Google\Cloud\ParameterManager\V1\Parameter;
use Google\Cloud\ParameterManager\V1\ParameterFormat;
/**
 * Creates a regional parameter with the specified format.
 *
 * @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 $format The format type of the parameter (UNFORMATTED, YAML, JSON).
 */
function create_structured_regional_param(string $projectId, string $locationId, string $parameterId, string $format): 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 parent object.
 $parent = $client->locationName($projectId, $locationId);
 // Create a new Parameter object and set the format.
 $parameter = (new Parameter())
 ->setFormat(ParameterFormat::value($format));
 // Prepare the request with the parent, parameter ID, and the parameter object.
 $request = (new CreateParameterRequest())
 ->setParent($parent)
 ->setParameterId($parameterId)
 ->setParameter($parameter);
 // Call the API and handle any network failures with print statements.
 $newParameter = $client->createParameter($request);
 printf('Created regional parameter %s with format %s' . PHP_EOL, $newParameter->getName(), ParameterFormat::name($newParameter->getFormat()));
}

#!/usr/bin/env python
# Copyright 2025 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
"""
command line application and sample code
for creating a new formatted regional parameter.
"""
fromgoogle.cloudimport parametermanager_v1
defcreate_structured_regional_param(
 project_id: str,
 location_id: str,
 parameter_id: str,
 format_type: parametermanager_v1 .ParameterFormat ,
) -> parametermanager_v1.Parameter:
"""
 Creates a parameter in the specified region of the specified
 project using the Google Cloud Parameter Manager SDK. The parameter is
 created with the specified format type.
 Args:
 project_id (str): The ID of the project where
 the parameter is to be created.
 location_id (str): The ID of the region where
 the parameter is to be created.
 parameter_id (str): The ID to assign to the new parameter.
 This ID must be unique within the project.
 format_type (parametermanager_v1.ParameterFormat): The format type of
 the parameter (UNFORMATTED, YAML, JSON).
 Returns:
 parametermanager_v1.Parameter: An object representing the
 newly created parameter.
 Example:
 create_structured_regional_param(
 "my-project",
 "my-regional-parameter",
 "us-central1",
 parametermanager_v1.ParameterFormat.JSON
 )
 """
 # 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)
 # Define the parameter creation request with the specified format.
 request = parametermanager_v1 .CreateParameterRequest (
 parent=parent,
 parameter_id=parameter_id,
 parameter=parametermanager_v1 .Parameter (format_=format_type),
 )
 # Create the parameter.
 response = client.create_parameter (request=request)
 # Print the newly created parameter name.
 print(
 f"Created regional parameter: {response.name} "
 f"with format {response.format_.name}"
 )
 return response

require"google/cloud/parameter_manager"
##
# Create 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")
# @param format [Google::Cloud::ParameterManager::V1::ParameterFormat::]
# The type of parameter format (UNFORMATTED, YAML, JSON)
#
defcreate_structured_regional_paramproject_id:,location_id:,parameter_id:,format:
# 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
parameter={
format:format
}
# Create the parameter.
param=client.create_parameterparent:parent,parameter_id:parameter_id,parameter:parameter
# Print the new parameter name.
puts"Created regional parameter #{param.name} with format #{param.format }"
end

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassCreateParameterSample
{
/// <summary>
/// This function creates a parameter of the format type "unformatted" using the Parameter Manager SDK for GCP.
/// </summary>
/// <param name="projectId">The ID of the project where the parameter is to be created.</param>
/// <param name="parameterId">The ID to assign to the new parameter. This ID must be unique within the project.</param>
/// <returns>The created Parameter object.</returns>
publicParameterCreateParameter(
stringprojectId,
stringparameterId)
{
// Create the client.
ParameterManagerClient client=ParameterManagerClient .Create ();
// Build the parent resource name. 
LocationName parent=newLocationName (projectId,"global");
// Build the parameter.
Parameterparameter=newParameter();
// Call the API to create the parameter.
ParametercreatedParameter=client.CreateParameter (parent,parameter,parameterId);
// Print the created parameter name.
Console.WriteLine($"Created parameter: {createdParameter.Name}");
// Return the created parameter.
returncreatedParameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
)
// createParam creates a new parameter with the format type "unformatted" in Parameter Manager.
//
// 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 be created.
//
// The function returns an error if the parameter creation fails.
funccreateParam(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 create parameter.
parent:=fmt.Sprintf("projects/%s/locations/global",projectID)
// Build the request to create a new parameter
req:=&parametermanagerpb.CreateParameterRequest{
Parent:parent,
ParameterId:parameterID,
Parameter:&parametermanagerpb.Parameter{},
}
// Call the API to create the parameter.
parameter,err:=client.CreateParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to create parameter: %w",err)
}
fmt.Fprintf(w,"Created parameter: %s\n",parameter.Name)
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importjava.io.IOException;
/** This class demonstrates how to create a parameter using the Parameter Manager SDK for GCP. */
publicclass CreateParam{
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 create parameter.
createParam(projectId,parameterId);
}
// This is an example snippet for creating a new parameter.
publicstaticParameter createParam(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 parent name from the project.
LocationName location=LocationName .of(projectId,locationId);
// Build the parameter to create.
Parameter parameter=Parameter .newBuilder().build();
// Create the parameter.
Parameter createdParameter=
client.createParameter(location.toString (),parameter,parameterId);
System.out.printf("Created parameter: %s\n",createdParameter.getName ());
returncreatedParameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const parameterId = 'YOUR_PARAMETER_ID';
// Imports the Parameter Manager library
const{ParameterManagerClient}=require('@google-cloud/parametermanager');
// Instantiates a client
constclient=newParameterManagerClient ();
asyncfunctioncreateParam(){
constparent=client.locationPath (projectId,'global');
constrequest={
parent:parent,
parameterId:parameterId,
};
const[parameter]=awaitclient.createParameter(request);
console.log(`Created parameter: ${parameter.name}`);
returnparameter;
}
returnawaitcreateParam();

// Import necessary classes for creating a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\CreateParameterRequest;
use Google\Cloud\ParameterManager\V1\Parameter;
/**
 * Creates a parameter of type "unformatted" 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 create_param(string $projectId, string $parameterId): void
{
 // Create a client for the Parameter Manager service.
 $client = new ParameterManagerClient();
 // Build the resource name of the parent object.
 $parent = $client->locationName($projectId, 'global');
 // Create a new Parameter object.
 $parameter = new Parameter();
 // Prepare the request with the parent, parameter ID, and the parameter object.
 $request = (new CreateParameterRequest())
 ->setParent($parent)
 ->setParameterId($parameterId)
 ->setParameter($parameter);
 // Crete the parameter.
 $newParameter = $client->createParameter($request);
 // Print the new parameter name
 printf('Created parameter: %s' . PHP_EOL, $newParameter->getName());
}

defcreate_param(project_id: str, parameter_id: str) -> parametermanager_v1.Parameter:
"""
 Creates a parameter with default format (Unformatted)
 in 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 to be created.
 parameter_id (str): The ID to assign to the new parameter.
 This ID must be unique within the project.
 Returns:
 parametermanager_v1.Parameter: An object representing
 the newly created parameter.
 Example:
 create_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 parent project in the global location.
 parent = client.common_location_path(project_id, "global")
 # Define the parameter creation request.
 request = parametermanager_v1.CreateParameterRequest(
 parent=parent,
 parameter_id=parameter_id,
 )
 # Create the parameter.
 response = client.create_parameter(request=request)
 # Print the newly created parameter name.
 print(f"Created parameter: {response.name}")

require"google/cloud/parameter_manager"
##
# Create 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")
#
defcreate_paramproject_id:,parameter_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"
# Create the parameter.
param=client.create_parameterparent:parent,parameter_id:parameter_id
# Print the new parameter name.
puts"Created parameter #{param.name}"
end

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.ParameterManager.V1 ;
publicclassCreateRegionalParameterSample
{
/// <summary>
/// This function creates a regional parameter using the Parameter Manager SDK for GCP.
/// </summary>
/// <param name="projectId">The ID of the project where the parameter is to be created.</param>
/// <param name="locationId">The region where the parameter is to be created.</param>
/// <param name="parameterId">The ID to assign to the new parameter. This ID must be unique within the project.</param>
/// <returns>The created Parameter object.</returns>
publicParameterCreateRegionalParameter(
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 parent resource name for the regional locationId
LocationName parent=newLocationName (projectId,locationId);
// Build the parameter
Parameterparameter=newParameter();
// Call the API to create the parameter
ParametercreatedParameter=client.CreateParameter (parent,parameter,parameterId);
// Print the created parameter name
Console.WriteLine($"Created regional parameter: {createdParameter.Name}");
// Return the created parameter
returncreatedParameter;
}
}

import(
"context"
"fmt"
"io"
parametermanager"cloud.google.com/go/parametermanager/apiv1"
parametermanagerpb"cloud.google.com/go/parametermanager/apiv1/parametermanagerpb"
"google.golang.org/api/option"
)
// createRegionalParam creates a parameter regional of the format type "unformatted" 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 region where the parameter is to be created.
// parameterID: The ID of the parameter to be created.
//
// The function returns an error if the parameter creation fails.
funccreateRegionalParam(wio.Writer,projectID,locationID,parameterIDstring)error{
// Create a context and a Parameter Manager client.
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 create parameter.
parent:=fmt.Sprintf("projects/%s/locations/%s",projectID,locationID)
// Create a parameter with unformatted format.
req:=&parametermanagerpb.CreateParameterRequest{
Parent:parent,
ParameterId:parameterID,
Parameter:&parametermanagerpb.Parameter{
Format:parametermanagerpb.ParameterFormat_UNFORMATTED ,
},
}
parameter,err:=client.CreateParameter(ctx,req)
iferr!=nil{
returnfmt.Errorf("failed to create parameter: %w",err)
}
fmt.Fprintf(w,"Created regional parameter: %s\n",parameter.Name)
returnnil
}

importcom.google.cloud.parametermanager.v1.LocationName ;
importcom.google.cloud.parametermanager.v1.Parameter ;
importcom.google.cloud.parametermanager.v1.ParameterManagerClient ;
importcom.google.cloud.parametermanager.v1.ParameterManagerSettings ;
importjava.io.IOException;
/**
 * This class demonstrates how to create a regional parameter using the Parameter Manager SDK for
 * GCP.
 */
publicclass CreateRegionalParam{
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";
createRegionalParam(projectId,locationId,parameterId);
}
// This is an example snippet for creating a new regional parameter.
publicstaticParameter createRegionalParam(
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 parent name from the project.
LocationName location=LocationName .of(projectId,locationId);
// Build the regional parameter to create.
Parameter parameter=Parameter .newBuilder().build();
// Create the regional parameter.
Parameter createdParameter=
client.createParameter(location.toString (),parameter,parameterId);
System.out.printf("Created regional parameter: %s\n",createdParameter.getName ());
returncreatedParameter;
}
}
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const locationId = 'YOUR_LOCATION_ID';
// const parameterId = 'YOUR_PARAMETER_ID';
// 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);
asyncfunctioncreateRegionalParam(){
constparent=client.locationPath (projectId,locationId);
constrequest={
parent:parent,
parameterId:parameterId,
};
const[parameter]=awaitclient.createParameter(request);
console.log(`Created regional parameter: ${parameter.name}`);
returnparameter;
}
returnawaitcreateRegionalParam();

// Import necessary classes for creating a parameter.
use Google\Cloud\ParameterManager\V1\Client\ParameterManagerClient;
use Google\Cloud\ParameterManager\V1\CreateParameterRequest;
use Google\Cloud\ParameterManager\V1\Parameter;
/**
 * Creates a regional parameter of type "unformatted" 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 create_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 parent object.
 $parent = $client->locationName($projectId, $locationId);
 // Create a new Parameter object.
 $parameter = new Parameter();
 // Prepare the request with the parent, parameter ID, and the parameter object.
 $request = (new CreateParameterRequest())
 ->setParent($parent)
 ->setParameterId($parameterId)
 ->setParameter($parameter);
 // Crete the parameter.
 $newParameter = $client->createParameter($request);
 // Print the new parameter name
 printf('Created regional parameter: %s' . PHP_EOL, $newParameter->getName());
}

defcreate_regional_param(
 project_id: str, location_id: str, parameter_id: str
) -> parametermanager_v1.Parameter:
"""
 Creates a regional parameter with default format (Unformatted)
 in the specified location and
 project using the Google Cloud Parameter Manager SDK.
 Args:
 project_id (str): The ID of the project where
 the parameter is to be created.
 location_id (str): The region where the parameter is to be created.
 parameter_id (str): The ID to assign to the new parameter.
 This ID must be unique within the project.
 Returns:
 parametermanager_v1.Parameter: An object representing
 the newly created parameter.
 Example:
 create_regional_param(
 "my-project",
 "us-central1",
 "my-regional-parameter"
 )
 """
 # Import the Parameter Manager client library.
 fromgoogle.cloudimport parametermanager_v1
 api_endpoint = f"parametermanager.{location_id}.rep.googleapis.com"
 # Create the Parameter Manager client for the specified region.
 client = parametermanager_v1 .ParameterManagerClient (
 client_options={"api_endpoint": api_endpoint}
 )
 # Build the resource name of the parent project for the specified region.
 parent = client.common_location_path (project_id, location_id)
 # Define the parameter creation request.
 request = parametermanager_v1 .CreateParameterRequest (
 parent=parent,
 parameter_id=parameter_id,
 )
 # Create the parameter.
 response = client.create_parameter (request=request)
 # Print the newly created parameter name.
 print(f"Created regional parameter: {response.name}")

require"google/cloud/parameter_manager"
##
# Create 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")
#
defcreate_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.
parent=client.location_path project:project_id,location:location_id
# Create the parameter.
param=client.create_parameterparent:parent,parameter_id:parameter_id
# Print the new parameter name.
puts"Created regional parameter #{param.name}"
end