Instanzen erstellen und verwalten

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

Hinweis: Informationen zu Spanner mit einer 90-tägigen kostenlosen Testinstanz finden Sie unter Kostenlose Spanner-Testinstanz erstellen.

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 schreibgeschützte Replikate hinzufügen.

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

Console

1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

   Instanz erstellen

2. Geben Sie einen Instanznamen ein, der in der Google Cloud Console angezeigt werden soll. Der Instanzname darf in einem Google Cloud-Projekt nur einmal vorkommen.

3. Geben Sie eine Instanz-ID ein, um die Instanz dauerhaft zu identifizieren. Außerdem darf die Instanz-ID innerhalb des Google Cloud-Projekts nur einmal vorkommen. Sie können die Instanz-ID später nicht ändern.

4. Klicken Sie unter Konfiguration auswählen auf Regional oder Mehrere Regionen. Wenn Sie die Spezifikationen zwischen zwei Regionen vergleichen möchten, klicken Sie alternativ auf Regionskonfigurationen vergleichen.

5. Wählen Sie im Drop-down-Menü eine Konfiguration aus.

6. Optional: Fügen Sie schreibgeschützte Replikate hinzu, um Lesevorgänge zu skalieren und veraltete Lesevorgänge mit niedriger Latenz zu unterstützen. Wenn Sie über die Google Cloud Console ein schreibgeschütztes Replikat erstellen und einer Instanzkonfiguration hinzufügen, wird die benutzerdefinierte Instanzkonfiguration automatisch erstellt. So fügen Sie ein schreibgeschütztes Replikat hinzu:

   1. Maximieren Sie Schreibgeschützte Replikate konfigurieren.

   2. Klicken Sie auf Schreibgeschütztes Replikat hinzufügen.

   3. Wählen Sie eine Region und eine Nummer aus.

7. Klicken Sie im Abschnitt Rechenkapazität konfigurieren unter Einheit auswählen auf eine der folgenden Optionen:

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

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

8. 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 (Vorschau), damit Spanner Rechenkapazität automatisch hinzufügen und entfernen kann. Weitere Informationen finden Sie unter Verwaltetes Autoscaling für Spanner. Konfigurieren Sie die folgenden Optionen für das verwaltete Autoscaling:

     • Minimum gibt die Mindestgrenze für das Herunterskalieren an, abhängig von der Messeinheit, die Sie für die Computing-Kapazität ausgewählt haben. Weitere Informationen finden Sie unter Mindestlimit ermitteln.
     • Maximum gibt das maximale Limit für die Hochskalierung an, abhängig von der Messeinheit, die Sie für die Compute-Kapazität ausgewählt haben. Weitere Informationen finden Sie unter Höchstzahl ermitteln.
     • CPU-Auslastungsziel mit hoher Priorität gibt den Zielprozentsatz der zu verwendenden CPU mit hoher Priorität an. Weitere Informationen finden Sie unter CPU-Auslastungsziel ermitteln.
     • Speicherauslastungsziel gibt den Zielprozentsatz des zu verwendenden Speichers an. Weitere Informationen finden Sie unter Speicherauslastungsziel bestimmen.

9. 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 wünschen.

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--nodes=NODE-COUNT

oder

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--processing-units=PROCESSING-UNIT-COUNT

Ersetzen Sie Folgendes:

• INSTANCE-ID: eine permanente Kennung, die in Ihrem Google Cloud-Projekt eindeutig ist. Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: eine permanente Kennung der 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 ist der Name, der in der Google Cloud Console für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb eines Google Cloud-Projekts nur einmal vorkommen.

• 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 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen als Vielfache 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 (Vorschau)

Mit dem Befehl gcloud beta spanner instances create können Sie neue Instanzen auch für die Verwendung von verwaltetem Autoscaling konfigurieren. Weitere Informationen finden Sie unter Verwaltetes Autoscaling für Spanner.

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

  gcloud beta spanner instances create INSTANCE-ID \
    --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 \
    --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 vorkommt. Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: eine permanente Kennung der 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 ist der Name, der in der Google Cloud Console für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb eines Google Cloud-Projekts nur einmal vorkommen.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: die Mindestanzahl von Verarbeitungseinheiten oder Knoten beim Herunterskalieren. Weitere Informationen finden Sie unter Mindestlimit ermitteln.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten beim Hochskalieren. Weitere Informationen finden Sie unter Höchstzahl ermitteln.
