인스턴스 만들기 및 관리

이 페이지에서는 Spanner 인스턴스의 생성, 나열, 수정 및 삭제 방법을 설명합니다.

참고: 90일 무료 체험판 인스턴스를 사용하여 Spanner를 살펴보려면 Spanner 무료 체험판 인스턴스 만들기를 참조하세요.

인스턴스 만들기

Google Cloud 콘솔, Google Cloud CLI 또는 클라이언트 라이브러리를 사용하여 인스턴스를 만들 수 있습니다. 또한 선택적읽기 전용 복제본 값을 추가하여 커스텀 인스턴스 구성으로 인스턴스를 만들 수 있습니다.

참고: Spanner에서 스토리지를 프로비저닝할 필요가 없습니다. 사용하는 스토리지에 대해서만 요금이 청구됩니다. 스토리지 가격 책정에 대해 자세히 알아보세요.

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

2. 인스턴스 만들기를 클릭합니다.

   인스턴스 만들기로 이동

3. 버전 선택 섹션에서 Spanner 버전을 선택합니다.

   여러 버전 간 사양을 비교하려면 버전 비교를 클릭합니다. 자세한 내용은 Spanner 버전 개요를 참조하세요.

4. 계속을 클릭합니다.

5. 인스턴스 이름 지정 섹션에서 Google Cloud 콘솔에 표시할 인스턴스 이름을 입력합니다. 인스턴스 이름은 Google Cloud 프로젝트 내에서 고유해야 합니다.

6. 인스턴스를 영구적으로 식별하는 인스턴스 ID를 입력합니다. 인스턴스 ID도 Google Cloud 프로젝트 내에서 고유해야 합니다. 인스턴스 ID는 나중에 변경할 수 없습니다.

7. 계속을 클릭합니다.

8. 인스턴스 구성 섹션의 구성 선택에서 리전, 이중 리전 또는 멀티 리전을 선택합니다.

   참고: 이중 리전 및 멀티 리전 인스턴스 구성은 Enterprise Plus 버전에서만 사용할 수 있습니다. 3가지 구성의 사양을 비교하려면 리전 구성 비교를 클릭합니다.

9. 드롭다운에서 구성 위치를 선택합니다.

10. 선택사항: 읽기 전용 복제본을 Spanner 기본 구성에 추가하려면 먼저 Google Cloud CLI를 사용하여 커스텀 인스턴스 구성을 만듭니다. 선택적 읽기 전용 복제본을 기본 구성에 추가하는 기능은 Enterprise 버전 및 Enterprise Plus 버전에서 사용할 수 있습니다.

11. 계속을 클릭합니다.

12. 컴퓨팅 용량 할당 섹션의 단위 선택에서 다음 중 하나를 클릭합니다.

    • 작은 인스턴스의 경우 처리 단위
    • 큰 인스턴스의 경우 노드. 노드 하나는 처리 단위 1,000개입니다.

    자세한 내용은 컴퓨팅 용량, 노드, 처리 단위를 참조하세요.

13. 확장 모드 선택에서 다음 중 하나를 클릭합니다.

    • 고정된 컴퓨팅 리소스 및 비용을 위해 컴퓨팅 용량을 수동으로 설정하려면 수동 할당

      • 수량은 이 인스턴스에 사용할 처리 단위 또는 노드 수를 나타냅니다.

    • Spanner가 컴퓨팅 용량을 자동으로 추가 및 삭제하도록 허용하려면 자동 확장(미리보기). 관리형 자동 확장 처리는 Spanner Enterprise 버전 및 Enterprise Plus 버전에서 사용할 수 있습니다. 관리형 자동 확장 처리에 대한 자세한 내용은 Spanner용 관리형 자동 확장 처리를 참조하세요. 다음 관리형 자동 확장 처리 옵션을 구성합니다.

      • 최소는 컴퓨팅 용량에 대해 선택하는 측정 단위에 따라 축소할 최소 한도를 나타냅니다. 자세한 내용은 최소 한도 확인을 참조하세요.
      • 최대는 컴퓨팅 용량에 대해 선택하는 측정 단위에 따라 수직 확장할 최대 한도를 나타냅니다. 자세한 내용은 최대 한도 확인을 참조하세요.
      • 높은 우선순위 CPU 사용률 목표는 사용할 높은 우선순위 CPU의 목표 백분율을 나타냅니다. 자세한 내용은 CPU 사용률 목표 확인을 참조하세요.
      • 스토리지 사용률 목표는 사용할 스토리지의 목표 백분율을 나타냅니다. 자세한 내용은 스토리지 사용률 목표 확인을 참조하세요.

