Criar e gerenciar partições

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

Antes de começar

Para usar partições, você precisa definir o banco de dados opt_in_dataplacement_preview em seu 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 no 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 Spanner no seu banco de dados.
  • INSTANCE_ID: o identificador permanente do Spanner instância.

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 identificá-la permanentemente. O também precisa ser exclusivo no projeto do Google Cloud. Não será possível alterar 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 mil 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 é possível alterar o ID da partição mais tarde.
  • PARTITION_CONFIG: o identificador permanente da partição. que define a localização geográfica da partição e afeta o armazenamento deles.
  • 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 do seu Instância do Spanner em que a partição reside.
  • NODE_COUNT: a capacidade de computação da partição, expressa como uma série 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 deve ter pelo menos com pelo menos mil unidades de processamento. Tecla Enter quantidades em múltiplos de 1000 (1000, 2000, 3000 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 aprender a 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();
}

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 aprender a 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 suas partições, use gcloud beta spanner instance-partitions list

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

A CLI gcloud imprime uma lista das instâncias do Spanner das partições, além do ID, nome de exibição, configuração e de computação do Google Cloud.

Editar uma partição

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

Alterar a capacidade de computação

Você precisa provisionar capacidade de computação suficiente para manter Uso de CPU e uso do armazenamento abaixo do recomendado máximos Para mais informações, consulte cotas e limites para no Spanner.

Para aumentar a capacidade de computação de uma partição, O projeto do Google Cloud precisa ter cota suficiente para adicionar a de armazenamento. O tempo necessário para que a solicitação de aumento seja concluída depende do tamanho da solicitação. Na maioria dos casos, as solicitações são concluídas em alguns minutos. Ativado raras ocasiões, um escalonar verticalmente pode levar até uma hora para ser concluído.

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 do expressa como um número de unidades de processamento. Sua partição precisa ter pelo menos mil unidades de processamento. Tecla Enter quantidades em múltiplos de 1000 (1000, 2000, 3000 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.

Para verificar o status da sua solicitação, execute 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