• CPU_PERCENTAGE: der Zielprozentsatz der zu verwendenden CPU mit hoher Priorität im Bereich von 10 bis 90%. Wenn Sie die Kosten optimieren, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter CPU-Auslastungsziel ermitteln.
• STORAGE_PERCENTAGE: der Zielprozentsatz des zu verwendenden Speichers (von 10 bis 99 %) Weitere Informationen finden Sie unter Speicherauslastungsziel ermitteln.

Beispiele für die Verwendung benutzerdefinierter Konfigurationen

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

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

Zum Erstellen einer Instanz custom-eur6-instance in der benutzerdefinierten multiregionalen Instanzkonfiguration custom-eur6 müssen Sie zuerst eine benutzerdefinierte Instanzkonfiguration erstellen.

Führen Sie dann diesen Befehl aus:

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

Nachdem Sie einen der oben genannten Befehle ausgeführt haben, sollten Sie eine Meldung ähnlich dem folgenden Beispiel sehen:

Creating instance...done.

C++

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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 Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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;

public class CreateInstanceSample
{
    public Instance CreateInstance(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();

        // 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" },
            }
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response = instanceAdminClient.CreateInstance(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse = response.PollUntilCompleted();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance created successfully.");

        return completedResponse.Result;
    }
}

Einfach loslegen (Go)

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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"
	instancepb "google.golang.org/genproto/googleapis/spanner/admin/instance/v1"
)

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"},
		},
	})
	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 (Vorschau)

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

Java

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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)
            .setNodeCount(nodeCount)
            .setConfig(
                InstanceConfigName.of(projectId, "regional-us-central1").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 Benutzeroberfläche der Clientbibliothek für Java sind in GitHub archiviert.

Instanz mit verwaltetem Autoscaling mit Java erstellen (Vorschau)

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

Node.js

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

// Imports the Google Cloud client library
const {Spanner} = 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
      },
    },
  });

  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 Oberfläche der Clientbibliothek für Node.js sind in GitHub archiviert.

PHP

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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 Benutzeroberfläche der Clientbibliothek für PHP sind in GitHub archiviert.

Python

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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())),
            },
        ),
    )

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

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

Hinweis: Die alten Codebeispiele für die Benutzeroberfläche der Clientbibliothek für Python sind in GitHub archiviert.

Ruby

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

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Spanner zu authentifizieren. 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"

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: "regional-us-central1"

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 zusammen mit ID, Anzeigename, Konfiguration und Rechenkapazität jeder Instanz an, ausgedrückt in Verarbeitungseinheiten und in 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 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 den Anzeigenamen und die Rechenkapazität einer Instanz ändern. Sie können die Instanz-ID oder die Instanzkonfiguration nicht ändern.

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 im Google 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 ist der Name, der in der Google Cloud Console für die Instanz angezeigt werden soll. Der Instanzname darf innerhalb eines Google Cloud-Projekts nur einmal vorkommen.

Rechenkapazität ändern

Sie müssen genügend Computing-Kapazität bereitstellen, damit die CPU-Auslastung und die Speicherauslastung unter den empfohlenen Höchstwerten bleiben. 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:

• Wenn Sie Rechenkapazität entfernen, muss die Instanz mehr als 4 TB Daten pro 1.000 Verarbeitungseinheiten (1 Knoten) speichern.
• Auf der Grundlage Ihrer bisherigen Nutzungsmuster hat Spanner eine große Anzahl von Splits für die Daten Ihrer Instanz erstellt. In einigen seltenen Fällen kann Spanner die Splits nach dem Entfernen von Rechenkapazität nicht verwalten.

In letzterem Fall können Sie versuchen, die Rechenkapazität um zunehmend kleinere Beträge zu reduzieren, bis Sie die Mindestkapazität gefunden haben, 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, führt Spanner möglicherweise einige Splits zusammen und Sie können versuchen, die Rechenkapazität der Instanz nach ein oder zwei Wochen weiter zu reduzieren.

Überwachen 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 in multiregionalen Instanzen unter 45% für jede Region 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 Ihr Google Cloud-Projekt über ein ausreichendes Kontingent zum Hinzufügen der Rechenkapazität verfügen.

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 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 als Vielfache 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. Wenn Sie diesen Befehl verwenden, geben Sie die Computing-Kapazität als Anzahl der Knoten oder Verarbeitungseinheiten an.

gcloud spanner instances update INSTANCE-ID --nodes=NODE-COUNT

oder

gcloud spanner instances update INSTANCE-ID
--processing-units=PROCESSING-UNIT-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 in Vielfachen von 100 (100, 200, 300 usw.) und größere Mengen als Vielfache von 1.000 (1.000, 2.000, 3.000 usw.) ein.