14. 백업에서 기본 백업 일정 사용 설정 체크박스가 기본적으로 선택되어 있습니다. 기본 백업 일정을 사용 중지하려면 체크박스를 선택 해제합니다. 사용 설정하면 인스턴스의 모든 새 데이터베이스에 24시간마다 전체 백업이 생성됩니다. 7일 동안 보관됩니다. 언제든지 기본 백업 일정을 수정하거나 삭제할 수 있습니다. 자세한 내용은 기본 백업 일정을 참고하세요.

15. 만들기를 클릭하여 인스턴스를 만듭니다.

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: Google Cloud 프로젝트 내에서 고유한 영구 식별자입니다. 인스턴스 ID는 나중에 변경할 수 없습니다.
• INSTANCE-CONFIG: 인스턴스의 지리적 위치를 정의하고 데이터 복제 방식에 영향을 주는 인스턴스 구성의 영구 식별자입니다. 커스텀 인스턴스 구성의 경우 custom-로 시작합니다. 자세한 내용은 인스턴스 구성을 참조하세요.
• INSTANCE_DESCRIPTION: Google Cloud 콘솔에 표시되는 인스턴스 이름입니다. 인스턴스 이름은 Google Cloud 프로젝트 내에서 고유해야 합니다.

• DEFAULT_BACKUP_SCHEDULE_TYPE: 인스턴스에서 사용되는 기본 백업 일정 유형입니다. 다음 값 중 하나여야 합니다.

  • AUTOMATIC: 인스턴스에 새 데이터베이스가 생성되면 기본 백업 일정이 자동으로 생성됩니다. 기본 백업 일정은 24시간마다 전체 백업을 생성합니다. 이러한 전체 백업은 7일 동안 보관됩니다. 기본 백업 일정을 만든 후 수정하거나 삭제할 수 있습니다.
  • NONE: 인스턴스에 새 데이터베이스가 생성될 때 기본 백업 일정이 자동으로 생성되지 않습니다.

• NODE-COUNT: 인스턴스의 컴퓨팅 용량으로서 노드 수로 표현됩니다. 노드 1개는 처리 단위 1,000개와 같습니다.

• PROCESSING_UNIT_COUNT: 인스턴스의 컴퓨팅 용량으로서 처리 단위 수로 표현됩니다. 최대 1,000개까지는 100의 배수(100, 200, 300 등)로 수량을 입력하고 더 큰 수량은 1,000의 배수(1000, 2000, 3000 등)로 입력합니다. 참고: 나중에 관리형 자동 확장 처리를 사용해서 사용 설정하려는 인스턴스를 만들 경우에는 이 매개변수를 사용하지 마세요.

관리형 자동 확장 추가(미리보기)

gcloud beta spanner instances create 명령어로 관리형 자동 확장을 사용하도록 Enterprise 버전 및 Enterprise Plus 버전 인스턴스를 만들 수도 있습니다. 자세한 내용은 Spanner의 관리형 자동 확장 처리를 참조하세요.

다음 명령어를 사용하여 관리형 자동 확장 처리로 인스턴스를 만듭니다.

  gcloud beta 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

또는

  gcloud beta 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

다음을 바꿉니다.

