Crea y administra instancias

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

Crea una instancia

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

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 instancia para que se muestre en la consola de Google Cloud . El nombre de la instancia debe ser único en tu Google Cloud proyecto.

  6. Ingresa un ID de instancia para identificar de forma permanente tu instancia. El ID de la instancia también debe ser único en tu proyecto Google Cloud . No podrás 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.

  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 básica de Spanner, primero crea una configuración de instancia personalizada con Google Cloud CLI. La opción para agregar réplicas opcionales de solo lectura a una configuración básica 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 manualmente la capacidad de procesamiento para los recursos de procesamiento y costos fijos

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

    • Ajuste de escala automático para permitir que Spanner agregue y quite capacidad de procesamiento automáticamente El ajuste de escala 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:

  14. Opcional: Si seleccionas Ajuste de escala automático como el modo de ajuste de escala, 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. 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 que deseas escalar automáticamente de forma asimétrica.

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

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

  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 esta opción, 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 Programaciones de copias de seguridad predeterminadas.

  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 Google Cloud proyecto. No podrás 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. En el caso de las configuraciones de instancias personalizadas, comienza con custom-. Para obtener más información, consulta configuraciones de instancias.
  • INSTANCE_DESCRIPTION: Es el nombre que se mostrará para la instancia en la consola de Google Cloud . El nombre de la instancia debe ser único en tu proyecto deGoogle Cloud .

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

    • AUTOMATIC: Se crea automáticamente una programación de copia de seguridad predeterminada cuando se crea una base de datos nueva en la instancia. La programación predeterminada de copias de seguridad 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 una programación de copias de seguridad predeterminada 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 cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera). Nota: No uses este parámetro si creas una instancia que piensas habilitar con el escalador automático administrado más adelante.

Agregar ajuste de escala automático administrado

También puedes crear instancias de la edición Enterprise y la edición 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 el ajustador de escala 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=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]

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=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]

Reemplaza lo siguiente:

  • INSTANCE-ID: Es un identificador permanente que es único dentro de tu Google Cloud proyecto. No podrás 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. En el caso de las configuraciones de instancias personalizadas, comienza con custom-. Para obtener más información, consulta configuraciones de instancias.
  • INSTANCE-DESCRIPTION: Es el nombre que se mostrará para la instancia en la consola de Google Cloud . El nombre de la instancia debe ser único en tu proyecto deGoogle Cloud .
  • MINIMUM_PROCESSING_UNITS y MINIMUM_NODES: Es la cantidad mínima de unidades de procesamiento o nodos cuando se reduce la escala. Para obtener más información, consulta Cómo determinar el límite mínimo.
  • MAXIMUM_PROCESSING_UNITS y MAXIMUM_NODES: Es la cantidad máxima de unidades de procesamiento o nodos cuando se aumenta la escala. Para obtener más información, consulta Cómo determinar el límite máximo.
  • CPU_PERCENTAGE: Es el porcentaje objetivo de CPU de alta prioridad que se usará, de un 10 a un 90%. Si optimizas tu campaña en función del costo, usa un porcentaje más alto. Para obtener más información, consulta Cómo determinar el objetivo de uso de CPU.
  • STORAGE_PERCENTAGE: Es el porcentaje objetivo de almacenamiento que se usará, del 10 al 99%. Para obtener más información, consulta Cómo determinar el objetivo de uso del almacenamiento.

Marcas opcionales:

  • --asymmetric-autoscaling-option: Usa esta marca para habilitar el escalado automático asimétrico. Reemplaza 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 deseas escalar de forma asimétrica.
    • ASYMMETRIC_AUTOSCALING_MIN: Parámetro opcional. Es la cantidad mínima de nodos cuando se reduce la escala.
    • ASYMMETRIC_AUTOSCALING_MAX: Parámetro opcional. Es la cantidad máxima de nodos cuando se realiza un ajuste de escala.
    • ASYMMETRIC_CPU_TARGET: Parámetro opcional. Es el porcentaje objetivo de CPU de prioridad alta que se usará, de un 10 a un 90%. Si optimizas en función del costo, 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 básica 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 personalizada de instancias multirregionales 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

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

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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

