建立及管理執行個體

本頁說明如何建立、列出、編輯與刪除 Spanner 執行個體。

注意： 如要透過 90 天的免費試用執行個體探索 Spanner，請參閱「 建立 Spanner 免費試用執行個體」。

建立執行個體

您可以使用 Google Cloud 控制台、Google Cloud CLI 或用戶端程式庫建立執行個體。您也可以新增選用的唯讀備用資源，建立自訂執行個體設定的執行個體。

注意： 您不需要在 Spanner 中提供儲存空間，而且只需要為您實際使用的儲存空間計費。進一步瞭解儲存空間定價。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

2. 點選「建立執行個體」。

   前往「建立執行個體」

3. 在「選取版本」部分，選取 Spanner 版本。

   如要比較不同版本的規格，請按一下「比較版本」。詳情請參閱「Spanner 版本總覽」。

4. 按一下「繼續」。

5. 在「為執行個體命名」部分，輸入要在 Google Cloud 控制台中顯示的「執行個體名稱」。執行個體名稱在 Google Cloud 專案中不得重複。

6. 輸入可永久識別執行個體的執行個體 ID。 Google Cloud 專案中的執行個體 ID 也不得重複。執行個體 ID 設定後即無法變更。

7. 按一下「繼續」。

8. 在「設定執行個體」部分中，選取「選擇設定」下方的「區域」、「雙區域」或「多區域」。

   注意： 雙區域和多區域執行個體設定僅適用於 Enterprise Plus 版本。如要比較三種設定的規格，請按一下「比較地區設定」。

9. 從下拉式選單中選取設定位置。

10. 選用步驟：如要為 Spanner 基礎設定新增唯讀備用資源，請先使用 Google Cloud CLI 建立自訂執行個體設定。在基本設定中新增選用的唯讀副本，適用於 Enterprise 和 Enterprise Plus 版本。

11. 按一下「繼續」。

12. 在「Allocate compute capacity」(配置運算容量) 部分的「Select unit」(選取單位) 下方，按一下下列其中一個選項：

    • 大型執行個體的「Nodes」(節點)。一個節點等於 1,000 個處理單元。
    • 小型執行個體的處理單元。

    詳情請參閱「運算資源、節點和處理單元」。

13. 在「選擇資源調度模式」下方，按一下下列其中一個選項：

    • 如要手動設定運算能力，取得定量的運算資源並支付定額費用，請選擇「手動分配」。

      • 「數量」表示要用於這個執行個體的處理單元或節點數量。

    • 自動調度資源，讓 Spanner 自動增減運算能力。代管式自動配置器適用於 Spanner Enterprise 版和 Enterprise Plus 版。如要進一步瞭解代管自動調度資源功能，請參閱「Spanner 的代管自動調度資源功能」。設定下列代管自動調度資源選項：

      • 「最低」表示縮減的下限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷最低限制」。
      • 「上限」表示擴充上限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷上限」。
      • 「高優先順序 CPU 使用率目標」表示要使用的高優先順序 CPU 目標百分比。詳情請參閱「判斷 CPU 使用率目標」。
      • 「儲存空間使用率目標」表示要使用的儲存空間目標百分比。詳情請參閱判斷儲存空間使用率目標。

14. 選用：如果選取「自動調度資源」做為調度模式，可以點按「顯示非對稱自動調度資源選項」下拉式選單，獨立自動調度唯讀副本的資源，與其他副本分開。詳情請參閱「非對稱唯讀自動調度資源模式」。

    1. 選取要以非對稱方式自動調度資源的唯讀副本。

    2. 設定下列非對稱自動調度資源選項：

       • 「最低」表示縮減的下限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷最低限制」。
       • 「上限」表示擴充上限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷上限」。
       • 「高優先順序 CPU 使用率目標」表示要使用的高優先順序 CPU 目標百分比。詳情請參閱「判斷 CPU 使用率目標」。

15. 在「備份」下方，預設會勾選「啟用預設備份排程」核取方塊。如要停用預設備份排程，請取消勾選核取方塊。啟用這項設定後，系統會每 24 小時為執行個體中的所有新資料庫建立完整備份。備份會保留 7 天。 您隨時可以編輯或刪除預設備份排程。詳情請參閱「預設備份時間表」。

16. 按一下「建立」，建立執行個體。

gcloud

使用 gcloud spanner instances create 指令建立執行個體。指定執行個體所需的節點或處理單元數量，做為運算資源。

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--nodes=NODE_COUNT

或

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--processing-units=PROCESSING_UNIT_COUNT

更改下列內容：

