Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Instanzen erstellen und verwalten

Auf dieser Seite wird beschrieben, wie Sie Spanner-Instanzen erstellen, auflisten, bearbeiten und löschen.

Instanz erstellen

Sie können eine Instanz mit der Google Cloud Console, der Google Cloud CLI oder Clientbibliotheken erstellen. Sie können auch eine Instanz mit einer benutzerdefinierten Instanzkonfiguration erstellen, indem Sie optionale Lesezugriff-Replikate hinzufügen.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.
Klicken Sie auf Instanz erstellen.

Zur Seite „Instanz erstellen”
Wählen Sie im Abschnitt Version auswählen eine Spanner-Version aus.

Wenn Sie die Spezifikationen der verschiedenen Versionen vergleichen möchten, klicken Sie auf Versionen vergleichen. Weitere Informationen finden Sie in der Übersicht über Spanner-Versionen.
Klicken Sie auf Weiter.
Geben Sie im Abschnitt Instanz benennen einen Instanznamen ein, der in der Google Cloud Console angezeigt werden soll. Der Instanzname muss innerhalb Ihres Google Cloud -Projekts eindeutig sein.
Geben Sie eine Instanz-ID ein, um Ihre Instanz dauerhaft zu identifizieren. Die Instanz-ID muss außerdem innerhalb Ihres Google Cloud -Projekts eindeutig sein. Sie können die Instanz-ID später nicht mehr ändern.
Klicken Sie auf Weiter.
Wählen Sie im Abschnitt Instanz konfigurieren unter Konfiguration auswählen die Option Regional, Dual-Region oder Multiregional aus.

Hinweis: Dual-Region- und Multi-Region-Instanzkonfigurationen sind nur in der Enterprise Plus-Version verfügbar. Wenn Sie die Spezifikationen der drei Konfigurationen vergleichen möchten, klicken Sie auf Regionskonfigurationen vergleichen.
Wählen Sie im Drop-down-Menü einen Konfigurationsstandort aus.
Optional: Wenn Sie einer Spanner-Basiskonfiguration ein schreibgeschütztes Replikat hinzufügen möchten, erstellen Sie zuerst eine benutzerdefinierte Instanzkonfiguration mit der gcloud CLI. Das Hinzufügen optionaler Lesezugriff-Replikate zu einer Basiskonfiguration ist in der Enterprise- und Enterprise Plus-Version verfügbar.
Klicken Sie auf Weiter.
Klicken Sie im Abschnitt Rechenkapazität zuweisen unter Einheit auswählen auf eine der folgenden Optionen:
- Knoten für große Instanzen. Ein Knoten entspricht 1.000 Verarbeitungseinheiten.
- Verarbeitungseinheiten für kleine Instanzen.
Weitere Informationen finden Sie unter Rechenkapazität, Knoten und Verarbeitungseinheiten.
Klicken Sie unter Skalierungsmodus auswählen auf eine der folgenden Optionen:
- Manuelle Zuweisung, wenn Sie die Rechenkapazität für feste Rechenressourcen und -kosten manuell festlegen möchten.
  - Menge gibt die Anzahl der Verarbeitungseinheiten oder Knoten an, die für diese Instanz verwendet werden sollen.
- Autoscaling, damit Spanner Rechenkapazität automatisch hinzufügen und entfernen kann. Das verwaltete Autoscaling ist in der Spanner Enterprise-Version und Enterprise Plus-Version verfügbar. Weitere Informationen zum verwalteten Autoscaler finden Sie unter Verwalteter Autoscaler für Cloud Spanner. Konfigurieren Sie die folgenden Optionen für das verwaltete Autoscaling:
  - Minimum gibt das Mindestlimit für das Herunterskalieren an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
  - Maximum gibt das maximale Limit für die Hochskalierung an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Maximale Beschränkung bestimmen.
  - CPU-Auslastungsziel mit hoher Priorität gibt den Zielprozentsatz der CPU an, der für Aufgaben mit hoher Priorität verwendet werden soll. Weitere Informationen finden Sie unter CPU-Auslastungsziel bestimmen.
  - Ziel für gesamte CPU-Auslastung gibt den Zielprozentsatz der CPU an, der für alle Aufgaben mit niedriger, mittlerer und hoher Priorität verwendet werden soll. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
  - Speicherauslastungsziel gibt den Zielprozentsatz des zu verwendenden Speichers an. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung bestimmen.
Optional: Wenn Sie Autoscaling als Skalierungsmodus auswählen, können Sie auf das Drop-down-Menü Optionen für asymmetrisches Autoscaling einblenden klicken, um Ihre schreibgeschützten Replikate unabhängig von anderen Replikaten automatisch zu skalieren. Weitere Informationen finden Sie unter Asymmetrisches schreibgeschütztes Autoscaling.
1. Wählen Sie das schreibgeschützte Replikat aus, das Sie asymmetrisch automatisch skalieren möchten.
2. Konfigurieren Sie die folgenden Optionen für asymmetrisches Autoscaling:
  - Minimum gibt das Mindestlimit für das Herunterskalieren an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
  - Maximum gibt das maximale Limit für die Hochskalierung an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Maximale Beschränkung bestimmen.
  - Das CPU-Auslastungsziel mit hoher Priorität gibt den Zielprozentsatz der CPU an, der für Aufgaben mit hoher Priorität verwendet werden soll. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung mit hoher Priorität bestimmen.
  - Ziel für gesamte CPU-Auslastung gibt den Zielprozentsatz der CPU an, der für alle Aufgaben mit niedriger, mittlerer und hoher Priorität verwendet werden soll. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Das Ziel für die gesamte CPU-Auslastung muss größer sein als das Ziel für die CPU-Auslastung mit hoher Priorität. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
  - Gesamte CPU deaktivieren gibt an, dass das Autoscaling das Ziel für die gesamte CPU explizit ignorieren soll.
  - CPU mit hoher Priorität deaktivieren gibt an, dass das Autoscaling das CPU-Ziel für Aufgaben mit hoher Priorität explizit ignorieren soll.
