Instanzen erstellen und verwalten

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

Hinweis :Wenn Sie Spanner mit einer 90-tägigen Testinstanz ausprobieren möchten, lesen Sie den Hilfeartikel Spanner-Testinstanz erstellen.

Instanz erstellen

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

Hinweis :Sie müssen keinen Speicher in Spanner bereitstellen und Ihnen wird nur der genutzte Speicher in Rechnung gestellt. Weitere Informationen zu Speicherpreisen

Console

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

2. Klicken Sie auf Instanz erstellen.

   Zur Seite „Instanz erstellen”

3. 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-Editionen.

4. Klicken Sie auf Weiter.

5. Geben Sie im Bereich Instanz benennen einen Instanznamen ein, der in der Google Cloud -Console angezeigt werden soll. Der Instanzname darf innerhalb Ihres Google Cloud -Projekts nur einmal vorkommen.

6. Geben Sie eine Instanz-ID ein, um Ihre Instanz dauerhaft zu identifizieren. Die Instanz-ID darf im Google Cloud -Projekt ebenfalls nur einmal vorkommen. Sie können die Instanz-ID später nicht ändern.

7. Klicken Sie auf Weiter.

8. Wählen Sie im Bereich Instanz konfigurieren unter Konfiguration auswählen die Option Regional, Dual-Region oder Multi-Region aus.

   Hinweis: Konfigurationen mit zwei oder mehreren Regionen sind nur in der Enterprise Plus-Version verfügbar. Wenn Sie die Spezifikationen der drei Konfigurationen vergleichen möchten, klicken Sie auf Regionskonfigurationen vergleichen.

9. Wählen Sie im Drop-down-Menü einen Speicherort für die Konfiguration aus.

10. Optional: Wenn Sie einer Spanner-Basiskonfiguration ein schreibgeschütztes Replikat hinzufügen möchten, erstellen Sie zuerst eine benutzerdefinierte Instanzkonfiguration mit der Google Cloud CLI. Optionale schreibgeschützte Replikate können einer Basiskonfiguration in der Enterprise- und Enterprise Plus-Version hinzugefügt werden.

11. Klicken Sie auf Weiter.

12. Klicken Sie im Bereich Rechenkapazität zuweisen unter Einheit auswählen auf eine der folgenden Optionen:

    • Verarbeitungseinheiten für kleine Instanzen.
    • Knoten für große Instanzen. Ein Knoten entspricht 1.000 Verarbeitungseinheiten.

    Weitere Informationen finden Sie unter Rechenkapazität, Knoten und Verarbeitungseinheiten.

13. 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 (Vorabversion): Spanner kann automatisch Rechenkapazität hinzufügen und entfernen. Der verwaltete Autoscaler ist in der Spanner Enterprise- und Enterprise Plus-Version verfügbar. Weitere Informationen zum verwalteten Autoscaler finden Sie unter Verwalteter Autoscaler für Spanner. Konfigurieren Sie die folgenden Optionen für die verwaltete automatische Skalierung:

      • Minimum gibt das Mindestlimit an, auf das herunterskaliert werden kann. Dies hängt von der Maßeinheit ab, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Mindestlimit festlegen.
      • Maximal gibt das maximale Limit an, bis zu dem skaliert werden kann. Dabei hängt es von der Maßeinheit ab, die Sie für die Rechenkapazität auswählen. Weitere Informationen finden Sie unter Maximalwert ermitteln.
      • CPU-Auslastungsziel mit hoher Priorität gibt den Zielprozentsatz der CPU-Auslastung mit hoher Priorität an. Weitere Informationen finden Sie unter CPU-Auslastungsziel bestimmen.
      • Das Speicherauslastungsziel gibt den Zielprozentsatz der zu verwendenden Speicherkapazität an. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

14. Unter Sicherungen ist standardmäßig das Kästchen Standard-Sicherungszeitpläne aktivieren angeklickt. Wenn Sie die Standard-Sicherungszeitpläne deaktivieren möchten, entfernen Sie das Häkchen aus dem Kästchen. 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 Standardsicherungszeitpläne.

15. Klicken Sie auf Erstellen, um die Instanz zu erstellen.

