Membuat dan mengelola instance

Halaman ini menjelaskan cara membuat, mencantumkan, mengedit, dan menghapus instance Spanner.

Catatan: Untuk menjelajahi Spanner menggunakan instance uji coba gratis selama 90 hari, baca artikel Membuat instance uji coba gratis Spanner.

Membuat instance

Anda dapat membuat instance dengan konsol Google Cloud, Google Cloud CLI, atau library klien. Anda juga dapat membuat instance dengan konfigurasi instance kustom dengan menambahkan replika hanya baca opsional.

Catatan: Anda tidak perlu menyediakan penyimpanan di Spanner, dan Anda hanya ditagih untuk penyimpanan yang Anda gunakan. Pelajari lebih lanjut harga penyimpanan.

Konsol

1. Di konsol Google Cloud, buka halaman Spanner Instances.

2. Klik Create instance.

   Buka Buat instance

3. Di bagian Select an edition, pilih edisi Spanner.

   Jika Anda ingin membandingkan spesifikasi antar- versi, klik Bandingkan edisi. Untuk mengetahui informasi selengkapnya, lihat ringkasan edisi Spanner.

4. Klik Lanjutkan.

5. Di bagian Nama instance Anda, masukkan Nama instance untuk ditampilkan di konsol Google Cloud. Nama instance harus unik dalam project Google Cloud Anda.

6. Masukkan Instance ID untuk mengidentifikasi instance Anda secara permanen. ID instance juga harus unik dalam project Google Cloud Anda. Anda tidak dapat mengubah ID instance nanti.

7. Klik Lanjutkan.

8. Di bagian Konfigurasikan instance Anda, pada bagian Pilih konfigurasi, pilih Regional, Dual-region, atau Multi-region.

   Catatan: Konfigurasi instance dual-region dan multi-region hanya tersedia di edisi Enterprise Plus. Jika Anda ingin membandingkan spesifikasi antara ketiga konfigurasi, klik Bandingkan konfigurasi region.

9. Pilih lokasi konfigurasi dari menu drop-down.

10. Opsional: Untuk menambahkan replika hanya baca ke konfigurasi dasar Spanner, buat konfigurasi instance kustom menggunakan Google Cloud CLI terlebih dahulu. Menambahkan replika hanya baca opsional ke konfigurasi dasar tersedia di edisi Enterprise dan edisi Enterprise Plus.

11. Klik Lanjutkan.

12. Di bagian Alokasikan kapasitas komputasi, pada bagian Pilih unit, klik salah satu opsi berikut:

    • Unit pemrosesan untuk instance kecil.
    • Node untuk instance besar. Node adalah 1.000 unit pemrosesan.

    Untuk informasi selengkapnya, lihat Kapasitas komputasi, node, dan unit pemrosesan.

13. Di bagian Pilih mode penskalaan, klik salah satu opsi berikut:

    • Alokasi manual jika Anda ingin menetapkan kapasitas komputasi secara manual untuk resource dan biaya komputasi tetap.

      • Quantity menunjukkan jumlah unit pemrosesan atau node yang akan digunakan untuk instance ini.

    • Penskalaan otomatis (Pratinjau), agar Spanner dapat otomatis menambahkan dan menghapus kapasitas komputasi. Autoscaler terkelola tersedia di edisi Spanner Enterprise dan edisi Enterprise Plus. Untuk mengetahui informasi selengkapnya tentang autoscaler terkelola, lihat Autoscaler terkelola untuk Spanner. Konfigurasikan opsi autoscaler terkelola berikut:

      • Minimum menunjukkan batas minimum untuk menskalakan ke bawah, bergantung pada satuan pengukuran yang Anda pilih untuk Kapasitas komputasi. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas minimum.
      • Maksimum menunjukkan batas maksimum untuk melakukan penskalaan, bergantung pada satuan pengukuran yang Anda pilih untuk Kapasitas compute. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas maksimum.
      • Target penggunaan CPU prioritas tinggi menunjukkan target persentase CPU prioritas tinggi yang akan digunakan. Untuk informasi selengkapnya, lihat Menentukan target penggunaan CPU.
      • Target penggunaan penyimpanan menunjukkan target persentase penyimpanan yang akan digunakan. Untuk mengetahui informasi selengkapnya, lihat Menentukan Target Penggunaan Penyimpanan.