• INSTANCE-ID：專案中唯一的永久 ID。 Google Cloud 執行個體 ID 設定後即無法變更。
• INSTANCE-CONFIG：執行個體設定的永久 ID，可定義執行個體的地理位置，並影響資料複製方式。如要自訂執行個體設定，請從 custom- 開始。詳情請參閱執行個體設定。
• INSTANCE_DESCRIPTION：顯示於 Google Cloud 控制台的執行個體名稱。執行個體名稱在Google Cloud 專案中不得重複。

• DEFAULT_BACKUP_SCHEDULE_TYPE：執行個體中使用的預設備份排程類型。必須是下列其中一個值：

  • AUTOMATIC：在執行個體中建立新資料庫時，系統會自動建立預設備份排程。預設備份排程會每 24 小時建立一次完整備份，這些完整備份會保留 7 天。建立預設備份排程之後，您可以加以編輯或刪除。
  • NONE：在執行個體中建立新資料庫時，系統不會自動建立預設備份排程。

• NODE-COUNT：執行個體的運算能力，以節點數表示。每個節點等於 1000 個處理單元。

• PROCESSING_UNIT_COUNT：執行個體的運算資源，以處理單元數量表示。輸入數量時，1000 以下請以 100 為單位 (100、200、300 等)，超過則以 1000 為單位 (1000、2000、3000 等)。注意： 如果您要建立的執行個體稍後會啟用代管自動調度器，請勿使用這個參數。

新增代管式自動調度資源

您也可以建立 Enterprise 版和 Enterprise Plus 版執行個體，搭配 gcloud spanner instances create 指令使用自動調度資源功能。詳情請參閱「Spanner 的自動調度管理工具」。

使用下列指令建立具有代管自動調度器的執行個體。

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --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 \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

或

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --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 \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

更改下列內容：

• INSTANCE-ID：專案中唯一的永久 ID。 Google Cloud 執行個體 ID 設定後即無法變更。
• INSTANCE-CONFIG：執行個體設定的永久 ID，可定義執行個體的地理位置，並影響資料複製方式。如要自訂執行個體設定，請從 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%。詳情請參閱判斷儲存空間使用率目標。

選用標記：

• --asymmetric-autoscaling-option：使用這個旗標啟用非對稱自動調度資源。替換下列參數：

  • ASYMMETRIC_AUTOSCALING_LOCATION：如果使用這個旗標，就必須提供這個參數。要以非對稱方式調度資源的唯讀區域位置。
  • ASYMMETRIC_AUTOSCALING_MIN：選用參數。調降資源配置時的節點數量下限。
  • ASYMMETRIC_AUTOSCALING_MAX：選用參數。擴充時的節點數量上限。
  • ASYMMETRIC_CPU_TARGET：選用參數。高優先順序 CPU 使用率目標百分比，範圍為 10% 至 90%。如果以成本為目標進行最佳化，請使用較高的百分比。

使用自訂設定的範例

如要在基本區域執行個體設定 us-central1 中建立執行個體 test-instance，請執行下列指令：

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

如要在自訂多區域執行個體設定 custom-eur6 中建立執行個體 custom-eur6-instance，請先建立自訂執行個體設定。

接著執行：

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

執行上述任一指令後，畫面會顯示類似以下的訊息：

Creating instance...done.

C++

如要瞭解如何安裝及使用 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 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

Go

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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
}

使用 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"},
			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
}

使用 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"
)

// 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
}

Java

如要瞭解如何安裝及使用 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)
            .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");
    }
  }
}

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

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

Node.js

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

注意：Node.js 的舊版用戶端程式庫介面程式碼範例已封存至 GitHub。

使用 Node.js 建立執行個體並啟用自動調度資源功能

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

PHP

如要瞭解如何安裝及使用 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);
}

注意：舊版 PHP 用戶端程式庫介面程式碼範例已封存於 GitHub。

Python

如要瞭解如何安裝及使用 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())),
            },
            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))

注意：舊版 Python 用戶端程式庫介面的程式碼範例已封存至 GitHub。

使用 Python 建立具有代管自動調度資源功能的執行個體

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

Ruby

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

# 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

列出執行個體

您可以顯示 Spanner 執行個體清單。

控制台

前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

前往「Instances」(執行個體) 頁面

Google Cloud 控制台隨即會顯示 Spanner 執行個體清單，以及每個執行個體的 ID、顯示名稱、設定和運算容量 (以處理單元和節點表示)。

gcloud

使用 gcloud spanner instances list 指令：

gcloud spanner instances list

gcloud CLI 會輸出 Spanner 執行個體清單，以及每個執行個體的 ID、顯示名稱、設定和運算容量。

編輯執行個體

