Crea y administra instancias

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

Nota: Para explorar Spanner con una instancia de prueba gratuita de 90 días, consulta Crea una instancia de prueba gratuita de Spanner.

Crea una instancia

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

Nota: No necesitas aprovisionar almacenamiento en Spanner y solo se te factura 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 Selecciona una edición, elige una edición de Spanner.

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

4. Haz clic en Continuar.

5. En la sección Asigna un nombre a tu instancia, ingresa un Nombre de la instancia para mostrar 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 tu instancia de forma permanente. El ID de instancia también debe ser único dentro de tu proyecto de Google Cloud . No puedes cambiar el ID de la instancia más adelante.

7. Haz clic en Continuar.

8. En la sección Configura tu instancia, en Elige una configuración, selecciona Regional, Birregional o Multirregional.

   Nota: Las configuraciones de instancias birregionales y multirregionales solo están disponibles en la edición Enterprise Plus. Si quieres comparar las especificaciones entre las tres opciones, haz clic en Compara configuraciones regionales.

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

10. Opcional: Para agregar una réplica de solo lectura a una configuración base de Spanner, primero crea una configuración de instancia personalizada con gcloud 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. Haz clic en Continuar.

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

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

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

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

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

      • Cantidad indica la cantidad de unidades de procesamiento o nodos que se usarán para esta instancia.

    • Ajuste de escala automático 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 del escalador automático administrado:

      • Mínimo indica el límite mínimo para reducir la escala verticalmente, 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 la capacidad de procesamiento. 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 que se usará para las tareas de alta prioridad. Para obtener más información, consulta Determina el objetivo de uso de CPU.
      • El objetivo de uso total de CPU indica el porcentaje objetivo de CPU que se usará para todas las tareas de prioridad baja, media y alta. Para obtener más información, consulta Determina el objetivo de uso total de CPU.
      • El objetivo de uso de almacenamiento indica el porcentaje objetivo de almacenamiento que se usará. Para obtener más información, consulta Determina el objetivo de uso del almacenamiento.

14. Opcional: Si seleccionas Ajuste de escala automático como el modo de escalamiento, puedes hacer clic en el menú desplegable Mostrar opciones de ajuste de escala automático asimétrico para ajustar la escala de forma automática de tus réplicas de solo lectura de forma independiente de otras réplicas. Para obtener más información, consulta Ajuste de escala automático asimétrico de solo lectura.

    1. Selecciona la réplica de solo lectura a la que deseas aplicar el ajuste de escala automático asimétrico.

    2. Configura las siguientes opciones del escalador automático asimétrico:

       • Mínimo indica el límite mínimo para reducir la escala verticalmente, 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 la capacidad de procesamiento. 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 que se usará para las tareas de alta prioridad. Para obtener más información, consulta Determina el objetivo de uso de CPU de alta prioridad.
       • El Objetivo de uso total de CPU indica el porcentaje objetivo de CPU que se usará para todas las tareas de prioridad baja, media y alta. El porcentaje de CPU puede variar del 10% al 90%. El objetivo de CPU total debe ser mayor que el objetivo de CPU de alta prioridad. Si optimizas en función del costo, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso total de CPU.
       • Inhabilitar la CPU total indica que el escalador automático debe ignorar de forma explícita el objetivo de CPU total.
       • Inhabilitar la CPU de alta prioridad indica que el escalador automático debe ignorar de forma explícita el objetivo de CPU para las tareas de alta prioridad.

15. En Copias de seguridad, la casilla de verificación Habilitar programaciones de copias de seguridad predeterminadas está marcada de forma predeterminada. Para inhabilitar las programaciones de copias de seguridad predeterminadas, desmarca la casilla de verificación. Cuando se habilita, todas las bases de datos nuevas de la instancia tienen copias de seguridad completas creadas cada 24 horas. Estas copias de seguridad se conservan durante 7 días. Puedes editar o borrar las programaciones predeterminadas de copias de seguridad en cualquier momento. Para obtener más información, consulta Programas de copia de seguridad predeterminados.

16. 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 \
--default-backup-schedule-type=DEFAULT_BACKUP_SCHEDULE_TYPE \
--nodes=NODE_COUNT

o

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

Reemplaza lo siguiente:

• INSTANCE-ID: Es un identificador permanente que es único dentro de tu proyecto de Google Cloud . No puedes cambiar el ID de la instancia más adelante.
• INSTANCE-CONFIG: Es 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 Parámetros de configuración 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 deGoogle Cloud .

