Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Creazione e gestione delle istanze

Questa pagina descrive come creare, elencare, modificare ed eliminare le istanze Spanner.

Crea un'istanza

Puoi creare un'istanza con la console Google Cloud , Google Cloud CLI o le librerie client. Puoi anche creare un'istanza con una configurazione dell'istanza personalizzata aggiungendo repliche di sola lettura facoltative.

Console

Nella console Google Cloud , vai alla pagina Istanze Spanner.
Fai clic su Crea istanza.

Vai a Crea istanza
Nella sezione Seleziona una versione, seleziona una versione di Spanner.

Se vuoi confrontare le specifiche delle diverse versioni, fai clic su Confronta le versioni. Per saperne di più, consulta la panoramica delle versioni di Spanner.
Fai clic su Continua.
Nella sezione Assegna un nome all'istanza, inserisci un Nome istanza da visualizzare nella console Google Cloud . Il nome dell'istanza deve essere univoco all'interno del progetto Google Cloud .
Inserisci un ID istanza per identificare in modo permanente la tua istanza. L'ID istanza deve essere univoco anche all'interno del progetto Google Cloud . Non potrai modificare l'ID istanza in un secondo momento.
Fai clic su Continua.
Nella sezione Configura l'istanza, in Scegli una configurazione, seleziona A livello di regione, A due regioni o Multiregionale.

Nota: le configurazioni di istanze a due regioni e multi-regione sono disponibili solo nella versione Enterprise Plus. Se vuoi confrontare le specifiche tra le tre configurazioni, fai clic su Confronta le configurazioni delle regioni.
Seleziona una località di configurazione dal menu a discesa.
(Facoltativo) Per aggiungere una replica di sola lettura a una configurazione di base di Spanner, crea prima una configurazione dell'istanza personalizzata utilizzando gcloud CLI. L'aggiunta di repliche di sola lettura facoltative a una configurazione di base è disponibile nelle versioni Enterprise ed Enterprise Plus.
Fai clic su Continua.
Nella sezione Alloca 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 istanze di piccole dimensioni.
Per saperne di più, consulta Capacità di calcolo, nodi e unità di elaborazione.
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.
(Facoltativo) Se selezioni Scalabilità automatica come modalità di scalabilità, puoi fare clic sul menu a discesa Mostra opzioni di scalabilità automatica asimmetrica per scalare automaticamente le repliche di sola lettura indipendentemente dalle altre repliche. Per saperne di più, consulta Scalabilità automatica asimmetrica di sola lettura.
1. Seleziona la replica di sola lettura di cui vuoi eseguire la scalabilità automatica in modo asimmetrico.
2. Configura le seguenti opzioni del gestore della scalabilità automatica asimmetrica:
  - 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 saperne di più, consulta Determina il target di utilizzo della CPU ad alta priorità.
  - Target di utilizzo totale della CPU indica la percentuale target di CPU da utilizzare per tutte le attività con priorità bassa, media e alta. La percentuale di CPU può variare dal 10% al 90%. Il target di CPU totale deve essere maggiore del target di CPU ad alta priorità. Se stai eseguendo l'ottimizzazione in base ai costi, utilizza una percentuale più alta. Per saperne di più, consulta Determina il target di utilizzo totale della CPU.
  - Disattiva CPU totale indica che il gestore della scalabilità automatica deve ignorare esplicitamente il target della CPU totale.
  - Disattiva CPU ad alta priorità indica che il gestore della scalabilità automatica deve ignorare esplicitamente il target della CPU per le attività ad alta priorità.
In Backup, la casella di controllo Abilita le pianificazioni dei backup predefiniti è selezionata per impostazione predefinita. Per disattivare le pianificazioni dei backup predefiniti, deseleziona la casella di controllo. Se questa opzione è abilitata, per tutti i nuovi database nell'istanza vengono creati backup completi ogni 24 ore. Questi backup vengono conservati per 7 giorni. Puoi modificare o eliminare le pianificazioni dei backup predefinite in qualsiasi momento. Per saperne di più, consulta Pianificazioni dei backup predefinite.
Fai clic sul pulsante Crea per creare l'istanza.

gcloud

Utilizza il comando gcloud spanner instances create per creare un'istanza. Specifica la capacità di calcolo come numero di nodi o unità di elaborazione che vuoi nell'istanza.

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--nodes=NODE_COUNT

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--processing-units=PROCESSING_UNIT_COUNT

Sostituisci quanto segue:

INSTANCE-ID: un identificatore permanente univoco all'interno del tuo progetto Google Cloud . Non potrai modificare l'ID istanza in un secondo momento.
INSTANCE-CONFIG: un identificatore permanente della configurazione dell'istanza, che definisce la posizione geografica dell'istanza e influisce sulla modalità di replica dei dati. Per le configurazioni delle istanze personalizzate, inizia con custom-. Per saperne di più, consulta Configurazioni delle istanze.
INSTANCE_DESCRIPTION: il nome da visualizzare per l'istanza nella console Google Cloud . Il nome dell'istanza deve essere univoco all'interno del progettoGoogle Cloud .
DEFAULT_BACKUP_SCHEDULE_TYPE: il tipo di pianificazione di backup predefinito utilizzato nell'istanza. Deve essere uno dei seguenti valori:
- AUTOMATIC: viene creata automaticamente una pianificazione di backup predefinita quando viene creato un nuovo database nell'istanza. La pianificazione del backup predefinita crea un backup completo ogni 24 ore. Questi backup completi vengono conservati per 7 giorni. Puoi modificare o eliminare la pianificazione del backup predefinita una volta creata.
- NONE: non viene creata automaticamente una pianificazione di backup predefinita quando viene creato un nuovo database nell'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. Inserisci quantità fino a 1000 in multipli di 100 (100, 200, 300 e così via) e quantità maggiori in multipli di 1000 (1000, 2000, 3000 e così via). Nota: non utilizzare questo parametro se stai creando un'istanza che intendi attivare in un secondo momento con il gestore della scalabilità automatica gestito.

Aggiungi scalabilità automatica gestita

Puoi anche creare istanze delle versioni Enterprise ed Enterprise Plus per utilizzare la scalabilità automatica gestita con il comando gcloud spanner instances create. Per saperne di più, consulta Gestore della scalabilità automatica gestito per Spanner.

Utilizza il seguente comando per creare un'istanza con gestore della scalabilità automatica gestito.

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --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 \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --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 \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET, \
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET, \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

Sostituisci quanto segue:

