Crie e faça a gestão de instâncias

Esta página descreve como criar, listar, editar e eliminar instâncias do Spanner.

Nota: para explorar o Spanner através de uma instância de avaliação gratuita de 90 dias, consulte o artigo Crie uma instância de avaliação gratuita do Spanner.

Crie uma instância

Pode criar uma instância com a Google Cloud consola, a Google Cloud CLI ou as bibliotecas de cliente. Também pode criar uma instância com uma configuração de instância personalizada adicionando réplicas só de leitura opcionais.

Nota: não precisa de aprovisionar armazenamento no Spanner e só lhe é faturado o armazenamento que usa. Saiba mais sobre os preços de armazenamento.

Consola

1. Na Google Cloud consola, aceda à página Instâncias do Spanner.

2. Clique em Criar instância.

   Aceda a Criar instância

3. Na secção Selecionar uma edição, selecione uma edição do Spanner.

   Se quiser comparar as especificações entre as diferentes edições, clique em Comparar edições. Para mais informações, consulte a Vista geral das edições do Spanner.

4. Clique em Continuar.

5. Na secção Atribua um nome à sua instância, introduza um Nome da instância a apresentar na consola Google Cloud . O nome da instância tem de ser exclusivo no seu Google Cloud projeto.

6. Introduza um ID de instância para identificar permanentemente a sua instância. O ID da instância também tem de ser exclusivo no seu Google Cloud projeto. Não pode alterar o ID da instância posteriormente.

7. Clique em Continuar.

8. Na secção Configure a sua instância, em Escolha uma configuração, selecione Regional, Duas regiões ou Várias regiões.

   Nota: as configurações de instâncias de várias regiões e de duas regiões só estão disponíveis na edição Enterprise Plus. Se quiser comparar as especificações entre as três configurações, clique em Comparar configurações de regiões.

9. Selecione uma localização de configuração no menu pendente.

10. Opcional: para adicionar uma réplica só de leitura a uma configuração base do Spanner, primeiro crie uma configuração de instância personalizada com a CLI do Google Cloud. A adição de réplicas opcionais só de leitura a uma configuração base está disponível na edição Enterprise e edição Enterprise Plus.

11. Clique em Continuar.

12. Na secção Atribuir capacidade de computação, em Selecionar unidade, clique numa das seguintes opções:

    • Nós para instâncias grandes. Um nó tem 1000 unidades de processamento.
    • Unidades de processamento para instâncias pequenas.

    Para mais informações, consulte o artigo Capacidade de computação, nós e unidades de processamento.

13. Em Escolha um modo de dimensionamento, clique numa das seguintes opções:

    • Atribuição manual se quiser definir manualmente a capacidade de computação para recursos e custos de computação fixos.

      • Quantidade indica o número de unidades de processamento ou nós a usar para esta instância.

    • Dimensionamento automático para permitir que o Spanner adicione e remova automaticamente capacidade de computação. O escalador automático gerido está disponível na edição Enterprise e Enterprise Plus do Spanner. Para mais informações sobre o escalador automático gerido, consulte o artigo Escalador automático gerido para o Spanner. Configure as seguintes opções do escalador automático gerido:

      • Mínimo indica o limite mínimo para reduzir a escala, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite mínimo.
      • Máximo indica o limite máximo de expansão, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite máximo.
      • O alvo de utilização da CPU de alta prioridade indica a percentagem de CPU de alta prioridade a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.
      • O objetivo de utilização do armazenamento indica a percentagem de armazenamento a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização do armazenamento.

14. Opcional: se selecionar Dimensionamento automático como modo de dimensionamento, pode clicar no menu pendente Mostrar opções de dimensionamento automático assimétrico para dimensionar automaticamente as réplicas só de leitura independentemente de outras réplicas. Para mais informações, consulte o artigo Dimensionamento automático assimétrico só de leitura.

    1. Selecione a réplica só de leitura que quer dimensionar automaticamente de forma assimétrica.

    2. Configure as seguintes opções de escalamento automático assimétrico:

       • Mínimo indica o limite mínimo para reduzir a escala, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite mínimo.
       • Máximo indica o limite máximo de expansão, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite máximo.
       • O alvo de utilização da CPU de alta prioridade indica a percentagem de CPU de alta prioridade a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.