• INSTANCE-ID: Google Cloud 프로젝트 내에서 고유한 영구 식별자입니다. 인스턴스 ID는 나중에 변경할 수 없습니다.
• INSTANCE-CONFIG: 인스턴스의 지리적 위치를 정의하고 데이터 복제 방식에 영향을 주는 인스턴스 구성의 영구 식별자입니다. 커스텀 인스턴스 구성의 경우 custom-로 시작합니다. 자세한 내용은 인스턴스 구성을 참조하세요.
• INSTANCE-DESCRIPTION: Google Cloud 콘솔에 표시되는 인스턴스 이름입니다. 인스턴스 이름은 Google Cloud 프로젝트 내에서 고유해야 합니다.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: 축소 시 처리 단위 또는 노드의 최소 개수입니다. 자세한 내용은 최소 한도 확인을 참조하세요.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: 확장 시 처리 단위 또는 노드의 최대 개수입니다. 자세한 내용은 최대 한도 확인을 참조하세요.
• CPU_PERCENTAGE: 사용할 높은 우선순위 CPU의 목표 백분율입니다(10~90%). 비용을 최적화하는 경우 높은 백분율을 사용합니다. 자세한 내용은 CPU 사용률 목표 확인을 참조하세요.
• STORAGE_PERCENTAGE: 사용할 스토리지의 목표 백분율입니다(10~99%). 자세한 내용은 스토리지 사용률 목표 확인을 참조하세요.

커스텀 구성 사용 예시

기본 리전 인스턴스 구성 us-central1에서 test-instance 인스턴스를 만들려면 다음을 실행합니다.

gcloud spanner instances create test-instance --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 클라이언트 라이브러리를 참조하세요.

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;
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 클라이언트 라이브러리를 참조하세요.

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
}

기본 백업 일정이 없는 인스턴스 만들기

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
}

자바

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)
            .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용 이전 클라이언트 라이브러리 인터페이스 코드 샘플은 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-east4";
      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");
      }
    }
  }
}

기본 백업 일정이 없는 인스턴스 만들기

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 클라이언트 라이브러리를 참조하세요.

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에 보관처리됩니다.

기본 백업 일정이 없는 인스턴스 만들기