Unter Sicherungen ist das Kästchen Standard-Sicherungszeitpläne aktivieren standardmäßig aktiviert. Entfernen Sie das Häkchen, um die Standard-Sicherungszeitpläne zu deaktivieren. Wenn diese Option aktiviert ist, werden für alle neuen Datenbanken in der Instanz alle 24 Stunden Vollsicherungen erstellt. Diese Sicherungen werden 7 Tage lang aufbewahrt. Sie können die Standard-Sicherungszeitpläne jederzeit bearbeiten oder löschen. Weitere Informationen finden Sie unter Standardmäßige Sicherungszeitpläne.
Klicken Sie auf Erstellen, um die Instanz zu erstellen.

gcloud

Erstellen Sie mit dem Befehl gcloud spanner instances create eine Instanz. Geben Sie die Rechenkapazität als Anzahl der Knoten oder Verarbeitungseinheiten an, die Sie für die Instanz verwenden möchten.

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

oder

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

Ersetzen Sie Folgendes:

INSTANCE-ID: eine permanente Kennung, die innerhalb Ihres Google Cloud -Projekts eindeutig ist. Sie können die Instanz-ID später nicht mehr ändern.
INSTANCE-CONFIG: die permanente Kennung Ihrer Instanzkonfiguration, die den geografischen Standort der Instanz definiert und sich auf die Replikation von Daten auswirkt. Bei benutzerdefinierten Instanzkonfigurationen beginnt sie mit custom-. Weitere Informationen finden Sie unter Instanzkonfigurationen.
INSTANCE_DESCRIPTION: der Name, der für die Instanz in der Google Cloud Console angezeigt werden soll. Der Instanzname muss innerhalb IhresGoogle Cloud -Projekts eindeutig sein.
DEFAULT_BACKUP_SCHEDULE_TYPE: der Standardtyp für den Sicherungszeitplan, der in der Instanz verwendet wird. Dies muss einer der folgenden Werte sein:
- AUTOMATIC: Ein Standardsicherungszeitplan wird automatisch erstellt, wenn eine neue Datenbank in der Instanz erstellt wird. Der Standardsicherungszeitplan erstellt alle 24 Stunden eine Vollsicherung. Diese Vollsicherungen werden 7 Tage lang aufbewahrt. Sie können den Standard-Sicherungszeitplan nach dem Erstellen bearbeiten oder löschen.
- NONE: Ein Standardsicherungszeitplan wird nicht automatisch erstellt, wenn eine neue Datenbank in der Instanz erstellt wird.
NODE-COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Knoten. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.
PROCESSING_UNIT_COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Verarbeitungseinheiten. Geben Sie Mengen bis 1.000 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen in Vielfachen von 1.000 (1.000, 2.000, 3.000 usw.) ein. Hinweis: Verwenden Sie diesen Parameter nicht, wenn Sie eine Instanz erstellen, die Sie später mit dem verwalteten Autoscaling aktivieren möchten.

Verwaltetes Autoscaling hinzufügen

Sie können auch Instanzen der Enterprise- und Enterprise Plus-Version erstellen, um verwaltetes Autoscaling mit dem Befehl gcloud spanner instances create zu verwenden. Weitere Informationen finden Sie unter Verwaltetes Autoscaling für Cloud Spanner.

Verwenden Sie den folgenden Befehl, um eine Instanz mit verwaltetem Autoscaling zu erstellen.

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

oder

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET, \
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET, \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

Ersetzen Sie Folgendes:

INSTANCE-ID: eine permanente Kennung, die innerhalb Ihres Google Cloud -Projekts eindeutig ist. Sie können die Instanz-ID später nicht mehr ändern.
INSTANCE-CONFIG: die permanente Kennung Ihrer Instanzkonfiguration, die den geografischen Standort der Instanz definiert und sich auf die Replikation von Daten auswirkt. Bei benutzerdefinierten Instanzkonfigurationen beginnt sie mit custom-. Weitere Informationen finden Sie unter Instanzkonfigurationen.
INSTANCE-DESCRIPTION: der Name, der für die Instanz in der Google Cloud Console angezeigt werden soll. Der Instanzname muss innerhalb IhresGoogle Cloud -Projekts eindeutig sein.
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Die Mindestanzahl von Verarbeitungseinheiten oder Knoten beim Herunterskalieren. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten beim Hochskalieren. Weitere Informationen finden Sie unter Höchstgrenze ermitteln.
HIGH_PRIORITY_CPU_PERCENTAGE: der Zielprozentsatz der CPU mit hoher Priorität, der basierend auf der Priorität der Aufgabe verwendet werden soll. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung mit hoher Priorität bestimmen.
TOTAL_CPU_PERCENTAGE: der Zielprozentsatz der gesamten CPU-Priorität, die verwendet werden soll. Das Ziel für die gesamte CPU-Auslastung muss größer sein als das Ziel für die CPU-Auslastung mit hoher Priorität. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
STORAGE_PERCENTAGE: der Zielprozentsatz des zu verwendenden Speichers, von 10 bis 99 %. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

