Crea y administra instancias

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

Nota: Para explorar Spanner con una instancia de prueba gratuita de 90 días, ver 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 bibliotecas cliente. También puedes crear con una configuración de instancias personalizada agregando réplicas de solo lectura opcionales.

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

Console

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

   Crea la 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 El ID de la instancia también debe ser único dentro de tu proyecto de Google Cloud. No puedes cambiar el ID de la instancia más tarde.

4. Haga clic en Continuar.

5. En la sección Configura tu instancia, en Elige una configuración, selecciona Regional, Birregional o Multirregión. Como alternativa, si quieres comparar entre las tres configuraciones y, luego, haz clic Compara los parámetros de configuración de las regiones.

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

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

8. Haga clic en Continuar.

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

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

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

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

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

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

    • Ajuste de escala automático (vista previa), para permitir que Spanner agregue y quite automáticamente recursos la capacidad de procesamiento. Para obtener más información sobre el escalador automático administrado ver Escalador automático administrado para Spanner. Configura las siguientes opciones de 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 Compute. capacidad. Para obtener más información, consulta Determina el límite mínimo.
      • Máximo indica el límite máximo para escalar verticalmente. según la unidad de medida que elijas para Compute. capacidad. Para obtener más información, consulta Determina el límite máximo.
      • El objetivo de uso de CPU de alta prioridad indica y el porcentaje 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 para usar. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

11. Haz clic en Crear para crear la instancia.

gcloud

Usa la gcloud spanner instances create. para crear una instancia. Especifica la capacidad de procesamiento. o unidades de procesamiento que quieres 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: Es un identificador permanente de tu instancia. actual, que define la ubicación geográfica de la instancia y afecta cómo se replican los datos. Para las configuraciones de instancias personalizadas, comienza con custom-. Para obtener más información, consulta instancias parámetros de configuración.
• INSTANCE-DESCRIPTION: Es el nombre que se mostrará para la instancia en el 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 un número de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.

• PROCESSING-UNIT-COUNT: La capacidad de procesamiento de la instancia. expresada como un número de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etc.) e ingresa mayor cantidades en múltiplos de 1000 (1000, 2000, 3000, etc.). Nota: No uses este parámetro si creas una instancia en la que deseas 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 usar el ajuste de escala automático administrado con el gcloud beta spanner instances create kubectl. Para obtener más información, consulta Escalador automático administrado para Spanner.

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

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

Ejemplos para usar configuraciones personalizadas

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

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

Para crear una instancia custom-eur6-instance en la multirregión personalizada, sigue estos pasos: configuración de instancia custom-eur6, primero crear una configuración de instancias 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 la ejecución 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
}

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java

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

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

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

class CreateInstanceExample {

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

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

    // Create an Instance object that will be used to create the instance.
    Instance instance =
        Instance.newBuilder()
            .setDisplayName(displayName)
            .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:

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

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

class CreateInstanceWithAutoscalingConfigExample {

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

