Esta página se ha traducido con Cloud Translation API.

Crear y gestionar instancias

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

Crear una instancia

Puedes crear una instancia con la Google Cloud consola, la CLI de Google Cloud o bibliotecas de cliente. También puede crear una instancia con una configuración de instancia personalizada añadiendo réplicas de solo lectura opcionales.

Consola

En la Google Cloud consola, ve a la página Instancias de Spanner.
Haz clic en Crear instancia.

Ir a Crear instancia
En la sección Seleccionar una edición, elija una edición de Spanner.

Si quieres comparar las especificaciones de las diferentes ediciones, haz clic en Comparar ediciones. Para obtener más información, consulta el resumen de las ediciones de Spanner.
Haz clic en Continuar.
En la sección Asigna un nombre a tu instancia, introduce un Nombre de instancia que se mostrará en la consola Google Cloud . El nombre de la instancia debe ser único en tu proyecto Google Cloud .
Introduce un ID de instancia para identificar tu instancia de forma permanente. El ID de instancia también debe ser único en tu proyecto. Google Cloud No podrás cambiar el ID de instancia más adelante.
Haz clic en Continuar.
En la sección Configure your instance (Configurar la instancia), en Choose a configuration (Elegir una configuración), selecciona Regional (Regional), Dual-region (Dual) o Multi-region (Multirregional).

Nota: Las configuraciones de instancias de dos regiones y de varias regiones solo están disponibles en la edición Enterprise Plus. Si quieres comparar las especificaciones de las tres configuraciones, haz clic en Comparar configuraciones regionales.
Seleccione una ubicación de configuración en el menú desplegable.
Opcional: Para añadir una réplica de solo lectura a una configuración base de Spanner, primero crea una configuración de instancia personalizada con la CLI de Google Cloud. Puedes añadir réplicas de solo lectura opcionales a una configuración base en las ediciones Enterprise y Enterprise Plus.
Haz clic en Continuar.
En la sección Asignar capacidad de computación, en Seleccionar unidad, haga clic en una de las siguientes opciones:
- Nodos para instancias grandes. Un nodo equivale a 1000 unidades de procesamiento.
- Unidades de procesamiento para instancias pequeñas.
Para obtener más información, consulta Capacidad de computación, nodos y unidades de procesamiento.
En Elige un modo de escalado, haz clic en una de las siguientes opciones:
- Asignación manual: si quieres definir manualmente la capacidad de computación para recursos y costes de computación fijos.
  - Cantidad indica el número de unidades de procesamiento o nodos que se van a usar en esta instancia.
- Autoescalado: permite que Spanner añada y quite capacidad de computación automáticamente. El escalador automático gestionado está disponible en las ediciones Enterprise y Enterprise Plus de Spanner. Para obtener más información sobre la herramienta de escalado automático gestionada, consulta Escalado automático gestionado de Spanner. Configura las siguientes opciones de escalador automático gestionado:
  - Mínimo: indica el límite mínimo para reducir la escala, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite mínimo.
  - Máximo indica el límite máximo al que se puede aumentar la capacidad, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite máximo.
  - Objetivo de uso de CPU de prioridad alta: indica el porcentaje objetivo de CPU de prioridad alta que se debe usar. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
  - Objetivo de uso del almacenamiento: indica el porcentaje objetivo de almacenamiento que se va a usar. Para obtener más información, consulta Determinar el objetivo de utilización del almacenamiento.
Opcional: Si seleccionas Escalado automático como modo de escalado, puedes hacer clic en el menú desplegable Mostrar opciones de escalado automático asimétrico para escalar automáticamente tus réplicas de solo lectura de forma independiente de otras réplicas. Para obtener más información, consulta Escalado automático asimétrico de solo lectura.
1. Selecciona la réplica de solo lectura que quieras escalar automáticamente de forma asimétrica.
2. Configura las siguientes opciones de autoescalador asimétrico:
  - Mínimo: indica el límite mínimo para reducir la escala, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite mínimo.
  - Máximo indica el límite máximo al que se puede aumentar la capacidad, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite máximo.
  - Objetivo de uso de CPU de prioridad alta: indica el porcentaje objetivo de CPU de prioridad alta que se debe usar. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
