Créer et gérer des instances

Cette page explique comment créer, répertorier, modifier et supprimer une instance Spanner instances.

Remarque : Pour découvrir Spanner à l'aide d'une instance d'essai gratuit de 90 jours, consultez Créer une instance d'essai gratuit Spanner.

Créer une instance

Vous pouvez créer une instance avec la console Google Cloud, la Google Cloud CLI ou les bibliothèques clientes. Vous pouvez également créer à l'aide d'un Configuration d'instances personnalisées en ajoutant des instances répliquées en lecture seule facultatives.

Remarque :Vous n'avez pas besoin de provisionner le stockage dans Spanner et vous sont facturés uniquement pour l'espace de stockage que vous utilisez. En savoir plus sur les tarifs de stockage

Console

1. Dans la console Google Cloud, accédez à la page Instances Spanner.

2. Cliquez sur Créer une instance.

   Accéder à la page Créer une instance

3. Dans la section Sélectionner une édition, sélectionnez une édition Spanner.

   Si vous souhaitez comparer les spécifications édition, puis cliquez sur Comparer les éditions. Pour en savoir plus, consultez la présentation des éditions Spanner.

4. Cliquez sur Continuer.

5. Dans la section Nommer votre instance, saisissez un nom d'instance à afficher dans la console Google Cloud. Le nom de l'instance doit être unique au sein de votre projet Google Cloud.

6. Saisissez un ID d'instance pour identifier définitivement votre instance. La L'ID d'instance doit également être unique au sein de votre projet Google Cloud. Une fois cet ID d'instance créé, vous ne pourrez plus le modifier.

7. Cliquez sur Continuer.

8. Dans la section Configurer votre instance, sous Sélectionner une configuration, sélectionnez Régional, Bi-régional ou Multirégional.

   Remarque :Les configurations d'instances birégionales et multirégionales disponibles dans l'édition Enterprise Plus. Si vous souhaitez comparer les spécifications entre les trois configurations, cliquez sur Comparer les configurations régionales.

9. Sélectionnez un emplacement de configuration dans le menu déroulant.

10. Facultatif : Pour ajouter un réplica avec accès en lecture seule à une configuration de base Spanner, commencez par créer une configuration d'instance personnalisée à l'aide de Google Cloud CLI. L'ajout de réplicas en lecture seule facultatifs à une configuration de base est disponible dans les éditions Enterprise et Enterprise Plus.

11. Cliquez sur Continuer.

12. Dans la section Allouer de la capacité de calcul, sous Sélectionner une unité, procédez comme suit : cliquez sur l'une des options suivantes:

    • Unités de traitement pour les petites instances.
    • Nœuds pour les instances volumineuses Un nœud correspond à 1 000 unités de traitement.

    Pour en savoir plus, consultez la section Capacité de calcul, nœuds et unités de traitement.

13. Sous Choisir un mode de scaling, cliquez sur l'une des options suivantes :

    • Allocation manuelle si vous souhaitez définir manuellement la capacité de calcul pour des ressources et des coûts de calcul fixes.

      • La quantité indique le nombre d'unités de traitement ou de nœuds. à utiliser pour cette instance.

    • Autoscaling (preview), pour permettre à Spanner d'ajouter et de supprimer automatiquement des ressources de calcul capacité. L'autoscalabilité gérée est disponible dans les éditions Spanner Enterprise et Enterprise Plus. Pour en savoir plus sur l'autoscaler géré, consultez la page Autoscaler géré pour Spanner Configurez les options d'autoscaler géré suivantes :

      • Minimum indique la limite minimale à laquelle vous pouvez réduire la capacité de calcul, en fonction de l'unité de mesure que vous choisissez pour Capacité de calcul. Pour en savoir plus, consultez la section Déterminer la limite minimale.
      • Maximum indique la limite maximale du scaling à la hausse. en fonction de l'unité de mesure que vous choisissez pour les calculs capacité. Pour en savoir plus, consultez Déterminez la limite maximale.
      • L'objectif d'utilisation du processeur de haute priorité indique la cible pourcentage du CPU de haute priorité à utiliser. Pour en savoir plus, consultez la section Déterminer l'objectif d'utilisation du processeur.
      • L'objectif d'utilisation du stockage indique le pourcentage cible. d'espace de stockage à utiliser. Pour en savoir plus, consultez Déterminez la cible d'utilisation du stockage.