• DEFAULT_BACKUP_SCHEDULE_TYPE: Es el tipo de programa de copia de seguridad predeterminado que se usa en la instancia. Debe ser uno de los siguientes valores:

  • AUTOMATIC: Se crea automáticamente un programa de copia de seguridad predeterminado cuando se crea una base de datos nueva en la instancia. La programación de copias de seguridad predeterminada crea una copia de seguridad completa cada 24 horas. Estas copias de seguridad completas se conservan durante 7 días. Puedes editar o borrar la programación predeterminada de copias de seguridad una vez que se crea.
  • NONE: No se crea automáticamente un programa de copia de seguridad predeterminado cuando se crea una base de datos nueva en la instancia.

• 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étera) y, para cantidades mayores, ingresa múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera). 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

También puedes crear instancias de la edición Enterprise y Enterprise Plus para usar el ajuste de escala automático administrado con el comando gcloud 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 un escalador automático administrado.

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=HIGH_PRIORITY_CPU_PERCENTAGE \
    --autoscaling-total-cpu-target=TOTAL_CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--disable-downscaling | --no-disable-downscaling] \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,\
       min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,\
       high_priority_cpu_target=ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET,\
       total_cpu_target=ASYMMETRIC_TOTAL_CPU_TARGET \
       [,disable_total_cpu_autoscaling=TRUE|FALSE \
       | disable_high_priority_cpu_autoscaling=TRUE|FALSE]
    ]

o

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

Reemplaza lo siguiente:

• INSTANCE-ID: Es un identificador permanente que es único dentro de tu proyecto de Google Cloud . No puedes cambiar el ID de la instancia más adelante.
• INSTANCE-CONFIG: Es 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 Parámetros de configuración 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 deGoogle Cloud .
• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Es la cantidad mínima de unidades de procesamiento o nodos cuando se reduce la escala verticalmente. 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 cuando se escala verticalmente. Para obtener más información, consulta Determina el límite máximo.
• HIGH_PRIORITY_CPU_PERCENTAGE: Es el porcentaje objetivo de CPU de alta prioridad que se usará, según la prioridad de la tarea. El porcentaje de CPU puede variar del 10% al 90%. Si optimizas para el costo, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso de CPU de alta prioridad.
• TOTAL_CPU_PERCENTAGE: Es el porcentaje objetivo de CPU de prioridad total que se usará. El objetivo de CPU total debe ser mayor que el objetivo de CPU de alta prioridad. El porcentaje de CPU puede variar del 10% al 90%. Si optimizas para reducir costos, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso total de CPU.
• STORAGE_PERCENTAGE: Es el porcentaje objetivo de almacenamiento que se usará, del 10% al 99%. Para obtener más información, consulta Determina el objetivo de uso del almacenamiento.

Marcas opcionales:

• --disable-downscaling: Usa esta marca booleana para inhabilitar la reducción de escala. Cuando se establece en TRUE, impide que el escalador automático reduzca la cantidad de nodos o unidades de procesamiento. El escalamiento vertical sigue funcionando con normalidad para satisfacer el aumento de la demanda. Para habilitar la reducción de escala después de inhabilitarla, usa la marca --no-disable-downscaling.