14. Di bagian Pencadangan, kotak centang Aktifkan jadwal pencadangan default dicentang secara default. Untuk menonaktifkan jadwal pencadangan default, hapus centang pada kotak. Jika diaktifkan, semua database baru di instance akan memiliki cadangan lengkap yang dibuat setiap 24 jam. Cadangan ini disimpan selama 7 hari. Anda dapat mengedit atau menghapus jadwal pencadangan default kapan saja. Untuk informasi selengkapnya, lihat Jadwal pencadangan default.

15. Klik Buat untuk membuat instance.

gcloud

Gunakan perintah gcloud spanner instances create untuk membuat instance. Tentukan kapasitas komputasi sebagai jumlah node atau unit pemrosesan yang Anda inginkan di instance.

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

atau

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

Ganti kode berikut:

• INSTANCE-ID: ID permanen yang unik dalam project Google Cloud Anda. Anda tidak dapat mengubah ID instance nanti.
• INSTANCE-CONFIG: ID permanen konfigurasi instance Anda, yang menentukan lokasi geografis instance dan memengaruhi cara data direplikasi. Untuk konfigurasi instance kustom, konfigurasi ini dimulai dengan custom-. Untuk mengetahui informasi selengkapnya, lihat konfigurasi instance.
• INSTANCE_DESCRIPTION: nama yang akan ditampilkan untuk instance di konsol Google Cloud. Nama instance harus unik dalam project Google Cloud Anda.

• DEFAULT_BACKUP_SCHEDULE_TYPE: jenis jadwal pencadangan default yang digunakan dalam instance. Harus salah satu dari nilai berikut:

  • AUTOMATIC: jadwal pencadangan default dibuat secara otomatis saat database baru dibuat di instance. Jadwal pencadangan default membuat cadangan penuh setiap 24 jam. Pencadangan penuh ini dipertahankan selama 7 hari. Anda dapat mengedit atau menghapus jadwal pencadangan default setelah dibuat.
  • NONE: jadwal pencadangan default tidak dibuat secara otomatis saat database baru dibuat di instance.

• NODE-COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah node. Setiap node sama dengan 1.000 unit pemrosesan.

• PROCESSING_UNIT_COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah unit pemrosesan. Masukkan jumlah hingga 1.000 dalam kelipatan 100 (100, 200, 300, dan seterusnya) dan masukkan jumlah yang lebih besar dalam kelipatan 1.000 (1.000, 2.000, 3.000, dan seterusnya). Catatan: Jangan gunakan parameter ini jika Anda membuat instance yang ingin diaktifkan dengan autoscaler terkelola nanti.

Menambahkan penskalaan otomatis terkelola (Pratinjau)

Anda juga dapat membuat instance edisi Enterprise dan edisi Enterprise Plus untuk menggunakan penskalaan otomatis terkelola dengan perintah gcloud beta spanner instances create. Untuk informasi selengkapnya, lihat Autoscaler terkelola untuk Spanner.

Gunakan perintah berikut untuk membuat instance dengan autoscaler terkelola.

  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

atau

  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

Ganti kode berikut:

• INSTANCE-ID: ID permanen yang unik dalam project Google Cloud Anda. Anda tidak dapat mengubah ID instance nanti.
• INSTANCE-CONFIG: ID permanen konfigurasi instance Anda, yang menentukan lokasi geografis instance dan memengaruhi cara data direplikasi. Untuk konfigurasi instance kustom, konfigurasi ini dimulai dengan custom-. Untuk mengetahui informasi selengkapnya, lihat konfigurasi instance.
• INSTANCE-DESCRIPTION: nama yang akan ditampilkan untuk instance di konsol Google Cloud. Nama instance harus unik dalam project Google Cloud Anda.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: jumlah minimum unit pemrosesan atau node saat menskalakan ke bawah. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas minimum.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: jumlah maksimum unit pemrosesan atau node saat melakukan penskalaan. Untuk informasi selengkapnya, lihat Menentukan batas maksimum.
• CPU_PERCENTAGE: target persentase CPU prioritas tinggi yang akan digunakan, dari 10 hingga 90%. Jika Anda mengoptimalkan biaya, gunakan persentase yang lebih tinggi. Untuk informasi selengkapnya, lihat Menentukan target penggunaan CPU.
• STORAGE_PERCENTAGE: target persentase penyimpanan yang akan digunakan, dari 10 hingga 99%. Untuk informasi selengkapnya, lihat Menentukan target penggunaan penyimpanan.

