创建和管理实例

本页面介绍了如何创建、列出、修改和删除 Spanner 实例。

注意 ：如需使用 90 天免费试用实例探索 Spanner，请参阅创建 Spanner 免费试用实例。

创建实例

您可以使用 Google Cloud 控制台、Google Cloud CLI 或客户端库创建实例。您还可以通过添加可选的只读副本来创建具有自定义实例配置的实例。

注意 ：您无需在 Spanner 中预配存储空间，只需为您使用的存储空间付费。详细了解存储价格。

控制台

1. 前往 Google Cloud Console 中的创建实例页面。

   创建实例

2. 输入要在 Google Cloud 控制台中显示的实例名称。此实例名称在您的 Google Cloud 项目中必须是唯一的。

3. 输入实例 ID 以永久标识您的实例。此实例 ID 在您的 Google Cloud 项目中也必须是唯一的。实例 ID 创建后便无法更改。

4. 在选择配置下方，点击单区域或多区域。 或者，如果您想比较两个区域之间的规范，请点击比较区域配置。

5. 从下拉列表中选择一个配置。

6. 可选：添加只读副本以扩缩读取并支持低延迟过时读取。当您使用 Google Cloud 控制台创建只读副本并将其添加到实例配置时，系统会自动创建自定义实例配置。如需添加只读副本，请执行以下操作：

   1. 展开配置只读副本。

   2. 点击添加只读副本。

   3. 选择区域和号码。

7. 在配置计算容量部分的选择单位下，点击以下选项之一：

   • 适用于小型实例的处理单元。
   • 大型实例的节点。一个节点是 1000 个处理单元。

   如需了解详情，请参阅计算容量、节点和处理单元。

8. 在选择伸缩模式下，点击以下选项之一：

   • 手动分配：如果您想为固定的计算资源和费用手动设置计算容量。

     • 数量表示此实例使用的处理单元或节点数。

   • 自动扩缩（预览版），可让 Spanner 自动添加和移除计算容量。如需详细了解代管式自动扩缩器，请参阅 Spanner 的代管式自动扩缩器。配置以下代管式自动扩缩器选项：

     • Minimum 表示要缩容到的最小限制，具体取决于您为计算容量选择的测量单位。如需了解详情，请参阅确定最低限制。
     • 最大值表示纵向扩容到的最大限制，具体取决于您为计算容量选择的测量单位。如需了解详情，请参阅确定上限。
     • 高优先级 CPU 利用率目标表示要使用的高优先级 CPU 的目标百分比。如需了解详情，请参阅确定 CPU 利用率目标。
     • 存储空间利用率目标表示要使用的存储空间的目标百分比。如需了解详情，请参阅确定存储空间利用率目标。

9. 点击创建以创建实例。

gcloud

使用 gcloud spanner instances create 命令创建实例。将计算容量指定为实例所需的节点或处理单元数量。

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--nodes=NODE-COUNT

或

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--processing-units=PROCESSING-UNIT-COUNT

替换以下内容：

• INSTANCE-ID：您的 Google Cloud 项目中唯一的永久标识符。实例 ID 创建后便无法更改。
• INSTANCE-CONFIG：实例配置的永久性标识符，用于定义实例的地理位置并影响数据的复制方式。对于自定义实例配置，它以 custom- 开头。如需了解详情，请参阅实例配置。
• INSTANCE-DESCRIPTION：实例在 Google Cloud 控制台中显示的名称。此实例名称在您的 Google Cloud 项目中必须是唯一的。

• NODE-COUNT：实例的计算容量，表示为节点数。每个节点等于 1000 个处理单元。

• PROCESSING-UNIT-COUNT：实例的计算容量，以处理单元数表示。输入数量不超过 1000 的倍数（100、200、300 等），然后输入 1000 的倍数（1000、2000、3000 等）。注意：如果您要创建稍后打算使用代管式自动扩缩器启用的实例，请勿使用此参数。

添加代管式自动扩缩（预览版）

您还可以通过 gcloud beta spanner instances create 命令将新实例配置为使用代管式自动扩缩。如需了解详情，请参阅 Spanner 的代管式自动扩缩器。

使用以下命令创建具有代管式自动扩缩器的实例。

  gcloud beta spanner instances create INSTANCE-ID \
    --config=INSTANCE-CONFIG \
    --description=INSTANCE-DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

