Criar e gerenciar instâncias

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

Observação: para conhecer o Spanner usando uma instância de teste gratuito de 90 dias, consulte Criar uma instância de teste gratuito do Spanner.

Criar uma instância

É possível criar uma instância com o console Google Cloud , a Google Cloud CLI ou as bibliotecas de cliente. Também é possível criar uma instância com uma configuração de instância personalizada adicionando réplicas somente leitura opcionais.

Observação: não é necessário provisionar o armazenamento no Spanner. Você só vai pagar pelo que usar. Saiba mais sobre os preços de armazenamento.

Console

1. No console do Google Cloud , acesse a página Instâncias do Spanner.

2. Clique em Criar instância.

   Acessar "Criar instância"

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

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

4. Clique em Continuar.

5. Na seção Nome da instância, insira um Nome da instância para exibir no console Google Cloud . O nome da instância precisa ser exclusivo no projeto do Google Cloud .

6. Insira um ID da instância para identificar a instância permanentemente. O ID da instância também precisa ser exclusivo no projeto do Google Cloud . Não será possível alterá-lo depois.

7. Clique em Continuar.

8. Na seção Configurar sua instância, em Escolher uma configuração, selecione Regional, Birregional ou Multirregional.

   Observação: as configurações de instâncias de região dupla e multirregional estão disponíveis apenas na edição Enterprise Plus. Se você quiser comparar as especificações entre as três configurações, clique em Comparar configurações de região.

9. Selecione um local de configuração no menu suspenso.

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

11. Clique em Continuar.

12. Na seção Alocar capacidade de computação, em Selecionar unidade, clique em uma das seguintes opções:

    • Unidades de processamento para instâncias pequenas.
    • Nós para instâncias grandes. Um nó é igual a 1.000 unidades de processamento.

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

13. Em Escolher um modo de escalonamento, clique em uma das seguintes opções:

    • Alocação manual, se você quiser definir manualmente a capacidade de computação para custos e recursos fixos de computação.

      • Quantity indica o número de unidades de processamento ou nós a serem usados para essa instância.

    • Escalonamento automático (pré-lançamento), para que o Spanner adicione e remova automaticamente a capacidade de computação. O autoscaler gerenciado está disponível nas edições Spanner Enterprise e Enterprise Plus. Para mais informações sobre o escalonador automático gerenciado, consulte Escalonador automático gerenciado para Spanner. Configure as seguintes opções do autoescalador gerenciado:

      • Mínimo indica o limite mínimo para reduzir escala vertical, dependendo da unidade de medida escolhida para a capacidade de computação. Para mais informações, consulte Determinar o limite mínimo.
      • Máximo indica o limite máximo de escalonamento, dependendo da unidade de medida escolhida para a capacidade de computação. Para mais informações, consulte Determinar o limite máximo.
      • A meta de utilização de CPU de alta prioridade indica a porcentagem de CPU de alta prioridade a ser usada. Para mais informações, consulte Determinar a meta de utilização da CPU.
      • A meta de uso do armazenamento indica a porcentagem de armazenamento a ser usada. Para mais informações, consulte Determinar o objetivo de uso do armazenamento.

14. Em Backups, a caixa de seleção Ativar programações de backup padrão está marcada por padrão. Para desativar as programações de backup padrão, desmarque a caixa de seleção. Quando ativado, todos os novos bancos de dados na instância têm backups completos criados a cada 24 horas. Esses backups são retidos por sete dias. É possível editar ou excluir as programações de backup padrão a qualquer momento. Para mais informações, consulte Programações de backup padrão.

15. 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 você 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:

• INSTANCE-ID: um identificador permanente exclusivo no seu projeto do Google Cloud . Não será possível alterá-lo depois.
• INSTANCE-CONFIG: um identificador permanente da configuração da instância, que define a localização geográfica dela e afeta a maneira como os dados são replicados. Para configurações de instâncias personalizadas, ele começa com custom-. Para mais informações, consulte Configurações de instâncias.
• INSTANCE_DESCRIPTION: o nome a ser exibido para a instância no console do Google Cloud . O nome da instância precisa ser exclusivo no projeto do Google Cloud .