gcloud

Verwenden Sie den Befehl gcloud spanner instances create, um eine Instanz zu erstellen. Geben Sie die Rechenkapazität als Anzahl der Knoten oder Verarbeitungseinheiten an, die Sie für die Instanz benötigen.

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 in einem Google Cloud -Projekt nur einmal vorkommen darf. Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: Eine permanente Kennzeichnung Ihrer Instanzkonfiguration, die den geografischen Standort der Instanz definiert und die Replikation von Daten beeinflusst. Bei benutzerdefinierten Instanzkonfigurationen beginnt sie mit custom-. Weitere Informationen finden Sie unter Instanzkonfigurationen.
• INSTANCE_DESCRIPTION: Der Name, der in der Google Cloud -Console für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb IhresGoogle Cloud -Projekts nur einmal vorkommen.

• 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 in der Instanz eine neue Datenbank erstellt wird. Mit dem Standardsicherungszeitplan wird alle 24 Stunden eine Vollsicherung erstellt. Diese vollständigen Sicherungen 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 in der Instanz eine neue Datenbank 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 zu 1.000 als Vielfaches von 100 (100, 200, 300 usw.) ein und geben Sie größere Mengen als ein Vielfaches 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 Autoscaler aktivieren möchten.

Verwaltetes Autoscaling hinzufügen (Vorabversion)

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

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

  gcloud beta spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

oder

  gcloud beta spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Ersetzen Sie Folgendes:

• INSTANCE-ID: Eine permanente Kennung, die in Ihrem Google Cloud -Projekt nur einmal vorkommen darf. Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: Eine permanente Kennzeichnung Ihrer Instanzkonfiguration, die den geografischen Standort der Instanz definiert und die Replikation von Daten beeinflusst. Bei benutzerdefinierten Instanzkonfigurationen beginnt sie mit custom-. Weitere Informationen finden Sie unter Instanzkonfigurationen.
• INSTANCE-DESCRIPTION: Der Name, der in der Google Cloud -Konsole für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb IhresGoogle Cloud -Projekts nur einmal vorkommen.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: die Mindestanzahl von Verarbeitungseinheiten oder Knoten beim Herunterskalieren. Weitere Informationen finden Sie unter Mindestlimit festlegen.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten beim Skalieren. Weitere Informationen finden Sie unter Maximales Limit ermitteln.
• CPU_PERCENTAGE: Der Prozentsatz der CPU mit hoher Priorität, der verwendet werden soll (10 bis 90 %). Wenn Sie die Kosten optimieren möchten, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung festlegen.
• STORAGE_PERCENTAGE: Der Zielprozentsatz des zu verwendenden Speicherplatzes, von 10 bis 99%. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

Beispiele für die Verwendung benutzerdefinierter Konfigurationen

Führen Sie Folgendes aus, um eine Instanz test-instance in der Basiskonfiguration der regionalen Instanz 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 mehrregionalen 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

Nach der Ausführung eines der vorherigen Befehle sollte eine Meldung ähnlich der folgenden angezeigt werden:

Creating instance...done.

C++

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

Richten Sie zur Authentifizierung bei Spanner 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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 Standard-Sicherungszeitplan 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

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 ohne Standard-Sicherungszeitplan 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

Hinweis:Die alten Codebeispiele für die Clientbibliotheksoberfläche für Java sind auf GitHub archiviert.

Instanz mit verwaltetem Autoscaling mit Java erstellen (Vorabversion)

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