或

  gcloud beta spanner instances create INSTANCE-ID \
    --config=INSTANCE-CONFIG \
    --description=INSTANCE-DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

替换以下内容：

• INSTANCE-ID：您的 Google Cloud 项目中唯一的永久标识符。实例 ID 创建后便无法更改。
• INSTANCE-CONFIG：实例配置的永久性标识符，用于定义实例的地理位置并影响数据的复制方式。对于自定义实例配置，它以 custom- 开头。如需了解详情，请参阅实例配置。
• INSTANCE-DESCRIPTION：实例在 Google Cloud 控制台中显示的名称。此实例名称在您的 Google Cloud 项目中必须是唯一的。
• MINIMUM_PROCESSING_UNITS、MINIMUM_NODES：缩减时的处理单元或节点数下限。如需了解详情，请参阅确定最低限制。
• MAXIMUM_PROCESSING_UNITS、MAXIMUM_NODES：纵向扩容时处理单元或节点的最大数量。如需了解详情，请参阅确定上限。
• CPU_PERCENTAGE：要使用的高优先级 CPU 的目标百分比，介于 10 到 90% 之间。如果您要针对费用进行优化，请使用较高的百分比。如需了解详情，请参阅确定 CPU 利用率目标。
• STORAGE_PERCENTAGE：要使用的存储空间的目标百分比，介于 10 到 99% 之间。如需了解详情，请参阅确定存储空间利用率目标。

使用自定义配置的示例

如需在基础区域实例配置 us-central1 中创建实例 test-instance，请运行以下命令：

gcloud spanner instances create test-instance --config=regional-us-central1 \
  --description="Test Instance" --nodes=1

如需在自定义多区域实例配置 custom-eur6 中创建实例 custom-eur6-instance，请先创建自定义实例配置。

然后运行以下命令：

  gcloud spanner instances create custom-eur6-instance --config=custom-eur6 \
      --description="Instance with custom read-only" --nodes=1

运行上述任一命令后，您应该会看到类似于以下示例的消息：

Creating instance...done.

C++

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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();
}

C#

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;

public class CreateInstanceSample
{
    public Instance CreateInstance(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();

        // 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" },
            }
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response = instanceAdminClient.CreateInstance(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse = response.PollUntilCompleted();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance created successfully.");

        return completedResponse.Result;
    }
}

Go

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	instancepb "google.golang.org/genproto/googleapis/spanner/admin/instance/v1"
)

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"},
		},
	})
	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
}

使用 Go 创建具有代管式自动扩缩的实例（预览版）

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"},
		},
	})
	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
}

Java

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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)
            .setNodeCount(nodeCount)
            .setConfig(
                InstanceConfigName.of(projectId, "regional-us-central1").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");
    }
  }
}

注意：GitHub 中归档了适用于 Java 的旧版客户端库接口代码示例。

使用 Java 创建具有代管式自动扩缩的实例（预览版）

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 java.util.concurrent.ExecutionException;

class CreateInstanceWithAutoscalingConfigExample {

  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 = "regional-us-central1";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .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("Autoscaler 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");
      }
    }
  }
}

Node.js

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

// Imports the Google Cloud client library
const {Spanner} = 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
      },
    },
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();

  console.log(`Created instance ${instanceId}.`);
} catch (err) {
  console.error('ERROR:', err);
}

注意：GitHub 中归档了 Node.js 的旧版客户端库接口代码示例。

PHP

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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);
}

注意：GitHub 中归档了适用于 PHP 的旧版客户端库接口代码示例。

Python

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

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())),
            },
        ),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Created instance {}".format(instance_id))

注意：GitHub 中归档了适用于 Python 的旧版客户端库界面代码示例。

Ruby

如需了解如何安装和使用 Spanner 客户端库，请参阅 Spanner 客户端库。

如需向 Spanner 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance 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: "regional-us-central1"

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

列出实例

您可以显示 Spanner 实例列表。

控制台

转到 Google Cloud 控制台中的 Spanner 实例页面。

转到“实例”页面

Google Cloud 控制台会显示 Spanner 实例列表，以及每个实例的 ID、显示名称、配置和计算容量（以处理单元和节点表示）。

gcloud

使用 gcloud spanner instances list 命令：