• --asymmetric-autoscaling-option: Usa esta marca para habilitar el ajuste de escala automático asimétrico. Reemplaza los siguientes parámetros:

  • ASYMMETRIC_AUTOSCALING_LOCATION: Si se usa la marca, este parámetro es obligatorio. La ubicación de la región de solo lectura que deseas escalar de forma asimétrica.
  • ASYMMETRIC_AUTOSCALING_MIN: Es un parámetro opcional. Es la cantidad mínima de nodos cuando se reduce la escala verticalmente. Si no se especifica, este valor se hereda de la configuración de la instancia base.
  • ASYMMETRIC_AUTOSCALING_MAX: Es un parámetro opcional. Es la cantidad máxima de nodos cuando se escala verticalmente. Si no se especifica, este valor se hereda de la configuración de la instancia base.
  • ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: Es un parámetro opcional. Es el porcentaje objetivo de CPU que se usará, según la prioridad de la tarea. Si no se especifica, este valor se hereda de la configuración de la instancia base. Si optimizas para reducir costos, usa un porcentaje más alto. Las réplicas pueden tener un porcentaje objetivo diferente al de la instancia base y al de otras réplicas, pero para situaciones de conmutación por error, recomendamos que las réplicas usen objetivos coherentes en las diferentes réplicas. Para obtener más información, consulta Problemas de conmutación por error.
  • ASYMMETRIC_TOTAL_CPU_TARGET: Es un parámetro opcional. Establece el objetivo del 10% al 90% para la CPU total. Si no se especifica, este valor se hereda de la configuración de la instancia base. Si optimizas para reducir costos, usa un porcentaje más alto. Las réplicas pueden tener un porcentaje objetivo diferente al de la instancia base y al de otras réplicas, pero para situaciones de conmutación por error, recomendamos que las réplicas usen objetivos coherentes en las diferentes réplicas. Para obtener más información, consulta Ajuste de escala automático asimétrico de solo lectura.
  • disable_total_cpu_autoscaling: Establece este parámetro en TRUE si no deseas que el escalador automático ajuste la escala de la CPU total en las réplicas. No especifiques este parámetro si quieres que la instancia herede el destino total_cpu_autoscaling de la instancia base. No puedes inhabilitar la CPU total y la CPU de alta prioridad en la misma réplica.
  • disable_high_priority_cpu_autoscaling: Establece el disable_high_priority_cpu_autoscaling en TRUE si no quieres que el escalador automático ajuste la escala de la CPU de alta prioridad en las réplicas. No especifiques este parámetro si quieres que la instancia herede el destino high_priority_cpu_autoscaling de la instancia base. No puedes inhabilitar la CPU total y la CPU de prioridad alta en la misma réplica.

Ejemplos de uso de configuraciones personalizadas

Para crear una instancia test-instance en la configuración de la instancia regional base 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 las bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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 las bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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;
using System.Threading.Tasks;

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

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

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

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

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

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

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

        return completedResponse.Result;
    }
}

Crea una instancia sin una programación de copia de seguridad predeterminada

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

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

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

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

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

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

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

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

Go

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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
}

Crea una instancia con ajuste de escala automático administrado con Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Crea una instancia con ajuste de escala automático asimétrico de solo lectura con Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Crea una instancia sin una programación de copia de seguridad predeterminada

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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");
    }
  }
}

Crea una instancia con ajuste de escala automático administrado con Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.Instance.Edition;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Crea una instancia con ajuste de escala automático asimétrico de solo lectura con Java

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.AutoscalingConfig;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.Instance.Edition;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Crea una instancia sin una programación de copia de seguridad predeterminada

import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.spanner.admin.instance.v1.CreateInstanceRequest;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithoutDefaultBackupSchedulesExample {

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

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

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

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

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

Node.js

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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.

Crea una instancia con ajuste de escala automático administrado con Node.js

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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,
});

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

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

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

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

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

Crea una instancia sin una programación de copia de seguridad predeterminada

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

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

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

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

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

PHP

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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 las bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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 se archivan en GitHub.

Crea una instancia con ajuste de escala automático administrado con Python

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

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

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

    spanner_client = spanner.Client()

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

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

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

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

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

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

Crea una instancia sin una programación de copia de seguridad predeterminada

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

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

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

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

Ruby

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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"
# instance_config_id = "Your Spanner InstanceConfig ID"

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

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

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

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

puts "Waiting for create instance operation to complete"

job.wait_until_done!

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

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

En la consola de Google Cloud , se 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

gcloud CLI 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 el nombre visible, la capacidad de procesamiento y el tipo de programa de copia de seguridad predeterminado de una instancia. No puedes cambiar el ID ni la configuración de la instancia (sin embargo, puedes moverla).

Actualiza la edición

Puedes actualizar tus instancias de la edición Standard a una edición de nivel superior. Las instancias de la edición Standard se pueden actualizar a la edición Enterprise o Enterprise Plus, siempre y cuando no se lo impida una restricción de la política de la organización. Las instancias de la edición Enterprise se pueden actualizar a la edición Enterprise Plus. La actualización de la edición tarda aproximadamente 10 minutos en completarse sin tiempo de inactividad.

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 y 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: Es 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 devuelva de inmediato, sin esperar a que se complete la operación en curso. Para verificar el estado de tu solicitud, ejecuta 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 las bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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 las bibliotecas cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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(900)

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

