Crea y administra instancias

En esta página, se describe cómo crear, enumerar, editar y borrar Spanner instancias.

Nota: Para explorar Spanner con una instancia de prueba gratuita de 90 días, consulta Cómo crear una instancia de prueba gratuita de Spanner.

Crea una instancia

Puedes crear una instancia con la consola de Google Cloud, Google Cloud CLI o bibliotecas cliente. También puedes crear con una configuración de instancias personalizada si agregas réplicas de solo lectura opcionales.

Nota: No es necesario aprovisionar almacenamiento en Spanner, y solo se cobra por el almacenamiento que usas. Obtén más información sobre los precios de almacenamiento.

Console

1. En la consola de Google Cloud, ve a la página Instancias de Spanner.

2. Haz clic en Crear instancia.

   Ir a Crear instancia

3. En la sección Seleccionar una edición, selecciona una edición de Spanner.

   Si deseas comparar las especificaciones entre las diferentes ediciones, haz clic en Comparar ediciones. Para ver más consulta la descripción general de las ediciones de Spanner.

4. Haga clic en Continuar.

5. En la sección Nombre de la instancia, ingresa el Nombre de la instancia para en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.

6. Ingresa un ID de instancia para identificar de forma permanente tu instancia. El ID de la instancia también debe ser único en tu proyecto de Google Cloud. No puedes cambiar el ID de la instancia más tarde.

7. Haga clic en Continuar.

8. En la sección Configura tu instancia, en Elige una configuración, selecciona Regional, Doble región o Multirregión.

   Nota: Las opciones de configuración de instancias birregionales y multirregionales solo son disponibles en la edición Enterprise Plus. Si quieres compara las especificaciones de las tres configuraciones y, luego, haz clic Compara los parámetros de configuración de las regiones.

9. Selecciona una ubicación de configuración del menú desplegable.

10. Opcional: Para agregar una réplica de solo lectura a una base de Spanner configuración, primero crea una configuración de instancia personalizada con el Google Cloud CLI La adición de réplicas de solo lectura opcionales a una configuración base está disponible en las ediciones Enterprise y Enterprise Plus.

11. Haga clic en Continuar.

12. En la sección Asignar capacidad de procesamiento, en Seleccionar unidad, haz clic en una de las siguientes opciones:

    • Unidades de procesamiento para instancias pequeñas.
    • Nodos para instancias grandes. Un nodo consta de 1,000 unidades de procesamiento.

    Para obtener más información, consulta Capacidad de procesamiento, nodos y unidades de procesamiento.

13. En Elegir un modo de escalamiento, haz clic en una de las siguientes opciones:

    • Asignación manual si deseas establecer manualmente la capacidad de procesamiento para los recursos de procesamiento y costos fijos

      • La cantidad indica la cantidad de unidades de procesamiento o nodos. para usar en esta instancia.

    • Ajuste de escala automático (versión preliminar) para permitir que Spanner agregue y quite capacidad de procesamiento de forma automática El escalador automático administrado está disponible en las ediciones Enterprise y Enterprise Plus de Spanner. Para obtener más información sobre el escalador automático administrado, consulta Escalador automático administrado para Spanner. Configura las siguientes opciones administradas de escalador automático:

      • Mínimo indica el límite mínimo al que se puede reducir la escala, según la unidad de medida que elijas para la capacidad de procesamiento. Para obtener más información, consulta Determina el límite mínimo.
      • Máximo indica el límite máximo para escalar verticalmente. según la unidad de medida que elijas para Compute. capacidad. Para obtener más información, consulta Determina el límite máximo.
      • El objetivo de uso de CPU de alta prioridad indica el porcentaje objetivo de CPU de alta prioridad que se debe usar. Para obtener más información, consulta Determina el objetivo de uso de CPU.
      • El objetivo de uso de almacenamiento indica el porcentaje objetivo de almacenamiento que se debe usar. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

14. Haz clic en Crear para crear la instancia.

gcloud