INSTANCE-ID: un identificatore permanente univoco all'interno del tuo progetto Google Cloud . Non potrai modificare l'ID istanza in un secondo momento.
INSTANCE-CONFIG: un identificatore permanente della configurazione dell'istanza, che definisce la posizione geografica dell'istanza e influisce sulla modalità di replica dei dati. Per le configurazioni delle istanze personalizzate, inizia con custom-. Per saperne di più, consulta Configurazioni delle istanze.
INSTANCE-DESCRIPTION: il nome da visualizzare per l'istanza nella console Google Cloud . Il nome dell'istanza deve essere univoco all'interno del progettoGoogle Cloud .
MINIMUM_PROCESSING_UNITS, 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, 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%. Se l'ottimizzazione è per i costi, utilizza una percentuale più alta. 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%. Se stai ottimizzando i costi, utilizza una percentuale più alta. Per ulteriori informazioni, 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.

Flag facoltativi:

--disable-downscaling: utilizza questo flag booleano per disattivare lo scale down. Se impostato su TRUE, impedisce al gestore della scalabilità automatica di ridurre il numero di nodi o unità di elaborazione. Lo scale up continua a funzionare normalmente per soddisfare l'aumento della domanda. Per attivare lo scale down dopo averlo disattivato, utilizza il flag --no-disable-downscaling.
--asymmetric-autoscaling-option: utilizza questo flag per attivare la scalabilità automatica asimmetrica. Sostituisci i seguenti parametri:
- ASYMMETRIC_AUTOSCALING_LOCATION: se viene utilizzato il flag, questo parametro è obbligatorio. La località della regione di sola lettura che vuoi scalare in modo asimmetrico.
- ASYMMETRIC_AUTOSCALING_MIN: parametro facoltativo. Il numero minimo di nodi durante lo scale down. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base.
- ASYMMETRIC_AUTOSCALING_MAX: parametro facoltativo. Il numero massimo di nodi durante lo scale up. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base.
- ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: parametro facoltativo. La percentuale target di CPU da utilizzare, in base alla priorità dell'attività. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base. Se stai ottimizzando i costi, utilizza una percentuale più alta. Le repliche possono avere una percentuale target diversa rispetto all'istanza di base e ad altre repliche, ma per gli scenari di failover consigliamo di utilizzare target coerenti tra le diverse repliche. Per saperne di più, consulta Problemi di failover.
- ASYMMETRIC_TOTAL_CPU_TARGET: parametro facoltativo. Imposta il target dal 10% al 90% per la CPU totale. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base. Se stai ottimizzando i costi, utilizza una percentuale più alta. Le repliche possono avere una percentuale target diversa rispetto all'istanza di base e ad altre repliche, ma per gli scenari di failover consigliamo di utilizzare target coerenti tra le diverse repliche. Per saperne di più, consulta Scalabilità automatica asimmetrica di sola lettura.
- disable_total_cpu_autoscaling: imposta questo parametro su TRUE se non vuoi che il gestore della scalabilità automatica esegua la scalabilità automatica della CPU totale sulle repliche. Non specificare questo parametro se vuoi che l'istanza erediti il target total_cpu_autoscaling dall'istanza di base. Non puoi disattivare sia la CPU totale sia la CPU ad alta priorità sulla stessa replica.
- disable_high_priority_cpu_autoscaling: imposta disable_high_priority_cpu_autoscaling su TRUE se non vuoi che il gestore della scalabilità automatica esegua la scalabilità automatica della CPU con priorità elevata sulle repliche. Non specificare questo parametro se vuoi che l'istanza erediti il target high_priority_cpu_autoscaling dall'istanza di base. Non puoi disabilitare sia la CPU totale sia la CPU ad alta priorità sulla stessa replica.

Esempi di utilizzo delle configurazioni personalizzate

Per creare un'istanza test-instance nella configurazione delle istanze regionali di base us-central1, esegui:

gcloud spanner instances create test-instance --edition=STANDARD --config=regional-us-central1 \
  --description="Test Instance" --nodes=1

Per creare un'istanza custom-eur6-instance nella configurazione dell'istanza multi-regione personalizzata custom-eur6, devi prima creare una configurazione dell'istanza personalizzata.

Dopodiché, esegui:

  gcloud spanner instances create custom-eur6-instance --edition=ENTERPRISE_PLUS --config=custom-eur6 \
      --description="Instance with custom read-only" --nodes=1

Dopo aver eseguito uno dei comandi precedenti, dovresti visualizzare un messaggio simile al seguente esempio:

Creating instance...done.

C++

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

void CreateInstance(google::cloud::spanner_admin::InstanceAdminClient client,
                    std::string const& project_id,
                    std::string const& instance_id,
                    std::string const& display_name,
                    std::string const& config_id) {
  namespace spanner = ::google::cloud::spanner;
  spanner::Instance in(project_id, instance_id);

  auto project = google::cloud::Project(project_id);
  std::string config_name =
      project.FullName() + "/instanceConfigs/" + config_id;
  auto instance =
      client
          .CreateInstance(spanner::CreateInstanceRequestBuilder(in, config_name)
                              .SetDisplayName(display_name)
                              .SetNodeCount(1)
                              .SetLabels({{"cloud_spanner_samples", "true"}})
                              .Build())
          .get();
  if (!instance) throw std::move(instance).status();
  std::cout << "Created instance [" << in << "]:\n" << instance->DebugString();
}

C#

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceAsyncSample
{
    public async Task<Instance> CreateInstanceAsync(
        string projectId,
        string instanceId,
        Instance.Types.Edition edition = Instance.Types.Edition.Standard)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName = InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-us-central1"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            Edition = edition,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response = await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse = await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance created successfully.");

        return completedResponse.Result;
    }
}

Crea un'istanza senza una pianificazione dei backup predefinita


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
using System.Threading.Tasks;

public class CreateInstanceWithoutDefaultBackupSchedulesAsyncSample
{
    public async Task<Instance> CreateInstanceWithoutDefaultBackupSchedulesAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            ConfigAsInstanceConfigName =
                InstanceConfigName.FromProjectInstanceConfig(projectId, "regional-me-central2"),
            DisplayName = "This is a display name.",
            NodeCount = 1,
            Labels =
            {
                { "cloud_spanner_samples", "true" },
            },
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.None,
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

