Create and manage instance configurations

voidListInstanceConfigs(
google::cloud::spanner_admin::InstanceAdminClientclient,
std::stringconst&project_id){
intcount=0;
autoproject=google::cloud::Project(project_id);
for(auto&config:client.ListInstanceConfigs(project.FullName())){
if(!config)throwstd::move(config).status();
++count;
std::cout << "Instance config [" << count << "]:\n"
 << config->DebugString();
}
if(count==0){
std::cout << "No instance configs found in project " << project_id << "\n";
}
}

usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.Spanner.Admin.Instance.V1 ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
publicclassListInstanceConfigsSample
{
publicIEnumerable<InstanceConfig>ListInstanceConfigs(stringprojectId)
{
varinstanceAdminClient=InstanceAdminClient .Create ();
varprojectName=ProjectName .FromProject (projectId);
varinstanceConfigs=instanceAdminClient.ListInstanceConfigs(projectName);
// We print the first 5 elements for demonstration purposes.
// You can print all configs in the sequence by removing the call to Take(5).
// The sequence will lazily fetch elements in pages as needed.
foreach(varinstanceConfigininstanceConfigs.Take(5))
{
Console.WriteLine($"Available leader options for instance config {instanceConfig.InstanceConfigName.InstanceConfigId}:");
foreach(varleaderininstanceConfig.LeaderOptions )
{
Console.WriteLine(leader);
}
Console.WriteLine($"Available optional replica for instance config {instanceConfig.InstanceConfigName.InstanceConfigId}:");
foreach(varoptionalReplicaininstanceConfig.OptionalReplicas )
{
Console.WriteLine($"Replica type - {optionalReplica.Type}, default leader location - {optionalReplica.DefaultLeaderLocation}, location - {optionalReplica.Location}");
}
}
returninstanceConfigs;
}
}

import(
"context"
"fmt"
"io"
instance"cloud.google.com/go/spanner/admin/instance/apiv1"
"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
"google.golang.org/api/iterator"
)
// istInstanceConfigs gets available leader options for all instances
funclistInstanceConfigs(wio.Writer,projectNamestring)error{
// projectName = `projects/<project>
ctx:=context.Background()
instanceAdmin,err:=instance.NewInstanceAdminClient(ctx)
iferr!=nil{
returnerr
}
deferinstanceAdmin.Close ()
request:=&instancepb.ListInstanceConfigsRequest{
Parent:projectName,
}
for{
iter:=instanceAdmin.ListInstanceConfigs(ctx,request)
for{
ic,err:=iter.Next()
iferr==iterator.Done{
break
}
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"Available leader options for instance config %s: %v\n",ic.Name,ic.LeaderOptions)
}
pageToken:=iter.PageInfo().Token
ifpageToken==""{
break
}else{
request.PageToken=pageToken
}
}
returnnil
}

importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient ;
importcom.google.spanner.admin.instance.v1.InstanceConfig ;
importcom.google.spanner.admin.instance.v1.ProjectName ;
publicclass ListInstanceConfigsSample{
staticvoidlistInstanceConfigs(){
// TODO(developer): Replace these variables before running the sample.
StringprojectId="my-project";
listInstanceConfigs(projectId);
}
staticvoidlistInstanceConfigs(StringprojectId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService();
InstanceAdminClient instanceAdminClient=spanner.createInstanceAdminClient ()){
finalProjectName projectName=ProjectName .of(projectId);
for(InstanceConfig instanceConfig:
instanceAdminClient.listInstanceConfigs(projectName).iterateAll()){
System.out.printf(
"Available leader options for instance config %s: %s%n",
instanceConfig.getName(),
instanceConfig.getLeaderOptionsList()
);
}
}
}
}

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const projectId = 'my-project-id';
// Imports the Google Cloud client library
const{Spanner}=require('@google-cloud/spanner');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
constinstanceAdminClient=spanner.getInstanceAdminClient ();
asyncfunctionlistInstanceConfigs(){
// Lists all available instance configurations in the project.
// See https://cloud.google.com/spanner/docs/instance-configurations#configuration for a list of all available
// configurations.
const[instanceConfigs]=awaitinstanceAdminClient.listInstanceConfigs({
parent:instanceAdminClient.projectPath (projectId),
});
console.log(`Available instance configs for project ${projectId}:`);
instanceConfigs.forEach(instanceConfig=>{
console.log(
`Available leader options for instance config ${
instanceConfig.name
} ('${instanceConfig.displayName}'): 
${instanceConfig.leaderOptions.join()}`,
);
});
}
listInstanceConfigs();

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\ListInstanceConfigsRequest;
/**
 * Lists the available instance configurations.
 * Example:
 * ```
 * list_instance_configs();
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 */
function list_instance_configs(string $projectId): void
{
 $instanceAdminClient = new InstanceAdminClient();
 $projectName = InstanceAdminClient::projectName($projectId);
 $request = new ListInstanceConfigsRequest();
 $request->setParent($projectName);
 $resp = $instanceAdminClient->listInstanceConfigs($request);
 foreach ($resp as $element) {
 printf(
 'Available leader options for instance config %s: %s' . PHP_EOL,
 $element->getDisplayName(),
 implode(',', iterator_to_array($element->getLeaderOptions()))
 );
 }
}

deflist_instance_config():
"""Lists the available instance configurations."""
 fromgoogle.cloud.spanner_admin_instance_v1.typesimport spanner_instance_admin
 spanner_client = spanner.Client()
 request = spanner_instance_admin.ListInstanceConfigsRequest(
 parent=spanner_client.project_name
 )
 for config in spanner_client.instance_admin_api.list_instance_configs(
 request=request
 ):
 print(
 "Available leader options for instance config {}: {}".format(
 config.name, config.leader_options
 )
 )