14. Cliquez sur Créer pour créer l'instance.

gcloud

Utilisez le gcloud spanner instances create pour créer une instance. Spécifiez la capacité de calcul comme le nombre de nœuds ou d'unités de traitement à utiliser sur l'instance.

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--nodes=NODE_COUNT

ou

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--processing-units=PROCESSING_UNIT_COUNT

Remplacez les éléments suivants :

• INSTANCE-ID : identifiant permanent unique au sein de votre projet Google Cloud. Une fois cet ID d'instance créé, vous ne pourrez plus le modifier.
• INSTANCE-CONFIG : identifiant permanent de la configuration de votre instance, qui définit l'emplacement géographique de l'instance et affecte la réplication des données. Pour les configurations d'instances personnalisées, il commence par custom-. Pour en savoir plus, consultez la section Configurations d'instance.
• INSTANCE_DESCRIPTION : nom à afficher pour l'instance dans la console Google Cloud. Le nom de l'instance doit être unique au sein de votre projet Google Cloud.
• NODE-COUNT : capacité de calcul de l'instance, exprimée en nombre de nœuds. Chaque nœud équivaut à 1 000 unités de traitement.
• PROCESSING_UNIT_COUNT : capacité de calcul de l'instance, exprimée en nombre d'unités de traitement. Saisissez des quantités jusqu'à 1 000 sous la forme de multiples de 100 (100, 200, 300, etc.) et saisissez une valeur supérieure des quantités sous forme de multiples de 1 000 (1 000, 2 000, 3 000, etc.). Remarque : N'utilisez pas ce paramètre si vous créez une instance que vous prévoyez d'activer ultérieurement avec l'autoscaler géré.

Ajouter l'autoscaling géré (bêta)

Vous pouvez également créer des instances Enterprise et Enterprise Plus pour utiliser l'autoscaling géré avec la commande gcloud beta spanner instances create. Pour en savoir plus, consultez la section Autoscaler géré pour Spanner.

Utilisez la commande suivante pour créer une instance avec un autoscaler géré.

  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

ou

  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

Remplacez les éléments suivants :

• INSTANCE-ID : identifiant permanent unique au sein de votre projet Google Cloud. Une fois cet ID d'instance créé, vous ne pourrez plus le modifier.
• INSTANCE-CONFIG: identifiant permanent de votre instance qui définit l'emplacement géographique de l'instance affecte la façon dont les données sont répliquées. Pour les configurations d'instances personnalisées, commence par custom-. Pour en savoir plus, consultez la section Configurations d'instance.
• INSTANCE-DESCRIPTION : nom à afficher pour l'instance dans la console Google Cloud. Le nom de l'instance doit être unique au sein de votre projet Google Cloud.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES : nombre minimal d'unités de traitement ou de nœuds lors de la réduction de l'échelle. Pour en savoir plus, consultez la section Déterminer la limite minimale.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: le le nombre maximal d'unités de traitement ou de nœuds lors d'un scaling à la hausse. Pour plus pour en savoir plus, consultez Déterminez la limite maximale.
• CPU_PERCENTAGE : pourcentage cible de processeur de haute priorité à utiliser, compris entre 10 et 90 %. Si vous optimisez les coûts, utilisez une valeur un pourcentage. Pour en savoir plus, consultez Déterminez l'objectif d'utilisation du processeur.
• STORAGE_PERCENTAGE: pourcentage cible de l'espace de stockage à utiliser de 10 à 99%. Pour en savoir plus, consultez Déterminez l'objectif d'utilisation du stockage.

Exemples d'utilisation des configurations personnalisées