Usa el comando gcloud spanner instances create para crear una instancia. Especifica la capacidad de procesamiento como la cantidad de nodos o unidades de procesamiento que deseas en la instancia.

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--nodes=NODE_COUNT

o

gcloud spanner instances create INSTANCE_ID \
--edition=EDITION \
--config=INSTANCE_CONFIG \
--description=INSTANCE_DESCRIPTION \
--processing-units=PROCESSING_UNIT_COUNT

Reemplaza lo siguiente:

• INSTANCE-ID: Un identificador permanente que es único dentro de tu proyecto de Google Cloud. No puedes cambiar el ID de la instancia más tarde.
• INSTANCE-CONFIG: Un identificador permanente de la configuración de tu instancia, que define la ubicación geográfica de la instancia y afecta la forma en que se replican los datos. En el caso de las configuraciones de instancias personalizadas, comienza con custom-. Para obtener más información, consulta Configuraciones de instancias.
• INSTANCE_DESCRIPTION: Es el nombre que se mostrará para la instancia en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.
• NODE-COUNT: Es la capacidad de procesamiento de la instancia, expresada como una cantidad de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.
• PROCESSING_UNIT_COUNT: Es la capacidad de procesamiento de la instancia, expresada como una cantidad de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etc.) e ingresa mayor cantidades en múltiplos de 1000 (1000, 2000, 3000, etc.). Nota: No uses este parámetro si creas una instancia que deseas habilitar con el escalador automático administrado más adelante.

Agrega el ajuste de escala automático administrado (Versión preliminar)

También puedes crear la edición Enterprise y Edición Enterprise Plus para usar el ajuste de escala automático administrado gcloud beta spanner instances create . Para obtener más información, consulta Escalador automático administrado para Spanner.

Usa el siguiente comando para crear una instancia con el ajustador de escala administrado.

  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

o

  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

Reemplaza lo siguiente:

• INSTANCE-ID: Un identificador permanente que es único dentro de tu proyecto de Google Cloud. No puedes cambiar el ID de la instancia más tarde.
• INSTANCE-CONFIG: Un identificador permanente de la configuración de tu instancia, que define la ubicación geográfica de la instancia y afecta la forma en que se replican los datos. Para las configuraciones de instancias personalizadas, comienza con custom-. Para obtener más información, consulta instancias parámetros de configuración.
• INSTANCE-DESCRIPTION: Es el nombre que se mostrará para la instancia en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: el la cantidad mínima de nodos o unidades de procesamiento cuando se reduce la escala. Para ver más consulta Determinar el límite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: el la cantidad máxima de unidades de procesamiento o nodos cuando escalen verticalmente. Para obtener más información, consulta Determina el límite máximo.
• CPU_PERCENTAGE: Es el porcentaje objetivo de la CPU de alta prioridad a usan, del 10 al 90%. Si optimizas el costo, usa un valor mayor porcentaje. Para obtener más información, consulta Determina el objetivo de uso de CPU.
• STORAGE_PERCENTAGE: Es el porcentaje objetivo de almacenamiento que se usará, de 10 a 99%. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

Ejemplos para usar configuraciones personalizadas

Para crear una instancia test-instance en la instancia regional base, sigue estos pasos: configuración us-central1, ejecuta lo siguiente:

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

Para crear una instancia custom-eur6-instance en la configuración de instancia multirregional personalizada custom-eur6, primero crea una configuración de instancia personalizada.

Luego, ejecuta lo siguiente:

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

Deberías ver un mensaje similar al siguiente ejemplo después de ejecutar cualquiera de los comandos anteriores:

Creating instance...done.

C++

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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
}

Crear una instancia con ajuste de escala automático administrado mediante Go (vista previa)

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 obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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");
    }
  }
}

Nota: Las muestras de código de interfaz de la biblioteca cliente anterior para Java se archivan en GitHub.

Crear una instancia con ajuste de escala automático administrado mediante Java (vista previa)

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

Node.js

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

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

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

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

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

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