下列各節說明如何升級執行個體的版本，以及變更執行個體的顯示名稱、運算容量和預設備份排程類型。您無法變更執行個體 ID 或執行個體設定 (但可以移動執行個體)。

升級版本

您可以將 Standard 版執行個體升級至更高階的版本。Standard 版執行個體可以升級至 Enterprise 版或 Enterprise Plus 版。Enterprise 版執行個體可以升級至 Enterprise Plus 版。版本升級大約需要 10 分鐘，期間不會停機。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下要升級的執行個體名稱。

3. 按一下版本類型旁的「升級」。

4. 在「Edition instance」(版本執行個體) 頁面中，選取「Update edition」(更新版本) 下方執行個體的新高階版本。

5. 按一下 [儲存]。

gcloud

使用 gcloud spanner instances update 指令升級執行個體的版本：

gcloud spanner instances update INSTANCE_ID --edition=EDITION \
[--async]

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。
• EDITION：為執行個體指定新的較高層級版本。詳情請參閱 Spanner 版本總覽。

選用標記：

• --async：如果希望要求立即傳回，不必等待進行中的作業完成，請使用這個旗標。您可以執行 gcloud spanner operations describe，查看要求狀態。

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

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
}

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

Node.js

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

Python

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

降級版本

您可以將 Spanner 執行個體降級為較低級別的版本。如要降級，請停止使用較高版本的功能。Enterprise 版執行個體可以降級至 Standard 版。Enterprise Plus 版執行個體可以降級為 Enterprise 版或 Standard 版。版本降級作業大約需要 10 分鐘，期間不會有任何停機時間。

gcloud

使用 gcloud spanner instances update 指令將執行個體版本降級：

gcloud spanner instances update INSTANCE_ID --edition=EDITION

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。
• EDITION：為執行個體指定新的低階版本。詳情請參閱 Spanner 版本總覽。

變更顯示名稱

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下您要重新命名的執行個體名稱。

3. 按一下 [Edit instance] (編輯執行個體)。

4. 輸入新執行個體的名稱。此名稱在Google Cloud 專案中不得重複。

5. 按一下 [儲存]。

gcloud

使用 gcloud spanner instances update 指令：

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。
• INSTANCE_NAME：顯示於Google Cloud 控制台中的執行個體名稱。執行個體名稱在Google Cloud 專案中不得重複。

變更運算能力

您必須佈建足夠的運算資源，讓CPU 使用率和儲存空間使用率低於建議最大值。詳情請參閱 Spanner 的配額與限制。

在下列情況下，您無法減少現有執行個體的運算容量：

• 如要移除運算資源，執行個體必須為每 1,000 個處理單元 (1 個節點) 儲存超過 10 TiB 的資料。
• 根據您的歷史用量模式，Spanner 為執行個體資料建立了大量分割，在極少數情況下，移除運算能力後，Spanner 無法管理分割。

在後者情況下，您可以嘗試逐步減少運算資源，直到找出 Spanner 管理所有執行個體分割所需的最低資源量為止。如果使用模式改變，導致執行個體不再需要這麼多分割，Spanner 最終可能會合併部分分割，讓您在一兩週後進一步減少執行個體的運算容量。

移除運算容量時，請在 Cloud Monitoring 中監控 CPU 使用率和要求延遲時間，確保區域執行個體的 CPU 使用率維持在 65% 以下，多區域執行個體中每個區域的 CPU 使用率維持在 45% 以下。移除運算容量時，要求延遲時間可能會暫時增加。

如要增加執行個體的運算容量，您的Google Cloud 專案必須有足夠的配額，才能增加運算容量。增加要求完成所需的時間取決於要求的大小。在大多數情況下，要求會在幾分鐘內完成。在極少數情況下，擴充作業最多可能需要一小時才能完成。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下要變更的執行個體名稱。

3. 按一下 [Edit Instance] (編輯執行個體)。

4. 選擇測量單位 (處理單元或節點)，然後輸入數量，即可變更運算資源。使用處理單元時，請輸入 100 的倍數，上限為 1, 000 (100、200、300 等)，如要輸入更大的數量，請輸入 1,000 的倍數 (1, 000、2, 000、3, 000 等)。每個節點等於 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：執行個體的永久 ID。
• NODE_COUNT：執行個體的運算能力，以節點數量表示。每個節點等於 1000 個處理單元。
• PROCESSING_UNIT_COUNT：執行個體的運算資源，以處理單元數量表示。輸入數量時，1000 以下請以 100 為單位 (100、200、300 等)，超過則以 1000 為單位 (1000、2000、3000 等)。

選用標記：

