Créer et gérer des partitions

Preview — Geo-partitioning

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

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

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

Avant de commencer

Pour utiliser des partitions, vous devez définir la base de données opt_in_dataplacement_preview dans votre base de données vide:

Console

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

   Instances

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

3. Sélectionnez la base de données vide dans laquelle vous souhaitez partitionner les données.

4. Dans le menu de navigation, cliquez sur Spanner Studio.

5. Sur la page Spanner Studio, cliquez sur Nouvel onglet ou utilisez le champ vide de l'éditeur.

6. Saisissez l'instruction LDD ALTER DATABASE suivante.

   GoogleSQL

   ALTER DATABASE DATABASE_ID SET OPTIONS (opt_in_dataplacement_preview = true);
   

   Remplacez DATABASE_ID par l'identifiant unique de votre base de données.

   PostgreSQL

   ALTER DATABASE DATABASE_ID SET "spanner.opt_in_dataplacement_preview" = TRUE;
   

   Remplacez DATABASE_ID par l'identifiant unique de votre base de données.

7. Cliquez sur Exécuter.

gcloud

Pour définir l'option de base de données opt_in_dataplacement_preview, utilisez gcloud spanner databases ddl update.

GoogleSQL

gcloud spanner databases ddl update DATABASE_ID \
  --instance=INSTANCE_ID \
  --ddl="ALTER DATABASE DATABASE_ID SET OPTIONS (opt_in_dataplacement_preview = true);"

Remplacez les éléments suivants :

• DATABASE_ID : identifiant permanent de votre base de données Spanner.
• INSTANCE_ID: identifiant permanent de votre instance Spanner Compute Engine.

PostgreSQL

gcloud spanner databases ddl update DATABASE_ID \
  --instance=INSTANCE_ID \
  --ddl="ALTER DATABASE DATABASE_ID SET "spanner.opt_in_dataplacement_preview" = TRUE"

Remplacez les éléments suivants :

• DATABASE_ID : identifiant permanent de votre base de données Spanner.
• INSTANCE_ID : identifiant permanent de votre instance Spanner.

Créer une partition

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.

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

4. Cliquez sur Créer une partition.

5. Saisissez un ID de partition pour identifier votre partition de manière permanente. La l'ID de partition doit également être unique au sein de votre projet Google Cloud. Vous ne pourrez pas modifier l'ID de partition 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 régions, puis cliquez sur Comparer les configurations régionales.

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

8. Dans la section Allouer de la capacité de calcul, sous Unité, cliquez sur l'une des options suivantes :

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

9. Saisissez une valeur pour l'unité sélectionnée.

   Votre partition doit comporter au moins un nœud ou 1 000 unités de traitement.

10. Cliquez sur Créer pour créer la partition.

gcloud

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

gcloud beta spanner instance-partitions create PARTITION_ID \
  --config=PARTITION_CONFIG \
  --description="PARTITION_DESCRIPTION" \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]

Remplacez les éléments suivants :

• PARTITION_ID : identifiant de partition permanent unique dans votre projet Google Cloud. Vous ne pouvez pas modifier l'ID de partition ultérieurement.
• PARTITION_CONFIG: identifiant permanent de votre partition. de configuration, qui définit l'emplacement géographique de la partition et affecte l'emplacement de stockage des données.
• PARTITION_DESCRIPTION: nom à afficher pour la partition. dans la console Google Cloud. Le nom de la partition doit être unique dans votre projet Google Cloud.
• INSTANCE_ID : identifiant permanent de votre instance Spanner dans laquelle se trouve cette partition.
• NODE_COUNT: capacité de calcul de la partition, 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é en nombre d'unités de traitement. Votre partition 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 europe-partition dans eur3 avec cinq nœuds, exécutez la commande suivante :

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

Bibliothèques clientes

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour Spanner, consultez 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 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 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 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 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 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

gcloud

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

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

Remplacez les éléments suivants :

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

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

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

Répertorier les partitions

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.

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

gcloud

Pour répertorier vos partitions, utilisez gcloud beta spanner instance-partitions list

gcloud beta spanner instance-partitions list --instance=INSTANCE_ID

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

Modifier une partition

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

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.

Pour augmenter la capacité de calcul d'une partition, Le projet Google Cloud doit disposer d'un quota suffisant pour ajouter de la capacité de calcul. La le temps nécessaire au traitement de la demande d'augmentation dépend de la taille requête. Dans la plupart des cas, les requêtes sont traitées en quelques minutes. Dans de rares cas, l'augmentation de l'échelle 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.

4. Dans la liste des partitions, 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 saisissez une quantité. Lorsque vous utilisez unités de traitement, saisissez les 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 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 votre partition, utilisez gcloud beta 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 beta spanner instance-partitions update PARTITION_ID /
  --instance=INSTANCE_ID /
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]
  [--async]

Remplacez les éléments suivants :

• PARTITION_ID : identifiant permanent de la partition.
• INSTANCE_ID : identifiant permanent de l'instance.
• NODE_COUNT : nouvelle capacité de calcul de la partition, 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, exprimée en nombre d'unités de traitement. Votre partition doit comporter au moins 1 000 unités de traitement. Entrée des quantités sous forme de multiples de 1 000 (1 000, 2 000, 3 000, etc.).

Indicateurs facultatifs :

• --async: utilisez cet indicateur si vous souhaitez que votre requête soit renvoyée immédiatement. sans attendre la fin de l'opération en cours.

Vous pouvez vérifier l'état de votre demande en exécutant gcloud spanner operations describe.

Supprimer une partition

Vous ne pouvez pas supprimer une partition tant qu'elle est associée à un emplacement ou à des données. Vous devez d'abord déplacer les données qui se trouvent dans la partition ou les supprimer les tables d'emplacement qui utilisent la partition avant de pouvoir la supprimer.

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.

4. Dans la liste des partitions, sous la colonne Actions, cliquez sur Plus Actions, puis sélectionnez Supprimer.

5. Suivez les instructions pour confirmer que vous souhaitez supprimer la partition.

6. Cliquez sur Supprimer.

gcloud

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

gcloud beta spanner instance-partitions delete PARTITION_ID
  --instance=INSTANCE_ID

Étape suivante

• Découvrez comment créer et gérer un tableau et des clés d'emplacement.