Nota: Las muestras de código de la interfaz de la biblioteca cliente anterior para Node.js se archivan en GitHub:

PHP

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

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

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

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

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

Nota: Las muestras de código de la interfaz de la biblioteca cliente anterior para PHP se archivan en GitHub:

Python

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

    spanner_client = spanner.Client()

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

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

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

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

Nota: Las muestras de código de la interfaz de la biblioteca cliente anterior para Python están archivadas en GitHub.

Ruby

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

Mostrar lista de instancias

Puedes mostrar una lista de tus instancias de Spanner.

Console

Ve a la página Instancias de Spanner en la consola de Google Cloud.

Ir a la página Instancias

La consola de Google Cloud muestra una lista de tus instancias de Spanner, junto con el ID, el nombre visible, la configuración y la capacidad de procesamiento de cada instancia, expresada en unidades de procesamiento y en nodos.

gcloud

Usa el comando gcloud spanner instances list:

gcloud spanner instances list

La CLI de gcloud imprime una lista de tus instancias de Spanner, junto con el ID, el nombre visible, la configuración y la capacidad de procesamiento de cada instancia.

Editar una instancia

En las siguientes secciones, se explica cómo actualizar la edición de tu instancia y cambiar su nombre visible y su capacidad de procesamiento. No puedes cambiar ID o configuración de la instancia (sin embargo, puedes mover la instancia).

Actualiza la edición

Puedes actualizar tus instancias de la edición estándar a una de nivel superior. Las instancias de la edición Standard se pueden actualizar al Enterprise o Enterprise Plus. Las instancias de la edición Enterprise se pueden actualizar a la edición Enterprise Plus.

La versión inferior de autoservicio no está disponible. Para cambiar a una versión anterior de la instancia, envía un ticket de asistencia. Para obtener más información, consulta las Preguntas frecuentes sobre las ediciones de Spanner.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia que deseas actualizar.

3. Haz clic en Actualizar junto al tipo de edición.

4. En la página Instancia de edición, en Actualizar edición, selecciona la nueva edición de nivel superior para tu instancia.

5. Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update para actualizar la edición de tu instancia:

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

Reemplaza lo siguiente:

• INSTANCE_ID: El identificador permanente de la instancia.
• EDITION: Especifica la nueva edición de nivel superior para tu instancia. Para obtener más información, consulta la Descripción general de las ediciones de Spanner.

Marcas opcionales:

• --async: Usa esta marca si deseas que tu solicitud se muestre de inmediato. sin esperar a que la operación en curso finalice. Puedes consultar el estado de tu solicitud ejecutando 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Spanner, consulta Bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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))

Cómo cambiar el nombre visible

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia a la que deseas cambiarle el nombre.

3. Haz clic en Editar instancia.

4. Ingresa un nuevo nombre de instancia. Este nombre debe ser único dentro del proyecto de Google Cloud.

5. Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Reemplaza lo siguiente:

• INSTANCE_ID: El identificador permanente de la instancia.
• INSTANCE_NAME: Es el nombre que se mostrará para la instancia en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.

Cambia la capacidad de procesamiento

Debes aprovisionar suficiente capacidad de procesamiento para mantener Uso de CPU y de uso de almacenamiento por debajo de los máximos recomendados. Para obtener más información, consulta las cuotas y límites de Spanner

Hay algunos casos en los que no puedes reducir la capacidad de procesamiento de un instancia existente:

• Si quitas la capacidad de procesamiento, tu instancia deberá almacenar más de 4 TB de datos por 1,000 unidades de procesamiento (1 nodo).
• Según tus patrones de uso históricos, Spanner creó un una gran cantidad de divisiones para tu de la instancia de VM y, en casos excepcionales, Spanner no podría para administrar las divisiones después de quitar la capacidad de procesamiento.

En el último caso, puedes intentar reducir la capacidad de procesamiento de forma progresiva con cantidades más pequeñas hasta encontrar la capacidad mínima que Spanner necesita para administrar todas las divisiones de la instancia. Si la instancia ya no requiere tantas divisiones debido a un cambio en los patrones de uso, Spanner podría combinar algunas divisiones y permitirte reducir aún más la capacidad de procesamiento de la instancia después de una o dos semanas.

