Crea plantillas de instancias

---

En esta página, se describe cómo crear y administrar plantillas de instancias. Las plantillas de instancias te permiten especificar el tipo de máquina, la imagen de disco de arranque, la red y otras propiedades de VM que se recomienda usar cuando creas instancias de máquinas virtuales (VM).

Puedes usar plantillas de instancias para hacer lo siguiente:

• Crear VMs individuales.
• Crear VMs de backend en un grupo de instancias administrado (MIG).
• Crear reservas para las VMs.
• Crear reservas futuras para las VMs.

Antes de comenzar

• Lee cuándo y por qué crear plantillas de instancias deterministas.
• Lee sobre las plantillas de instancias regionales y globales.
• Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las APIs de Google Cloud . Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:
  

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. Install the Google Cloud CLI, then initialize it by running the following command:

     gcloud init

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Terraform

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

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Go

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

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Java

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

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Node.js

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

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Para obtener más información, consulta Set up authentication for a local development environment.

  Python

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

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Para obtener más información, consulta Set up authentication for a local development environment.

  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.

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

  Para obtener más información, consulta Autentica para usar REST en la documentación de autenticación de Google Cloud .

Limitaciones

• La VPC compartida en interfaces que no sean nic0 para las plantillas de instancias es compatible con gcloud CLI y REST, pero no con la consola de Google Cloud.
• No puedes actualizar una plantilla de instancias existente ni modificar una plantilla de instancias después de crearla. Si una plantilla de instancias caduca o si necesitas aplicar cambios en la configuración, debes crear una plantilla de instancias nueva.
• Si deseas especificar una familia de imágenes en una plantilla de instancias, no puedes usar la consola de Google Cloud. En su lugar, puedes usar Google Cloud CLI o REST.
• Si deseas especificar discos regionales en lugar de discos zonales en una plantilla de instancias, no puedes usar la consola de Google Cloud. En su lugar, puedes usar Google Cloud CLI o REST.
• Puedes usar una plantilla de instancia para crear VMs con un disco de arranque Hyperdisk Balanced que esté en un grupo de almacenamiento, si el grupo de almacenamiento existe en la misma zona en la que se creó la VM. No puedes usar plantillas de instancias globales para crear VMs con discos que no sean de inicio que se encuentran en un grupo de almacenamiento.

Crea una plantilla de instancias

La mayoría de las propiedades de VM que puedes especificar en una solicitud para crear una instancia de VM individual también se pueden especificar en una plantilla de instancias, incluidos los metadatos de VM, las secuencias de comandos de inicio, los discos persistentes y las cuentas de servicio. Debes especificar el tipo de máquina, el disco de arranque y la red.

Crea una plantilla de instancias regional o global a través de la consola de Google Cloud, Google Cloud CLI o la API. Para crear una plantilla de instancias global, también puedes usar Terraform o las bibliotecas cliente de Cloud.

Permisos necesarios para esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

• Todos los permisos necesarios para llamar al método instanceTemplates.insert

Console

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

   Ir a Plantillas de instancia

   Los pasos restantes aparecen en la consola de Google Cloud.

2. Haz clic en Crear plantilla de instancias.
3. Selecciona la ubicación de la siguiente manera:
1. Si deseas usar la plantilla de instancias entre regiones, elige Global.
2. Si deseas reducir la dependencia entre regiones, elige Regional.
4. Si eliges regional, selecciona la región en la que deseas crear tu plantilla de instancias.

5. En los siguientes campos, acepta los valores predeterminados o modifícalos según sea necesario. Los valores predeterminados cambian según la familia de máquinas que selecciones.

   • Selecciona un tipo de máquina.
   • Para actualizar el tipo o la imagen de disco de arranque, en la sección Disco de arranque, haz clic en Cambiar.
   • Para actualizar la configuración de la interfaz de red o de la dirección IP, haz clic en Opciones avanzadas, luego, en Herramientas de redes y, por último, en la interfaz de red que deseas editar.

6. Opcional: Si eliges una imagen que admite una VM protegida, cambia la configuración de VM protegida de la VM:

   1. Haz clic en Opciones avanzadas y, luego, en la pestaña Seguridad.
   2. Si quieres inhabilitar el Inicio seguro, desmarca la casilla de verificación Activar inicio seguro. El Inicio seguro ayuda a proteger las instancias de VM del software malicioso y los rootkits a nivel de inicio y kernel. Para obtener más información, consulta Inicio seguro.

   3. Si quieres inhabilitar el módulo de plataforma segura virtual (vTPM), desmarca la casilla de verificación Activar vTPM. El vTPM habilita el inicio medido, que valida la integridad previa al inicio y la integridad de inicio de la VM. Para obtener más información, consulta Módulo de plataforma segura virtual (vTPM).

      Importante: Si inhabilitas el vTPM, también se inhabilita la supervisión de integridad, ya que esta se basa en los datos recopilados por el inicio medido.

   4. Si quieres inhabilitar la supervisión de integridad, desmarca la casilla de verificación Activar supervisión de integridad. La supervisión de integridad te permite supervisar la integridad del arranque de las instancias de VM protegida con Cloud Monitoring. Para obtener más información, consulta Supervisión de integridad.

7. Opcional: En Opciones avanzadas, haz clic en las pestañas para personalizar aún más tu plantilla. Por ejemplo, puedes agregar hasta 15 discos secundarios que no sean de arranque.

8. Opcional: Haz clic en REST equivalente para ver el cuerpo de la solicitud REST, que incluye la representación JSON de tu plantilla de instancias.

9. Haz clic en Crear para crear la plantilla.

gcloud

Para crear una plantilla de instancias regional o global, usa el comando instance-templates create. Para una plantilla de instancias regional, debes usar la marca --instance-template-region para configurar la región de la plantilla.

Crea una plantilla de instancias regional con el siguiente comando.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --instance-template-region=REGION

Reemplaza REGION por la región en la que deseas crear la plantilla de instancias regional.

Crea una plantilla de instancias global con el siguiente comando:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Si no proporcionas una configuración de plantilla explícita, gcloud compute usa los siguientes valores predeterminados:

• Tipo de máquina: el tipo de máquina, por ejemplo, n1-standard-1.
• Imagen: la última imagen de Debian
• Disco de arranque: un nuevo disco de arranque estándar con el nombre de la VM
• Red: la red de VPC predeterminada
• Dirección IP: una dirección IPv4 externa efímera
• Tipo de pila: IPV4_ONLY

