Creare e gestire le partizioni

Anteprima - Geo-partitioning

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Nota: questa funzionalità è disponibile con la versione Spanner Enterprise Plus. Per ulteriori informazioni, consulta la panoramica delle versioni di Spanner.

Questa pagina descrive come creare e gestire Spanner partizioni.

Prima di iniziare

Per utilizzare le partizioni, devi impostare l'opzione database opt_in_dataplacement_preview nel database vuoto:

Console

1. Vai alla pagina Istanze nella console Google Cloud.

   Istanze

2. Seleziona l'istanza in cui vuoi aggiungere le partizioni.

3. Seleziona il database vuoto in cui vuoi partizionare i dati.

4. Nel menu di navigazione, fai clic su Spanner Studio.

5. Nella pagina Spanner Studio, fai clic su Nuova scheda o utilizza la scheda editor vuota.

6. Inserisci la seguente istruzione DDL ALTER DATABASE.

   GoogleSQL

   ALTER DATABASE DATABASE_ID SET OPTIONS (opt_in_dataplacement_preview = true);
   

   Sostituisci DATABASE_ID con l'identificatore univoco del tuo per configurare un database.

   PostgreSQL

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

   Sostituisci DATABASE_ID con l'identificatore univoco del database.

7. Fai clic su Esegui.

gcloud

Per impostare l'opzione di database opt_in_dataplacement_preview, utilizza 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);"

Sostituisci quanto segue:

• DATABASE_ID: l'identificatore permanente per il tuo Spanner per configurare un database.
• INSTANCE_ID: l'identificatore permanente per il tuo Spanner in esecuzione in un'istanza 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"

Sostituisci quanto segue:

• DATABASE_ID: l'identificatore permanente per il tuo Spanner per configurare un database.
• INSTANCE_ID: l'identificatore permanente della tua istanza Spanner.

Creare una partizione

Console

1. Nella console Google Cloud, apri la pagina Spanner.

   Vai a Spanner

2. Seleziona l'istanza in cui vuoi aggiungere le partizioni.

3. Nel menu di navigazione, seleziona Partizioni.

4. Fai clic su Crea partizione.

5. Inserisci un ID partizione per identificare definitivamente la partizione. Anche l'ID parametro deve essere univoco all'interno del progetto Google Cloud. Non puoi modificare l'ID partizione in un secondo momento.

6. Nella sezione Scegli una configurazione, seleziona Regionale o Più regioni. In alternativa, se vuoi confrontare le specifiche tra le regioni, fai clic su Confronta configurazioni per regioni.

7. Seleziona una configurazione dal menu a discesa.

8. Nella sezione Alloca capacità di calcolo, in Unità, fai clic su una delle seguenti opzioni:

   • Unità di elaborazione per partizioni di istanze di piccole dimensioni.
   • Nodi per istanze di grandi dimensioni. Un nodo equivale a 1000 unità di elaborazione.

9. Inserisci un valore per l'unità selezionata.

   La partizione deve avere almeno un nodo o 1000 unità di elaborazione.

10. Fai clic su Crea per creare la partizione.

gcloud

Per creare una partizione, utilizza 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]

Sostituisci quanto segue:

• PARTITION_ID: l'identificatore della partizione permanente univoco all'interno del tuo progetto Google Cloud. Non puoi modificare l'ID partizione in un secondo momento.
• PARTITION_CONFIG: l'identificatore permanente della configurazione della partizione, che definisce la posizione geografica della partizione e influisce sulla posizione in cui vengono archiviati i dati.
• PARTITION_DESCRIPTION: il nome da visualizzare per la partizione nella console Google Cloud. Il nome della partizione deve essere univoco all'interno del tuo progetto Google Cloud.
• INSTANCE_ID: l'identificatore permanente della tua Istanza Spanner in cui si trova questa partizione.
• NODE_COUNT: la capacità di calcolo della partizione, espressa come numero di nodi. Un nodo equivale a 1000 unità di elaborazione.
• PROCESSING_UNIT_COUNT: capacità di calcolo dell'istanza, espresso in un numero di unità di elaborazione. La partizione deve avere almeno 1000 unità di elaborazione. Inserisci quantità in multipli di 1000 (1000, 2000, 3000 e così via).

Ad esempio, per creare una partizione europe-partition in eur3 con 5 nodi, esegui quanto segue:

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

Librerie client

C++

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta la pagina relativa alle librerie client di 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#

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client 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;
    }
}

Vai

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta la pagina relativa alle librerie client di 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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di 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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client 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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client 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

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta la pagina relativa alle librerie client di 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))

Descrivi una partizione

gcloud

Per descrivere una partizione, utilizza gcloud beta spanner instance-partitions describe.

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