Cuando quites capacidad de procesamiento, supervisa el uso de CPU latencias en Cloud Monitoring para garantizar que los la utilización se mantiene por debajo del 65% para los de Compute Engine y un 45% para cada región en multirregionales. Es posible que experimentes un aumento temporal en la solicitud latencias mientras se quita la capacidad de procesamiento.

Si deseas aumentar la capacidad de procesamiento de una instancia, tu proyecto de Google Cloud debe tener una cuota suficiente para agregar la capacidad de procesamiento. El tiempo que tarda en completarse la solicitud de aumento depende del tamaño de la solicitud. En la mayoría de los casos, las solicitudes se completan en pocos minutos. En ocasiones excepcionales, un aumento de escala puede tardar hasta una hora en completarse.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia que deseas cambiar.

3. Haz clic en Editar instancia.

4. Elige las unidades de medida para cambiar la capacidad de procesamiento (unidades de procesamiento o nodos) y, luego, ingresa una cantidad. Cuando uses unidades de procesamiento, ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etcétera) y cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera). Cada nodo equivale a 1,000 unidades de procesamiento.

5. Haz clic en Guardar.

Si ves un cuadro de diálogo que indica que tienes una cuota insuficiente para agregar capacidad de procesamiento en esta ubicación, sigue las instrucciones a fin de solicitar una cuota superior.

gcloud

Usa el comando gcloud spanner instances update. Cuando uses este comando, especifica la capacidad de procesamiento como una cantidad de nodos o unidades de procesamiento.

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

o

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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• NODE_COUNT: La capacidad de procesamiento de la instancia, expresada como cantidad de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.
• PROCESSING_UNIT_COUNT: Es la capacidad de procesamiento de la instancia, expresada como una cantidad de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etcétera) y cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera).

Marcas opcionales:

• --async: Usa esta marca si deseas que tu solicitud se muestre de inmediato. sin esperar a que la operación en curso finalice. Puedes consultar el estado de tu solicitud ejecutando gcloud spanner operations describe

Habilita o modifica el escalador automático administrado en una instancia

Vista previa — Managed autoscaler

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Se aplican las siguientes limitaciones cuando agregas o cambias la función de escalamiento automático administrado en una instancia existente:

• El escalador automático administrado solo está disponible en la edición Enterprise o Enterprise Plus.
• No puedes habilitar el escalador automático administrado en una instancia que estás moviendo.

• No puedes mover una instancia mientras el escalador automático administrado está habilitado.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia en la que deseas habilitar el ajustador de escala administrado.

3. Haz clic en Editar instancia.

4. En Configura la capacidad de procesamiento, haz clic en Ajuste de escala automático.

5. En Mínimo, selecciona el límite mínimo que se usará cuando se reduzca la escala. Para obtener más información, consulta Determina el límite mínimo.

6. En Máximo, selecciona el límite máximo que se usará cuando se realice el escalamiento. Para para obtener más información, consulta Determina el límite máximo.

7. En Objetivo de uso de CPU de alta prioridad, selecciona el porcentaje de CPU de alta prioridad que deseas usar. Para obtener más información, consulta Determina el objetivo de uso de CPU.

8. En Objetivo de uso de almacenamiento, selecciona el porcentaje de almacenamiento que se usará. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

9. Haz clic en Guardar.

gcloud

Usa el comando gcloud beta spanner instances update para agregar el escalador automático administrado a una instancia. Para obtener más información y limitaciones, consulta Marcas y limitaciones de Google Cloud CLI.

Puedes agregar el escalador automático administrado con el siguiente 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

o

  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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Es la cantidad mínima de unidades de procesamiento o nodos que se deben usar cuando se reduce la escala. Para obtener más información, consulta Determina el límite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: Es la cantidad máxima de unidades de procesamiento o nodos que se deben usar cuando se realiza la escalamiento. Para obtener más información, consulta Determina el límite máximo.