También puedes proporcionar de manera explícita estos ajustes de configuración. Por ejemplo:

gcloud compute instance-templates create example-template-custom \
    --machine-type=e2-standard-4 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

Puedes agregar hasta 15 discos secundarios que no sean de arranque. Especifica la marca --create-disk para cada disco secundario que crees. Para crear discos secundarios a partir de una imagen pública o personalizada, especifica las propiedades image y image-project para cada disco en la marca --create-disk. Para crear un disco en blanco, no incluyas estas propiedades. De manera opcional, incluye propiedades para las opciones size y type del disco. Para especificar discos regionales, usa la propiedad replica-zones.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --create-disk=image-family=DISK_IMAGE_FAMILY,image-project=DISK_IMAGE_PROJECT,size=SIZE_GB_DISK1 \
    --create-disk=device-name=DISK_NAME,type=DISK_TYPE,size=SIZE_GB_DISK2,replica-zones=^:^ZONE:REMOTE_ZONE,boot=false

Sugerencia: Cuando se especifica el parámetro replica-zones del disco, los caracteres ^:^ especifican que el carácter de separación entre valores es dos puntos (:) en lugar de la coma esperada (,).

Reemplaza lo siguiente:

• INSTANCE_TEMPLATE_NAME: es el nombre de la plantilla.
• MACHINE_TYPE: Es el tipo de máquina de las VM.

• DISK_IMAGE_FAMILY: una familia de imágenes para usar como disco que no sea de arranque.

  Para obtener más información sobre las familias de imágenes, consulta las prácticas recomendadas para usar familias de imágenes en Compute Engine.

  En su lugar, puedes usar la marca --image=IMAGE para especificar una versión específica de una imagen.

  Para los discos en blanco, no especifiques la propiedad image-family ni image.

• DISK_IMAGE_PROJECT: Es el proyecto de imagen que contiene la imagen.

  Para los discos en blanco, no especifiques la propiedad image-project. Para obtener más información sobre las imágenes públicas, consulta Imágenes públicas.

• SIZE_GB_DISK1 y SIZE_GB_DISK2: es el tamaño de cada disco secundario.

• DISK_NAME: Es el nombre del disco que se muestra al SO invitado después de crear la VM (opcional).

• DISK_TYPE: es el tipo de disco que se creará (opcional). Si no se especifica, el tipo de disco predeterminado que se usa depende del valor de la marca --machine-type.

• ZONE y REMOTE_ZONE: es la zona en la que se creará el disco regional y la zona en la que se replicará.

  Para los discos zonales, no incluyas la propiedad replica-zones.

Si eliges una imagen que admite una VM protegida, puedes cambiar de manera opcional la configuración de VM protegida de la instancia con una de las siguientes marcas:

• --no-shielded-secure-boot: Desactiva el inicio seguro.

  El inicio seguro ayuda a proteger tus instancias de VM de softwares maliciosos y rootkits de nivel de inicio y kernel. Para obtener más información, consulta la documentación sobre Inicio seguro.

• --no-shielded-vtpm: Desactiva el módulo de plataforma segura virtual (vTPM)

  El vTPM habilita el inicio medido, que valida la integridad previa al inicio y la integridad de inicio de la VM. Para obtener más información, consulta la documentación sobre el Módulo de plataforma de confianza virtual (vTPM).

  Importante: Si inhabilitas el vTPM, también se inhabilita la supervisión de integridad, ya que esta se basa en los datos recopilados por el inicio medido.

• --no-shielded-integrity-monitoring: Desactiva la supervisión de integridad.

  Esta función te permite supervisar la integridad de inicio de las instancias de VM protegida a través de Cloud Monitoring. Para obtener más información, consulta Supervisión de integridad.

Para obtener una lista de todos los subcomandos y las marcas disponibles, consulta la referencia de instance-templates.

Una plantilla con la configuración predeterminada podría tener el aspecto siguiente:

gcloud compute instance-templates describe example-template

creationTimestamp: '2019-09-10T16:18:32.042-07:00'
description: ''
id: '6057583701980539406'
kind: compute#instanceTemplate
name: example-template
properties:
  canIpForward: false
  disks:
  - autoDelete: true
    boot: true
    initializeParams:
      sourceImage: https://compute.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-12
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: c3-standard-4
  networkInterfaces:
  - accessConfigs:
    - kind: compute#accessConfig
      name: external-nat
      type: ONE_TO_ONE_NAT
    network: https://compute.googleapis.com/compute/v1/projects/myproject/global/networks/default
  scheduling:
    automaticRestart: true
    onHostMaintenance: MIGRATE
  serviceAccounts:
  - email: default
    scopes:
    - https://www.googleapis.com/auth/devstorage.read_only
selfLink: https://compute.googleapis.com/compute/v1/projects/myproject/global/instanceTemplates/example-template

Terraform

Para crear una plantilla de instancias, puedes usar el recurso google_compute_instance_template.

El siguiente ejemplo de Terraform es similar al siguiente comando de la CLI de gcloud:

gcloud compute instance-templates create my-instance-template \
    --machine-type=c3-standard-4 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

resource "google_compute_instance_template" "foobar" {
  name         = "my-instance-template"
  machine_type = "e2-standard-4"

  disk {
    source_image = "debian-cloud/debian-11"
    disk_size_gb = 250
  }

  network_interface {
    network = "default"

    # default access config, defining external IP configuration
    access_config {
      network_tier = "PREMIUM"
    }
  }

  # To avoid embedding secret keys or user credentials in the instances, Google recommends that you use custom service accounts with the following access scopes.
  service_account {
    scopes = [
      "https://www.googleapis.com/auth/cloud-platform"
    ]
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createTemplate creates a new instance template with the provided name and a specific instance configuration.
func createTemplate(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.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create 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 created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.NetworkTier;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
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 CreateInstanceTemplate {

  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";
    createInstanceTemplate(projectId, templateName);
  }

  /*
    Create a new instance template with the provided name and a specific
    instance configuration.
   */
  public static void createInstanceTemplate(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      String machineType = "e2-standard-4";
      String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

      // The template describes the size and source image of the boot disk
      // to attach to the instance.
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true).build();

      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          // The template lets the instance use an external IP address.
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(NetworkTier.PREMIUM.toString()).build()).build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .addNetworkInterfaces(networkInterface).build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties).build()).build();

      // Create the Instance Template.
      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }

  public static void createInstanceTemplateWithDiskType(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setDiskSizeGb(10)
              .setDiskType("pd-balanced")
              .setSourceImage("projects/debian-cloud/global/images/family/debian-11").build())
          .setAutoDelete(true)
          .setBoot(true)
          .setType(AttachedDisk.Type.PERSISTENT.toString()).build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(InstanceProperties.newBuilder()
              .setMachineType("n1-standard-1")
              .addDisks(disk)
              .addNetworkInterfaces(NetworkInterface.newBuilder()
                  .setName("global/networks/default").build()).build()).build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate).build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }
}