Contoh penggunaan konfigurasi kustom

Untuk membuat instance test-instance dalam konfigurasi instance regional dasar us-central1, jalankan:

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

Untuk membuat instance custom-eur6-instance dalam konfigurasi instance multi-region kustom custom-eur6, pertama-tama buat konfigurasi instance kustom.

Kemudian, jalankan:

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

Anda akan melihat pesan yang mirip dengan contoh berikut setelah menjalankan salah satu perintah sebelumnya:

Creating instance...done.

C++

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Membuat instance tanpa jadwal pencadangan default

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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
}

Membuat instance dengan penskalaan otomatis terkelola menggunakan Go (Pratinjau)

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
}

Membuat instance tanpa jadwal pencadangan default

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Catatan: Contoh kode antarmuka library klien lama untuk Java diarsipkan di GitHub.

Membuat instance dengan penskalaan otomatis terkelola menggunakan Java (Pratinjau)

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

Membuat instance tanpa jadwal pencadangan default

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Catatan: Contoh kode antarmuka library klien lama untuk Node.js diarsipkan di GitHub.

Membuat instance tanpa jadwal pencadangan default

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Catatan: Contoh kode antarmuka library klien lama untuk PHP diarsipkan di GitHub.

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Catatan: Contoh kode antarmuka library klien lama untuk Python diarsipkan di GitHub.

Membuat instance tanpa jadwal pencadangan default

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# 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

Mencantumkan instance

Anda dapat menampilkan daftar instance Spanner.

Konsol

Buka halaman Spanner Instances di konsol Google Cloud.

Buka halaman Instances

Konsol Google Cloud menampilkan daftar instance Spanner Anda, bersama dengan ID, nama tampilan, konfigurasi, dan kapasitas komputasi setiap instance yang dinyatakan dalam unit pemrosesan dan dalam node.

gcloud

Gunakan perintah gcloud spanner instances list:

gcloud spanner instances list

gcloud CLI akan mencetak daftar instance Spanner Anda, beserta ID, nama tampilan, konfigurasi, dan kapasitas komputasi setiap instance.

Mengedit instance

Bagian berikut menjelaskan cara mengupgrade edisi instance, dan mengubah nama tampilan, kapasitas komputasi, dan jenis jadwal pencadangan default instance. Anda tidak dapat mengubah ID instance atau konfigurasi instance (tetapi, Anda dapat memindahkan instance).

Mengupgrade edisi

Anda dapat mengupgrade instance edisi Standard ke edisi tingkat yang lebih tinggi. Instance edisi Standard dapat diupgrade ke edisi Enterprise atau edisi Enterprise Plus. Instance edisi Enterprise dapat diupgrade ke edisi Enterprise Plus.

Penurunan layanan mandiri tidak tersedia. Untuk mendowngrade edisi instance Anda, ajukan tiket dukungan. Untuk mengetahui informasi selengkapnya, lihat FAQ edisi Spanner.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang ingin Anda upgrade.

3. Klik Upgrade di samping jenis edisi.

4. Di halaman Instance edisi, dan di bagian Update edisi, pilih edisi tingkat yang lebih tinggi untuk instance Anda.

5. Klik Simpan.

gcloud

Gunakan perintah gcloud spanner instances update untuk mengupgrade edisi instance Anda:

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

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.
• EDITION: menentukan edisi tingkat yang lebih tinggi untuk instance Anda. Untuk mengetahui informasi selengkapnya, lihat ringkasan edisi Spanner.

Flag opsional:

• --async: Gunakan flag ini jika Anda ingin permintaan segera ditampilkan, tanpa menunggu operasi yang sedang berlangsung selesai. Anda dapat memeriksa status permintaan dengan menjalankan 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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Mengubah nama tampilan

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang ingin diganti namanya.

3. Klik Edit instance.

4. Masukkan nama instance baru. Nama ini harus unik dalam project Google Cloud.