gcloud spanner instances list

gcloud CLI 会输出 Spanner 实例的列表，以及每个实例的 ID、显示名称、配置和计算容量。

修改实例

以下部分介绍了如何更改实例的显示名和计算容量。您无法更改实例 ID 或实例配置。

更改显示名称

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 点击您要重命名的实例的名称。

3. 点击修改实例。

4. 输入新的实例名称。此名称在 Google Cloud 项目中必须是唯一的。

5. 点击保存。

gcloud

使用 gcloud spanner instances update 命令：

gcloud spanner instances update INSTANCE-ID --description=INSTANCE-NAME

替换以下内容：

• INSTANCE-ID：实例的永久标识符。
• INSTANCE-NAME：实例在 Google Cloud 控制台中显示的名称。此实例名称在您的 Google Cloud 项目中必须是唯一的。

更改计算容量

您必须预配足够的计算容量，使 CPU 利用率和存储空间利用率低于建议的最大值。如需了解详情，请参阅 Spanner 的配额和限制。

在以下几种情况下，您无法减少现有实例的计算容量：

• 移除计算容量需要您的实例每 1,000 个处理单元（1 个节点）存储超过 4 TB 的数据。
• 根据您的历史使用模式，Spanner 已为实例数据创建了大量分片，在极少数情况下，Spanner 移除计算容量后将无法管理分片。

在后一种情况下，您可以尝试逐步减少计算容量，直到找到 Spanner 管理所有实例拆分所需的最小容量。如果由于使用模式的变化，实例不再需要如此多的分片，则 Spanner 最终可能会将一些分片合并在一起，并允许您在一两周后尝试进一步减少实例的计算容量。

移除计算容量时，请在 Cloud Monitoring 中监控 CPU 利用率和请求延迟时间，以确保单区域实例的 CPU 利用率保持在 65% 以下，多区域实例中每个区域的 CPU 利用率保持在 45% 以下。在移除计算容量时，您可能会遇到请求延迟时间暂时增加的情况。

如果要增加实例的计算容量，您的 Google Cloud 项目必须具有足够的配额来增加计算容量。

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 点击要更改的实例名称。

3. 点击修改实例。

4. 选择测量单位（处理单元或节点），然后输入数量，从而更改计算容量。使用处理单元时，请输入不超过 1000 的数量（100、200、300 等），然后输入 1000 的倍数（1000、2000、3000 等）。每个节点等于 1000 个处理单元。

5. 点击保存。

如果系统对话框提示此位置没有足够的配额来添加计算容量，请按照说明请求更高配额。

gcloud

使用 gcloud spanner instances update 命令。使用此命令时，请将计算容量指定为节点或处理单元的数量。

gcloud spanner instances update INSTANCE-ID --nodes=NODE-COUNT

或

gcloud spanner instances update INSTANCE-ID
--processing-units=PROCESSING-UNIT-COUNT

替换以下内容：

• INSTANCE-ID：实例的永久标识符。
• NODE-COUNT：实例的计算容量，表示为节点数。每个节点等于 1000 个处理单元。
• PROCESSING-UNIT-COUNT：实例的计算容量，以处理单元数表示。输入数量不超过 1000 的倍数（100、200、300 等），然后输入 1000 的倍数（1000、2000、3000 等）。

在实例上启用或修改代管式自动扩缩器

预览 — Managed autoscaler

此功能须遵守服务专用条款的“通用服务条款”部分中的“非正式版产品条款”。 非正式版功能“按原样”提供，可能只能获得有限的支持。 如需了解详情，请参阅发布阶段说明。

在现有实例上添加或更改代管式自动扩缩功能时，存在以下限制：

• 您无法在要移动的实例上启用代管式自动扩缩器。

• 启用代管式自动扩缩器后，您无法移动实例。

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 点击要启用代管式自动扩缩器的实例的名称。

3. 点击修改实例。

4. 在配置计算容量下，点击自动扩缩。

5. 在下限部分，选择纵向伸缩时要使用的最小限制。 如需了解详情，请参阅确定最低限制。

6. 在最大值部分，选择纵向扩容时使用的上限。如需了解详情，请参阅确定上限。

7. 对于高优先级 CPU 利用率目标，选择要使用的高优先级 CPU 的百分比。如需了解详情，请参阅确定 CPU 利用率目标。

