Obtén, enumera y borra plantillas de instancias

En esta página, se describe cómo obtener, enumerar y borrar plantillas de instancias.

Antes de comenzar

  • Configura la autenticación si aún no lo hiciste. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine de la siguiente manera.

    Selecciona la pestaña para saber cómo planeas usar las muestras en esta página:

    Consola

    Cuando usas la consola de Google Cloud para acceder a los servicios y las APIs de Google Cloud, no necesitas configurar la autenticación.

    gcloud

    1. Instala Google Cloud CLI y, luego, inicializa la ejecución del siguiente comando: 

      gcloud init
    2. Configura una región y una zona predeterminadas.

    Go

    Para usar las muestras de Go de esta página desde un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

    1. Instala Google Cloud CLI.

    2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

      gcloud init

    3. Crea credenciales de autenticación locales para tu Cuenta de Google: 

      gcloud auth application-default login

    Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Java

    Para usar las muestras de Java de esta página desde un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

    1. Instala Google Cloud CLI.

    2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

      gcloud init

    3. Crea credenciales de autenticación locales para tu Cuenta de Google: 

      gcloud auth application-default login

    Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Node.js

    Para usar las muestras de Node.js de esta página desde un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

    1. Instala Google Cloud CLI.

    2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

      gcloud init

    3. Crea credenciales de autenticación locales para tu Cuenta de Google: 

      gcloud auth application-default login

    Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    Python

    Para usar las muestras de Python de esta página desde un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

    1. Instala Google Cloud CLI.

    2. Para inicializar la CLI de gcloud, ejecuta el siguiente comando: 

      gcloud init

    3. Crea credenciales de autenticación locales para tu Cuenta de Google: 

      gcloud auth application-default login

    Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

    REST

    Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporcionas a la CLI de gcloud.

      Instala Google Cloud CLI y, luego, inicializa la ejecución del siguiente comando: 

      gcloud init

Obtén información de una plantilla de instancias

Console

  1. En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a la página Plantillas de instancias

  2. Haz clic en el nombre de la plantilla de instancias para ver los detalles de la plantilla.

gcloud

Para obtener información sobre una plantilla de instancias regional o global, usa instance-templates describe command.

Para una plantilla de instancias regional, usa el siguiente comando:

gcloud compute instance-templates describe INSTANCE_TEMPLATE_NAME \
    --region=REGION

Para una plantilla de instancias global, usa el siguiente comando:

gcloud compute instance-templates describe INSTANCE_TEMPLATE_NAME

Go

compute/instance-templates/create-instance-templates/get_instance_template.go 
import (
	"context"
	"fmt"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// getInstanceTemplate retrieves an instance template, which you can use to create virtual machine
// (VM) instances and managed instance groups (MIGs).
func getInstanceTemplate(projectID, templateName string) (*computepb.InstanceTemplate, error) {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.GetInstanceTemplateRequest{
		Project:          projectID,
		InstanceTemplate: templateName,
	}

	return instanceTemplatesClient.Get(ctx, req)
}

Java

compute/cloud-client/src/main/java/compute/GetInstanceTemplate.java 

import com.google.cloud.compute.v1.GetInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import java.io.IOException;

public class GetInstanceTemplate {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // templateName: name of the template to retrieve.
    String projectId = "your-project-id";
    String templateName = "template-name";
    getInstanceTemplate(projectId, templateName);
  }

  //  Retrieve an instance template, which you can use to create virtual machine
  //  (VM) instances and managed instance groups (MIGs).
  public static void getInstanceTemplate(String projectId, String templateName) throws IOException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      GetInstanceTemplateRequest getInstanceTemplateRequest = GetInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplate(templateName).build();

      InstanceTemplate instanceTemplate = instanceTemplatesClient.get(getInstanceTemplateRequest);
      System.out.println("Instance Template retrieved: " + instanceTemplate.getName());
    }
  }
}

Node.js

