Instanzen erstellen und verwalten

Auf dieser Seite wird beschrieben, wie Sie Spanner erstellen, auflisten, bearbeiten und löschen instances:

Hinweis: Wenn Sie Spanner mit einer 90-tägigen kostenlosen Testinstanz ausprobieren möchten, Siehe Kostenlose Spanner-Testinstanz erstellen

Instanz erstellen

Sie können eine Instanz mit der Google Cloud Console, dem Google Cloud CLI oder Clientbibliotheken Sie können auch eine Instanz mit einem benutzerdefinierte Instanzkonfiguration, indem Sie Optionale schreibgeschützte Replikate.

Hinweis: Sie müssen keinen Speicher in Spanner bereitstellen wird nur der in Anspruch genommene Speicherplatz berechnet. 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. Die Die Instanz-ID muss außerdem innerhalb Ihres Google Cloud-Projekts eindeutig sein. Sie können die Instanz-ID später nicht ändern.

4. Klicken Sie auf Weiter.

5. Klicken Sie im Bereich Instanz konfigurieren unter Wählen Sie unter Konfiguration auswählen die Option Regional, Dual-Region oder Mehrere Regionen: Alternativ können Sie die Messwerte Spezifikationen zwischen den drei Konfigurationen aus und klicken Sie dann auf Regionenkonfigurationen vergleichen

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

7. Optional: Einer Spanner-Basis ein schreibgeschütztes Replikat hinzufügen erstellen Sie zuerst eine benutzerdefinierte Instanzkonfiguration Google Cloud CLI

8. Klicken Sie auf Weiter.

9. Gehen Sie im Bereich Rechenkapazität zuweisen unter Einheit auswählen so vor: klicken Sie auf eine der folgenden Optionen:

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

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

10. Klicken Sie unter Skalierungsmodus auswählen auf eine der folgenden Optionen:

    • Manuelle Zuweisung, wenn Sie die Rechenkapazität manuell festlegen möchten für feste Rechenressourcen und -kosten.

      • Menge gibt die Anzahl der Verarbeitungseinheiten oder Knoten an. für diese Instanz zu verwenden.

    • Autoscaling (Vorschau) damit Spanner automatisch Computing-Daten Kapazität. Weitere Informationen zum verwalteten verwalteten Autoscaling Siehe Verwaltetes Autoscaling für Spanner Konfigurieren Sie die folgenden Optionen für das verwaltete Autoscaling:

      • Minimum gibt das Minimum an, auf das herunterskaliert werden soll. abhängig von der Maßeinheit, die Sie für Compute Kapazität. Weitere Informationen finden Sie unter Bestimmen Sie die Mindestgrenze.
      • Maximum gibt das Maximum für die Hochskalierung an. abhängig von der Maßeinheit, die Sie für Compute Kapazität. Weitere Informationen finden Sie unter Bestimmen Sie die Obergrenze.
      • CPU-Auslastungsziel mit hoher Priorität gibt das Ziel an. Prozentsatz der zu verwendenden CPU mit hoher Priorität. Weitere Informationen Siehe CPU-Auslastungsziel bestimmen.
      • Speicherauslastungsziel gibt den Zielprozentsatz an. Speicherplatz verfügbar sind. Weitere Informationen finden Sie unter Speicherauslastungsziel bestimmen

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

gcloud

Verwenden Sie den gcloud spanner instances create. zum Erstellen einer Instanz. Geben Sie die Rechenkapazität an. als Anzahl der Knoten oder Verarbeitungseinheiten, die Sie auf der Instanz haben möchten.

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 Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: Eine permanente Kennzeichnung Ihrer Instanz Konfiguration, die den geografischen Standort der Instanz und die Replikation von Daten beeinflusst. Bei benutzerdefinierten Instanzkonfigurationen beginnt mit custom-. Weitere Informationen finden Sie unter Instanz Konfigurationen
• INSTANCE-DESCRIPTION: der Name, der für die Instanz im Google Cloud Console 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 als Anzahl von Verarbeitungseinheiten angegeben. Geben Sie Mengen bis zu 1.000 ein in Vielfachen von 100 (100, 200, 300 usw.) und geben Sie größere Mengen als Vielfache von 1.000 (1.000, 2.000, 3.000 usw.) angeben. Hinweis: Verwenden Sie diesen Parameter nicht, wenn Sie eine Instanz erstellen, die Sie später mit dem verwalteten Autoscaling aktivieren können.

Verwaltetes Autoscaling hinzufügen (Vorschau)

