Crea y administra instancias

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

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

Crea una instancia

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

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

Console

1. Ve a la página Crea una instancia en la consola de Google Cloud.

   Crea una instancia

2. Ingresa un Nombre de instancia para mostrar en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.

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

4. En la sección Asignar capacidad de procesamiento, en Elige una configuración, selecciona Regional o Multirregional. Como alternativa, si quieres comparar las especificaciones entre dos regiones, haz clic en Comparar configuraciones de las regiones.

5. Selecciona una configuración del menú desplegable.

6. Opcional: Para agregar una réplica de solo lectura a una configuración base de Spanner, primero debes crear una configuración de instancia personalizada con Google Cloud CLI.

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

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

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

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

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

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

   • Ajuste de escala automático (Vista previa), para permitir que Spanner agregue y quite capacidad de procesamiento de forma automática. 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:

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

9. 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 quieres usar en la instancia.

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

o

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

Reemplaza lo siguiente:

• INSTANCE-ID: Es un identificador permanente que es único dentro de tu proyecto de Google Cloud. No puedes cambiar el ID de la instancia más tarde.
• INSTANCE-CONFIG: Un identificador permanente de la configuración de tu instancia, que define la ubicación geográfica de la instancia y afecta la forma en que se replican los datos. Para la configuración de instancias personalizadas, comienza con custom-. Para obtener más información, consulta Configuraciones de instancias.
• INSTANCE-DESCRIPTION: Es el nombre que se mostrará para la instancia en la consola de Google Cloud. El nombre de la instancia debe ser único en tu proyecto de Google Cloud.

• NODE-COUNT: 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: La capacidad de procesamiento de la instancia, expresada como una cantidad de unidades de procesamiento. Ingresa cantidades hasta 1,000 en múltiplos de 100 (100, 200, 300 y así sucesivamente) e ingresa cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000 y así sucesivamente). Nota: No uses este parámetro si creas una instancia que quieras habilitar con el escalador automático administrado más adelante.

Agrega el ajuste de escala automático administrado (vista previa)

También puedes configurar instancias nuevas para que usen el ajuste de escala automático administrado con el comando gcloud beta spanner instances create. Si deseas obtener más información, consulta Escalador automático administrado para Spanner.

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

  gcloud beta spanner instances create INSTANCE-ID \
    --config=INSTANCE-CONFIG \
    --description=INSTANCE-DESCRIPTION \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

o

  gcloud beta spanner instances create INSTANCE-ID \
    --config=INSTANCE-CONFIG \
    --description=INSTANCE-DESCRIPTION \
    --autoscaling-min-nodes=MINIMUM_NODES \
    --autoscaling-max-nodes=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Reemplaza lo siguiente:

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

Ejemplos para usar configuraciones personalizadas

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

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

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

Luego, ejecuta lo siguiente:

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

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

Creating instance...done.

C++

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

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

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

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

C#

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

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

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

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

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

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

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

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

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

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

        return completedResponse.Result;
    }
}

Go

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java

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

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

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

class CreateInstanceExample {

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

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

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

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

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

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

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

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

class CreateInstanceWithAutoscalingConfigExample {

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

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

      // Create an autoscaling config.
      // When autoscaling_config is enabled, node_count and processing_units fields
      // need not be specified.
      AutoscalingConfig autoscalingConfig =
          AutoscalingConfig.newBuilder()
              .setAutoscalingLimits(
                  AutoscalingConfig.AutoscalingLimits.newBuilder().setMinNodes(1).setMaxNodes(2))
              .setAutoscalingTargets(
                  AutoscalingConfig.AutoscalingTargets.newBuilder()
                      .setHighPriorityCpuUtilizationPercent(65)
                      .setStorageUtilizationPercent(95))
              .build();
      Instance instance =
          Instance.newBuilder()
              .setAutoscalingConfig(autoscalingConfig)
              .setDisplayName(displayName)
              .setConfig(
                  InstanceConfigName.of(projectId, configId).toString())
              .build();

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

Node.js

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

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

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

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

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

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

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

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

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

PHP

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

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

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

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

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

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

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

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

Python

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

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

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

    spanner_client = spanner.Client()

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

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

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

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

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

Rita

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

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

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"

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

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

project_path = instance_admin_client.project_path project: project_id
instance_path = instance_admin_client.instance_path project: project_id, instance: instance_id
instance_config_path = instance_admin_client.instance_config_path project: project_id, instance_config: "regional-us-central1"

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

puts "Waiting for create instance operation to complete"

job.wait_until_done!

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

Mostrar lista de instancias

Puedes mostrar una lista de tus instancias de Spanner.

Console

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

Ir a la página Instancias

En la consola de Google Cloud, se muestra una lista de las instancias de Spanner, junto con el ID, el nombre visible, la configuración y la capacidad de procesamiento de cada instancia, expresados 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 cambiar el nombre visible y la capacidad de procesamiento de una instancia. No puedes cambiar el ID ni la configuración de la instancia.

Cómo cambiar el nombre visible

Console

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

