创建和管理实例

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

注意 ：如需使用 90 天的免费试用实例探索 Spanner，请执行以下操作： 请参阅 创建一个 Spanner 免费试用实例。

创建实例

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

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

控制台

1. 前往 Google Cloud 控制台中的创建实例页面。

   创建实例

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

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

4. 点击继续。

5. 在配置实例部分的下方 选择配置，选择区域级、双区域或 多区域。或者，如果您想将 然后点击 比较区域配置。

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

7. 可选：向 Spanner 基础添加只读副本 配置，首先使用 Google Cloud CLI。

8. 点击继续。

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

   • 处理单元，适用于小型实例。
   • 节点（适用于大型实例）。一个节点是 1,000 个处理单元。

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

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

    • 手动分配（如果要手动设置计算容量） 固定计算资源和费用

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

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

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

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

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：实例的计算容量。 处理单元数最多可输入 1,000 的数量 为 100 的倍数（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%如需了解详情，请参阅 确定存储空间利用率目标。

使用自定义配置的示例

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

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

在自定义多区域位置 custom-eur6-instance 创建实例 实例配置 custom-eur6，第一个 创建自定义实例配置。

然后运行以下命令：

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

<ph type="x-smartling-placeholder">

</ph> 注意：适用于 Java 的旧版客户端库接口代码示例归档在 GitHub。

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

<ph type="x-smartling-placeholder">

</ph> 注意：适用于 Node.js 的旧版客户端库接口代码示例归档在 GitHub。

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

<ph type="x-smartling-placeholder">

</ph> 注意：适用于 PHP 的旧版客户端库接口代码示例归档在 GitHub。

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

<ph type="x-smartling-placeholder">

</ph> 注意：适用于 Python 的旧版客户端库接口代码示例归档在 GitHub。

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。

在少数情况下，您无法减少 现有实例：

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

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

移除计算容量时，请监控 CPU 利用率和请求 Cloud Monitoring 中的延迟时间，以确保 CPU 区域级的利用率保持在 65% 以下 每个区域各占 45% 多区域实例您的请求数量可能会暂时增加 同时降低计算容量时所需的延迟。

如果要增加实例的计算容量， Google Cloud 项目必须具有足够的配额才能添加计算 容量。完成增加请求所需的时间取决于 请求的大小在大多数情况下，请求会在几分钟内完成。已开启 在极少数情况下，纵向扩容最长可能需要一个小时才能完成。

控制台

1. 前往 Google Cloud 控制台中的 Spanner 实例页面。

   转到“实例”页面

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

3. 点击修改实例。

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

5. 点击保存。

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

gcloud

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

gcloud spanner instances update INSTANCE_ID --nodes=NODE_COUNT
[--async]

或

gcloud spanner instances update INSTANCE_ID
--processing-units=PROCESSING_UNIT_COUNT [--async]

替换以下内容：

• INSTANCE_ID：实例的永久性标识符。
• NODE_COUNT：实例的计算容量，表示为 节点数量每个节点等于 1000 个处理单元。
• PROCESSING_UNIT_COUNT：实例的计算容量。 处理单元数最多可输入 1,000 的数量 为 100 的倍数（100、200、300 等），然后输入大于 是 1000 的倍数（1000、2000、3000 等）。

可选标志：

• --async：如果您希望立即返回请求，请使用此标志。 而无需等待正在进行的操作完成。您可以查看 通过运行 gcloud spanner operations describe.

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

预览 — 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 INSTANCE_ID \
    --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 INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

替换以下内容：

• INSTANCE_ID：实例的永久性标识符。
• 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 test-instance \
     --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 INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

或

  gcloud beta spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

替换以下内容：

• INSTANCE_ID：实例的永久性标识符。
• NODE_COUNT：实例的计算容量，表示为 节点数量每个节点等于 1000 个处理单元。
• PROCESSING_UNIT_COUNT：实例的计算容量。 处理单元数最多可输入 1,000 的数量 为 100 的倍数（100、200、300 等），然后输入大于 是 1000 的倍数（1000、2000、3000 等）。

为实例添加标签

标签可帮助您整理资源。

控制台

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 架构。