Cette page a été traduite par l'API Cloud Translation.

Créer et gérer des instances

Cette page explique comment créer, répertorier, modifier et supprimer des instances 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 une instance avec une configuration d'instance personnalisée en ajoutant des instances répliquées en lecture seule facultatives.

Console

Dans la console Google Cloud , accédez à la page Instances Spanner.
Cliquez sur Créer une instance.

Accéder à la page Créer une instance
Dans la section Sélectionner une édition, sélectionnez une édition Spanner.

Si vous souhaitez comparer les spécifications des différentes éditions, cliquez sur Comparer les éditions. Pour en savoir plus, consultez la présentation des éditions Spanner.
Cliquez sur Continuer.
Dans la section Nommez votre instance, saisissez un Nom de l'instance à afficher dans la console Google Cloud . Le nom de l'instance doit être unique au sein de votre projet Google Cloud .
Saisissez un ID d'instance pour identifier votre instance de manière permanente. L'ID d'instance doit également être unique au sein de votre projet Google Cloud . Vous ne pourrez pas modifier l'ID d'instance par la suite.
Cliquez sur Continuer.
Dans la section Configurer votre instance, sous Sélectionner une configuration, sélectionnez Régional, Birégional ou Multirégional.

Remarque : Les configurations d'instance birégionales et multirégionales ne sont disponibles que dans l'édition Enterprise Plus. Si vous souhaitez comparer les spécifications des trois configurations, cliquez sur Comparer les configurations régionales.
Sélectionnez un emplacement de configuration dans le menu déroulant.
Facultatif : Pour ajouter une instance répliquée 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 d'instances dupliquées en lecture seule facultatives à une configuration de base est disponible dans les éditions Enterprise et Enterprise Plus.
Cliquez sur Continuer.
Dans la section Allouer une capacité de calcul, sous Sélectionner une unité, cliquez sur l'une des options suivantes :
- Nœuds pour les instances volumineuses. Un nœud correspond à 1 000 unités de traitement.
- Unités de traitement pour les petites instances.
Pour en savoir plus, consultez Capacité de calcul, nœuds et unités de traitement.
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.
  - Quantité indique le nombre d'unités de traitement ou de nœuds à utiliser pour cette instance.
- L'autoscaling permet à Spanner d'ajouter et de supprimer automatiquement de la capacité de calcul. Le scaling automatique géré est disponible dans les éditions Enterprise et Enterprise Plus de Spanner. Pour en savoir plus sur l'autoscaler géré, consultez Autoscaler géré pour Spanner. Configurez les options suivantes de l'autoscaler géré :
  - Minimum indique la limite minimale de réduction, en fonction de l'unité de mesure que vous choisissez pour Capacité de calcul. Pour en savoir plus, consultez Déterminer la limite minimale.
  - Maximum indique la limite maximale à laquelle effectuer un scaling, en fonction de l'unité de mesure que vous choisissez pour la capacité de calcul. Pour en savoir plus, consultez Déterminer la limite maximale.
  - L'objectif d'utilisation du CPU à haute priorité indique le pourcentage cible de CPU à haute priorité à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
  - L'objectif d'utilisation du stockage indique le pourcentage de stockage à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.
Facultatif : Si vous sélectionnez Autoscaling comme mode de scaling, vous pouvez cliquer sur le menu déroulant Afficher les options d'autoscaling asymétrique pour effectuer l'autoscaling de vos réplicas en lecture seule indépendamment des autres réplicas. Pour en savoir plus, consultez Autoscaling asymétrique en lecture seule.
1. Sélectionnez la réplique en lecture seule dont vous souhaitez effectuer l'autoscaling asymétrique.
2. Configurez les options d'autoscaler asymétrique suivantes :
  - Minimum indique la limite minimale de réduction, en fonction de l'unité de mesure que vous choisissez pour Capacité de calcul. Pour en savoir plus, consultez Déterminer la limite minimale.
  - Maximum indique la limite maximale à laquelle effectuer un scaling, en fonction de l'unité de mesure que vous choisissez pour la capacité de calcul. Pour en savoir plus, consultez Déterminer la limite maximale.
  - L'objectif d'utilisation du CPU à haute priorité indique le pourcentage cible de CPU à haute priorité à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
