Criar e gerenciar instâncias

Nesta página, descrevemos como criar, listar, editar e excluir o Spanner instâncias.

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

Criar uma instância

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

Observação :não é necessário provisionar o armazenamento no Spanner, e você são cobrados apenas pelo armazenamento que você usa. Saiba mais sobre os preços de armazenamento.

Console

1. Acesse a página Criar instância no console do Google Cloud.

   Criar instância

2. Insira um nome de instância para ser exibido no console do Google Cloud. O nome da instância precisa ser exclusivo no projeto do Google Cloud.

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

4. Clique em Continuar.

5. Na seção Configurar sua instância, em Escolha uma configuração, selecione Regional, Birregional ou Multirregional. Como alternativa, se você quiser comparar especificações entre as três configurações e, em seguida, clique Compare as configurações de região.

6. Selecione uma configuração na lista suspensa.

7. Opcional: para adicionar uma réplica somente leitura a uma base do Spanner do seu aplicativo, primeiro crie uma configuração de instância personalizada usando o Google Cloud CLI.

8. Clique em Continuar.

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

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

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

10. Em Escolha 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 computacionais fixos.

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

    • Escalonamento automático (Pré-lançamento), para permitir que o Spanner adicione e remova automaticamente recursos de armazenamento. Para mais informações sobre o escalonador automático gerenciado, ver Escalonador automático gerenciado para o Spanner. Configure as seguintes opções do escalonador automático gerenciado:

      • Mínimo indica o limite mínimo de redução da escala vertical, com base na unidade de medida escolhida para o Compute de armazenamento. Para mais informações, consulte Determine o limite mínimo.
      • Máximo indica o limite máximo para o escalonamento vertical. com base na unidade de medida escolhida para o Compute de armazenamento. Para mais informações, consulte Determinar o limite máximo
      • Meta de utilização de CPU de alta prioridade indica a meta 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 utilização do armazenamento indica a porcentagem desejada de armazenamento para usar. Para mais informações, consulte Determinar a meta de utilização do armazenamento.

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

gcloud

Usar o gcloud spanner instances create para criar uma instância. Especificar a capacidade de computação como o número de nós ou unidades de processamento que você quer ter na instância.

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--nodes=NODE-COUNT

ou

gcloud spanner instances create INSTANCE-ID \
--config=INSTANCE-CONFIG \
--description=INSTANCE-DESCRIPTION \
--processing-units=PROCESSING-UNIT-COUNT

Substitua:

• INSTANCE-ID: um identificador permanente que é exclusivo no seu projeto do Google Cloud. Não será possível alterá-lo depois.
• INSTANCE-CONFIG: um identificador permanente da instância. da instância, que define a localização geográfica da instância e afeta a replicação dos dados. Para configurações de instância personalizadas, começa com custom-. Para mais informações, consulte instance personalizadas.
• 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.

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

• PROCESSING-UNIT-COUNT: a capacidade de computação da instância. expresso 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 maior quantidades em múltiplos de 1000 (1000, 2000, 3000 e assim por diante). Observação: Não use esse parâmetro ao criar uma instância que você pretende para ativar o escalonador automático gerenciado posteriormente.

Adicionar escalonamento automático gerenciado (prévia)

Também é possível configurar novas instâncias para usar o escalonamento automático gerenciado com o gcloud beta spanner instances create kubectl. Para mais informações, consulte Escalonador automático gerenciado para o Spanner.

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

  gcloud beta spanner instances create INSTANCE-ID \
    --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 \
    --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 que é exclusivo em seu projeto do Google Cloud. Não será possível alterá-lo depois.
