Créer et gérer des partitions d'instances

Preview — Geo-partitioning

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

Remarque : Cette fonctionnalité est disponible dans l'édition Spanner Enterprise Plus. Pour en savoir plus, consultez la présentation des éditions Spanner.

Cette page explique comment créer et gérer des partitions d'instance Spanner.

Créer une partition d'instance

Console

1. Dans la console Google Cloud , ouvrez la page Spanner.

   Accéder à Spanner

2. Sélectionnez l'instance à laquelle vous souhaitez ajouter des partitions d'instance.

3. Dans le menu de navigation, sélectionnez Partitions d'instances.

4. Cliquez sur Créer une partition d'instance.

5. Saisissez un ID de partition d'instance pour identifier de manière permanente la partition de votre instance. L'ID de partition d'instance doit également être unique dans votre instance. Vous ne pourrez pas modifier l'ID de partition d'instance par la suite.

6. Dans la section Sélectionner une configuration, sélectionnez Régional ou Multirégional. Si vous souhaitez comparer les spécifications entre les régions, cliquez sur Comparer les configurations régionales.

7. Sélectionnez une configuration dans le menu déroulant.

8. Dans la section Configurer la 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 partitions d'instance.

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

9. 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. L'autoscaler géré est disponible dans les éditions Spanner Enterprise et Enterprise Plus. 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 d'augmentation, 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 processeur à priorité élevée indique le pourcentage cible du processeur à utiliser pour les tâches à priorité élevée. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.
     • L'objectif d'utilisation totale du processeur indique le pourcentage cible de processeur à utiliser pour toutes les tâches à priorité faible, moyenne et élevée. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale 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.

10. Cliquez sur Créer pour créer la partition d'instance.

gcloud

Pour créer une partition d'instance, utilisez gcloud spanner instance-partitions create.

gcloud spanner instance-partitions create INSTANCE_PARTITION_ID \
  --config=INSTANCE_PARTITION_CONFIG \
  --description="INSTANCE_PARTITION_DESCRIPTION" \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance, unique dans votre instance. Vous ne pourrez pas modifier l'ID de partition d'instance par la suite.
• INSTANCE_PARTITION_CONFIG : identifiant permanent de la configuration de la partition de votre instance, qui définit l'emplacement géographique de la partition de l'instance et affecte l'emplacement de stockage des données.
• INSTANCE_PARTITION_DESCRIPTION : nom à afficher pour la partition d'instance dans la console Google Cloud . Le nom de la partition d'instance doit être unique dans votre instance.
• INSTANCE_ID : identifiant permanent de votre instance Spanner dans laquelle réside cette partition d'instance.
• NODE_COUNT : capacité de calcul de la partition d'instance, exprimée en nombre de nœuds. Un nœud correspond à 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. Votre partition d'instance doit comporter au moins 1 000 unités de traitement. Saisissez des quantités par multiples de 1 000 (1 000, 2 000, 3 000, etc.).

Par exemple, pour créer une partition d'instance europe-partition dans eur3 avec cinq nœuds, exécutez la commande suivante :

  gcloud spanner instance-partitions create europe-partition --config=eur3 \
    --description="europe-partition" --instance=test-instance --nodes=5

Utiliser l'autoscaling géré

Vous pouvez utiliser l'autoscaling géré avec la commande gcloud spanner instance-partitions create. Pour en savoir plus, consultez Autoscaler géré.

Exécutez la commande suivante pour créer une partition d'instance avec un autoscaler géré :

  gcloud 
  spanner instance-partitions create INSTANCE_PARTITION_ID \
    --config=INSTANCE_PARTITION_CONFIG \
    --description="INSTANCE_PARTITION_DESCRIPTION" \
    --instance=INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

ou

  gcloud spanner instance-partitions create INSTANCE_PARTITION_ID \
    --config=INSTANCE_PARTITION_CONFIG \
    --description="INSTANCE_PARTITION_DESCRIPTION" \
    --instance=INSTANCE_ID \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance, unique dans votre instance. Vous ne pourrez pas modifier l'ID de partition d'instance par la suite.
• INSTANCE_PARTITION_CONFIG : identifiant permanent de la configuration de la partition de votre instance, qui définit l'emplacement géographique de la partition de l'instance et affecte l'emplacement de stockage des données.
• INSTANCE_PARTITION_DESCRIPTION : nom à afficher pour la partition d'instance dans la console Google Cloud . Le nom de la partition d'instance doit être unique dans votre instance.
• INSTANCE_ID : identifiant permanent de votre instance Spanner dans laquelle réside cette partition d'instance.
• MINIMUM_PROCESSING_UNITS ou MINIMUM_NODES : nombre minimal d'unités de traitement ou de nœuds lors du scaling à la baisse. Pour en savoir plus, consultez Déterminer la limite minimale.
• MAXIMUM_PROCESSING_UNITS ou 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.
• HIGH_PRIORITY_CPU_PERCENTAGE : pourcentage cible de processeur à haute priorité à utiliser, en fonction de la priorité de la tâche. Le pourcentage de processeur peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur à priorité élevée.
• TOTAL_CPU_PERCENTAGE : pourcentage cible du CPU prioritaire total à utiliser. L'objectif de CPU total doit être supérieur à l'objectif de CPU à priorité élevée. Le pourcentage de processeur peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale 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.

