インスタンスを作成、管理する

void CreateInstance(google::cloud::spanner_admin::InstanceAdminClient client,                     std::string const& project_id,                     std::string const& instance_id,                     std::string const& display_name,                     std::string const& config_id) {   namespace spanner = ::google::cloud::spanner;   spanner::Instance in(project_id, instance_id);    auto project = google::cloud::Project(project_id);   std::string config_name =       project.FullName() + "/instanceConfigs/" + config_id;   auto instance =       client           .CreateInstance(spanner::CreateInstanceRequestBuilder(in, config_name)                               .SetDisplayName(display_name)                               .SetNodeCount(1)                               .SetLabels({{"cloud_spanner_samples", "true"}})                               .Build())           .get();   if (!instance) throw std::move(instance).status();   std::cout << "Created instance [" << in << "]:\n" << instance->DebugString(); }

 using Google.Api.Gax.ResourceNames; using Google.Cloud.Spanner.Admin.Instance.V1; using Google.Cloud.Spanner.Common.V1; using Google.LongRunning; using System; using System.Threading.Tasks;  public class CreateInstanceAsyncSample {     public async Task<Instance> CreateInstanceAsync(         string projectId,         string instanceId,         Instance.Types.Edition edition = Instance.Types.Edition.Standard)     {         // Create the InstanceAdminClient instance.         InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();          // Initialize request parameters.         Instance instance = new Instance         {             InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),             ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-us-central1"),             DisplayName = "This is a display name.",             NodeCount = 1,             Labels =             {                 { "cloud_spanner_samples", "true" },             },             Edition = edition,         };         ProjectName projectName = ProjectName.FromProject(projectId);          // Make the CreateInstance request.         Operation<Instance, CreateInstanceMetadata> response = await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);          Console.WriteLine("Waiting for the operation to finish.");          // Poll until the returned long-running operation is complete.         Operation<Instance, CreateInstanceMetadata> completedResponse = await response.PollUntilCompletedAsync();          if (completedResponse.IsFaulted)         {             Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");             throw completedResponse.Exception;         }          Console.WriteLine($"Instance created successfully.");          return completedResponse.Result;     } }

 using Google.Api.Gax.ResourceNames; using Google.Cloud.Spanner.Admin.Instance.V1; using Google.Cloud.Spanner.Common.V1; using Google.LongRunning; using System; using System.Threading.Tasks;  public class CreateInstanceWithoutDefaultBackupSchedulesAsyncSample {     public async Task<Instance> CreateInstanceWithoutDefaultBackupSchedulesAsync(string projectId, string instanceId)     {         // Create the InstanceAdminClient instance.         InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();          // Initialize request parameters.         Instance instance = new Instance         {             InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),             ConfigAsInstanceConfigName =                 InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-me-central2"),             DisplayName = "This is a display name.",             NodeCount = 1,             Labels =             {                 { "cloud_spanner_samples", "true" },             },             DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.None,         };         ProjectName projectName = ProjectName.FromProject(projectId);          // Make the CreateInstance request.         Operation<Instance, CreateInstanceMetadata> response =             await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);          Console.WriteLine("Waiting for the operation to finish.");          // Poll until the returned long-running operation is complete.         Operation<Instance, CreateInstanceMetadata> completedResponse =             await response.PollUntilCompletedAsync();          if (completedResponse.IsFaulted)         {             Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");             throw completedResponse.Exception;         }          Console.WriteLine($"Instance created successfully.");         return completedResponse.Result;     } }

import ( 	"context" 	"fmt" 	"io"  	instance "cloud.google.com/go/spanner/admin/instance/apiv1" 	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb" )  func createInstance(w io.Writer, projectID, instanceID string) error { 	// projectID := "my-project-id" 	// instanceID := "my-instance" 	ctx := context.Background() 	instanceAdmin, err := instance.NewInstanceAdminClient(ctx) 	if err != nil { 		return err 	} 	defer instanceAdmin.Close()  	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{ 		Parent:     fmt.Sprintf("projects/%s", projectID), 		InstanceId: instanceID, 		Instance: &instancepb.Instance{ 			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"), 			DisplayName: instanceID, 			NodeCount:   1, 			Labels:      map[string]string{"cloud_spanner_samples": "true"}, 			Edition:     instancepb.Instance_STANDARD, 		}, 	}) 	if err != nil { 		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err) 	} 	// Wait for the instance creation to finish. 	i, err := op.Wait(ctx) 	if err != nil { 		return fmt.Errorf("waiting for instance creation to finish failed: %w", err) 	} 	// The instance may not be ready to serve yet. 	if i.State != instancepb.Instance_READY { 		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State) 	} 	fmt.Fprintf(w, "Created instance [%s]\n", instanceID) 	return nil } 

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/genproto/protobuf/field_mask" )  // Example of creating an autoscaling instance with Go. // projectID is the ID of the project that the new instance will be in. // instanceID is the ID of the new instance to be created. func createInstanceWithAutoscalingConfig(w io.Writer, projectID, instanceID string) error { 	// projectID := "my-project-id" 	// instanceID := "my-instance" 	ctx := context.Background() 	instanceAdmin, err := instance.NewInstanceAdminClient(ctx) 	if err != nil { 		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err) 	} 	defer instanceAdmin.Close()  	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID) 	fmt.Fprintf(w, "Creating instance %s.", instanceName)  	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{ 		Parent:     fmt.Sprintf("projects/%s", projectID), 		InstanceId: instanceID, 		Instance: &instancepb.Instance{ 			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"), 			DisplayName: "Create instance example", 			AutoscalingConfig: &instancepb.AutoscalingConfig{ 				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{ 					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{ 						MinNodes: 1, 					}, 					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{ 						MaxNodes: 2, 					}, 				}, 				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{ 					HighPriorityCpuUtilizationPercent: 65, 					StorageUtilizationPercent:         95, 				}, 			}, 			Labels:  map[string]string{"cloud_spanner_samples": "true"}, 			Edition: instancepb.Instance_ENTERPRISE_PLUS, 		}, 	}) 	if err != nil { 		return fmt.Errorf("could not create instance %s: %w", instanceName, err) 	} 	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID) 	// Wait for the instance creation to finish. 	i, err := op.Wait(ctx) 	if err != nil { 		return fmt.Errorf("waiting for instance creation to finish failed: %w", err) 	} 	// The instance may not be ready to serve yet. 	if i.State != instancepb.Instance_READY { 		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State) 	} 	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)  	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{ 		Name: instanceName, 		// Get the autoscaling_config field from the newly created instance. 		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}}, 	}) 	if err != nil { 		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err) 	} 	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig) 	return nil } 

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/genproto/protobuf/field_mask" )  // createInstanceWithAsymmetricAutoscalingConfig is a code snippet to show // an example of creating an asymmetric autoscaling enabled instance in Go. // // projectID is the ID of the project that the new instance will be in. // instanceID is the ID of the new instance to be created. func createInstanceWithAsymmetricAutoscalingConfig(w io.Writer, projectID, instanceID string) error { 	ctx := context.Background() 	instanceAdmin, err := instance.NewInstanceAdminClient(ctx) 	if err != nil { 		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err) 	} 	defer instanceAdmin.Close()  	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID) 	fmt.Fprintf(w, "Creating instance %s.", instanceName)  	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{ 		Parent:     fmt.Sprintf("projects/%s", projectID), 		InstanceId: instanceID, 		Instance: &instancepb.Instance{ 			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam-eur-asia3"), 			DisplayName: "Create instance example", 			AutoscalingConfig: &instancepb.AutoscalingConfig{ 				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{ 					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{ 						MinNodes: 1, 					}, 					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{ 						MaxNodes: 10, 					}, 				}, 				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{ 					HighPriorityCpuUtilizationPercent: 65, 					StorageUtilizationPercent:         95, 				}, 				// Read-only replicas in europe-west1, europe-west4, and asia-east1 are autoscaled 				// independly from other replicas based on the usage in the respective region. 				AsymmetricAutoscalingOptions: []*instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{ 					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{ 						ReplicaSelection: &instancepb.ReplicaSelection{ 							Location: "europe-west1", 						}, 					}, 					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{ 						ReplicaSelection: &instancepb.ReplicaSelection{ 							Location: "europe-west4", 						}, 					}, 					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{ 						ReplicaSelection: &instancepb.ReplicaSelection{ 							Location: "asia-east1", 						}, 					}, 				}, 			}, 			Labels:  map[string]string{"cloud_spanner_samples": "true"}, 			Edition: instancepb.Instance_ENTERPRISE_PLUS, 		}, 	}) 	if err != nil { 		return fmt.Errorf("could not create instance %s: %w", instanceName, err) 	} 	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID) 	// Wait for the instance creation to finish. 	i, err := op.Wait(ctx) 	if err != nil { 		return fmt.Errorf("waiting for instance creation to finish failed: %w", err) 	} 	// The instance may not be ready to serve yet. 	if i.State != instancepb.Instance_READY { 		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State) 	} 	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)  	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{ 		Name: instanceName, 		// Get the autoscaling_config field from the newly created instance. 		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}}, 	}) 	if err != nil { 		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err) 	} 	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig) 	return nil } 

import ( 	"context" 	"fmt" 	"io"  	instance "cloud.google.com/go/spanner/admin/instance/apiv1" 	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb" )  // createInstanceWithoutDefaultBackupSchedule creates instance with default backup schedule disabled. func createInstanceWithoutDefaultBackupSchedule(w io.Writer, projectID, instanceID string) error { 	// projectID := "my-project-id" 	// instanceID := "my-instance" 	ctx := context.Background() 	instanceAdmin, err := instance.NewInstanceAdminClient(ctx) 	if err != nil { 		return err 	} 	defer instanceAdmin.Close()  	// Create an instance without default backup schedule, whicn means no default backup schedule will 	// be created automatically on creation of a database within the instance. 	req := &instancepb.CreateInstanceRequest{ 		Parent:     fmt.Sprintf("projects/%s", projectID), 		InstanceId: instanceID, 		Instance: &instancepb.Instance{ 			Config:                    fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"), 			DisplayName:               instanceID, 			NodeCount:                 1, 			Labels:                    map[string]string{"cloud_spanner_samples": "true"}, 			DefaultBackupScheduleType: instancepb.Instance_NONE, 		}, 	}  	op, err := instanceAdmin.CreateInstance(ctx, req) 	if err != nil { 		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err) 	} 	// Wait for the instance creation to finish.  For more information about instances, see 	// https://cloud.google.com/spanner/docs/instances. 	instance, err := op.Wait(ctx) 	if err != nil { 		return fmt.Errorf("waiting for instance creation to finish failed: %w", err) 	} 	// The instance may not be ready to serve yet. 	if instance.State != instancepb.Instance_READY { 		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", instance.State) 	} 	fmt.Fprintf(w, "Created instance [%s]\n", instanceID) 	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.CreateInstanceRequest; import com.google.spanner.admin.instance.v1.Instance; import com.google.spanner.admin.instance.v1.InstanceConfigName; import com.google.spanner.admin.instance.v1.ProjectName; import java.util.concurrent.ExecutionException;  class CreateInstanceExample {    static void createInstance() {     // TODO(developer): Replace these variables before running the sample.     String projectId = "my-project";     String instanceId = "my-instance";     createInstance(projectId, instanceId);   }    static void createInstance(String projectId, String instanceId) {     // Set Instance configuration.     int nodeCount = 2;     String displayName = "Descriptive name";      // Create an Instance object that will be used to create the instance.     Instance instance =         Instance.newBuilder()             .setDisplayName(displayName)             .setEdition(Instance.Edition.STANDARD)             .setNodeCount(nodeCount)             .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())             .build();      try (Spanner spanner =             SpannerOptions.newBuilder().setProjectId(projectId).build().getService();         InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {        // Wait for the createInstance operation to finish.       Instance createdInstance =           instanceAdminClient               .createInstanceAsync(                   CreateInstanceRequest.newBuilder()                       .setParent(ProjectName.of(projectId).toString())                       .setInstanceId(instanceId)                       .setInstance(instance)                       .build())               .get();       System.out.printf("Instance %s was successfully created%n", createdInstance.getName());     } catch (ExecutionException e) {       System.out.printf(           "Error: Creating instance %s failed with error message %s%n",           instance.getName(), e.getMessage());     } catch (InterruptedException e) {       System.out.println("Error: Waiting for createInstance operation to finish was interrupted");     }   } }

 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.AutoscalingConfig; import com.google.spanner.admin.instance.v1.CreateInstanceRequest; import com.google.spanner.admin.instance.v1.Instance; import com.google.spanner.admin.instance.v1.InstanceConfigName; import com.google.spanner.admin.instance.v1.ProjectName; import com.google.spanner.admin.instance.v1.ReplicaSelection; import java.util.concurrent.ExecutionException;  class CreateInstanceWithAsymmetricAutoscalingConfigExample {    static void createInstance() {     // TODO(developer): Replace these variables before running the sample.     String projectId = "my-project";     String instanceId = "my-instance";     createInstance(projectId, instanceId);   }    static void createInstance(String projectId, String instanceId) {     try (Spanner spanner =         SpannerOptions.newBuilder()             .setProjectId(projectId)             .build()             .getService();         InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {       // Set Instance configuration.       String configId = "nam-eur-asia3";       String displayName = "Descriptive name";        // Create an autoscaling config.       // When autoscaling_config is enabled, node_count and processing_units fields       // need not be specified.       // The read-only replicas listed in the asymmetric autoscaling options scale independently       // from other replicas.       AutoscalingConfig autoscalingConfig =           AutoscalingConfig.newBuilder()               .setAutoscalingLimits(                   AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))               .setAutoscalingTargets(                   AutoscalingConfig.AutoscalingTargets.newBuilder()                       .setHighPriorityCpuUtilizationPercent(65)                       .setStorageUtilizationPercent(95))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))               .build();       Instance instance =           Instance.newBuilder()               .setAutoscalingConfig(autoscalingConfig)               .setDisplayName(displayName)               .setConfig(                   InstanceConfigName.of(projectId, configId).toString())               .build();        // Creates a new instance       System.out.printf("Creating instance %s.%n", instanceId);       try {         // Wait for the createInstance operation to finish.         Instance instanceResult = instanceAdminClient.createInstanceAsync(             CreateInstanceRequest.newBuilder()                 .setParent(ProjectName.of(projectId).toString())                 .setInstanceId(instanceId)                 .setInstance(instance)                 .build()).get();         System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",             instanceResult.getName());       } catch (ExecutionException e) {         System.out.printf(             "Error: Creating instance %s failed with error message %s%n",             instance.getName(), e.getMessage());       } catch (InterruptedException e) {         System.out.println("Error: Waiting for createInstance operation to finish was interrupted");       }     }   } }

 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.AutoscalingConfig; import com.google.spanner.admin.instance.v1.CreateInstanceRequest; import com.google.spanner.admin.instance.v1.Instance; import com.google.spanner.admin.instance.v1.InstanceConfigName; import com.google.spanner.admin.instance.v1.ProjectName; import com.google.spanner.admin.instance.v1.ReplicaSelection; import java.util.concurrent.ExecutionException;  class CreateInstanceWithAsymmetricAutoscalingConfigExample {    static void createInstance() {     // TODO(developer): Replace these variables before running the sample.     String projectId = "my-project";     String instanceId = "my-instance";     createInstance(projectId, instanceId);   }    static void createInstance(String projectId, String instanceId) {     try (Spanner spanner =         SpannerOptions.newBuilder()             .setProjectId(projectId)             .build()             .getService();         InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {       // Set Instance configuration.       String configId = "nam-eur-asia3";       String displayName = "Descriptive name";        // Create an autoscaling config.       // When autoscaling_config is enabled, node_count and processing_units fields       // need not be specified.       // The read-only replicas listed in the asymmetric autoscaling options scale independently       // from other replicas.       AutoscalingConfig autoscalingConfig =           AutoscalingConfig.newBuilder()               .setAutoscalingLimits(                   AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))               .setAutoscalingTargets(                   AutoscalingConfig.AutoscalingTargets.newBuilder()                       .setHighPriorityCpuUtilizationPercent(65)                       .setStorageUtilizationPercent(95))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))               .addAsymmetricAutoscalingOptions(                   AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()                   .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))               .build();       Instance instance =           Instance.newBuilder()               .setAutoscalingConfig(autoscalingConfig)               .setDisplayName(displayName)               .setConfig(                   InstanceConfigName.of(projectId, configId).toString())               .build();        // Creates a new instance       System.out.printf("Creating instance %s.%n", instanceId);       try {         // Wait for the createInstance operation to finish.         Instance instanceResult = instanceAdminClient.createInstanceAsync(             CreateInstanceRequest.newBuilder()                 .setParent(ProjectName.of(projectId).toString())                 .setInstanceId(instanceId)                 .setInstance(instance)                 .build()).get();         System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",             instanceResult.getName());       } catch (ExecutionException e) {         System.out.printf(             "Error: Creating instance %s failed with error message %s%n",             instance.getName(), e.getMessage());       } catch (InterruptedException e) {         System.out.println("Error: Waiting for createInstance operation to finish was interrupted");       }     }   } }

 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.CreateInstanceRequest; import com.google.spanner.admin.instance.v1.Instance; import com.google.spanner.admin.instance.v1.InstanceConfigName; import com.google.spanner.admin.instance.v1.ProjectName; import java.util.concurrent.ExecutionException;  class CreateInstanceWithoutDefaultBackupSchedulesExample {    static void createInstanceWithoutDefaultBackupSchedules() {     // TODO(developer): Replace these variables before running the sample.     String projectId = "my-project";     String instanceId = "my-instance";     createInstanceWithoutDefaultBackupSchedules(projectId, instanceId);   }    static void createInstanceWithoutDefaultBackupSchedules(String projectId, String instanceId) {     // Set Instance configuration.     int nodeCount = 2;     String displayName = "Descriptive name";      // Create an Instance object that will be used to create the instance.     Instance instance =         Instance.newBuilder()             .setDisplayName(displayName)             .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.NONE)             .setNodeCount(nodeCount)             .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())             .build();      try (Spanner spanner =             SpannerOptions.newBuilder().setProjectId(projectId).build().getService();         InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {        // Wait for the createInstance operation to finish.       Instance createdInstance =           instanceAdminClient               .createInstanceAsync(                   CreateInstanceRequest.newBuilder()                       .setParent(ProjectName.of(projectId).toString())                       .setInstanceId(instanceId)                       .setInstance(instance)                       .build())               .get();       System.out.printf("Instance %s was successfully created%n", createdInstance.getName());     } catch (ExecutionException e) {       System.out.printf(           "Error: Creating instance %s failed with error message %s%n",           instance.getName(), e.getMessage());     } catch (InterruptedException e) {       System.out.println("Error: Waiting for createInstance operation to finish was interrupted");     }   } }

 // Imports the Google Cloud client library const {Spanner, protos} = require('@google-cloud/spanner');  // Creates a client const spanner = new Spanner({   projectId: projectId, });  const instanceAdminClient = await spanner.getInstanceAdminClient(); /**  * TODO(developer): Uncomment the following lines before running the sample.  **/ // const projectId = 'my-project-id'; // const instanceId = 'my-instance';  // Creates a new instance try {   console.log(     `Creating instance ${instanceAdminClient.instancePath(       projectId,       instanceId,     )}.`,   );   const [operation] = await instanceAdminClient.createInstance({     instanceId: instanceId,     parent: instanceAdminClient.projectPath(projectId),     instance: {       config: instanceAdminClient.instanceConfigPath(         projectId,         'regional-us-central1',       ),       nodeCount: 1,       displayName: 'Display name for the instance.',       labels: {         cloud_spanner_samples: 'true',         created: Math.round(Date.now() / 1000).toString(), // current time       },       edition:         protos.google.spanner.admin.instance.v1.Instance.Edition.STANDARD, //optional     },   });    console.log(`Waiting for operation on ${instanceId} to complete...`);   await operation.promise();    console.log(`Created instance ${instanceId}.`); } catch (err) {   console.error('ERROR:', err); }

// Imports the Google Cloud client library const {Spanner, protos} = require('@google-cloud/spanner');  /**  * TODO(developer): Uncomment the following lines before running the sample.  */ // const projectId = 'my-project-id'; // const instanceId = 'my-instance';  // Creates a client const spanner = new Spanner({   projectId: projectId, });  // Get the instance admin client const instanceAdminClient = spanner.getInstanceAdminClient();  const autoscalingConfig =   protos.google.spanner.admin.instance.v1.AutoscalingConfig.create({     // Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.     autoscalingLimits:       protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.create(         {           minNodes: 1,           maxNodes: 2,         },       ),     // highPriorityCpuUtilizationPercent and storageUtilizationPercent are both     // percentages and must lie between 0 and 100.     autoscalingTargets:       protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.create(         {           highPriorityCpuUtilizationPercent: 65,           storageUtilizationPercent: 95,         },       ),   });  // Creates a new instance with autoscaling configuration // When autoscalingConfig is enabled, nodeCount and processingUnits fields // need not be specified. try {   console.log(     `Creating instance ${instanceAdminClient.instancePath(       projectId,       instanceId,     )}.`,   );   const [operation] = await instanceAdminClient.createInstance({     instanceId: instanceId,     parent: instanceAdminClient.projectPath(projectId),     instance: {       config: instanceAdminClient.instanceConfigPath(         projectId,         'regional-us-central1',       ),       displayName: 'Display name for the instance.',       autoscalingConfig: autoscalingConfig,       labels: {         cloud_spanner_samples: 'true',         created: Math.round(Date.now() / 1000).toString(), // current time       },       // Managed autoscaler is available only for ENTERPRISE edition       edition:         protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE,     },   });    console.log(`Waiting for operation on ${instanceId} to complete...`);   await operation.promise();   console.log(`Created instance ${instanceId}.`);    // get instance metadata   const [metadata] = await instanceAdminClient.getInstance({     name: instanceAdminClient.instancePath(projectId, instanceId),   });   console.log(     `Autoscaling configurations of ${instanceId} are:  ` +       '\n' +       `Min nodes: ${metadata.autoscalingConfig.autoscalingLimits.minNodes} ` +       'nodes.' +       '\n' +       `Max nodes: ${metadata.autoscalingConfig.autoscalingLimits.maxNodes}` +       ' nodes.' +       '\n' +       `High priority cpu utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.highPriorityCpuUtilizationPercent}.` +       '\n' +       `Storage utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.storageUtilizationPercent}.`,   ); } catch (err) {   console.error('ERROR:', err); }

/**  * TODO(developer): Uncomment the following lines before running the sample.  **/ // const projectId = 'my-project-id'; // const instanceId = 'my-instance';  // Imports the Google Cloud client library const {Spanner, protos} = require('@google-cloud/spanner');  // Creates a client const spanner = new Spanner({   projectId: projectId, });  const instanceAdminClient = await spanner.getInstanceAdminClient(); // Creates a new instance try {   const [operation] = await instanceAdminClient.createInstance({     instanceId: instanceId,     parent: instanceAdminClient.projectPath(projectId),     instance: {       config: instanceAdminClient.instanceConfigPath(         projectId,         'regional-me-central2',       ),       nodeCount: 1,       displayName: 'Display name for the instance.',       labels: {         cloud_spanner_samples: 'true',         created: Math.round(Date.now() / 1000).toString(), // current time       },       defaultBackupScheduleType:         protos.google.spanner.admin.instance.v1.Instance           .DefaultBackupScheduleType.NONE,     },   });   await operation.promise();    console.log(     `Created instance ${instanceId} without default backup schedules.`,   ); } catch (err) {   console.error('ERROR:', err); }

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient; use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceRequest; use Google\Cloud\Spanner\Admin\Instance\V1\Instance;  /**  * Creates an instance.  * Example:  * ```  * create_instance($projectId, $instanceId);  * ```  *  * @param string $projectId  The Spanner project ID.  * @param string $instanceId The Spanner instance ID.  */ function create_instance(string $projectId, string $instanceId): void {     $instanceAdminClient = new InstanceAdminClient();     $parent = InstanceAdminClient::projectName($projectId);     $instanceName = InstanceAdminClient::instanceName($projectId, $instanceId);     $configName = $instanceAdminClient->instanceConfigName($projectId, 'regional-us-central1');     $instance = (new Instance())         ->setName($instanceName)         ->setConfig($configName)         ->setDisplayName('dispName')         ->setNodeCount(1);      $operation = $instanceAdminClient->createInstance(         (new CreateInstanceRequest())         ->setParent($parent)         ->setInstanceId($instanceId)         ->setInstance($instance)     );      print('Waiting for operation to complete...' . PHP_EOL);     $operation->pollUntilComplete();      printf('Created instance %s' . PHP_EOL, $instanceId); }

def create_instance(instance_id):     """Creates an instance."""     from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin      spanner_client = spanner.Client()      config_name = "{}/instanceConfigs/regional-us-central1".format(         spanner_client.project_name     )      operation = spanner_client.instance_admin_api.create_instance(         parent=spanner_client.project_name,         instance_id=instance_id,         instance=spanner_instance_admin.Instance(             config=config_name,             display_name="This is a display name.",             node_count=1,             labels={                 "cloud_spanner_samples": "true",                 "sample_name": "snippets-create_instance-explicit",                 "created": str(int(time.time())),             },             edition=spanner_instance_admin.Instance.Edition.STANDARD,  # Optional         ),     )      print("Waiting for operation to complete...")     operation.result(OPERATION_TIMEOUT_SECONDS)      print("Created instance {}".format(instance_id))  

def create_instance_with_autoscaling_config(instance_id):     """Creates a Cloud Spanner instance with an autoscaling configuration."""     from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin      spanner_client = spanner.Client()      config_name = "{}/instanceConfigs/regional-us-central1".format(         spanner_client.project_name     )      autoscaling_config = spanner_instance_admin.AutoscalingConfig(         # Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.         autoscaling_limits=spanner_instance_admin.AutoscalingConfig.AutoscalingLimits(             min_nodes=1,             max_nodes=2,         ),         # highPriorityCpuUtilizationPercent and storageUtilizationPercent are both         # percentages and must lie between 0 and 100.         autoscaling_targets=spanner_instance_admin.AutoscalingConfig.AutoscalingTargets(             high_priority_cpu_utilization_percent=65,             storage_utilization_percent=95,         ),     )      #  Creates a new instance with autoscaling configuration     #  When autoscalingConfig is enabled, nodeCount and processingUnits fields     #  need not be specified.     request = spanner_instance_admin.CreateInstanceRequest(         parent=spanner_client.project_name,         instance_id=instance_id,         instance=spanner_instance_admin.Instance(             config=config_name,             display_name="This is a display name.",             autoscaling_config=autoscaling_config,             labels={                 "cloud_spanner_samples": "true",                 "sample_name": "snippets-create_instance_with_autoscaling_config",                 "created": str(int(time.time())),             },             edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional         ),     )      operation = spanner_client.instance_admin_api.create_instance(request=request)      print("Waiting for operation to complete...")     instance = operation.result(OPERATION_TIMEOUT_SECONDS)      print(         "Created instance {} with {} autoscaling config".format(             instance_id, instance.autoscaling_config         )     )  

def create_instance_without_default_backup_schedules(instance_id):     spanner_client = spanner.Client()     config_name = "{}/instanceConfigs/regional-me-central2".format(         spanner_client.project_name     )      operation = spanner_client.instance_admin_api.create_instance(         parent=spanner_client.project_name,         instance_id=instance_id,         instance=spanner_instance_admin.Instance(             config=config_name,             display_name="This is a display name.",             node_count=1,             default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.NONE,  # Optional         ),     )      print("Waiting for operation to complete...")     operation.result(OPERATION_TIMEOUT_SECONDS)      print("Created instance {} without default backup schedules".format(instance_id))  

# project_id  = "Your Google Cloud project ID" # instance_id = "Your Spanner instance ID" # instance_config_id = "Your Spanner InstanceConfig 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 instance_path = instance_admin_client.instance_path project: project_id, instance: instance_id instance_config_path = instance_admin_client.instance_config_path project: project_id, instance_config: instance_config_id  job = instance_admin_client.create_instance parent: project_path,                                             instance_id: instance_id,                                             instance: { name: instance_path,                                                         config: instance_config_path,                                                         display_name: instance_id,                                                         node_count: 2,                                                         labels: { cloud_spanner_samples: "true" } }  puts "Waiting for create instance operation to complete"  job.wait_until_done!  if job.error?   puts job.error else   puts "Created instance #{instance_id}" end

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/genproto/protobuf/field_mask" )  func updateInstance(w io.Writer, projectID, instanceID string) error { 	// projectID := "my-project-id" 	// instanceID := "my-instance" 	ctx := context.Background() 	instanceAdmin, err := instance.NewInstanceAdminClient(ctx) 	if err != nil { 		return err 	} 	defer instanceAdmin.Close()  	req := &instancepb.UpdateInstanceRequest{ 		Instance: &instancepb.Instance{ 			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), 			// The edition selected for this instance. 			// Different editions provide different capabilities at different price points. 			// For more information, see https://cloud.google.com/spanner/docs/editions-overview. 			Edition: instancepb.Instance_ENTERPRISE, 		}, 		FieldMask: &field_mask.FieldMask{ 			Paths: []string{"edition"}, 		}, 	} 	op, err := instanceAdmin.UpdateInstance(ctx, req) 	if err != nil { 		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err) 	} 	// Wait for the instance update to finish. 	_, err = op.Wait(ctx) 	if err != nil { 		return fmt.Errorf("waiting for instance update to finish failed: %w", err) 	}  	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID) 	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.Lists; import com.google.protobuf.FieldMask; import com.google.spanner.admin.instance.v1.Instance; import com.google.spanner.admin.instance.v1.InstanceConfigName; import com.google.spanner.admin.instance.v1.InstanceName; import com.google.spanner.admin.instance.v1.UpdateInstanceRequest; import java.util.concurrent.ExecutionException;  public class UpdateInstanceExample {    static void updateInstance() {     // TODO(developer): Replace these variables before running the sample.     String projectId = "my-project";     String instanceId = "my-instance";     updateInstance(projectId, instanceId);   }    static void updateInstance(String projectId, String instanceId) {     // Set Instance configuration.     int nodeCount = 2;     String displayName = "Updated name";      // Update an Instance object that will be used to update the instance.     Instance instance =         Instance.newBuilder()             .setName(InstanceName.of(projectId, instanceId).toString())             .setDisplayName(displayName)             .setNodeCount(nodeCount)             .setEdition(Instance.Edition.ENTERPRISE)             .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())             .build();      try (Spanner spanner =             SpannerOptions.newBuilder().setProjectId(projectId).build().getService();         InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {        // Wait for the updatedInstance operation to finish.       Instance updatedInstance =           instanceAdminClient               .updateInstanceAsync(                   UpdateInstanceRequest.newBuilder()                       .setFieldMask(                           FieldMask.newBuilder().addAllPaths(Lists.newArrayList("edition")))                       .setInstance(instance)                       .build())               .get();       System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());     } catch (ExecutionException e) {       System.out.printf(           "Error: Updating instance %s failed with error message %s%n",           instance.getName(), e.getMessage());     } catch (InterruptedException e) {       System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");     }   } } 

 // Imports the Google Cloud client library const {Spanner, protos} = require('@google-cloud/spanner');  /**  * TODO(developer): Uncomment the following lines before running the sample.  */ // const projectId = 'my-project-id'; // const instanceId = 'my-instance';  // Creates a client const spanner = new Spanner({   projectId: projectId, });  const instanceAdminClient = spanner.getInstanceAdminClient();  // Updates an instance try {   console.log(     `Updating instance ${instanceAdminClient.instancePath(       projectId,       instanceId,     )}.`,   );   const [operation] = await instanceAdminClient.updateInstance({     instance: {       name: instanceAdminClient.instancePath(projectId, instanceId),       labels: {         updated: 'true',         created: Math.round(Date.now() / 1000).toString(), // current time       },       edition:         protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE, //optional     },     // Field mask specifying fields that should get updated in an Instance     fieldMask: (protos.google.protobuf.FieldMask = {       paths: ['labels', 'edition'],     }),   });    console.log(`Waiting for operation on ${instanceId} to complete...`);   await operation.promise();   console.log(`Updated instance ${instanceId}.`);   const [metadata] = await instanceAdminClient.getInstance({     name: instanceAdminClient.instancePath(projectId, instanceId),   });   console.log(     `Instance ${instanceId} has been updated with the ${metadata.edition} ` +       'edition.',   ); } catch (err) {   console.error('ERROR:', err); }

def update_instance(instance_id):     """Updates an instance."""     from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin      spanner_client = spanner.Client()      name = "{}/instances/{}".format(spanner_client.project_name, instance_id)      operation = spanner_client.instance_admin_api.update_instance(         instance=spanner_instance_admin.Instance(             name=name,             labels={                 "sample_name": "snippets-update_instance-explicit",             },             edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional         ),         field_mask=field_mask_pb2.FieldMask(paths=["labels", "edition"]),     )      print("Waiting for operation to complete...")     operation.result(900)      print("Updated instance {}".format(instance_id))  

 using Google.Cloud.Spanner.Admin.Instance.V1; using Google.Cloud.Spanner.Common.V1; using Google.LongRunning; using Google.Protobuf.WellKnownTypes; using System; using System.Threading.Tasks;  public class UpdateInstanceDefaultBackupScheduleTypeAsyncSample {     public async Task<Instance> UpdateInstanceDefaultBackupScheduleTypeAsync(string projectId, string instanceId)     {         // Create the InstanceAdminClient instance.         InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();          // Initialize request parameters.         Instance instance = new Instance         {             InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),             DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.Automatic,         };         FieldMask mask = new FieldMask          {             Paths = { "default_backup_schedule_type" }         };          // Make the CreateInstance request.         Operation<Instance, UpdateInstanceMetadata> response =             await instanceAdminClient.UpdateInstanceAsync(instance, mask);          Console.WriteLine("Waiting for the operation to finish.");          // Poll until the returned long-running operation is complete.         Operation<Instance, UpdateInstanceMetadata> completedResponse =             await response.PollUntilCompletedAsync();          if (completedResponse.IsFaulted)         {             Console.WriteLine($"Error while updating instance: {completedResponse.Exception}");             throw completedResponse.Exception;         }          Console.WriteLine($"Instance updated successfully.");         return completedResponse.Result;     } }