5. Klik Simpan.

gcloud

Gunakan perintah gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.
• INSTANCE_NAME: nama yang akan ditampilkan untuk instance di konsol Google Cloud. Nama instance harus unik dalam project Google Cloud Anda.

Mengubah kapasitas komputasi

Anda harus menyediakan kapasitas komputasi yang memadai agar penggunaan CPU dan penggunaan penyimpanan tetap di bawah maksimum yang direkomendasikan. Untuk mengetahui informasi selengkapnya, lihat kuota dan batas untuk Spanner.

Ada beberapa kasus saat Anda tidak dapat mengurangi kapasitas komputasi instance yang ada:

• Menghapus kapasitas komputasi akan mengharuskan instance Anda menyimpan lebih dari 4 TB data per 1.000 unit pemrosesan (1 node).
• Berdasarkan pola penggunaan historis Anda, Spanner telah membuat pemisahan dalam jumlah besar untuk data instance Anda, dan dalam beberapa kasus yang jarang terjadi, Spanner tidak akan dapat mengelola pemisahan setelah menghapus kapasitas komputasi.

Dalam kasus kedua, Anda dapat mencoba mengurangi kapasitas komputasi dengan jumlah yang lebih kecil secara bertahap hingga Anda menemukan kapasitas minimum yang diperlukan Spanner untuk mengelola semua bagian instance. Jika instance tidak lagi memerlukan begitu banyak pemisahan karena perubahan pola penggunaan, Spanner mungkin pada akhirnya menggabungkan beberapa pemisahan dan memungkinkan Anda mencoba mengurangi kapasitas komputasi instance lebih lanjut setelah satu atau dua minggu.

Saat menghapus kapasitas komputasi, pantau penggunaan CPU dan latensi permintaan di Cloud Monitoring untuk memastikan penggunaan CPU tetap di bawah 65% untuk instance regional dan 45% untuk setiap region dalam instance multi-region. Anda mungkin mengalami peningkatan latensi permintaan sementara saat menghapus kapasitas komputasi.

Jika Anda ingin meningkatkan kapasitas komputasi instance, project Google Cloud Anda harus memiliki kuota yang memadai untuk menambahkan kapasitas komputasi. Waktu yang diperlukan untuk menyelesaikan permintaan peningkatan bergantung pada ukuran permintaan. Biasanya, permintaan selesai dalam beberapa menit. Terkadang, perlu waktu hingga satu jam untuk menyelesaikan penskalaan.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang ingin diubah.

3. Klik Edit Instance.

4. Ubah kapasitas komputasi dengan memilih satuan pengukuran (unit pemrosesan atau node), lalu memasukkan kuantitas. Saat menggunakan unit pemrosesan, masukkan jumlah hingga 1.000 dalam kelipatan 100 (100, 200, 300, dan seterusnya) dan masukkan jumlah yang lebih besar dalam kelipatan 1.000 (1.000, 2.000, 3.000, dan seterusnya). Setiap node sama dengan 1.000 unit pemrosesan.

5. Klik Simpan.

Jika Anda melihat dialog yang menyatakan bahwa Anda tidak memiliki kuota yang memadai untuk menambahkan kapasitas komputasi di lokasi ini, ikuti petunjuk untuk meminta kuota yang lebih tinggi.

gcloud

Gunakan perintah gcloud spanner instances update. Saat menggunakan perintah ini, tentukan kapasitas komputasi sebagai jumlah node atau unit pemrosesan.

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

atau

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

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.
• NODE_COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah node. Setiap node sama dengan 1.000 unit pemrosesan.
• PROCESSING_UNIT_COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah unit pemrosesan. Masukkan jumlah hingga 1.000 dalam kelipatan 100 (100, 200, 300, dan seterusnya) dan masukkan jumlah yang lebih besar dalam kelipatan 1.000 (1.000, 2.000, 3.000, dan seterusnya).

Flag opsional:

• --async: Gunakan flag ini jika Anda ingin permintaan segera ditampilkan, tanpa menunggu operasi yang sedang berlangsung selesai. Anda dapat memeriksa status permintaan dengan menjalankan gcloud spanner operations describe.

Mengaktifkan atau mengubah autoscaler terkelola di instance

Pratinjau — Managed autoscaler

Fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dalam Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Batasan berikut berlaku saat Anda menambahkan atau mengubah fitur penskalaan otomatis terkelola di instance yang ada:

• Autoscaler terkelola hanya tersedia di edisi Enterprise atau edisi Enterprise Plus.
• Anda tidak dapat mengaktifkan pengoptimal skala terkelola pada instance yang dipindahkan.

• Anda tidak dapat memindahkan instance saat autoscaler terkelola diaktifkan.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance tempat Anda ingin mengaktifkan pengoptimal ukuran terkelola.

3. Klik Edit instance.

4. Di bagian Configure compute capacity, klik Autoscaling.

5. Untuk Minimum, pilih batas minimum yang akan digunakan saat menskalakan ke bawah. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas minimum.

6. Untuk Maksimum, pilih batas maksimum yang akan digunakan saat menskalakan ke atas. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas maksimum.

7. Untuk Target penggunaan CPU prioritas tinggi, pilih persentase CPU prioritas tinggi yang akan digunakan. Untuk informasi selengkapnya, lihat Menentukan target penggunaan CPU.

8. Untuk Target penggunaan penyimpanan, pilih persentase penyimpanan yang akan digunakan. Untuk informasi selengkapnya, lihat Menentukan target penggunaan penyimpanan.

9. Klik Simpan.

gcloud

Gunakan perintah gcloud beta spanner instances update untuk menambahkan autoscaler terkelola ke instance. Untuk informasi dan batasan selengkapnya, lihat tanda dan batasan Google Cloud CLI.

Anda dapat menambahkan autoscaler terkelola dengan perintah berikut:

  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

atau

  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

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: jumlah minimum unit pemrosesan atau node yang akan digunakan saat menskalakan ke bawah. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas minimum.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: jumlah maksimum unit pemrosesan atau node yang akan digunakan saat menskalakan. Untuk mengetahui informasi selengkapnya, lihat Menentukan batas maksimum.
• CPU_PERCENTAGE: persentase target CPU prioritas tinggi yang akan digunakan, dari 10% hingga 90%. Jika Anda mengoptimalkan biaya dan tidak memerlukan latensi rendah pada semua permintaan, gunakan persentase yang lebih tinggi. Untuk informasi selengkapnya, lihat Menentukan target penggunaan CPU.
• STORAGE_PERCENTAGE: target persentase penyimpanan yang akan digunakan, dari 10% hingga 99%. Untuk mengetahui informasi selengkapnya, lihat Menentukan Target Penggunaan Penyimpanan.

Setelah menambahkan autoscaler terkelola ke instance, Anda juga dapat mengubah setelan autoscaler terkelola. Misalnya, jika Anda ingin meningkatkan jumlah unit pemrosesan maksimum menjadi 10.000, jalankan perintah berikut:

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

Mengubah instance dari menggunakan autoscaler terkelola menjadi penskalaan manual

Pratinjau — Managed autoscaling

Fitur ini tunduk pada "Persyaratan Penawaran Pra-GA" di bagian Persyaratan Layanan Umum dalam Persyaratan Khusus Layanan. Fitur pra-GA tersedia "sebagaimana adanya" dan mungkin memiliki dukungan terbatas. Untuk mengetahui informasi selengkapnya, lihat deskripsi tahap peluncuran.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang ingin Anda nonaktifkan pengatur skala terkelolanya.

3. Di bagian Pilih mode penskalaan, klik Alokasi manual.

4. Klik Simpan.

gcloud

Gunakan perintah gcloud beta spanner instances update untuk memperbarui instance.

Gunakan perintah berikut untuk mengubah instance dari menggunakan autoscaler terkelola ke penskalaan manual:

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

atau

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

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.
• NODE_COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah node. Setiap node sama dengan 1.000 unit pemrosesan.
• PROCESSING_UNIT_COUNT: kapasitas komputasi instance, yang dinyatakan sebagai jumlah unit pemrosesan. Masukkan jumlah hingga 1.000 dalam kelipatan 100 (100, 200, 300, dan seterusnya) dan masukkan jumlah yang lebih besar dalam kelipatan 1.000 (1.000, 2.000, 3.000, dan seterusnya).

Memberi label pada instance