Node.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');

// Create a new instance template with the provided name and a specific instance configuration.
async function createTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the `default` network,
        // without specifying a subnetwork.
        networkInterfaces: [
          {
            // Use the network interface provided in the networkName argument.
            name: 'global/networks/default',
            // The template lets the instance use an external IP address.
            accessConfigs: [
              {
                name: 'External NAT',
                type: 'ONE_TO_ONE_NAT',
                networkTier: 'PREMIUM',
              },
            ],
          },
        ],
      },
    },
  });
  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 created.');
}

createTemplate();

Python

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 create_template(project_id: str, template_name: str) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template with the provided name and a specific
    instance configuration.

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

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    # The template connects the instance to the `default` network,
    # without specifying a subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.name = "global/networks/default"

    # The template lets the instance use an external IP address.
    access_config = compute_v1.AccessConfig()
    access_config.name = "External NAT"
    access_config.type_ = "ONE_TO_ONE_NAT"
    access_config.network_tier = "PREMIUM"
    network_interface.access_configs = [access_config]

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"
    template.properties.network_interfaces = [network_interface]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

Para crear una plantilla de instancias regional, realiza una solicitud POST al método regionInstanceTemplates.insert de la siguiente manera:

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

Para crear una plantilla de instancias global, realiza una solicitud POST al método instanceTemplates.insert:

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

Puedes agregar hasta 15 discos secundarios que no sean de arranque con la propiedad disks, con un campo para cada disco adicional. Para cada disco adicional, puedes hacer lo siguiente:

• Crea discos adicionales con una imagen pública o personalizada.
• Para agregar un disco en blanco, define la entrada initializeParams sin ningún valor sourceImage.
• Para crear discos regionales, define la entrada initializeParams con la propiedad replicaZones.

En el cuerpo de la solicitud, proporciona las propiedades de la plantilla:

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "network": "global/networks/default",
        "accessConfigs":
        [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ]
      }
    ],
    "disks":
    [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams":
        {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      },
      {
        "type": "PERSISTENT",
        "boot": false,
        "deviceName": "DISK_NAME",
        "initializeParams":
        {
          "replicaZones": [
              "projects/PROJECT_NAME/zones/ZONE",
              "projects/PROJECT_NAME/zones/REMOTE_ZONE"
          ]
        }
      }
    ]
  }
}

Reemplaza lo siguiente:

• PROJECT_ID: es el ID del proyecto.
• REGION: es la región en la que deseas crear la plantilla de instancias regional.
• INSTANCE_TEMPLATE_NAME: Es el nombre de la plantilla de instancias.
• ZONE: Es la zona en la que se encuentran las VM.

• MACHINE_TYPE: Es el tipo de máquina de las VM.

• IMAGE_PROJECT: Es el proyecto de imagen que contiene la imagen.

  Para obtener más información sobre imágenes públicas, consulta Imágenes públicas.

• IMAGE o IMAGE_FAMILY: Especifica una de las siguientes opciones:
  • IMAGE: Es una versión específica de la imagen

    Por ejemplo: "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

  • IMAGE_FAMILY: Es una familia de imágenes.

    Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.

    Para obtener más información sobre las familias de imágenes, consulta las prácticas recomendadas para usar familias de imágenes en Compute Engine.

• DISK_NAME: Es el nombre del disco que se muestra al SO invitado después de crear la VM (opcional).

• PROJECT_NAME: Es el proyecto asociado con la VM.

• REMOTE_ZONE: Es la zona en la que se debe replicar el disco regional.

Puedes especificar una de las siguientes opciones para la propiedad disks:

• Especifica initializeParams para crear discos de arranque para cada instancia. Puedes crear discos con imágenes públicas o personalizadas (o familias de imágenes) con la propiedad sourceImage, como se muestra en el ejemplo anterior. Para agregar discos en blanco, no especifiques una sourceImage. También puedes agregar hasta 15 discos secundarios que no sean de arranque con la propiedad initializeParams para cada disco adicional.

• Especifica source para conectar un disco de arranque existente. Si conectas un disco de arranque existente, solo se puede crear una instancia a partir de tu plantilla.

De manera opcional, puedes especificar las propiedades diskSizeGb, diskType y labels para initializeParams y la propiedad diskSizeGb para source.

Si eliges una imagen compatible con una VM protegida, puedes cambiar de manera opcional la configuración de VM protegida de la VM con los siguientes elementos del cuerpo de solicitud booleana:

• enableSecureBoot: Activa o desactiva el inicio seguro

  El inicio seguro ayuda a proteger tus instancias de VM de softwares maliciosos y rootkits de nivel de inicio y kernel. Para obtener más información, consulta la documentación sobre Inicio seguro.

• enableVtpm: Activa o desactiva el módulo de plataforma segura virtual (vTPM).

  El vTPM habilita el inicio medido, que valida la integridad previa al inicio y la integridad de inicio de la VM. Para obtener más información, consulta la documentación sobre el Módulo de plataforma de confianza virtual (vTPM).

  Importante: Si inhabilitas el vTPM, también se inhabilita la supervisión de integridad, ya que esta depende de los datos recopilados por el inicio medido.

• enableIntegrityMonitoring: Activa o desactiva la supervisión de integridad

  La supervisión de integridad te permite supervisar y verificar la integridad de inicio del entorno de ejecución correspondiente a las instancias de VM protegida a través de informes de Cloud Monitoring. Para obtener más información, consulta Supervisión de integridad.

Para obtener más información sobre los parámetros de solicitud, consulta el método instanceTemplates.insert.

Crea una plantilla de instancias basada en una instancia existente

Puedes usar REST o gcloud CLI para guardar la configuración de una instancia de VM existente como una plantilla de instancias. Puedes anular la forma en que se definen los discos de origen en la plantilla.