• INSTANCE-CONFIG: um identificador permanente da instância. da instância, que define a localização geográfica da instância e afeta a replicação dos dados. Para configurações de instância personalizadas, começa com custom-. Para mais informações, consulte instance personalizadas.
• 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 nós ou unidades de processamento ao reduzir a escala vertical. Para mais informações, consulte Determinar o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o e o número máximo de nós ou unidades de processamento durante o escalonamento vertical. Para mais informações, consulte Determinar o limite máximo
• CPU_PERCENTAGE: a porcentagem desejada de CPU de alta prioridade para usar, de 10 a 90%. Se você estiver otimizando custos, use um modelo porcentagem. Para mais informações, consulte Determine a meta de utilização da CPU.
• STORAGE_PERCENTAGE: a porcentagem desejada de armazenamento a ser usada. de 10% a 99%. Para mais informações, consulte Determine a meta de utilização do armazenamento.

Exemplos de uso de configurações personalizadas

Para criar uma instância, test-instance na instância regional de base us-central1, execute:

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

Para criar uma instância custom-eur6-instance na multirregião personalizada configuração da instância custom-eur6, primeiro criar uma configuração de instância personalizada.

Depois, execute:

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

Após a execução, uma mensagem semelhante ao exemplo a seguir será exibida. um dos comandos anteriores:

Creating instance...done.

C++

Para aprender a 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 aprender a 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;

public class CreateInstanceSample
{
    public Instance CreateInstance(string projectId, string instanceId)
    {
        // Create the InstanceAdminClient instance.
        InstanceAdminClient instanceAdminClient = InstanceAdminClient.Create();

        // 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" },
            }
        };
        ProjectName projectName = ProjectName.FromProject(projectId);

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

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

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

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

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

        return completedResponse.Result;
    }
}

Go

Para aprender a 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"
	instancepb "google.golang.org/genproto/googleapis/spanner/admin/instance/v1"
)

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

Java

Para aprender a 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)
            .setNodeCount(nodeCount)
            .setConfig(
                InstanceConfigName.of(projectId, "regional-us-central1").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 da biblioteca de cliente antiga para Java estão arquivados em 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-central1";
      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");
      }
    }
  }
}

Node.js

Para aprender a 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} = 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
      },
    },
  });

  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 da biblioteca de cliente antiga para Node.js estão arquivados em GitHub:

PHP

Para aprender a 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 da biblioteca de cliente antiga para PHP estão arquivados em GitHub:

Python

Para aprender a 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())),
            },
        ),
    )

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

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

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

Ruby

Para aprender a 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"

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: "regional-us-central1"

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

É possível 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 instâncias com ID, nome de exibição, configuração e capacidade de computação 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 instâncias do Spanner com ID, nome de exibição, configuração e de computação do Google Cloud.

Editar uma instância

As seções a seguir explicam como alterar o nome de exibição e a capacidade de computação de uma instância. Não é possível alterar o código ou a configuração da instância.

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.

Alterar a capacidade de computação

Você precisa provisionar capacidade de computação suficiente para manter Uso de CPU e uso do armazenamento abaixo do máximo recomendado. Para mais informações, consulte Cotas e limites para no Spanner.

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

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

No último caso, tente reduzir a capacidade de computação progressivamente em quantidades menores até encontrar a capacidade mínima que o Spanner precisa gerenciar todas as divisões da instância. Se a instância não precisar mais a tantas divisões devido a uma mudança nos padrões de uso, o Spanner pode mesclar algumas divisões e tentar reduzir o a capacidade de computação da instância após uma ou duas semanas.

Ao remover a capacidade de computação, monitore o uso da CPU e solicite latências no Cloud Monitoring para garantir que a CPU o uso permanece abaixo de 65% para o e 45% para cada região do instâncias multirregionais. Pode haver um aumento temporário nas solicitações e latências ao remover a capacidade de computação.

