Criar e gerenciar partições

Visualização — Geo-partitioning

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Observação sobre a interface do PostgreSQL: a versão de pré-lançamento do particionamento geográfico não oferece suporte à interface do PostgreSQL para o Spanner.

Observação:esse recurso está disponível na edição Spanner Enterprise Plus. Para mais informações, consulte a visão geral das edições do Spanner.

Nesta página, descrevemos como criar e gerenciar o Spanner partitions.

Antes de começar

Para usar partições, defina a opção de banco de dados opt_in_dataplacement_preview no banco de dados vazio:

Console

1. Acesse a página Instâncias no console do Google Cloud.

   Instâncias

2. Selecione a instância em que você quer adicionar partições.

3. Selecione o banco de dados vazio em que você quer particionar os dados.

4. No menu de navegação, clique em Spanner Studio.

5. Na página do Spanner Studio, clique em Nova guia ou use o botão na guia "Editor".

6. Digite a seguinte instrução DDL ALTER DATABASE.

   ALTER DATABASE DATABASE_ID SET OPTIONS (opt_in_dataplacement_preview = true);
   

   Substitua DATABASE_ID pelo identificador exclusivo do seu banco de dados.

7. Clique em Executar.

gcloud

Para definir a opção de banco de dados opt_in_dataplacement_preview, use gcloud spanner databases ddl update.

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

Substitua:

• DATABASE_ID: o identificador permanente do banco de dados do Spanner.
• INSTANCE_ID: o identificador permanente da sua instância do Spanner.

Criar uma partição

Console

1. No console do Google Cloud, abra a página Spanner.

   Acessar o Spanner

2. Selecione a instância em que você quer adicionar partições.

3. No menu de navegação, selecione Partições.

4. Clique em Criar partição.

5. Insira um ID de partição para identificar a partição permanentemente. O ID da partição também precisa ser exclusivo no projeto do Google Cloud. Não será possível mudar o ID da partição depois.

6. Na seção Escolher uma configuração, selecione Regional ou Multirregional. Como alternativa, se você quiser comparar as especificações entre regiões e clique em Comparar configurações de região.

7. Selecione uma configuração no menu suspenso.

8. Na seção Alocar capacidade de computação, em Unidade, faça o seguinte: clique em uma destas opções:

   • Unidades de processamento para partições pequenas de instâncias.
   • Nós para instâncias grandes. Um nó tem 1.000 unidades de processamento.

9. Insira um valor para a unidade selecionada.

   Sua partição precisa ter pelo menos um nó ou 1.000 unidades de processamento.

10. Clique em Criar para criar a partição.

gcloud

Para criar uma partição, use 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]

Substitua:

• PARTITION_ID: o identificador de partição permanente que é exclusivo. no projeto do Google Cloud. Não será possível mudar o ID da partição mais tarde.
• PARTITION_CONFIG: o identificador permanente da configuração da partição, que define a localização geográfica da partição e afeta onde os dados são armazenados.
• PARTITION_DESCRIPTION: o nome a ser exibido para a partição. no console do Google Cloud. O nome da partição deve ser exclusivo seu projeto do Google Cloud.
• INSTANCE_ID: o identificador permanente da sua instância do Spanner em que essa partição está.
• NODE_COUNT: a capacidade de computação da partição, expressa como um número de nós. Um nó equivale a 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância. expresso como um número de unidades de processamento. Sua partição precisa ter pelo menos 1.000 unidades de processamento. Insira quantidades em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante).

Por exemplo, para criar uma partição europe-partition em eur3 com cinco nós, execute o seguinte:

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

C++

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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#

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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

Para aprender a instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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

Para saber como instalar e usar a biblioteca de cliente do Spanner, consulte Bibliotecas de cliente do 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))

Descrever uma partição

gcloud

Para descrever uma partição, use gcloud beta spanner instance-partitions describe.

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

Substitua:

• PARTITION_ID: o identificador permanente da partição.
• INSTANCE_ID: o identificador permanente da instância.