Optionale Flags:

--disable-downscaling: Verwenden Sie dieses boolesche Flag, um die Herunterskalierung zu deaktivieren. Wenn der Wert auf TRUE gesetzt ist, wird verhindert, dass das Autoscaling die Anzahl der Knoten oder Verarbeitungseinheiten reduziert. Die Hochskalierung funktioniert weiterhin normal, um die erhöhte Nachfrage zu decken. Wenn Sie die Herunterskalierung nach dem Deaktivieren wieder aktivieren möchten, verwenden Sie das Flag --no-disable-downscaling.
--asymmetric-autoscaling-option: Verwenden Sie dieses Flag, um asymmetrisches Autoscaling zu aktivieren. Ersetzen Sie die folgenden Parameter:
- ASYMMETRIC_AUTOSCALING_LOCATION: Wenn das Flag verwendet wird, ist dieser Parameter erforderlich. Der Standort der Region mit Lesezugriff, die Sie asymmetrisch skalieren möchten.
- ASYMMETRIC_AUTOSCALING_MIN: optionaler Parameter. Die Mindestanzahl von Knoten beim Herunterskalieren. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen.
- ASYMMETRIC_AUTOSCALING_MAX: optionaler Parameter. Die maximale Anzahl von Knoten beim Hochskalieren. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen.
- ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: optionaler Parameter. Der Zielprozentsatz der zu verwendenden CPU, basierend auf der Priorität der Aufgabe. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Replikate können einen anderen Zielprozentsatz als die Basisinstanz und andere Replikate haben. Für Failover-Szenarien empfehlen wir jedoch, dass Replikate konsistente Ziele für verschiedene Replikate verwenden. Weitere Informationen finden Sie unter Failover-Probleme.
- ASYMMETRIC_TOTAL_CPU_TARGET: optionaler Parameter. Legen Sie das Ziel für die Gesamt-CPU auf einen Wert zwischen 10 und 90 % fest. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Replikate können einen anderen Zielprozentsatz als die Basisinstanz und andere Replikate haben. Für Failover-Szenarien empfehlen wir jedoch, dass Replikate konsistente Ziele für verschiedene Replikate verwenden. Weitere Informationen finden Sie unter Asymmetrisches schreibgeschütztes Autoscaling.
- disable_total_cpu_autoscaling: Setzen Sie diesen Parameter auf TRUE, wenn Sie nicht möchten, dass das Autoscaling die gesamte CPU auf Replikaten automatisch skaliert. Geben Sie diesen Parameter nicht an, wenn die Instanz das total_cpu_autoscaling-Ziel von der Basisinstanz übernehmen soll. Sie können nicht sowohl die gesamte CPU als auch die CPU mit hoher Priorität für dasselbe Replikat deaktivieren.
- disable_high_priority_cpu_autoscaling: Setzen Sie disable_high_priority_cpu_autoscaling auf TRUE, wenn Sie nicht möchten, dass das Autoscaling die CPU mit hoher Priorität auf Replikaten automatisch skaliert. Geben Sie diesen Parameter nicht an, wenn die Instanz das high_priority_cpu_autoscaling-Ziel von der Basisinstanz übernehmen soll. Sie können nicht sowohl die gesamte CPU als auch die CPU mit hoher Priorität auf demselben Replikat deaktivieren.

Beispiele für die Verwendung benutzerdefinierter Konfigurationen

Führen Sie folgenden Befehl aus, um eine Instanz test-instance in der regionalen Basisinstanzkonfiguration us-central1 zu erstellen:

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

Wenn Sie eine Instanz custom-eur6-instance in der benutzerdefinierten multiregionalen Instanzkonfiguration custom-eur6 erstellen möchten, müssen Sie zuerst eine benutzerdefinierte Instanzkonfiguration erstellen.

Führen Sie dann diesen Befehl aus:

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

Nachdem Sie einen der vorherigen Befehle ausgeführt haben, sollte eine Meldung wie die folgende angezeigt werden:

Creating instance...done.

C++

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

Richten Sie zur Authentifizierung bei Cloud Spanner die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Instanz ohne Standardsicherungszeitplan erstellen


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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
}

Instanz mit verwaltetem Autoscaling mit Go erstellen

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
}

Instanz mit asymmetrischem schreibgeschütztem Autoscaling mit Go erstellen

import (
	"context"
	"fmt"
	"io"

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

// createInstanceWithAsymmetricAutoscalingConfig is a code snippet to show
// an example of creating an asymmetric autoscaling enabled instance in Go.
//
// projectID is the ID of the project that the new instance will be in.
// instanceID is the ID of the new instance to be created.
func createInstanceWithAsymmetricAutoscalingConfig(w io.Writer, projectID, instanceID string) error {
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err)
	}
	defer instanceAdmin.Close()

	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID)
	fmt.Fprintf(w, "Creating instance %s.", instanceName)

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam-eur-asia3"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 10,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
				// Read-only replicas in europe-west1, europe-west4, and asia-east1 are autoscaled
				// independly from other replicas based on the usage in the respective region.
				AsymmetricAutoscalingOptions: []*instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west1",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west4",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "asia-east1",
						},
					},
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{
		Name: instanceName,
		// Get the autoscaling_config field from the newly created instance.
		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}},
	})
	if err != nil {
		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig)
	return nil
}

Instanz ohne Standardsicherungszeitplan erstellen

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Instanz mit verwaltetem Autoscaling mit Java erstellen


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

