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

Aperçu — Partitionnement géographique

Cette fonctionnalité est soumise 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 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 dans laquelle vous souhaitez ajouter des partitions d'instance.

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

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

5. Saisissez un ID de partition d'instance pour identifier votre partition d'instance de manière permanente. L'ID de partition d'instance doit également être unique au sein de votre instance. Vous ne pourrez pas modifier l'ID de la 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électionnez 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.

   • Autoscaling pour laisser Spanner ajouter et 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 d'autoscaler géré suivantes :

     • Minimum indique la limite minimale de scaling à la baisse, en fonction de l'unité de mesure que vous choisissez pour la capacité de calcul. Pour en savoir plus, consultez Déterminer la limite minimale.
     • Maximum indique la limite maximale de scaling à la hausse, 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.
     • Objectif d'utilisation du CPU à haute priorité indique le pourcentage cible de CPU à utiliser pour les tâches à haute priorité. Pour en savoir plus, consultez la section Déterminer l'objectif d'utilisation du processeur.
     • Objectif d'utilisation totale du processeur indique le pourcentage cible de processeur à utiliser pour toutes les tâches de priorité faible, moyenne et élevée. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale du processeur.
     • Objectif d'utilisation du stockage indique le pourcentage cible d'espace 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 au sein de 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 votre partition d'instance, qui définit l'emplacement géographique de la partition d'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 au sein de votre instance.
• INSTANCE_ID : identifiant permanent de l'instance Spanner où se trouve 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 : 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 l'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 au sein de 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 votre partition d'instance, qui définit l'emplacement géographique de la partition d'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 au sein de votre instance.
• INSTANCE_ID : identifiant permanent de l'instance Spanner où se trouve cette partition d'instance.
• MINIMUM_PROCESSING_UNITS ou MINIMUM_NODES : nombre minimal d'unités de traitement ou de nœuds lors d'un 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 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 CPU 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 d'utilisation totale du processeur prioritaire. L'objectif de CPU total doit être supérieur à l'objectif de CPU à priorité élevée. Le pourcentage de CPU 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 d'espace de stockage à utiliser, de 10 à 99 %. Pour en savoir plus, consultez la section 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'instance.

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

gcloud

Pour lister vos partitions d'instance, utilisez gcloud spanner instance-partitions list.

gcloud spanner instance-partitions list --instance=INSTANCE_ID

La Google Cloud CLI affiche la liste des partitions d'instance Spanner, ainsi que l'ID, le nom à afficher, 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 votre partition d'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 une capacité de calcul suffisante pour maintenir l'utilisation du processeur et l'utilisation du stockage en dessous des 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 pour ajouter la capacité de calcul. Le temps nécessaire pour traiter la demande d'augmentation dépend de la taille de la demande. 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'instance.

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.

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

6. Cliquez sur Enregistrer.

   Si une boîte de dialogue s'affiche pour vous indiquer que votre quota est insuffisant pour ajouter de la capacité de calcul , suivez les instructions pour demander un quota plus élevé.

gcloud

Pour modifier la capacité de calcul de votre partition d'instance, utilisez gcloud spanner instance-partitions update. Lorsque vous utilisez cette commande, spécifiez la capacité de calcul sous la forme d'un 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. La partition de votre 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 renvoie immédiatement un résultat, 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 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 tant que 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'instance.

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 à la hausse. 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 processeur, saisissez le pourcentage de processeur cible à utiliser pour toutes les tâches de priorité faible, moyenne et élevée. Le pourcentage de CPU peut être compris entre 10 % et 90 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation totale du processeur.

10. Dans le champ Objectif d'utilisation du stockage, saisissez le pourcentage d'espace de stockage à utiliser. Pour en savoir plus, consultez la section 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 sur les options et les limites, consultez Options et limites de Google Cloud CLI.

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 d'un 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 à 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 CPU 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 d'utilisation totale du processeur prioritaire. L'objectif de CPU total doit être supérieur à l'objectif de CPU à priorité élevée. Le pourcentage de CPU 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 d'espace de stockage à utiliser, de 10 % à 99 %. Pour en savoir plus, consultez Déterminer l'objectif d'utilisation du stockage.

Après avoir 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 de l'autoscaler géré au 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'instance.

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 Attribution manuelle.

6. Cliquez sur Enregistrer.

gcloud

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

Utilisez la commande suivante pour passer de l'autoscaler géré au 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 : capacité de calcul de l'instance, exprimée en nombre de nœuds. Chaque nœud équivaut à 1 000 unités de traitement.
• PROCESSING_UNIT_COUNT : capacité de calcul de l'instance, exprimée en nombre d'unités de traitement. 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. Vous devez d'abord déplacer toutes les données de la partition d'instance ou supprimer les tables d'emplacement qui utilisent la partition d'instance avant de pouvoir supprimer la partition 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'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'emplacement.