Créer une instance test-instance dans l'instance régionale de base configuration us-central1, exécutez:

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

Créer une instance custom-eur6-instance dans l'emplacement multirégional personnalisé configuration d'instance custom-eur6, d'abord créer une configuration d'instance personnalisée.

Exécutez ensuite la commande ci-dessous :

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

Un message semblable à l'exemple suivant doit s'afficher une fois que vous avez exécuté l'une des commandes précédentes:

Creating instance...done.

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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
}

Créer une instance avec autoscaling géré à l'aide de Go (Preview)

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour Java sont archivés sur GitHub.

Créer une instance avec autoscaling géré à l'aide de Java (Preview)

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

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Remarque:Les exemples de code de l'ancienne interface de la bibliothèque cliente pour Node.js sont archivés dans GitHub

PHP

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez la page Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Remarque : Les anciens exemples de code d'interface de bibliothèque client pour PHP sont archivés sur GitHub.

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez la page Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Remarque : Les anciens exemples de code d'interface de bibliothèque cliente pour Python sont archivés sur GitHub.

Ruby

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

# 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

Répertorier les instances

Vous pouvez afficher la liste de vos instances Spanner.

Console

Accédez à la page Instances Spanner dans la console Google Cloud.

Accéder à la page Instances

La console Google Cloud affiche la liste de vos fichiers Spanner ainsi que l'ID, le nom à afficher, la configuration et capacité de calcul, exprimée à la fois en unités de traitement et en nœuds.

gcloud

Exécutez la commande gcloud spanner instances list :

gcloud spanner instances list

La CLI gcloud affiche la liste de vos instances Spanner, ainsi que l'ID, le nom d'affichage, la configuration et la capacité de calcul de chaque instance.

Modifier une instance

Les sections suivantes expliquent comment mettre à niveau l'édition de votre instance, et modifier son nom à afficher et sa capacité de calcul. Vous ne pouvez pas modifier l'ID ni la configuration d'une instance (vous pouvez toutefois déplacer votre instance).

Passer à une édition supérieure

Vous pouvez mettre à niveau vos instances de l'édition Standard vers un niveau supérieur édition. Les instances de l'édition Standard peuvent être migrées vers l'édition Enterprise ou Enterprise Plus. Les instances de l'édition Enterprise peuvent être mises à niveau vers Édition Enterprise Plus.

Le retour à une version antérieure en libre-service n'est pas disponible. Pour passer à une édition inférieure envoyez une demande d'assistance. Pour en savoir plus, consultez les questions fréquentes sur les éditions Spanner.

Console

1. Accédez à la page Instances de Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance que vous souhaitez mettre à niveau.

3. Cliquez sur Mettre à niveau à côté du type d'édition.

4. Sur la page Instance d'édition, sous Mettre à jour l'édition, sélectionnez la nouvelle édition de niveau supérieur pour votre instance.

5. Cliquez sur Enregistrer.

gcloud

Utilisez le gcloud spanner instances update pour mettre à niveau l'édition de votre instance:

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

Remplacez les éléments suivants :

• INSTANCE_ID : identifiant permanent de l'instance.
• EDITION : spécifiez la nouvelle édition de niveau supérieur pour votre instance. Pour en savoir plus, consultez la présentation des éditions Spanner.

Indicateurs facultatifs :

• --async : utilisez cet indicateur si vous souhaitez que votre requête soit renvoyée immédiatement, sans attendre la fin de l'opération en cours. Vous pouvez vérifier l'état de votre demande en exécutant gcloud spanner operations describe.

Go