void CreateInstance(google::cloud::spanner_admin::InstanceAdminClient client,
                    std::string const& project_id,
                    std::string const& instance_id,
                    std::string const& display_name,
                    std::string const& config_id) {
  namespace spanner = ::google::cloud::spanner;
  spanner::Instance in(project_id, instance_id);

  auto project = google::cloud::Project(project_id);
  std::string config_name =
      project.FullName() + "/instanceConfigs/" + config_id;
  auto instance =
      client
          .CreateInstance(spanner::CreateInstanceRequestBuilder(in, config_name)
                              .SetDisplayName(display_name)
                              .SetNodeCount(1)
                              .SetLabels({{"cloud_spanner_samples", "true"}})
                              .Build())
          .get();
  if (!instance) throw std::move(instance).status();
  std::cout << "Created instance [" << in << "]:\n" << instance->DebugString();
}

C#

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

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


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Spanner.Admin.Instance.V1;
using Google.Cloud.Spanner.Common.V1;
using Google.LongRunning;
using System;
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 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 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"

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

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

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

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 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 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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

class CreateInstanceExample {

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

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

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

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

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

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

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

Crea 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 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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

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

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

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

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

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

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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

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

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

// 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 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 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

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

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

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

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

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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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

    spanner_client = spanner.Client()

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

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

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

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

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. Si deseas 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 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 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# 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

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

gcloud

Usa el comando gcloud spanner instances list:

gcloud spanner instances list

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

Actualiza la edición

Puedes actualizar tus instancias de la edición Estándar 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.

Console

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

    Ir a la página Instancias

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

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

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

  5. Haz clic en Guardar.

gcloud

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

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

Reemplaza lo siguiente:

Marcas opcionales:

  • --async: Usa esta marca si deseas que tu solicitud se muestre 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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

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

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

const instanceAdminClient = spanner.getInstanceAdminClient();

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

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

Python

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

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

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

    spanner_client = spanner.Client()

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

    operation = spanner_client.instance_admin_api.update_instance(
        instance=spanner_instance_admin.Instance(
            name=name,
            labels={
                "sample_name": "snippets-update_instance-explicit",
            },
            edition=spanner_instance_admin.Instance.Edition.ENTERPRISE,  # Optional
        ),
        field_mask=field_mask_pb2.FieldMask(paths=["labels", "edition"]),
    )

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

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

Cómo cambiar a una edición anterior

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 de nivel 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. La reversión de edición tarda aproximadamente 10 minutos en completarse sin tiempo de inactividad.

gcloud

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

gcloud spanner instances update INSTANCE_ID --edition=EDITION

Reemplaza lo siguiente:

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 dentro del proyectoGoogle 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 .

Cómo cambiar 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 valores máximos recomendados. Para obtener más información, consulta las cuotas y los límites de Spanner.

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

  • Quitar capacidad de procesamiento requiere que tu instancia almacene más de 10 TiB de datos por cada 1,000 unidades de procesamiento (1 nodo).
  • Según tus patrones de uso históricos, Spanner creó una gran cantidad de divisiones para los datos de tu instancia y, en algunos casos excepcionales, no podrá administrarlas después de quitar la capacidad de procesamiento.

En el último caso, puedes intentar reducir la capacidad de procesamiento en cantidades cada vez más pequeñas hasta que encuentres la capacidad mínima que Spanner necesita para administrar todas las divisiones de la instancia. Si la instancia ya no requiere tantas divisiones debido a un cambio en los patrones de uso, es posible que Spanner combine algunas divisiones y te permita intentar reducir aún más la capacidad de procesamiento de la instancia después de una o dos semanas.

Cuando quites capacidad de procesamiento, supervisa el uso de CPU y las latencias de solicitud en Cloud Monitoring para asegurarte de que el uso de CPU permanezca por debajo del 65% para las instancias regionales y del 45% para cada región en instancias multirregionales. Es posible que experimentes un aumento temporal en las latencias de solicitud 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 de su tamaño. En la mayoría de los casos, las solicitudes se completan en unos minutos. En ocasiones excepcionales, el aumento de escala puede tardar hasta una hora en completarse.

Console

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