• DEFAULT_BACKUP_SCHEDULE_TYPE: o tipo de programação de backup padrão usado na instância. Precisa ser um dos valores abaixo.

  • AUTOMATIC: uma programação de backup padrão é criada automaticamente quando um novo banco de dados é criado na instância. A programação de backup padrão cria um backup completo a cada 24 horas. Esses backups completos são retidos por 7 dias. É possível editar ou excluir a programação de backup padrão depois que ela for criada.
  • NONE: uma programação de backup padrão não é criada automaticamente quando um novo banco de dados é criado 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 1.000 unidades de processamento.

• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Insira quantidades até 1.000 em múltiplos de 100 (100, 200, 300 e assim por diante) e insira quantidades maiores em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante). Observação: não use esse parâmetro se você estiver criando uma instância que pretende ativar com o escalonador automático gerenciado mais tarde.

Adicionar o escalonamento automático gerenciado (pré-lançamento)

Também é possível criar instâncias da edição Enterprise e da edição Enterprise Plus para usar o escalonamento automático gerenciado com o comando gcloud beta spanner instances create. Para mais informações, consulte Escalonador automático gerenciado para o Spanner.

Use o comando a seguir para criar uma instância com um escalonador automático gerenciado.

  gcloud beta 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

ou

  gcloud beta 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

Substitua:

• INSTANCE-ID: um identificador permanente exclusivo no seu projeto do Google Cloud . Não será possível alterá-lo depois.
• INSTANCE-CONFIG: um identificador permanente da configuração da instância, que define a localização geográfica dela e afeta a maneira como os dados são replicados. Para configurações de instâncias personalizadas, ele começa com custom-. Para mais informações, consulte Configurações de instâncias.
• INSTANCE-DESCRIPTION: o nome a ser exibido para a instância no console do Google Cloud . O nome da instância precisa ser exclusivo no projeto do Google Cloud .
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: o número mínimo de unidades de processamento ou nós ao reduzir a escala. Para mais informações, consulte Determinar o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o número máximo de unidades de processamento ou nós ao dimensionar. Para mais informações, consulte Determinar o limite máximo.
• CPU_PERCENTAGE: a porcentagem de destino da CPU de alta prioridade a ser usada, de 10 a 90%. Se você estiver otimizando para custo, use uma porcentagem maior. Para mais informações, consulte Determinar a meta de utilização da CPU.
• STORAGE_PERCENTAGE: a porcentagem de armazenamento a ser usada, de 10 a 99%. Para mais informações, consulte Determinar o objetivo de uso do armazenamento.

Exemplos de uso de configurações personalizadas

Para criar uma instância test-instance na configuração de 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 multirregional personalizada custom-eur6, primeiro crie uma configuração de instância personalizada.

Depois, execute:

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

Uma mensagem semelhante ao exemplo a seguir será exibida depois de executar um dos comandos anteriores:

Creating instance...done.

C++

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

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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;
    }
}

Criar uma instância sem uma programação de backup padrão

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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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
}

Criar uma instância com escalonamento automático gerenciado usando o Go (pré-lançamento)

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
}

Criar uma instância sem uma programação de backup padrão

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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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");
    }
  }
}

Observação:os exemplos de código de interface de biblioteca de cliente antigos para Java estão arquivados no GitHub.

Criar uma instância com escalonamento automático gerenciado usando Java (pré-lançamento)

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 java.util.concurrent.ExecutionException;

class CreateInstanceWithAutoscalingConfigExample {

  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 = "regional-us-east4";
      String displayName = "Descriptive name";

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .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("Autoscaler 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");
      }
    }
  }
}

Criar uma instância sem uma programação de backup padrão

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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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);
}

Observação:os exemplos de código de interface de biblioteca de cliente antigos para Node.js estão arquivados no GitHub.

Criar uma instância sem uma programação de backup padrão