import (
	"context"
	"fmt"
	"io"

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

func updateInstance(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// The edition selected for this instance.
			// Different editions provide different capabilities at different price points.
			// For more information, see https://cloud.google.com/spanner/docs/editions-overview.
			Edition: instancepb.Instance_ENTERPRISE,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"edition"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID)
	return nil
}

Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceExample {

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

  static void updateInstance(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Updated name";

    // Update an Instance object that will be used to update the instance.
    Instance instance =
        Instance.newBuilder()
            .setName(InstanceName.of(projectId, instanceId).toString())
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setEdition(Instance.Edition.ENTERPRISE)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the updatedInstance operation to finish.
      Instance updatedInstance =
          instanceAdminClient
              .updateInstanceAsync(
                  UpdateInstanceRequest.newBuilder()
                      .setFieldMask(
                          FieldMask.newBuilder().addAllPaths(Lists.newArrayList("edition")))
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Updating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");
    }
  }
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez la page Bibliothèques clientes Spanner.

Pour vous authentifier auprès de Spanner, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Modifier le nom à afficher

Console

1. Accédez à la page Instances de Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance que vous souhaitez renommer.

3. Cliquez sur Modifier l'instance.

4. Saisissez un nouveau nom d'instance. Ce nom doit être unique au sein du projet Google Cloud.

5. Cliquez sur Enregistrer.

gcloud

Exécutez la commande gcloud spanner instances update :

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Remplacez les éléments suivants :

• INSTANCE_ID: identifiant permanent de l'instance.
• INSTANCE_NAME : nom à afficher pour l'instance dans la console Google Cloud. Le nom de l'instance doit être unique au sein de votre projet Google Cloud.

Modifier la capacité de calcul

Vous devez provisionner une capacité de calcul suffisante pour conserver Utilisation du processeur utilisation du stockage inférieure aux valeurs maximales recommandées. Pour plus d'informations, consultez les quotas et limites pour Spanner.

Dans certains cas, vous ne pouvez pas réduire la capacité de calcul d'une instance existante :

• Pour supprimer de la capacité de calcul, votre instance doit stocker plus de 4 To de données pour 1 000 unités de traitement (1 nœud).
• En se basant sur l'historique de vos schémas d'utilisation, Spanner a créé un grand nombre de divisions pour les données de votre instance. Dans de rares cas, Spanner ne serait plus en mesure de gérer ces divisions en cas de suppression de la capacité de calcul.

Dans ce cas, vous pouvez essayer de réduire la capacité de calcul progressivement par petites quantités jusqu'à ce que vous trouviez la capacité minimale dont Spanner a besoin pour gérer toutes les divisions de l'instance. Si l'instance ne nécessite plus En raison d'un changement des schémas d'utilisation, le nombre de divisions vous pouvez fusionner des divisions et essayer de réduire la capacité de calcul de l'instance après une semaine ou deux.

Lorsque vous supprimez de la capacité de calcul, surveillez l'utilisation du processeur et les latences des requêtes dans Cloud Monitoring pour vous assurer que l'utilisation du processeur reste inférieure à 65 % pour les instances régionales et à 45 % pour chaque région des instances multirégionales. Il est possible que la latence des requêtes augmente temporairement lors de la suppression de la capacité de calcul.

Si vous souhaitez augmenter la capacité de calcul d'une instance, votre projet Google Cloud doit disposer d'un quota suffisant. Le temps nécessaire au traitement de la demande d'augmentation dépend de la taille de la requête. Dans la plupart des cas, les requêtes sont traitées en quelques minutes. Activé dans de rares cas, une mise à l'échelle peut prendre jusqu'à une heure.

Console

1. Accédez à la page Instances Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance que vous souhaitez modifier.

3. Cliquez sur Modifier l'instance.

4. Modifiez la capacité de calcul en choisissant les unités de mesure (unités de traitement ou nœuds), puis saisissez une quantité. Lorsque vous utilisez unités de traitement, saisissez jusqu'à 1 000 par multiples de 100 (100, 200, 300, etc.) et saisir des quantités supérieures par multiples de 1 000 (1 000, 2 000, 3 000, etc.). Chaque nœud équivaut à 1 000 unités de traitement.

5. Cliquez sur Enregistrer.

Si vous voyez apparaître une boîte de dialogue indiquant que votre quota est insuffisant pour ajouter de la capacité de calcul à cet emplacement, suivez les instructions pour demander une augmentation de quota.

gcloud

Exécutez la commande gcloud spanner instances update. Lorsque vous utilisez cette commande, spécifiez la capacité de calcul en nombre de nœuds ou d'unités de traitement.

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

ou

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

Remplacez les éléments suivants :

• INSTANCE_ID : identifiant permanent de l'instance.
• NODE_COUNT : capacité de calcul de l'instance, exprimée en nombre de nœuds. Chaque nœud équivaut à 1 000 unités de traitement.
• PROCESSING_UNIT_COUNT: capacité de calcul de l'instance exprimé en nombre d'unités de traitement. Saisissez des quantités allant jusqu'à 1 000 par multiples de 100 (100, 200, 300, etc.) et saisissez des quantités supérieures par multiples de 1 000 (1 000, 2 000, 3 000, etc.).

Indicateurs facultatifs :

• --async : utilisez cette option si vous souhaitez que votre requête soit renvoyée immédiatement, sans attendre la fin de l'opération en cours. Vous pouvez consulter l'état de votre requête en exécutant gcloud spanner operations describe

Activer ou modifier l'autoscaler géré sur une instance

Preview — Managed autoscaler

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Les limites suivantes s'appliquent lorsque vous ajoutez ou modifiez la fonctionnalité d'autoscaling géré sur une instance existante :

• L'autoscaler géré n'est disponible que dans l'édition Enterprise ou Enterprise Plus.
• Vous ne pouvez pas activer l'autoscaler géré sur une instance que vous déplacez.

• Vous ne pouvez pas déplacer une instance lorsque l'autoscaler géré est est activé.

Console

1. Accédez à la page Instances de Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance pour laquelle vous souhaitez activer le service géré l'autoscaler est activé.

3. Cliquez sur Modifier l'instance.

4. Sous Configurer la capacité de calcul, cliquez sur Autoscaling.

5. Dans Minimum, sélectionnez la limite minimale à utiliser pour le scaling à la baisse. Pour en savoir plus, consultez la section Déterminer la limite minimale.

6. Dans Maximum, sélectionnez la limite maximale à utiliser pour l'augmentation de la capacité. Pour en savoir plus, consultez Déterminer la limite maximale.

7. Pour Objectif d'utilisation du processeur à priorité élevée, sélectionnez le pourcentage à haute priorité. Pour en savoir plus, consultez la section Déterminer l'objectif d'utilisation du processeur.

8. Pour Objectif d'utilisation du stockage, sélectionnez le pourcentage d'espace de stockage à utiliser. Pour en savoir plus, consultez Déterminez l'objectif d'utilisation du stockage.

9. Cliquez sur Enregistrer.

gcloud

Utilisez la commande gcloud beta spanner instances update pour ajouter l'autoscaler géré à une instance. Pour en savoir plus et connaître les limites, consultez Options et limites Google Cloud CLI.

Vous pouvez ajouter l'autoscaler géré à l'aide de la commande suivante:

  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

ou

  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

Remplacez les éléments suivants :

• INSTANCE_ID : identifiant permanent de l'instance.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: le le nombre minimal d'unités de traitement ou de nœuds à utiliser pour effectuer un scaling à la baisse. Pour en savoir plus, consultez la section Déterminer la limite minimale.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: le le nombre maximal d'unités de traitement ou de nœuds à utiliser pour le scaling à la hausse. Pour en savoir plus, consultez la section Déterminer la limite maximale.
• CPU_PERCENTAGE: pourcentage cible du processeur à priorité élevée à de 10% à 90%. Si vous optimisez pour le coût et que vous n'avez pas besoin d'une faible latence pour toutes les requêtes, utilisez un pourcentage plus élevé. Pour plus pour en savoir plus, consultez Déterminez l'objectif d'utilisation du processeur.
• STORAGE_PERCENTAGE : pourcentage cible d'espace de stockage à utiliser, compris entre 10 % et 99 %. Pour en savoir plus, consultez la section Déterminer l'objectif d'utilisation du stockage.

Après avoir ajouté l'autoscaler géré à une instance, vous pouvez également modifier ses paramètres. Par exemple, si vous souhaitez augmenter le nombre maximal d'unités de traitement à 10 000, exécutez la commande suivante :

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

Faire passer une instance de l'utilisation de l'autoscaler géré au scaling manuel

Preview — Managed autoscaling

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Console

1. Accédez à la page Instances de Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance que vous souhaitez désactiver. l'autoscaler est activé.

3. Sous Sélectionner un mode de scaling, cliquez sur Allocation manuelle.

4. Cliquez sur Enregistrer.

gcloud

Utilisez la commande gcloud beta spanner instances update pour mettre à jour l'instance.

Utilisez la commande suivante pour passer d'un autoscaling géré à un autoscaling manuel pour une instance :

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

ou

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

Remplacez les éléments suivants :

• INSTANCE_ID: identifiant permanent de l'instance.
• NODE_COUNT: capacité de calcul de l'instance, exprimée en nombre de nœuds. Chaque nœud équivaut à 1 000 unités de traitement.
• PROCESSING_UNIT_COUNT : capacité de calcul de l'instance, exprimée en nombre d'unités de traitement. Saisissez des quantités allant jusqu'à 1 000 par multiples de 100 (100, 200, 300, etc.) et saisissez des quantités supérieures par multiples de 1 000 (1 000, 2 000, 3 000, etc.).

Ajouter un libellé à une instance

Les libellés vous aident à organiser vos ressources.

Console

1. Accédez à la page Instances Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cochez la case correspondant à l'instance. Le panneau d'informations apparaît sur le côté droit de la page.

3. Cliquez sur l'onglet Libellés dans le panneau d'informations. Vous pouvez ensuite ajouter, supprimer ou mettre à jour des étiquettes pour l'instance Spanner.

Déplacer une instance

Remarque :Vous ne pouvez pas déplacer une instance pour laquelle l'autoscaler géré est activé.

Pour savoir comment déplacer votre instance de n'importe quelle configuration d'instance vers Toute autre configuration d'instance, y compris entre une configuration régionale et multirégionale de configuration, consultez la section Déplacer une instance.

Supprimer une instance

Avertissement : La suppression définitive d'une instance implique la suppression de toutes ses bases de données. Cette action est irréversible. Vous ne pouvez pas non plus en créer instance en essai sans frais une fois que vous avez supprimé votre première instance en essai sans frais. Toi vous pouvez créer une instance en essai sans frais par cycle de vie de projet.

Vous pouvez supprimer une instance à l'aide de la console Google Cloud ou de la Google Cloud CLI :

Si vous souhaitez supprimer une instance comportant une ou plusieurs bases de données avec protection contre la suppression activée, vous devez d'abord Désactiver la protection contre la suppression sur toutes les bases de données de cette instance avant de pouvoir la supprimer.

Console

1. Accédez à la page Instances de Spanner dans la console Google Cloud.

   Accéder à la page Instances

2. Cliquez sur le nom de l'instance que vous souhaitez supprimer.

3. Cliquez sur Supprimer l'instance.

4. Suivez les instructions pour confirmer que vous souhaitez bien supprimer l'instance.

5. Cliquez sur Supprimer.

gcloud

Exécutez la commande gcloud spanner instances delete, en remplaçant INSTANCE_ID par l'ID d'instance :

gcloud spanner instances delete INSTANCE_ID

Arrêter ou redémarrer une instance

Spanner est un service de base de données entièrement géré qui supervise ses propres tâches et ressources sous-jacentes, y compris la surveillance et le redémarrage des processus si nécessaire, sans temps d'arrêt. Comme il n'est pas nécessaire de modifier manuellement arrêter ou redémarrer une instance donnée, Spanner ne permet pas le faire.

Étape suivante

• Découvrez comment insérer, mettre à jour et supprimer des données avec Langage de manipulation de données (LMD) ou gcloud CLI
• Attribuez des rôles Identity and Access Management pour l'instance et ses bases de données.
• Découvrez comment concevoir un schéma Spanner.