        // Make the CreateInstance request.
        Operation<Instance, CreateInstanceMetadata> response =
            await instanceAdminClient.CreateInstanceAsync(projectName, instanceId, instance);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, CreateInstanceMetadata> completedResponse =
            await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while creating instance: {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.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)

func createInstance(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: instanceID,
			NodeCount:   1,
			Labels:      map[string]string{"cloud_spanner_samples": "true"},
			Edition:     instancepb.Instance_STANDARD,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

Crea un'istanza con scalabilità automatica gestita utilizzando Go

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// Example of creating an autoscaling instance with Go.
// projectID is the ID of the project that the new instance will be in.
// instanceID is the ID of the new instance to be created.
func createInstanceWithAutoscalingConfig(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err)
	}
	defer instanceAdmin.Close()

	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID)
	fmt.Fprintf(w, "Creating instance %s.", instanceName)

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 2,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{
		Name: instanceName,
		// Get the autoscaling_config field from the newly created instance.
		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}},
	})
	if err != nil {
		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig)
	return nil
}

Crea un'istanza con scalabilità automatica asimmetrica di sola lettura utilizzando Go

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// createInstanceWithAsymmetricAutoscalingConfig is a code snippet to show
// an example of creating an asymmetric autoscaling enabled instance in Go.
//
// projectID is the ID of the project that the new instance will be in.
// instanceID is the ID of the new instance to be created.
func createInstanceWithAsymmetricAutoscalingConfig(w io.Writer, projectID, instanceID string) error {
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return fmt.Errorf("could not create instance admin client for project %s: %w", projectID, err)
	}
	defer instanceAdmin.Close()

	instanceName := fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID)
	fmt.Fprintf(w, "Creating instance %s.", instanceName)

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "nam-eur-asia3"),
			DisplayName: "Create instance example",
			AutoscalingConfig: &instancepb.AutoscalingConfig{
				AutoscalingLimits: &instancepb.AutoscalingConfig_AutoscalingLimits{
					MinLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MinNodes{
						MinNodes: 1,
					},
					MaxLimit: &instancepb.AutoscalingConfig_AutoscalingLimits_MaxNodes{
						MaxNodes: 10,
					},
				},
				AutoscalingTargets: &instancepb.AutoscalingConfig_AutoscalingTargets{
					HighPriorityCpuUtilizationPercent: 65,
					StorageUtilizationPercent:         95,
				},
				// Read-only replicas in europe-west1, europe-west4, and asia-east1 are autoscaled
				// independly from other replicas based on the usage in the respective region.
				AsymmetricAutoscalingOptions: []*instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west1",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "europe-west4",
						},
					},
					&instancepb.AutoscalingConfig_AsymmetricAutoscalingOption{
						ReplicaSelection: &instancepb.ReplicaSelection{
							Location: "asia-east1",
						},
					},
				},
			},
			Labels:  map[string]string{"cloud_spanner_samples": "true"},
			Edition: instancepb.Instance_ENTERPRISE_PLUS,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Waiting for operation on %s to complete...", instanceID)
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s].\n", instanceID)

	instance, err := instanceAdmin.GetInstance(ctx, &instancepb.GetInstanceRequest{
		Name: instanceName,
		// Get the autoscaling_config field from the newly created instance.
		FieldMask: &field_mask.FieldMask{Paths: []string{"autoscaling_config"}},
	})
	if err != nil {
		return fmt.Errorf("failed to get instance [%s]: %w", instanceName, err)
	}
	fmt.Fprintf(w, "Instance %s has autoscaling_config: %s.", instanceID, instance.AutoscalingConfig)
	return nil
}

Crea un'istanza senza una pianificazione dei backup predefinita

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
)

// createInstanceWithoutDefaultBackupSchedule creates instance with default backup schedule disabled.
func createInstanceWithoutDefaultBackupSchedule(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	// Create an instance without default backup schedule, whicn means no default backup schedule will
	// be created automatically on creation of a database within the instance.
	req := &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:                    fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName:               instanceID,
			NodeCount:                 1,
			Labels:                    map[string]string{"cloud_spanner_samples": "true"},
			DefaultBackupScheduleType: instancepb.Instance_NONE,
		},
	}

	op, err := instanceAdmin.CreateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.  For more information about instances, see
	// https://cloud.google.com/spanner/docs/instances.
	instance, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if instance.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", instance.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

Java

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


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.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import java.util.concurrent.ExecutionException;

class CreateInstanceExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Descriptive name";

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .setEdition(Instance.Edition.STANDARD)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the createInstance operation to finish.
      Instance createdInstance =
          instanceAdminClient
              .createInstanceAsync(
                  CreateInstanceRequest.newBuilder()
                      .setParent(ProjectName.of(projectId).toString())
                      .setInstanceId(instanceId)
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully created%n", createdInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
    }
  }
}

Crea un'istanza con scalabilità automatica gestita utilizzando Java


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.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

Crea un'istanza con scalabilità automatica asimmetrica di sola lettura utilizzando Java


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.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

  static void createInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstance(projectId, instanceId);
  }

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "nam-eur-asia3";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      // The read-only replicas listed in the asymmetric autoscaling options scale independently
      // from other replicas.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west1")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("europe-west4")))
              .addAsymmetricAutoscalingOptions(
                  AutoscalingConfig.AsymmetricAutoscalingOption.newBuilder()
                  .setReplicaSelection(ReplicaSelection.newBuilder().setLocation("asia-east1")))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

      // Creates a new instance
      System.out.printf("Creating instance %s.%n", instanceId);
      try {
        // Wait for the createInstance operation to finish.
        Instance instanceResult = instanceAdminClient.createInstanceAsync(
            CreateInstanceRequest.newBuilder()
                .setParent(ProjectName.of(projectId).toString())
                .setInstanceId(instanceId)
                .setInstance(instance)
                .build()).get();
        System.out.printf("Asymmetric Autoscaling instance %s was successfully created%n",
            instanceResult.getName());
      } catch (ExecutionException e) {
        System.out.printf(
            "Error: Creating instance %s failed with error message %s%n",
            instance.getName(), e.getMessage());
      } catch (InterruptedException e) {
        System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
      }
    }
  }
}