15. Em Cópias de segurança, a caixa de verificação Ativar agendamentos de cópias de segurança predefinidos está selecionada por predefinição. Para desativar as predefinições de agendamentos de cópias de segurança, desmarque a caixa de verificação. Quando ativada, todas as novas bases de dados na instância têm cópias de segurança completas criadas a cada 24 horas. Estas cópias de segurança são retidas durante 7 dias. Pode editar ou eliminar as programações de cópias de segurança predefinidas em qualquer altura. Para mais informações, consulte Programações de cópias de segurança predefinidas.

16. Clique em Criar para criar a instância.

gcloud

Use o comando gcloud spanner instances create para criar uma instância. Especifique a capacidade de computação como o número de nós ou unidades de processamento que quer na instância.

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

ou

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

Substitua o seguinte:

• INSTANCE-ID: um identificador permanente exclusivo no seu projeto Google Cloud . Não pode alterar o ID da instância posteriormente.
• INSTANCE-CONFIG: um identificador permanente da configuração da sua instância, que define a localização geográfica da instância e afeta a forma como os dados são replicados. Para configurações de instâncias personalizadas, começa com custom-. Para mais informações, consulte as configurações de instâncias.
• INSTANCE_DESCRIPTION: o nome a apresentar para a instância na consola Google Cloud . O nome da instância tem de ser exclusivo no seuGoogle Cloud projeto.

• DEFAULT_BACKUP_SCHEDULE_TYPE: o tipo de agendamento de cópias de segurança predefinido usado na instância. Tem de ser um dos seguintes valores:

  • AUTOMATIC: é criada automaticamente uma agenda de cópias de segurança predefinida quando é criada uma nova base de dados na instância. A agenda de cópias de segurança predefinida cria uma cópia de segurança completa a cada 24 horas. Estas cópias de segurança completas são retidas durante 7 dias. Pode editar ou eliminar a agenda de cópias de segurança predefinida assim que for criada.
  • NONE: não é criada automaticamente uma programação de cópias de segurança predefinida quando é criada uma nova base de dados na instância.

• NODE-COUNT: a capacidade de computação da instância, expressa como um número de nós. Cada nó é igual a 1000 unidades de processamento.

• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Introduza quantidades até 1000 em múltiplos de 100 (100, 200, 300 e assim sucessivamente) e introduza quantidades superiores em múltiplos de 1000 (1000, 2000, 3000 e assim sucessivamente). Nota: Não use este parâmetro se estiver a criar uma instância que pretenda ativar com o escalador automático gerido mais tarde.

Adicione o dimensionamento automático gerido

Também pode criar instâncias da edição Enterprise e da edição Enterprise Plus para usar o dimensionamento automático gerido com o comando gcloud spanner instances create. Para mais informações, consulte o artigo Autoscaler gerido para o Spanner.

Use o seguinte comando para criar uma instância com o escalador automático gerido.

  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=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

ou

  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=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

Substitua o seguinte:

• INSTANCE-ID: um identificador permanente exclusivo no seu projeto Google Cloud . Não pode alterar o ID da instância posteriormente.
• INSTANCE-CONFIG: um identificador permanente da configuração da sua instância, que define a localização geográfica da instância e afeta a forma como os dados são replicados. Para configurações de instâncias personalizadas, começa com custom-. Para mais informações, consulte as configurações de instâncias.
• INSTANCE-DESCRIPTION: o nome a apresentar para a instância na consola Google Cloud . O nome da instância tem de ser exclusivo no seuGoogle Cloud projeto.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: o número mínimo de unidades de processamento ou nós quando reduz a escala. Para mais informações, consulte o artigo Determine o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o número máximo de unidades de processamento ou nós ao aumentar a escala. Para mais informações, consulte Determine o limite máximo.
• CPU_PERCENTAGE: a percentagem alvo de CPU de alta prioridade a usar, de 10 a 90%. Se estiver a otimizar em função do custo, use uma percentagem mais elevada. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.
• STORAGE_PERCENTAGE: a percentagem alvo de armazenamento a usar, entre 10 e 99%. Para mais informações, consulte o artigo Determine o objetivo de utilização do armazenamento.

Sinalizadores opcionais:

• --asymmetric-autoscaling-option: use esta flag para ativar o dimensionamento automático assimétrico. Substitua os seguintes parâmetros:

  • ASYMMETRIC_AUTOSCALING_LOCATION: se a flag for usada, este parâmetro é obrigatório. A localização da região só de leitura que quer redimensionar de forma assimétrica.
  • ASYMMETRIC_AUTOSCALING_MIN: parâmetro opcional. O número mínimo de nós quando reduz a escala.
  • ASYMMETRIC_AUTOSCALING_MAX: parâmetro opcional. O número máximo de nós ao aumentar a escala.
  • ASYMMETRIC_CPU_TARGET: parâmetro opcional. A percentagem alvo de CPU de prioridade elevada a usar, de 10 a 90%. Se estiver a fazer a otimização em função do custo, use uma percentagem mais elevada.

