Create and manage instance configurations

  void 
  
 ListInstanceConfigs 
 ( 
  
 google 
 :: 
 cloud 
 :: 
 spanner_admin 
 :: 
 InstanceAdminClient 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 project_id 
 ) 
  
 { 
  
 int 
  
 count 
  
 = 
  
 0 
 ; 
  
 auto 
  
 project 
  
 = 
  
 google 
 :: 
 cloud 
 :: 
 Project 
 ( 
 project_id 
 ); 
  
 for 
  
 ( 
 auto 
&  
 config 
  
 : 
  
 client 
 . 
 ListInstanceConfigs 
 ( 
 project 
 . 
 FullName 
 ())) 
  
 { 
  
 if 
  
 ( 
 ! 
 config 
 ) 
  
 throw 
  
 std 
 :: 
 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 
 " 
 ; 
  
 } 
 } 
 

  using 
  
  Google.Api.Gax.ResourceNames 
 
 ; 
 using 
  
  Google.Cloud.Spanner.Admin.Instance.V1 
 
 ; 
 using 
  
 System 
 ; 
 using 
  
 System.Collections.Generic 
 ; 
 using 
  
 System.Linq 
 ; 
 public 
  
 class 
  
 ListInstanceConfigsSample 
 { 
  
 public 
  
 IEnumerable<InstanceConfig> 
  
 ListInstanceConfigs 
 ( 
 string 
  
 projectId 
 ) 
  
 { 
  
 var 
  
 instanceAdminClient 
  
 = 
  
  InstanceAdminClient 
 
 . 
  Create 
 
 (); 
  
 var 
  
 projectName 
  
 = 
  
  ProjectName 
 
 . 
  FromProject 
 
 ( 
 projectId 
 ); 
  
 var 
  
 instanceConfigs 
  
 = 
  
 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 
  
 ( 
 var 
  
 instanceConfig 
  
 in 
  
 instanceConfigs 
 . 
 Take 
 ( 
 5 
 )) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Available leader options for instance config {instanceConfig. InstanceConfigName 
.InstanceConfigId}:" 
 ); 
  
 foreach 
  
 ( 
 var 
  
 leader 
  
 in 
  
 instanceConfig 
 . 
  LeaderOptions 
 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 leader 
 ); 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Available optional replica for instance config {instanceConfig. InstanceConfigName 
.InstanceConfigId}:" 
 ); 
  
 foreach 
  
 ( 
 var 
  
 optionalReplica 
  
 in 
  
 instanceConfig 
 . 
  OptionalReplicas 
 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Replica type - {optionalReplica.Type}, default leader location - {optionalReplica. DefaultLeaderLocation 
}, location - {optionalReplica.Location}" 
 ); 
  
 } 
  
 } 
  
 return 
  
 instanceConfigs 
 ; 
  
 } 
 } 
 

  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 
 func 
  
 listInstanceConfigs 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectName 
  
 string 
 ) 
  
 error 
  
 { 
  
 // projectName = `projects/<project> 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 instanceAdmin 
 , 
  
 err 
  
 := 
  
 instance 
 . 
 NewInstanceAdminClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 instanceAdmin 
 . 
  Close 
 
 () 
  
 request 
  
 := 
  
& instancepb 
 . 
 ListInstanceConfigsRequest 
 { 
  
 Parent 
 : 
  
 projectName 
 , 
  
 } 
  
 for 
  
 { 
  
 iter 
  
 := 
  
 instanceAdmin 
 . 
 ListInstanceConfigs 
 ( 
 ctx 
 , 
  
 request 
 ) 
  
 for 
  
 { 
  
 ic 
 , 
  
 err 
  
 := 
  
 iter 
 . 
 Next 
 () 
  
 if 
  
 err 
  
 == 
  
 iterator 
 . 
 Done 
  
 { 
  
 break 
  
 } 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Available leader options for instance config %s: %v\n" 
 , 
  
 ic 
 . 
 Name 
 , 
  
 ic 
 . 
 LeaderOptions 
 ) 
  
 } 
  
 pageToken 
  
 := 
  
 iter 
 . 
 PageInfo 
 (). 
 Token 
  
 if 
  
 pageToken 
  
 == 
  
 "" 
  
 { 
  
 break 
  
 } 
  
 else 
  
 { 
  
 request 
 . 
 PageToken 
  
 = 
  
 pageToken 
  
 } 
  
 } 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.cloud.spanner. Spanner 
 
 ; 
 import 
  
 com.google.cloud.spanner. SpannerOptions 
 
 ; 
 import 
  
 com.google.cloud.spanner.admin.instance.v1. InstanceAdminClient 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. InstanceConfig 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. ProjectName 
 
 ; 
 public 
  
 class 
 ListInstanceConfigsSample 
  
 { 
  
 static 
  
 void 
  
 listInstanceConfigs 
 () 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 String 
  
 projectId 
  
 = 
  
 "my-project" 
 ; 
  
 listInstanceConfigs 
 ( 
 projectId 
 ); 
  
 } 
  
 static 
  
 void 
  
 listInstanceConfigs 
 ( 
 String 
  
 projectId 
 ) 
  
 { 
  
 try 
  
 ( 
  Spanner 
 
  
 spanner 
  
 = 
  
  SpannerOptions 
 
 . 
 newBuilder 
 () 
  
 . 
 setProjectId 
 ( 
 projectId 
 ) 
  
 . 
 build 
 () 
  
 . 
 getService 
 (); 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  createInstanceAdminClient 
 
 ()) 
  
 { 
  
 final 
  
  ProjectName 
 
  
 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 
 const 
  
 spanner 
  
 = 
  
 new 
  
  Spanner 
 
 ({ 
  
 projectId 
 : 
  
 projectId 
 , 
 }); 
 const 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  getInstanceAdminClient 
 
 (); 
 async 
  
 function 
  
 listInstanceConfigs 
 () 
  
 { 
  
 // 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 
 ] 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 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())) 
 ); 
 } 
 } 
 

  def 
  
 list_instance_config 
 (): 
  
 """Lists the available instance configurations.""" 
 from 
  
 google.cloud.spanner_admin_instance_v1.types 
  
 import 
 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_path 
  
 project 
 : 
  
 project_id 
 configs 
  
 = 
  
 instance_admin_client 
 . 
 list_instance_configs 
  
 parent 
 : 
  
 project_path 
 configs 
 . 
 each 
  
 do 
  
 | 
 c 
 | 
  
 puts 
  
 "Available leader options for instance config 
 #{ 
 c 
 . 
 name 
 } 
 : 
 #{ 
 c 
 . 
 leader_options 
 } 
 " 
 end 
 

  void 
  
 GetInstanceConfig 
 ( 
 google 
 :: 
 cloud 
 :: 
 spanner_admin 
 :: 
 InstanceAdminClient 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 project_id 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 config_id 
 ) 
  
 { 
  
 auto 
  
 project 
  
 = 
  
 google 
 :: 
 cloud 
 :: 
 Project 
 ( 
 project_id 
 ); 
  
 auto 
  
 config 
  
 = 
  
 client 
 . 
 GetInstanceConfig 
 ( 
 project 
 . 
 FullName 
 () 
  
 + 
  
 "/instanceConfigs/" 
  
 + 
  
 config_id 
 ); 
  
 if 
  
 ( 
 ! 
 config 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 config 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "The instanceConfig " 
 << 
 config 
 - 
> name 
 () 
 << 
 " exists and its metadata is: 
 \n 
 " 
 << 
 config 
 - 
> DebugString 
 (); 
 } 
 

  using 
  
  Google.Cloud.Spanner.Admin.Instance.V1 
 
 ; 
 using 
  
 System 
 ; 
 using 
  
 System.Threading.Tasks 
 ; 
 public 
  
 class 
  
 GetInstanceConfigAsyncSample 
 { 
  
 public 
  
 async 
  
 Task<InstanceConfig> 
  
 GetInstanceConfigAsync 
 ( 
 string 
  
 projectId 
 , 
  
 string 
  
 instanceConfigId 
 ) 
  
 { 
  
 var 
  
 instanceAdminClient 
  
 = 
  
 await 
  
  InstanceAdminClient 
 
 . 
  CreateAsync 
 
 (); 
  
 var 
  
 instanceConfigName 
  
 = 
  
  InstanceConfigName 
 
 . 
  FromProjectInstanceConfig 
 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 var 
  
 instanceConfig 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 GetInstanceConfigAsync 
 ( 
 instanceConfigName 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Available leader options for instance config {instanceConfigName.InstanceConfigId}:" 
 ); 
  
 foreach 
  
 ( 
 var 
  
 leader 
  
 in 
  
 instanceConfig 
 . 
  LeaderOptions 
 
 ) 
  
 { 
  
 Console 
 . 
 WriteLine 
 ( 
 leader 
 ); 
  
 } 
  
 return 
  
 instanceConfig 
 ; 
  
 } 
 } 
 

  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 
 func 
  
 getInstanceConfig 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 instanceConfigName 
  
 string 
 ) 
  
 error 
  
 { 
  
 // defaultLeader = `nam3` 
  
 ctx 
  
 := 
  
 context 
 . 
 Background 
 () 
  
 instanceAdmin 
 , 
  
 err 
  
 := 
  
 instance 
 . 
 NewInstanceAdminClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 instanceAdmin 
 . 
  Close 
 
 () 
  
 ic 
 , 
  
 err 
  
 := 
  
 instanceAdmin 
 . 
 GetInstanceConfig 
 ( 
 ctx 
 , 
  
& instancepb 
 . 
 GetInstanceConfigRequest 
 { 
  
 Name 
 : 
  
 instanceConfigName 
 , 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "could not get instance config %s: %w" 
 , 
  
 instanceConfigName 
 , 
  
 err 
 ) 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Available leader options for instance config %s: %v" 
 , 
  
 instanceConfigName 
 , 
  
 ic 
 . 
 LeaderOptions 
 ) 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.cloud.spanner. Spanner 
 
 ; 
 import 
  
 com.google.cloud.spanner. SpannerOptions 
 
 ; 
 import 
  
 com.google.cloud.spanner.admin.instance.v1. InstanceAdminClient 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. InstanceConfig 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. InstanceConfigName 
 
 ; 
 public 
  
 class 
 GetInstanceConfigSample 
  
 { 
  
 static 
  
 void 
  
 getInstanceConfig 
 () 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 final 
  
 String 
  
 projectId 
  
 = 
  
 "my-project" 
 ; 
  
 final 
  
 String 
  
 instanceConfigId 
  
 = 
  
 "nam6" 
 ; 
  
 getInstanceConfig 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 } 
  
 static 
  
 void 
  
 getInstanceConfig 
 ( 
 String 
  
 projectId 
 , 
  
 String 
  
 instanceConfigId 
 ) 
  
 { 
  
 try 
  
 ( 
  Spanner 
 
  
 spanner 
  
 = 
  
  SpannerOptions 
 
 . 
 newBuilder 
 () 
  
 . 
 setProjectId 
 ( 
 projectId 
 ) 
  
 . 
 build 
 () 
  
 . 
 getService 
 (); 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  createInstanceAdminClient 
 
 ()) 
  
 { 
  
 final 
  
  InstanceConfigName 
 
  
 instanceConfigName 
  
 = 
  
  InstanceConfigName 
 
 . 
 of 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 final 
  
  InstanceConfig 
 
  
 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 
 const 
  
 spanner 
  
 = 
  
 new 
  
  Spanner 
 
 ({ 
  
 projectId 
 : 
  
 projectId 
 , 
 }); 
 const 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  getInstanceAdminClient 
 
 (); 
 async 
  
 function 
  
 getInstanceConfig 
 () 
  
 { 
  
 // 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 
 ] 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 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()))) 
 ); 
 } 
 

  def 
  
 get_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_config 
  
 name 
 : 
  
 instance_config_path 
 puts 
  
 "Available leader options for instance config 
 #{ 
 config 
 . 
 name 
 } 
 : 
 #{ 
 config 
 . 
 leader_options 
 } 
 " 
 

  void 
  
 CreateInstanceConfig 
 ( 
  
 google 
 :: 
 cloud 
 :: 
 spanner_admin 
 :: 
 InstanceAdminClient 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 project_id 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 user_config_id 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 base_config_id 
 ) 
  
 { 
  
 auto 
  
 project 
  
 = 
  
 google 
 :: 
 cloud 
 :: 
 Project 
 ( 
 project_id 
 ); 
  
 auto 
  
 base_config 
  
 = 
  
 client 
 . 
 GetInstanceConfig 
 ( 
  
 project 
 . 
 FullName 
 () 
  
 + 
  
 "/instanceConfigs/" 
  
 + 
  
 base_config_id 
 ); 
  
 if 
  
 ( 
 ! 
 base_config 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 base_config 
 ). 
 status 
 (); 
  
 if 
  
 ( 
 base_config 
 - 
> optional_replicas 
 (). 
 empty 
 ()) 
  
 { 
  
 throw 
  
 std 
 :: 
 runtime_error 
 ( 
 "No optional replicas in base config" 
 ); 
  
 } 
  
 google 
 :: 
 spanner 
 :: 
 admin 
 :: 
 instance 
 :: 
 v1 
 :: 
 CreateInstanceConfigRequest 
  
 request 
 ; 
  
 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 
  
 ( 
 auto 
  
 const 
&  
 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 
 ); 
  
 auto 
  
 user_config 
  
 = 
  
 client 
 . 
 CreateInstanceConfig 
 ( 
 request 
 ). 
 get 
 (); 
  
 if 
  
 ( 
 ! 
 user_config 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 user_config 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "Created instance config [" 
 << 
 user_config_id 
 << 
 "]: 
 \n 
 " 
 << 
 user_config 
 - 
> DebugString 
 (); 
 } 
 

  using 
  
 System 
 ; 
 using 
  
 System.Threading.Tasks 
 ; 
 using 
  
  Google.Api.Gax.ResourceNames 
 
 ; 
 using 
  
  Google.Cloud.Spanner.Admin.Instance.V1 
 
 ; 
 public 
  
 class 
  
 CreateInstanceConfigAsyncSample 
 { 
  
 public 
  
 async 
  
 Task<InstanceConfig> 
  
 CreateInstanceConfigAsync 
 ( 
 string 
  
 projectId 
 , 
  
 string 
  
 baseInstanceConfigId 
 , 
  
 string 
  
 customInstanceConfigId 
 ) 
  
 { 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 await 
  
  InstanceAdminClient 
 
 . 
  CreateAsync 
 
 (); 
  
 var 
  
 instanceConfigName 
  
 = 
  
 new 
  
  InstanceConfigName 
 
 ( 
 projectId 
 , 
  
 baseInstanceConfigId 
 ); 
  
 var 
  
 instanceConfig 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
  GetInstanceConfigAsync 
 
 ( 
 instanceConfigName 
 ); 
  
 var 
  
 customInstanceConfigName 
  
 = 
  
 new 
  
  InstanceConfigName 
 
 ( 
 projectId 
 , 
  
 customInstanceConfigId 
 ); 
  
 //Create a custom config. 
  
  InstanceConfig 
 
  
 userInstanceConfig 
  
 = 
  
 new 
  
  InstanceConfig 
 
  
 { 
  
 DisplayName 
  
 = 
  
 "C# test custom instance config" 
 , 
  
 ConfigType 
  
 = 
  
  InstanceConfig 
 
 . 
  Type 
 
s . 
  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 
  
 = 
  
 { 
  
 new 
  
  ReplicaInfo 
 
  
 { 
  
 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 
 
  
 } 
  
 }; 
  
 var 
  
 operationResult 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
  CreateInstanceConfigAsync 
 
 ( 
 new 
  
  CreateInstanceConfigRequest 
 
  
 { 
  
 ParentAsProjectName 
  
 = 
  
  ProjectName 
 
 . 
  FromProject 
 
 ( 
 projectId 
 ), 
  
 InstanceConfig 
  
 = 
  
 userInstanceConfig 
 , 
  
 InstanceConfigId 
  
 = 
  
 customInstanceConfigId 
  
 }); 
  
 var 
  
 pollResult 
  
 = 
  
 await 
  
 operationResult 
 . 
 PollUntilCompletedAsync 
 (); 
  
 if 
  
 ( 
 pollResult 
 . 
 IsFaulted 
 ) 
  
 { 
  
 throw 
  
 pollResult 
 . 
 Exception 
 ; 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Instance config created successfully" 
 ); 
  
 Console 
 . 
 WriteLine 
 ( 
 $"Available custom replication options for instance config {pollResult.Result.Name}\r\n{pollResult.Result. OptionalReplicas 
}" 
 ); 
  
 return 
  
 pollResult 
 . 
 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 
 func 
  
 createInstanceConfig 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
 , 
  
 userConfigID 
 , 
  
 baseConfigID 
  
 string 
 ) 
  
 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 
 ) 
  
 defer 
  
 cancel 
 () 
  
 adminClient 
 , 
  
 err 
  
 := 
  
 instance 
 . 
 NewInstanceAdminClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 admiadminClient 
 . 
  Close 
 
baseConfig , 
  
 err 
  
 := 
  
 adminClient 
 . 
 GetInstanceConfig 
 ( 
 ctx 
 , 
  
& instancepb 
 . 
 GetInstanceConfigRequest 
 { 
  
 Name 
 : 
  
 fmt 
 . 
 Sprintf 
 ( 
 "projects/%s/instanceConfigs/%s" 
 , 
  
 projectID 
 , 
  
 baseConfigID 
 ), 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "createInstanceConfig.GetInstanceConfig: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 if 
  
 baseConfig 
 . 
 OptionalReplicas 
  
 == 
  
 nil 
  
 || 
  
 len 
 ( 
 baseConfig 
 . 
 OptionalReplicas 
 ) 
  
 == 
  
 0 
  
 { 
  
 return 
  
 fmt 
 . 
 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_MANAGED 
 
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 
 : 
  
 append 
 ( 
 baseConfig 
 . 
 Replicas 
 , 
  
 baseConfig 
 . 
 OptionalReplicas 
 ... 
 ), 
  
 BaseConfig 
 : 
  
 baseConfig 
 . 
 Name 
 , 
  
 Labels 
 : 
  
 map 
 [ 
 string 
 ] 
 string 
 { 
 "go_cloud_spanner_samples" 
 : 
  
 "true" 
 }, 
  
 }, 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 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 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "Waiting for instance config creation to finish failed: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // The instance configuration may not be ready to serve yet. 
  
 if 
  
 i 
 . 
 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 
 ) 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.cloud.spanner. Spanner 
 
 ; 
 import 
  
 com.google.cloud.spanner. SpannerOptions 
 
 ; 
 import 
  
 com.google.cloud.spanner.admin.instance.v1. InstanceAdminClient 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. CreateInstanceConfigRequest 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. InstanceConfig 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. InstanceConfigName 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. ProjectName 
 
 ; 
 import 
  
 com.google.spanner.admin.instance.v1. ReplicaInfo 
 
 ; 
 import 
  
 java.util.List 
 ; 
 import 
  
 java.util.concurrent.ExecutionException 
 ; 
 import 
  
 java.util.concurrent.TimeUnit 
 ; 
 import 
  
 java.util.concurrent.TimeoutException 
 ; 
 import 
  
 java.util.stream.Collectors 
 ; 
 import 
  
 java.util.stream.Stream 
 ; 
 class 
 CreateInstanceConfigSample 
  
 { 
  
 static 
  
 void 
  
 createInstanceConfig 
 () 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 String 
  
 projectId 
  
 = 
  
 "my-project" 
 ; 
  
 String 
  
 baseInstanceConfigId 
  
 = 
  
 "nam11" 
 ; 
  
 String 
  
 instanceConfigId 
  
 = 
  
 "custom-instance-config4" 
 ; 
  
 createInstanceConfig 
 ( 
 projectId 
 , 
  
 baseInstanceConfigId 
 , 
  
 instanceConfigId 
 ); 
  
 } 
  
 static 
  
 void 
  
 createInstanceConfig 
 ( 
  
 String 
  
 projectId 
 , 
  
 String 
  
 baseInstanceConfigId 
 , 
  
 String 
  
 instanceConfigId 
 ) 
  
 { 
  
 try 
  
 ( 
  Spanner 
 
  
 spanner 
  
 = 
  
  SpannerOptions 
 
 . 
 newBuilder 
 () 
  
 . 
 setProjectId 
 ( 
 projectId 
 ) 
  
 . 
 build 
 () 
  
 . 
 getService 
 (); 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  createInstanceAdminClient 
 
 ()) 
  
 { 
  
 final 
  
  InstanceConfigName 
 
  
 baseInstanceConfigName 
  
 = 
  
  InstanceConfigName 
 
 . 
 of 
 ( 
 projectId 
 , 
  
 baseInstanceConfigId 
 ); 
  
 final 
  
  InstanceConfig 
 
  
 baseConfig 
  
 = 
  
 instanceAdminClient 
 . 
 getInstanceConfig 
 ( 
 baseInstanceConfigName 
 . 
  toString 
 
 ()); 
  
 final 
  
  InstanceConfigName 
 
  
 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. 
 */ 
  
 final 
  
 List<ReplicaInfo> 
  
 replicas 
  
 = 
  
 Stream 
 . 
 concat 
 ( 
 baseConfig 
 . 
  getReplicasList 
 
 (). 
 stream 
 (), 
  
 baseConfig 
 . 
  getOptionalReplicasList 
 
 (). 
 stream 
 (). 
  limit 
 
 ( 
 1 
 )). 
 collect 
 ( 
 Collectors 
 . 
 toList 
 ()); 
  
 final 
  
  InstanceConfig 
 
  
 instanceConfig 
  
 = 
  
  InstanceConfig 
 
 . 
 newBuilder 
 (). 
 setName 
 ( 
 instanceConfigName 
 . 
  toString 
 
 ()) 
  
 . 
 setBaseConfig 
 ( 
 baseInstanceConfigName 
 . 
  toString 
 
 ()) 
  
 . 
 setDisplayName 
 ( 
 "Instance Configuration" 
 ). 
  addAllReplicas 
 
 ( 
 replicas 
 ). 
 build 
 (); 
  
 final 
  
  CreateInstanceConfigRequest 
 
  
 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 
  
 | 
  
 TimeoutException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Error: Creating instance configuration %s failed with error message %s\n" 
 , 
  
 instanceConfig 
 . 
  getName 
 
 (), 
  
 e 
 . 
 getMessage 
 ()); 
  
 } 
  
 catch 
  
 ( 
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 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 
 const 
  
 spanner 
  
 = 
  
 new 
  
  Spanner 
 
 ({ 
  
 projectId 
 : 
  
 projectId 
 , 
 }); 
 const 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  getInstanceAdminClient 
 
 (); 
 // Creates a new instance config 
 async 
  
 function 
  
 createInstanceConfig 
 () 
  
 { 
  
 const 
  
 [ 
 baseInstanceConfig 
 ] 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 getInstanceConfig 
 ({ 
  
 name 
 : 
  
 instanceAdminClient 
 . 
  instanceConfigPath 
 
 ( 
  
 projectId 
 , 
  
 baseInstanceConfigId 
 , 
  
 ), 
  
 }); 
  
 try 
  
 { 
  
 console 
 . 
 log 
 ( 
  
 `Creating instance config 
 ${ 
 instanceAdminClient 
 . 
  instanceConfigPath 
 
 ( 
  
 projectId 
 , 
  
 instanceConfigId 
 , 
  
 ) 
 } 
 .` 
 , 
  
 ); 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 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...` 
 , 
  
 ); 
  
 await 
  
  operation 
 
 . 
 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); 
 } 
 

  def 
  
 create_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" 
 def 
  
 spanner_create_instance_config 
  
 project_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_path 
  
 project 
 : 
  
 project_id 
  
 base_instance_config 
  
 = 
  
 instance_admin_client 
 . 
 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. 
  
 custom_replicas 
  
 = 
  
 [] 
  
 base_instance_config 
 . 
 replicas 
 . 
 each 
  
 do 
  
 | 
 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_config 
  
 request 
  
 puts 
  
 "Waiting for create instance config operation to complete" 
  
 job 
 . 
 wait_until_done! 
  
 if 
  
 job 
 . 
 error? 
  
 puts 
  
 job 
 . 
 error 
  
 else 
  
 puts 
  
 "Created instance configuration 
 #{ 
 user_config_name 
 } 
 " 
  
 end 
 end 
 

  void 
  
 UpdateInstanceConfig 
 ( 
  
 google 
 :: 
 cloud 
 :: 
 spanner_admin 
 :: 
 InstanceAdminClient 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 project_id 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 config_id 
 ) 
  
 { 
  
 auto 
  
 project 
  
 = 
  
 google 
 :: 
 cloud 
 :: 
 Project 
 ( 
 project_id 
 ); 
  
 auto 
  
 config 
  
 = 
  
 client 
 . 
 GetInstanceConfig 
 ( 
 project 
 . 
 FullName 
 () 
  
 + 
  
 "/instanceConfigs/" 
  
 + 
  
 config_id 
 ); 
  
 if 
  
 ( 
 ! 
 config 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 config 
 ). 
 status 
 (); 
  
 google 
 :: 
 spanner 
 :: 
 admin 
 :: 
 instance 
 :: 
 v1 
 :: 
 UpdateInstanceConfigRequest 
  
 request 
 ; 
  
 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 
 ); 
  
 auto 
  
 updated_config 
  
 = 
  
 client 
 . 
 UpdateInstanceConfig 
 ( 
 request 
 ). 
 get 
 (); 
  
 if 
  
 ( 
 ! 
 updated_config 
 ) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 updated_config 
 ). 
 status 
 (); 
  
 std 
 :: 
 cout 
 << 
 "Updated instance config [" 
 << 
 config_id 
 << 
 "]: 
 \n 
 " 
 << 
 updated_config 
 - 
> DebugString 
 (); 
 } 
 

  using 
  
 System 
 ; 
 using 
  
 System.Collections.Generic 
 ; 
 using 
  
 System.Threading.Tasks 
 ; 
 using 
  
  Google.Cloud.Spanner.Admin.Instance.V1 
 
 ; 
 using 
  
  Google.LongRunning 
 
 ; 
 using 
  
  Google.Protobuf.WellKnownTypes 
 
 ; 
 public 
  
 class 
  
 UpdateInstanceConfigAsyncSample 
 { 
  
 public 
  
 async 
  
 Task<Operation<InstanceConfig 
 , 
  
 UpdateInstanceConfigMetadata 
>>  
 UpdateInstanceConfigAsync 
 ( 
 string 
  
 projectId 
 , 
  
 string 
  
 instanceConfigId 
 ) 
  
 { 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 await 
  
  InstanceAdminClient 
 
 . 
  CreateAsync 
 
 (); 
  
 var 
  
 instanceConfigName 
  
 = 
  
 new 
  
  InstanceConfigName 
 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 var 
  
 instanceConfig 
  
 = 
  
 new 
  
  InstanceConfig 
 
 (); 
  
 instanceConfig 
 . 
  InstanceConfigName 
 
  
 = 
  
 instanceConfigName 
 ; 
  
 instanceConfig 
 . 
 DisplayName 
  
 = 
  
 "New display name" 
 ; 
  
 instanceConfig 
 . 
 Labels 
 . 
 Add 
 ( 
 new 
  
 Dictionary<string 
 , 
  
 string 
>  
 { 
  
 { 
 "cloud_spanner_samples" 
 , 
 "true" 
 }, 
  
 { 
 "updated" 
 , 
 "true" 
 }, 
  
 }); 
  
 var 
  
 updateInstanceConfigOperation 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
  UpdateInstanceConfigAsync 
 
 ( 
 new 
  
  UpdateInstanceConfigRequest 
 
  
 { 
  
 InstanceConfig 
  
 = 
  
 instanceConfig 
 , 
  
 UpdateMask 
  
 = 
  
 new 
  
  FieldMask 
 
  
 { 
  
 Paths 
  
 = 
  
 { 
  
 "display_name" 
 , 
  
 "labels" 
  
 } 
  
 } 
  
 }); 
  
 updateInstanceConfigOperation 
  
 = 
  
 await 
  
 updateInstanceConfigOperation 
 . 
 PollUntilCompletedAsync 
 (); 
  
  
 if 
  
 ( 
 updateInstanceConfigOperation 
 . 
 IsFaulted 
 ) 
  
 { 
  
 throw 
  
 updateInstanceConfigOperation 
 . 
 Exception 
 ; 
  
 } 
  
 Console 
 . 
 WriteLine 
 ( 
 "Update Instance Config operation completed successfully." 
 ); 
  
 return 
  
 updateInstanceConfigOperation 
 ; 
  
 } 
 } 
 

  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 
 func 
  
 updateInstanceConfig 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
 , 
  
 userConfigID 
  
 string 
 ) 
  
 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 
 ) 
  
 defer 
  
 cancel 
 () 
  
 adminClient 
 , 
  
 err 
  
 := 
  
 instance 
 . 
 NewInstanceAdminClient 
 ( 
 ctx 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 admiadminClient 
 . 
  Close 
 
config , 
  
 err 
  
 := 
  
 adminClient 
 . 
 GetInstanceConfig 
 ( 
 ctx 
 , 
  
& instancepb 
 . 
 GetInstanceConfigRequest 
 { 
  
 Name 
 : 
  
 fmt 
 . 
 Sprintf 
 ( 
 "projects/%s/instanceConfigs/%s" 
 , 
  
 projectID 
 , 
  
 userConfigID 
 ), 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 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 
 , 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 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 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 fmt 
 . 
 Errorf 
 ( 
 "Waiting for instance config creation to finish failed: %w" 
 , 
  
 err 
 ) 
  
 } 
  
 // The instance configuration may not be ready to serve yet. 
  
 if 
  
 i 
 . 
 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 
 ) 
  
 return 
  
 nil 
 } 
 

  import 
  
 com.google.cloud.spanner. Spanner 
 
 ; 
 import 
  
 com.google.cloud.spanner. SpannerOptions 
 
 ; 
 import 
  
 com.google.cloud.spanner.admin. instance 
.v1. InstanceAdminClient 
 
 ; 
 import 
  
 com.google.common.collect.ImmutableList 
 ; 
 import 
  
 com.google.protobuf. FieldMask 
 
 ; 
 import 
  
 com.google.spanner.admin. instance 
.v1. InstanceConfig 
 
 ; 
 import 
  
 com.google.spanner.admin. instance 
.v1. InstanceConfigName 
 
 ; 
 import 
  
 com.google.spanner.admin. instance 
.v1. UpdateInstanceConfigRequest 
 
 ; 
 import 
  
 java.util.concurrent.ExecutionException 
 ; 
 import 
  
 java.util.concurrent.TimeUnit 
 ; 
 import 
  
 java.util.concurrent.TimeoutException 
 ; 
 class 
 UpdateInstanceConfigSample 
  
 { 
  
 static 
  
 void 
  
 updateInstanceConfig 
 () 
  
 { 
  
 // TODO(developer): Replace these variables before running the sample. 
  
 String 
  
 projectId 
  
 = 
  
 "my-project" 
 ; 
  
 String 
  
 instanceConfigId 
  
 = 
  
 "custom-instance-config" 
 ; 
  
 updateInstanceConfig 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 } 
  
 static 
  
 void 
  
 updateInstanceConfig 
 ( 
 String 
  
 projectId 
 , 
  
 String 
  
 instanceConfigId 
 ) 
  
 { 
  
 try 
  
 ( 
  Spanner 
 
  
 spanner 
  
 = 
  
  SpannerOptions 
 
 . 
 newBuilder 
 () 
  
 . 
 setProjectId 
 ( 
 projectId 
 ) 
  
 . 
 build 
 () 
  
 . 
 getService 
 (); 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  createInstanceAdminClient 
 
 ()) 
  
 { 
  
 final 
  
  InstanceConfigName 
 
  
 instanceConfigName 
  
 = 
  
  InstanceConfigName 
 
 . 
 of 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 final 
  
  InstanceConfig 
 
  
 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. 
 */ 
  
 final 
  
  UpdateInstanceConfigRequest 
 
  
 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 
  
 | 
  
 TimeoutException 
  
 e 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 printf 
 ( 
  
 "Error: Updating instance config %s failed with error message %s\n" 
 , 
  
 instanceConfig 
 . 
  getName 
 
 (), 
  
 e 
 . 
 getMessage 
 ()); 
  
 e 
 . 
 printStackTrace 
 (); 
  
 } 
  
 catch 
  
 ( 
 InterruptedException 
  
 e 
 ) 
  
 { 
  
 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 
 const 
  
 spanner 
  
 = 
  
 new 
  
  Spanner 
 
 ({ 
  
 projectId 
 : 
  
 projectId 
 , 
 }); 
 const 
  
 instanceAdminClient 
  
 = 
  
 spanner 
 . 
  getInstanceAdminClient 
 
 (); 
 async 
  
 function 
  
 updateInstanceConfig 
 () 
  
 { 
  
 // Updates an instance config 
  
 try 
  
 { 
  
 console 
 . 
 log 
 ( 
  
 `Updating instance config 
 ${ 
 instanceAdminClient 
 . 
  instanceConfigPath 
 
 ( 
  
 projectId 
 , 
  
 instanceConfigId 
 , 
  
 ) 
 } 
 .` 
 , 
  
 ); 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 instanceAdminClient 
 . 
 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...` 
 , 
  
 ); 
  
 await 
  
  operation 
 
 . 
 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); 
 } 
 

  def 
  
 update_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" 
 def 
  
 spanner_update_instance_config 
  
 user_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_config 
  
 name 
 : 
  
 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_config 
  
 request 
  
 puts 
  
 "Waiting for update instance config operation to complete" 
  
 job 
 . 
 wait_until_done! 
  
 if 
  
 job 
 . 
 error? 
  
 puts 
  
 job 
 . 
 error 
  
 else 
  
 puts 
  
 "Updated instance configuration 
 #{ 
 config 
 . 
 name 
 } 
 " 
  
 end 
 end 
 

  void 
  
 DeleteInstanceConfig 
 ( 
  
 google 
 :: 
 cloud 
 :: 
 spanner_admin 
 :: 
 InstanceAdminClient 
  
 client 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 project_id 
 , 
  
 std 
 :: 
 string 
  
 const 
&  
 config_id 
 ) 
  
 { 
  
 auto 
  
 project 
  
 = 
  
 google 
 :: 
 cloud 
 :: 
 Project 
 ( 
 project_id 
 ); 
  
 auto 
  
 config_name 
  
 = 
  
 project 
 . 
 FullName 
 () 
  
 + 
  
 "/instanceConfigs/" 
  
 + 
  
 config_id 
 ; 
  
 auto 
  
 status 
  
 = 
  
 client 
 . 
 DeleteInstanceConfig 
 ( 
 config_name 
 ); 
  
 if 
  
 ( 
 ! 
 status 
 . 
 ok 
 ()) 
  
 throw 
  
 std 
 :: 
 move 
 ( 
 status 
 ); 
  
 std 
 :: 
 cout 
 << 
 "Instance config " 
 << 
 config_name 
 << 
 " successfully deleted 
 \n 
 " 
 ; 
 } 
 

  using 
  
 System 
 ; 
 using 
  
 System.Threading.Tasks 
 ; 
 using 
  
  Google.Cloud.Spanner.Admin.Instance.V1 
 
 ; 
 using 
  
  Grpc.Core 
 
 ; 
 public 
  
 class 
  
 DeleteInstanceConfigAsyncSample 
 { 
  
 public 
  
 async 
  
 Task 
  
 DeleteInstanceConfigAsync 
 ( 
 string 
  
 projectId 
 , 
  
 string 
  
 instanceConfigId 
 ) 
  
 { 
  
  InstanceAdminClient 
 
  
 instanceAdminClient 
  
 = 
  
 await 
  
  InstanceAdminClient 
 
 . 
  CreateAsync 
 
 (); 
  
 var 
  
 instanceConfigName 
  
 = 
  
 new 
  
  InstanceConfigName 
 
 ( 
 projectId 
 , 
  
 instanceConfigId 
 ); 
  
 try 
  
 { 
  
 await 
  
 instanceAdminClient 
 . 
  DeleteInstanceConfigAsync 
 
 ( 
 new 
  
  DeleteInstanceConfigRequest 
 
  
 { 
  
 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 
 func 
  
 deleteInstanceConfig 
 ( 
 w 
  
 io 
 . 
 Writer 
 , 
  
 projectID 
 , 
  
 userConfigID 
  
 string 
 ) 
  
 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 
 ) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 defer 
  
 admiadminClient 
 . 
  Close 
 
err  
 = 
  
 adminClient 
 . 
 DeleteInstanceConfig 
 ( 
 ctx 
 , 
  
& instancepb 
 . 
 DeleteInstanceConfigRequest 
 { 
  
 Name 
 : 
  
 fmt 
 . 
 Sprintf 
 ( 
 "projects/%s/instanceConfigs/%s" 
 , 
  
 projectID 
 , 
  
 userConfigID 
 ), 
  
 }) 
  
 if 
  
 err 
  
 != 
  
 nil 
  
 { 
  
 return 
  
 err 
  
 } 
  
 fmt 
 . 
 Fprintf 
 ( 
 w 
 , 
  
 "Deleted instance configuration [%s]\n" 
 , 
  
 userConfigID 
 ) 
  
 return 
  
 nil 
 }