Crea un'istanza senza una pianificazione dei backup predefinita


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.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithoutDefaultBackupSchedulesExample {

  static void createInstanceWithoutDefaultBackupSchedules() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    createInstanceWithoutDefaultBackupSchedules(projectId, instanceId);
  }

  static void createInstanceWithoutDefaultBackupSchedules(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Descriptive name";

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.NONE)
            .setNodeCount(nodeCount)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the createInstance operation to finish.
      Instance createdInstance =
          instanceAdminClient
              .createInstanceAsync(
                  CreateInstanceRequest.newBuilder()
                      .setParent(ProjectName.of(projectId).toString())
                      .setInstanceId(instanceId)
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully created%n", createdInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Creating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for createInstance operation to finish was interrupted");
    }
  }
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = await spanner.getInstanceAdminClient();
/**
 * TODO(developer): Uncomment the following lines before running the sample.
 **/
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a new instance
try {
  console.log(
    `Creating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-us-central1',
      ),
      nodeCount: 1,
      displayName: 'Display name for the instance.',
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.STANDARD, //optional
    },
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();

  console.log(`Created instance ${instanceId}.`);
} catch (err) {
  console.error('ERROR:', err);
}

Crea un'istanza con scalabilità automatica gestita utilizzando Node.js

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Get the instance admin client
const instanceAdminClient = spanner.getInstanceAdminClient();

const autoscalingConfig =
  protos.google.spanner.admin.instance.v1.AutoscalingConfig.create({
    // Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
    autoscalingLimits:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingLimits.create(
        {
          minNodes: 1,
          maxNodes: 2,
        },
      ),
    // highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
    // percentages and must lie between 0 and 100.
    autoscalingTargets:
      protos.google.spanner.admin.instance.v1.AutoscalingConfig.AutoscalingTargets.create(
        {
          highPriorityCpuUtilizationPercent: 65,
          storageUtilizationPercent: 95,
        },
      ),
  });

// Creates a new instance with autoscaling configuration
// When autoscalingConfig is enabled, nodeCount and processingUnits fields
// need not be specified.
try {
  console.log(
    `Creating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-us-central1',
      ),
      displayName: 'Display name for the instance.',
      autoscalingConfig: autoscalingConfig,
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      // Managed autoscaler is available only for ENTERPRISE edition
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE,
    },
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();
  console.log(`Created instance ${instanceId}.`);

  // get instance metadata
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Autoscaling configurations of ${instanceId} are:  ` +
      '\n' +
      `Min nodes: ${metadata.autoscalingConfig.autoscalingLimits.minNodes} ` +
      'nodes.' +
      '\n' +
      `Max nodes: ${metadata.autoscalingConfig.autoscalingLimits.maxNodes}` +
      ' nodes.' +
      '\n' +
      `High priority cpu utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.highPriorityCpuUtilizationPercent}.` +
      '\n' +
      `Storage utilization percent: ${metadata.autoscalingConfig.autoscalingTargets.storageUtilizationPercent}.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