Sous Sauvegardes, la case Activer les planifications de sauvegarde par défaut est cochée par défaut. Pour désactiver les planifications de sauvegarde par défaut, décochez la case. Lorsque cette option est activée, des sauvegardes complètes sont créées pour toutes les nouvelles bases de données de l'instance toutes les 24 heures. Ces sauvegardes sont conservées pendant sept jours. Vous pouvez modifier ou supprimer les planifications de sauvegarde par défaut à tout moment. Pour en savoir plus, consultez Programmes de sauvegarde par défaut.
Cliquez sur Créer pour créer l'instance.

gcloud

Utilisez la commande gcloud spanner instances create pour créer une instance. Spécifiez la capacité de calcul en nombre de nœuds ou d'unités de traitement que vous souhaitez pour l'instance.

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--nodes=NODE_COUNT

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--processing-units=PROCESSING_UNIT_COUNT

Remplacez les éléments suivants :

INSTANCE-ID : identifiant permanent unique au sein de votre projet Google Cloud . Vous ne pourrez pas modifier l'ID d'instance par la suite.
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 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 projetGoogle Cloud .
DEFAULT_BACKUP_SCHEDULE_TYPE : type de calendrier de sauvegarde par défaut utilisé dans l'instance. Il doit s'agir de l'une des options suivantes :
- AUTOMATIC : une programmation de sauvegarde par défaut est créée automatiquement lorsqu'une base de données est créée dans l'instance. La planification de sauvegarde par défaut crée une sauvegarde complète toutes les 24 heures. Ces sauvegardes complètes sont conservées pendant sept jours. Vous pouvez modifier ou supprimer la planification de sauvegarde par défaut une fois qu'elle a été créée.
- NONE : aucune planification de sauvegarde par défaut n'est créée automatiquement lorsqu'une base de données est créée dans l'instance.
NODE-COUNT : la 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 : la 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.). 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é

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

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

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

Remplacez les éléments suivants :

INSTANCE-ID : identifiant permanent unique au sein de votre projet Google Cloud . Vous ne pourrez pas modifier l'ID d'instance par la suite.
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 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 projetGoogle Cloud .
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES : nombre minimal d'unités de traitement ou de nœuds lors de la réduction de la capacité. Pour en savoir plus, consultez Déterminer la limite minimale.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES : nombre maximal d'unités de traitement ou de nœuds lors de la mise à l'échelle. Pour en savoir plus, consultez Déterminer la limite maximale.
CPU_PERCENTAGE : pourcentage cible de processeur de haute priorité à utiliser, de 10 à 90 %. Si vous optimisez vos campagnes pour le coût, utilisez un pourcentage plus élevé. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
STORAGE_PERCENTAGE : pourcentage cible de stockage à utiliser, entre 10 et 99 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.

Indicateurs facultatifs :

--asymmetric-autoscaling-option : utilisez cette option pour activer l'autoscaling asymétrique. Remplacez les paramètres suivants :
- ASYMMETRIC_AUTOSCALING_LOCATION : si l'indicateur est utilisé, ce paramètre est obligatoire. Emplacement de la région en lecture seule que vous souhaitez mettre à l'échelle de manière asymétrique.
- ASYMMETRIC_AUTOSCALING_MIN : paramètre facultatif. Nombre minimal de nœuds lors d'un scaling à la baisse.
- ASYMMETRIC_AUTOSCALING_MAX : paramètre facultatif. Nombre maximal de nœuds lors de l'augmentation de la capacité.
- ASYMMETRIC_CPU_TARGET : paramètre facultatif. Pourcentage cible de CPU à haute priorité à utiliser, de 10 à 90 %. Si vous optimisez vos campagnes pour le coût, utilisez un pourcentage plus élevé.

Exemples d'utilisation de configurations personnalisées

Pour créer une instance test-instance dans la configuration d'instance régionale de base us-central1, exécutez la commande suivante :

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