Label membantu mengatur resource Anda.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Centang kotak untuk instance. Panel Info muncul di sisi kanan halaman.

3. Klik tab Label di Panel info. Kemudian, Anda dapat menambahkan, menghapus, atau memperbarui label untuk instance Spanner.

Mengedit jenis jadwal pencadangan default

Jadwal pencadangan default diaktifkan secara otomatis untuk semua instance baru. Anda dapat mengaktifkan atau menonaktifkan jadwal pencadangan default di instance saat membuat instance atau dengan mengedit instance nanti. Untuk informasi selengkapnya, lihat Jadwal pencadangan default.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang jadwal cadangan default-nya ingin Anda edit.

3. Klik Edit instance.

4. Di bagian Pencadangan, kotak centang Aktifkan jadwal pencadangan default menentukan apakah jadwal pencadangan default diaktifkan atau tidak. Jika diaktifkan, semua database baru di instance ini akan memiliki jadwal pencadangan default yang dibuat.

5. Klik Simpan.

gcloud

Gunakan perintah gcloud spanner instances update untuk mengedit jenis jadwal pencadangan default.

Anda dapat mengedit jenis jadwal pencadangan default dengan menjalankan perintah berikut:

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

Ganti kode berikut:

• INSTANCE_ID: ID permanen untuk instance.

• DEFAULT_BACKUP_SCHEDULE_TYPE: jenis jadwal pencadangan default yang digunakan dalam instance. Harus salah satu dari nilai berikut:

  • AUTOMATIC: jadwal pencadangan default dibuat secara otomatis saat database baru dibuat di instance. Jadwal pencadangan default membuat cadangan penuh setiap 24 jam. Pencadangan penuh ini dipertahankan selama 7 hari. Anda dapat mengedit atau menghapus jadwal pencadangan default setelah dibuat.
  • NONE: jadwal pencadangan default tidak dibuat secara otomatis saat database baru dibuat di instance.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Spanner, lihat library klien Spanner.

Untuk melakukan autentikasi ke Spanner, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Memindahkan instance

Catatan: Anda tidak dapat memindahkan instance yang telah mengaktifkan autoscaler terkelola.

Untuk mengetahui petunjuk cara memindahkan instance dari konfigurasi instance apa pun ke konfigurasi instance lainnya, termasuk antara konfigurasi regional dan multi-regional, lihat Memindahkan instance.

Menghapus instance

Peringatan: Menghapus instance akan menghapus instance tersebut beserta semua databasenya secara permanen. Tindakan ini tidak dapat diurungkan. Selain itu, Anda tidak dapat membuat instance uji coba gratis lain setelah menghapus instance uji coba gratis pertama. Anda dapat membuat satu instance uji coba gratis per siklus proses project.

Anda dapat menghapus instance dengan konsol Google Cloud atau Google Cloud CLI.

Jika ingin menghapus instance yang memiliki satu atau beberapa database dengan perlindungan penghapusan diaktifkan, Anda harus menonaktifkan perlindungan penghapusan di semua database dalam instance tersebut terlebih dahulu sebelum dapat menghapus instance.

Konsol

1. Buka halaman Spanner Instances di konsol Google Cloud.

   Buka halaman Instances

2. Klik nama instance yang ingin Anda hapus.

3. Klik Hapus instance.

4. Ikuti petunjuk untuk mengonfirmasi bahwa Anda ingin menghapus instance.

5. Klik Hapus.

gcloud

Gunakan perintah gcloud spanner instances delete, ganti INSTANCE_ID dengan ID instance:

gcloud spanner instances delete INSTANCE_ID

Menghentikan atau memulai ulang instance

Spanner adalah layanan database terkelola sepenuhnya yang mengawasi tugas dan resource pokoknya sendiri, termasuk memantau dan memulai ulang proses jika diperlukan tanpa periode nonaktif. Karena tidak perlu menghentikan atau memulai ulang instance tertentu secara manual, Spanner tidak menawarkan cara untuk melakukannya.

Langkah selanjutnya

• Pelajari cara menyisipkan, memperbarui, dan menghapus data dengan Data Manipulation Language (DML) atau gcloud CLI.
• Berikan peran Identity and Access Management untuk instance dan database-nya.
• Pahami cara mendesain skema Spanner.