Crea un'istanza senza una pianificazione dei backup predefinita

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 **/
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = await spanner.getInstanceAdminClient();
// Creates a new instance
try {
  const [operation] = await instanceAdminClient.createInstance({
    instanceId: instanceId,
    parent: instanceAdminClient.projectPath(projectId),
    instance: {
      config: instanceAdminClient.instanceConfigPath(
        projectId,
        'regional-me-central2',
      ),
      nodeCount: 1,
      displayName: 'Display name for the instance.',
      labels: {
        cloud_spanner_samples: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.NONE,
    },
  });
  await operation.promise();

  console.log(
    `Created instance ${instanceId} without default backup schedules.`,
  );
} catch (err) {
  console.error('ERROR:', err);
}

PHP

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceRequest;
use Google\Cloud\Spanner\Admin\Instance\V1\Instance;

/**
 * Creates an instance.
 * Example:
 * ```
 * create_instance($projectId, $instanceId);
 * ```
 *
 * @param string $projectId  The Spanner project ID.
 * @param string $instanceId The Spanner instance ID.
 */
function create_instance(string $projectId, string $instanceId): void
{
    $instanceAdminClient = new InstanceAdminClient();
    $parent = InstanceAdminClient::projectName($projectId);
    $instanceName = InstanceAdminClient::instanceName($projectId, $instanceId);
    $configName = $instanceAdminClient->instanceConfigName($projectId, 'regional-us-central1');
    $instance = (new Instance())
        ->setName($instanceName)
        ->setConfig($configName)
        ->setDisplayName('dispName')
        ->setNodeCount(1);

    $operation = $instanceAdminClient->createInstance(
        (new CreateInstanceRequest())
        ->setParent($parent)
        ->setInstanceId($instanceId)
        ->setInstance($instance)
    );

    print('Waiting for operation to complete...' . PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created instance %s' . PHP_EOL, $instanceId);
}

Python

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

def create_instance(instance_id):
    """Creates an instance."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    config_name = "{}/instanceConfigs/regional-us-central1".format(
        spanner_client.project_name
    )

    operation = spanner_client.instance_admin_api.create_instance(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            node_count=1,
            labels={
                "cloud_spanner_samples": "true",
                "sample_name": "snippets-create_instance-explicit",
                "created": str(int(time.time())),
            },
            edition=spanner_instance_admin.Instance.Edition.STANDARD,  # Optional
        ),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Created instance {}".format(instance_id))

Crea un'istanza con scalabilità automatica gestita utilizzando Python

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

def create_instance_with_autoscaling_config(instance_id):
    """Creates a Cloud Spanner instance with an autoscaling configuration."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    config_name = "{}/instanceConfigs/regional-us-central1".format(
        spanner_client.project_name
    )

    autoscaling_config = spanner_instance_admin.AutoscalingConfig(
        # Only one of minNodes/maxNodes or minProcessingUnits/maxProcessingUnits can be set.
        autoscaling_limits=spanner_instance_admin.AutoscalingConfig.AutoscalingLimits(
            min_nodes=1,
            max_nodes=2,
        ),
        # highPriorityCpuUtilizationPercent and storageUtilizationPercent are both
        # percentages and must lie between 0 and 100.
        autoscaling_targets=spanner_instance_admin.AutoscalingConfig.AutoscalingTargets(
            high_priority_cpu_utilization_percent=65,
            storage_utilization_percent=95,
        ),
    )

    #  Creates a new instance with autoscaling configuration
    #  When autoscalingConfig is enabled, nodeCount and processingUnits fields
    #  need not be specified.
    request = spanner_instance_admin.CreateInstanceRequest(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            autoscaling_config=autoscaling_config,
            labels={
                "cloud_spanner_samples": "true",
                "sample_name": "snippets-create_instance_with_autoscaling_config",
                "created": str(int(time.time())),
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
    )

    operation = spanner_client.instance_admin_api.create_instance(request=request)

    print("Waiting for operation to complete...")
    instance = operation.result(OPERATION_TIMEOUT_SECONDS)

    print(
        "Created instance {} with {} autoscaling config".format(
            instance_id, instance.autoscaling_config
        )
    )

Crea un'istanza senza una pianificazione dei backup predefinita

def create_instance_without_default_backup_schedules(instance_id):
    spanner_client = spanner.Client()
    config_name = "{}/instanceConfigs/regional-me-central2".format(
        spanner_client.project_name
    )

    operation = spanner_client.instance_admin_api.create_instance(
        parent=spanner_client.project_name,
        instance_id=instance_id,
        instance=spanner_instance_admin.Instance(
            config=config_name,
            display_name="This is a display name.",
            node_count=1,
            default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.NONE,  # Optional
        ),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Created instance {} without default backup schedules".format(instance_id))

Ruby

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# instance_config_id = "Your Spanner InstanceConfig ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/instance"

instance_admin_client = Google::Cloud::Spanner::Admin::Instance.instance_admin

project_path = instance_admin_client.project_path project: project_id
instance_path = instance_admin_client.instance_path project: project_id, instance: instance_id
instance_config_path = instance_admin_client.instance_config_path project: project_id, instance_config: instance_config_id

job = instance_admin_client.create_instance parent: project_path,
                                            instance_id: instance_id,
                                            instance: { name: instance_path,
                                                        config: instance_config_path,
                                                        display_name: instance_id,
                                                        node_count: 2,
                                                        labels: { cloud_spanner_samples: "true" } }

puts "Waiting for create instance operation to complete"

job.wait_until_done!

if job.error?
  puts job.error
else
  puts "Created instance #{instance_id}"
end

Elenca istanze

Puoi visualizzare un elenco delle tue istanze Spanner.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze

La console Google Cloud mostra un elenco delle tue istanze Spanner, insieme all'ID, al nome visualizzato, alla configurazione e alla capacità di computing di ciascuna istanza, espressa sia in unità di elaborazione sia in nodi.

gcloud

Utilizza il comando gcloud spanner instances list:

gcloud spanner instances list

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

Modifica un'istanza

Le sezioni seguenti spiegano come eseguire l'upgrade della versione dell'istanza e modificare il nome visualizzato, la capacità di calcolo e il tipo di pianificazione del backup predefinito di un'istanza. Non puoi modificare l'ID o la configurazione dell'istanza (tuttavia, puoi spostare l'istanza).

Esegui l'upgrade della versione

Puoi eseguire l'upgrade delle istanze della versione Standard a una versione di livello superiore. È possibile eseguire l'upgrade delle istanze della versione Standard alla versione Enterprise o Enterprise Plus, a condizione che non siano state bloccate da un vincolo della policy dell'organizzazione. È possibile eseguire l'upgrade delle istanze della versione Enterprise alla versione Enterprise Plus. Il completamento dell'upgrade della versione richiede circa 10 minuti senza tempi di inattività.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza di cui vuoi eseguire l'upgrade.
Fai clic su Esegui l'upgrade accanto al tipo di versione.
Nella pagina Modifica istanza, in Aggiorna versione, seleziona la nuova versione di livello superiore per l'istanza.
Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instances update per eseguire l'upgrade della versione dell'istanza:

gcloud spanner instances update INSTANCE_ID --edition=EDITION \
[--async]

Sostituisci quanto segue:

INSTANCE_ID: l'identificatore permanente dell'istanza.
EDITION: specifica la nuova versione di livello superiore per la tua istanza. Per saperne di più, consulta la panoramica delle versioni di Spanner.

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.

Vai

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

func updateInstance(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// The edition selected for this instance.
			// Different editions provide different capabilities at different price points.
			// For more information, see https://cloud.google.com/spanner/docs/editions-overview.
			Edition: instancepb.Instance_ENTERPRISE,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"edition"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID)
	return nil
}

Java


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceExample {

  static void updateInstance() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    updateInstance(projectId, instanceId);
  }

  static void updateInstance(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Updated name";

    // Update an Instance object that will be used to update the instance.
    Instance instance =
        Instance.newBuilder()
            .setName(InstanceName.of(projectId, instanceId).toString())
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setEdition(Instance.Edition.ENTERPRISE)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the updatedInstance operation to finish.
      Instance updatedInstance =
          instanceAdminClient
              .updateInstanceAsync(
                  UpdateInstanceRequest.newBuilder()
                      .setFieldMask(
                          FieldMask.newBuilder().addAllPaths(Lists.newArrayList("edition")))
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Updating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");
    }
  }
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

const instanceAdminClient = spanner.getInstanceAdminClient();

// Updates an instance
try {
  console.log(
    `Updating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      labels: {
        updated: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE, //optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['labels', 'edition'],
    }),
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();
  console.log(`Updated instance ${instanceId}.`);
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.edition} ` +
      'edition.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

def update_instance(instance_id):
    """Updates an instance."""
    from google.cloud.spanner_admin_instance_v1.types import spanner_instance_admin

    spanner_client = spanner.Client()

    name = "{}/instances/{}".format(spanner_client.project_name, instance_id)

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            labels={
                "sample_name": "snippets-update_instance-explicit",
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["labels", "edition"]),
    )

    print("Waiting for operation to complete...")
    operation.result(900)

    print("Updated instance {}".format(instance_id))

Esegui il downgrade della versione

Puoi eseguire il downgrade delle istanze Spanner a un'edizione di livello inferiore. Per eseguire il downgrade, devi smettere di utilizzare le funzionalità della versione di livello superiore. È possibile eseguire il downgrade delle istanze della versione Enterprise alla versione Standard. È possibile eseguire il downgrade delle istanze della versione Enterprise Plus alla versione Enterprise o Standard. Il downgrade della versione richiede circa 10 minuti senza tempi di inattività.

Per monitorare l'utilizzo delle funzionalità delle versioni Enterprise ed Enterprise Plus nella tua istanza, utilizza la metrica di monitoraggio Utilizzo delle funzionalità (instance/edition/feature_usage). Per saperne di più, consulta Monitora l'utilizzo della versione.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza di cui vuoi eseguire il downgrade.
Nella pagina Panoramica istanza, fai clic su Modifica istanza.
Nella pagina Modifica istanza, in Scegli una versione di Spanner, seleziona la versione di livello inferiore.
Fai clic su Aggiorna istanza.

gcloud

Utilizza il comando gcloud spanner instances update per eseguire il downgrade della versione dell'istanza:

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Sostituisci quanto segue:

INSTANCE_ID: l'identificatore permanente dell'istanza.
EDITION: specifica la nuova versione di livello inferiore per la tua istanza. Per saperne di più, consulta la panoramica delle versioni di Spanner.

Modifica il nome visualizzato

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza che vuoi rinominare.
Fai clic su Modifica istanza.
Inserisci un nuovo nome per l'istanza. Questo nome deve essere univoco all'interno del progettoGoogle Cloud .
Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Sostituisci quanto segue:

INSTANCE_ID: l'identificatore permanente dell'istanza.
INSTANCE_NAME: il nome da visualizzare per l'istanza nella consoleGoogle Cloud . Il nome dell'istanza deve essere univoco all'interno del progettoGoogle Cloud .

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.

Puoi ridurre la capacità di calcolo di un'istanza Spanner, tranne nei seguenti scenari:

Non puoi archiviare più di 10 TiB di dati per nodo (1000 unità di elaborazione).
Esiste un numero elevato di suddivisioni per i dati dell'istanza. In questo scenario, Spanner potrebbe non essere in grado di gestire le suddivisioni dopo la riduzione della capacità di computing. Puoi provare a ridurre la capacità di calcolo di quantità progressivamente inferiori fino a trovare la capacità minima necessaria a Spanner per gestire tutte le suddivisioni dell'istanza.

Spanner può creare un numero elevato di suddivisioni per adattarsi ai tuoi pattern di utilizzo. Se i pattern di utilizzo cambiano, dopo una o due settimane Spanner potrebbe unire alcune suddivisioni e potrai provare a ridurre la capacità di computing dell'istanza.

Quando rimuovi la capacità di calcolo, monitora l'utilizzo della CPU e le latenze delle richieste in Cloud Monitoring per assicurarti che l'utilizzo della CPU rimanga inferiore al 65% per le istanze regionali e al 45% per ogni regione nelle istanze multiregionali. Potresti riscontrare un aumento temporaneo delle latenze delle richieste durante la rimozione della capacità di computing.

Se vuoi aumentare la capacità di calcolo di un'istanza, il tuo progettoGoogle Cloud deve avere una quota sufficiente per aggiungere la 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 rari casi, lo scale up potrebbe richiedere fino a un'ora.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza che vuoi modificare.
Fai clic su Modifica istanza.
Modifica la capacità di calcolo scegliendo le unità di misura (unità di elaborazione o nodi) e inserendo una quantità. Quando utilizzi le unità di elaborazione, inserisci quantità fino a 1000 in multipli di 100 (100, 200, 300 e così via) e inserisci quantità maggiori in multipli di 1000 (1000, 2000, 3000 e così via). Ogni nodo equivale a 1000 unità di elaborazione.
Fai clic su Salva.

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

gcloud

Utilizza il comando gcloud spanner instances update. Quando utilizzi questo comando, specifica la capacità di computing come numero di nodi o unità di elaborazione.

gcloud spanner instances update INSTANCE_ID --nodes=NODE_COUNT
[--async]

gcloud spanner instances update INSTANCE_ID
--processing-units=PROCESSING_UNIT_COUNT [--async]

Sostituisci quanto segue:

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. Inserisci quantità fino a 1000 in multipli di 100 (100, 200, 300 e così via) e quantità maggiori 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 un'istanza

Puoi attivare o modificare la scalabilità automatica in un'istanza Spanner utilizzando la console Google Cloud , gcloud CLI o le librerie client di Spanner. Quando aggiungi o modifichi la funzionalità di scalabilità automatica gestita in un'istanza esistente, si applicano le seguenti limitazioni:

Il gestore della scalabilità automatica gestito è disponibile solo nella versione Enterprise o Enterprise Plus.
Non puoi attivare il gestore della scalabilità automatica gestito su un'istanza che stai spostando.
Non puoi spostare un'istanza mentre il gestore della scalabilità automatica è attivato.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza per cui vuoi attivare il gestore della scalabilità automatica gestito.
Fai clic su Modifica istanza.
In Configura capacità di calcolo, fai clic su Scalabilità automatica.
In Minimo, seleziona il limite minimo da utilizzare per fare lo scale down. Per saperne di più, consulta Determina il limite minimo.
In Massimo, seleziona il limite massimo da utilizzare per lo scale up. Per saperne di più, consulta Determina il limite massimo.
In Target di utilizzo della CPU ad alta priorità, seleziona la percentuale di CPU da utilizzare per le attività ad alta priorità. Per saperne di più, consulta Determina il target di utilizzo della CPU.
Per Target di utilizzo totale della CPU, seleziona 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.
Per Target di utilizzo dello spazio di archiviazione, seleziona la percentuale di spazio di archiviazione da utilizzare. Per saperne di più, consulta Determina il target di utilizzo dello spazio di archiviazione.
(Facoltativo) Se selezioni Scalabilità automatica come modalità di scalabilità, puoi fare clic sul menu a discesa Mostra opzioni di scalabilità automatica asimmetrica per scalare automaticamente le repliche di sola lettura indipendentemente dalle altre repliche.
1. Seleziona la replica di sola lettura di cui vuoi eseguire la scalabilità automatica in modo asimmetrico.
2. Configura le seguenti opzioni del gestore della scalabilità automatica:
  - 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 saperne di più, consulta Determina il target di utilizzo della CPU ad alta priorità.
  - Target di utilizzo totale della CPU indica la percentuale target di CPU 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.
Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instances update per aggiungere il gestore della scalabilità automatica gestito a un'istanza. 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 instances update 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 \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET,\
       disable_total_cpu_autoscaling=TRUE|FALSE
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]

Sostituisci quanto segue:

INSTANCE_ID: l'identificatore permanente dell'istanza.
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: il numero minimo di unità di elaborazione o nodi da utilizzare per fare lo scale down. Per saperne di più, consulta Determina il limite minimo.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: il numero massimo di unità di elaborazione o nodi da utilizzare per 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%. Se l'ottimizzazione è per i costi, utilizza una percentuale più alta. 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%. Se stai ottimizzando i costi, utilizza una percentuale più alta. Per ulteriori informazioni, 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.

Flag facoltativi:

--disable-downscaling: utilizza questo flag booleano per disattivare lo scale down. Se impostato su TRUE, impedisce al gestore della scalabilità automatica di ridurre il numero di nodi o unità di elaborazione. Lo scale up continua a funzionare normalmente per soddisfare l'aumento della domanda. Per attivare lo scale down dopo averlo disattivato, utilizza il flag --no-disable-downscaling.
--asymmetric-autoscaling-option: utilizza questo flag per attivare la scalabilità automatica asimmetrica.

Sostituisci i seguenti parametri:
- ASYMMETRIC_AUTOSCALING_LOCATION: se viene utilizzato il flag di scalabilità automatica asimmetrica, questo parametro è obbligatorio. La località della regione di sola lettura che vuoi scalare in modo asimmetrico.
- ASYMMETRIC_AUTOSCALING_MIN: parametro facoltativo. Il numero minimo di nodi durante lo scale down. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base.
- ASYMMETRIC_AUTOSCALING_MAX: parametro facoltativo. Il numero massimo di nodi durante lo scale up. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base.
- ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: parametro facoltativo. La percentuale target di CPU da utilizzare, in base alla priorità dell'attività. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base. Se stai ottimizzando i costi, utilizza una percentuale più alta. Le repliche possono avere una percentuale target diversa rispetto all'istanza di base e ad altre repliche, ma per gli scenari di failover consigliamo di utilizzare target coerenti tra le diverse repliche. Per saperne di più, consulta Problemi di failover.
- ASYMMETRIC_TOTAL_CPU_TARGET: parametro facoltativo. Imposta il target dal 10% al 90% per la CPU totale. Se non viene specificato, questo valore viene ereditato dalla configurazione dell'istanza di base. Se stai ottimizzando i costi, utilizza una percentuale più alta. Le repliche possono avere una percentuale target diversa rispetto all'istanza di base e ad altre repliche, ma per gli scenari di failover consigliamo di utilizzare target coerenti tra le diverse repliche. Per saperne di più, consulta Scalabilità automatica asimmetrica di sola lettura.
- disable_total_cpu_autoscaling: imposta questo parametro su TRUE se non vuoi che il gestore della scalabilità automatica esegua la scalabilità automatica della CPU totale sulle repliche. Non specificare questo parametro se vuoi che l'istanza erediti il target total_cpu_autoscaling dall'istanza di base. Non puoi disattivare sia la CPU totale sia la CPU ad alta priorità sulla stessa replica.
- disable_high_priority_cpu_autoscaling: imposta disable_high_priority_cpu_autoscaling su TRUE se non vuoi che il gestore della scalabilità automatica esegua la scalabilità automatica della CPU con priorità elevata sulle repliche. Non specificare questo parametro se vuoi che l'istanza erediti il target high_priority_cpu_autoscaling dall'istanza di base. Non puoi disabilitare sia la CPU totale sia la CPU ad alta priorità sulla stessa replica.

Dopo aver aggiunto il gestore della scalabilità automatica gestito a un'istanza, 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 instances update test-instance \
     --autoscaling-max-processing-units=10000

Cambia un'istanza dall'utilizzo del gestore della scalabilità automatica gestito alla scalabilità manuale

Puoi modificare l'utilizzo della scalabilità manuale o gestita da parte di un'istanza Spanner utilizzando la console Google Cloud , gcloud CLI o le librerie client di Spanner.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza per cui vuoi disattivare il gestore della scalabilità automatica gestito.
In Scegli una modalità di scalabilità, fai clic su Allocazione manuale.
Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instances update per aggiornare l'istanza.

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

  gcloud spanner instances update INSTANCE_ID \
  --processing-units=PROCESSING_UNIT_COUNT

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Sostituisci quanto segue:

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. Inserisci quantità fino a 1000 in multipli di 100 (100, 200, 300 e così via) e quantità maggiori in multipli di 1000 (1000, 2000, 3000 e così via).

Etichetta un'istanza

Le etichette consentono di organizzare le risorse.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Seleziona la casella di controllo per l'istanza. Il riquadro Informazioni viene visualizzato sul lato destro della pagina.
Fai clic sulla scheda Etichette nel riquadro Informazioni. Puoi quindi aggiungere, eliminare o aggiornare le etichette per l'istanza Spanner.

Modifica il tipo di pianificazione dei backup predefiniti

Le pianificazioni di backup predefinite vengono attivate automaticamente per tutte le nuove istanze. Puoi attivare o disattivare le pianificazioni dei backup predefiniti in un'istanza durante la creazione dell'istanza o modificandola in un secondo momento. Per saperne di più, consulta Pianificazioni di backup predefinite.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze

Fai clic sul nome dell'istanza per cui vuoi modificare la pianificazione dei backup predefinita.
Fai clic su Modifica istanza.
In Backup, la casella di controllo Abilita le pianificazioni dei backup predefiniti determina se le pianificazioni dei backup predefiniti sono abilitate o meno. Se abilitata, per tutti i nuovi database in questa istanza viene creata una pianificazione del backup predefinita.
Fai clic su Salva.

gcloud

Utilizza il comando gcloud spanner instances update per modificare il tipo di pianificazione di backup predefinita.

Puoi modificare il tipo di pianificazione del backup predefinito eseguendo questo comando:

  gcloud spanner instances update INSTANCE_ID \
    --default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE

Sostituisci quanto segue:

INSTANCE_ID: l'identificatore permanente dell'istanza.
DEFAULT_BACKUP_SCHEDULE_TYPE: il tipo di pianificazione di backup predefinito utilizzato nell'istanza. Deve essere uno dei seguenti valori:
- AUTOMATIC: viene creata automaticamente una pianificazione di backup predefinita quando viene creato un nuovo database nell'istanza. La pianificazione del backup predefinita crea un backup completo ogni 24 ore. Questi backup completi vengono conservati per 7 giorni. Puoi modificare o eliminare la pianificazione del backup predefinita una volta creata.
- NONE: non viene creata automaticamente una pianificazione di backup predefinita quando viene creato un nuovo database nell'istanza.

C#

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;
using System;
using System.Threading.Tasks;

public class UpdateInstanceDefaultBackupScheduleTypeAsyncSample
{
    public async Task<Instance> UpdateInstanceDefaultBackupScheduleTypeAsync(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = await InstanceAdminClient.CreateAsync();

        // Initialize request parameters.
        Instance instance = new Instance
        {
            InstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
            DefaultBackupScheduleType = Instance.Types.DefaultBackupScheduleType.Automatic,
        };
        FieldMask mask = new FieldMask 
        {
            Paths = { "default_backup_schedule_type" }
        };

        // Make the CreateInstance request.
        Operation<Instance, UpdateInstanceMetadata> response =
            await instanceAdminClient.UpdateInstanceAsync(instance, mask);

        Console.WriteLine("Waiting for the operation to finish.");

        // Poll until the returned long-running operation is complete.
        Operation<Instance, UpdateInstanceMetadata> completedResponse =
            await response.PollUntilCompletedAsync();

        if (completedResponse.IsFaulted)
        {
            Console.WriteLine($"Error while updating instance: {completedResponse.Exception}");
            throw completedResponse.Exception;
        }

        Console.WriteLine($"Instance updated successfully.");
        return completedResponse.Result;
    }
}

Vai

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"google.golang.org/genproto/protobuf/field_mask"
)