compute/create-instance-templates/getInstanceTemplate.js 
/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const templateName = 'your_template_name';

const compute = require('@google-cloud/compute');

// Retrieve an instance template, which you can use to create
// virtual machine (VM) instances and managed instance groups (MIGs).
async function getInstanceTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [instance] = await instanceTemplatesClient.get({
    project: projectId,
    instanceTemplate: templateName,
  });

  console.log('Instance template:', instance);
}

getInstanceTemplate();

Python

compute/client_library/snippets/instance_templates/get.py 
from google.cloud import compute_v1

def get_instance_template(
    project_id: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Retrieve an instance template, which you can use to create virtual machine
    (VM) instances and managed instance groups (MIGs).

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the template to retrieve.

    Returns:
        InstanceTemplate object that represents the retrieved template.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    return template_client.get(project=project_id, instance_template=template_name)

REST

Para obtener información sobre una plantilla de instancias regional, usa el método regionInstanceTemplates.get de la siguiente manera:

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME

Para obtener información sobre una plantilla de instancias global, usa instanceTemplates.get de la siguiente manera:

GET https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/instanceTemplates/[INSTANCE_TEMPLATE]

Mostrar lista de plantillas de instancias

Para obtener una lista de las plantillas de instancias que creaste, sigue estos pasos:

Console

En la página Plantillas de instancias, se enumeran todas las plantillas de instancias en tu proyecto.

Ir a la página Plantillas de instancias

gcloud

Para obtener una lista de todas las plantillas de instancias regionales, usa el siguiente comando:

gcloud compute instance-templates list \
    --regions

Para obtener una lista de plantillas de instancias regionales en una región específica, usa el siguiente comando:

gcloud compute instance-templates list \
    --filter="region:(REGION)"

Para obtener una lista de plantillas de instancias globales, usa el siguiente comando:

gcloud compute instance-templates list \
    --global

Para obtener una lista de todas las plantillas de instancias, incluidas las regionales y las globales, usa el siguiente comando:

gcloud compute instance-templates list

Go

compute/instance-templates/create-instance-templates/list_instance_templates.go 
import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"google.golang.org/api/iterator"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// listInstanceTemplates prints a list of InstanceTemplate objects available in a project.
func listInstanceTemplates(w io.Writer, projectID string) error {
	// projectID := "your_project_id"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.ListInstanceTemplatesRequest{
		Project: projectID,
	}

	it := instanceTemplatesClient.List(ctx, req)
	for {
		instance, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s %s\n", instance.GetName(), instance.GetProperties().GetMachineType())
	}

	return nil
}

Java

compute/cloud-client/src/main/java/compute/ListInstanceTemplates.java 

import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.InstanceTemplatesClient.ListPagedResponse;
import java.io.IOException;

public class ListInstanceTemplates {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    String projectId = "your-project-id";
    listInstanceTemplates(projectId);
  }

  // Get a list of InstanceTemplate objects available in a project.
  public static ListPagedResponse listInstanceTemplates(String projectId) throws IOException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      int count = 0;
      System.out.println("Listing instance templates...");
      ListPagedResponse templates = instanceTemplatesClient.list(projectId);
      for (InstanceTemplate instanceTemplate : templates.iterateAll()) {
        System.out.printf("%s. %s%n", ++count, instanceTemplate.getName());
      }
      return templates;
    }
  }
}

Node.js

compute/create-instance-templates/listInstanceTemplates.js 
/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';

const compute = require('@google-cloud/compute');

// Print a list of instance template objects available in a project.
async function listInstanceTemplates() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const instanceTemplates = instanceTemplatesClient.listAsync({
    project: projectId,
  });

  for await (const instanceTemplate of instanceTemplates) {
    console.log(` - ${instanceTemplate.name}`);
  }
}

listInstanceTemplates();

Python

compute/client_library/snippets/instance_templates/list.py 
from __future__ import annotations

from collections.abc import Iterable

from google.cloud import compute_v1