Si necesitas anular otras propiedades, primero crea una plantilla de instancias basada en una instancia existente y, luego, crea una plantilla similar con anulaciones adicionales.

Advertencia: Si la instancia existente contiene una dirección IP externa y estática, esa dirección se copia en la plantilla de instancias y puede limitar el uso de la plantilla.

Permisos necesarios para esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

• Todos los permisos necesarios para llamar al método instanceTemplates.insert

gcloud

Usa el comando gcloud compute instance-templates create con las marcas --source-instance y --source-instance-zone. Si deseas crear una plantilla de instancias regional, también debes usar la marca --instance-template-region para especificar la región de la plantilla de instancias.

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

 gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
     --source-instance=SOURCE_INSTANCE \
     --source-instance-zone=SOURCE_INSTANCE_ZONE \
     --instance-template-region=REGION

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

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-instance-zone=SOURCE_INSTANCE_ZONE

Para anular cómo se definen los discos de la instancia de origen, agrega una o más marcas --configure-disk de la siguiente forma:

En el siguiente ejemplo, se crea una plantilla de instancias global a partir de una instancia existente y se anula el disco de la instancia de origen con las especificaciones que proporcionas.

  gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
      --source-instance=SOURCE_INSTANCE \
      --source-instance-zone=SOURCE_INSTANCE_ZONE \
      --configure-disk= \
      device-name=SOURCE_DISK, \
      instantiate-from=INSTANTIATE_OPTIONS, \
      auto-delete=AUTO_DELETE

Reemplaza lo siguiente:

• INSTANCE_TEMPLATE_NAME es el nombre de la plantilla que se creará.
• SOURCE_INSTANCE es el nombre de la instancia que se usará como modelo para la plantilla nueva.
• SOURCE_INSTANCE_ZONE es la zona que contiene la instancia de origen.
• SOURCE_DISK es el nombre de un disco de instancia de origen que quieres anular dentro de la plantilla.

• INSTANTIATE_OPTIONS especifica si se debe incluir el disco y qué imagen usar. Los valores válidos dependen del tipo de disco:

  • source-image o source-image-family (válidos solo para el inicio y otros discos persistentes de lectura y escritura). Especifica esta opción si deseas usar la misma imagen de origen o familia de imágenes de origen que se usó para crear el disco en la instancia de VM de origen.

  • custom-image (válido solo para inicio y otros discos persistentes de lectura y escritura). Si deseas conservar las aplicaciones y la configuración de las VMs de origen en la plantilla de instancias, puedes crear una imagen personalizada y especificarla cuando crees la plantilla. Si se especifica, proporciona la ruta o URL de la imagen personalizada, como se muestra en el ejemplo siguiente. Como alternativa, también puedes especificar una familia de imágenes con el siguiente formato:

    --configure-disk=device-name=DATA_DISK_NAME,instantiate-from=custom-image, \
    custom-image=projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME
    

  • attach-read-only (válido solo para discos de solo lectura).

  • blank (válido solo para los discos persistentes que no son de arranque y los SSD locales). Si se especifica, entonces, cuando se usa la plantilla para crear una instancia nueva, el disco se crea sin formato. Debes formatear y activar el disco en una secuencia de comandos de inicio antes de poder usarlo en una configuración escalable.

  • do-not-include (válido solo para los discos persistentes que no son de arranque y los discos de solo lectura).

• AUTO_DELETE especifica si el disco se borra automáticamente cuando se borra la instancia. Los valores válidos son false, no, true y yes.