// updateInstanceDefaultBackupScheduleType updates instance default backup schedule type to AUTOMATIC.
// This means a default backup schedule will be created automatically on creation of a database within the instance.
func updateInstanceDefaultBackupScheduleType(w io.Writer, projectID, instanceID string) error {
	// projectID := "my-project-id"
	// instanceID := "my-instance"
	ctx := context.Background()
	instanceAdmin, err := instance.NewInstanceAdminClient(ctx)
	if err != nil {
		return err
	}
	defer instanceAdmin.Close()

	// Updates the default backup schedule type field of an instance.  The field mask is required to
	// indicate which field is being updated.
	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// Controls the default backup behavior for new databases within the instance.
			DefaultBackupScheduleType: instancepb.Instance_AUTOMATIC,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"default_backup_schedule_type"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

	fmt.Fprintf(w, "Updated instance [%s]\n", instanceID)
	return nil
}

Java

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceDefaultBackupScheduleTypeExample {

  static void updateInstanceDefaultBackupScheduleType() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    updateInstanceDefaultBackupScheduleType(projectId, instanceId);
  }

  static void updateInstanceDefaultBackupScheduleType(String projectId, String instanceId) {
    // Set Instance configuration.
    int nodeCount = 2;
    String displayName = "Updated name";

    // Update an Instance object that will be used to update the instance.
    Instance instance =
        Instance.newBuilder()
            .setName(InstanceName.of(projectId, instanceId).toString())
            .setDisplayName(displayName)
            .setNodeCount(nodeCount)
            .setDefaultBackupScheduleType(Instance.DefaultBackupScheduleType.AUTOMATIC)
            .setConfig(InstanceConfigName.of(projectId, "regional-us-east4").toString())
            .build();

    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {

      // Wait for the updatedInstance operation to finish.
      Instance updatedInstance =
          instanceAdminClient
              .updateInstanceAsync(
                  UpdateInstanceRequest.newBuilder()
                      .setFieldMask(
                          FieldMask.newBuilder()
                              .addAllPaths(Lists.newArrayList("default_backup_schedule_type")))
                      .setInstance(instance)
                      .build())
              .get();
      System.out.printf("Instance %s was successfully updated%n", updatedInstance.getName());
    } catch (ExecutionException e) {
      System.out.printf(
          "Error: Updating instance %s failed with error message %s%n",
          instance.getName(), e.getMessage());
    } catch (InterruptedException e) {
      System.out.println("Error: Waiting for updateInstance operation to finish was interrupted");
    }
  }
}