Exemplos de utilização de configurações personalizadas

Para criar uma instância test-instance na configuração da instância regional base us-central1, execute:

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

Para criar uma instância custom-eur6-instance na configuração de instância personalizada de várias regiões custom-eur6, primeiro crie uma configuração de instância personalizada.

Em seguida, execute:

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

Deve ver uma mensagem semelhante ao seguinte exemplo depois de executar qualquer um dos comandos anteriores:

Creating instance...done.

C++

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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#

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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;
    }
}

Crie uma instância sem um horário de cópia de segurança predefinido

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;
    }
}

Go

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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
}

Crie uma instância com o dimensionamento automático gerido através do 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
}

Crie uma instância com o escalamento automático só de leitura assimétrico através do 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
}

Crie uma instância sem um horário de cópia de segurança predefinido

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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");
    }
  }
}

Crie uma instância com o dimensionamento automático gerido através do 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");
      }
    }
  }
}

Crie uma instância com o ajuste de escala automático assimétrico só de leitura através do 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");
      }
    }
  }
}

Crie uma instância sem um horário de cópia de segurança predefinido

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

// 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);
}

Nota: os exemplos de código da interface da biblioteca cliente antiga para Node.js estão arquivados no GitHub.

Crie uma instância com o dimensionamento automático gerido através do Node.js

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

// 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);
}

Crie uma instância sem um horário de cópia de segurança predefinido