En Copias de seguridad, la casilla Habilitar las programaciones de copias de seguridad predeterminadas está marcada de forma predeterminada. Para inhabilitar las programaciones de copias de seguridad predeterminadas, desmarca la casilla. Si esta opción está habilitada, se crearán copias de seguridad completas de todas las bases de datos nuevas de la instancia cada 24 horas. Estas copias de seguridad se conservan durante 7 días. Puedes editar o eliminar las programaciones de copias de seguridad predeterminadas en cualquier momento. Para obtener más información, consulta Programaciones de copias de seguridad predeterminadas.
Haz clic en Crear para que se genere la instancia.

gcloud

Usa el comando gcloud spanner instances create para crear una instancia. Especifica la capacidad de computación como el número de nodos o unidades de procesamiento que quieras 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

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

Haz los cambios siguientes:

INSTANCE-ID: un identificador permanente que es único en tu proyecto de Google Cloud . No podrás cambiar el ID de instancia más adelante.
INSTANCE-CONFIG: identificador permanente de la configuración de la instancia, que define la ubicación geográfica de la instancia y afecta a la forma en que se replican los datos. En el caso de las configuraciones de instancias personalizadas, empieza por custom-. Para obtener más información, consulta las configuraciones de instancias.
INSTANCE_DESCRIPTION: el nombre que se mostrará de la instancia en la Google Cloud consola. El nombre de la instancia debe ser único en tu proyectoGoogle Cloud .
DEFAULT_BACKUP_SCHEDULE_TYPE: el tipo de programación de copias de seguridad predeterminado que se usa en la instancia. Debe tener uno de los siguientes valores:
- AUTOMATIC: se crea automáticamente una programación de copias de seguridad predeterminada cuando se crea una base de datos 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 eliminar la programación de copias de seguridad predeterminada una vez que se haya creado.
- NONE: no se crea automáticamente una programación de copias de seguridad predeterminada cuando se crea una base de datos en la instancia.
NODE-COUNT: la capacidad de computación de la instancia, expresada como el número de nodos. Cada nodo equivale a 1000 unidades de procesamiento.
PROCESSING_UNIT_COUNT: la capacidad de computación de la instancia, expresada como un número de unidades de procesamiento. Introduce cantidades de hasta 1000 en múltiplos de 100 (100, 200, 300, etc.) y cantidades superiores en múltiplos de 1000 (1000, 2000, 3000, etc.). Nota: No use este parámetro si va a crear una instancia que quiera habilitar con el escalador automático gestionado más adelante.

Añadir autoescalado gestionado

También puedes crear instancias de la edición Enterprise y de la edición Enterprise Plus con el comando gcloud spanner instances create para usar el escalado automático gestionado. Para obtener más información, consulta Escalador automático gestionado de Spanner.

Usa el siguiente comando para crear una instancia con el escalador automático gestionado.

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

  gcloud spanner instances create INSTANCE_ID \
    --edition=EDITION \
    --config=INSTANCE_CONFIG \
    --description=INSTANCE_DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

Haz los cambios siguientes:

INSTANCE-ID: un identificador permanente que es único en tu proyecto de Google Cloud . No podrás cambiar el ID de instancia más adelante.
INSTANCE-CONFIG: identificador permanente de la configuración de la instancia, que define la ubicación geográfica de la instancia y afecta a la forma en que se replican los datos. En el caso de las configuraciones de instancias personalizadas, empieza por custom-. Para obtener más información, consulta las configuraciones de instancias.
INSTANCE-DESCRIPTION: el nombre que se mostrará de la instancia en la Google Cloud consola. El nombre de la instancia debe ser único en tu proyectoGoogle Cloud .
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: el número mínimo de unidades de procesamiento o nodos al reducir la escala. Para obtener más información, consulta Determinar el límite mínimo.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: el número máximo de unidades de procesamiento o nodos al aumentar la escala. Para obtener más información, consulta Determinar el límite máximo.
CPU_PERCENTAGE: porcentaje objetivo de CPU de prioridad alta que se va a usar, del 10 al 90%. Si quieres optimizar los costes, usa un porcentaje más alto. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
STORAGE_PERCENTAGE: el porcentaje de almacenamiento que se quiere usar, entre el 10 y el 99%. Para obtener más información, consulta Determinar el objetivo de utilización del almacenamiento.

Marcas posibles