• --async：如果希望要求立即傳回，不必等待進行中的作業完成，請使用這個旗標。您可以執行 gcloud spanner operations describe，查看要求狀態。

在執行個體上啟用或修改代管自動調度資源

在現有執行個體上新增或變更代管自動調整功能時，有下列限制：

• 受管理自動調度器僅適用於 Enterprise 版或 Enterprise Plus 版。
• 您無法在要遷移的執行個體上啟用代管自動調度器。

• 啟用受管理自動調度資源功能後，您就無法移動執行個體。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下要啟用代管自動調度器的執行個體名稱。

3. 按一下 [Edit instance] (編輯執行個體)。

4. 在「設定運算能力」下方，按一下「自動調度資源」。

5. 在「Minimum」(下限) 中，選取縮減時使用的下限。 詳情請參閱「判斷最低限制」。

6. 在「Maximum」(上限) 中，選取擴充時使用的上限。詳情請參閱「判斷上限」一文。

7. 在「高優先順序 CPU 使用率目標」中，選取要使用的高優先順序 CPU 百分比。詳情請參閱「判斷 CPU 使用率目標」。

8. 在「儲存空間使用率目標」中，選取要使用的儲存空間百分比。詳情請參閱判斷儲存空間使用率目標。

9. 選用：如果選取「自動調度資源」做為調度模式，則可以點選「顯示非對稱自動調度資源選項」下拉式選單，獨立自動調度唯讀副本的資源，與其他副本分開。

   1. 選取要以非對稱方式自動調度資源的唯讀副本。

   2. 設定下列自動配置器選項：

      • 「最低」表示縮減的下限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷最低限制」。
      • 「上限」表示擴充上限，取決於您為「運算容量」選擇的測量單位。詳情請參閱「判斷上限」。
      • 「高優先順序 CPU 使用率目標」表示要使用的高優先順序 CPU 目標百分比。詳情請參閱「判斷 CPU 使用率目標」。

10. 按一下 [儲存]。

gcloud

使用 gcloud spanner instances update 指令，將代管自動調度器新增至執行個體。如要瞭解詳情和限制，請參閱 Google Cloud CLI 標記和限制。

您可以使用下列指令新增受管理自動調整功能：

  gcloud 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 \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

或

  gcloud 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 \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。
• MINIMUM_PROCESSING_UNITS、MINIMUM_NODES：縮減規模時要使用的處理單元或節點數量下限。詳情請參閱「判斷最低限制」。
• MAXIMUM_PROCESSING_UNITS、MAXIMUM_NODES：擴充時使用的處理單元或節點數量上限。詳情請參閱「判斷上限」一文。
• CPU_PERCENTAGE：高優先順序 CPU 的目標使用百分比，範圍為 10% 至 90%。如果您要盡量降低費用，且並非所有要求都需要低延遲，請使用較高的百分比。詳情請參閱判斷 CPU 使用率目標。
• STORAGE_PERCENTAGE：要使用的目標儲存空間百分比，範圍為 10% 至 99%。詳情請參閱判斷儲存空間使用率目標。

選用標記：

• --asymmetric-autoscaling-option：使用這個旗標啟用非對稱自動調度。替換下列參數：

  • ASYMMETRIC_AUTOSCALING_LOCATION：如果使用這個旗標，就必須提供這個參數。要以非對稱方式調度資源的唯讀區域位置。
  • ASYMMETRIC_AUTOSCALING_MIN：選用參數。調降資源配置時的節點數量下限。
  • ASYMMETRIC_AUTOSCALING_MAX：選用參數。擴充時的節點數量上限。
  • ASYMMETRIC_CPU_TARGET：選用參數。高優先順序 CPU 使用率目標百分比，範圍為 10% 至 90%。如果以成本為目標進行最佳化，請使用較高的百分比。

將代管自動調度器新增至執行個體後，您也可以修改代管自動調度器設定。舉例來說，如要將處理單元上限提高至 10000，請執行下列指令：

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

將執行個體從使用代管自動調度器改為手動調度

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下要停用代管自動調度程式的執行個體名稱。

3. 在「選擇資源調度模式」下方，按一下「手動分配」。

4. 按一下 [儲存]。

gcloud

使用 gcloud spanner instances update 指令更新執行個體。

使用下列指令，將執行個體從使用代管自動調度器變更為手動調度：

  gcloud spanner instances update INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

或

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。
• NODE_COUNT：執行個體的運算能力，以節點數表示。每個節點等於 1000 個處理單元。
• PROCESSING_UNIT_COUNT：執行個體的運算資源，以處理單元數量表示。輸入數量時，1000 以下請以 100 為單位 (100、200、300 等)，超過則以 1000 為單位 (1000、2000、3000 等)。