Instanz mit asymmetrischem schreibgeschütztem Autoscaling mit Java erstellen


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

Instanz ohne Standardsicherungszeitplan erstellen


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Instanz mit verwaltetem Autoscaling mit Node.js erstellen

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Get the instance admin client
const instanceAdminClient = spanner.getInstanceAdminClient();

const autoscalingConfig =
  protos.google.spanner.admin.instance.v1.AutoscalingConfig.create({
    // Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
    autoscalingLimits:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.create(
        {
          minNodes: 1,
          maxNodes: 2,
        },
      ),
    // highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
    // percentages and must lie between 0 and 100.
    autoscalingTargets:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.create(
        {
          highPriorityCpuUtilizationPercent: 65,
          storageUtilizationPercent: 95,
        },
      ),
  });

// Creates a new instance with autoscaling configuration
// When autoscalingConfig is enabled, nodeCount and processingUnits fields
// need not be specified.
try {
  console.log(
    `Creating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-us-central1',
      ),
      displayName: 'Display name for the instance.',
      autoscalingConfig: autoscalingConfig,
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      // Managed autoscaler is available only for ENTERPRISE edition
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE,
    },
  });

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

  // get instance metadata
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Autoscaling configurations of ${instanceId} are:  ` +
      '\n' +
      `Min nodes: ${metadata.autoscalingConfig.autoscalingLimits.minNodes} ` +
      'nodes.' +
      '\n' +
      `Max nodes: ${metadata.autoscalingConfig.autoscalingLimits.maxNodes}` +
      ' nodes.' +
      '\n' +
      `High priority cpu utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.highPriorityCpuUtilizationPercent}.` +
      '\n' +
      `Storage utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.storageUtilizationPercent}.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

Instanz ohne Standardsicherungszeitplan erstellen

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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

Python

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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

Instanz mit verwaltetem Autoscaling mit Python erstellen

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

def create_instance_with_autoscaling_config(instance_id):
    """Creates a Cloud Spanner instance with an autoscaling configuration."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    config_name = "{}/instanceConfigs/regional-us-central1".format(
        spanner_client.project_name
    )

    autoscaling_config = spanner_instance_admin.AutoscalingConfig(
        # Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
        autoscaling_limits=spanner_instance_admin.AutoscalingConfig.AutoscalingLimits(
            min_nodes=1,
            max_nodes=2,
        ),
        # highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
        # percentages and must lie between 0 and 100.
        autoscaling_targets=spanner_instance_admin.AutoscalingConfig.AutoscalingTargets(
            high_priority_cpu_utilization_percent=65,
            storage_utilization_percent=95,
        ),
    )

    #  Creates a new instance with autoscaling configuration
    #  When autoscalingConfig is enabled, nodeCount and processingUnits fields
    #  need not be specified.
    request = spanner_instance_admin.CreateInstanceRequest(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            autoscaling_config=autoscaling_config,
            labels={
                "cloud_spanner_samples": "true",
                "sample_name": "snippets-create_instance_with_autoscaling_config",
                "created": str(int(time.time())),
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
    )

    operation = spanner_client.instance_admin_api.create_instance(request=request)

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

    print(
        "Created instance {} with {} autoscaling config".format(
            instance_id, instance.autoscaling_config
        )
    )

Instanz ohne Standardsicherungszeitplan erstellen

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

# 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

Instanzen auflisten

Sie können eine Liste Ihrer Spanner-Instanzen anzeigen lassen.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"

In der Google Cloud Console wird eine Liste Ihrer Spanner-Instanzen angezeigt, zusammen mit der ID, dem Anzeigenamen, der Konfiguration und der Rechenkapazität jeder Instanz, ausgedrückt in Verarbeitungseinheiten und Knoten.

gcloud

Führen Sie den Befehl gcloud spanner instances list aus:

gcloud spanner instances list

Die gcloud CLI gibt eine Liste Ihrer Spanner-Instanzen aus, einschließlich der ID, des Anzeigenamens, der Konfiguration und der Rechenkapazität jeder Instanz.

Instanz bearbeiten

In den folgenden Abschnitten wird erläutert, wie Sie die Version Ihrer Instanz aktualisieren und den Anzeigenamen, die Rechenkapazität und den Standardtyp des Sicherungszeitplans einer Instanz ändern. Sie können die Instanz-ID oder die Instanzkonfiguration nicht ändern. Sie können jedoch Ihre Instanz verschieben.

Versionsupgrade durchführen

Sie können Ihre Standard-Version-Instanzen auf eine höhere Version upgraden. Instanzen der Standard-Version können auf die Enterprise- oder Enterprise Plus-Version aktualisiert werden, sofern dies nicht durch eine Einschränkung der Organisationsrichtlinie verhindert wird. Instanzen der Enterprise-Version können auf die Enterprise Plus-Version aktualisiert werden. Das Versionsupgrade dauert etwa 10 Minuten und verursacht keine Ausfallzeit.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, die Sie aktualisieren möchten.
Klicken Sie neben dem Versionstyp auf Upgrade ausführen.
Wählen Sie auf der Seite Versionsinstanz unter Version aktualisieren die neue Version mit höherer Stufe für Ihre Instanz aus.
Klicken Sie auf Speichern.

gcloud

Verwenden Sie den Befehl gcloud spanner instances update, um ein Upgrade der Version Ihrer Instanz durchzuführen:

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

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
EDITION: Geben Sie die neue, höherwertige Version für Ihre Instanz an. Weitere Informationen finden Sie in der Übersicht über Spanner-Versionen.

Optionale Flags:

--async: Verwenden Sie dieses Flag, wenn die Anfrage sofort zurückgegeben werden soll, ohne auf den Abschluss des laufenden Vorgangs zu warten. Sie können den Status Ihrer Anfrage mit gcloud spanner operations describe prüfen.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

def update_instance(instance_id):
    """Updates an instance."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    name = "{}/instances/{}".format(spanner_client.project_name, instance_id)

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            labels={
                "sample_name": "snippets-update_instance-explicit",
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["labels", "edition"]),
    )

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

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

Downgrade der Version durchführen

Sie können ein Downgrade Ihrer Cloud Spanner-Instanzen auf eine Version einer niedrigeren Stufe durchführen. Sie dürfen die Funktionen der höheren Version nicht mehr verwenden, um ein Downgrade durchzuführen. Für Instanzen der Enterprise-Version kann ein Downgrade auf die Standard-Version durchgeführt werden. Instanzen der Enterprise Plus-Version können auf die Enterprise- oder Standard-Version herabgestuft werden. Das Downgrade der Version dauert etwa 10 Minuten und verursacht keine Ausfallzeit.

Wenn Sie die Nutzung von Funktionen der Enterprise- und Enterprise Plus-Version in Ihrer Instanz überwachen möchten, verwenden Sie den Monitoring-Messwert Featurenutzung (instance/edition/feature_usage). Weitere Informationen finden Sie unter Nutzung von Versionen überwachen.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, die Sie downgraden möchten.
Klicken Sie auf der Seite Instanzübersicht auf Instanz bearbeiten.
Wählen Sie auf der Seite Instanz bearbeiten unter Cloud Spanner-Version auswählen die niedrigere Version aus.
Klicken Sie auf Instanz aktualisieren.

gcloud

Verwenden Sie den Befehl gcloud spanner instances update, um ein Downgrade der Instanzversion durchzuführen:

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
EDITION: Geben Sie die neue niedrigere Version für Ihre Instanz an. Weitere Informationen finden Sie in der Übersicht über Spanner-Versionen.

Anzeigenamen ändern

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, die Sie umbenennen möchten.
Klicken Sie auf Instanz bearbeiten.
Geben Sie einen neuen Instanznamen ein. Dieser Name muss innerhalb des ProjektsGoogle Cloud eindeutig sein.
Klicken Sie auf Speichern.

gcloud

Führen Sie den Befehl gcloud spanner instances update aus:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Ersetzen Sie Folgendes:

INSTANCE_ID: die permanente Kennung der Instanz.
INSTANCE_NAME: der Name, der für die Instanz in derGoogle Cloud Console angezeigt werden soll. Der Instanzname muss innerhalb IhresGoogle Cloud -Projekts eindeutig sein.

Rechenkapazität ändern

Sie müssen genügend Rechenkapazität bereitstellen, um die CPU-Auslastung und die Speicherauslastung unter den empfohlenen Höchstwerten zu halten. Weitere Informationen finden Sie unter Kontingente und Limits für Cloud Spanner.

Sie können die Rechenkapazität einer Spanner-Instanz reduzieren, außer in den folgenden Szenarien:

Sie können nicht mehr als 10 TiB Daten pro Knoten (1.000 Verarbeitungseinheiten) speichern.
Es gibt eine große Anzahl von Splits für die Daten Ihrer Instanz. In diesem Szenario kann Spanner die Splits möglicherweise nicht mehr verwalten, nachdem Sie die Rechenkapazität reduziert haben. Sie können versuchen, die Rechenkapazität schrittweise zu reduzieren, bis Sie die Mindestkapazität gefunden haben, die Spanner benötigt, um alle Splits der Instanz zu verwalten.

Spanner kann eine große Anzahl von Splits erstellen, um Ihren Nutzungsmustern gerecht zu werden. Wenn sich Ihre Nutzungsmuster ändern, führt Cloud Spanner nach ein oder zwei Wochen möglicherweise einige Splits zusammen und Sie können versuchen, die Rechenkapazität der Instanz zu reduzieren.

Wenn Sie Rechenkapazität entfernen, sollten Sie die CPU-Auslastung und die Anfragelatenzen in Cloud Monitoring im Auge behalten, um sicherzustellen, dass die CPU-Auslastung bei regionalen Instanzen unter 65 % und bei multiregionalen Instanzen in jeder Region unter 45 % bleibt. Beim Entfernen von Rechenkapazität kann es zu einem vorübergehenden Anstieg der Anfragelatenzen kommen.

Wenn Sie die Rechenkapazität einer Instanz erhöhen möchten, muss IhrGoogle Cloud -Projekt ein ausreichendes Kontingent haben, um die Rechenkapazität hinzuzufügen. Wie lange es dauert, bis die Anfrage zur Erhöhung abgeschlossen ist, hängt von der Größe der Anfrage ab. In den meisten Fällen werden Anfragen innerhalb weniger Minuten abgeschlossen. In seltenen Fällen kann eine Hochskalierung bis zu einer Stunde dauern.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, die Sie ändern möchten.
Klicken Sie auf Instanz bearbeiten.
Ändern Sie die Rechenkapazität, indem Sie die Maßeinheiten (Verarbeitungseinheiten oder Knoten) auswählen und dann eine Menge eingeben. Wenn Sie Verarbeitungseinheiten verwenden, geben Sie Mengen bis zu 1.000 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen in Vielfachen von 1.000 (1.000, 2.000, 3.000 usw.) ein. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.
Klicken Sie auf Speichern.

Wenn in einem Dialogfeld angezeigt wird, dass Sie kein ausreichendes Kontingent haben, um Rechenkapazität an dieser Position hinzuzufügen, folgen Sie den Anweisungen, um ein höheres Kontingent anzufordern.

gcloud

Führen Sie den Befehl gcloud spanner instances update aus. Geben Sie bei Verwendung dieses Befehls die Rechenkapazität als Anzahl von Knoten oder Verarbeitungseinheiten an.

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

oder

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

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
NODE_COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Knoten. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.
PROCESSING_UNIT_COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Verarbeitungseinheiten. Geben Sie Mengen bis 1.000 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen in Vielfachen von 1.000 (1.000, 2.000, 3.000 usw.) ein.

Optionale Flags:

--async: Verwenden Sie dieses Flag, wenn die Anfrage sofort zurückgegeben werden soll, ohne auf den Abschluss des laufenden Vorgangs zu warten. Sie können den Status Ihrer Anfrage mit gcloud spanner operations describe prüfen.

Verwaltetes Autoscaling für eine Instanz aktivieren oder ändern

Sie können das Autoscaling für eine Spanner-Instanz über die Google Cloud Console, die gcloud CLI oder die Spanner-Clientbibliotheken aktivieren oder ändern. Die folgenden Einschränkungen gelten, wenn Sie das verwaltete Autoscaling-Feature einer vorhandenen Instanz hinzufügen oder ändern:

Das verwaltete Autoscaling ist nur in der Enterprise- oder Enterprise Plus-Version verfügbar.
Sie können den verwalteten Autoscaler nicht für eine Instanz aktivieren, die Sie gerade verschieben.
Sie können eine Instanz nicht verschieben, während der verwaltete Autoscaler aktiviert ist.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, für die Sie das verwaltete Autoscaling aktivieren möchten.
Klicken Sie auf Instanz bearbeiten.
Klicken Sie unter Rechenkapazität konfigurieren auf Autoscaling.
Wählen Sie für Minimum das Mindestlimit aus, das beim Herunterskalieren verwendet werden soll. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
Wählen Sie unter Maximum das maximale Limit für die Hochskalierung aus. Weitere Informationen finden Sie unter Höchstgrenze ermitteln.
Wählen Sie für CPU-Auslastungsziel mit hoher Priorität den Prozentsatz der CPU aus, der für Aufgaben mit hoher Priorität verwendet werden soll. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung bestimmen.
Wählen Sie für Ziel für gesamte CPU-Auslastung den Zielprozentsatz für die CPU-Auslastung aus, der für alle Aufgaben mit niedriger, mittlerer und hoher Priorität verwendet werden soll. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
Wählen Sie für Speicherauslastungsziel den Prozentsatz des zu verwendenden Speichers aus. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.
Optional: Wenn Sie Autoscaling als Skalierungsmodus auswählen, können Sie auf das Drop-down-Menü Optionen für asymmetrisches Autoscaling einblenden klicken, um Ihre schreibgeschützten Replikate unabhängig von anderen Replikaten automatisch zu skalieren.
1. Wählen Sie das schreibgeschützte Replikat aus, das Sie asymmetrisch automatisch skalieren möchten.
2. Konfigurieren Sie die folgenden Autoscaling-Optionen:
  - Minimum gibt das Mindestlimit für das Herunterskalieren an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
  - Maximum gibt das maximale Limit für die Hochskalierung an, je nach der Maßeinheit, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Maximale Beschränkung bestimmen.
  - CPU-Auslastungsziel mit hoher Priorität gibt den Zielprozentsatz der CPU an, der für Aufgaben mit hoher Priorität verwendet werden soll. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung mit hoher Priorität bestimmen.
  - Ziel für gesamte CPU-Auslastung gibt den Zielprozentsatz der CPU an, der für alle Aufgaben mit niedriger, mittlerer und hoher Priorität verwendet werden soll. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
Klicken Sie auf Speichern.

gcloud

Verwenden Sie den Befehl gcloud spanner instances update, um das verwaltete Autoscaling einer Instanz hinzuzufügen. Weitere Informationen und Einschränkungen finden Sie unter Google Cloud CLI-Flags und Einschränkungen.

Mit dem folgenden Befehl können Sie den verwalteten Autoscaler hinzufügen:

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

oder

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Die Mindestanzahl von Verarbeitungseinheiten oder Knoten, die beim Herunterskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Mindestlimit bestimmen.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten, die beim Hochskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Höchstgrenze ermitteln.
HIGH_PRIORITY_CPU_PERCENTAGE: der Zielprozentsatz der CPU mit hoher Priorität, der basierend auf der Priorität der Aufgabe verwendet werden soll. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung mit hoher Priorität bestimmen.
TOTAL_CPU_PERCENTAGE: der Zielprozentsatz der gesamten CPU-Priorität, die verwendet werden soll. Das Ziel für die gesamte CPU-Auslastung muss größer sein als das Ziel für die CPU-Auslastung mit hoher Priorität. Der CPU-Prozentsatz kann zwischen 10 % und 90 % liegen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die gesamte CPU-Auslastung bestimmen.
STORAGE_PERCENTAGE: der Zielprozentsatz des zu verwendenden Speichers, von 10 % bis 99 %. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

Optionale Flags:

--disable-downscaling: Verwenden Sie dieses boolesche Flag, um die Herunterskalierung zu deaktivieren. Wenn der Wert auf TRUE gesetzt ist, wird verhindert, dass das Autoscaling die Anzahl der Knoten oder Verarbeitungseinheiten reduziert. Die Hochskalierung funktioniert weiterhin normal, um die erhöhte Nachfrage zu decken. Wenn Sie die Herunterskalierung nach dem Deaktivieren wieder aktivieren möchten, verwenden Sie das Flag --no-disable-downscaling.
--asymmetric-autoscaling-option: Verwenden Sie dieses Flag, um asymmetrisches Autoscaling zu aktivieren.

Ersetzen Sie die folgenden Parameter:
- ASYMMETRIC_AUTOSCALING_LOCATION: Wenn das Flag für asymmetrisches Autoscaling verwendet wird, ist dieser Parameter erforderlich. Der Standort der Region mit Lesezugriff, die Sie asymmetrisch skalieren möchten.
- ASYMMETRIC_AUTOSCALING_MIN: optionaler Parameter. Die Mindestanzahl von Knoten beim Herunterskalieren. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen.
- ASYMMETRIC_AUTOSCALING_MAX: optionaler Parameter. Die maximale Anzahl von Knoten beim Hochskalieren. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen.
- ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: optionaler Parameter. Der Zielprozentsatz der zu verwendenden CPU, basierend auf der Priorität der Aufgabe. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Replikate können einen anderen Zielprozentsatz als die Basisinstanz und andere Replikate haben. Für Failover-Szenarien empfehlen wir jedoch, dass Replikate konsistente Ziele für verschiedene Replikate verwenden. Weitere Informationen finden Sie unter Failover-Probleme.
- ASYMMETRIC_TOTAL_CPU_TARGET: optionaler Parameter. Legen Sie das Ziel für die Gesamt-CPU auf einen Wert zwischen 10 und 90 % fest. Wenn keine Angabe erfolgt, wird dieser Wert von der Basisinstanzkonfiguration übernommen. Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Replikate können einen anderen Zielprozentsatz als die Basisinstanz und andere Replikate haben. Für Failover-Szenarien empfehlen wir jedoch, dass Replikate konsistente Ziele für verschiedene Replikate verwenden. Weitere Informationen finden Sie unter Asymmetrisches schreibgeschütztes Autoscaling.
- disable_total_cpu_autoscaling: Setzen Sie diesen Parameter auf TRUE, wenn Sie nicht möchten, dass das Autoscaling die gesamte CPU auf Replikaten automatisch skaliert. Geben Sie diesen Parameter nicht an, wenn die Instanz das total_cpu_autoscaling-Ziel von der Basisinstanz übernehmen soll. Sie können nicht sowohl die gesamte CPU als auch die CPU mit hoher Priorität für dasselbe Replikat deaktivieren.
- disable_high_priority_cpu_autoscaling: Setzen Sie disable_high_priority_cpu_autoscaling auf TRUE, wenn Sie nicht möchten, dass das Autoscaling die CPU mit hoher Priorität auf Replikaten automatisch skaliert. Geben Sie diesen Parameter nicht an, wenn die Instanz das high_priority_cpu_autoscaling-Ziel von der Basisinstanz übernehmen soll. Sie können nicht sowohl die gesamte CPU als auch die CPU mit hoher Priorität auf demselben Replikat deaktivieren.

Nachdem Sie den verwalteten Autoscaler einer Instanz hinzugefügt haben, können Sie auch die Einstellungen des verwalteten Autoscalers ändern. Wenn Sie beispielsweise die maximale Anzahl von Verarbeitungseinheiten auf 10.000 erhöhen möchten, führen Sie den folgenden Befehl aus:

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

Instanz von verwaltetem Autoscaling auf manuelle Skalierung umstellen

Sie können die Skalierung einer Spanner-Instanz von manuell auf verwaltet oder umgekehrt ändern. Verwenden Sie dazu die Google Cloud Console, die gcloud CLI oder die Spanner-Clientbibliotheken.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, für die Sie das verwaltete Autoscaling deaktivieren möchten.
Klicken Sie unter Skalierungsmodus auswählen auf Manuelle Zuordnung.
Klicken Sie auf Speichern.

gcloud

Aktualisieren Sie die Instanz mit dem Befehl gcloud spanner instances update.

Verwenden Sie den folgenden Befehl, um eine Instanz von der Verwendung des verwalteten Autoscalings auf manuelles Skalieren umzustellen:

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

oder

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
NODE_COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Knoten. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.
PROCESSING_UNIT_COUNT: die Rechenkapazität der Instanz, ausgedrückt als Anzahl von Verarbeitungseinheiten. Geben Sie Mengen bis 1.000 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen in Vielfachen von 1.000 (1.000, 2.000, 3.000 usw.) ein.

Instanz mit einem Label versehen

Labels erleichtern die Organisation von Ressourcen.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf das Kästchen der Instanz. Das Infofeld wird rechts auf der Seite angezeigt.
Klicken Sie im Infofeld auf den Tab Labels. Anschließend können Sie Labels für die Spanner-Instanz hinzufügen, löschen oder aktualisieren.

Standardtyp des Sicherungszeitplans bearbeiten

Standardmäßige Sicherungszeitpläne werden automatisch für alle neuen Instanzen aktiviert. Sie können Standard-Sicherungszeitpläne in einer Instanz aktivieren oder deaktivieren, wenn Sie die Instanz erstellen oder später bearbeiten. Weitere Informationen finden Sie unter Standardsicherungszeitpläne.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"

Klicken Sie auf den Namen der Instanz, für die Sie den Standard-Sicherungszeitplan bearbeiten möchten.
Klicken Sie auf Instanz bearbeiten.
Unter Sicherungen bestimmt das Kästchen Standard-Sicherungszeitpläne aktivieren, ob Standard-Sicherungszeitpläne aktiviert sind oder nicht. Wenn diese Option aktiviert ist, wird für alle neuen Datenbanken in dieser Instanz ein Standardsicherungszeitplan erstellt.
Klicken Sie auf Speichern.

gcloud

Verwenden Sie den Befehl gcloud spanner instances update, um den Standardtyp für Sicherungszeitpläne zu bearbeiten.

Sie können den Standardtyp für den Sicherungszeitplan mit dem folgenden Befehl bearbeiten:

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

Ersetzen Sie Folgendes:

INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
DEFAULT_BACKUP_SCHEDULE_TYPE: der Standardtyp für den Sicherungszeitplan, der in der Instanz verwendet wird. Dies muss einer der folgenden Werte sein:
- AUTOMATIC: Ein Standardsicherungszeitplan wird automatisch erstellt, wenn eine neue Datenbank in der Instanz erstellt wird. Der Standardsicherungszeitplan erstellt alle 24 Stunden eine Vollsicherung. Diese Vollsicherungen werden 7 Tage lang aufbewahrt. Sie können den Standard-Sicherungszeitplan nach dem Erstellen bearbeiten oder löschen.
- NONE: Ein Standardsicherungszeitplan wird nicht automatisch erstellt, wenn eine neue Datenbank in der Instanz erstellt wird.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für Cloud Spanner finden Sie unter Cloud Spanner-Clientbibliotheken.

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

Instanz verschieben

Eine Anleitung zum Verschieben einer Instanz von einer Instanzkonfiguration in eine andere, einschließlich zwischen regionalen und multiregionalen Konfigurationen, finden Sie unter Instanz verschieben.

Instanz löschen

Sie können eine Instanz mit der Google Cloud Console oder der gcloud CLI löschen.

Wenn Sie eine Instanz löschen möchten, die eine oder mehrere Datenbanken mit aktiviertem Löschschutz enthält, müssen Sie zuerst den Löschschutz für alle Datenbanken in dieser Instanz deaktivieren, bevor Sie die Instanz löschen können.

Console

Rufen Sie in der Google Cloud Console die Seite Spanner-Instanzen auf.

Zur Seite "VM-Instanzen"
Klicken Sie auf den Namen der Instanz, die Sie löschen möchten.
Klicken Sie auf Instanz löschen.
Folgen Sie den Anweisungen, um zu bestätigen, dass Sie die Instanz löschen möchten.
Klicken Sie auf Löschen.

gcloud

Verwenden Sie den Befehl gcloud spanner instances delete und ersetzen Sie INSTANCE_ID durch die Instanz-ID:

gcloud spanner instances delete INSTANCE_ID

Instanz beenden oder neu starten

Spanner ist ein vollständig verwalteter Datenbankdienst, der die zugrunde liegenden Aufgaben und Ressourcen selbst verwaltet. Dazu gehören das Monitoring und der Neustart von Prozessen, falls erforderlich, ohne Ausfallzeiten. Da es nicht erforderlich ist, eine bestimmte Instanz manuell zu beenden oder neu zu starten, bietet Spanner keine Möglichkeit dazu.

Nächste Schritte

Hier erfahren Sie, wie Sie Daten mit der Datenbearbeitungssprache (Data Manipulation Language, DML) oder der gcloud CLI einfügen, aktualisieren und löschen.
Weisen Sie der Instanz und ihren Datenbanken IAM-Rollen (Identity and Access Management) zu.
Spanner-Schema entwerfen

Instanzen erstellen und verwalten Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Instanz erstellen

Console

gcloud

Verwaltetes Autoscaling hinzufügen

Beispiele für die Verwendung benutzerdefinierter Konfigurationen

C++

C#

Instanz ohne Standardsicherungszeitplan erstellen

Go

Instanz mit verwaltetem Autoscaling mit Go erstellen

Instanz mit asymmetrischem schreibgeschütztem Autoscaling mit Go erstellen

Instanz ohne Standardsicherungszeitplan erstellen

Java

Instanz mit verwaltetem Autoscaling mit Java erstellen

Instanz mit asymmetrischem schreibgeschütztem Autoscaling mit Java erstellen

Instanz ohne Standardsicherungszeitplan erstellen

Node.js

Instanz mit verwaltetem Autoscaling mit Node.js erstellen

Instanz ohne Standardsicherungszeitplan erstellen

PHP

Python

Instanz mit verwaltetem Autoscaling mit Python erstellen

Instanz ohne Standardsicherungszeitplan erstellen

Ruby

Instanzen auflisten

Console

gcloud

Instanz bearbeiten

Versionsupgrade durchführen

Console

gcloud

Go

Java

Node.js

Python

Downgrade der Version durchführen

Console

gcloud

Anzeigenamen ändern

Console

gcloud

Rechenkapazität ändern

Console

gcloud

Verwaltetes Autoscaling für eine Instanz aktivieren oder ändern

Console

gcloud

Instanz von verwaltetem Autoscaling auf manuelle Skalierung umstellen

Console

gcloud

Instanz mit einem Label versehen

Console

Standardtyp des Sicherungszeitplans bearbeiten

Console

gcloud

C#

Go

Java

Node.js

Python

Instanz verschieben

Instanz löschen

Console

gcloud

Instanz beenden oder neu starten

Nächste Schritte

Instanzen erstellen und verwalten