Cambia a una versión inferior de la edición

Puedes cambiar tus instancias de Spanner a una edición de nivel inferior. Debes dejar de usar las funciones de la edición de nivel superior para cambiar a una versión inferior. Las instancias de la edición Enterprise se pueden cambiar a la edición Standard. Las instancias de la edición Enterprise Plus se pueden cambiar a una versión anterior, como la edición Enterprise o Standard. La reducción de edición tarda aproximadamente 10 minutos en completarse sin tiempo de inactividad.

Para supervisar el uso de las funciones de las ediciones Enterprise y Enterprise Plus en tu instancia, usa la métrica de supervisión Uso de funciones (instance/edition/feature_usage). Para obtener más información, consulta Supervisa el uso de las ediciones.

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 a una versión anterior.

3. En la página Descripción general de la instancia, haz clic en Editar instancia.

4. En la página Editar instancia, en Elige una edición de Spanner, selecciona la edición de nivel inferior.

5. Haz clic en Actualizar instancia.

gcloud

Usa el comando gcloud spanner instances update para cambiar a una edición inferior de la instancia:

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Reemplaza lo siguiente:

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

Cambia 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 en el proyecto 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: Es el identificador permanente de la instancia.
• INSTANCE_NAME: Es el nombre que se mostrará para la instancia en la consola deGoogle Cloud . El nombre de la instancia debe ser único en tu proyecto deGoogle Cloud .

Cambia la capacidad de procesamiento

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

Puedes reducir la capacidad de procesamiento de una instancia de Spanner, excepto en las siguientes situaciones:

• No puedes almacenar más de 10 TiB de datos por nodo (1,000 unidades de procesamiento).

• Hay una gran cantidad de divisiones para los datos de tu instancia. En esta situación, es posible que Spanner no pueda administrar las divisiones después de que reduzcas la capacidad de procesamiento. Puedes intentar reducir la capacidad de procesamiento en cantidades cada vez más pequeñas hasta encontrar la capacidad mínima que Spanner necesita para administrar todas las divisiones de la instancia.

  Spanner puede crear una gran cantidad de divisiones para adaptarse a tus patrones de uso. Si tus patrones de uso cambian, después de una o dos semanas, Spanner podría combinar algunas divisiones y puedes intentar reducir la capacidad de procesamiento de la instancia.

Cuando quites capacidad de procesamiento, supervisa el uso de CPU y las latencias de las solicitudes en Cloud Monitoring para asegurarte de que el uso de CPU se mantenga por debajo del 65% en las instancias regionales y del 45% en cada región en las instancias multirregionales. Es posible que experimentes un aumento temporal en las latencias de las solicitudes mientras quitas capacidad de procesamiento.

Si deseas aumentar la capacidad de procesamiento de una instancia, tu proyecto deGoogle 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 unos minutos. En ocasiones excepcionales, un escalamiento vertical 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. Para cambiar la capacidad de procesamiento, elige las unidades de medida (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, luego, ingresa 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: 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étera) y, para cantidades mayores, ingresa 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 devuelva de inmediato, sin esperar a que se complete la operación en curso. Para verificar el estado de tu solicitud, ejecuta gcloud spanner operations describe.

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

Puedes habilitar o modificar el ajuste de escala automático en una instancia de Spanner con la consola de Google Cloud , la gcloud CLI o las bibliotecas cliente de Spanner. Se aplican las siguientes limitaciones cuando agregas o cambias la función de ajuste de escala 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 escalador automático 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 verticalmente. 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 escale verticalmente. 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 que se usará para las tareas de alta prioridad. Para obtener más información, consulta Determina el objetivo de uso de CPU.

8. En Objetivo de uso total de CPU, selecciona el porcentaje de CPU objetivo que se usará para todas las tareas de prioridad baja, media y alta. El porcentaje de CPU puede variar del 10% al 90%. Para obtener más información, consulta Determina el objetivo de uso total de CPU.

9. 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 del almacenamiento.