/**
 * 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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);
}

Observação:os exemplos de código de interface de biblioteca de cliente antigos para PHP estão arquivados no GitHub.

Python

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

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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))

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

Criar uma instância sem uma programação de backup padrão

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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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

Listar instâncias

Você pode mostrar uma lista das suas instâncias do Spanner.

Console

Acesse a página Instâncias do Spanner no console do Google Cloud .

Acessar a página "Instâncias"

O console do Google Cloud mostra uma lista das suas instâncias do Spanner, incluindo o ID, o nome de exibição, a configuração e a capacidade de computação de cada instância, expressas nas unidades de processamento e nos nós.

gcloud

Use o comando gcloud spanner instances list:

gcloud spanner instances list

A CLI gcloud mostra uma lista das suas instâncias do Spanner, incluindo o ID, o nome de exibição, a configuração e a capacidade de computação de cada instância.

Editar uma instância

As seções a seguir explicam como fazer upgrade da edição da instância e mudar o nome de exibição, a capacidade de computação e o tipo de programação de backup padrão de uma instância. Não é possível mudar o ID ou a configuração da instância. No entanto, é possível mover a instância.

Fazer upgrade da edição

É possível fazer upgrade das instâncias da edição Standard para uma edição de nível mais alto. 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.

O downgrade por conta própria não está disponível. Para fazer downgrade da edição da sua instância, registre um tíquete de suporte. Para mais informações, consulte as Perguntas frequentes sobre as edições do Spanner.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

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

3. Clique em Fazer upgrade ao lado do tipo de edição.

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

5. Clique em Salvar.

gcloud

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

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

Substitua:

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

Sinalizações opcionais:

• --async: use essa flag se quiser que a solicitação seja retornada imediatamente, sem aguardar a conclusão da operação em andamento. Para verificar o status da sua solicitação, execute 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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(OPERATION_TIMEOUT_SECONDS)

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

Mudar o nome de exibição

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Para renomear, clique no nome da instância.

3. Clique em Editar instância.

4. Insira um novo nome de instância. Esse nome precisa ser exclusivo no projeto do Google Cloud .

5. Clique em Salvar.

gcloud

Use o comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Substitua:

• INSTANCE_ID: o identificador permanente da instância.
• INSTANCE_NAME: o nome a ser exibido para a instância no console do Google Cloud . O nome da instância precisa ser exclusivo no projeto do Google Cloud .

Mudar a capacidade de computação

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

Há alguns casos em que não é possível reduzir a capacidade de computação de uma instância:

• A remoção da capacidade de computação exige que a instância armazene mais de 10 TB de dados por 1.000 unidades de processamento (1 nó).
• Com base nos padrões históricos de uso, o Spanner criou um grande número de divisões nos dados da instância, e, em alguns raros casos, o Spanner não consegue gerenciar as divisões depois da remoção dos nós.

No último caso, é possível tentar reduzir a capacidade de computação progressivamente em valores menores até encontrar a capacidade mínima que o Spanner precisa para gerenciar todas as divisões da instância. Se a instância não exigir mais tantas divisões devido a uma alteração nos padrões de uso, o Spanner poderá mesclar algumas divisões e permitir que você tente reduzir ainda mais a capacidade de computação da instância depois de uma ou duas semanas.

Ao remover a capacidade de computação, monitore a utilização da CPU e as latências de solicitação em Monitoramento do Cloud para garantir que a utilização da CPU permaneça abaixo de 65% para instâncias regionais e 45% para cada região em instâncias multirregionais. Pode haver um aumento temporário nas latências de solicitação ao remover a capacidade de computação.

Se você quiser aumentar a capacidade de computação de uma instância, seu projeto do Google Cloud precisa ter cota suficiente para adicionar a capacidade de computação. O tempo necessário para concluir a solicitação de aumento depende do tamanho dela. Na maioria dos casos, as solicitações são concluídas em alguns minutos. Em ocasiões raras, um escalonar verticalmente pode levar até uma hora para ser concluído.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Clique no nome da instância a ser modificada.

3. Clique em Editar instância.

4. Para alterar a capacidade de computação, escolha as unidades de medida (unidades de processamento ou nós) e insira uma quantidade. Ao usar unidades de processamento, insira quantidades até 1.000 em múltiplos de 100 (100, 200, 300 e assim por diante) e insira quantidades maiores em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante). Cada nó é igual a 1.000 unidades de processamento.

5. Clique em Salvar.

Se for exibida uma caixa de diálogo informando que sua cota é insuficiente para adicionar nós neste local, siga as instruções para solicitar uma cota maior.

gcloud

Use o comando gcloud spanner instances update. Ao usar esse 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:

• 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 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Insira quantidades até 1.000 em múltiplos de 100 (100, 200, 300 e assim por diante) e insira quantidades maiores em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante).

Sinalizações opcionais:

• --async: use essa flag se quiser que a solicitação seja retornada imediatamente, sem aguardar a conclusão da operação em andamento. Para verificar o status da solicitação, execute gcloud spanner operations describe.

Ativar ou modificar o escalonador automático gerenciado em uma instância

Visualização — Managed autoscaler

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

As limitações a seguir se aplicam quando você adiciona ou altera o recurso de escalonamento automático gerenciado em uma instância atual:

• O escalonador gerenciado está disponível apenas na edição Enterprise ou Enterprise Plus.
• Não é possível ativar o escalonador gerenciado em uma instância que está sendo movida.

• Não é possível mover uma instância enquanto o escalonador automático gerenciado está ativado.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Clique no nome da instância em que você quer ativar o escalonador gerenciado.

3. Clique em Editar instância.

4. Em Configurar capacidade de computação, clique em Escalonamento automático.

5. Em Mínimo, selecione o limite mínimo a ser usado na redução de escala. Para mais informações, consulte Determinar o limite mínimo.

6. Em Máximo, selecione o limite máximo a ser usado no escalonamento. Para mais informações, consulte Determinar o limite máximo.

7. Em Meta de utilização de CPU de alta prioridade, selecione a porcentagem de CPU de alta prioridade a ser usada. Para mais informações, consulte Determinar a meta de utilização da CPU.

8. Em Objetivo de uso do armazenamento, selecione a porcentagem de armazenamento a ser usada. Para mais informações, consulte Determinar o objetivo de uso do armazenamento.

9. Clique em Salvar.

gcloud

Use o comando gcloud beta spanner instances update para adicionar o escalonador automático gerenciado a uma instância. Para mais informações e limitações, consulte Flags e limitações do Google Cloud CLI.

É possível adicionar o escalonador automático gerenciado com o seguinte comando:

  gcloud beta 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

ou

  gcloud beta 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

Substitua:

• 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 serem usadas ao reduzir a escala. Para mais informações, consulte Determinar o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o número máximo de unidades de processamento ou nós a serem usadas ao aumentar a escala. Para mais informações, consulte Determinar o limite máximo.
• CPU_PERCENTAGE: a porcentagem de destino da CPU de alta prioridade a ser usada, de 10% a 90%. Se você estiver otimizando para custo e não precisar de baixa latência em todas as solicitações, use uma porcentagem maior. Para mais informações, consulte Determinar a meta de utilização da CPU.
• STORAGE_PERCENTAGE: a porcentagem de armazenamento a ser usada, de 10% a 99%. Para mais informações, consulte Determinar o objetivo de uso do armazenamento.

Depois de adicionar o escalonador automático gerenciado a uma instância, você também pode modificar as configurações dele. Por exemplo, se você quiser aumentar o número máximo de unidades de processamento para 10.000, execute o seguinte comando:

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

Mudar uma instância de um autoescalador gerenciado para o escalonamento manual

Visualização — Managed autoscaling

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Clique no nome da instância em que você quer desativar o escalonador gerenciado.

3. Em Escolher um modo de escalonamento, clique em Alocação manual.

4. Clique em Salvar.

gcloud

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

Use o comando a seguir para mudar uma instância do escalonador automático gerenciado para o escalonamento manual:

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

ou

  gcloud beta spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Substitua:

• 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 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância, expressa como um número de unidades de processamento. Insira quantidades até 1.000 em múltiplos de 100 (100, 200, 300 e assim por diante) e insira quantidades maiores em múltiplos de 1.000 (1.000, 2.000, 3.000 e assim por diante).

Rotular uma instância

Os rótulos ajudam a organizar os recursos.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Marque a caixa de seleção da instância. O Painel de informações aparece no lado direito da página.

3. Clique na guia Permissões no painel de informações. É possível adicionar, excluir ou atualizar rótulos para a instância do Spanner.

Editar o tipo de programação de backup padrão

Os horários de backup padrão são ativados automaticamente para todas as novas instâncias. É possível ativar ou desativar as programações de backup padrão em uma instância ao criar ou editar a instância mais tarde. Para mais informações, consulte Programações de backup padrão.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Clique no nome da instância em que você quer editar a programação de backup padrão.

3. Clique em Editar instância.

4. Em Backups, a caixa de seleção Ativar programações de backup padrão determina se as programações de backup padrão estão ativadas ou não. Quando ativada, todos os novos bancos de dados nesta instância têm uma programação de backup padrão criada.

5. Clique em Salvar.

gcloud

Use o comando gcloud spanner instances update para editar o tipo de programação de backup padrão.

Para editar o tipo de programação de backup padrão, execute o seguinte comando:

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

Substitua:

• INSTANCE_ID: o identificador permanente da instância.

• DEFAULT_BACKUP_SCHEDULE_TYPE: o tipo de programação de backup padrão usado na instância. Precisa ser um dos valores abaixo.

  • AUTOMATIC: uma programação de backup padrão é criada automaticamente quando um novo banco de dados é criado na instância. A programação de backup padrão cria um backup completo a cada 24 horas. Esses backups completos são retidos por 7 dias. É possível editar ou excluir a programação de backup padrão depois que ela for criada.
  • NONE: uma programação de backup padrão não é criada automaticamente quando um novo banco de dados é criado na instância.

C#

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

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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 de cliente do Spanner, consulte Bibliotecas de cliente do Spanner.

Para autenticar no Spanner, configure o Application Default Credentials. Para mais informações, consulte Configurar 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))

Mover uma instância

Observação: não é possível mover uma instância com o escalonador gerenciado ativado.

Para instruções sobre como mover a instância de qualquer configuração para outra, incluindo configurações regionais e multirregionais, consulte Mover uma instância.

Excluir uma instância

Aviso: com a exclusão de uma instância, todos os respectivos bancos de dados também são removidos permanentemente. Não é possível desfazer essa ação. Além disso, não é possível criar outra instância de teste gratuito depois de excluir a primeira. É possível criar uma instância de teste gratuito por ciclo de vida do projeto.

É possível excluir uma instância usando o console do Google Cloud ou a Google Cloud CLI.

Se você quiser excluir uma instância que tenha um ou mais bancos de dados com a proteção contra exclusão ativada, primeiro desative a proteção contra exclusão em todos os bancos de dados dessa instância.

Console

1. Acesse a página Instâncias do Spanner no console do Google Cloud .

   Acessar a página "Instâncias"

2. Clique no nome da instância a ser excluída.

3. Clique em Excluir instância.

4. Siga as instruções para confirmar a exclusão da instância.

5. Clique em Excluir.

gcloud

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

gcloud spanner instances delete INSTANCE_ID

Interromper ou reiniciar uma instância

O Spanner é um serviço de banco de dados totalmente gerenciado que supervisiona as próprias tarefas e recursos subjacentes, incluindo monitoramento e reinicialização de processos quando necessário, sem inatividade. Como não é necessário interromper ou reiniciar manualmente uma determinada instância, o Spanner não oferece uma maneira de fazer isso.

A seguir

• Saiba como inserir, atualizar e excluir dados com a linguagem de manipulação de dados (DML) ou a CLI do gcloud.
• Conceda papéis de gerenciamento de identidade e acesso para a instância e os respectivos bancos de dados.
• Saiba como projetar um esquema do Spanner.