Sostituisci quanto segue:

• PARTITION_ID: l'identificatore permanente della partizione.
• INSTANCE_ID: l'identificatore permanente dell'istanza.

Ad esempio, per descrivere la partizione europe-partition, esegui questo comando:

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

Elenca partizioni

Console

1. Nella console Google Cloud, apri la pagina Spanner.

   Vai a Spanner

2. Seleziona un'istanza dall'elenco.

3. Nel menu di navigazione, seleziona Partizioni.

   Viene visualizzato un elenco delle partizioni associate all'istanza.

gcloud

Per elencare le partizioni, utilizza gcloud beta spanner instance-partitions list.

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

L'interfaccia a riga di comando gcloud stampa un elenco delle partizioni Spanner, insieme all'ID, al nome visualizzato, alla configurazione e alla capacità di calcolo di ciascuna partizione.

Modifica una partizione

La sezione seguente spiega come modificare la capacità di calcolo di un'istanza della partizione di testo. Non puoi modificare l'ID, il nome o la configurazione della partizione.

Modificare la capacità di calcolo

Devi eseguire il provisioning di una capacità di calcolo sufficiente per mantenere l'utilizzo della CPU e l'utilizzo dello spazio di archiviazione al di sotto dei valori massimi consigliati. Per ulteriori informazioni, consulta le quote e i limiti per Spanner.

Se vuoi aumentare la capacità di calcolo di una partizione, Il progetto Google Cloud deve avere una quota sufficiente per aggiungere capacità di calcolo. Il tempo necessario per completare la richiesta di aumento dipende dalle dimensioni della richiesta. Nella maggior parte dei casi, le richieste vengono completate entro pochi minuti. In rare occasioni, il completamento di un'operazione di ridimensionamento potrebbe richiedere fino a un'ora.

Console

1. Nella console Google Cloud, apri la pagina Spanner.

   Vai a Spanner

2. Seleziona un'istanza dall'elenco.

3. Nel menu di navigazione, seleziona Partizioni.

4. Nell'elenco delle partizioni, fai clic su Altre azioni nella colonna Azioni e seleziona Modifica.

5. Modifica la capacità di calcolo scegliendo un'unità di misura (unità di elaborazione o nodi) e inserendo una quantità. Quando si utilizza le unità di elaborazione, inserisci le quantità in multipli di 1000 (1000, 2000, 3000 e così via). Ogni nodo equivale a 1000 unità di elaborazione.

   La partizione deve avere almeno un nodo (1000 unità di elaborazione).

6. Fai clic su Salva.

   Se viene visualizzata una finestra di dialogo che ti informa che la quota non è sufficiente per aggiungere capacità di calcolo, segui le istruzioni per richiedere una quota più alta.

gcloud

Per modificare la capacità di calcolo della partizione, usa gcloud beta spanner instance-partitions update Quando utilizzi questo comando, specifica la capacità di calcolo come numero di nodi o unità di elaborazione.

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

Sostituisci quanto segue:

• PARTITION_ID: l'identificatore permanente della partizione.
• INSTANCE_ID: l'identificatore permanente dell'istanza.
• NODE_COUNT: la nuova capacità di calcolo della partizione, espresso sotto forma di numero di nodi. Un nodo equivale a 1000 unità di elaborazione.
• PROCESSING_UNIT_COUNT: la nuova capacità di calcolo della partizione, espressa come numero di unità di elaborazione. La tua partizione deve avere almeno 1000 unità di elaborazione. Invio quantità in multipli di 1000 (1000, 2000, 3000 e così via).

Flag facoltativi:

• --async: utilizza questo flag se vuoi che la richiesta venga restituita immediatamente, senza attendere il completamento dell'operazione in corso.

Puoi controllare lo stato della tua richiesta eseguendo gcloud spanner operations describe.

Eliminare una partizione

Non puoi eliminare una partizione mentre è associata a posizionamenti o dati. Prima di poter eliminare la partizione, devi spostare tutti i dati al suo interno o eliminare le tabelle di posizionamento che la utilizzano.

Console

1. Nella console Google Cloud, apri la pagina Spanner.

   Vai a Spanner

2. Seleziona un'istanza dall'elenco.

3. Nel menu di navigazione, seleziona Partizioni.

4. Nell'elenco delle partizioni, nella colonna Azioni, fai clic su Altro Azioni e seleziona Elimina.

5. Segui le istruzioni per confermare che vuoi eliminare la partizione.

6. Fai clic su Elimina.

gcloud

Utilizza il comando gcloud beta spanner instance-partitions delete.

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

Passaggi successivi

• Scopri come creare e gestire chiavi e tabelle dei posizionamenti.