--asymmetric-autoscaling-option: usa esta marca para habilitar el escalado automático asimétrico. Sustituye los siguientes parámetros:
- ASYMMETRIC_AUTOSCALING_LOCATION: si se usa la marca, este parámetro es obligatorio. Ubicación de la región de solo lectura que quieres escalar de forma asimétrica.
- ASYMMETRIC_AUTOSCALING_MIN: parámetro opcional. El número mínimo de nodos al reducir la escala.
- ASYMMETRIC_AUTOSCALING_MAX: parámetro opcional. Número máximo de nodos al aumentar la escala.
- ASYMMETRIC_CPU_TARGET: parámetro opcional. Porcentaje objetivo de CPU de prioridad alta que se va a usar, entre el 10 y el 90%. Si quieres optimizar los costes, usa un porcentaje más alto.

Ejemplos de uso de configuraciones personalizadas

Para crear una instancia test-instance en la configuración de instancia regional base us-central1, ejecuta el siguiente comando:

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.

A continuación, ejecuta este comando:

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

Después de ejecutar cualquiera de los comandos anteriores, debería aparecer un mensaje similar al siguiente ejemplo:

Creating instance...done.

C++

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

Para autenticarte en Spanner, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


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

Crear una instancia sin una programación de copias 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

import (
	"context"
	"fmt"
	"io"

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

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

	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
		Parent:     fmt.Sprintf("projects/%s", projectID),
		InstanceId: instanceID,
		Instance: &instancepb.Instance{
			Config:      fmt.Sprintf("projects/%s/instanceConfigs/%s", projectID, "regional-us-central1"),
			DisplayName: instanceID,
			NodeCount:   1,
			Labels:      map[string]string{"cloud_spanner_samples": "true"},
			Edition:     instancepb.Instance_STANDARD,
		},
	})
	if err != nil {
		return fmt.Errorf("could not create instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance creation to finish.
	i, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance creation to finish failed: %w", err)
	}
	// The instance may not be ready to serve yet.
	if i.State != instancepb.Instance_READY {
		fmt.Fprintf(w, "instance state is not READY yet. Got state %v\n", i.State)
	}
	fmt.Fprintf(w, "Created instance [%s]\n", instanceID)
	return nil
}

Crear una instancia con el autoescalado gestionado mediante 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
}

Crear una instancia con autoescalado 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
}

Crear una instancia sin una programación de copias 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


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

Crear una instancia con el autoescalado gestionado mediante Java


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

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Crear una instancia con autoescalado 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.InstanceConfigName;
import com.google.spanner.admin.instance.v1.ProjectName;
import com.google.spanner.admin.instance.v1.ReplicaSelection;
import java.util.concurrent.ExecutionException;

class CreateInstanceWithAsymmetricAutoscalingConfigExample {

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

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

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

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

Crear una instancia sin una programación de copias 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


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

Crear una instancia con el autoescalado gestionado mediante Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Crear una instancia sin una programación de copias 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Python

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Crear una instancia con el autoescalado gestionado mediante Python

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Crear una instancia sin una programación de copias 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 saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

# 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 instancias

Puedes mostrar una lista de tus instancias de Spanner.

Consola

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

Ir a la página Instancias

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

gcloud

Usa el comando gcloud spanner instances list:

gcloud spanner instances list

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

Editar una instancia

En las siguientes secciones se explica cómo actualizar la edición de una instancia y cómo cambiar el nombre visible, la capacidad de computación y el tipo de programación de copias de seguridad predeterminada de una instancia. No puedes cambiar el ID de instancia ni la configuración de la instancia (pero sí puedes mover tu instancia).

Cambiar a una edición superior

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. Las instancias de la edición Enterprise se pueden actualizar a la edición Enterprise Plus. La actualización de edición tarda aproximadamente 10 minutos en completarse sin tiempo de inactividad.

Consola

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

Ir a la página Instancias
Haga clic en el nombre de la instancia que quiera actualizar.
Haz clic en Actualizar junto al tipo de edición.
En la página Instancia de edición, en Actualizar edición, selecciona la nueva edición de nivel superior para tu instancia.
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]

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
EDITION: especifica la nueva edición de nivel superior para tu instancia. Para obtener más información, consulta el resumen de las ediciones de Spanner.

Marcas posibles

--async: use esta marca si quiere que su solicitud se devuelva inmediatamente, sin esperar a que se complete la operación en curso. Puedes consultar el estado de tu solicitud ejecutando gcloud spanner operations describe.

Go