Bibliothèques clientes

C++

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

void CreateInstancePartition(
    google::cloud::spanner_admin::InstanceAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& instance_partition_id) {
  auto project = google::cloud::Project(project_id);
  auto in = google::cloud::spanner::Instance(project_id, instance_id);
  auto config = project.FullName() + "/instanceConfigs/nam3";

  google::spanner::admin::instance::v1::CreateInstancePartitionRequest request;
  request.set_parent(in.FullName());
  request.set_instance_partition_id(instance_partition_id);
  request.mutable_instance_partition()->set_display_name(
      "Test instance partition");
  request.mutable_instance_partition()->set_node_count(1);
  request.mutable_instance_partition()->set_config(config);

  auto instance_partition = client.CreateInstancePartition(request).get();
  if (!instance_partition) throw std::move(instance_partition).status();
  std::cout << "Created instance partition [" << instance_partition_id << "]:\n"
            << instance_partition->DebugString();
}

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

public class CreateInstancePartitionSample
{
    public InstancePartition CreateInstancePartition(string projectId, string instanceId, string instancePartitionId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();

        // Initialize request parameters.
        InstancePartition partition = new InstancePartition
        {
            DisplayName = "This is a display name.",
            NodeCount = 1,
            ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "nam3"),
        };
        InstanceName instanceName = InstanceName.FromProjectInstance(projectId, instanceId);