Por ejemplo, con el comando siguiente, se crea una plantilla de instancias basada en my-source-instance, con la opción de usar la imagen original de data-disk-a, pero se establece la eliminación automática para true y se reemplaza data-disk-b por una imagen personalizada.

 gcloud compute instance-templates create my-instance-template  \
     --source-instance=my-source-instance \
     --configure-disk=device-name=data-disk-a,instantiate-from=source-image,auto-delete=true \
     --configure-disk=device-name=data-disk-b,instantiate-from=custom-image,custom-image=projects/cps-cloud/global/images/cos-89-16108-403-15

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createTemplateFromInstance creates a new instance template based on an existing instance.
// This new template specifies a different boot disk.
func createTemplateFromInstance(w io.Writer, projectID, instance, templateName string) error {
	// projectID := "your_project_id"
	// instance := "projects/project/zones/zone/instances/instance"
	// 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.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name:           proto.String(templateName),
			SourceInstance: proto.String(instance),
			SourceInstanceParams: &computepb.SourceInstanceParams{
				DiskConfigs: []*computepb.DiskInstantiationConfig{
					{
						// Device name must match the name of a disk attached to the instance
						// your template is based on.
						DeviceName: proto.String("disk-1"),
						// Replace the original boot disk image used in your instance with a Rocky Linux image.
						InstantiateFrom: proto.String(computepb.DiskInstantiationConfig_CUSTOM_IMAGE.String()),
						CustomImage:     proto.String("projects/rocky-linux-cloud/global/images/family/rocky-linux-8"),
						// Override the auto_delete setting.
						AutoDelete: proto.Bool(true),
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create 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 created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.DiskInstantiationConfig;
import com.google.cloud.compute.v1.DiskInstantiationConfig.InstantiateFrom;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SourceInstanceParams;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateFromInstance {

  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.
    // instance: the instance to base the new template on. This value uses the following format:
    // **NOTE**: "projects/{project}/zones/{zone}/instances/{instance_name}"
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    String instance = String.format("projects/%s/zones/%s/instances/%s", projectId, "zone",
        "instanceName");
    createTemplateFromInstance(projectId, templateName, instance);
  }

  // Create a new instance template based on an existing instance.
  // This new template specifies a different boot disk.
  public static void createTemplateFromInstance(String projectId, String templateName,
      String instance)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      SourceInstanceParams sourceInstanceParams = SourceInstanceParams.newBuilder()
          .addDiskConfigs(DiskInstantiationConfig.newBuilder()
              // Device name must match the name of a disk attached to the instance you are
              // basing your template on.
              .setDeviceName("disk-1")
              // Replace the original boot disk image used in your instance
              // with a Rocky Linux image.
              .setInstantiateFrom(InstantiateFrom.CUSTOM_IMAGE.toString())
              .setCustomImage(
                  String.format("projects/%s/global/images/family/%s", "rocky-linux-cloud",
                      "rocky-linux-8"))
              // Override the AutoDelete setting.
              .setAutoDelete(true).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setSourceInstance(instance)
          .setSourceInstanceParams(sourceInstanceParams)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

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

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const instance = 'projects/project/zones/zone/instances/instance';
// const templateName = 'your_template_name';

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

// Create a new instance template based on an existing instance.
// This new template specifies a different boot disk.
async function createTemplateFromInstance() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      sourceInstance: instance,
      sourceInstanceParams: {
        diskConfigs: [
          {
            // Device name must match the name of a disk attached to the instance
            // your template is based on.
            deviceName: 'disk-1',
            // Replace the original boot disk image used in your instance with a Rocky Linux image.
            instantiateFrom: 'CUSTOM_IMAGE',
            customImage:
              'projects/rocky-linux-cloud/global/images/family/rocky-linux-8',
            // Override the auto_delete setting.
            autoDelete: true,
          },
        ],
      },
    },
  });
  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 created.');
}

createTemplateFromInstance();

Python

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 create_template_from_instance(
    project_id: str, instance: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template based on an existing instance.
    This new template specifies a different boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        instance: the instance to base the new template on. This value uses
            the following format: "projects/{project}/zones/{zone}/instances/{instance_name}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    disk = compute_v1.DiskInstantiationConfig()
    # Device name must match the name of a disk attached to the instance you are
    # basing your template on.
    disk.device_name = "disk-1"
    # Replace the original boot disk image used in your instance with a Rocky Linux image.
    disk.instantiate_from = "CUSTOM_IMAGE"
    disk.custom_image = "projects/rocky-linux-cloud/global/images/family/rocky-linux-8"
    # Override the auto_delete setting.
    disk.auto_delete = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.source_instance = instance
    template.source_instance_params = compute_v1.SourceInstanceParams()
    template.source_instance_params.disk_configs = [disk]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

Para crear una plantilla de instancias regional, usa el método regionInstanceTemplates.insert o, para crear una plantilla de instancias global, usa el método instanceTemplates.insert.

En tu solicitud, debes especificar el campo sourceInstance. Para anular cómo se definen los discos de la instancia de origen, agrega uno o más campos diskConfigs.

Por ejemplo, realiza la siguiente llamada para crear una plantilla de instancias global a partir de una instancia existente.

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

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "sourceInstance": "zones/SOURCE_INSTANCE_ZONE/instances/SOURCE_INSTANCE",
  "sourceInstanceParams": {
    "diskConfigs": [
      {
        "deviceName": "SOURCE_DISK",
        "instantiateFrom": "INSTANTIATE_OPTIONS",
        "autoDelete": false
      }
    ]
  }
}

Reemplaza lo siguiente:

• PROJECT_ID: es el ID del proyecto.
• INSTANCE_TEMPLATE_NAME: Es el nombre de la plantilla nueva.
• SOURCE_INSTANCE_ZONE: Es la zona de la instancia de origen.
• SOURCE_INSTANCE: Es el nombre de la instancia de origen que se usará como modelo para esta plantilla de instancias.
• SOURCE_DISK: Es el nombre de un disco de instancia de origen que quieres anular dentro de la plantilla.

• INSTANTIATE_OPTIONS: Especifica si se debe incluir el disco y qué imagen usar.

  Los valores válidos dependen del tipo de disco:

  • source-image o source-image-family (válidos solo para el inicio y otros discos persistentes de lectura y escritura).

  • custom-image (válido solo para inicio y otros discos persistentes de lectura y escritura). Si deseas conservar las aplicaciones y la configuración de las VMs de origen en la plantilla de instancias, puedes crear una imagen personalizada y especificarla cuando crees la plantilla. Si se especifica, proporciona la ruta o URL de la imagen personalizada, como se muestra en el ejemplo siguiente. Como alternativa, también puedes especificar una familia de imágenes con el siguiente formato:

      "diskConfigs": [
        {
          "deviceName": DATA_DISK_NAME,
          "instantiateFrom": custom-image,
          "customImage": "projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME"
        }
      ]
    

  • attach-read-only (válido solo para discos de solo lectura).

  • blank (válido solo para los discos persistentes que no son de arranque y los SSD locales). Si se especifica, entonces, cuando se usa la plantilla para crear una instancia nueva, el disco se crea sin formato. Debes formatear y activar el disco en una secuencia de comandos de inicio antes de poder usarlo en una configuración escalable.

  • do-not-include (válido solo para los discos persistentes que no son de arranque y los discos de solo lectura).

En el ejemplo siguiente, se crea una plantilla de instancias nueva basada en my-source-instance. En la plantilla de instancias, la imagen de data-disk-a se reemplaza por projects/cos-cloud/global/images/cos-89-16108-403-15.

POST https://compute.googleapis.com/compute/v1/projects/my_project/global/instanceTemplates

{
  "name": "my-instance-template",
  "sourceInstance": "zones/us-central1-a/instances/my-source-instance",
  "sourceInstanceParams":
  {
    "diskConfigs":
    [
      {
        "deviceName": "data-disk-a",
        "instantiateFrom": "custom-image",
        "customImage": "projects/cos-cloud/global/images/cos-89-16108-403-15"
      }
    ]
  }
}

En la siguiente tabla, se muestra cómo se definen las opciones para anular discos en la plantilla.

Tipo de disco	Opciones
Disco de arranque	[Predeterminado] Usa la misma imagen fuente o familia de imágenes que se usó para crear el disco de arranque en la instancia de origen. Usa la URL de cualquier imagen (personalizada o pública) como se describe en el ejemplo anterior o especifica una familia de imágenes con el siguiente formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Otros discos persistentes de lectura y escritura	[Predeterminado] Usa la misma imagen de origen o familia de imágenes de origen que se usó para crear el disco en la instancia de origen. Nota: Si el disco de la instancia de origen no tiene una propiedad de imagen de origen o familia de imágenes de origen, se incluye en la plantilla como un disco en blanco. Usa la URL de cualquier imagen (personalizada o pública) como se describe en el ejemplo anterior o especifica una familia de imágenes con el siguiente formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME De lo contrario, usa un disco en blanco en la plantilla. Cuando la plantilla se usa para crear una instancia nueva, este disco se crea sin formato. Debes formatear y activar el disco en una secuencia de comandos de inicio antes de poder usarlo en una configuración escalable. No incluyas el disco.
Discos de solo lectura	[Predeterminado] Incluye el disco en modo de solo lectura. No incluyas el disco.
SSD locales	[Predeterminado] Incluye un SSD local en blanco. Cuando la plantilla se usa para crear una instancia nueva, este disco se crea sin formato. Debes formatear y activar el disco en una secuencia de comandos de inicio antes de usarlo en una configuración escalable.

Para cada disco, también puedes anular el atributo auto-delete a fin de especificar si el disco se debe borrar cuando se borra su instancia asociada.

De forma predeterminada, si no se especifican opciones de anulación, la configuración del disco en la plantilla coincide con la instancia de origen.

Crea una plantilla de instancias basada en una plantilla existente

No puedes actualizar una plantilla de instancias existente. Sin embargo, si una plantilla de instancias está desactualizada o si necesitas hacer cambios, puedes crear otra con propiedades similares en la consola.

1. Ve a la página Plantillas de instancias.

   Ir a Plantillas de instancia

2. Haz clic en la plantilla de instancias que deseas copiar y actualizar.

3. Haz clic en Crear una similar.

4. Actualiza la configuración en la plantilla nueva.

5. Haz clic en Crear.

Crea una plantilla de instancias para las VMs de GPU

Cuando creas una plantilla de instancias, puedes configurarla para crear VMs que tengan GPUs conectadas. Para ello, especifica lo siguiente:

• Un tipo de máquina que admita el tipo de GPU que deseas. Si deseas crear una plantilla de instancias regional, el tipo de GPU que especifiques en la plantilla debe estar disponible en al menos una zona de la región.

• Una política de mantenimiento que detiene las VMs durante los eventos de mantenimiento del host.

Nota: Si deseas ejecutar cargas de trabajo de ciencia de datos o aprendizaje automático, considera usar una Deep Learning VM Image cuando crees una plantilla de instancia. Deep Learning VM Images es un conjunto de imágenes de VM ya preparadas que incluye frameworks de aprendizaje automático y herramientas esenciales. Para obtener más información sobre estas imágenes, consulta Elige una imagen en la documentación de Deep Learning VM Images.

Permisos necesarios para esta tarea

Para realizar esta tarea, debes tener los siguientes permisos:

• Todos los permisos necesarios para llamar al método instanceTemplates.insert

Console

Para crear una plantilla de instancias para las VMs de GPU, haz lo siguiente:

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

   Ir a Plantillas de instancia

2. Haz clic en Crear plantilla de instancias.

3. En el campo Nombre, ingresa un nombre para la plantilla de instancias.

4. En la sección Ubicación, selecciona una de las siguientes opciones:

   • Para crear una plantilla de instancias global, selecciona Global (predeterminado).

   • Para crear una plantilla de instancias regional, selecciona Regional y, luego, la región en la que deseas crear la plantilla de instancias.

5. En la sección Configuración de la máquina, haz lo siguiente:

   1. Haz clic en la pestaña GPU.

   2. En el menú Tipo de GPU, selecciona el tipo de GPU.

   3. En el menú Cantidad de GPU, selecciona la cantidad.

   4. Opcional: Si tu modelo de GPU es compatible con estaciones de trabajo virtuales (vWS) NVIDIA RTX para cargas de trabajo de gráficos y planeas ejecutar cargas de trabajo de alto contenido gráfico, selecciona Habilitar estación de trabajo virtual (NVIDIA GRID).

   5. En la sección Tipo de máquina, selecciona un tipo de máquina.

6. Opcional: Para cambiar el valor o la imagen de disco de arranque predeterminados, en la sección Disco de arranque, haz clic en Cambiar. Luego, sigue las instrucciones para cambiar el disco de arranque.

7. Haz clic en Crear.

gcloud

Para crear una plantilla de instancias para las VMs de GPU, usa el comando instance-templates create con la marca --maintenance-policy establecida como TERMINATE.

Por ejemplo, para crear una plantilla de instancias global para las VMs de GPU, usa el siguiente comando:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --image-project=IMAGE_PROJECT \
    --image-family=IMAGE_FAMILY \
    --machine-type=MACHINE_TYPE \
    --maintenance-policy=TERMINATE

Reemplaza lo siguiente:

• INSTANCE_TEMPLATE_NAME: el nombre de la plantilla de instancias.

• IMAGE_PROJECT: el proyecto de imagen que contiene la imagen; por ejemplo, debian-cloud. Para obtener más información sobre los proyectos de imágenes compatibles, consulta Imágenes públicas.

• IMAGE_FAMILY o IMAGE: especifica una de las siguientes opciones:

  • IMAGE_FAMILY: Es una familia de imágenes. Esto especifica la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas debian-10, se usa la versión más reciente de la familia de imágenes de Debian 10. Para obtener más información sobre el uso de las familias de imágenes, consulta Prácticas recomendadas para las familias de imágenes.

  • IMAGE: una versión específica de la imagen de SO; por ejemplo, debian-10-buster-v20200309. Si eliges especificar una versión específica de la imagen del SO, debes reemplazar la marca --image-family por la marca --image.

• MACHINE_TYPE: el tipo de máquina de las VMs. Si especificas un tipo de máquina N1, incluye la marca --accelerator para especificar la cantidad y el tipo de GPU que conectarás a las VMs.

Por ejemplo, supongamos que deseas crear una plantilla de instancias global para VMs de GPU que especifique las siguientes propiedades:

• Un tipo predefinido de máquina N1 con 2 CPUs virtuales

• Una GPU NVIDIA T4 para conectar a las VMs.

• Debian como el proyecto de imagen

• Debian 10 como la familia de imágenes

Para crear la plantilla de instancias de ejemplo, usa el siguiente comando:

gcloud compute instance-templates create instance-template-gpu \
    --accelerator=count=1,type=nvidia-tesla-t4 \
    --machine-type=n1-standard-2 \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --maintenance-policy=TERMINATE

Terraform

Para crear una plantilla de instancias para las VMs de GPU, usa el recurso google_compute_region_instance_template.

Por ejemplo, para crear una plantilla de instancias global, que especifique un tipo predefinido de máquina N1 con 2 CPU virtuales y una GPU NVIDIA T4 conectada, usa el siguiente recurso:

resource "google_compute_instance_template" "default" {
  name         = "gpu-template"
  machine_type = "n1-standard-2"

  disk {
    source_image = "debian-cloud/debian-11"
  }

  network_interface {
    network = "default"
  }

  guest_accelerator {
    type  = "nvidia-tesla-t4"
    count = 1
  }

  scheduling {
    on_host_maintenance = "TERMINATE"
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

REST

Si deseas crear una plantilla de instancias para las VMs de GPU, realiza una solicitud POST al método instanceTemplates.insert. En el cuerpo de la solicitud, incluye el campo onHostMaintenance y configúralo como TERMINATE.

Por ejemplo, para crear una plantilla de instancias global para las VMs de GPU, realiza una solicitud POST de la siguiente manera:

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

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Reemplaza lo siguiente:

• PROJECT_ID: Es el ID del proyecto en el que deseas crear la plantilla de instancias.

• INSTANCE_TEMPLATE_NAME: el nombre de la plantilla de instancias.

• IMAGE_PROJECT: el proyecto de imagen que contiene la imagen; por ejemplo, debian-cloud. Para obtener más información sobre los proyectos de imágenes compatibles, consulta Imágenes públicas.

• IMAGE o IMAGE_FAMILY: especifica una de las siguientes opciones:

  • IMAGE: una versión específica de la imagen de SO; por ejemplo, debian-10-buster-v20200309.

  • IMAGE_FAMILY: Es una familia de imágenes. Esto especifica la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas family/debian-10, se usa la versión más reciente de la familia de imágenes de Debian 10. Para obtener más información sobre el uso de las familias de imágenes, consulta Prácticas recomendadas para las familias de imágenes.

• MACHINE_TYPE: el tipo de máquina de las VMs. Si especificas un tipo de máquina N1, incluye el campo guestAccelerators para especificar la cantidad y el tipo de GPU que conectarás a las VMs.

Por ejemplo, supongamos que deseas crear una plantilla de instancias global para VMs de GPU que especifique las siguientes propiedades:

• Un tipo predefinido de máquina N1 con 2 CPUs virtuales

• Una GPU NVIDIA T4 para conectar a las VMs.

• Debian como el proyecto de imagen

• Debian 10 como la familia de imágenes

Para crear la plantilla de instancias de ejemplo, realiza una solicitud POST de la siguiente manera:

POST https://compute.googleapis.com/compute/v1/projects/example-project/global/instanceTemplates

{
  "name": "instance-template-gpu",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/family/debian-10"
        }
      }
    ],
    "guestAccelerators": [
      {
        "acceleratorType": "nvidia-tesla-t4",
        "acceleratorCount": 1
      }
    ],
    "machineType": "n1-standard-2",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Para obtener más opciones de configuración cuando crees una plantilla de instancias, consulta Crea una plantilla de instancias en este documento.

Crea una plantilla de instancias con una imagen de contenedor

Puedes especificar una imagen de contenedor en una plantilla de instancias. De forma predeterminada, Compute Engine también incluye en la plantilla una imagen de Container-Optimized OS con Docker instalado. Si usas la plantilla para crear una instancia nueva, el contenedor se inicia de manera automática cuando se inicializa la instancia.

Console

1. Ve a la página Plantillas de instancias.

   Ir a Plantillas de instancia

2. Haz clic en Crear plantilla de instancias.

3. En la sección Contenedor, haz clic en Implementar contenedor.

4. En el cuadro de diálogo Configurar contenedor, especifica la Imagen de contenedor que deseas usar.

   • Puedes especificar una imagen de Container Registry o Artifact Registry. Por ejemplo:
     • gcr.io/cloud-marketplace/google/nginx1:TAG, en la que TAG es la etiqueta definida para una versión específica de la imagen de contenedor NGINX disponible en Google Cloud Marketplace.
     • Con us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0, se selecciona una imagen de muestra de hello-app almacenada en Artifact Registry.
   • Si usas una imagen de contenedor de Docker Hub, especifica siempre el nombre completo de la imagen de Docker. Por ejemplo, especifica el siguiente nombre de imagen para implementar una imagen de contenedor de Apache: docker.io/httpd:2.4.

5. De manera opcional, haz clic en Opciones avanzadas de contenedor. Si quieres obtener más información, consulta Configura opciones para ejecutar tu contenedor.

6. Haz clic en Crear.

gcloud

Usa el comando gcloud compute instance-templates create-with-container:

 gcloud compute instance-templates create-with-container INSTANCE_TEMPLATE_NAME \
     --container-image=CONTAINER_IMAGE

Reemplaza lo siguiente:

• INSTANCE_TEMPLATE_NAME: Es el nombre de la plantilla que se creará.
• CONTAINER_IMAGE: Es el nombre completo de la imagen de contenedor que se usará.

Por ejemplo, con el siguiente comando, se crea una plantilla de instancias nueva llamada nginx-vm. Una instancia de VM creada a partir de esta plantilla inicia y ejecuta la imagen de contenedor, gcr.io/cloud-marketplace/google/nginx1:TAG, cuando se inicia la VM.

 gcloud compute instance-templates create-with-container nginx-vm \
     --container-image=gcr.io/cloud-marketplace/google/nginx1:TAG

Reemplaza TAG por la etiqueta definida para una versión específica de la imagen de contenedor NGINX disponible en Google Cloud Marketplace.

También puedes configurar las opciones para ejecutar tu contenedor.

Precaución: Container Registry está obsoleto y se programó para el cierre. Las organizaciones que no usaron Container Registry antes del 8 de enero de 2024 tendrán nuevos repositorios de gcr.io alojados en Artifact Registry de forma predeterminada. A partir del 15 de mayo de 2024, los proyectos Google Cloud sin uso anterior de Container Registry solo admitirán el hosting y la administración de imágenes para el dominio gcr.io en Artifact Registry.

Container Registry está programado para cerrarse el 18 de marzo de 2025. Para obtener detalles sobre la baja, consulta Baja de Container Registry.

Crea una plantilla de instancias que especifique una subred

gcloud

Para crear una plantilla de instancias regional o global, usa el comando instance-templates create. Usa la marca --subnet para colocar las instancias que se crean a partir de la plantilla en la subred que elijas. La marca --subnet requiere la marca --region.

Si deseas crear una plantilla de instancias regional, debes usar la marca --instance-template-region para establecer la región de la plantilla. Asegúrate de usar una subred de la misma región en la que deseas crear la plantilla de instancias regional.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME_OR_URL \
    --stack-type=STACK_TYPE \
    --instance-template-region=INSTANCE_TEMPLATE_REGION

Reemplaza lo siguiente:

• INSTANCE_TEMPLATE_NAME: El nombre de la plantilla de instancias.
• REGION: Es la región de la subred.

• SUBNET_NAME_OR_URL: Es el nombre de la subred o su URL.

  Nota: Si usas el nombre de la subred, Google busca esa subred en la región de destino (siempre que exista allí). Sin embargo, si usas la URL de la subred, la plantilla de instancias solo se puede usar para crear instancias en la región específica asociada con la URL de la subred.

• STACK_TYPE: Opcional: Indica si IPv6 está habilitado en la interfaz de red predeterminada. Se pueden usar los siguientes valores: IPV4_ONLY, IPV4_IPV6 o IPV6_ONLY (versión preliminar). Si no incluyes esta marca, el valor predeterminado es IPV4_ONLY.

• INSTANCE_TEMPLATE_REGION: es la región en la que deseas crear la plantilla de instancias. Esta región debe ser igual que REGION.

En el siguiente ejemplo, se crea una plantilla llamada template-qa que solo crea instancias en la subred subnet-us-qa.

gcloud compute instance-templates create template-qa \
    --region=us-central1 \
    --subnet=subnet-us-qa

El resultado es similar a este:

Created [https://compute.googleapis.com/compute/latest/projects/PROJECT_ID/global/instanceTemplates/template-qa].
NAME        MACHINE_TYPE        PREEMPTIBLE CREATION_TIMESTAMP
template-qa e2-standard-2       2019-12-23T20:34:00.791-07:00

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createTemplateWithSubnet creates an instance template that uses a provided subnet.
func createTemplateWithSubnet(w io.Writer, projectID, network, subnetwork, templateName string) error {
	// projectID := "your_project_id"
	// network := "projects/project/global/networks/network"
	// subnetwork := "projects/project/regions/region/subnetworks/subnetwork"
	// 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.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the specified network and subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Network:    proto.String(network),
						Subnetwork: proto.String(subnetwork),
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create 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 created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
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 CreateTemplateWithSubnet {

  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.
    network: the network to be used in the new template. This value uses
        the following format: "projects/{project}/global/networks/{network}"
    subnetwork: the subnetwork to be used in the new template. This value
        uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
    templateName: name of the new template to create.
    */
    String projectId = "your-project-id";
    String network = String.format("projects/%s/global/networks/%s", projectId, "network");
    String subnetwork = String.format("projects/%s/regions/%s/subnetworks/%s", projectId, "region",
        "subnetwork");
    String templateName = "template-name";
    createTemplateWithSubnet(projectId, network, subnetwork, templateName);
  }

  // Create an instance template that uses a provided subnet.
  public static void createTemplateWithSubnet(String projectId, String network, String subnetwork,
      String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(
                  String.format("projects/%s/global/images/family/%s", "debian-cloud", "debian-11"))
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(disk)
          .setMachineType("e2-standard-4")
          .addNetworkInterfaces(NetworkInterface.newBuilder()
              .setNetwork(network)
              .setSubnetwork(subnetwork).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(instanceProperties)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

      if (response.hasError()) {
        System.out.println("Template creation from subnet failed ! ! " + response);
        return;
      }
      System.out.printf("Template creation from subnet operation status %s: %s", templateName,
          response.getStatus());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const network = 'projects/project/global/networks/network';
// const subnetwork = 'projects/project/regions/region/subnetworks/subnetwork';
// const templateName = 'your_template_name';

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

// Create an instance template that uses a provided subnet.
async function createTemplateWithSubnet() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        // The template describes the size and source image of the boot disk
        // to attach to the instance.
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the specified network and subnetwork.
        networkInterfaces: [
          {
            network,
            subnetwork,
          },
        ],
      },
    },
  });
  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 created.');
}