Sie können neue Instanzen auch so konfigurieren, dass sie verwaltetes Autoscaling mit der gcloud beta spanner instances create . 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 innerhalb von Ihr Google Cloud-Projekt. Sie können die Instanz-ID später nicht ändern.
• INSTANCE-CONFIG: Eine permanente Kennzeichnung Ihrer Instanz Konfiguration, die den geografischen Standort der Instanz und die Replikation von Daten beeinflusst. Bei benutzerdefinierten Instanzkonfigurationen beginnt mit custom-. Weitere Informationen finden Sie unter Instanz Konfigurationen
• INSTANCE-DESCRIPTION: der Name, der für die Instanz im Google Cloud Console 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 Weitere Informationen
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die maximale Anzahl von Verarbeitungseinheiten oder Knoten bei der Hochskalierung. Weitere Informationen finden Sie unter Bestimmen Sie die Obergrenze.
• CPU_PERCENTAGE: der Zielprozentsatz der CPU mit hoher Priorität für zwischen 10 und 90%. Wenn Sie im Hinblick auf Kosten optimieren, verwenden Sie einen höheren Prozentsatz. Weitere Informationen finden Sie unter Bestimmen Sie das CPU-Auslastungsziel.
• STORAGE_PERCENTAGE: Zielprozentsatz des zu verwendenden Speichers von 10 auf 99 % reduzieren. Weitere Informationen finden Sie unter Bestimmen Sie das Speicherauslastungsziel.

Beispiele für die Verwendung benutzerdefinierter Konfigurationen

Zum Erstellen der Instanz test-instance in der regionalen Basisinstanz Konfiguration us-central1, führen Sie Folgendes aus:

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

So erstellen Sie die Instanz custom-eur6-instance am benutzerdefinierten multiregionalen Standort: Instanzkonfiguration custom-eur6, zuerst Erstellen Sie eine benutzerdefinierte Instanzkonfiguration.

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

Nach der Ausführung sollte eine Meldung wie die folgende angezeigt werden: einen der vorherigen Befehle:

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

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

<ph type="x-smartling-placeholder">

</ph> Hinweis: Die Codebeispiele für die alte Clientbibliotheksschnittstellen-Codebeispiele für Java sind archiviert in GitHub.

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

<ph type="x-smartling-placeholder">

</ph> Hinweis: Die Codebeispiele für die alte Clientbibliothek-Schnittstelle für Node.js sind archiviert in GitHub.

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

<ph type="x-smartling-placeholder">

</ph> Hinweis: Die Codebeispiele für die alte Clientbibliotheksschnittstellen-Codebeispiele für PHP sind archiviert in GitHub.

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

<ph type="x-smartling-placeholder">

</ph> Hinweis: Die Codebeispiele für die alte Clientbibliothek-Schnittstelle für Python sind archiviert in GitHub.

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"

In der Google Cloud Console wird eine Liste Ihrer Spanner- Instanzen gibt es außerdem die ID, den Anzeigenamen, die Konfiguration und Rechenkapazität, 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 aus Instanzen gibt es außerdem die ID, den Anzeigenamen, die Konfiguration und Rechenkapazität.

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

Rechenkapazität ändern

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

Es gibt einige Fälle, in denen Sie die Rechenkapazität eines vorhandene Instanz:

• Zum Entfernen von Rechenkapazität müsste Ihre Instanz mehr als 4 TB Daten pro 1.000 Verarbeitungseinheiten (1 Knoten).
• Basierend auf Ihren bisherigen Nutzungsmustern hat Spanner eine viele Splits für Ihr und in seltenen Fällen kann Spanner nicht in der Lage sein, um die Aufteilungen nach dem Entfernen von Rechenkapazität zu verwalten.

Im letzteren Fall können Sie versuchen, die Rechenkapazität schrittweise kleinere Beträge, bis Sie die Mindestkapazität gefunden haben, der alle Splits der Instanz verwalten muss. Wenn die Instanz keine so viele Splits aufgrund einer Änderung der Nutzungsmuster, einige Teilungen zusammenführen und versuchen, die Rechenkapazität der Instanz nach ein oder zwei Wochen zu erhöhen.

Wenn Sie Rechenkapazität entfernen, beobachten Sie die CPU-Auslastung und die Anfrage Latenzen in Cloud Monitoring, um die CPU-Leistung unter 65% für regionale und 45% für jede Region in multiregionale Instanzen. Die Anzahl der Anfragen kann vorübergehend erhöht werden Latenzen auftreten, während die Rechenkapazität reduziert wird.

Wenn Sie die Rechenkapazität einer Instanz erhöhen möchten, Das Google Cloud-Projekt muss ein ausreichendes Kontingent haben, um die Compute Engine Kapazität. Wie lange es dauert, bis die Erhöhungsanfrage abgeschlossen ist, hängt vom die Größe der Anfrage. In den meisten Fällen werden Anfragen innerhalb weniger Minuten abgeschlossen. An In seltenen Fällen kann eine Hochskalierung 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 Maßeinheiten auswählen (Verarbeitungseinheiten oder Knoten) und geben Sie dann eine Menge ein. Bei Verwendung Verarbeitungseinheiten können Sie Mengen bis 1000 als Vielfache von 100 (100, 200, 300 usw.) und geben Sie größere Mengen als Vielfache von 1000 ein. (1000, 2000, 3000 usw.). 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.

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 Knotenanzahl. Jeder Knoten entspricht 1.000 Verarbeitungseinheiten.
• PROCESSING_UNIT_COUNT: die Rechenkapazität der Instanz als Anzahl von Verarbeitungseinheiten angegeben. Geben Sie Mengen bis zu 1.000 ein in Vielfachen von 100 (100, 200, 300 usw.) und geben Sie größere Mengen als Vielfache von 1.000 (1.000, 2.000, 3.000 usw.) angeben.