Para aumentar a capacidade de computação de uma instância, O projeto do Google Cloud precisa ter cota suficiente para adicionar a de armazenamento. O tempo necessário para que a solicitação de aumento seja concluída depende do tamanho da solicitação. Na maioria dos casos, as solicitações são concluídas em alguns minutos. Ativado raras ocasiões, 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. Escolha as unidades de medida para alterar a capacidade de computação (unidades de processamento ou nós) e, em seguida, inserir uma quantidade. Ao usar de unidades de processamento, insira quantidades até 1.000 em múltiplos de 100 (100, 200, 300 e assim por diante) e inserir quantidades maiores em múltiplos de 1000 (1000, 2000, 3000 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 este comando, especifique a capacidade de computação como uma o 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 uma total de nós. Cada nó é igual a 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância. expresso 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 maior quantidades em múltiplos de 1000 (1000, 2000, 3000 e assim por diante).

Sinalizações opcionais:

• --async: use essa sinalização se quiser que sua solicitação seja retornada imediatamente; sem esperar a conclusão da operação em andamento. Você pode conferir o status da sua solicitação executando 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 escalonamento automático gerenciado atributo em uma instância atual:

• Não é possível ativar o escalonador automático 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 automático ativado.

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 ao reduzir a escala. Para mais informações, consulte Determine o limite mínimo.

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

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

8. Em Meta de uso do armazenamento, selecione a porcentagem de armazenamento usar. Para mais informações, consulte Determine a meta de utilização do armazenamento.

9. Clique em Salvar.

gcloud

Use o gcloud beta spanner instances update para adicionar o escalonador automático gerenciado a uma instância. Para mais informações e limitações, consulte sinalizações 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 ou nós de processamento para usar ao reduzir a escala vertical. Para mais informações, consulte Determine o limite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: o número máximo de nós ou unidades de processamento para usar ao escalonar verticalmente. Para mais informações, consulte Determinar o limite máximo
• CPU_PERCENTAGE: a porcentagem desejada de CPU de alta prioridade para uso, de 10% a 90%. Se você otimizar os custos e não precisar de latência em todas as solicitações e depois use uma porcentagem maior. Para mais informações, consulte Determine a meta de utilização da CPU.
• STORAGE_PERCENTAGE: a porcentagem desejada de armazenamento a ser usada. de 10% a 99%. Para mais informações, consulte Determinar a meta de utilização do armazenamento.

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

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

Alterar o uso do escalonador automático gerenciado em uma instância 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 gerenciamento. escalonador automático ativado.

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

4. Clique em Salvar.

gcloud

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

Use o comando a seguir para impedir que uma instância use o serviço escalonador automático para 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 uma série de nós. Cada nó é igual a 1.000 unidades de processamento.
• PROCESSING_UNIT_COUNT: a capacidade de computação da instância. expresso 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 maior quantidades em múltiplos de 1000 (1000, 2000, 3000 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. Depois, é possível adicionar, excluir ou atualizar os rótulos da instância do Spanner.

Mover uma instância

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

Para instruções sobre como mover sua instância de qualquer configuração de instância para qualquer outra configuração de instância, inclusive entre configurações regionais e multirregionais configurações, 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 outro instância de teste gratuito depois de excluir sua primeira instância de teste gratuito. Você pode criar uma instância de teste gratuito por ciclo de vida do projeto.

É possível excluir uma instância com o console do Google Cloud ou CLI do Google Cloud:

Se você quer excluir uma instância que tem um ou mais bancos de dados com ativada, é necessário desativar a proteção contra exclusão em todos os bancos de dados da instância antes que seja possível excluí-la.

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

Usar o 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 próprias tarefas e recursos, incluindo monitoramento e reinicialização e processos quando necessário, sem inatividade. Como não é preciso fazer alterações interromper ou reiniciar uma determinada instância, o Spanner não oferece uma maneira de faça isso.

A seguir

• Saiba como inserir, atualizar e excluir dados com o Linguagem de manipulação de dados (DML, na sigla em inglês) ou a CLI gcloud.
• Conceda papéis de gerenciamento de identidade e acesso para a instância e os bancos de dados dela.
• Entenda como projetar um esquema do Spanner.