    Ir a la página Instancias

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

  3. Haz clic en Editar instancia.

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

Marcas opcionales:

  • --async: Usa esta marca si deseas que tu solicitud se muestre de inmediato, sin esperar a que 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

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

  • El ajuste de escala automático administrado solo está disponible en la edición Enterprise o Enterprise Plus.
  • No puedes habilitar el ajustador de escala automático administrado en una instancia que estás trasladando.

  • No puedes mover una instancia mientras el ajustador de escala 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 ajuste de escala automático administrado.

  3. Haz clic en Editar instancia.

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

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

  6. En Máximo, selecciona el límite máximo que se usará cuando se aumente la escala. Para obtener más información, consulta Cómo determinar el límite máximo.

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

  8. En Objetivo de uso de almacenamiento, selecciona el porcentaje de almacenamiento que deseas usar. Para obtener más información, consulta Cómo determinar el objetivo de uso del almacenamiento.

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

    1. Selecciona la réplica de solo lectura que deseas escalar automáticamente de forma asimétrica.

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

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

  10. 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 Marcadores y limitaciones de Google Cloud CLI.

Puedes agregar el ajuste de escala 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=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]

o

  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]

Reemplaza lo siguiente:

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

Marcas opcionales:

  • --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. Ubicación de la región de solo lectura que deseas escalar de forma asimétrica.
    • ASYMMETRIC_AUTOSCALING_MIN: Parámetro opcional. Es la cantidad mínima de nodos cuando se reduce la escala.
    • ASYMMETRIC_AUTOSCALING_MAX: Parámetro opcional. Es la cantidad máxima de nodos cuando se realiza un ajuste de escala.
    • ASYMMETRIC_CPU_TARGET: Parámetro opcional. Es el porcentaje objetivo de CPU de prioridad alta que se usará, de un 10 a un 90%. Si optimizas en función del costo, usa un porcentaje más alto.

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

Cómo cambiar una instancia del uso del escalador automático administrado al ajuste de escala manual

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 ajuste de escala, 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 del uso del ajustador de escala automático administrado al ajuste de escala 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 cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000, etcétera).

Etiqueta una instancia

Etiquetas para organizar tus recursos.

Console

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

    Ir a la página Instancias

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

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

Cómo editar el tipo de programación de copias de seguridad predeterminado

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

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 cuya programación de copias de seguridad predeterminada deseas editar.

  3. Haz clic en Editar instancia.

  4. 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 esta opción, todas las bases de datos nuevas de esta instancia tienen una programación de copias de seguridad predeterminada creada.

  5. Haz clic en Guardar.

gcloud

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

Puedes editar el tipo de programa de copia de seguridad predeterminado ejecutando 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 programación de copia de seguridad predeterminado que se usa en la instancia. Debe ser uno de los siguientes valores:

    • AUTOMATIC: Se crea automáticamente una programación de copia de seguridad predeterminada cuando se crea una base de datos nueva en la instancia. La programación predeterminada de copias de seguridad 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 una programación de copias de seguridad predeterminada 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. Si deseas 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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"

	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
	"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. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;
import com.google.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. Si deseas 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. Si deseas 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

Si deseas obtener instrucciones para mover tu instancia de cualquier configuración de instancia a cualquier otra, incluidas las configuraciones regionales y multirregionales, consulta Cómo mover una instancia.

Borrar una instancia

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

Si deseas borrar una instancia que tiene una o más 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 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 los procesos de supervisión y reinicio cuando es necesario, sin tiempo de inactividad. Como no es necesario detener o reiniciar manualmente una instancia determinada, Spanner no ofrece una forma de hacerlo.

¿Qué sigue?