Pour créer une instance custom-eur6-instance dans la configuration d'instance multirégionale personnalisée custom-eur6, commencez par 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 après l'exécution de l'une des commandes précédentes :

Creating instance...done.

C++

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.

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 la page Bibliothèques clientes Spanner.


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceAsyncSample
{
    public async Task<Instance> CreateInstanceAsync(
        string projectId,
        string instanceId,
        Instance.Types.Edition edition = Instance.Types.Edition.Standard)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-us-central1"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            Edition = edition,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

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

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

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

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

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

        return completedResponse.Result;
    }
}

Créer une instance sans calendrier de sauvegarde par défaut


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceWithoutDefaultBackupSchedulesAsyncSample
{
    public async Task<Instance> CreateInstanceWithoutDefaultBackupSchedulesAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName =
                InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-me-central2"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.None,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

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

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

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

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

        Console.WriteLine($"Instance created successfully.");
        return completedResponse.Result;
    }
}

Go

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 2,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

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

Créer une instance avec autoscaling asymétrique en lecture seule à l'aide de 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"
)

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

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

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

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

Créer une instance sans calendrier de sauvegarde par défaut

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)

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

	// Create an instance without default backup schedule, whicn means no default backup schedule will
	// be created automatically on creation of a database within the instance.
	req := &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:                    fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName:               instanceID,
			NodeCount:                 1,
			Labels:                    map[string]string{"cloud_spanner_samples": "true"},
			DefaultBackupScheduleType: instancepb.Instance_NONE,
		},
	}

	op, err := instanceAdmin.CreateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.  For more information about instances, see
	// https://cloud.google.com/spanner/docs/instances.
	instance, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if instance.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", instance.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

Java

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


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

Créer une instance avec autoscaling géré à l'aide de 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.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Créer une instance avec autoscaling asymétrique en lecture seule à l'aide de 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.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Créer une instance sans calendrier de sauvegarde par défaut


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

class CreateInstanceWithoutDefaultBackupSchedulesExample {

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

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

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.NONE)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

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

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

Node.js

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


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

Créer une instance avec autoscaling géré à l'aide de Node.js

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

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

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

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

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

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

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

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

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

Créer une instance sans calendrier de sauvegarde par défaut

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

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

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

