Creazione e gestione delle partizioni delle istanze

Anteprima - Partizionamento geografico

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

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

Questa pagina descrive come creare e gestire le partizioni di istanze Spanner.

Crea una partizione dell'istanza

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 dell'istanza.

4. Fai clic su Crea partizione di istanza.

5. Inserisci un ID partizione istanza per identificare in modo permanente la partizione dell'istanza. Anche l'ID partizione dell'istanza deve essere univoco all'interno dell'istanza. Non potrai modificare l'ID partizione dell'istanza in un secondo momento.

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

7. Seleziona una configurazione dal menu a discesa.

8. Nella sezione Configura la capacità di computing, in Seleziona unità, fai clic su una delle seguenti opzioni:

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

   Per saperne di più, consulta Capacità di calcolo, nodi e unità di elaborazione.

9. In Scegli una modalità di scalabilità, fai clic su una delle seguenti opzioni:

   • Allocazione manuale se vuoi impostare manualmente la capacità di calcolo per risorse e costi di calcolo fissi.

     • Quantità indica il numero di unità di elaborazione o nodi da utilizzare per questa istanza.

   • Scalabilità automatica per consentire a Spanner di aggiungere e rimuovere automaticamente capacità di calcolo. Il gestore della scalabilità automatica gestito è disponibile nelle versioni Enterprise ed Enterprise Plus di Spanner. Per saperne di più sul gestore della scalabilità automatica gestito, consulta Gestore della scalabilità automatica gestito per Spanner. Configura le seguenti opzioni del gestore della scalabilità automatica gestito:

     • Minimo indica il limite minimo per fare lo scale down, a seconda dell'unità di misura scelta per Capacità di calcolo. Per saperne di più, consulta Determina il limite minimo.
     • Massimo indica il limite massimo di scale up, a seconda dell'unità di misura scelta per Capacità di calcolo. Per saperne di più, consulta Determina il limite massimo.
     • Target di utilizzo della CPU ad alta priorità indica la percentuale target di CPU da utilizzare per le attività ad alta priorità. Per maggiori informazioni, consulta Determina il target di utilizzo della CPU.
     • Target di utilizzo totale della CPU indica la percentuale target di CPU da utilizzare per tutte le attività con priorità bassa, media e alta. Per saperne di più, consulta Determina il target di utilizzo totale della CPU.
     • Target di utilizzo dello spazio di archiviazione indica la percentuale target di spazio di archiviazione da utilizzare. Per saperne di più, consulta Determina il target di utilizzo dello spazio di archiviazione.

10. Fai clic su Crea per creare la partizione dell'istanza.

gcloud

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

Sostituisci quanto segue:

• INSTANCE_PARTITION_ID: l'identificatore permanente della partizione dell'istanza, univoco all'interno dell'istanza. Non potrai modificare l'ID partizione dell'istanza in un secondo momento.
• INSTANCE_PARTITION_CONFIG: l'identificatore permanente della configurazione della partizione dell'istanza, che definisce la posizione geografica della partizione dell'istanza e influisce sulla posizione di archiviazione dei dati.
• INSTANCE_PARTITION_DESCRIPTION: il nome da visualizzare per la partizione dell'istanza nella console Google Cloud . Il nome della partizione dell'istanza deve essere univoco all'interno dell'istanza.
• INSTANCE_ID: l'identificatore permanente dell'istanza Spanner in cui si trova questa partizione dell'istanza.
• NODE_COUNT: la capacità di calcolo della partizione dell'istanza, espressa come numero di nodi. Un nodo equivale a 1000 unità di elaborazione.
• PROCESSING_UNIT_COUNT: la capacità di calcolo dell'istanza, espressa come numero di unità di elaborazione. La partizione dell'istanza 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 di istanza europe-partition in eur3 con 5 nodi, esegui questo comando:

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

Utilizza la scalabilità automatica gestita

Puoi utilizzare la scalabilità automatica gestita con il comando gcloud spanner instance-partitions create. Per saperne di più, consulta Gestore della scalabilità automatica gestito.

Utilizza il seguente comando per creare una partizione di istanza con gestore della scalabilità automatica:

  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

o

  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

Sostituisci quanto segue:

• INSTANCE_PARTITION_ID: l'identificatore permanente della partizione dell'istanza, univoco all'interno dell'istanza. Non potrai modificare l'ID partizione dell'istanza in un secondo momento.
• INSTANCE_PARTITION_CONFIG: l'identificatore permanente della configurazione della partizione dell'istanza, che definisce la posizione geografica della partizione dell'istanza e influisce sulla posizione di archiviazione dei dati.
• INSTANCE_PARTITION_DESCRIPTION: il nome da visualizzare per la partizione dell'istanza nella console Google Cloud . Il nome della partizione dell'istanza deve essere univoco all'interno dell'istanza.
• INSTANCE_ID: l'identificatore permanente dell'istanza Spanner in cui si trova questa partizione dell'istanza.
• MINIMUM_PROCESSING_UNITS o MINIMUM_NODES: il numero minimo di unità di elaborazione o nodi durante lo scale down. Per saperne di più, consulta Determina il limite minimo.
• MAXIMUM_PROCESSING_UNITS o MAXIMUM_NODES: il numero massimo di unità di elaborazione o nodi durante lo scale up. Per saperne di più, consulta Determina il limite massimo.
• HIGH_PRIORITY_CPU_PERCENTAGE: la percentuale target di CPU ad alta priorità da utilizzare, in base alla priorità dell'attività. La percentuale di CPU può variare dal 10% al 90%. Per saperne di più, consulta Determina il target di utilizzo della CPU ad alta priorità.
• TOTAL_CPU_PERCENTAGE: la percentuale target di utilizzo della CPU con priorità totale. Il target di CPU totale deve essere maggiore del target di CPU ad alta priorità. La percentuale di CPU può variare dal 10% al 90%. Per saperne di più, consulta Determina il target di utilizzo totale della CPU.
• STORAGE_PERCENTAGE: la percentuale target di spazio di archiviazione da utilizzare, dal 10% al 99%. Per saperne di più, consulta Determina il target di utilizzo dello spazio di archiviazione.

Librerie client

C++

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

gcloud

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

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

Sostituisci quanto segue:

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

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

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

Elenca le partizioni dell'istanza

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 dell'istanza.

   Viene visualizzato un elenco delle partizioni di istanze associate all'istanza.

gcloud

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

gcloud spanner instance-partitions list --instance=INSTANCE_ID

Google Cloud CLI stampa un elenco delle partizioni di istanza Spanner, insieme all'ID, al nome visualizzato, alla configurazione e alla capacità di calcolo di ciascuna partizione di istanza.

Modifica una partizione dell'istanza

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

Modifica 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 massimi consigliati. Per saperne di più, consulta quote e limiti per Spanner.

Se vuoi aumentare la capacità di computing di una partizione dell'istanza, il tuo progettoGoogle Cloud deve avere una quota sufficiente per aggiungere la capacità di computing. Il tempo necessario per il completamento della richiesta di aumento dipende dalle dimensioni della richiesta. Nella maggior parte dei casi, le richieste vengono completate entro pochi minuti. In rari casi, lo scale up 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 dell'istanza.

4. Nell'elenco delle partizioni di istanza, nella colonna Azioni, fai clic su Altre 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 utilizzi 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 dell'istanza deve avere almeno un nodo (1000 unità di elaborazione).

6. Fai clic su Salva.

   Se viene visualizzata una finestra di dialogo che indica che non disponi di quota sufficiente per aggiungere capacità di calcolo , segui le istruzioni per richiedere una quota più elevata.

gcloud

Per modificare la capacità di computing della partizione dell'istanza, utilizza gcloud spanner instance-partitions update. Quando utilizzi questo comando, specifica la capacità di computing come numero di nodi o unità di elaborazione.

gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
  --instance=INSTANCE_ID \
  [--nodes=NODE_COUNT | --processing-units=PROCESSING_UNIT_COUNT]
  [--async]

Sostituisci quanto segue:

• INSTANCE_PARTITION_ID: l'identificatore permanente della partizione dell'istanza.
• INSTANCE_ID: l'identificatore permanente dell'istanza.
• NODE_COUNT: la nuova capacità di computing della partizione dell'istanza, espressa come numero di nodi. Un nodo equivale a 1000 unità di elaborazione.
• PROCESSING_UNIT_COUNT: la nuova capacità di calcolo della partizione dell'istanza, espressa come numero di unità di elaborazione. La partizione dell'istanza deve avere almeno 1000 unità di elaborazione. Inserisci le 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.

Attiva o modifica il gestore della scalabilità automatica gestito su una partizione di istanze

Quando attivi o modifichi la funzionalità di scalabilità automatica gestita su una partizione di istanza esistente, si applicano le seguenti limitazioni:

• Non puoi spostare un'istanza mentre il gestore della scalabilità automatica è attivato.

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 dell'istanza.

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

5. In Configura capacità di calcolo, fai clic su Scalabilità automatica.

6. In Minimo, seleziona il limite minimo da utilizzare per fare lo scale down. Per saperne di più, consulta Determina il limite minimo.

7. In Massimo, seleziona il limite massimo da utilizzare per lo scale up. Per saperne di più, consulta Determina il limite massimo.

8. In Target di utilizzo della CPU ad alta priorità, inserisci la percentuale di CPU da utilizzare per le attività ad alta priorità. Per saperne di più, consulta Determina il target di utilizzo della CPU.