class CreateInstanceWithAutoscalingConfigExample {

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

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

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

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

Instanz ohne Standard-Sicherungszeitplan 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

Hinweis:Die alten Codebeispiele für die Clientbibliotheksoberfläche für Node.js sind auf GitHub archiviert.

Instanz ohne Standard-Sicherungszeitplan 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

Hinweis:Die alten Codebeispiele für die Clientbibliotheksoberfläche für PHP sind auf GitHub archiviert.

Python

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

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

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

Hinweis:Die alten Codebeispiele für die Clientbibliotheksoberfläche für Python sind auf GitHub archiviert.

Instanz ohne Standard-Sicherungszeitplan 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

# 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 aufrufen.

Console

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

Zur Seite "VM-Instanzen"

Die Google Cloud -Console zeigt eine Liste Ihrer Spanner-Instanzen sowie die ID, den Anzeigenamen, die Konfiguration und die Rechenkapazität jeder Instanz an, die sowohl in Verarbeitungseinheiten als auch in Knoten ausgedrückt werden.

gcloud

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

gcloud spanner instances list

Die gcloud CLI druckt eine Liste Ihrer Spanner-Instanzen zusammen mit der ID, dem Anzeigenamen, der Konfiguration und der Rechenkapazität jeder Instanz aus.

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 die Instanz jedoch verschieben.

Version upgraden

Sie können Ihre Instanzen der Standardversion auf eine höhere Version umstellen. Instanzen der Standardversion können auf die Enterprise-Version oder Enterprise Plus-Version umgestellt werden. Instanzen der Enterprise-Version können auf Enterprise Plus umgestellt werden.

Ein Self-Service-Downgrade ist nicht verfügbar. Wenn Sie die Version Ihrer Instanz downgraden möchten, reichen Sie ein Support-Ticket ein. Weitere Informationen finden Sie in den häufig gestellten Fragen zu Spanner-Versionen.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, die Sie aktualisieren möchten.

3. Klicken Sie neben der Versionsart auf Upgrade.

4. Wählen Sie auf der Seite Instanzversion unter Version aktualisieren die neue Version mit höherer Stufe für Ihre Instanz aus.

5. Klicken Sie auf Speichern.

gcloud

Verwenden Sie den Befehl gcloud spanner instances update, um die Version Ihrer Instanz zu aktualisieren:

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öhere Version für Ihre Instanz an. Weitere Informationen finden Sie unter Spanner-Versionen – Übersicht.

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 prüfen, indem Sie gcloud spanner operations describe ausführen.

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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

// 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