10. Opcional: Si seleccionas Ajuste de escala automático como el modo de escalamiento, puedes hacer clic en el menú desplegable Mostrar opciones de ajuste de escala automático asimétrico para ajustar la escala automáticamente de tus réplicas de solo lectura de forma independiente de otras réplicas.

    1. Selecciona la réplica de solo lectura a la que deseas aplicar el ajuste de escala automático asimétrico.

    2. Configura las siguientes opciones del escalador automático:

       • Mínimo indica el límite mínimo para reducir la escala verticalmente, 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 la capacidad de procesamiento. 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 que se usará para las tareas de alta prioridad. Para obtener más información, consulta Determina el objetivo de uso de CPU de alta prioridad.
       • El Objetivo de uso total de CPU indica el porcentaje objetivo de CPU que se usará para todas las tareas de prioridad baja, media y alta. El porcentaje de CPU puede variar del 10% al 90%. Para obtener más información, consulta Determina el objetivo de uso total de CPU.

11. Haz clic en Guardar.

gcloud

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

Puedes agregar el escalador automático administrado con el siguiente comando:

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

o

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

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 usarán cuando se reduzca la escala verticalmente. 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 usarán cuando se realice el escalamiento vertical. Para obtener más información, consulta Determina el límite máximo.
• HIGH_PRIORITY_CPU_PERCENTAGE: Es el porcentaje objetivo de CPU de alta prioridad que se usará, según la prioridad de la tarea. El porcentaje de CPU puede variar del 10% al 90%. Si optimizas para el costo, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso de CPU de alta prioridad.
• TOTAL_CPU_PERCENTAGE: Es el porcentaje objetivo de CPU de prioridad total que se usará. El objetivo de CPU total debe ser mayor que el objetivo de CPU de alta prioridad. El porcentaje de CPU puede variar del 10% al 90%. Si optimizas para reducir costos, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso total de CPU.
• STORAGE_PERCENTAGE: Es el porcentaje objetivo de almacenamiento que se usará, del 10% al 99%. Para obtener más información, consulta Determina el objetivo de uso del almacenamiento.

Marcas opcionales:

• --disable-downscaling: Usa esta marca booleana para inhabilitar la reducción de escala. Cuando se establece en TRUE, impide que el escalador automático reduzca la cantidad de nodos o unidades de procesamiento. El escalamiento vertical sigue funcionando con normalidad para satisfacer el aumento de la demanda. Para habilitar la reducción de escala después de inhabilitarla, usa la marca --no-disable-downscaling.

• --asymmetric-autoscaling-option: Usa esta marca para habilitar el ajuste de escala automático asimétrico.

  Reemplaza los siguientes parámetros:

  • ASYMMETRIC_AUTOSCALING_LOCATION: Si se usa la marca de ajuste de escala automático asimétrico, este parámetro es obligatorio. Es la ubicación de la región de solo lectura que deseas escalar de forma asimétrica.
  • ASYMMETRIC_AUTOSCALING_MIN: Es un parámetro opcional. Es la cantidad mínima de nodos cuando se reduce la escala verticalmente. Si no se especifica, este valor se hereda de la configuración de la instancia base.
  • ASYMMETRIC_AUTOSCALING_MAX: Es un parámetro opcional. Es la cantidad máxima de nodos cuando se escala verticalmente. Si no se especifica, este valor se hereda de la configuración de la instancia base.
  • ASYMMETRIC_HIGH_PRIORITY_CPU_TARGET: Es un parámetro opcional. Es el porcentaje objetivo de CPU que se usará, según la prioridad de la tarea. Si no se especifica, este valor se hereda de la configuración de la instancia base. Si optimizas para reducir costos, usa un porcentaje más alto. Las réplicas pueden tener un porcentaje objetivo diferente al de la instancia base y al de otras réplicas, pero para situaciones de conmutación por error, recomendamos que las réplicas usen objetivos coherentes en las diferentes réplicas. Para obtener más información, consulta Problemas de conmutación por error.
  • ASYMMETRIC_TOTAL_CPU_TARGET: Es un parámetro opcional. Establece el objetivo del 10% al 90% para la CPU total. Si no se especifica, este valor se hereda de la configuración de la instancia base. Si optimizas para reducir costos, usa un porcentaje más alto. Las réplicas pueden tener un porcentaje objetivo diferente al de la instancia base y al de otras réplicas, pero para situaciones de conmutación por error, recomendamos que las réplicas usen objetivos coherentes en las diferentes réplicas. Para obtener más información, consulta Ajuste de escala automático asimétrico de solo lectura.
  • disable_total_cpu_autoscaling: Establece este parámetro en TRUE si no deseas que el escalador automático ajuste la escala de la CPU total en las réplicas. No especifiques este parámetro si quieres que la instancia herede el destino total_cpu_autoscaling de la instancia base. No puedes inhabilitar la CPU total y la CPU de alta prioridad en la misma réplica.
  • disable_high_priority_cpu_autoscaling: Establece el disable_high_priority_cpu_autoscaling en TRUE si no quieres que el escalador automático ajuste la escala de la CPU de alta prioridad en las réplicas. No especifiques este parámetro si quieres que la instancia herede el destino high_priority_cpu_autoscaling de la instancia base. No puedes inhabilitar la CPU total y la CPU de prioridad alta en la misma réplica.

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

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