Por exemplo, para descrever a partição europe-partition, execute o seguinte:

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

Listar partições

Console

1. No console do Google Cloud, abra a página Spanner.

   Acessar o Spanner

2. Selecione uma instância na lista.

3. No menu de navegação, selecione Partições.

   Uma lista de partições associadas a essa instância é mostrada.

gcloud

Para listar as partições, use gcloud beta spanner instance-partitions list.

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

A CLI do gcloud mostra uma lista das partições do Spanner, além do ID, nome de exibição, configuração e capacidade de computação de cada partição.

Editar uma partição

A seção a seguir explica como mudar a capacidade de computação da partição. Não é possível mudar o ID, o nome ou a configuração da partição.

Alterar a capacidade de computação

Provisione capacidade de computação suficiente para manter a utilização da CPU e a utilização de armazenamento abaixo dos valores máximos recomendados. Para mais informações, consulte as cotas e limites do Spanner.

Se você quiser aumentar a capacidade de computação de uma partição, seu projeto do Google Cloud precisa ter cota suficiente para adicionar a capacidade de computação. O o tempo que leva para a solicitação de aumento ser concluída depende do tamanho do solicitação. Na maioria dos casos, as solicitações são concluídas em alguns minutos. Em raras ocasiões, uma ampliação pode levar até uma hora para ser concluída.

Console

1. No console do Google Cloud, abra a página Spanner.

   Acessar o Spanner

2. Selecione uma instância na lista.

3. No menu de navegação, selecione Partições.

4. Na lista de partições, na coluna Ações, clique em Mais Ações e selecione Editar.

5. Escolha uma unidade de medida para alterar a capacidade de computação (unidades de processamento ou nós) e, em seguida, inserir uma quantidade. Ao usar de unidades de processamento, insira quantidades em múltiplos de 1000 (1000, 2000, 3000 e assim por diante). Cada nó é igual a 1.000 unidades de processamento.

   Sua partição precisa ter pelo menos um nó (1.000 unidades de processamento).

6. Clique em Salvar.

   Se aparecer uma caixa de diálogo informando que você não tem cota suficiente para adicionar computação , siga as instruções para solicitar uma cota maior.

gcloud

Para alterar a capacidade de computação da partição, use gcloud beta spanner instance-partitions update Ao usar este comando, especifique a capacidade de computação como uma o número de nós ou unidades de processamento.

gcloud beta spanner instance-partitions update PARTITION_ID /
  --instance=INSTANCE_ID /
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]
  [--async]

Substitua:

• PARTITION_ID: o identificador permanente da partição.
• INSTANCE_ID: o identificador permanente da instância.
• NODE_COUNT: a nova capacidade de computação da partição. expresso como uma série de nós. Um nó equivale a 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a nova capacidade de computação da partição, expressa como um número de unidades de processamento. Sua partição precisa ter pelo menos 1.000 unidades de processamento. Insira quantidades em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante).

Sinalizações opcionais:

• --async: use essa sinalização se quiser que sua solicitação seja retornada imediatamente; sem esperar a conclusão da operação em andamento.

É possível verificar o status da sua solicitação executando gcloud spanner operations describe.

Excluir uma partição

Não é possível excluir uma partição enquanto ela está associada a posições ou dados. Primeiro, mova todos os dados que estão na partição ou exclua-os. as tabelas de posicionamento que a usam antes de você excluí-la.

Console

1. No console do Google Cloud, abra a página Spanner.

   Acessar o Spanner

2. Selecione uma instância na lista.

3. No menu de navegação, selecione Partições.

4. Na lista de partições, na coluna Ações, clique em Mais ações e selecione Excluir.

5. Siga as instruções para confirmar que você quer excluir a partição.

6. Clique em Excluir.

gcloud

Use o comando gcloud beta spanner instance-partitions delete.

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

A seguir

• Saiba como criar e gerenciar a tabela de posicionamento e as chaves.