Optionale Flags:

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

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 verwaltete Autoscaling hinzufügen oder ändern, gelten die folgenden Einschränkungen auf einer vorhandenen Instanz:

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

• Sie können keine Instanz verschieben, während das verwaltete Autoscaling aktiviert ist aktiviert.

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 die verwaltete Version aktivieren möchten. Autoscaling aktiviert ist.

3. Klicken Sie auf Instanz bearbeiten.

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

5. Wählen Sie als Minimum das Mindestlimit aus, das beim Herunterskalieren verwendet werden soll. Weitere Informationen finden Sie unter Bestimmen Sie die Mindestgrenze.

6. Wählen Sie als Maximum das Maximum aus, das beim Hochskalieren verwendet werden soll. Für Weitere Informationen

7. Wählen Sie unter CPU-Auslastungsziel mit hoher Priorität den Prozentsatz eine CPU mit hoher Priorität. Weitere Informationen finden Sie unter Bestimmen Sie das CPU-Auslastungsziel.

8. Wählen Sie für Speicherauslastungsziel den Prozentsatz des Speichers aus, verwenden. Weitere Informationen finden Sie unter Bestimmen Sie das Speicherauslastungsziel.

9. Klicken Sie auf Speichern.

gcloud

Verwenden Sie die Methode gcloud beta spanner instances update zum Hinzufügen des verwalteten Autoscalings zu einer Instanz. Weitere Informationen und Weitere Informationen 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 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 Mindestanzahl von Verarbeitungseinheiten oder Knoten, die beim Herunterskalieren verwendet werden sollen. Weitere Informationen finden Sie unter Bestimmen Sie die Mindestgrenze.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: die Maximale Anzahl von Verarbeitungseinheiten oder Knoten, die beim Hochskalieren verwendet werden sollen. Für finden Sie unter Bestimmen Sie die Obergrenze.
• CPU_PERCENTAGE: der Zielprozentsatz der CPU mit hoher Priorität für von 10% auf 90%. Wenn Sie im Hinblick auf Kosten optimieren und keine niedrigen Latenz für alle Anfragen und verwenden dann einen höheren Prozentsatz. Weitere Informationen finden Sie unter Bestimmen Sie das CPU-Auslastungsziel.
• STORAGE_PERCENTAGE: Zielprozentsatz des zu verwendenden Speichers von 10% auf 99%. Weitere Informationen finden Sie unter Speicherauslastungsziel bestimmen

Nachdem Sie das verwaltete Autoscaling einer Instanz hinzugefügt haben, können Sie auch Autoscaling-Einstellungen verwaltet. Wenn Sie z. B. die maximale Anzahl von Anzahl der Verarbeitungseinheiten auf 10.000 erhöhen, führen Sie den folgenden Befehl aus:

gcloud beta spanner instances update test-instance \
     --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 die Verwaltung deaktivieren möchten. Autoscaling aktiviert ist.

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

4. Klicken Sie auf Speichern.

gcloud

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

Verwenden Sie den folgenden Befehl, um für eine Instanz den verwalteten Dienst von Autoscaling auf manuelle Skalierung:

  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 als Anzahl von Verarbeitungseinheiten angegeben. Geben Sie Mengen bis zu 1.000 ein in Vielfachen von 100 (100, 200, 300 usw.) und geben Sie größere Mengen als Vielfache von 1.000 (1.000, 2.000, 3.000 usw.) angeben.

Instanz 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 oder Labels für die Spanner-Instanz aktualisieren.

Instanz verschieben

Hinweis: Sie können keine Instanz verschieben, für die das verwaltete Autoscaling aktiviert ist.

Anweisungen zum Verschieben Ihrer Instanz von einer beliebigen Instanzkonfiguration zu jede andere Instanzkonfiguration, auch zwischen regional und multiregional 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 weiteren kostenlosen Testinstanz nach dem Löschen Ihrer ersten kostenlosen Testinstanz. Ich kann eine kostenlose Testinstanz pro Projektlebenszyklus erstellen.

Sie können eine Instanz mit der Google Cloud Console oder dem Google Cloud CLI

Wenn Sie eine Instanz mit einer oder mehreren Datenbanken mit Löschschutz aktiviert ist, müssen Sie zuerst Löschschutz deaktivieren für alle Datenbanken in dieser Instanz, 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 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, eigene zugrunde liegende Aufgaben und Ressourcen, einschließlich Monitoring und Neustart bei Bedarf ganz ohne Ausfallzeiten. Da keine manuelle Einrichtung eine bestimmte Instanz anhalten oder neu starten, bietet Spanner keine Möglichkeit, tun Sie dies.

Nächste Schritte

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