    spanner_client = spanner.Client()

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

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

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

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

Anzeigenamen ändern

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, die Sie umbenennen möchten.

3. Klicken Sie auf Instanz bearbeiten.

4. Geben Sie einen neuen Instanznamen ein. Dieser Name darf imGoogle Cloud -Projekt nur einmal vorkommen.

5. 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 Kennzeichnung der Instanz.
• INSTANCE_NAME: Der Name, der in derGoogle Cloud -Console für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb IhresGoogle Cloud -Projekts nur einmal vorkommen.

Rechenkapazität ändern

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

Es gibt einige Fälle, in denen Sie die Rechenkapazität einer vorhandenen Instanz nicht reduzieren können:

• Zum Entfernen der Rechenkapazität müsste die Instanz mehr als 10 TB an Daten pro 1.000 Verarbeitungseinheiten (1 Knoten) speichern.
• Beruhend auf Ihren bisherigen Nutzungsmustern hat Spanner eine große Anzahl von Splits für die Daten Ihrer Instanz erstellt. In einigen seltenen Fällen wäre Spanner nach dem Entfernen der Rechenkapazität nicht in der Lage, die Splits zu verwalten.

Im letztgenannten Fall können Sie versuchen, die Rechenkapazität schrittweise um kleinere Werte zu reduzieren, bis Sie die Mindestkapazität herausfinden, die Spanner zum Verwalten aller Splits der Instanz benötigt. Wenn die Instanz aufgrund einer Änderung der Nutzungsmuster nicht mehr so viele Splits benötigt, kann Spanner schließlich einige Splits zusammenführen und Ihnen die Möglichkeit bieten, die Rechenkapazität der Instanz nach ein oder zwei Wochen weiter zu reduzieren.

Beobachten Sie beim Entfernen von Rechenkapazität die CPU-Auslastung und die Anfragelatenzen in Cloud Monitoring, damit die CPU-Auslastung bei regionalen Instanzen unter 65% und bei Instanzen mit mehreren Regionen bei jeder Region unter 45% liegt. Beim Entfernen von Rechenkapazität kann es vorübergehend zu einer Anfragelatenz kommen.

Wenn Sie die Rechenkapazität einer Instanz erhöhen möchten, muss dasGoogle Cloud -Projekt ein ausreichendes Kontingent zum Hinzufügen der Rechenkapazität haben. Wie lange es dauert, bis die 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 die Skalierung bis zu einer Stunde dauern.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, die Sie ändern möchten.

3. Klicken Sie auf Instanz bearbeiten.

4. Ändern Sie die Rechenkapazität, indem Sie die Messeinheiten (Verarbeitungseinheiten oder Knoten) auswählen und dann eine Menge eingeben. Wenn Sie Verarbeitungseinheiten verwenden, geben Sie Mengen bis 1.000 als Vielfaches von 100 (100, 200, 300 usw.) und größere Mengen als Vielfaches von 1.000 (1.000, 2.000, 3.000 usw.) ein. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.

5. 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 der 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 zu 1.000 als Vielfaches von 100 (100, 200, 300 usw.) ein und geben Sie größere Mengen als ein Vielfaches 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 prüfen, indem Sie gcloud spanner operations describe ausführen.

Verwaltete Autoscaler für eine Instanz aktivieren oder ändern

Vorschau — Managed autoscaler

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Die folgenden Einschränkungen gelten, wenn Sie die Funktion „Verwaltetes Autoscaling“ zu einer vorhandenen Instanz hinzufügen oder ändern:

• Der verwaltete Autoscaler 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 verschieben.

• Sie können eine Instanz nicht verschieben, während der verwaltete Autoscaler aktiviert ist.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, für die Sie den verwalteten Autoscaler aktivieren möchten.

3. Klicken Sie auf Instanz bearbeiten.

4. Klicken Sie unter Rechenkapazität konfigurieren auf Autoscaling.

5. Wählen Sie unter Minimum die Mindestanzahl aus, die beim Herunterskalieren verwendet werden soll. Weitere Informationen finden Sie unter Mindestlimit festlegen.

6. Wählen Sie unter Maximal das maximale Limit aus, das beim Skalieren verwendet werden soll. Weitere Informationen finden Sie unter Maximales Limit ermitteln.

7. Wählen Sie unter CPU-Auslastungsziel mit hoher Priorität den Prozentsatz der CPU mit hoher Priorität aus, der verwendet werden soll. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung festlegen.

8. Wählen Sie unter Speicherauslastungsziel den Prozentsatz des zu verwendenden Speicherplatzes aus. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

9. Klicken Sie auf Speichern.

gcloud

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

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

  gcloud beta spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

oder

  gcloud beta spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Ersetzen Sie Folgendes:

• INSTANCE_ID: Die permanente Kennzeichnung der Instanz.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Die minimale Anzahl von Verarbeitungseinheiten oder Knoten, die beim Herunterskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Mindestlimit festlegen.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten, die beim Skalieren verwendet werden sollen. Weitere Informationen finden Sie unter Maximales Limit ermitteln.
• CPU_PERCENTAGE: Der Zielprozentsatz der CPU mit hoher Priorität, der verwendet werden soll (10% bis 90 %). Wenn Sie nach Kosten optimieren und nicht für alle Anfragen eine geringe Latenz benötigen, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Ziel für die CPU-Auslastung festlegen.
• STORAGE_PERCENTAGE: Der Zielprozentsatz der zu verwendenden Speicherkapazität, von 10% bis 99%. Weitere Informationen finden Sie unter Ziel für die Speicherauslastung festlegen.

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

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

Verwaltete Autoscaling-Funktion für eine Instanz durch manuelle Skalierung ersetzen

Vorschau — Managed autoscaling

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, für die Sie den verwalteten Autoscaler deaktivieren möchten.

3. Klicken Sie unter Skalierungsmodus auswählen auf Manuelle Zuordnung.

4. Klicken Sie auf Speichern.

gcloud

Verwenden Sie den Befehl gcloud beta spanner instances update, um die Instanz zu aktualisieren.

Mit dem folgenden Befehl können Sie die automatische Skalierung für eine Instanz auf manuelle Skalierung umstellen:

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

oder