const instanceAdminClient = await spanner.getInstanceAdminClient();
// Creates a new instance
try {
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-me-central2',
      ),
      nodeCount: 1,
      displayName: 'Display name for the instance.',
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.NONE,
    },
  });
  await operation.promise();

  console.log(
    `Created instance ${instanceId} without default backup schedules.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

PHP

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

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\Instance;

/**
 * Creates an instance.
 * Example:
 * ```
 * create_instance($projectId, $instanceId);
 * ```
 *
 * @param string $projectId  The Spanner project ID.
 * @param string $instanceId The Spanner instance ID.
 */
function create_instance(string $projectId, string $instanceId): void
{
    $instanceAdminClient = new InstanceAdminClient();
    $parent = InstanceAdminClient::projectName($projectId);
    $instanceName = InstanceAdminClient::instanceName($projectId, $instanceId);
    $configName = $instanceAdminClient->instanceConfigName($projectId, 'regional-us-central1');
    $instance = (new Instance())
        ->setName($instanceName)
        ->setConfig($configName)
        ->setDisplayName('dispName')
        ->setNodeCount(1);

    $operation = $instanceAdminClient->createInstance(
        (new CreateInstanceRequest())
        ->setParent($parent)
        ->setInstanceId($instanceId)
        ->setInstance($instance)
    );

    print('Waiting for operation to complete...' . PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created instance %s' . PHP_EOL, $instanceId);
}

Python

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

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

Créer une instance avec autoscaling géré à l'aide de Python

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

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

    spanner_client = spanner.Client()

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

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

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

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

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

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

Créer une instance sans calendrier de sauvegarde par défaut

def create_instance_without_default_backup_schedules(instance_id):
    spanner_client = spanner.Client()
    config_name = "{}/instanceConfigs/regional-me-central2".format(
        spanner_client.project_name
    )

    operation = spanner_client.instance_admin_api.create_instance(
      parent=spanner_client.project_name,
      instance_id=instance_id,
      instance=spanner_instance_admin.Instance(
          config=config_name,
          display_name="This is a display name.",
          node_count=1,
          default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.NONE,  # Optional
      ),
    )

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

    print("Created instance {} without default backup schedules".format(instance_id))

Ruby

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

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# instance_config_id = "Your Spanner InstanceConfig ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/instance"

instance_admin_client = Google::Cloud::Spanner::Admin::Instance.instance_admin

project_path = instance_admin_client.project_path project: project_id
instance_path = instance_admin_client.instance_path project: project_id, instance: instance_id
instance_config_path = instance_admin_client.instance_config_path project: project_id, instance_config: instance_config_id

job = instance_admin_client.create_instance parent: project_path,
                                            instance_id: instance_id,
                                            instance: { name: instance_path,
                                                        config: instance_config_path,
                                                        display_name: instance_id,
                                                        node_count: 2,
                                                        labels: { cloud_spanner_samples: "true" } }

puts "Waiting for create instance operation to complete"

job.wait_until_done!

if job.error?
  puts job.error
else
  puts "Created instance #{instance_id}"
end

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 instances Spanner, ainsi que l'ID, le nom d'affichage, la configuration et la capacité de calcul de chaque instance, exprimée en unités de traitement et en nœuds.

gcloud

Exécutez la commande gcloud spanner instances list :

gcloud spanner instances list

Gcloud CLI 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 comment modifier le nom à afficher, la capacité de calcul et le type de calendrier de sauvegarde par défaut d'une instance. Vous ne pouvez pas modifier l'ID ni la configuration d'une instance (mais vous pouvez déplacer votre instance).

Mettre à niveau l'édition

Vous pouvez mettre à niveau vos instances de l'édition Standard vers une édition de niveau supérieur. Les instances de l'édition Standard peuvent être mises à niveau vers l'édition Enterprise ou Enterprise Plus. Les instances de l'édition Enterprise peuvent être mises à niveau vers l'édition Enterprise Plus. La mise à niveau de l'édition prend environ 10 minutes et n'entraîne aucun temps d'arrêt.

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance que vous souhaitez mettre à niveau.
Cliquez sur Mettre à niveau à côté du type d'édition.
Sur la page Édition de l'instance, sous Mettre à jour l'édition, sélectionnez la nouvelle édition de niveau supérieur pour votre instance.
Cliquez sur Enregistrer.

gcloud

Exécutez la commande 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 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 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 la page Bibliothèques clientes Spanner.


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

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

    spanner_client = spanner.Client()

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

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

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

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

Rétrograder l'édition

Vous pouvez passer à une édition de niveau inférieur pour vos instances Spanner. Pour passer à un forfait inférieur, vous devez arrêter d'utiliser les fonctionnalités de l'édition de niveau supérieur. Vous pouvez passer des instances de l'édition Enterprise à l'édition Standard. Les instances de l'édition Enterprise Plus peuvent être rétrogradées vers l'édition Enterprise ou Standard. La rétrogradation de l'édition prend environ 10 minutes et n'entraîne aucun temps d'arrêt.

gcloud

Utilisez la commande gcloud spanner instances update pour passer à une édition inférieure de votre instance :

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Remplacez les éléments suivants :

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

Modifier le nom à afficher

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance que vous souhaitez renommer.
Cliquez sur Modifier l'instance.
Saisissez un nouveau nom d'instance. Ce nom doit être unique au sein du projetGoogle Cloud .
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 consoleGoogle Cloud . Le nom de l'instance doit être unique au sein de votre projetGoogle Cloud .

Modifier la capacité de calcul

Vous devez provisionner suffisamment de capacité de calcul pour que l'utilisation du processeur et l'utilisation du stockage restent inférieures aux valeurs maximales recommandées. Pour en savoir plus, consultez les quotas et limites de Spanner.

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

Pour supprimer la capacité de calcul, votre instance doit stocker plus de 10 Tio 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, le service 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 autant de divisions en raison d'un changement des modèles d'utilisation, Spanner peut fusionner certaines divisions et vous permettre d'essayer de réduire la capacité de calcul de l'instance au bout d'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 projetGoogle Cloud doit disposer d'un quota suffisant. Le temps nécessaire pour traiter la demande d'augmentation dépend de sa taille. Dans la plupart des cas, les demandes sont traitées en quelques minutes. Dans de rares cas, l'augmentation de la capacité peut prendre jusqu'à une heure.

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance que vous souhaitez modifier.
Cliquez sur Modifier l'instance.
Modifiez la capacité de calcul en choisissant les unités de mesure (unités de traitement ou nœuds), puis en saisissant une quantité. Lorsque vous utilisez des 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.). Chaque nœud équivaut à 1 000 unités de traitement.
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]

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 : la 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 : la 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.).

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 vérifier l'état de votre demande en exécutant gcloud spanner operations describe.

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

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 les éditions Enterprise ou Enterprise Plus.
Vous ne pouvez pas activer le scaler automatique géré sur une instance que vous déplacez.
Vous ne pouvez pas déplacer une instance lorsque le scaler automatique géré est activé.

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance sur laquelle vous souhaitez activer le scaler automatique géré.
Cliquez sur Modifier l'instance.
Sous Configurer la capacité de calcul, cliquez sur Autoscaling.
Pour Minimum, sélectionnez la limite minimale à utiliser lors du scaling à la baisse. Pour en savoir plus, consultez Déterminer la limite minimale.
Pour Maximum, sélectionnez la limite maximale à utiliser lors du scaling-up. Pour en savoir plus, consultez Déterminer la limite maximale.
Pour Objectif d'utilisation du processeur de haute priorité, sélectionnez le pourcentage de processeur de haute priorité à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
Pour Objectif d'utilisation du stockage, sélectionnez le pourcentage de stockage à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.
Facultatif : Si vous sélectionnez Autoscaling comme mode de scaling, vous pouvez cliquer sur le menu déroulant Afficher les options d'autoscaling asymétrique pour effectuer l'autoscaling de vos réplicas en lecture seule indépendamment des autres réplicas.
1. Sélectionnez la réplique en lecture seule dont vous souhaitez effectuer l'autoscaling asymétrique.
2. Configurez les options Autoscaler suivantes :
  - Minimum indique la limite minimale de réduction, en fonction de l'unité de mesure que vous choisissez pour Capacité de calcul. Pour en savoir plus, consultez Déterminer la limite minimale.
  - Maximum indique la limite maximale à laquelle effectuer un scaling, en fonction de l'unité de mesure que vous choisissez pour la capacité de calcul. Pour en savoir plus, consultez Déterminer la limite maximale.
  - L'objectif d'utilisation du CPU à haute priorité indique le pourcentage cible de CPU à haute priorité à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
Cliquez sur Enregistrer.

gcloud

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

Vous pouvez ajouter le scaling automatique géré à l'aide de la commande suivante :

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

  gcloud 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 \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

Remplacez les éléments suivants :

INSTANCE_ID : identifiant permanent de l'instance.
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES : nombre minimal d'unités de traitement ou de nœuds à utiliser lors de la réduction de la capacité. Pour en savoir plus, consultez Déterminer la limite minimale.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES : nombre maximal d'unités de traitement ou de nœuds à utiliser lors de la mise à l'échelle. Pour en savoir plus, consultez Déterminer la limite maximale.
CPU_PERCENTAGE : pourcentage cible de processeur à haute priorité à utiliser, entre 10 % et 90 %. Si vous optimisez les coûts et que vous n'avez pas besoin d'une faible latence pour toutes les requêtes, utilisez un pourcentage plus élevé. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
STORAGE_PERCENTAGE : pourcentage cible de stockage à utiliser, de 10 % à 99 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.

Indicateurs facultatifs :

--asymmetric-autoscaling-option : utilisez cette option pour activer l'autoscaling asymétrique. Remplacez les paramètres suivants :
- ASYMMETRIC_AUTOSCALING_LOCATION : si l'indicateur est utilisé, ce paramètre est obligatoire. Emplacement de la région en lecture seule que vous souhaitez mettre à l'échelle de manière asymétrique.
- ASYMMETRIC_AUTOSCALING_MIN : paramètre facultatif. Nombre minimal de nœuds lors d'un scaling à la baisse.
- ASYMMETRIC_AUTOSCALING_MAX : paramètre facultatif. Nombre maximal de nœuds lors de l'augmentation de la capacité.
- ASYMMETRIC_CPU_TARGET : paramètre facultatif. Pourcentage cible de CPU à haute priorité à utiliser, de 10 à 90 %. Si vous optimisez vos campagnes pour le coût, utilisez un pourcentage plus élevé.

Une fois l'autoscaler géré ajouté à 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 spanner instances update test-instance \
     --autoscaling-max-processing-units=10000

Passer d'un autoscaler géré à un scaling manuel pour une instance

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance sur laquelle vous souhaitez désactiver l'autoscaler géré.
Sous Choisir un mode de scaling, cliquez sur Allocation manuelle.
Cliquez sur Enregistrer.

gcloud

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

Exécutez la commande suivante pour passer d'un autoscaler géré à un scaling manuel pour une instance :

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

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Remplacez les éléments suivants :

INSTANCE_ID : identifiant permanent de l'instance.
NODE_COUNT : la 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 : la 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

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

Accéder à la page Instances
Cochez la case correspondant à l'instance. Le panneau d'informations apparaît sur le côté droit de la page.
Cliquez sur l'onglet Libellés dans le panneau d'informations. Vous pouvez ensuite ajouter, supprimer ou mettre à jour des libellés pour l'instance Spanner.

Modifier le type de planification de sauvegarde par défaut

Les plannings de sauvegarde par défaut sont automatiquement activés pour toutes les nouvelles instances. Vous pouvez activer ou désactiver les planifications de sauvegarde par défaut dans une instance lors de la création de l'instance ou en la modifiant ultérieurement. Pour en savoir plus, consultez Programmes de sauvegarde par défaut.

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance dont vous souhaitez modifier la programmation de sauvegarde par défaut.
Cliquez sur Modifier l'instance.
Sous Sauvegardes, la case à cocher Activer les planifications de sauvegarde par défaut détermine si les planifications de sauvegarde par défaut sont activées ou non. Lorsqu'elle est activée, une planification de sauvegarde par défaut est créée pour toutes les nouvelles bases de données de cette instance.
Cliquez sur Enregistrer.

gcloud

Utilisez la commande gcloud spanner instances update pour modifier le type de planification des sauvegardes par défaut.

Vous pouvez modifier le type de planification de sauvegarde par défaut en exécutant la commande suivante :

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

Remplacez les éléments suivants :

INSTANCE_ID : identifiant permanent de l'instance.
DEFAULT_BACKUP_SCHEDULE_TYPE : type de calendrier de sauvegarde par défaut utilisé dans l'instance. Il doit s'agir de l'une des options suivantes :
- AUTOMATIC : une programmation de sauvegarde par défaut est créée automatiquement lorsqu'une base de données est créée dans l'instance. La planification de sauvegarde par défaut crée une sauvegarde complète toutes les 24 heures. Ces sauvegardes complètes sont conservées pendant sept jours. Vous pouvez modifier ou supprimer la planification de sauvegarde par défaut une fois qu'elle a été créée.
- NONE : aucune planification de sauvegarde par défaut n'est créée automatiquement lorsqu'une base de données est créée dans l'instance.

C#

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


using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System;
using System.Threading.Tasks;

public class UpdateInstanceDefaultBackupScheduleTypeAsyncSample
{
    public async Task<Instance> UpdateInstanceDefaultBackupScheduleTypeAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.Automatic,
        };
        FieldMask mask = new FieldMask 
        {
            Paths = { "default_backup_schedule_type" }
        };

        // Make the CreateInstance request.
        Operation<Instance, UpdateInstanceMetadata> response =
            await instanceAdminClient.UpdateInstanceAsync(instance, mask);

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

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

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

        Console.WriteLine($"Instance updated successfully.");
        return completedResponse.Result;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

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

// updateInstanceDefaultBackupScheduleType updates instance default backup schedule type to AUTOMATIC.
// This means a default backup schedule will be created automatically on creation of a database within the instance.
func updateInstanceDefaultBackupScheduleType(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	// Updates the default backup schedule type field of an instance.  The field mask is required to
	// indicate which field is being updated.
	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// Controls the default backup behavior for new databases within the instance.
			DefaultBackupScheduleType: instancepb.Instance_AUTOMATIC,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"default_backup_schedule_type"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

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

Java

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


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

public class UpdateInstanceDefaultBackupScheduleTypeExample {

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

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

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

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

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

Node.js

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

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

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

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

// Updates an instance
try {
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.AUTOMATIC, // optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['default_backup_schedule_type'],
    }),
  });

  await operation.promise();
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.defaultBackupScheduleType}` +
      ' default backup schedule type.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

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

def update_instance_default_backup_schedule_type(instance_id):
    spanner_client = spanner.Client()

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

    operation = spanner_client.instance_admin_api.update_instance(
      instance=spanner_instance_admin.Instance(
          name=name,
          default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.AUTOMATIC,  # Optional
      ),
      field_mask=field_mask_pb2.FieldMask(
          paths=["default_backup_schedule_type"]
      ),
    )

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

    print("Updated instance {} to have default backup schedules".format(instance_id))

Déplacer une instance

Pour savoir comment déplacer votre instance d'une configuration d'instance vers une autre, y compris entre des configurations régionales et multirégionales, consultez Déplacer une instance.

Supprimer une instance

Vous pouvez supprimer une instance avec la console Google Cloud ou la Google Cloud CLI.

Si vous souhaitez supprimer une instance qui comporte une ou plusieurs bases de données pour lesquelles la protection contre la suppression est activée, vous devez d'abord désactiver la protection contre la suppression sur toutes les bases de données de cette instance.

Console

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

Accéder à la page Instances
Cliquez sur le nom de l'instance que vous souhaitez supprimer.
Cliquez sur Supprimer l'instance.
Suivez les instructions pour confirmer que vous souhaitez bien supprimer l'instance.
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 aucun temps d'arrêt. Comme il n'est pas nécessaire d'arrêter ou de redémarrer manuellement une instance donnée, Spanner ne propose pas de méthode pour le faire.

Étapes suivantes

Découvrez comment insérer, mettre à jour et supprimer des données à l'aide du langage de manipulation de données (LMD) ou de la 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.

Créer et gérer des instances Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Créer une instance

Console

gcloud

Ajouter l'autoscaling géré

Exemples d'utilisation de configurations personnalisées

C++

C#

Créer une instance sans calendrier de sauvegarde par défaut

Go

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

Créer une instance avec autoscaling asymétrique en lecture seule à l'aide de Go

Créer une instance sans calendrier de sauvegarde par défaut

Java

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

Créer une instance avec autoscaling asymétrique en lecture seule à l'aide de Java

Créer une instance sans calendrier de sauvegarde par défaut

Node.js

Créer une instance avec autoscaling géré à l'aide de Node.js

Créer une instance sans calendrier de sauvegarde par défaut

PHP

Python

Créer une instance avec autoscaling géré à l'aide de Python

Créer une instance sans calendrier de sauvegarde par défaut

Ruby

Répertorier les instances

Console

gcloud

Modifier une instance

Mettre à niveau l'édition

Console

gcloud

Go

Java

Node.js

Python

Rétrograder l'édition

gcloud

Modifier le nom à afficher

Console

gcloud

Modifier la capacité de calcul

Console

gcloud

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

Console

gcloud

Passer d'un autoscaler géré à un scaling manuel pour une instance

Console

gcloud

Ajouter un libellé à une instance

Console

Modifier le type de planification de sauvegarde par défaut

Console

gcloud

C#

Go

Java

Node.js

Python

Déplacer une instance

Supprimer une instance

Console

gcloud

Arrêter ou redémarrer une instance

Étapes suivantes

Créer et gérer des instances