• CPU_PERCENTAGE: Es el porcentaje objetivo de la CPU de alta prioridad a usan, del 10% al 90%. Si optimizas en función del costo y no necesitas la latencia en todas las solicitudes y, luego, usar un porcentaje más alto. Para ver más información, consulta Determina el objetivo de uso de CPU.
• STORAGE_PERCENTAGE: El porcentaje objetivo de almacenamiento que se usará. de 10% a 99%. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

Después de agregar el escalador automático administrado a una instancia, puedes modificar el del escalador automático administrado. Por ejemplo, si deseas aumentar la cantidad máxima de unidades de procesamiento a 10,000, ejecuta el siguiente comando:

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

Cambia una instancia de usar el escalador automático administrado al ajuste de escala manual

Vista previa — Managed autoscaling

Esta función está sujeta a las "Condiciones de las Ofertas de Fase Previa a la DG" de la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de fase previa a la DG están disponibles “tal cual” y podrían tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia en la que deseas inhabilitar el escalador administrado.

3. En Elegir un modo de escalamiento, haz clic en Asignación manual.

4. Haz clic en Guardar.

gcloud

Usa el comando gcloud beta spanner instances update para actualizar la instancia.

Usa el siguiente comando para impedir que una instancia use el rol escalador automático al ajuste de escala manual:

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

o

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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• NODE_COUNT: La capacidad de procesamiento de la instancia, expresada como un número de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.
• PROCESSING_UNIT_COUNT: La capacidad de procesamiento de la instancia. expresada como un número de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etcétera) y cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera).

Etiqueta una instancia

Etiquetas para organizar tus recursos.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Selecciona la casilla de verificación de la instancia. El panel de información aparece en el lado derecho de la página.

3. Haz clic en la pestaña Etiquetas en el panel de información. Luego, puedes agregar, borrar o actualizar etiquetas para la instancia de Spanner.

Cómo mover una instancia

Nota: No puedes mover una instancia que tenga habilitado el escalador automático administrado.

Si deseas obtener instrucciones para trasladar tu instancia de cualquier configuración de instancias a cualquier otra configuración de instancias, incluso entre instancias regionales y multirregionales consulta Traslada una instancia.

Borrar una instancia

Advertencia: Si borras una instancia, esta y todos sus componentes se quitarán de forma permanente bases de datos. No puedes deshacer esta acción más adelante. Además, no puedes crear otra instancia de prueba gratuita una vez que hayas borrado la primera. Puedes crear una instancia de prueba gratuita por ciclo de vida del proyecto.

Puedes borrar una instancia con la consola de Google Cloud o Google Cloud CLI

Si quieres borrar una instancia que tiene una o más bases de datos con protección contra la eliminación habilitada, primero debes inhabilitar la protección contra la eliminación en todas las bases de datos de esa instancia antes de borrarla.

Console

1. Ve a la página Instancias de Spanner en la consola de Google Cloud.

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia que deseas borrar.

3. Haz clic en Borrar instancia.

4. Sigue las instrucciones para confirmar que deseas borrar la instancia.

5. Haz clic en Borrar.

gcloud

Usa la gcloud spanner instances delete. comando y reemplaza INSTANCE_ID por el ID de la instancia:

gcloud spanner instances delete INSTANCE_ID

Detén o reinicia una instancia

Spanner es un servicio de base de datos completamente administrado que supervisa sus propias tareas y recursos subyacentes, lo que incluye supervisar y reiniciar procesos cuando sea necesario sin tiempo de inactividad. Como no hay necesidad de modificar detener o reiniciar una instancia determinada, Spanner no ofrece hazlo.

¿Qué sigue?

• Obtén más información para insertar, actualizar y borrar datos con el lenguaje de manipulación de datos (DML) o gcloud CLI.
• Otorga funciones de administración de identidades y accesos para la instancia y sus bases de datos.
• Obtén información para diseñar un esquema de Spanner.