Node.js

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';

// Imports the Google Cloud client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});
const instanceAdminClient = await spanner.getInstanceAdminClient();

// Updates an instance
try {
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      defaultBackupScheduleType:
        protos.google.spanner.admin.instance.v1.Instance
          .DefaultBackupScheduleType.AUTOMATIC, // optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['default_backup_schedule_type'],
    }),
  });

  await operation.promise();
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.defaultBackupScheduleType}` +
      ' default backup schedule type.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

Per scoprire come installare e utilizzare la libreria client per Spanner, consulta Librerie client di Spanner.

Per eseguire l'autenticazione in Spanner, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

def update_instance_default_backup_schedule_type(instance_id):
    spanner_client = spanner.Client()

    name = "{}/instances/{}".format(spanner_client.project_name, instance_id)

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            default_backup_schedule_type=spanner_instance_admin.Instance.DefaultBackupScheduleType.AUTOMATIC,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["default_backup_schedule_type"]),
    )

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Updated instance {} to have default backup schedules".format(instance_id))

Sposta un'istanza

Per istruzioni su come spostare l'istanza da qualsiasi configurazione di istanza a qualsiasi altra configurazione di istanza, anche tra configurazioni regionali e multiregionali, consulta Sposta un'istanza.

Elimina un'istanza

Puoi eliminare un'istanza con la console Google Cloud o con gcloud CLI.

Se vuoi eliminare un'istanza che contiene uno o più database con la protezione da eliminazione abilitata, devi prima disabilitare la protezione da eliminazione su tutti i database dell'istanza prima di poterla eliminare.

Console

Vai alla pagina Istanze Spanner nella console Google Cloud .

Vai alla pagina Istanze
Fai clic sul nome dell'istanza che vuoi eliminare.
Fai clic su Elimina istanza.
Segui le istruzioni per confermare che vuoi eliminare l'istanza.
Fai clic su Elimina.

gcloud

Utilizza il comando gcloud spanner instances delete, sostituendo INSTANCE_ID con l'ID istanza:

gcloud spanner instances delete INSTANCE_ID

Arresta o riavvia un'istanza

Spanner è un servizio di database completamente gestito che supervisiona le proprie attività e risorse sottostanti, tra cui il monitoraggio e il riavvio dei processi, se necessario, senza tempi di inattività. Poiché non è necessario arrestare o riavviare manualmente un'istanza, Spanner non offre un modo per farlo.

Passaggi successivi

Scopri come inserire, aggiornare ed eliminare i dati con Data Manipulation Language (DML) o gcloud CLI.
Concedi i ruoli IAM (Identity and Access Management) per l'istanza e i relativi database.
Scopri come progettare uno schema Spanner.

Creazione e gestione delle istanze Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Crea un'istanza

Console

gcloud

Aggiungi scalabilità automatica gestita

Esempi di utilizzo delle configurazioni personalizzate

C++

C#

Crea un'istanza senza una pianificazione dei backup predefinita

Vai

Crea un'istanza con scalabilità automatica gestita utilizzando Go

Crea un'istanza con scalabilità automatica asimmetrica di sola lettura utilizzando Go

Crea un'istanza senza una pianificazione dei backup predefinita

Java

Crea un'istanza con scalabilità automatica gestita utilizzando Java

Crea un'istanza con scalabilità automatica asimmetrica di sola lettura utilizzando Java

Crea un'istanza senza una pianificazione dei backup predefinita

Node.js

Crea un'istanza con scalabilità automatica gestita utilizzando Node.js

Crea un'istanza senza una pianificazione dei backup predefinita

PHP

Python

Crea un'istanza con scalabilità automatica gestita utilizzando Python

Crea un'istanza senza una pianificazione dei backup predefinita

Ruby

Elenca istanze

Console

gcloud

Modifica un'istanza

Esegui l'upgrade della versione

Console

gcloud

Vai

Java

Node.js

Python

Esegui il downgrade della versione

Console

gcloud

Modifica il nome visualizzato

Console

gcloud

Modifica la capacità di calcolo

Console

gcloud

Attiva o modifica il gestore della scalabilità automatica gestito su un'istanza

Console

gcloud

Cambia un'istanza dall'utilizzo del gestore della scalabilità automatica gestito alla scalabilità manuale

Console

gcloud

Etichetta un'istanza

Console

Modifica il tipo di pianificazione dei backup predefiniti

Console

gcloud

C#

Vai

Java

Node.js

Python

Sposta un'istanza

Elimina un'istanza

Console

gcloud

Arresta o riavvia un'istanza

Passaggi successivi

Creazione e gestione delle istanze