  gcloud beta 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 zu 1.000 als Vielfaches von 100 (100, 200, 300 usw.) ein und geben Sie größere Mengen als ein Vielfaches von 1.000 (1.000, 2.000, 3.000 usw.) ein.

Instanz mit Label versehen

Labels erleichtern die Organisation von Ressourcen.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf das Kästchen der Instanz. Das Infofeld wird rechts auf der Seite angezeigt.

3. Klicken Sie im Infofeld auf den Tab Labels. Sie können dann Labels für die Spanner-Instanz hinzufügen, löschen oder aktualisieren.

Standardtyp des Sicherungszeitplans bearbeiten

Standardsicherungszeitpläne werden für alle neuen Instanzen automatisch aktiviert. Sie können Standard-Sicherungszeitpläne in einer Instanz beim Erstellen oder später durch Bearbeiten der Instanz aktivieren oder deaktivieren. Weitere Informationen finden Sie unter Standardsicherungszeitpläne.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, für die Sie den Standardsicherungszeitplan bearbeiten möchten.

3. Klicken Sie auf Instanz bearbeiten.

4. Unter Sicherungen können Sie mit dem Kästchen Standard-Sicherungszeitpläne aktivieren festlegen, ob Standard-Sicherungszeitpläne aktiviert werden sollen. Wenn diese Option aktiviert ist, wird für alle neuen Datenbanken in dieser Instanz ein Standard-Sicherungszeitplan erstellt.

5. 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 des Sicherungszeitplans 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 in der Instanz eine neue Datenbank erstellt wird. Mit dem Standardsicherungszeitplan wird alle 24 Stunden eine Vollsicherung erstellt. Diese vollständigen Sicherungen 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 in der Instanz eine neue Datenbank erstellt wird.

C#

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

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

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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

/**
 * 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 Spanner finden Sie unter Spanner-Clientbibliotheken.

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

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

Hinweis: Sie können eine Instanz, für die ein verwalteter Autoscaler aktiviert ist, nicht verschieben.

Eine Anleitung zum Verschieben Ihrer Instanz von einer beliebigen Instanzkonfiguration in eine andere Instanzkonfiguration, auch zwischen regionalen und multiregionalen Konfigurationen, finden Sie unter Instanz verschieben.

Instanz löschen

Achtung: Durch das Löschen einer Instanz werden die Instanz und alle zugehörigen Datenbanken endgültig entfernt. Sie können diese Aktion nicht rückgängig machen. Außerdem können Sie keine weitere kostenlose Testinstanz erstellen, nachdem Sie Ihre erste kostenlose Testinstanz gelöscht haben. Sie können eine kostenlose Testinstanz pro Projektlebenszyklus erstellen.

Sie können eine Instanz über die Google Cloud Console oder die Google Cloud CLI löschen.

Wenn Sie eine Instanz mit einer oder mehreren Datenbanken löschen möchten, für die der Löschschutz aktiviert ist, müssen Sie zuerst den Löschschutz für alle Datenbanken in dieser Instanz deaktivieren, bevor Sie die Instanz löschen können.

Console

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

   Zur Seite "VM-Instanzen"

2. Klicken Sie auf den Namen der Instanz, die Sie löschen möchten.

3. Klicken Sie auf Instanz löschen.

4. Folgen Sie den Anweisungen, um zu bestätigen, dass Sie die Instanz löschen möchten.

5. Klicken Sie auf Löschen.

gcloud

Verwenden Sie den Befehl gcloud spanner instances delete. Ersetzen Sie dabei 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 seine eigenen zugrunde liegenden Aufgaben und Ressourcen überwacht und bei Bedarf Monitoring- und Neustartprozesse ohne Ausfallzeiten ausführt. Da es nicht erforderlich ist, eine bestimmte Instanz manuell zu beenden oder neu zu starten, bietet Spanner auch keine Möglichkeit dazu.

Nächste Schritte

• Informationen zum Einfügen, Aktualisieren und Löschen von Daten mithilfe der Datenmanipulationssprache (Data Manipulation Language, DML) oder der gcloud-Befehlszeile
• Weisen Sie der Instanz und ihren Datenbanken Identity and Access Management-Rollen zu.
• Weitere Informationen zum Entwerfen eines Spanner-Schemas