Cambia una instancia para que use el escalado manual en lugar del escalador automático administrado

Puedes cambiar si una instancia de Spanner usa el escalamiento manual o administrado con la consola de Google Cloud , la gcloud CLI o las bibliotecas cliente 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 en la que deseas inhabilitar el escalador automático administrado.

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

4. Haz clic en Guardar.

gcloud

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

Usa el siguiente comando para cambiar una instancia de usar el escalador automático administrado al escalamiento manual:

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

o

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• 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étera) y, para cantidades mayores, ingresa 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.

Edita el tipo de programa de copias de seguridad predeterminado

Las programaciones de copias de seguridad predeterminadas se habilitan automáticamente para todas las instancias nuevas. Puedes habilitar o inhabilitar las programaciones de copias de seguridad predeterminadas en una instancia cuando la creas o la editas más adelante. Para obtener más información, consulta Programas de copia de seguridad predeterminados.

Console

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

Ir a la página Instancias

1. Haz clic en el nombre de la instancia en la que deseas editar el programa de copia de seguridad predeterminado.
2. Haz clic en Editar instancia.
3. En Copias de seguridad, la casilla de verificación Habilitar programaciones de copias de seguridad predeterminadas determina si las programaciones de copias de seguridad predeterminadas están habilitadas o no. Cuando se habilita, todas las bases de datos nuevas de esta instancia tienen una programación de copias de seguridad predeterminada.
4. Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update para editar el tipo de programaciones de copia de seguridad predeterminadas.

Para editar el tipo de programa de copia de seguridad predeterminado, ejecuta el siguiente comando:

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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.

• DEFAULT_BACKUP_SCHEDULE_TYPE: Es el tipo de programa de copia de seguridad predeterminado que se usa en la instancia. Debe ser uno de los siguientes valores:

  • AUTOMATIC: Se crea automáticamente un programa de copia de seguridad predeterminado cuando se crea una base de datos nueva en la instancia. La programación de copias de seguridad predeterminada crea una copia de seguridad completa cada 24 horas. Estas copias de seguridad completas se conservan durante 7 días. Puedes editar o borrar la programación predeterminada de copias de seguridad una vez que se crea.
  • NONE: No se crea automáticamente un programa de copia de seguridad predeterminado cuando se crea una base de datos nueva en la instancia.

C#

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

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

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

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

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

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

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

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

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

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

Go

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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"
	"google.golang.org/genproto/protobuf/field_mask"
)

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

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

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

Java

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

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para 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.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceDefaultBackupScheduleTypeExample {

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

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

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

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

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

Node.js

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

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

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

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

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

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

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

Python

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

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

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

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

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

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

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

Mover una instancia

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

Para obtener instrucciones sobre cómo mover tu instancia de cualquier configuración de instancia a cualquier otra configuración de instancia, incluso entre configuraciones regionales y multirregionales, consulta Mueve una instancia.

Borrar una instancia

Advertencia: Si borras una instancia, se quitará de forma permanente junto con todas sus 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 la gcloud CLI.

Si deseas borrar una instancia que tiene una o más bases de datos con la protección contra eliminaciones habilitada, primero debes inhabilitar la protección contra eliminaciones en todas las bases de datos de esa instancia antes de poder 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 el comando gcloud spanner instances delete 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, incluidos la supervisión y el reinicio de procesos cuando es necesario, sin tiempo de inactividad. Como no es necesario detener o reiniciar de forma manual una instancia determinada, Spanner no ofrece una forma de hacerlo.

¿Qué sigue?

• Aprende a insertar, actualizar y borrar datos con el lenguaje de manipulación de datos (DML) o la gcloud CLI.
• Otorga roles de Identity and Access Management (IAM) para la instancia y sus bases de datos.
• Comprender cómo diseñar un esquema de Spanner