        // Make the CreateInstancePartition request.
        Operation<InstancePartition, CreateInstancePartitionMetadata> response = instanceAdminClient.CreateInstancePartition(instanceName, partition, instancePartitionId);

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

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

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance partition: {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"
)

// Example of creating an instance partition with Go.
// projectID is the ID of the project that the new instance partition will be in.
// instanceID is the ID of the instance that the new instance partition will be in.
// instancePartitionID is the ID of the new instance partition to be created.
func createInstancePartition(w io.Writer, projectID, instanceID, instancePartitionID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	// instancePartitionID := "my-instance-partition"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	op, err := instanceAdmin.CreateInstancePartition(ctx, &instancepb.CreateInstancePartitionRequest{
		Parent:              fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
		InstancePartitionId: instancePartitionID,
		InstancePartition: &instancepb.InstancePartition{
			Config:          fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam3"),
			DisplayName:     "my-instance-partition",
			ComputeCapacity: &instancepb.InstancePartition_NodeCount{NodeCount: 1},
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance partition %s: %w", fmt.Sprintf("projects/%s/instances/%s/instancePartitions/%s", projectID, instanceID, instancePartitionID), err)
	}
	// Wait for the instance partition creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance partition creation to finish failed: %w", err)
	}
	// The instance partition may not be ready to serve yet.
	if i.State != instancepb.InstancePartition_READY {
		fmt.Fprintf(w, "instance partition state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance partition [%s]\n", instancePartitionID)
	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.CreateInstancePartitionRequest;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.InstancePartition;
import java.util.concurrent.ExecutionException;

class CreateInstancePartitionSample {

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

  static void createInstancePartition(
      String projectId, String instanceId, String instancePartitionId) {
    // Set instance partition configuration.
    int nodeCount = 1;
    String displayName = "Descriptive name";

    // Create an InstancePartition object that will be used to create the instance partition.
    InstancePartition instancePartition =
        InstancePartition.newBuilder()
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "nam3").toString())
            .build();

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

      // Wait for the createInstancePartition operation to finish.
      InstancePartition createdInstancePartition =
          instanceAdminClient
              .createInstancePartitionAsync(
                  CreateInstancePartitionRequest.newBuilder()
                      .setParent(InstanceName.of(projectId, instanceId).toString())
                      .setInstancePartitionId(instancePartitionId)
                      .setInstancePartition(instancePartition)
                      .build())
              .get();
      System.out.printf(
          "Instance partition %s was successfully created%n", createdInstancePartition.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance partition %s failed with error message %s%n",
          instancePartition.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println(
          "Error: Waiting for createInstancePartition 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} = require('@google-cloud/spanner');

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

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

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

// Creates a new instance partition
try {
  console.log(
    `Creating instance partition ${instanceAdminClient.instancePartitionPath(
      projectId,
      instanceId,
      instancePartitionId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstancePartition({
    instancePartitionId: instancePartitionId,
    parent: instanceAdminClient.instancePath(projectId, instanceId),
    instancePartition: {
      config: instanceAdminClient.instanceConfigPath(projectId, 'nam3'),
      nodeCount: 1,
      displayName: 'Test instance partition',
    },
  });

  console.log(
    `Waiting for operation on ${instancePartitionId} to complete...`,
  );
  await operation.promise();

  console.log(`Created instance partition ${instancePartitionId}.`);
} 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\CreateInstancePartitionRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\InstancePartition;

/**
 * Creates an instance partition.
 * Example:
 * ```
 * create_instance_partition($projectId, $instanceId, $instancePartitionId);
 * ```
 *
 * @param string $projectId The Google Cloud project ID.
 * @param string $instanceId The Spanner instance ID.
 * @param string $instancePartitionId The instance partition ID.
 */
function create_instance_partition(string $projectId, string $instanceId, string $instancePartitionId): void
{
    $instanceAdminClient = new InstanceAdminClient();

    $instanceName = $instanceAdminClient->instanceName($projectId, $instanceId);
    $instancePartitionName = $instanceAdminClient->instancePartitionName($projectId, $instanceId, $instancePartitionId);
    $configName = $instanceAdminClient->instanceConfigName($projectId, 'nam3');

    $instancePartition = (new InstancePartition())
        ->setConfig($configName)
        ->setDisplayName('Test instance partition.')
        ->setNodeCount(1);

    $operation = $instanceAdminClient->createInstancePartition(
        (new CreateInstancePartitionRequest())
        ->setParent($instanceName)
        ->setInstancePartitionId($instancePartitionId)
        ->setInstancePartition($instancePartition)
    );

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

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

Python

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

def create_instance_partition(instance_id, instance_partition_id):
    """Creates an instance partition."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()
    instance_admin_api = spanner_client.instance_admin_api

    config_name = "{}/instanceConfigs/nam3".format(spanner_client.project_name)

    operation = spanner_client.instance_admin_api.create_instance_partition(
        parent=instance_admin_api.instance_path(spanner_client.project, instance_id),
        instance_partition_id=instance_partition_id,
        instance_partition=spanner_instance_admin.InstancePartition(
            config=config_name,
            display_name="Test instance partition",
            node_count=1,
        ),
    )

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

    print("Created instance partition {}".format(instance_partition_id))

Décrire une partition d'instance

gcloud

Pour décrire une partition d'instance, utilisez gcloud spanner instance-partitions describe.

gcloud spanner instance-partitions describe PARTITION_ID \
  --instance=INSTANCE_ID

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance.
• INSTANCE_ID : identifiant permanent de l'instance.

Par exemple, pour décrire la partition d'instance europe-partition, exécutez la commande suivante :

  gcloud spanner instance-partitions describe europe-partition
    --instance=test-instance

Lister les partitions d'instance

Console

1. Dans la console Google Cloud , ouvrez la page Spanner.

   Accéder à Spanner

2. Sélectionnez une instance dans la liste.

3. Dans le menu de navigation, sélectionnez Partitions d'instances.

   La liste des partitions d'instance associées à cette instance s'affiche.

gcloud

Pour répertorier les partitions de votre instance, utilisez gcloud spanner instance-partitions list.

gcloud spanner instance-partitions list --instance=INSTANCE_ID

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

Modifier une partition d'instance

La section suivante explique comment modifier la capacité de calcul de la partition de votre instance. Vous ne pouvez pas modifier l'ID, le nom ni la configuration de la partition d'instance.

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.

Si vous souhaitez augmenter la capacité de calcul d'une partition d'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, une augmentation de capacité peut prendre jusqu'à une heure.

Console

1. Dans la console Google Cloud , ouvrez la page Spanner.

   Accéder à Spanner

2. Sélectionnez une instance dans la liste.

3. Dans le menu de navigation, sélectionnez Partitions d'instances.

4. Dans la liste des partitions d'instance, sous la colonne Actions, cliquez sur Autres actions, puis sélectionnez Modifier.

5. Modifiez la capacité de calcul en choisissant une unité 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 par multiples de 1 000 (1 000, 2 000, 3 000, etc.). Chaque nœud équivaut à 1 000 unités de traitement.

   Votre partition d'instance doit comporter au moins un nœud (1 000 unités de traitement).

6. 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 , suivez les instructions pour demander une augmentation de quota.

gcloud

Pour modifier la capacité de calcul de la partition d'instance, utilisez gcloud spanner instance-partitions 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 instance-partitions update INSTANCE_PARTITION_ID \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]
  [--async]

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance.
• INSTANCE_ID : identifiant permanent de l'instance.
• NODE_COUNT : nouvelle capacité de calcul de la partition d'instance, exprimée en nombre de nœuds. Un nœud correspond à 1 000 unités de traitement.
• PROCESSING_UNIT_COUNT : nouvelle capacité de calcul de la partition d'instance, exprimée en nombre d'unités de traitement. Votre partition d'instance doit comporter au moins 1 000 unités de traitement. Saisissez des quantités 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 la commande gcloud spanner operations describe.

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

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

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

Console

1. Dans la console Google Cloud , ouvrez la page Spanner.

   Accéder à Spanner

2. Sélectionnez une instance dans la liste.

3. Dans le menu de navigation, sélectionnez Partitions d'instances.

4. Dans la liste des partitions d'instance, sous la colonne Actions, cliquez sur Autres actions, puis sélectionnez Modifier.

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

6. Pour Minimum, sélectionnez la limite minimale à utiliser lors du scaling à la baisse. Pour en savoir plus, consultez Déterminer la limite minimale.

7. Pour Maximum, sélectionnez la limite maximale à utiliser lors du scaling-up. Pour en savoir plus, consultez Déterminer la limite maximale.

8. Pour Objectif d'utilisation du processeur à haute priorité, saisissez le pourcentage de processeur à utiliser pour les tâches à haute priorité. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur.

9. Pour Objectif d'utilisation totale du CPU, saisissez le pourcentage cible du CPU à utiliser pour toutes les tâches à priorité faible, moyenne et élevée. Le pourcentage de processeur peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale du processeur.

10. Pour Objectif d'utilisation du stockage, saisissez le pourcentage de stockage à utiliser. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.

11. Cliquez sur Enregistrer.

gcloud

Utilisez la commande gcloud spanner instance-partitions update pour activer l'autoscaler géré sur une partition d'instance. Pour en savoir plus et connaître les limites, consultez Indicateurs Google Cloud CLI et limites.

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

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

ou

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance.
• INSTANCE_ID : identifiant permanent de l'instance.
• MINIMUM_PROCESSING_UNITS ou 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 ou MAXIMUM_NODES : nombre maximal d'unités de traitement ou de nœuds à utiliser lors du scaling à la hausse. Pour en savoir plus, consultez Déterminer la limite maximale.
• HIGH_PRIORITY_CPU_PERCENTAGE : pourcentage cible de processeur à haute priorité à utiliser, en fonction de la priorité de la tâche. Le pourcentage de processeur peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du processeur à priorité élevée.
• TOTAL_CPU_PERCENTAGE : pourcentage cible du CPU prioritaire total à utiliser. L'objectif de CPU total doit être supérieur à l'objectif de CPU à priorité élevée. Le pourcentage de processeur peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale 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.

Une fois que vous avez activé l'autoscaler géré sur une partition d'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 instance-partitions update test-instance-partition \
     --instance=test-instance
     --autoscaling-max-processing-units=10000

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

Console

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

   Accéder à la page Instances

2. Sélectionnez une instance dans la liste.

3. Dans le menu de navigation, sélectionnez Partitions d'instances.

4. Dans la liste des partitions d'instance, sous la colonne Actions, cliquez sur Autres actions, puis sélectionnez Modifier.

5. Sous Choisir un mode de scaling, cochez la case Allocation manuelle.

6. Cliquez sur Enregistrer.

gcloud

Exécutez la commande gcloud spanner instance-partitions update pour mettre à jour la partition de l'instance.

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

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

ou

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --nodes=NODE_COUNT

Remplacez les éléments suivants :

• INSTANCE_PARTITION_ID : identifiant permanent de la partition d'instance.
• 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. Le nombre minimal d'unités de traitement pour une partition d'instance est de 1 000.

Supprimer une partition d'instance

Vous ne pouvez pas supprimer une partition d'instance tant qu'elle est associée à des emplacements ou des données. Avant de pouvoir supprimer la partition d'instance, vous devez d'abord déplacer les données qu'elle contient ou supprimer les tables d'emplacement qui l'utilisent.

Console

1. Dans la console Google Cloud , ouvrez la page Spanner.

   Accéder à Spanner

2. Sélectionnez une instance dans la liste.

3. Dans le menu de navigation, sélectionnez Partitions d'instance.

4. Dans la liste des partitions d'instance, sous la colonne Actions, cliquez sur Autres actions, puis sélectionnez Supprimer.

5. Suivez les instructions pour confirmer que vous souhaitez bien supprimer la partition d'instance.

6. Cliquez sur Supprimer.

gcloud

Exécutez la commande gcloud spanner instance-partitions delete.

gcloud spanner instance-partitions delete INSTANCE_PARTITION_ID
  --instance=INSTANCE_ID

Étapes suivantes

• Découvrez comment créer et gérer des tables et des clés d'emplacements.