8. 对于存储空间利用率目标，选择要使用的存储空间百分比。如需了解详情，请参阅确定存储空间利用率目标。

9. 点击保存。

gcloud

使用 gcloud beta spanner instances update 命令将代管式自动扩缩器添加到实例。如需了解详情和限制，请参阅 Google Cloud CLI 标志和限制。

您可以使用以下命令添加代管式自动扩缩器：

  gcloud beta spanner instances update \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

或

  gcloud beta spanner instances update \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

替换以下内容：

• MINIMUM_PROCESSING_UNITS、MINIMUM_NODES：纵向缩容时使用的处理单元或节点数下限。如需了解详情，请参阅确定最低限制。
• MAXIMUM_PROCESSING_UNITS、MAXIMUM_NODES：纵向扩容时使用的处理单元或节点数上限。如需了解详情，请参阅确定上限。
• CPU_PERCENTAGE：要使用的高优先级 CPU 的目标百分比，介于 10% 到 90% 之间。如果您要针对费用进行优化，并且不需要所有请求的延迟时间较短，请使用较高的百分比。如需了解详情，请参阅确定 CPU 利用率目标。
• STORAGE_PERCENTAGE：要使用的存储空间的目标百分比，介于 10% 到 99% 之间。如需了解详情，请参阅确定存储空间利用率目标。

将代管式自动扩缩器添加到实例后，您还可以修改代管式自动扩缩器设置。例如，如果要将处理单元数上限增加到 10,000，请运行以下命令：

gcloud beta spanner instances update \
     --autoscaling-max-processing-units=10000

将实例从使用代管式自动伸缩器更改为手动伸缩

预览 — Managed autoscaling

此功能须遵守服务专用条款的“通用服务条款”部分中的“非正式版产品条款”。 非正式版功能“按原样”提供，可能只能获得有限的支持。 如需了解详情，请参阅发布阶段说明。

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 点击要停用代管式自动扩缩器的实例的名称。

3. 在选择伸缩模式下，点击手动分配。

4. 点击保存。

gcloud

使用 gcloud beta spanner instances update 命令更新实例。

使用以下命令将实例从使用代管式自动伸缩器更改为手动伸缩：

  gcloud beta spanner instances update \
  --processing-units=PROCESSING-UNITS-COUNT

或

  gcloud beta spanner instances update \
  --nodes=NODE-COUNT

将 PROCESSING-UNIT-COUNT 或 NODE-COUNT 替换为您要在实例上使用的处理单元或节点数。

为实例添加标签

标签可帮助您整理资源。

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 选中实例对应的复选框。 页面右侧将显示信息面板。

3. 点击信息面板中的标签标签页。然后，您可以为 Spanner 实例添加、删除或更新标签。

移动实例

注意 ：您无法移动启用了代管式自动扩缩器的实例。

如需了解如何将实例从任何实例配置移至任何其他实例配置，包括在单区域配置和多区域配置之间移动，请参阅移动实例。

删除实例

警告：删除实例将永久移除该实例及其所有数据库。后续无法撤消此操作。此外，删除第一个免费试用实例后，您就无法再创建免费试用实例。您可以针对每个项目生命周期创建一个免费试用实例。

您可以使用 Google Cloud 控制台或 Google Cloud CLI 删除实例。

如果要删除具有一个或多个启用了删除保护的数据库的实例，您必须先对该实例中的所有数据库停用删除保护，然后才能删除该实例。

控制台

1. 转到 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

2. 点击要删除的实例名称。

3. 点击删除实例。

4. 按照说明进行操作，确认您要删除实例。

5. 点击删除。

gcloud

使用 gcloud spanner instances delete 命令，并将 INSTANCE-ID 替换为实例 ID：

gcloud spanner instances delete INSTANCE-ID

停止或重启实例

Spanner 是一项全代管式数据库服务，可监督自己的底层任务和资源，包括在必要时监控和重启进程，且无需停机。由于无需手动停止或重启给定实例，因此 Spanner 不提供执行此操作的方法。

后续步骤

• 了解如何使用数据操纵语言 (DML) 或 gcloud CLI 插入、更新和删除数据。
• 为实例及其数据库授予 Identity and Access Management 角色。
• 了解如何设计 Spanner 架构。