/**
 * 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 클라이언트 라이브러리를 참조하세요.

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 클라이언트 라이브러리를 참조하세요.

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에 보관처리됩니다.

기본 백업 일정이 없는 인스턴스 만들기

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 클라이언트 라이브러리를 참조하세요.

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 인스턴스 페이지로 이동합니다.

인스턴스 페이지로 이동

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 버전으로 업그레이드할 수 있습니다.

셀프서비스 다운그레이드는 제공되지 않습니다. 인스턴스 버전을 다운그레이드하려면 지원 티켓을 제출합니다. 자세한 내용은 Spanner 버전 FAQ를 참조하세요.

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

2. 업그레이드하려는 인스턴스의 이름을 클릭합니다.

3. 버전 유형 옆에 있는 업그레이드를 클릭합니다.

4. 버전 인스턴스 페이지의 버전 업데이트에서 인스턴스의 새로운 상위 등급 버전을 선택합니다.

5. 저장을 클릭합니다.

gcloud

gcloud spanner instances update 명령어를 사용하여 인스턴스의 버전을 업그레이드합니다.

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

다음을 바꿉니다.

• INSTANCE_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
}

자바

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 클라이언트 라이브러리를 참조하세요.

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 클라이언트 라이브러리를 참조하세요.

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

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

표시 이름 변경

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

2. 이름을 바꿀 인스턴스 이름을 클릭합니다.

3. 인스턴스 수정을 클릭합니다.

4. 새 인스턴스 이름을 입력합니다. 이 이름은 Google Cloud 프로젝트 내에서 고유해야 합니다.

5. 저장을 클릭합니다.

gcloud

gcloud spanner instances update 명령어를 사용합니다.

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

다음을 바꿉니다.

• INSTANCE_ID: 인스턴스의 영구 식별자입니다.
• INSTANCE_NAME: Google Cloud 콘솔에 표시되는 인스턴스 이름입니다. 인스턴스 이름은 Google Cloud 프로젝트 내에서 고유해야 합니다.

컴퓨팅 용량 변경

CPU 사용률 및 스토리지 사용률을 권장 최댓값 아래로 유지할 수 있도록 컴퓨팅 용량을 충분하게 프로비저닝해야 합니다. 자세한 내용은 Spanner의 할당량 및 한도를 참조하세요.

다음과 같이 기존 인스턴스의 컴퓨팅 용량을 줄일 수 없는 몇 가지 경우가 있습니다.

• 컴퓨팅 용량을 삭제하려면 인스턴스에서 처리 단위 1,000개 (노드 1개)당 10TB 이상의 데이터를 저장해야 하는 경우
• 과거 사용량 패턴에 따라 Spanner에서 다수의 인스턴스 데이터 분할을 만들었으며 드물게는 컴퓨팅 용량 삭제 후에 Spanner에서 분할을 관리할 수 없게 되는 경우

후자의 경우 Spanner에서 모든 인스턴스 분할을 관리하는 데 필요한 최소 용량을 확보할 때까지 컴퓨팅 용량을 점진적으로 조금씩 줄여봅니다. 사용량 패턴 변경으로 인해 인스턴스에 더 이상 많은 분할이 필요하지 않은 경우 Spanner에서 일부 분할을 병합하여 1~2주 후에 인스턴스의 컴퓨팅 용량을 더 줄일 수 있습니다.

컴퓨팅 용량을 삭제할 때 CPU 사용률을 모니터링하고 Cloud Monitoring에서 지연 시간을 요청하여 CPU 사용률이 리전 인스턴스의 경우 65% 미만, 멀티 리전 인스턴스의 각 리전에서 45% 미만으로 유지되도록 합니다. 컴퓨팅 용량을 삭제하는 동안 요청 지연 시간이 일시적으로 늘어날 수 있습니다.

인스턴스의 컴퓨팅 용량을 늘리려면 Google Cloud 프로젝트에 컴퓨팅 용량을 추가할 수 있을 만큼 충분한 할당량이 있어야 합니다. 증가 요청을 완료하는 데 걸리는 시간은 요청 크기에 따라 달라집니다. 대부분의 경우 몇 분 내에 요청이 완료됩니다. 드문 경우지만 수직 확장을 완료하는 데 최대 1시간까지 걸릴 수 있습니다.

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

2. 변경하려는 인스턴스의 이름을 클릭합니다.

3. 인스턴스 수정을 클릭합니다.

4. 측정 단위(처리 단위 또는 노드)를 선택한 후 수량을 입력하여 컴퓨팅 용량을 변경합니다. 처리 단위를 사용하는 경우 최대 1,000개까지는 100의 배수(100, 200, 300 등)로 수량을 입력하고 더 큰 수량은 1,000의 배수(1000, 2000, 3000 등)로 입력합니다. 노드 1개는 처리 단위 1,000개와 같습니다.

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: 인스턴스의 컴퓨팅 용량으로서 노드 수로 표현됩니다. 노드 1개는 처리 단위 1,000개와 같습니다.
• PROCESSING_UNIT_COUNT: 인스턴스의 컴퓨팅 용량으로서 처리 단위 수로 표현됩니다. 최대 1,000개까지는 100의 배수(100, 200, 300 등)로 수량을 입력하고 더 큰 수량은 1,000의 배수(1000, 2000, 3000 등)로 입력합니다.

선택적 플래그:

• --async: 진행 중인 작업이 완료될 때까지 기다리지 않고 요청이 즉시 반환되도록 하려면 이 플래그를 사용합니다. gcloud spanner operations describe를 실행하여 요청 상태를 확인할 수 있습니다.

인스턴스에서 관리형 자동 확장 처리 사용 설정 또는 수정

미리보기 — Managed autoscaler

이 기능에는 서비스별 약관의 일반 서비스 약관 섹션에 있는 'GA 이전 제공 서비스 약관'이 적용됩니다. GA 이전 기능은 '있는 그대로' 제공되며 지원이 제한될 수 있습니다. 자세한 내용은 출시 단계 설명을 참조하세요.

기존 인스턴스에서 관리형 자동 확장 기능을 추가하거나 변경할 때는 다음과 같은 제한사항이 적용됩니다.

• 관리형 자동 확장 처리는 Enterprise 버전 또는 Enterprise Plus 버전에서만 사용할 수 있습니다.
• 이동 중인 인스턴스에서는 관리형 자동 확장 처리를 사용 설정할 수 없습니다.

• 관리형 자동 확장 처리가 사용 설정된 상태에서는 인스턴스를 이동할 수 없습니다.

콘솔

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

이 기능에는 서비스별 약관의 일반 서비스 약관 섹션에 있는 'GA 이전 제공 서비스 약관'이 적용됩니다. GA 이전 기능은 '있는 그대로' 제공되며 지원이 제한될 수 있습니다. 자세한 내용은 출시 단계 설명을 참조하세요.

콘솔

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: 인스턴스의 컴퓨팅 용량으로서 노드 수로 표현됩니다. 노드 1개는 처리 단위 1,000개와 같습니다.
• PROCESSING_UNIT_COUNT: 인스턴스의 컴퓨팅 용량으로서 처리 단위 수로 표현됩니다. 최대 1,000개까지는 100의 배수(100, 200, 300 등)로 수량을 입력하고 더 큰 수량은 1,000의 배수(1000, 2000, 3000 등)로 입력합니다.

인스턴스 라벨 지정

라벨은 리소스를 정리하는 데 도움이 됩니다.

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

2. 인스턴스의 확인란을 선택합니다. 페이지 오른쪽에 정보 패널이 나타납니다.

3. 정보 패널에서 라벨 탭을 클릭합니다. 그런 다음 Spanner 인스턴스의 라벨을 추가, 삭제 또는 업데이트할 수 있습니다.

기본 백업 일정 유형 수정

기본 백업 일정은 모든 새 인스턴스에 자동으로 사용 설정됩니다. 인스턴스를 만들 때 또는 나중에 인스턴스를 수정하여 인스턴스의 기본 백업 일정을 사용 설정하거나 사용 중지할 수 있습니다. 자세한 내용은 기본 백업 일정을 참고하세요.

콘솔

1. Google Cloud 콘솔에서 Spanner 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

2. 기본 백업 일정을 수정할 인스턴스의 이름을 클릭합니다.

3. 인스턴스 수정을 클릭합니다.

4. 백업의 기본 백업 일정 사용 설정 체크박스는 기본 백업 일정을 사용 설정할지 여부를 결정합니다. 사용 설정하면 이 인스턴스의 모든 새 데이터베이스에 기본 백업 일정이 생성됩니다.

5. 저장을 클릭합니다.

gcloud

gcloud spanner instances update 명령어를 사용하여 기본 백업 일정 유형을 수정합니다.

다음 명령어를 실행하여 기본 백업 일정 유형을 수정할 수 있습니다.

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

다음을 바꿉니다.

• INSTANCE_ID: 인스턴스의 영구 식별자입니다.

• DEFAULT_BACKUP_SCHEDULE_TYPE: 인스턴스에서 사용되는 기본 백업 일정 유형입니다. 다음 값 중 하나여야 합니다.

  • AUTOMATIC: 인스턴스에 새 데이터베이스가 생성되면 기본 백업 일정이 자동으로 생성됩니다. 기본 백업 일정은 24시간마다 전체 백업을 생성합니다. 이러한 전체 백업은 7일 동안 보관됩니다. 기본 백업 일정을 만든 후 수정하거나 삭제할 수 있습니다.
  • NONE: 인스턴스에 새 데이터베이스가 생성될 때 기본 백업 일정이 자동으로 생성되지 않습니다.

C#

Spanner용 클라이언트 라이브러리를 설치하고 사용하는 방법은 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 클라이언트 라이브러리를 참조하세요.

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
}

자바

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.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 클라이언트 라이브러리를 참조하세요.

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 클라이언트 라이브러리를 참조하세요.

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 인스턴스 페이지로 이동합니다.

   인스턴스 페이지로 이동

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 스키마 설계 방법을 이해합니다.