/**
 * 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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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);
}

Nota: os exemplos de código da interface da biblioteca cliente antiga para PHP estão arquivados no GitHub.

Python

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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))

Nota: os exemplos de código da interface da biblioteca cliente antiga para Python estão arquivados no GitHub.

Crie uma instância com o dimensionamento automático gerido através do Python

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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
        )
    )

Crie uma instância sem um horário de cópia de segurança predefinido

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

# 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

Apresentar instâncias

Pode mostrar uma lista das suas instâncias do Spanner.

Consola

Aceda à página Instâncias do Spanner na Google Cloud consola.

Aceda à página Instâncias

A Google Cloud consola mostra uma lista das suas instâncias do Spanner, juntamente com o ID, o nome a apresentar, a configuração e a capacidade de computação de cada instância, expressa em unidades de processamento e em nós.

gcloud

Use o comando gcloud spanner instances list:

gcloud spanner instances list

A CLI gcloud imprime uma lista das suas instâncias do Spanner, juntamente com o ID, o nome a apresentar, a configuração e a capacidade de computação de cada instância.

Edite uma instância

As secções seguintes explicam como atualizar a edição da sua instância e alterar o nome a apresentar, a capacidade de computação e o tipo de agendamento de cópias de segurança predefinido de uma instância. Não pode alterar o ID da instância nem a configuração da instância (no entanto, pode mover a instância).

Atualize a edição

Pode atualizar as suas instâncias da edição Standard para uma edição de nível superior. As instâncias da edição Standard podem ser atualizadas para a edição Enterprise ou Enterprise Plus. As instâncias da edição Enterprise podem ser atualizadas para a edição Enterprise Plus. A atualização da edição demora aproximadamente 10 minutos a concluir sem tempo de inatividade.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância que quer atualizar.

3. Clique em Atualizar junto ao tipo de edição.

4. Na página Instância de edição e em Atualizar edição, selecione a nova edição de nível superior para a sua instância.

5. Clique em Guardar.

gcloud

Use o comando gcloud spanner instances update para atualizar a edição da sua instância:

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

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• EDITION: especifique a nova edição de nível superior para a sua instância. Para mais informações, consulte a Vista geral das edições do Spanner.

Sinalizadores opcionais:

• --async: Use esta flag se quiser que o seu pedido seja devolvido imediatamente, sem aguardar a conclusão da operação em curso. Pode verificar o estado do seu pedido executando o comando gcloud spanner operations describe.

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"
)

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

// 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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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))

Altere a edição para uma versão inferior

Pode alterar as suas instâncias do Spanner para uma edição de nível inferior. Tem de parar de usar as funcionalidades da edição de nível superior para fazer a mudança para um nível inferior. As instâncias da edição Enterprise podem ser alteradas para a edição Standard. As instâncias da edição Enterprise Plus podem ser revertidas para a edição Enterprise ou Standard. A despromoção da edição demora aproximadamente 10 minutos a concluir e não tem tempo de inatividade.

gcloud

Use o comando gcloud spanner instances update para mudar a edição da sua instância para uma edição inferior:

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• EDITION: especifique a nova edição de nível inferior para a sua instância. Para mais informações, consulte a Vista geral das edições do Spanner.

Altere o nome a apresentar

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância à qual quer mudar o nome.

3. Clique em Editar instância.

4. Introduza um novo nome da instância. Este nome tem de ser exclusivo no projetoGoogle Cloud .

5. Clique em Guardar.

gcloud

Use o comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• INSTANCE_NAME: o nome a apresentar para a instância na Google Cloud consola. O nome da instância tem de ser exclusivo no seuGoogle Cloud projeto.

Altere a capacidade de computação

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

Pode reduzir a capacidade de computação de uma instância do Spanner, exceto nos seguintes cenários:

• Não pode armazenar mais de 10 TiB de dados por nó (1000 unidades de processamento).

• Existem um grande número de divisões para os dados da sua instância. Neste cenário, o Spanner pode não conseguir gerir as divisões depois de reduzir a capacidade de computação. Pode tentar reduzir a capacidade de computação em quantidades progressivamente menores até encontrar a capacidade mínima de que o Spanner precisa para gerir todas as divisões da instância.

  O Spanner pode criar um grande número de divisões para se adaptar aos seus padrões de utilização. Se os seus padrões de utilização mudarem, após uma ou duas semanas, o Spanner pode unir algumas divisões e pode tentar reduzir a capacidade de computação da instância.

Quando remover capacidade de computação, monitorize a utilização da CPU e as latências de pedidos no Cloud Monitoring para garantir que a utilização da CPU permanece abaixo de 65% para instâncias regionais e 45% para cada região em instâncias multirregionais. Pode ocorrer um aumento temporário nas latências de pedidos durante a remoção da capacidade de computação.

Se quiser aumentar a capacidade de computação de uma instância, o seu projeto tem de ter quota suficiente para adicionar a capacidade de computação.Google Cloud O tempo que o pedido de aumento demora a ser concluído depende da dimensão do pedido. Na maioria dos casos, os pedidos são concluídos em poucos minutos. Em raras ocasiões, o aumento da escala pode demorar até uma hora a ser concluído.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância que quer alterar.

3. Clique em Editar instância.

4. Altere a capacidade de computação escolhendo as unidades de medida (unidades de processamento ou nós) e, em seguida, introduzindo uma quantidade. Quando usar unidades de processamento, introduza quantidades até 1000 em múltiplos de 100 (100, 200, 300 e assim sucessivamente) e introduza quantidades superiores em múltiplos de 1000 (1000, 2000, 3000 e assim sucessivamente). Cada nó é igual a 1000 unidades de processamento.

5. Clique em Guardar.

Se vir uma caixa de diálogo a indicar que tem uma quota insuficiente para adicionar capacidade de computação nesta localização, siga as instruções para pedir uma quota mais elevada.

gcloud

Use o comando gcloud spanner instances update. Quando usar este comando, especifique a capacidade de computação como um número de nós ou unidades de processamento.

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

ou

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

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• NODE_COUNT: a capacidade de computação da instância, expressa como um número de nós. Cada nó é igual a 1000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Introduza quantidades até 1000 em múltiplos de 100 (100, 200, 300 e assim sucessivamente) e introduza quantidades superiores em múltiplos de 1000 (1000, 2000, 3000 e assim sucessivamente).

Sinalizadores opcionais:

• --async: Use esta flag se quiser que o seu pedido seja devolvido imediatamente, sem aguardar a conclusão da operação em curso. Pode verificar o estado do seu pedido executando o comando gcloud spanner operations describe.

Ative ou modifique o escalador automático gerido numa instância

Pode ativar ou modificar o dimensionamento automático numa instância do Spanner através da Google Cloud consola, da CLI gcloud ou das bibliotecas de cliente do Spanner. Aplicam-se as seguintes limitações quando adiciona ou altera a funcionalidade de escalamento automático gerido numa instância existente:

• O escalador automático gerido só está disponível na edição Enterprise ou Enterprise Plus.
• Não pode ativar o escalador automático gerido numa instância que está a mover.

• Não pode mover uma instância enquanto o escalador automático gerido estiver ativado.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância na qual quer ativar o escalador automático gerido.

3. Clique em Editar instância.

4. Em Configurar capacidade de computação, clique em Escala automática.

5. Para Mínimo, selecione o limite mínimo a usar quando reduzir a escala. Para mais informações, consulte o artigo Determine o limite mínimo.

6. Para Máximo, selecione o limite máximo a usar quando aumentar a escala. Para mais informações, consulte o artigo Determine o limite máximo.

7. Para o alvo de utilização da CPU de alta prioridade, selecione a percentagem de CPU de alta prioridade a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.

8. Para Objetivo de utilização do armazenamento, selecione a percentagem de armazenamento a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização do armazenamento.

9. Opcional: se selecionar Dimensionamento automático como modo de dimensionamento, pode clicar no menu pendente Mostrar opções de dimensionamento automático assimétrico para dimensionar automaticamente as réplicas só de leitura independentemente de outras réplicas.

   1. Selecione a réplica só de leitura que quer dimensionar automaticamente de forma assimétrica.

   2. Configure as seguintes opções do redimensionador automático:

      • Mínimo indica o limite mínimo para reduzir a escala, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite mínimo.
      • Máximo indica o limite máximo de expansão, dependendo da unidade de medida que escolher para a capacidade de computação. Para mais informações, consulte o artigo Determine o limite máximo.
      • O alvo de utilização da CPU de alta prioridade indica a percentagem de CPU de alta prioridade a usar. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.

10. Clique em Guardar.

gcloud

Use o comando gcloud spanner instances update para adicionar o escalador automático gerido a uma instância. Para mais informações e limitações, consulte as Google Cloud CLI flags e as limitações.

Pode adicionar o escalador automático gerido com o seguinte 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=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

ou

  gcloud spanner instances update INSTANCE_ID \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: o número mínimo de unidades de processamento ou nós a usar quando reduz a escala. Para mais informações, consulte o artigo Determine o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o número máximo de unidades de processamento ou nós a usar ao aumentar a escala. Para mais informações, consulte o artigo Determine o limite máximo.
• CPU_PERCENTAGE: a percentagem alvo de CPU de alta prioridade a usar, de 10% a 90%. Se estiver a otimizar em função do custo e não precisar de uma latência baixa em todos os pedidos, use uma percentagem mais elevada. Para mais informações, consulte o artigo Determine o objetivo de utilização da CPU.
• STORAGE_PERCENTAGE: a percentagem de armazenamento a usar, entre 10% e 99%. Para mais informações, consulte o artigo Determine o objetivo de utilização do armazenamento.

Sinalizadores opcionais:

• --asymmetric-autoscaling-option: use esta flag para ativar o dimensionamento automático assimétrico. Substitua os seguintes parâmetros:

  • ASYMMETRIC_AUTOSCALING_LOCATION: se a flag for usada, este parâmetro é obrigatório. A localização da região só de leitura que quer redimensionar de forma assimétrica.
  • ASYMMETRIC_AUTOSCALING_MIN: parâmetro opcional. O número mínimo de nós quando reduz a escala.
  • ASYMMETRIC_AUTOSCALING_MAX: parâmetro opcional. O número máximo de nós ao aumentar a escala.
  • ASYMMETRIC_CPU_TARGET: parâmetro opcional. A percentagem alvo de CPU de prioridade elevada a usar, de 10 a 90%. Se estiver a fazer a otimização em função do custo, use uma percentagem mais elevada.

Depois de adicionar o escalador automático gerido a uma instância, também pode modificar as definições do escalador automático gerido. Por exemplo, se quiser aumentar o número máximo de unidades de processamento para 10 000, execute o seguinte comando:

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

Altere uma instância da utilização do escalamento automático gerido para o escalamento manual

Pode alterar se uma instância do Spanner usa o escalamento manual ou gerido através da Google Cloud consola, da CLI gcloud ou das bibliotecas de cliente do Spanner.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância na qual quer desativar o escalador automático gerido.

3. Em Escolha um modo de escalabilidade, clique em Atribuição manual.

4. Clique em Guardar.

gcloud

Use o comando gcloud spanner instances update para atualizar a instância.

Use o seguinte comando para alterar uma instância de modo a usar o escalamento automático gerido para o escalamento manual:

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

ou

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.
• NODE_COUNT: a capacidade de computação da instância, expressa como um número de nós. Cada nó é igual a 1000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Introduza quantidades até 1000 em múltiplos de 100 (100, 200, 300 e assim sucessivamente) e introduza quantidades superiores em múltiplos de 1000 (1000, 2000, 3000 e assim sucessivamente).

Etiquete uma instância

As etiquetas ajudam a organizar os recursos.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Selecione a caixa de verificação da instância. O painel de informações aparece no lado direito da página.

3. Clique no separador Etiquetas no painel de informações. Em seguida, pode adicionar, eliminar ou atualizar etiquetas para a instância do Spanner.

Edite o tipo de agendamento de cópia de segurança predefinido

As programações de cópias de segurança predefinidas são ativadas automaticamente para todas as novas instâncias. Pode ativar ou desativar as programações de cópias de segurança predefinidas numa instância quando cria a instância ou editando-a mais tarde. Para mais informações, consulte o artigo Programações de cópias de segurança predefinidas.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância para editar a programação de cópias de segurança predefinida.

3. Clique em Editar instância.

4. Em Cópias de segurança, a caixa de verificação Ativar agendamentos de cópias de segurança predefinidos determina se os agendamentos de cópias de segurança predefinidos estão ativados ou não. Quando ativada, todas as novas bases de dados nesta instância têm um agendamento de cópias de segurança predefinido criado.

5. Clique em Guardar.

gcloud

Use o comando gcloud spanner instances update para editar o tipo de agendamentos de cópias de segurança predefinidos.

Pode editar o tipo de agendamento de cópia de segurança predefinido executando o seguinte comando:

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

Substitua o seguinte:

• INSTANCE_ID: o identificador permanente da instância.

• DEFAULT_BACKUP_SCHEDULE_TYPE: o tipo de agendamento de cópias de segurança predefinido usado na instância. Tem de ser um dos seguintes valores:

  • AUTOMATIC: é criada automaticamente uma agenda de cópias de segurança predefinida quando é criada uma nova base de dados na instância. A agenda de cópias de segurança predefinida cria uma cópia de segurança completa a cada 24 horas. Estas cópias de segurança completas são retidas durante 7 dias. Pode editar ou eliminar a agenda de cópias de segurança predefinida assim que for criada.
  • NONE: não é criada automaticamente uma programação de cópias de segurança predefinida quando é criada uma nova base de dados na instância.

C#

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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;
    }
}

Go

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

/**
 * 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

Para saber como instalar e usar a biblioteca cliente do Spanner, consulte o artigo Bibliotecas cliente do Spanner.

Para se autenticar no Spanner, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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))

Mova uma instância

Nota: não pode mover uma instância que tenha o escalador automático gerido ativado.

Para ver instruções sobre como mover a sua instância de qualquer configuração de instância para qualquer outra configuração de instância, incluindo entre configurações regionais e de várias regiões, consulte o artigo Mova uma instância.

Elimine uma instância

Aviso: a eliminação de uma instância remove permanentemente a instância e todas as respetivas bases de dados. Não é possível anular esta ação posteriormente. Além disso, não pode criar outra instância de avaliação gratuita depois de eliminar a primeira. Pode criar uma instância de avaliação gratuita por ciclo de vida do projeto.

Pode eliminar uma instância com a Google Cloud consola ou a CLI Google Cloud.

Se quiser eliminar uma instância que tenha uma ou mais bases de dados com a proteção contra eliminação ativada, tem de desativar a proteção contra eliminação em todas as bases de dados nessa instância antes de poder eliminar a instância.

Consola

1. Aceda à página Instâncias do Spanner na Google Cloud consola.

   Aceda à página Instâncias

2. Clique no nome da instância que quer eliminar.

3. Clique em Eliminar instância.

4. Siga as instruções para confirmar que quer eliminar a instância.

5. Clique em Eliminar.

gcloud

Use o comando gcloud spanner instances delete substituindo INSTANCE_ID pelo ID da instância:

gcloud spanner instances delete INSTANCE_ID

Pare ou reinicie uma instância

O Spanner é um serviço de base de dados totalmente gerido que supervisiona as suas próprias tarefas e recursos subjacentes, incluindo a monitorização e o reinício de processos quando necessário, sem inatividade. Como não é necessário parar nem reiniciar manualmente uma determinada instância, o Spanner não oferece uma forma de o fazer.

O que se segue?

• Saiba como inserir, atualizar e eliminar dados com a linguagem de manipulação de dados (DML) ou a CLI gcloud.
• Conceda funções de gestão de identidade e de acesso para a instância e as respetivas bases de dados.
• Compreenda como conceber um esquema do Spanner.