Verwaltetes Autoscaling 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.

Wenn Sie das Feature für das verwaltete Autoscaling einer vorhandenen Instanz hinzufügen oder ändern, gelten die folgenden Einschränkungen:

• Sie können das verwaltete Autoscaling nicht für eine Instanz aktivieren, die Sie verschieben.

• Sie können keine Instanz verschieben, wenn das verwaltete Autoscaling 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 das verwaltete Autoscaling 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 Mindestgrenze aus, die beim Herunterskalieren verwendet werden soll. Weitere Informationen finden Sie unter Mindestlimit ermitteln.

6. Wählen Sie für Maximum den Maximalwert aus, der beim Hochskalieren verwendet werden soll. Weitere Informationen finden Sie unter Höchstzahl ermitteln.

7. Wählen Sie für CPU-Auslastungsziel mit hoher Priorität den Prozentsatz der zu verwendenden CPU mit hoher Priorität aus. Weitere Informationen finden Sie unter CPU-Auslastungsziel ermitteln.

8. Wählen Sie unter Speicherauslastungsziel den Prozentsatz des zu verwendenden Speichers aus. Weitere Informationen finden Sie unter Speicherauslastungsziel ermitteln.

9. Klicken Sie auf Speichern.

gcloud

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

Sie können das verwaltete Autoscaling mit dem folgenden Befehl hinzufügen:

  gcloud beta spanner instances update \
    --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 \
    --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:

• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: die Mindestanzahl von Verarbeitungseinheiten oder Knoten, die beim Herunterskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Mindestlimit ermitteln.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten, die beim Hochskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Höchstzahl ermitteln.
• CPU_PERCENTAGE: der Zielprozentsatz der zu verwendenden CPU mit hoher Priorität von 10% bis 90%. Wenn Sie die Kosten optimieren und nicht für alle Anfragen eine niedrige Latenz benötigen, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter CPU-Auslastungsziel ermitteln.
• STORAGE_PERCENTAGE: der angestrebte Prozentsatz des zu verwendenden Speichers von 10% bis 99%. Weitere Informationen finden Sie unter Speicherauslastungsziel bestimmen.

Nachdem Sie das verwaltete Autoscaling einer Instanz hinzugefügt haben, können Sie auch die Einstellungen des verwalteten Autoscalings ä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 \
     --autoscaling-max-processing-units=10000

Instanz von verwaltetem Autoscaling auf manuelle Skalierung umstellen

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 das verwaltete Autoscaling deaktivieren möchten.

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

4. Klicken Sie auf Speichern.

gcloud

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

Verwenden Sie den folgenden Befehl, um eine Instanz von der Verwendung des verwalteten Autoscalings auf die manuelle Skalierung umzustellen:

  gcloud beta spanner instances update \
  --processing-units=PROCESSING-UNITS-COUNT

oder

  gcloud beta spanner instances update \
  --nodes=NODE-COUNT

Ersetzen Sie PROCESSING-UNIT-COUNT oder NODE-COUNT durch die Anzahl der Verarbeitungseinheiten oder Knoten, die Sie für die Instanz verwenden möchten.

Instanzen mit Labels 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. Anschließend können Sie Labels für die Spanner-Instanz hinzufügen, löschen oder aktualisieren.

Instanz verschieben

Hinweis: Instanzen, für die verwaltetes Autoscaling aktiviert ist, können nicht verschoben werden.

Eine Anleitung zum Verschieben einer Instanz von einer Instanzkonfiguration in eine andere Instanzkonfiguration, einschließlich 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. Sie können auch keine weitere kostenlose Testinstanz mehr erstellen, nachdem Sie Ihre erste kostenlose Testinstanz gelöscht haben. Sie können eine kostenlose Testinstanz pro Projektlebenszyklus erstellen.

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

Wenn Sie eine Instanz löschen möchten, für die eine oder mehrere Datenbanken mit aktiviertem Löschschutz aktiviert sind, 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 und 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. Dazu gehören auch das Monitoring und der Neustart von Prozessen bei Bedarf ohne Ausfallzeiten. Da eine bestimmte Instanz nicht manuell beendet oder neu gestartet werden muss, bietet Spanner keine Möglichkeit.

Nächste Schritte

• Informationen zum Einfügen, Aktualisieren und Löschen von Daten mit der Datenbearbeitungssprache (DML) oder der gcloud CLI
• Weisen Sie der Instanz und ihren Datenbanken Rollen von Identity and Access Management zu.
• Informieren Sie sich, wie Sie ein Spanner-Schema entwerfen.