# project_id = "Your Google Cloud project ID"
require"google/cloud/spanner"
require"google/cloud/spanner/admin/instance"
instance_admin_client=Google::Cloud::Spanner::Admin::Instance.instance_admin
project_path=instance_admin_client.project_pathproject:project_id
configs=instance_admin_client.list_instance_configsparent:project_path
configs.eachdo|c|
puts"Available leader options for instance config #{c.name} : #{c.leader_options}"
end

voidGetInstanceConfig(google::cloud::spanner_admin::InstanceAdminClientclient,
std::stringconst&project_id,
std::stringconst&config_id){
autoproject=google::cloud::Project(project_id);
autoconfig=client.GetInstanceConfig(project.FullName()+
"/instanceConfigs/"+config_id);
if(!config)throwstd::move(config).status();
std::cout << "The instanceConfig " << config->name()
 << " exists and its metadata is:\n"
 << config->DebugString();
}

usingGoogle.Cloud.Spanner.Admin.Instance.V1 ;
usingSystem;
usingSystem.Threading.Tasks;
publicclassGetInstanceConfigAsyncSample
{
publicasyncTask<InstanceConfig>GetInstanceConfigAsync(stringprojectId,stringinstanceConfigId)
{
varinstanceAdminClient=awaitInstanceAdminClient .CreateAsync ();
varinstanceConfigName=InstanceConfigName .FromProjectInstanceConfig (projectId,instanceConfigId);
varinstanceConfig=awaitinstanceAdminClient.GetInstanceConfigAsync(instanceConfigName);
Console.WriteLine($"Available leader options for instance config {instanceConfigName.InstanceConfigId}:");
foreach(varleaderininstanceConfig.LeaderOptions )
{
Console.WriteLine(leader);
}
returninstanceConfig;
}
}

import(
"context"
"fmt"
"io"
instance"cloud.google.com/go/spanner/admin/instance/apiv1"
"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)
// getInstanceConfig gets available leader options
funcgetInstanceConfig(wio.Writer,instanceConfigNamestring)error{
// defaultLeader = `nam3`
ctx:=context.Background()
instanceAdmin,err:=instance.NewInstanceAdminClient(ctx)
iferr!=nil{
returnerr
}
deferinstanceAdmin.Close ()
ic,err:=instanceAdmin.GetInstanceConfig(ctx,&instancepb.GetInstanceConfigRequest{
Name:instanceConfigName,
})
iferr!=nil{
returnfmt.Errorf("could not get instance config %s: %w",instanceConfigName,err)
}
fmt.Fprintf(w,"Available leader options for instance config %s: %v",instanceConfigName,ic.LeaderOptions)
returnnil
}

importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient ;
importcom.google.spanner.admin.instance.v1.InstanceConfig ;
importcom.google.spanner.admin.instance.v1.InstanceConfigName ;
publicclass GetInstanceConfigSample{
staticvoidgetInstanceConfig(){
// TODO(developer): Replace these variables before running the sample.
finalStringprojectId="my-project";
finalStringinstanceConfigId="nam6";
getInstanceConfig(projectId,instanceConfigId);
}
staticvoidgetInstanceConfig(StringprojectId,StringinstanceConfigId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService();
InstanceAdminClient instanceAdminClient=spanner.createInstanceAdminClient ()){
finalInstanceConfigName instanceConfigName=InstanceConfigName .of(projectId,
instanceConfigId);
finalInstanceConfig instanceConfig=
instanceAdminClient.getInstanceConfig(instanceConfigName.toString ());
System.out.printf(
"Available leader options for instance config %s: %s%n",
instanceConfig.getName (),
instanceConfig.getLeaderOptionsList ()
);
}
}
}

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const projectId = 'my-project-id';
// Imports the Google Cloud client library
const{Spanner}=require('@google-cloud/spanner');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
constinstanceAdminClient=spanner.getInstanceAdminClient ();
asyncfunctiongetInstanceConfig(){
// Get the instance config for the multi-region North America 6 (NAM6).
// See https://cloud.google.com/spanner/docs/instance-configurations#configuration for a list of all available
// configurations.
const[instanceConfig]=awaitinstanceAdminClient.getInstanceConfig({
name:instanceAdminClient.instanceConfigPath (projectId,'nam6'),
});
console.log(
`Available leader options for instance config ${instanceConfig.name} ('${
instanceConfig.displayName
}'): 
${instanceConfig.leaderOptions.join()}`,
);
}
getInstanceConfig();

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\GetInstanceConfigRequest;
/**
 * Gets the leader options for the instance configuration.
 *
 * @param string $projectId The Google Cloud Project ID.
 * @param string $instanceConfig The name of the instance configuration.
 */
function get_instance_config(string $projectId, string $instanceConfig): void
{
 $instanceAdminClient = new InstanceAdminClient();
 $instanceConfigName = InstanceAdminClient::instanceConfigName($projectId, $instanceConfig);
 $request = (new GetInstanceConfigRequest())
 ->setName($instanceConfigName);
 $configInfo = $instanceAdminClient->getInstanceConfig($request);
 printf('Available leader options for instance config %s: %s' . PHP_EOL,
 $instanceConfig,
 implode(',', array_keys(iterator_to_array($configInfo->getLeaderOptions())))
 );
}

defget_instance_config(instance_config):
"""Gets the leader options for the instance configuration."""
 spanner_client = spanner.Client()
 config_name = "{}/instanceConfigs/{}".format(
 spanner_client.project_name, instance_config
 )
 config = spanner_client.instance_admin_api.get_instance_config(name=config_name)
 print(
 "Available leader options for instance config {}: {}".format(
 instance_config, config.leader_options
 )
 )