為執行個體加上標籤

標籤能協助您整理資源。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 選取執行個體的核取方塊。資訊面板會顯示在頁面右側。

3. 按一下資訊面板中的「標籤」分頁標籤。然後新增、刪除或更新 Spanner 執行個體的標籤。

編輯預設備份排程類型

所有新執行個體都會自動啟用預設備份時間表。建立執行個體時，您可以啟用或停用執行個體的預設備份排程，也可以稍後編輯執行個體。詳情請參閱「預設備份時間表」。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下要編輯預設備份時間表的執行個體名稱。

3. 按一下 [Edit instance] (編輯執行個體)。

4. 在「備份」下方，勾選「啟用預設備份排程」核取方塊，即可啟用或停用預設備份排程。啟用後，這個執行個體中的所有新資料庫都會建立預設備份排程。

5. 按一下 [儲存]。

gcloud

使用 gcloud spanner instances update 指令編輯預設備份排程類型。

您可以執行下列指令，編輯預設備份排程類型：

  gcloud spanner instances update INSTANCE_ID \
    --default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE

更改下列內容：

• INSTANCE_ID：執行個體的永久 ID。

• DEFAULT_BACKUP_SCHEDULE_TYPE：執行個體中使用的預設備份排程類型。必須是下列其中一個值：

  • AUTOMATIC：在執行個體中建立新資料庫時，系統會自動建立預設備份排程。預設備份排程會每 24 小時建立一次完整備份，這些完整備份會保留 7 天。建立預設備份排程之後，您可以加以編輯或刪除。
  • NONE：在執行個體中建立新資料庫時，系統不會自動建立預設備份排程。

C#

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

Go

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

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

// updateInstanceDefaultBackupScheduleType updates instance default backup schedule type to AUTOMATIC.
// This means a default backup schedule will be created automatically on creation of a database within the instance.
func updateInstanceDefaultBackupScheduleType(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()

	// Updates the default backup schedule type field of an instance.  The field mask is required to
	// indicate which field is being updated.
	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// Controls the default backup behavior for new databases within the instance.
			DefaultBackupScheduleType: instancepb.Instance_AUTOMATIC,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"default_backup_schedule_type"},
		},
	}
	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
}

Java

如要瞭解如何安裝及使用 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.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 UpdateInstanceDefaultBackupScheduleTypeExample {

  static void updateInstanceDefaultBackupScheduleType() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    updateInstanceDefaultBackupScheduleType(projectId, instanceId);
  }

  static void updateInstanceDefaultBackupScheduleType(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)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.AUTOMATIC)
            .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("default_backup_schedule_type")))
                      .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");
    }
  }
}

Node.js

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

/**
 * 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();

// Updates an instance
try {
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.AUTOMATIC, // optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['default_backup_schedule_type'],
    }),
  });

  await operation.promise();
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.defaultBackupScheduleType}` +
      ' default backup schedule type.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

如要瞭解如何安裝及使用 Spanner 的用戶端程式庫，請參閱這篇文章。

如要向 Spanner 進行驗證，請設定應用程式預設憑證。 詳情請參閱「為本機開發環境設定驗證」。

def update_instance_default_backup_schedule_type(instance_id):
    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,
          default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.AUTOMATIC,  # Optional
      ),
      field_mask=field_mask_pb2.FieldMask(
          paths=["default_backup_schedule_type"]
      ),
    )

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

    print("Updated instance {} to have default backup schedules".format(instance_id))

移動執行個體

注意： 您無法移動已啟用代管自動調度資源功能的執行個體。

如要瞭解如何將執行個體從任何執行個體設定移至其他執行個體設定，包括在區域和多區域設定之間移動，請參閱「移動執行個體」。

刪除執行個體

警告： 永久刪除執行個體會移除該執行個體及其所有資料庫。這項操作無法復原。 此外，刪除第一個免費試用執行個體後，您就無法再建立其他免費試用執行個體。每個專案生命週期可建立一個免費試用執行個體。

您可以使用 Google Cloud 控制台或 Google Cloud CLI 刪除執行個體。

如要刪除執行個體，但該執行個體中有一或多個資料庫已啟用防刪除功能，請先停用所有資料庫的防刪除功能，再刪除執行個體。

控制台

1. 前往 Google Cloud 控制台的「Spanner Instances」(Spanner 執行個體) 頁面。

   前往「Instances」(執行個體) 頁面

2. 按一下您要刪除的執行個體名稱。

3. 按一下 [Delete instance] (刪除執行個體)。

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 結構定義。