   Ir a la página Instancias

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

3. Haz clic en Editar instancia.

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

5. Haz clic en Guardar.

gcloud

Usa el comando gcloud spanner instances update:

gcloud spanner instances update INSTANCE-ID --description=INSTANCE-NAME

Reemplaza lo siguiente:

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

Cambia la capacidad de procesamiento

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

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

• Quitar la capacidad de procesamiento requeriría que la instancia almacene más de 4 TB de datos por cada 1,000 unidades de procesamiento (1 nodo).
• En función de tus patrones de uso históricos, Spanner creó una gran cantidad de divisiones para los datos de la instancia y, en algunos casos excepcionales, Spanner no podría administrar las divisiones después de quitar la capacidad de procesamiento.

En el último caso, puedes intentar reducir la capacidad de procesamiento a cantidades cada vez más pequeñas hasta encontrar la capacidad mínima que Spanner necesita para administrar todas las divisiones de la instancia. Si la instancia ya no requiere tantas divisiones debido a un cambio en los patrones de uso, Spanner podría combinar algunas divisiones y permitirte 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 solicitudes en Cloud Monitoring para asegurarte de que el uso de CPU se mantenga por debajo del 65% en las instancias regionales y del 45% para cada región en las instancias multirregionales. Es posible que experimentes un aumento temporal en la latencia de las solicitudes mientras quitas la capacidad de procesamiento.

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

Console

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

   Ir a la página Instancias

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

3. Haz clic en Editar instancia.

4. Para cambiar la capacidad de procesamiento, elige las unidades de medición (unidades de procesamiento o nodos) y, luego, ingresa una cantidad. Cuando uses unidades de procesamiento, ingresa cantidades hasta 1,000 en múltiplos de 100 (100, 200, 300, etc.) e ingresa cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000 y así sucesivamente). 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: El identificador permanente de la instancia.
• NODE-COUNT: 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: La capacidad de procesamiento de la instancia, expresada como una cantidad de unidades de procesamiento. Ingresa cantidades hasta 1,000 en múltiplos de 100 (100, 200, 300 y así sucesivamente) e ingresa cantidades mayores en múltiplos de 1,000 (1,000, 2,000, 3,000 y así sucesivamente).

Marcas opcionales:

• --async: Usa esta marca si quieres 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

Vista previa — Managed autoscaler

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

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

• No puedes habilitar el escalador automático administrado en una instancia que estás moviendo.

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

Console

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

   Ir a la página Instancias

2. Haz clic en el nombre de la instancia en la que deseas habilitar el escalador automático administrado.

3. Haz clic en Editar instancia.

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

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

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

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

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

9. Haz clic en Guardar.

gcloud

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

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

  gcloud beta spanner instances update \
    --autoscaling-min-processing-units=MINIMUM_PROCESSING_UNITS \
    --autoscaling-max-processing-units=MAXIMUM_PROCESSING_UNITS \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

o

  gcloud beta spanner instances update \
    --autoscaling-min-processing-units=MINIMUM_NODES \
    --autoscaling-max-processing-units=MAXIMUM_NODES \
    --autoscaling-high-priority-cpu-target=CPU_PERCENTAGE \
    --autoscaling-storage-target=STORAGE_PERCENTAGE

Reemplaza lo siguiente:

• MINIMUM_PROCESSING_UNITS, MINIMUM_NODES: Es la cantidad mínima de nodos o unidades de procesamiento que se usarán cuando se reduzca la escala. Para obtener más información, consulta Determina el límite mínimo.
• MAXIMUM_PROCESSING_UNITS, MAXIMUM_NODES: La cantidad máxima de nodos o unidades de procesamiento que se usarán cuando se escala verticalmente Para obtener más información, consulta Determina el límite máximo.
• CPU_PERCENTAGE: Es el porcentaje objetivo de la CPU de alta prioridad que se usará, del 10% al 90%. Si quieres optimizar el costo y no necesitas una latencia baja en todas las solicitudes, usa un porcentaje más alto. Para obtener más información, consulta Determina el objetivo de uso de CPU.
• STORAGE_PERCENTAGE: Es el porcentaje objetivo de almacenamiento que se usará, del 10% al 99%. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

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

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

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

Vista previa — Managed autoscaling

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

Console

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

   Ir a la página Instancias

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

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

4. Haz clic en Guardar.

gcloud

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

Usa el siguiente comando para cambiar una instancia del escalador automático administrado al ajuste de escala manual:

  gcloud beta spanner instances update \
  --processing-units=PROCESSING-UNITS-COUNT

o

  gcloud beta spanner instances update \
  --nodes=NODE-COUNT

Reemplaza PROCESSING-UNIT-COUNT o NODE-COUNT por la cantidad de nodos o unidades de procesamiento que quieres usar en la instancia.

Etiqueta una instancia

Las etiquetas ayudan a 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 del panel de información. Luego, puedes agregar, borrar o actualizar las etiquetas de la instancia de Spanner.

Cómo mover una instancia

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

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

Borrar una instancia

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

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

Si 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 borrar la instancia.

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 propios recursos y tareas subyacentes, incluida la supervisión y el reinicio de procesos cuando es necesario sin tiempo de inactividad. Como no es necesario detener o reiniciar una instancia determinada de forma manual, Spanner no ofrece una manera de hacerlo.

¿Qué sigue?

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