# project_id = "Your Google Cloud project ID"
# instance_config_id = "Spanner instance config ID"
require"google/cloud/spanner"
require"google/cloud/spanner/admin/instance"
instance_admin_client=Google::Cloud::Spanner::Admin::Instance.instance_admin
instance_config_path=instance_admin_client.instance_config_path\
project:project_id,instance_config:instance_config_id
config=instance_admin_client.get_instance_configname:instance_config_path
puts"Available leader options for instance config #{config.name} : #{config.leader_options}"

voidCreateInstanceConfig(
google::cloud::spanner_admin::InstanceAdminClientclient,
std::stringconst&project_id,std::stringconst&user_config_id,
std::stringconst&base_config_id){
autoproject=google::cloud::Project(project_id);
autobase_config=client.GetInstanceConfig(
project.FullName()+"/instanceConfigs/"+base_config_id);
if(!base_config)throwstd::move(base_config).status();
if(base_config->optional_replicas().empty()){
throwstd::runtime_error("No optional replicas in base config");
}
google::spanner::admin::instance::v1::CreateInstanceConfigRequestrequest;
request.set_parent(project.FullName());
request.set_instance_config_id(user_config_id);
auto*request_config=request.mutable_instance_config();
request_config->set_name(project.FullName()+"/instanceConfigs/"+
user_config_id);
request_config->set_display_name("My instance config");
// The user-managed instance config must contain all the replicas
// of the base config plus at least one of the optional replicas.
*request_config->mutable_replicas()=base_config->replicas();
for(autoconst&replica:base_config->optional_replicas()){
*request_config->add_replicas()=replica;
}
request_config->set_base_config(base_config->name());
*request_config->mutable_leader_options()=base_config->leader_options();
request.set_validate_only(false);
autouser_config=client.CreateInstanceConfig(request).get();
if(!user_config)throwstd::move(user_config).status();
std::cout << "Created instance config [" << user_config_id << "]:\n"
 << user_config->DebugString();
}

usingSystem;
usingSystem.Threading.Tasks;
usingGoogle.Api.Gax.ResourceNames ;
usingGoogle.Cloud.Spanner.Admin.Instance.V1 ;
publicclassCreateInstanceConfigAsyncSample
{
publicasyncTask<InstanceConfig>CreateInstanceConfigAsync(stringprojectId,stringbaseInstanceConfigId,stringcustomInstanceConfigId)
{
InstanceAdminClient instanceAdminClient=awaitInstanceAdminClient .CreateAsync ();
varinstanceConfigName=newInstanceConfigName (projectId,baseInstanceConfigId);
varinstanceConfig=awaitinstanceAdminClient.GetInstanceConfigAsync (instanceConfigName);
varcustomInstanceConfigName=newInstanceConfigName (projectId,customInstanceConfigId);
//Create a custom config.
InstanceConfig userInstanceConfig=newInstanceConfig
{
DisplayName="C# test custom instance config",
ConfigType=InstanceConfig .Types.Type .UserManaged ,
BaseConfigAsInstanceConfigName=instanceConfigName,
InstanceConfigName=customInstanceConfigName,
//The replicas for the custom instance configuration must include all the replicas of the base
//configuration, in addition to at least one from the list of optional replicas of the base
//configuration.
Replicas={instanceConfig.Replicas },
OptionalReplicas=
{
newReplicaInfo
{
Type=ReplicaInfo .Types .ReplicaType .ReadOnly ,
Location="us-east1",
DefaultLeaderLocation=false
},
//The replicas for the custom instance configuration must include all the replicas of the base
//configuration, in addition to at least one from the list of optional replicas of the base
//configuration.
instanceConfig.OptionalReplicas
}
};
varoperationResult=awaitinstanceAdminClient.CreateInstanceConfigAsync (newCreateInstanceConfigRequest
{
ParentAsProjectName=ProjectName .FromProject (projectId),
InstanceConfig=userInstanceConfig,
InstanceConfigId=customInstanceConfigId
});
varpollResult=awaitoperationResult.PollUntilCompletedAsync();
if(pollResult.IsFaulted)
{
throwpollResult.Exception;
}
Console.WriteLine($"Instance config created successfully");
Console.WriteLine($"Available custom replication options for instance config {pollResult.Result.Name}\r\n{pollResult.Result.OptionalReplicas}");
returnpollResult.Result;
}
}

import(
"context"
"fmt"
"io"
"time"
instance"cloud.google.com/go/spanner/admin/instance/apiv1"
"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)
// createInstanceConfig creates a custom spanner instance config
funccreateInstanceConfig(wio.Writer,projectID,userConfigID,baseConfigIDstring)error{
// projectID := "my-project-id"
// userConfigID := "custom-config", custom config names must start with the prefix "custom-".
// baseConfigID := "my-base-config"
// Add timeout to context.
ctx,cancel:=context.WithTimeout(context.Background(),10*time.Minute)
defercancel()
adminClient,err:=instance.NewInstanceAdminClient(ctx)
iferr!=nil{
returnerr
}
deferadmiadminClient.ClosebaseConfig,err:=adminClient.GetInstanceConfig(ctx,&instancepb.GetInstanceConfigRequest{
Name:fmt.Sprintf("projects/%s/instanceConfigs/%s",projectID,baseConfigID),
})
iferr!=nil{
returnfmt.Errorf("createInstanceConfig.GetInstanceConfig: %w",err)
}
ifbaseConfig.OptionalReplicas==nil||len(baseConfig.OptionalReplicas)==0{
returnfmt.Errorf("CreateInstanceConfig expects base config with at least from the list of optional replicas")
}
op,err:=adminClient.CreateInstanceConfig(ctx,&instancepb.CreateInstanceConfigRequest{
Parent:fmt.Sprintf("projects/%s",projectID),
// Custom config names must start with the prefix "custom-".
InstanceConfigId:userConfigID,
InstanceConfig:&instancepb.InstanceConfig{
Name:fmt.Sprintf("projects/%s/instanceConfigs/%s",projectID,userConfigID),
DisplayName:"custom-golang-samples",
ConfigType:instanceinstancepb.InstanceConfig_USER_MANAGEDThereplicasforthecustominstanceconfigurationmustincludeallthereplicasofthebase
// configuration, in addition to at least one from the list of optional replicas of the base
// configuration.
Replicas:append(baseConfig.Replicas,baseConfig.OptionalReplicas...),
BaseConfig:baseConfig.Name,
Labels:map[string]string{"go_cloud_spanner_samples":"true"},
},
})
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"Waiting for create operation on projects/%s/instanceConfigs/%s to complete...\n",projectID,userConfigID)
// Wait for the instance configuration creation to finish.
i,err:=op.Wait(ctx)
iferr!=nil{
returnfmt.Errorf("Waiting for instance config creation to finish failed: %w",err)
}
// The instance configuration may not be ready to serve yet.
ifi.State!=instanceinstancepb.InstanceConfig_READY .Fprintf(w,"InstanceConfig state is not READY yet. Got state %v\n",i.State)
}
fmt.Fprintf(w,"Created instance configuration [%s]\n",userConfigID)
returnnil
}

importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient ;
importcom.google.spanner.admin.instance.v1.CreateInstanceConfigRequest ;
importcom.google.spanner.admin.instance.v1.InstanceConfig ;
importcom.google.spanner.admin.instance.v1.InstanceConfigName ;
importcom.google.spanner.admin.instance.v1.ProjectName ;
importcom.google.spanner.admin.instance.v1.ReplicaInfo ;
importjava.util.List;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
importjava.util.stream.Collectors;
importjava.util.stream.Stream;
class CreateInstanceConfigSample{
staticvoidcreateInstanceConfig(){
// TODO(developer): Replace these variables before running the sample.
StringprojectId="my-project";
StringbaseInstanceConfigId="nam11";
StringinstanceConfigId="custom-instance-config4";
createInstanceConfig(projectId,baseInstanceConfigId,instanceConfigId);
}
staticvoidcreateInstanceConfig(
StringprojectId,StringbaseInstanceConfigId,StringinstanceConfigId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService();
InstanceAdminClient instanceAdminClient=spanner.createInstanceAdminClient ()){
finalInstanceConfigName baseInstanceConfigName=InstanceConfigName .of(projectId,
baseInstanceConfigId);
finalInstanceConfig baseConfig=
instanceAdminClient.getInstanceConfig(baseInstanceConfigName.toString ());
finalInstanceConfigName instanceConfigName=InstanceConfigName .of(projectId,
instanceConfigId);
/**
 * The replicas for the custom instance configuration must include all the replicas of the
 * base configuration, in addition to at least one from the list of optional replicas of the
 * base configuration.
 */
finalList<ReplicaInfo>replicas=
Stream.concat(baseConfig.getReplicasList ().stream(),
baseConfig.getOptionalReplicasList ().stream().limit (1)).collect(Collectors.toList());
finalInstanceConfig instanceConfig=
InstanceConfig .newBuilder().setName(instanceConfigName.toString ())
.setBaseConfig(baseInstanceConfigName.toString ())
.setDisplayName("Instance Configuration").addAllReplicas (replicas).build();
finalCreateInstanceConfigRequest createInstanceConfigRequest=
CreateInstanceConfigRequest .newBuilder().setParent(ProjectName .of(projectId).toString())
.setInstanceConfigId(instanceConfigId).setInstanceConfig(instanceConfig).build();
try{
System.out.printf("Waiting for create operation for %s to complete...\n",
instanceConfigName);
InstanceConfig instanceConfigResult=
instanceAdminClient.createInstanceConfigAsync(
createInstanceConfigRequest).get(5,TimeUnit.MINUTES);
System.out.printf("Created instance configuration %s\n",instanceConfigResult.getName ());
}catch(ExecutionException|TimeoutExceptione){
System.out.printf(
"Error: Creating instance configuration %s failed with error message %s\n",
instanceConfig.getName (),e.getMessage());
}catch(InterruptedExceptione){
System.out.println(
"Error: Waiting for createInstanceConfig operation to finish was interrupted");
}
}
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const instanceConfigId = 'custom-my-instance-config-id'
// const baseInstanceConfigId = 'my-base-instance-config-id';
// const projectId = 'my-project-id';
// Imports the Google Cloud client library
const{Spanner}=require('@google-cloud/spanner');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
constinstanceAdminClient=spanner.getInstanceAdminClient ();
// Creates a new instance config
asyncfunctioncreateInstanceConfig(){
const[baseInstanceConfig]=awaitinstanceAdminClient.getInstanceConfig({
name:instanceAdminClient.instanceConfigPath (
projectId,
baseInstanceConfigId,
),
});
try{
console.log(
`Creating instance config ${instanceAdminClient.instanceConfigPath (
projectId,
instanceConfigId,
)}.`,
);
const[operation]=awaitinstanceAdminClient.createInstanceConfig({
instanceConfigId:instanceConfigId,
parent:instanceAdminClient.projectPath (projectId),
instanceConfig:{
name:instanceAdminClient.instanceConfigPath (
projectId,
instanceConfigId,
),
baseConfig:instanceAdminClient.instanceConfigPath (
projectId,
baseInstanceConfigId,
),
displayName:instanceConfigId,
replicas:baseInstanceConfig.replicas.concat(
baseInstanceConfig.optionalReplicas[0],
),
},
});
console.log(
`Waiting for create operation for ${instanceConfigId} to complete...`,
);
awaitoperation .promise();
console.log(`Created instance config ${instanceConfigId}.`);
}catch(err){
console.error(
'ERROR: Creating instance config ',
instanceConfigId,
' failed with error message ',
err,
);
}
}
createInstanceConfig();

use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceConfigRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\GetInstanceConfigRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\InstanceConfig;
use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\ReplicaInfo;
/**
 * Creates a customer managed instance configuration.
 * Example:
 * ```
 * create_instance_config($instanceConfigId);
 * ```
 *
 * @param string $projectId The Google Cloud Project ID.
 * @param string $instanceConfigId The customer managed instance configuration id. The id must start with 'custom-'.
 * @param string $baseConfigId Base configuration ID to be used for creation, e.g. nam11.
 */
function create_instance_config(string $projectId, string $instanceConfigId, string $baseConfigId): void
{
 $instanceAdminClient = new InstanceAdminClient();
 $projectName = InstanceAdminClient::projectName($projectId);
 $instanceConfigName = $instanceAdminClient->instanceConfigName(
 $projectId,
 $instanceConfigId
 );
 // Get a Google Managed instance configuration to use as the base for our custom instance configuration.
 $baseInstanceConfig = $instanceAdminClient->instanceConfigName(
 $projectId,
 $baseConfigId
 );
 $request = new GetInstanceConfigRequest(['name' => $baseInstanceConfig]);
 $baseInstanceConfigInfo = $instanceAdminClient->getInstanceConfig($request);
 $instanceConfig = (new InstanceConfig())
 ->setBaseConfig($baseInstanceConfig)
 ->setName($instanceConfigName)
 ->setDisplayName('My custom instance configuration')
 ->setLabels(['php-cloud-spanner-samples' => true])
 ->setReplicas(array_merge(
 iterator_to_array($baseInstanceConfigInfo->getReplicas()),
 [new ReplicaInfo([
 'location' => 'us-east1',
 'type' => ReplicaInfo\ReplicaType::READ_ONLY,
 'default_leader_location' => false
 ])]
 ));
 $request = new CreateInstanceConfigRequest([
 'parent' => $projectName,
 'instance_config' => $instanceConfig,
 'instance_config_id' => $instanceConfigId
 ]);
 $operation = $instanceAdminClient->createInstanceConfig($request);
 print('Waiting for operation to complete...' . PHP_EOL);
 $operation->pollUntilComplete();
 printf('Created instance configuration %s' . PHP_EOL, $instanceConfigId);
}

defcreate_instance_config(user_config_name, base_config_id):
"""Creates the new user-managed instance configuration using base instance config."""
 # user_config_name = `custom-nam11`
 # base_config_id = `projects/<project>/instanceConfigs/nam11`
 spanner_client = spanner.Client()
 base_config = spanner_client.instance_admin_api.get_instance_config(
 name=base_config_id
 )
 # The replicas for the custom instance configuration must include all the replicas of the base
 # configuration, in addition to at least one from the list of optional replicas of the base
 # configuration.
 replicas = []
 for replica in base_config.replicas:
 replicas.append(replica)
 replicas.append(base_config.optional_replicas[0])
 operation = spanner_client.instance_admin_api.create_instance_config(
 parent=spanner_client.project_name,
 instance_config_id=user_config_name,
 instance_config=spanner_instance_admin.InstanceConfig(
 name="{}/instanceConfigs/{}".format(
 spanner_client.project_name, user_config_name
 ),
 display_name="custom-python-samples",
 config_type=spanner_instance_admin.InstanceConfig.Type.USER_MANAGED,
 replicas=replicas,
 base_config=base_config.name,
 labels={"python_cloud_spanner_samples": "true"},
 ),
 )
 print("Waiting for operation to complete...")
 operation.result(OPERATION_TIMEOUT_SECONDS)
 print("Created instance configuration {}".format(user_config_name))

require"google/cloud/spanner"
require"google/cloud/spanner/admin/instance"
defspanner_create_instance_configproject_id:,user_config_name:,base_config_id:
# project_id = "Your Google Cloud project ID"
# user_config_name = "Your custom instance configuration name, The name must start with 'custom-'"
# base_config_id = "Base configuration ID to be used for creation, e.g projects/<project>/instanceConfigs/nam11"
instance_admin_client=Google::Cloud::Spanner::Admin::Instance.instance_admin
project_path=instance_admin_client.project_pathproject:project_id
base_instance_config=instance_admin_client.get_instance_configname:base_config_id
# The replicas for the custom instance configuration must include all the replicas of the base
# configuration, in addition to at least one from the list of optional replicas of the base
# configuration.
custom_replicas=[]
base_instance_config.replicas.eachdo|replica|
custom_replicas << replica
end
custom_replicas << base_instance_config.optional_replicas[0]
custom_instance_config_id=instance_admin_client.instance_config_path\
project:project_id,instance_config:user_config_name
custom_instance_config={
name:custom_instance_config_id,
display_name:"custom-ruby-samples",
config_type::USER_MANAGED,
replicas:custom_replicas,
base_config:base_config_id,
labels:{ruby_cloud_spanner_samples:"true"}
}
request={
parent:project_path,
# Custom config names must start with the prefix "custom-".
instance_config_id:user_config_name,
instance_config:custom_instance_config
}
job=instance_admin_client.create_instance_configrequest
puts"Waiting for create instance config operation to complete"
job.wait_until_done!
ifjob.error?
putsjob.error
else
puts"Created instance configuration #{user_config_name}"
end
end

voidUpdateInstanceConfig(
google::cloud::spanner_admin::InstanceAdminClientclient,
std::stringconst&project_id,std::stringconst&config_id){
autoproject=google::cloud::Project(project_id);
autoconfig=client.GetInstanceConfig(project.FullName()+
"/instanceConfigs/"+config_id);
if(!config)throwstd::move(config).status();
google::spanner::admin::instance::v1::UpdateInstanceConfigRequestrequest;
auto*request_config=request.mutable_instance_config();
request_config->set_name(config->name());
request_config->mutable_labels()->insert({"key","value"});
request.mutable_update_mask()->add_paths("labels");
request_config->set_etag(config->etag());
request.set_validate_only(false);
autoupdated_config=client.UpdateInstanceConfig(request).get();
if(!updated_config)throwstd::move(updated_config).status();
std::cout << "Updated instance config [" << config_id << "]:\n"
 << updated_config->DebugString();
}

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Threading.Tasks;
usingGoogle.Cloud.Spanner.Admin.Instance.V1 ;
usingGoogle.LongRunning ;
usingGoogle.Protobuf.WellKnownTypes ;
publicclassUpdateInstanceConfigAsyncSample
{
publicasyncTask<Operation<InstanceConfig,UpdateInstanceConfigMetadata>>UpdateInstanceConfigAsync(stringprojectId,stringinstanceConfigId)
{
InstanceAdminClient instanceAdminClient=awaitInstanceAdminClient .CreateAsync ();
varinstanceConfigName=newInstanceConfigName (projectId,instanceConfigId);
varinstanceConfig=newInstanceConfig ();
instanceConfig.InstanceConfigName =instanceConfigName;
instanceConfig.DisplayName="New display name";
instanceConfig.Labels.Add(newDictionary<string,string>
{
{"cloud_spanner_samples","true"},
{"updated","true"},
});
varupdateInstanceConfigOperation=awaitinstanceAdminClient.UpdateInstanceConfigAsync (newUpdateInstanceConfigRequest
{
InstanceConfig=instanceConfig,
UpdateMask=newFieldMask
{
Paths={"display_name","labels"}
}
});
updateInstanceConfigOperation=awaitupdateInstanceConfigOperation.PollUntilCompletedAsync();
if(updateInstanceConfigOperation.IsFaulted)
{
throwupdateInstanceConfigOperation.Exception;
}
Console.WriteLine("Update Instance Config operation completed successfully.");
returnupdateInstanceConfigOperation;
}
}

import(
"context"
"fmt"
"io"
"time"
instance"cloud.google.com/go/spanner/admin/instance/apiv1"
"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
"google.golang.org/genproto/protobuf/field_mask"
)
// updateInstanceConfig updates the custom spanner instance config
funcupdateInstanceConfig(wio.Writer,projectID,userConfigIDstring)error{
// projectID := "my-project-id"
// userConfigID := "custom-config", custom config names must start with the prefix "custom-".
// Add timeout to context.
ctx,cancel:=context.WithTimeout(context.Background(),10*time.Minute)
defercancel()
adminClient,err:=instance.NewInstanceAdminClient(ctx)
iferr!=nil{
returnerr
}
deferadmiadminClient.Closeconfig,err:=adminClient.GetInstanceConfig(ctx,&instancepb.GetInstanceConfigRequest{
Name:fmt.Sprintf("projects/%s/instanceConfigs/%s",projectID,userConfigID),
})
iferr!=nil{
returnfmt.Errorf("updateInstanceConfig.GetInstanceConfig: %w",err)
}
config.DisplayName="updated custom instance config"
config.Labels["updated"]="true"
op,err:=adminClient.UpdateInstanceConfig(ctx,&instancepb.UpdateInstanceConfigRequest{
InstanceConfig:config,
UpdateMask:&field_mask.FieldMask{
Paths:[]string{"display_name","labels"},
},
ValidateOnly:false,
})
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"Waiting for update operation on %s to complete...\n",userConfigID)
// Wait for the instance configuration creation to finish.
i,err:=op.Wait(ctx)
iferr!=nil{
returnfmt.Errorf("Waiting for instance config creation to finish failed: %w",err)
}
// The instance configuration may not be ready to serve yet.
ifi.State!=instinstancepb.InstanceConfig_READY fmt.Fprintf(w,"InstanceConfig state is not READY yet. Got state %v\n",i.State)
}
fmt.Fprintf(w,"Updated instance configuration [%s]\n",config.Name)
returnnil
}

importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient ;
importcom.google.common.collect.ImmutableList;
importcom.google.protobuf.FieldMask ;
importcom.google.spanner.admin.instance.v1.InstanceConfig ;
importcom.google.spanner.admin.instance.v1.InstanceConfigName ;
importcom.google.spanner.admin.instance.v1.UpdateInstanceConfigRequest ;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.TimeUnit;
importjava.util.concurrent.TimeoutException;
class UpdateInstanceConfigSample{
staticvoidupdateInstanceConfig(){
// TODO(developer): Replace these variables before running the sample.
StringprojectId="my-project";
StringinstanceConfigId="custom-instance-config";
updateInstanceConfig(projectId,instanceConfigId);
}
staticvoidupdateInstanceConfig(StringprojectId,StringinstanceConfigId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService();
InstanceAdminClient instanceAdminClient=spanner.createInstanceAdminClient ()){
finalInstanceConfigName instanceConfigName=
InstanceConfigName .of(projectId,instanceConfigId);
finalInstanceConfig instanceConfig=
InstanceConfig .newBuilder()
.setName(instanceConfigName.toString ())
.setDisplayName("updated custom instance config")
.putLabels("updated","true").build();
/**
 * The field mask must always be specified; this prevents any future
 * fields in [InstanceConfig][google.spanner.admin.instance.v1.InstanceConfig]
 * from being erased accidentally by clients that do not know about them.
 */
finalUpdateInstanceConfigRequest updateInstanceConfigRequest=
UpdateInstanceConfigRequest .newBuilder()
.setInstanceConfig(instanceConfig)
.setUpdateMask (
FieldMask .newBuilder().addAllPaths (ImmutableList.of("display_name","labels"))
.build()).build();
try{
System.out.printf("Waiting for update operation on %s to complete...\n",
instanceConfigName);
InstanceConfig instanceConfigResult=
instanceAdminClient.updateInstanceConfigAsync(
updateInstanceConfigRequest).get(5,TimeUnit.MINUTES);
System.out.printf(
"Updated instance configuration %s with new display name %s\n",
instanceConfigResult.getName (),instanceConfig.getDisplayName ());
}catch(ExecutionException|TimeoutExceptione){
System.out.printf(
"Error: Updating instance config %s failed with error message %s\n",
instanceConfig.getName (),e.getMessage());
e.printStackTrace();
}catch(InterruptedExceptione){
System.out.println(
"Error: Waiting for updateInstanceConfig operation to finish was interrupted");
}
}
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const instanceConfigId = 'custom-my-instance-config-id';
// const projectId = 'my-project-id';
// Imports the Google Cloud client library
const{Spanner,protos}=require('@google-cloud/spanner');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
constinstanceAdminClient=spanner.getInstanceAdminClient ();
asyncfunctionupdateInstanceConfig(){
// Updates an instance config
try{
console.log(
`Updating instance config ${instanceAdminClient.instanceConfigPath (
projectId,
instanceConfigId,
)}.`,
);
const[operation]=awaitinstanceAdminClient.updateInstanceConfig({
instanceConfig:{
name:instanceAdminClient.instanceConfigPath (
projectId,
instanceConfigId,
),
displayName:'updated custom instance config',
labels:{
updated:'true',
created:Math.round(Date.now()/1000).toString(),// current time
},
},
// Field mask specifying fields that should get updated in InstanceConfig
// Only display_name and labels can be updated
updateMask:(protos.google.protobuf.FieldMask ={
paths:['display_name','labels'],
}),
});
console.log(
`Waiting for update operation for ${instanceConfigId} to complete...`,
);
awaitoperation .promise();
console.log(`Updated instance config ${instanceConfigId}.`);
}catch(err){
console.error(
'ERROR: Updating instance config ',
instanceConfigId,
' failed with error message ',
err,
);
}
}
updateInstanceConfig();

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\InstanceConfig;
use Google\Cloud\Spanner\Admin\Instance\V1\UpdateInstanceConfigRequest;
use Google\Protobuf\FieldMask;
/**
 * Updates a customer managed instance configuration.
 * Example:
 * ```
 * update_instance_config($instanceConfigId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceConfigId The customer managed instance configuration id. The id must start with 'custom-'.
 */
function update_instance_config(string $projectId, string $instanceConfigId): void
{
 $instanceAdminClient = new InstanceAdminClient();
 $instanceConfigPath = $instanceAdminClient->instanceConfigName($projectId, $instanceConfigId);
 $displayName = 'New display name';
 $instanceConfig = new InstanceConfig();
 $instanceConfig->setName($instanceConfigPath);
 $instanceConfig->setDisplayName($displayName);
 $instanceConfig->setLabels(['cloud_spanner_samples' => true, 'updated' => true]);
 $fieldMask = new FieldMask();
 $fieldMask->setPaths(['display_name', 'labels']);
 $updateInstanceConfigRequest = (new UpdateInstanceConfigRequest())
 ->setInstanceConfig($instanceConfig)
 ->setUpdateMask($fieldMask);
 $operation = $instanceAdminClient->updateInstanceConfig($updateInstanceConfigRequest);
 print('Waiting for operation to complete...' . PHP_EOL);
 $operation->pollUntilComplete();
 printf('Updated instance configuration %s' . PHP_EOL, $instanceConfigId);
}

defupdate_instance_config(user_config_name):
"""Updates the user-managed instance configuration."""
 # user_config_name = `custom-nam11`
 spanner_client = spanner.Client()
 config = spanner_client.instance_admin_api.get_instance_config(
 name="{}/instanceConfigs/{}".format(
 spanner_client.project_name, user_config_name
 )
 )
 config.display_name = "updated custom instance config"
 config.labels["updated"] = "true"
 operation = spanner_client.instance_admin_api.update_instance_config(
 instance_config=config,
 update_mask=field_mask_pb2.FieldMask(paths=["display_name", "labels"]),
 )
 print("Waiting for operation to complete...")
 operation.result(OPERATION_TIMEOUT_SECONDS)
 print("Updated instance configuration {}".format(user_config_name))

require"google/cloud/spanner"
require"google/cloud/spanner/admin/instance"
defspanner_update_instance_configuser_config_id:
# user_config_id = "The customer managed instance configuration ID, e.g projects/<project>/instanceConfigs/custom-nam11"
instance_admin_client=Google::Cloud::Spanner::Admin::Instance.instance_admin
config=instance_admin_client.get_instance_configname:user_config_id
config.display_name="updated custom instance config"
config.labels["updated"]="true"
request={
instance_config:config,
update_mask:{paths:["display_name","labels"]},
validate_only:false
}
job=instance_admin_client.update_instance_configrequest
puts"Waiting for update instance config operation to complete"
job.wait_until_done!
ifjob.error?
putsjob.error
else
puts"Updated instance configuration #{config.name}"
end
end

voidDeleteInstanceConfig(
google::cloud::spanner_admin::InstanceAdminClientclient,
std::stringconst&project_id,std::stringconst&config_id){
autoproject=google::cloud::Project(project_id);
autoconfig_name=project.FullName()+"/instanceConfigs/"+config_id;
autostatus=client.DeleteInstanceConfig(config_name);
if(!status.ok())throwstd::move(status);
std::cout << "Instance config " << config_name << " successfully deleted\n";
}

usingSystem;
usingSystem.Threading.Tasks;
usingGoogle.Cloud.Spanner.Admin.Instance.V1 ;
usingGrpc.Core ;
publicclassDeleteInstanceConfigAsyncSample
{
publicasyncTaskDeleteInstanceConfigAsync(stringprojectId,stringinstanceConfigId)
{
InstanceAdminClient instanceAdminClient=awaitInstanceAdminClient .CreateAsync ();
varinstanceConfigName=newInstanceConfigName (projectId,instanceConfigId);
try
{
awaitinstanceAdminClient.DeleteInstanceConfigAsync (newDeleteInstanceConfigRequest
{
InstanceConfigName=instanceConfigName
});
}
catch(RpcException ex)when(ex.Status .StatusCode ==StatusCode .NotFound )
{
Console.WriteLine("The specified instance config does not exist. It cannot be deleted.");
return;
}
Console.WriteLine("Delete Instance Config operation is completed");
}
}

import(
"context"
"fmt"
"io"
instance"cloud.google.com/go/spanner/admin/instance/apiv1"
"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)
// deleteInstanceConfig deletes the custom spanner instance config
funcdeleteInstanceConfig(wio.Writer,projectID,userConfigIDstring)error{
// projectID := "my-project-id"
// userConfigID := "custom-config", custom config names must start with the prefix "custom-".
ctx:=context.Background()
adminClient,err:=instance.NewInstanceAdminClient(ctx)
iferr!=nil{
returnerr
}
deferadmiadminClient.Closeerr=adminClient.DeleteInstanceConfig(ctx,&instancepb.DeleteInstanceConfigRequest{
Name:fmt.Sprintf("projects/%s/instanceConfigs/%s",projectID,userConfigID),
})
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"Deleted instance configuration [%s]\n",userConfigID)
returnnil
}

importcom.google.cloud.spanner.Spanner ;
importcom.google.cloud.spanner.SpannerException ;
importcom.google.cloud.spanner.SpannerOptions ;
importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient ;
importcom.google.spanner.admin.instance.v1.DeleteInstanceConfigRequest ;
importcom.google.spanner.admin.instance.v1.InstanceConfigName ;
class DeleteInstanceConfigSample{
staticvoiddeleteInstanceConfig(){
// TODO(developer): Replace these variables before running the sample.
StringprojectId="my-project";
StringinstanceConfigId="custom-user-config";
deleteInstanceConfig(projectId,instanceConfigId);
}
staticvoiddeleteInstanceConfig(StringprojectId,StringinstanceConfigId){
try(Spanner spanner=
SpannerOptions .newBuilder()
.setProjectId(projectId)
.build()
.getService();
InstanceAdminClient instanceAdminClient=spanner.createInstanceAdminClient ()){
finalInstanceConfigName instanceConfigName=InstanceConfigName .of(projectId,
instanceConfigId);
finalDeleteInstanceConfigRequest request=
DeleteInstanceConfigRequest .newBuilder().setName(instanceConfigName.toString ()).build();
try{
System.out.printf("Deleting %s...\n",instanceConfigName);
instanceAdminClient.deleteInstanceConfig(request);
System.out.printf("Deleted instance configuration %s\n",instanceConfigName);
}catch(SpannerException e){
System.out.printf(
"Error: Deleting instance configuration %s failed with error message: %s\n",
instanceConfigName,e.getMessage());
}
}
}
}

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const instanceConfigId = 'custom-my-instance-config-id';
// const projectId = 'my-project-id';
// Imports the Google Cloud client library
const{Spanner}=require('@google-cloud/spanner');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
constinstanceAdminClient=spanner.getInstanceAdminClient ();
asyncfunctiondeleteInstanceConfig(){
// Deletes an instance config.
try{
// Delete the instance config.
console.log(`Deleting ${instanceConfigId}...\n`);
awaitinstanceAdminClient.deleteInstanceConfig({
name:instanceAdminClient.instanceConfigPath (
projectId,
instanceConfigId,
),
});
console.log(`Deleted instance config ${instanceConfigId}.\n`);
}catch(err){
console.error(
'ERROR: Deleting instance config ',
instanceConfigId,
' failed with error message ',
err,
);
}
}
deleteInstanceConfig();

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\DeleteInstanceConfigRequest;
/**
 * Deletes a customer managed instance configuration.
 * Example:
 * ```
 * delete_instance_config($instanceConfigId);
 * ```
 *
 * @param string $projectId The Google Cloud Project ID.
 * @param string $instanceConfigId The customer managed instance configuration id. The id must start with 'custom-'.
 */
function delete_instance_config(string $projectId, string $instanceConfigId)
{
 $instanceAdminClient = new InstanceAdminClient();
 $instanceConfigName = $instanceAdminClient->instanceConfigName(
 $projectId,
 $instanceConfigId
 );
 $request = new DeleteInstanceConfigRequest();
 $request->setName($instanceConfigName);
 $instanceAdminClient->deleteInstanceConfig($request);
 printf('Deleted instance configuration %s' . PHP_EOL, $instanceConfigId);
}

defdelete_instance_config(user_config_id):
"""Deleted the user-managed instance configuration."""
 spanner_client = spanner.Client()
 spanner_client.instance_admin_api.delete_instance_config(name=user_config_id)
 print("Instance config {} successfully deleted".format(user_config_id))

require"google/cloud/spanner"
require"google/cloud/spanner/admin/instance"
defspanner_delete_instance_configuser_config_id:
# user_config_id = "The customer managed instance configuration ID, e.g projects/<project>/instanceConfigs/custom-nam11"
instance_admin_client=Google::Cloud::Spanner::Admin::Instance.instance_admin
instance_admin_client.delete_instance_configname:user_config_id
puts"Deleted instance configuration #{user_config_id}"
end