createTemplateWithSubnet();

Python

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 create_template_with_subnet(
    project_id: str, network: str, subnetwork: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create an instance template that uses a provided subnet.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        network: the network to be used in the new template. This value uses
            the following format: "projects/{project}/global/networks/{network}"
        subnetwork: the subnetwork to be used in the new template. This value
            uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the book disk to
    # attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties = compute_v1.InstanceProperties()
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"

    # The template connects the instance to the specified network and subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network
    network_interface.subnetwork = subnetwork
    template.properties.network_interfaces = [network_interface]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )
    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

Si usas esta plantilla en la creación de instancias para un MIG (con o sin ajuste de escala automático), la instancia se crea de forma automática en la región y subred especificadas. Esto te permite controlar la subred de las instancias nuevas creadas para el balanceo de cargas.

Usa imágenes personalizadas o públicas en tus plantillas de instancias

Puedes usar una imagen personalizada o pública para las plantillas de instancias:

• Imágenes personalizadas. Como los MIG están diseñados para agregar y quitar instancias con frecuencia, es útil crear una imagen personalizada y especificarla en la plantilla de instancias. Puedes preparar la imagen con las aplicaciones y la configuración que necesitan tus VM para que no tengas que configurar de forma manual esos elementos en las VM individuales del MIG.

• Imágenes públicas. Puedes crear una plantilla de instancias que use una imagen pública y una secuencia de comandos de inicio para preparar la instancia después de que comience a ejecutarse.

Las imágenes personalizadas son más deterministas y se inician con más velocidad que las VM con secuencias de comandos de inicio. Sin embargo, las secuencias de comandos de inicio son más flexibles, lo que te permite actualizar las apps y la configuración de tus instancias.

Si administras imágenes con familias de imágenes, puedes especificar el nombre de tu familia de imágenes públicas o personalizadas en la plantilla de instancias. Para obtener más información sobre las familias de imágenes, consulta las prácticas recomendadas para usar familias de imágenes en Compute Engine.

Nota: Si la imagen que quieres usar pertenece a otro proyecto, puedes usar esa imagen en la plantilla de instancias, siempre que el propietario del proyecto le otorgue al MIG acceso a las imágenes. Para obtener más información, consulta Otorga a un MIG acceso a las imágenes.

¿Qué sigue?

• Crear una instancia de VM a partir de una plantilla de instancias.
• Crea un grupo de instancias administrado zonal (MIG).
• Crea un MIG regional.
• Actualiza las VMs en un MIG existente para usar la configuración de una plantilla nueva.
• Crea una reserva para las VMs.