import (
	"context"
	"fmt"
	"io"

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

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

	req := &instancepb.UpdateInstanceRequest{
		Instance: &instancepb.Instance{
			Name: fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID),
			// The edition selected for this instance.
			// Different editions provide different capabilities at different price points.
			// For more information, see https://cloud.google.com/spanner/docs/editions-overview.
			Edition: instancepb.Instance_ENTERPRISE,
		},
		FieldMask: &field_mask.FieldMask{
			Paths: []string{"edition"},
		},
	}
	op, err := instanceAdmin.UpdateInstance(ctx, req)
	if err != nil {
		return fmt.Errorf("could not update instance %s: %w", fmt.Sprintf("projects/%s/instances/%s", projectID, instanceID), err)
	}
	// Wait for the instance update to finish.
	_, err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("waiting for instance update to finish failed: %w", err)
	}

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

Java


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceExample {

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

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

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

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

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

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


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

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

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

const instanceAdminClient = spanner.getInstanceAdminClient();

// Updates an instance
try {
  console.log(
    `Updating instance ${instanceAdminClient.instancePath(
      projectId,
      instanceId,
    )}.`,
  );
  const [operation] = await instanceAdminClient.updateInstance({
    instance: {
      name: instanceAdminClient.instancePath(projectId, instanceId),
      labels: {
        updated: 'true',
        created: Math.round(Date.now() / 1000).toString(), // current time
      },
      edition:
        protos.google.spanner.admin.instance.v1.Instance.Edition.ENTERPRISE, //optional
    },
    // Field mask specifying fields that should get updated in an Instance
    fieldMask: (protos.google.protobuf.FieldMask = {
      paths: ['labels', 'edition'],
    }),
  });

  console.log(`Waiting for operation on ${instanceId} to complete...`);
  await operation.promise();
  console.log(`Updated instance ${instanceId}.`);
  const [metadata] = await instanceAdminClient.getInstance({
    name: instanceAdminClient.instancePath(projectId, instanceId),
  });
  console.log(
    `Instance ${instanceId} has been updated with the ${metadata.edition} ` +
      'edition.',
  );
} catch (err) {
  console.error('ERROR:', err);
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Cambiar a una edición inferior

Puedes cambiar tus instancias de Spanner a una edición de nivel inferior. Para cambiar a una edición inferior, debes dejar de usar las funciones de la edición superior. 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 la edición Enterprise o Standard. El proceso de cambio a una edición inferior tarda aproximadamente 10 minutos en completarse y no requiere tiempo de inactividad.

gcloud

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

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Haz los cambios siguientes:

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

Cambiar el nombre visible

Consola

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

Ir a la página Instancias
Haz clic en el nombre de la instancia cuyo nombre quieras cambiar.
Haz clic en Editar instancia.
Introduce un nombre nuevo para la instancia. Este nombre debe ser único en el proyectoGoogle Cloud .
Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE_ID --description=INSTANCE_NAME

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
INSTANCE_NAME: el nombre que se mostrará de la instancia en la consolaGoogle Cloud . El nombre de la instancia debe ser único en tu proyectoGoogle Cloud .

Cambiar la capacidad de computación

Debes aprovisionar suficiente capacidad de computación para que la utilización de la CPU y la utilización del almacenamiento se mantengan 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 computación de una instancia de Spanner, excepto en los siguientes casos:

No puedes almacenar más de 10 TiB de datos por nodo (1000 unidades de procesamiento).
Hay un gran número de divisiones de los datos de tu instancia. En este caso, es posible que Spanner no pueda gestionar las divisiones después de reducir la capacidad de computación. Puedes probar a reducir la capacidad de computación en cantidades cada vez menores hasta que encuentres la capacidad mínima que necesita Spanner para gestionar todas las divisiones de la instancia.

Spanner puede crear un gran número 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 podrías intentar reducir la capacidad de computación de la instancia.

Cuando elimines capacidad de computación, monitoriza la utilización de la CPU y las latencias de las solicitudes en Cloud Monitoring para asegurarte de que la utilización de la CPU se mantiene por debajo del 65% en las instancias regionales y del 45% en cada región de las instancias multirregionales. Es posible que experimentes un aumento temporal de la latencia de las solicitudes mientras se elimina la capacidad de computación.

Si quieres aumentar la capacidad de computación de una instancia, tuGoogle Cloud proyecto debe tener cuota suficiente para añadirla. 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 raras ocasiones, el escalado puede tardar hasta una hora en completarse.

Consola

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

Ir a la página Instancias
Haga clic en el nombre de la instancia que quiera cambiar.
Haz clic en Editar instancia.
Cambia la capacidad de computación eligiendo las unidades de medida (unidades de procesamiento o nodos) y, a continuación, introduciendo una cantidad. Cuando uses unidades de procesamiento, introduce cantidades de hasta 1000 en múltiplos de 100 (100, 200, 300, etc.) y cantidades superiores en múltiplos de 1000 (1000, 2000, 3000, etc.). Cada nodo equivale a 1000 unidades de procesamiento.
Haz clic en Guardar.

Si aparece un cuadro de diálogo que indica que no tienes suficiente cuota para añadir capacidad de computación en esta ubicación, sigue las instrucciones para solicitar una cuota superior.

gcloud

Usa el comando gcloud spanner instances update. Cuando uses este comando, especifica la capacidad de computación como un número de nodos o unidades de procesamiento.

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

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

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
NODE_COUNT: la capacidad de computación de la instancia, expresada como número de nodos. Cada nodo equivale a 1000 unidades de procesamiento.
PROCESSING_UNIT_COUNT: la capacidad de computación de la instancia, expresada como un número de unidades de procesamiento. Introduce cantidades de hasta 1000 en múltiplos de 100 (100, 200, 300, etc.) y cantidades superiores en múltiplos de 1000 (1000, 2000, 3000, etc.).

Marcas posibles

--async: use esta marca si quiere que su solicitud se devuelva inmediatamente, sin esperar a que se complete la operación en curso. Puedes consultar el estado de tu solicitud ejecutando gcloud spanner operations describe.

Habilitar o modificar el auto escalador gestionado en una instancia

Puedes habilitar o modificar el autoescalado en una instancia de Spanner mediante la Google Cloud consola, la CLI de gcloud o las bibliotecas de cliente de Spanner. Se aplican las siguientes limitaciones al añadir o cambiar la función de escalado automático gestionado en una instancia:

El autoescalador gestionado solo está disponible en las ediciones Enterprise y Enterprise Plus.
No puedes habilitar el escalador automático gestionado en una instancia que estés moviendo.
No puedes mover una instancia mientras el escalador automático gestionado esté habilitado.

Consola

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

Ir a la página Instancias
Haga clic en el nombre de la instancia en la que quiera habilitar el escalador automático gestionado.
Haz clic en Editar instancia.
En Configurar capacidad de computación, haga clic en Autoescalado.
En Mínimo, selecciona el límite mínimo que se usará al reducir la escala. Para obtener más información, consulta Determinar el límite mínimo.
En Máximo, seleccione el límite máximo que se usará al aumentar la escala. Para obtener más información, consulta Determinar el límite máximo.
En Uso de CPU objetivo de prioridad alta, selecciona el porcentaje de CPU de prioridad alta que quieras usar. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
En Objetivo de uso del almacenamiento, selecciona el porcentaje de almacenamiento que quieras usar. Para obtener más información, consulta Determinar el objetivo de utilización del almacenamiento.
Opcional: Si seleccionas Escalado automático como modo de escalado, puedes hacer clic en el menú desplegable Mostrar opciones de escalado automático asimétrico para escalar automáticamente tus réplicas de solo lectura de forma independiente de otras réplicas.
1. Selecciona la réplica de solo lectura que quieras escalar automáticamente de forma asimétrica.
2. Configura las siguientes opciones de escalador automático:
  - Mínimo: indica el límite mínimo para reducir la escala, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite mínimo.
  - Máximo indica el límite máximo al que se puede aumentar la capacidad, en función de la unidad de medida que elijas para Capacidad de cálculo. Para obtener más información, consulta Determinar el límite máximo.
  - Objetivo de uso de CPU de prioridad alta: indica el porcentaje objetivo de CPU de prioridad alta que se debe usar. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update para añadir el auto escalador gestionado a una instancia. Para obtener más información y conocer las limitaciones, consulta Banderas y limitaciones de Google Cloud CLI.

Puedes añadir el escalador automático gestionado 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=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE \
    [--asymmetric-autoscaling-option \
       location=ASYMMETRIC_AUTOSCALING_LOCATION,min_nodes=ASYMMETRIC_AUTOSCALING_MIN,\
       max_nodes=ASYMMETRIC_AUTOSCALING_MAX,high_priority_cpu_target=ASYMMETRIC_CPU_TARGET]

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

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: el número mínimo de unidades de procesamiento o nodos que se deben usar al reducir la escala. Para obtener más información, consulta Determinar el límite mínimo.
MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: número máximo de unidades de procesamiento o nodos que se van a usar al aumentar la escala. Para obtener más información, consulta Determinar el límite máximo.
CPU_PERCENTAGE: porcentaje objetivo de CPU de prioridad alta que se va a usar, del 10% al 90%. Si quieres optimizar los costes y no necesitas una latencia baja en todas las solicitudes, usa un porcentaje más alto. Para obtener más información, consulta Determinar el objetivo de utilización de la CPU.
STORAGE_PERCENTAGE: porcentaje de almacenamiento que se quiere usar, entre el 10% y el 99%. Para obtener más información, consulta Determinar el objetivo de utilización del almacenamiento.

Marcas posibles

--asymmetric-autoscaling-option: usa esta marca para habilitar el escalado automático asimétrico. Sustituye los siguientes parámetros:
- ASYMMETRIC_AUTOSCALING_LOCATION: si se usa la marca, este parámetro es obligatorio. Ubicación de la región de solo lectura que quieres escalar de forma asimétrica.
- ASYMMETRIC_AUTOSCALING_MIN: parámetro opcional. El número mínimo de nodos al reducir la escala.
- ASYMMETRIC_AUTOSCALING_MAX: parámetro opcional. Número máximo de nodos al aumentar la escala.
- ASYMMETRIC_CPU_TARGET: parámetro opcional. Porcentaje objetivo de CPU de prioridad alta que se va a usar, entre el 10 y el 90%. Si quieres optimizar los costes, usa un porcentaje más alto.

Después de añadir el escalador automático gestionado a una instancia, también puedes modificar sus ajustes. Por ejemplo, si quieres aumentar el número máximo de unidades de procesamiento a 10.000, ejecuta el siguiente comando:

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

Cambiar una instancia de autoescalado gestionado a escalado manual

Puedes cambiar si una instancia de Spanner usa el escalado manual o el gestionado con la Google Cloud consola, la CLI de gcloud o las bibliotecas de cliente de Spanner.

Consola

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

Ir a la página Instancias
Haga clic en el nombre de la instancia en la que quiera inhabilitar el escalado automático gestionado.
En Elige un modo de escalado, haz clic en Asignación manual.
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 autoescalado gestionado a escalado manual:

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

  gcloud spanner instances update INSTANCE_ID \
  --nodes=NODE_COUNT

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
NODE_COUNT: la capacidad de computación de la instancia, expresada como el número de nodos. Cada nodo equivale a 1000 unidades de procesamiento.
PROCESSING_UNIT_COUNT: la capacidad de computación de la instancia, expresada como un número de unidades de procesamiento. Introduce cantidades de hasta 1000 en múltiplos de 100 (100, 200, 300, etc.) y cantidades superiores en múltiplos de 1000 (1000, 2000, 3000, etc.).

Etiquetar una instancia

Las etiquetas te ayudan a organizar los recursos.

Consola

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

Ir a la página Instancias
Marca la casilla de la instancia. El panel de información aparece en la parte derecha de la página.
En el panel de información, haz clic en la pestaña Etiquetas. Después, puede añadir, eliminar o actualizar etiquetas de la instancia de Spanner.

Editar el tipo de programación de copias de seguridad predeterminado

Las programaciones de copias de seguridad predeterminadas se habilitan automáticamente en todas las instancias nuevas. Puedes habilitar o inhabilitar las programaciones de copias de seguridad predeterminadas en una instancia al crearla o editándola más adelante. Para obtener más información, consulta Programaciones de copias de seguridad predeterminadas.

Consola

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

Ir a la página Instancias
Haga clic en el nombre de la instancia cuya programación de copias de seguridad predeterminada quiera editar.
Haz clic en Editar instancia.
En Copias de seguridad, la casilla Habilitar programaciones de copias de seguridad predeterminadas determina si las programaciones de copias de seguridad predeterminadas están habilitadas o no. Cuando está habilitada, se crea una programación de copias de seguridad predeterminada para todas las bases de datos nuevas de esta instancia.
Haz clic en Guardar.

gcloud

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

Para editar el tipo de programación de copia de seguridad predeterminado, ejecuta el siguiente comando:

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

Haz los cambios siguientes:

INSTANCE_ID: identificador permanente de la instancia.
DEFAULT_BACKUP_SCHEDULE_TYPE: el tipo de programación de copias de seguridad predeterminado que se usa en la instancia. Debe tener uno de los siguientes valores:
- AUTOMATIC: se crea automáticamente una programación de copias de seguridad predeterminada cuando se crea una base de datos 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 eliminar la programación de copias de seguridad predeterminada una vez que se haya creado.
- NONE: no se crea automáticamente una programación de copias de seguridad predeterminada cuando se crea una base de datos en la instancia.

C#

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


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

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

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

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

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

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

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

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

Go

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.common.collect.Lists;
import com.google.protobuf.FieldMask;
import com.google.spanner.admin.instance.v1.Instance;
import com.google.spanner.admin.instance.v1.InstanceConfigName;
import com.google.spanner.admin.instance.v1.InstanceName;
import com.google.spanner.admin.instance.v1.UpdateInstanceRequest;
import java.util.concurrent.ExecutionException;

public class UpdateInstanceDefaultBackupScheduleTypeExample {

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

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

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

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

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

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

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

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

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

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

Python

Para saber cómo instalar y usar la biblioteca de cliente de Spanner, consulta Bibliotecas de cliente de Spanner.

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

Para obtener instrucciones sobre cómo mover tu instancia de una configuración a otra, incluidas las configuraciones regionales y multirregionales, consulta Mover una instancia.

Eliminar una instancia

Puedes eliminar una instancia con la consola de Google Cloud o con la CLI de Google Cloud.

Si quieres eliminar una instancia que tiene una o varias bases de datos con la protección contra la eliminación habilitada, primero debes inhabilitar la protección contra la eliminación en todas las bases de datos de esa instancia antes de poder eliminarla.

Consola

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

Ir a la página Instancias
Haz clic en el nombre de la instancia que quieras eliminar.
Haz clic en Eliminar instancia.
Sigue las instrucciones para confirmar que quieres eliminar la instancia.
Haz clic en Eliminar.

gcloud

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

gcloud spanner instances delete INSTANCE_ID

Detener o reiniciar una instancia

Spanner es un servicio de base de datos totalmente gestionado que supervisa sus propias tareas y recursos subyacentes, como la monitorización y el reinicio de procesos cuando es necesario, sin tiempo de inactividad. Como no es necesario detener ni reiniciar manualmente una instancia, Spanner no ofrece ninguna forma de hacerlo.

Siguientes pasos

Consulta cómo insertar, actualizar y eliminar datos con el lenguaje de manipulación de datos (DML) o la CLI de gcloud.
Concede roles de gestión de identidades y accesos a la instancia y a sus bases de datos.
Consulta cómo diseñar un esquema de Spanner.

Crear y gestionar instancias Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Crear una instancia

Consola

gcloud

Añadir autoescalado gestionado

Ejemplos de uso de configuraciones personalizadas

C++

C#

Crear una instancia sin una programación de copias de seguridad predeterminada

Go

Crear una instancia con el autoescalado gestionado mediante Go

Crear una instancia con autoescalado asimétrico de solo lectura con Go

Crear una instancia sin una programación de copias de seguridad predeterminada

Java

Crear una instancia con el autoescalado gestionado mediante Java

Crear una instancia con autoescalado asimétrico de solo lectura con Java

Crear una instancia sin una programación de copias de seguridad predeterminada

Node.js

Crear una instancia con el autoescalado gestionado mediante Node.js

Crear una instancia sin una programación de copias de seguridad predeterminada

PHP

Python

Crear una instancia con el autoescalado gestionado mediante Python

Crear una instancia sin una programación de copias de seguridad predeterminada

Ruby

Mostrar instancias

Consola

gcloud

Editar una instancia

Cambiar a una edición superior

Consola

gcloud

Go

Java

Node.js

Python

Cambiar a una edición inferior

gcloud

Cambiar el nombre visible

Consola

gcloud

Cambiar la capacidad de computación

Consola

gcloud

Habilitar o modificar el auto escalador gestionado en una instancia

Consola

gcloud

Cambiar una instancia de autoescalado gestionado a escalado manual

Consola

gcloud

Etiquetar una instancia

Consola

Editar el tipo de programación de copias de seguridad predeterminado

Consola

gcloud

C#

Go

Java

Node.js

Python

Mover una instancia

Eliminar una instancia

Consola

gcloud

Detener o reiniciar una instancia

Siguientes pasos

Crear y gestionar instancias