9. In Target di utilizzo totale della CPU, inserisci la percentuale di CPU target da utilizzare per tutte le attività con priorità bassa, media e alta. La percentuale di CPU può variare dal 10% al 90%. Per saperne di più, consulta Determina il target di utilizzo totale della CPU.

10. In Target di utilizzo dello spazio di archiviazione, inserisci la percentuale di spazio di archiviazione da utilizzare. Per saperne di più, consulta Determina il target di utilizzo dello spazio di archiviazione.

11. Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instance-partitions update per attivare il gestore della scalabilità automatica gestito su una partizione di istanze. Per ulteriori informazioni e limitazioni, consulta Flag e limitazioni di Google Cloud CLI.

Puoi aggiungere il gestore della scalabilità automatica gestito con il seguente comando:

  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

o

  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

Sostituisci quanto segue:

• INSTANCE_PARTITION_ID: l'identificatore permanente della partizione dell'istanza.
• INSTANCE_ID: l'identificatore permanente dell'istanza.
• MINIMUM_PROCESSING_UNITS o MINIMUM_NODES: il numero minimo di unità di elaborazione o nodi da utilizzare durante lo scale down. Per saperne di più, consulta Determina il limite minimo.
• MAXIMUM_PROCESSING_UNITS o MAXIMUM_NODES: il numero massimo di unità di elaborazione o nodi da utilizzare durante lo scale up. Per saperne di più, consulta Determina il limite massimo.
• HIGH_PRIORITY_CPU_PERCENTAGE: la percentuale target di CPU ad alta priorità da utilizzare, in base alla priorità dell'attività. La percentuale di CPU può variare dal 10% al 90%. Per saperne di più, consulta Determina il target di utilizzo della CPU ad alta priorità.
• TOTAL_CPU_PERCENTAGE: la percentuale target di utilizzo della CPU con priorità totale. Il target di CPU totale deve essere maggiore del target di CPU ad alta priorità. La percentuale di CPU può variare dal 10% al 90%. Per saperne di più, consulta Determina il target di utilizzo totale della CPU.
• STORAGE_PERCENTAGE: la percentuale target di spazio di archiviazione da utilizzare, dal 10% al 99%. Per saperne di più, consulta Determina il target di utilizzo dello spazio di archiviazione.

Dopo aver attivato il gestore della scalabilità automatica gestito su una partizione di istanze, puoi anche modificarne le impostazioni. Ad esempio, se vuoi aumentare il numero massimo di unità di elaborazione a 10.000, esegui questo comando:

gcloud spanner instance-partitions update test-instance-partition \
     --instance=test-instance
     --autoscaling-max-processing-units=10000

Cambia una partizione di istanza dall'utilizzo del gestore della scalabilità automatica gestito alla scalabilità manuale

Console

1. Vai alla pagina Istanze Spanner nella console Google Cloud .

   Vai alla pagina Istanze

2. Seleziona un'istanza dall'elenco.

3. Nel menu di navigazione, seleziona Partizioni dell'istanza.

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

5. In Scegli una modalità di scalabilità, seleziona la casella Allocazione manuale.

6. Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instance-partitions update per aggiornare la partizione dell'istanza.

Utilizza il seguente comando per modificare una partizione di istanza in modo che utilizzi la scalabilità manuale anziché il gestore della scalabilità automatica gestito:

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

o

  gcloud spanner instance-partitions update INSTANCE_PARTITION_ID \
    --instance=INSTANCE_ID \
  --nodes=NODE_COUNT

Sostituisci quanto segue:

• INSTANCE_PARTITION_ID: l'identificatore permanente della partizione dell'istanza.
• INSTANCE_ID: l'identificatore permanente dell'istanza.
• NODE_COUNT: la capacità di calcolo dell'istanza, espressa come numero di nodi. Ogni nodo equivale a 1000 unità di elaborazione.
• PROCESSING_UNIT_COUNT: la capacità di calcolo dell'istanza, espressa come numero di unità di elaborazione. Il numero minimo di unità di elaborazione per una partizione di istanza è 1000.

Elimina una partizione dell'istanza

Non puoi eliminare una partizione dell'istanza mentre è associata a posizionamenti o dati. Prima di poter eliminare la partizione dell'istanza, devi spostare tutti i dati presenti nella partizione dell'istanza o eliminare le tabelle di posizionamento che utilizzano la partizione dell'istanza.

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 dell'istanza.

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

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

6. Fai clic su Elimina.

gcloud

Utilizza il comando gcloud spanner instance-partitions delete.

gcloud spanner instance-partitions delete INSTANCE_PARTITION_ID
  --instance=INSTANCE_ID

Passaggi successivi

• Scopri come creare e gestire tabelle e chiavi di posizionamento gestito.