def list_instance_templates(project_id: str) -> Iterable[compute_v1.InstanceTemplate]:
    """
    Get a list of InstanceTemplate objects available in a project.

    Args:
        project_id: project ID or project number of the Cloud project you use.

    Returns:
        Iterable list of InstanceTemplate objects.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    return template_client.list(project=project_id)

REST

Para obtener una lista de las plantillas de instancias regionales, realiza una solicitud regionInstanceTemplates.list:

GET https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/instanceTemplates

Para obtener una lista de las plantillas de instancias globales, realiza una solicitud instanceTemplates.list:

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

Borrar una plantilla de instancias

Si borras una plantilla de instancias, se quita de tu lista de plantillas. No puedes borrar una plantilla de instancias si un grupo de instancias administrado hace referencia a ella.

Console

  1. En la consola de Google Cloud, ve a la página Plantillas de instancia.

    Ir a la página Plantillas de instancias

  2. Selecciona las plantillas de instancias que quieres borrar.
  3. Haz clic en Borrar.

gcloud

Con Google Cloud CLI, ejecuta lo siguiente:

gcloud compute instance-templates delete INSTANCE_TEMPLATE_NAME

Para una plantilla de instancias regional, INSTANCE_TEMPLATE_NAME debe contener la URL completa de la plantilla. Por ejemplo, https://www.googleapis.com/compute/v1/projects/example-project/regions/us-central1/instanceTemplates/example-regional-instance-template

Go

compute/instance-templates/create-instance-templates/delete_instance_template.go 
import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// deleteInstanceTemplate deletes an instance template.
func deleteInstanceTemplate(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.DeleteInstanceTemplateRequest{
		Project:          projectID,
		InstanceTemplate: templateName,
	}

	op, err := instanceTemplatesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete instance template: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance template deleted\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/DeleteInstanceTemplate.java 

import com.google.cloud.compute.v1.DeleteInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteInstanceTemplate {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    deleteInstanceTemplate(projectId, templateName);
  }

  // Delete an instance template.
  public static void deleteInstanceTemplate(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      DeleteInstanceTemplateRequest deleteInstanceTemplateRequest = DeleteInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplate(templateName).build();

      Operation response = instanceTemplatesClient.deleteAsync(deleteInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance template deletion failed ! ! " + response);
        return;
      }
      System.out.printf("Instance template deletion operation status for %s: %s ", templateName,
          response.getStatus());
    }
  }
}

Node.js

compute/create-instance-templates/deleteInstanceTemplate.js 
/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const templateName = 'your_template_name';

const compute = require('@google-cloud/compute');

// Delete an instance template.
async function deleteInstanceTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.delete({
    project: projectId,
    instanceTemplate: templateName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

  // Wait for the create operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
    });
  }

  console.log('Instance template deleted.');
}

deleteInstanceTemplate();

Python

compute/client_library/snippets/instance_templates/delete.py 
from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def delete_instance_template(project_id: str, template_name: str) -> None:
    """
    Delete an instance template.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the template to delete.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.delete(
        project=project_id, instance_template=template_name
    )
    wait_for_extended_operation(operation, "instance template deletion")

REST

Para borrar una plantilla de instancias regional, realiza una solicitud regionInstanceTemplates.delete:

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME

Para borrar una plantilla de instancias global, realiza una solicitud instanceTemplates.delete:

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/INSTANCE_TEMPLATE_NAME

A veces, las VMs en un grupo de instancias administrado pueden estar fuera de sincronización con el resto del grupo y usar una plantilla de instancias diferente que el resto del grupo. Si una VM en un grupo de instancias administrado usa una plantilla diferente a la especificada en el grupo, esa VM continuará con el uso de su plantilla para la reparación, incluso si esa plantilla se borra. Para obtener más información sobre cómo aplicar una plantilla de instancias nueva, consulta Aplica una configuración nueva a las VMs en un MIG.