  static void createInstance(String projectId, String instanceId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .build()
            .getService();
        InstanceAdminClient instanceAdminClient = spanner.createInstanceAdminClient()) {
      // Set Instance configuration.
      String configId = "regional-us-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 la biblioteca cliente anterior para Node.js se archivan en GitHub:

PHP

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

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

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

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

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

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

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

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

Python

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

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

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

    spanner_client = spanner.Client()

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

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

    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:

Ruby

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

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

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

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

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

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

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

puts "Waiting for create instance operation to complete"

job.wait_until_done!

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

Mostrar lista de instancias

Puedes mostrar una lista de tus instancias de Spanner.

Console

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

Ir a la página Instancias

En la consola de Google Cloud, se muestra una lista de tus instancias junto con el ID, el nombre visible, la configuración y capacidad de procesamiento 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 junto con el ID, el nombre visible, la configuración y la capacidad de procesamiento.

Editar una instancia

En las siguientes secciones, se explica cómo cambiar el nombre visible de una instancia y la capacidad de procesamiento. 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: Es el identificador permanente de la instancia.
• INSTANCE_NAME: Es el nombre que se mostrará para la instancia en el Consola de Google Cloud El nombre de la instancia debe ser único en tu proyecto de Google Cloud.

Cambia la capacidad de procesamiento

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

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

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

En este último caso, intenta reducir la capacidad de procesamiento de manera progresiva cantidades más pequeñas hasta que encuentres la capacidad mínima que necesita 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 finalmente combinar algunas divisiones y permitirte intentar reducir la capacidad de procesamiento de la instancia después de una o dos semanas.

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

Si quieres aumentar la capacidad de procesamiento de una instancia, El proyecto de Google Cloud debe tener una cuota suficiente para agregar el procesamiento la capacidad de procesamiento. El tiempo que demore en completarse la solicitud de aumento depende del el tamaño de la solicitud. En la mayoría de los casos, las solicitudes se completan en pocos minutos. Activada en muy pocas ocasiones, el 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. Elige las unidades de medida para cambiar la capacidad de procesamiento (unidades de procesamiento o nodos) y, luego, ingresa una cantidad. Al usar unidades de procesamiento, ingrese cantidades hasta 1000 en múltiplos de 100 (100, 200, 300, etc.) e ingresar cantidades mayores en múltiplos de 1000 (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 la cantidad de nodos o unidades de procesamiento.

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

o

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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• NODE_COUNT: La capacidad de procesamiento de la instancia, expresada como cantidad de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.
• PROCESSING_UNIT_COUNT: La capacidad de procesamiento de la instancia. expresada como un número de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etc.) e ingresa mayor cantidades en múltiplos de 1000 (1000, 2000, 3000, etc.).

Marcas opcionales:

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

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

Vista previa — Managed autoscaler

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

Las siguientes limitaciones se aplican cuando agregas o cambias el 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 quieres habilitar escalador automático.

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 verticalmente. Para obtener más información, consulta Determina el límite mínimo.

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

7. En Objetivo de uso de CPU de alta prioridad, selecciona el porcentaje de de alta prioridad para 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á usar. Para obtener más información, consulta Determina el objetivo de uso de almacenamiento.

9. Haz clic en Guardar.

gcloud

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

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

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

o

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

Reemplaza lo siguiente:

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

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

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

Cambia una instancia de uso del 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 que quieres inhabilitar escalador automático.

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

4. Haz clic en Guardar.

gcloud

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

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

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

o

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

Reemplaza lo siguiente:

• INSTANCE_ID: Es el identificador permanente de la instancia.
• NODE_COUNT: La capacidad de procesamiento de la instancia, expresada como un número de nodos. Cada nodo equivale a 1,000 unidades de procesamiento.
• PROCESSING_UNIT_COUNT: La capacidad de procesamiento de la instancia. expresada como un número de unidades de procesamiento. Ingresa cantidades de hasta 1,000 en múltiplos de 100 (100, 200, 300, etc.) e ingresa mayor cantidades en múltiplos de 1000 (1000, 2000, 3000, etc.).

Etiqueta una instancia

Etiquetas para organizar tus recursos.

Console

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

   Ir a la página Instancias

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

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

Traslada una instancia

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

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

Borra una instancia

Advertencia: Si borras una instancia, esta y todas sus bases de datos. No puedes deshacer esta acción más adelante. Además, no puedes crear otro instancia de prueba gratuita una vez que hayas borrado tu primera instancia de prueba gratuita. Tú Puedes crear una instancia de prueba gratuita por ciclo de vida de proyecto.

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

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

Console

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

   Ir a la página Instancias

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

3. Haz clic en Borrar instancia.

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

5. Haz clic en Borrar.

gcloud

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

gcloud spanner instances delete INSTANCE-ID

Detén o reinicia una instancia

Spanner es un servicio de base de datos completamente administrado que supervisa sus propias tareas y recursos subyacentes, incluida la supervisión y el reinicio y procesos cuando sea necesario sin tiempo de inactividad. Como no hay necesidad de modificar detener o reiniciar una instancia determinada, Spanner no ofrece hazlo.

¿Qué sigue?

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