Crie modelos de instâncias

---

Esta página descreve como criar e gerir modelos de instâncias. Os modelos de instâncias permitem-lhe especificar o tipo de máquina, a imagem do disco de arranque, a rede e outras propriedades da VM que quer usar quando cria instâncias de máquinas virtuais (VMs).

Pode usar modelos de instâncias para fazer o seguinte:

• Criar VMs individuais.
• Crie VMs num grupo de instâncias geridas (GIG).
• Crie reservas para VMs.

Antes de começar

• Leia quando e por que motivo deve criar modelos de instâncias determinísticos.
• Leia acerca dos modelos de instâncias regionais e globais.
• Se ainda não o tiver feito, configure a autenticação. A autenticação valida a sua identidade para aceder a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode autenticar-se no Compute Engine selecionando uma das seguintes opções:

  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. Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:

     gcloud init

     Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

     Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
  2. Set a default region and zone.

  Terraform

  Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Go

  Para usar os Go exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Java

  Para usar os Java exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Node.js

  Para usar os Node.js exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  Python

  Para usar os Python exemplos nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as Credenciais predefinidas da aplicação com as suas credenciais de utilizador.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  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.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para mais informações, consulte Set up authentication for a local development environment.

  REST

  Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.

  Instale a CLI Google Cloud.

  Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

  Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

  Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

Limitações

• A VPC partilhada em interfaces que não sejam nic0 para modelos de instâncias é suportada na CLI gcloud e no REST, mas não na consolaGoogle Cloud .
• Não pode atualizar um modelo de instância existente nem alterar um modelo de instância depois de o criar. Se um modelo de instância ficar desatualizado ou precisar de fazer alterações à configuração, crie um novo modelo de instância.
• Se quiser especificar uma família de imagens num modelo de instância, não pode usar a consola. Google Cloud Em alternativa, pode usar a Google Cloud CLI ou a API REST.
• Se quiser especificar discos regionais em vez de discos zonais num modelo de instância, não pode usar a consola. Google Cloud Em alternativa, pode usar a CLI Google Cloud ou o REST.
• Pode usar um modelo de instância para criar VMs com um disco de arranque Hyperdisk Balanced que está num conjunto de armazenamento, se o conjunto de armazenamento existir na mesma zona em que a VM é criada. Não pode usar modelos de instâncias globais para criar VMs com discos que não sejam de arranque e que estejam num conjunto de armazenamento.

Crie um modelo de instância

A maioria das propriedades da VM que pode especificar num pedido para criar uma instância de VM individual também pode ser especificada para um modelo de instância, incluindo quaisquer metadados da VM, scripts de arranque, discos persistentes e contas de serviço. Tem de especificar o tipo de máquina, o disco de arranque e a rede.

Crie um modelo de instância regional ou global através da Google Cloud console, da CLI do Google Cloud ou da API. Para criar um modelo de instância global, também pode usar o Terraform ou as bibliotecas de cliente da nuvem.

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

• Todas as autorizações necessárias para chamar o método instanceTemplates.insert.

Consola

1. Na Google Cloud consola, aceda à página Modelos de instâncias.

   Aceda a Modelos de instâncias

   Os passos restantes aparecem na Google Cloud consola.

2. Clique em Criar modelo de instância.
3. Selecione a Localização da seguinte forma:
1. Se quiser usar o modelo de instância em várias regiões, escolha Global.
2. Se quiser reduzir a dependência entre regiões, escolha Regional.
4. Se escolheu a opção regional, selecione a Região onde quer criar o modelo de instância.

5. Para os campos seguintes, aceite os valores predefinidos ou modifique-os conforme necessário. Os valores predefinidos mudam com base na família de máquinas que selecionar.

   • Selecione um Tipo de máquina.
   • Para atualizar o tipo ou a imagem do disco de arranque, na secção Disco de arranque, clique em Alterar.
   • Para atualizar as definições da interface de rede ou do endereço IP, clique em Opções avançadas, clique em Rede e, de seguida, clique na interface de rede que quer editar.

6. Opcional: se escolheu uma imagem que suporta a VM protegida, altere as definições da VM protegida:

   1. Clique em Opções avançadas e, de seguida, clique no separador Segurança.
   2. Se quiser desativar o arranque seguro, desmarque a caixa de verificação Ativar arranque seguro. O Arranque seguro ajuda a proteger as instâncias de VM contra software malicioso ao nível do arranque e do kernel, bem como rootkits. Para mais informações, consulte o artigo Arranque seguro.

   3. Se quiser desativar o Módulo de plataforma fidedigna virtual (vTPM), desmarque a caixa de verificação Ativar vTPM. O vTPM permite o arranque medido, que valida a integridade do pré-arranque e do arranque da VM. Para mais informações, consulte Virtual Trusted Platform Module (vTPM).

      Importante: a desativação do vTPM também desativa a monitorização da integridade, uma vez que esta depende dos dados recolhidos pelo arranque medido.

   4. Se quiser desativar a monitorização da integridade, desmarque a caixa de verificação Ativar monitorização da integridade. A monitorização da integridade permite-lhe monitorizar a integridade do arranque das suas instâncias de VM protegidas através do Cloud Monitoring. Para mais informações, consulte o artigo Monitorização da integridade.

7. Opcional: em Opções avançadas, clique nos separadores para personalizar ainda mais o modelo. Por exemplo, pode adicionar até 15 discos secundários que não sejam de arranque.

8. Opcional: clique em REST equivalente para ver o corpo do pedido REST, que inclui a representação JSON do modelo de instância.

9. Clique em Criar para criar o modelo.

gcloud

Para criar um modelo de instância regional ou global, use o comando instance-templates create. Para um modelo de instância regional, tem de usar a flag --instance-template-region para definir a região do modelo.

Crie um modelo de instância regional com o seguinte comando.

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

Substitua REGION pela região onde quer criar o modelo de instância regional.

Crie um modelo de instância global com o seguinte comando:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Se não fornecer definições explícitas do modelo, o gcloud compute usa os seguintes valores predefinidos:

• Tipo de máquina: o tipo de máquina, por exemplo, n1-standard-1
• Imagem: a imagem do Debian mais recente
• Disco de arranque: um novo disco de arranque padrão com o nome da VM
• Rede: a rede VPC predefinida
• Endereço IP: um endereço IPv4 externo efémero
• Tipo de pilha: IPV4_ONLY

Também pode fornecer explicitamente estas definições de configuração. Por exemplo:

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

Pode adicionar até 15 discos não de arranque secundários. Especifique a flag --create-disk para cada disco secundário que criar. Para criar discos secundários a partir de uma imagem pública ou personalizada, especifique as propriedades image e image-project para cada disco na flag --create-disk. Para criar um disco em branco, não inclua estas propriedades. Opcionalmente, inclua propriedades para o disco size e type. Para especificar discos regionais, use a propriedade 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

Sugestão: quando especificar o parâmetro replica-zones do disco, os carateres ^:^ especificam que o carater de separação entre os valores é dois pontos (:) em vez da vírgula esperada (,).

Substitua o seguinte:

• INSTANCE_TEMPLATE_NAME: o nome do modelo
• MACHINE_TYPE: o tipo de máquina das VMs

• DISK_IMAGE_FAMILY: uma família de imagens a usar como um disco não arrancável

  Para mais informações sobre famílias de imagens, consulte as práticas recomendadas quando usar famílias de imagens no Compute Engine.

  Em alternativa, pode usar a flag --image=IMAGE para especificar uma versão específica de uma imagem.

  Para discos em branco, não especifique a propriedade image-family nem image.

• DISK_IMAGE_PROJECT: o projeto de imagem que contém a imagem

  Para discos em branco, não especifique a propriedade image-project. Para mais informações sobre imagens públicas, consulte o artigo Imagens públicas.

• SIZE_GB_DISK1 e SIZE_GB_DISK2: o tamanho de cada disco secundário

• DISK_NAME: opcional: o nome do disco apresentado ao SO convidado após a criação da VM.

• DISK_TYPE: opcional: o tipo de disco a criar. Se não for especificado, o tipo de disco predefinido usado depende do valor da flag --machine-type.

• ZONE e REMOTE_ZONE: a zona onde criar o disco regional e a zona para a qual replicá-lo.

  Para discos zonais, não inclua a propriedade replica-zones.

Se escolheu uma imagem que suporta a VM protegida, pode alterar opcionalmente as definições da VM protegida da instância através de uma das seguintes flags:

• --no-shielded-secure-boot: desativa o arranque seguro

  O Arranque seguro ajuda a proteger as instâncias de VM contra software malicioso e rootkits ao nível do arranque e do kernel. Para mais informações, consulte o artigo Arranque seguro.

• --no-shielded-vtpm: desativa o Trusted Platform Module virtual (vTPM)

  O vTPM permite o arranque medido, que valida a integridade do pré-arranque e do arranque da VM. Para mais informações, consulte o artigo Módulo de plataforma fidedigna virtual (vTPM).

  Importante: a desativação do vTPM também desativa a monitorização da integridade, uma vez que esta depende dos dados recolhidos pelo arranque medido.

• --no-shielded-integrity-monitoring: desativa a monitorização da integridade

  A monitorização da integridade permite-lhe monitorizar a integridade do arranque das suas instâncias de VM protegidas através do Cloud Monitoring. Para mais informações, consulte o artigo Monitorização da integridade.

Para ver uma lista de todos os subcomandos e flags disponíveis, consulte a instance-templates referência.

Terraform

Para criar um modelo de instância, use um dos seguintes recursos:

• Para um modelo de instância regional, use o recurso google_compute_region_instance_template.
• Para um modelo de instância global, use o recurso google_compute_instance_template.

O exemplo seguinte cria um modelo de instância global:

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"
    ]
  }
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do 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 criar um modelo de instância regional, faça um pedido POST ao método regionInstanceTemplates.insert da seguinte forma:

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

Para criar um modelo de instância global, faça um pedido POST ao método instanceTemplates.insert:

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

Pode adicionar até 15 discos secundários não de arranque através da propriedade disks, com um campo para cada disco adicional. Para cada disco adicional, pode fazer o seguinte:

• Crie discos adicionais com uma imagem pública ou personalizada.
• Para adicionar um disco em branco, defina a entrada initializeParams sem valor de sourceImage.
• Para criar discos regionais, defina a entrada initializeParams com a propriedade replicaZones.

No corpo do pedido, indique as propriedades do modelo:

{
  "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"
          ]
        }
      }
    ]
  }
}

Substitua o seguinte:

• PROJECT_ID: o ID do projeto
• REGION: a região onde quer criar o modelo de instância regional
• INSTANCE_TEMPLATE_NAME: o nome do modelo de instância
• ZONE: a zona onde as VMs estão localizadas

• MACHINE_TYPE: o tipo de máquina das VMs

• IMAGE_PROJECT: o projeto de imagem que contém a imagem

  Para mais informações sobre imagens públicas, consulte o artigo Imagens públicas.

• IMAGE ou IMAGE_FAMILY: especifique uma das seguintes opções:
  • IMAGE: uma versão específica da imagem

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

  • IMAGE_FAMILY: uma família de imagens

    Isto cria a VM a partir da imagem do SO não descontinuada mais recente. Por exemplo, se especificar "sourceImage": "projects/debian-cloud/global/images/family/debian-10", o Compute Engine cria uma VM a partir da versão mais recente da imagem do SO na família de imagens Debian 10.

    Para mais informações sobre famílias de imagens, consulte as práticas recomendadas quando usar famílias de imagens no Compute Engine.

• DISK_NAME: opcional: o nome do disco apresentado ao SO convidado após a criação da VM.

• PROJECT_NAME: o projeto associado à VM

• REMOTE_ZONE: a zona para a qual o disco regional deve ser replicado

Pode especificar uma das seguintes opções para a propriedade disks:

• Especifique initializeParams para criar discos de arranque para cada instância. Pode criar discos usando imagens públicas ou personalizadas (ou famílias de imagens) através da propriedade sourceImage, conforme mostrado no exemplo anterior. Para adicionar discos em branco, não especifique um sourceImage. Também pode adicionar até 15 discos secundários não de arranque através da propriedade initializeParams para cada disco adicional.

• Especifique source para anexar um disco de arranque existente. Se anexar um disco de arranque existente, só pode criar uma instância a partir do seu modelo.

Opcionalmente, pode especificar as propriedades diskSizeGb, diskType e labels para initializeParams e a propriedade diskSizeGb para source.

Se escolheu uma imagem que suporta a VM protegida, pode alterar opcionalmente as definições da VM protegida através dos seguintes itens do corpo do pedido booleano:

• enableSecureBoot: ativa ou desativa o arranque seguro

  O Arranque seguro ajuda a proteger as instâncias de VM contra software malicioso e rootkits ao nível do arranque e do kernel. Para mais informações, consulte o artigo Arranque seguro.

• enableVtpm: ativa ou desativa o Trusted Platform Module virtual (vTPM)

  O vTPM permite o arranque medido, que valida a integridade do pré-arranque e do arranque da MV. Para mais informações, consulte o artigo Módulo de plataforma fidedigna virtual (vTPM).

  Importante: a desativação do vTPM também desativa a monitorização da integridade, uma vez que esta depende dos dados recolhidos pelo arranque medido.

• enableIntegrityMonitoring: ativa ou desativa a monitorização da integridade

  A monitorização da integridade permite-lhe monitorizar e validar a integridade de arranque em tempo de execução das suas instâncias de VM protegida através de relatórios do Cloud Monitoring. Para mais informações, consulte o artigo Monitorização da integridade.

Para saber mais acerca dos parâmetros de pedido, consulte o método instanceTemplates.insert.

Crie um modelo de instância com base numa instância existente

Pode usar a CLI REST ou gcloud para guardar a configuração de uma instância de VM existente como um modelo de instância. Opcionalmente, pode substituir a forma como os discos de origem são definidos no modelo.

Se precisar de substituir outras propriedades, comece por criar um modelo de instância com base numa instância existente e, em seguida, crie um modelo semelhante com substituições adicionais.

Aviso: se a instância existente contiver um endereço IP externo estático, esse endereço é copiado para o modelo de instância e pode limitar a utilização do modelo.

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

• Todas as autorizações necessárias para chamar o método instanceTemplates.insert.

gcloud

Use o comando gcloud compute instance-templates create com as flags --source-instance e --source-instance-zone. Se quiser criar um modelo de instância regional, também tem de usar a flag --instance-template-region para especificar a região do modelo de instância.

Para criar um modelo de instância regional, use o seguinte comando:

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

Para criar um modelo de instância global, use o seguinte comando:

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

Para substituir a forma como os discos da instância de origem são definidos, adicione uma ou mais flags --configure-disk.

O exemplo seguinte cria um modelo de instância global a partir de uma instância existente e substitui o disco da instância de origem pelas especificações que fornecer.

  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

Substitua o seguinte:

• INSTANCE_TEMPLATE_NAME é o nome do modelo a criar.
• SOURCE_INSTANCE é o nome da instância a usar como modelo para o novo modelo.
• SOURCE_INSTANCE_ZONE é a zona que contém a instância de origem.
• SOURCE_DISK é o nome de um disco de instância de origem que quer substituir no modelo.

• INSTANTIATE_OPTIONS especifica se deve incluir o disco e que imagem usar. Os valores válidos dependem do tipo de disco:

  • source-image ou source-image-family (válido apenas para discos de arranque e outros discos de leitura/escrita persistentes). Especifique esta opção se quiser usar a mesma imagem de origem ou família de imagens de origem que foi usada para criar o disco na instância da VM de origem.

  • custom-image (válido apenas para o arranque e outros discos de leitura/escrita persistentes). Se quiser reter aplicações e definições das VMs de origem no modelo de instância, pode criar uma imagem personalizada e, em seguida, especificá-la quando criar o modelo. Se especificado, indique o caminho ou o URL da imagem personalizada, conforme mostrado no exemplo seguinte. Em alternativa, pode especificar uma família de imagens através do seguinte 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 apenas para discos só de leitura).

  • blank (válido apenas para discos persistentes não de arranque e SSDs locais). Se especificado, quando o modelo é usado para criar uma nova instância, o disco é criado sem formatação. Tem de formatar e montar o disco num script de arranque antes de o poder usar numa configuração escalável.

  • do-not-include (válido apenas para discos persistentes não de arranque e discos só de leitura).

• AUTO_DELETE especifica se o disco é eliminado automaticamente quando a instância é eliminada. Os valores válidos são: false, no, true e yes.

Por exemplo, o seguinte comando cria um modelo de instância com base em my-source-instance, com a opção de usar a imagem original de data-disk-a, mas define a eliminação automática como true e substitui data-disk-b por uma imagem 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 criar um modelo de instância regional, use o método regionInstanceTemplates.insert ou, para criar um modelo de instância global, use o método instanceTemplates.insert.

No seu pedido, tem de especificar o campo sourceInstance. Para substituir a forma como os discos da instância de origem estão definidos, adicione um ou mais campos diskConfigs.

Por exemplo, faça a seguinte chamada para criar um modelo de instância global a partir de uma instância 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
      }
    ]
  }
}

Substitua o seguinte:

• PROJECT_ID: o ID do projeto
• INSTANCE_TEMPLATE_NAME: o nome do novo modelo
• SOURCE_INSTANCE_ZONE: a zona da instância de origem
• SOURCE_INSTANCE: o nome da instância de origem a usar como modelo para este modelo de instância
• SOURCE_DISK: o nome de um disco de instância de origem que quer substituir no modelo

• INSTANTIATE_OPTIONS: especifica se deve incluir o disco e que imagem usar

  Os valores válidos dependem do tipo de disco:

  • source-image ou source-image-family (válido apenas para discos de arranque e outros discos persistentes de leitura/escrita).

  • custom-image (válido apenas para o arranque e outros discos de leitura/escrita persistentes). Se quiser reter aplicações e definições das VMs de origem no modelo de instância, pode criar uma imagem personalizada e, em seguida, especificá-la quando criar o modelo. Se especificado, indique o caminho ou o URL da imagem personalizada, conforme mostrado no exemplo seguinte. Em alternativa, pode especificar uma família de imagens através do seguinte formato:

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

  • attach-read-only (válido apenas para discos só de leitura).

  • blank (válido apenas para discos persistentes não de arranque e SSDs locais). Se especificado, quando o modelo é usado para criar uma nova instância, o disco é criado sem formatação. Tem de formatar e montar o disco num script de arranque antes de o poder usar numa configuração escalável.

  • do-not-include (válido apenas para discos persistentes não de arranque e discos só de leitura).

O exemplo seguinte cria um novo modelo de instância com base em my-source-instance. No modelo de instância, a imagem de data-disk-a é substituída 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"
      }
    ]
  }
}

A tabela seguinte mostra como as opções para substituir discos são definidas no modelo.

Tipo de disco	Opções
Disco de arranque	[Predefinição] Use a mesma imagem de origem ou família de imagens que foi usada para criar o disco de arranque na instância de origem. Use o URL de qualquer imagem (personalizada ou pública), conforme descrito no exemplo anterior, ou especifique uma família de imagens com o seguinte formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Outros discos persistentes de leitura/escrita	[Predefinição] Use a mesma imagem de origem/família de imagens de origem que foi usada para criar o disco na instância de origem. Nota: se o disco da instância de origem não tiver uma propriedade de imagem de origem/família de imagens de origem, é incluído no modelo como um disco em branco. Use o URL de qualquer imagem (personalizada ou pública), conforme descrito no exemplo anterior, ou especifique uma família de imagens com o seguinte formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Em alternativa, use um disco em branco no modelo. Quando o modelo é usado para criar uma nova instância, este disco é criado sem formatação. Tem de formatar e montar o disco num script de arranque antes de o poder usar numa configuração escalável. Não inclua o disco.
Discos só de leitura	[Predefinição] Inclua o disco no modo de leitura. Não inclua o disco.
SSD(s) local(ais)	[Predefinição] Inclua um SSD local em branco. Quando o modelo é usado para criar uma nova instância, este disco é criado sem formatação. Tem de formatar e montar o disco num script de arranque antes de o poder usar numa configuração escalável.

Para cada disco, também pode substituir o atributo auto-delete para especificar se o disco deve ser eliminado quando a instância associada for eliminada.

Por predefinição, se não forem especificadas opções de substituição, a configuração do disco no modelo corresponde à instância de origem.

Crie um modelo de instância com base num modelo existente

Não pode atualizar um modelo de instância existente. No entanto, se um modelo de instância ficar desatualizado ou se precisar de fazer alterações, pode criar outro com propriedades semelhantes através da consola.

1. Aceda à página Modelos de instâncias.

   Aceda a Modelos de instâncias

2. Clique no modelo de instância que quer copiar e atualizar.

3. Clique em Criar semelhante.

4. Atualize a configuração no novo modelo.

5. Clique em Criar.

Crie um modelo de instância para VMs com GPU

Quando cria um modelo de instância, pode configurá-lo para criar VMs com GPUs anexadas especificando o seguinte:

• Um tipo de máquina que suporta o tipo de GPU que quer. Se quiser criar um modelo de instância regional, o tipo de GPU que especificar no modelo tem de estar disponível, pelo menos, numa zona da região.

• Uma política de manutenção que para as VMs durante os eventos de manutenção do anfitrião.

Nota: se quiser executar cargas de trabalho de ciência de dados ou aprendizagem automática, considere usar uma imagem de VM de aprendizagem profunda quando criar um modelo de instância. As Deep Learning VM Images são um conjunto de imagens de VMs pré-instaladas com frameworks de aprendizagem automática e ferramentas essenciais. Para mais informações sobre estas imagens, consulte o artigo Escolha uma imagem na documentação sobre imagens de VMs de aprendizagem profunda.

Autorizações necessárias para esta tarefa

Para realizar esta tarefa, tem de ter as seguintes autorizações:

• Todas as autorizações necessárias para chamar o método instanceTemplates.insert.

Consola

Para criar um modelo de instância para VMs de GPU, faça o seguinte:

1. Na Google Cloud consola, aceda à página Modelos de instâncias.

   Aceda a Modelos de instâncias

2. Clique em Criar modelo de instância.

3. No campo Nome, introduza um nome para o modelo de instância.

4. Na secção Localização, selecione uma das seguintes opções:

   • Para criar um modelo de instância global, selecione Global (predefinição).

   • Para criar um modelo de instância regional, selecione Regional e, de seguida, selecione a região onde quer criar o modelo de instância.

5. Na secção Configuração da máquina, faça o seguinte:

   1. Clique no separador GPUs.

   2. No menu Tipo de GPU, selecione o tipo de GPU.

   3. No menu Número de GPUs, selecione o número de GPUs.

   4. Opcional: se o modelo da sua GPU suportar estações de trabalho virtuais (vWS) NVIDIA RTX para cargas de trabalho de gráficos, e planeia executar cargas de trabalho com utilização intensiva de gráficos, selecione Ativar estação de trabalho virtual (NVIDIA GRID).

   5. Na secção Tipo de máquina, selecione um tipo de máquina.

6. Opcional: para alterar o tipo ou a imagem do disco de arranque predefinido, na secção Disco de arranque, clique em Alterar. Em seguida, siga as instruções para alterar o disco de arranque.

7. Clique em Criar.

gcloud

Para criar um modelo de instância para VMs de GPU, use o comando instance-templates create com a flag --maintenance-policy definida como TERMINATE.

Por exemplo, para criar um modelo de instância global para VMs de GPU, use o seguinte comando:

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

Substitua o seguinte:

• INSTANCE_TEMPLATE_NAME: o nome do modelo de instância.

• IMAGE_PROJECT: o projeto de imagem que contém a imagem; por exemplo, debian-cloud. Para mais informações sobre os projetos de imagens suportados, consulte o artigo Imagens públicas.

• IMAGE_FAMILY ou IMAGE: especifique uma das seguintes opções:

  • IMAGE_FAMILY: uma família de imagens. Isto especifica a imagem do SO mais recente e não descontinuada. Por exemplo, se especificar debian-10, é usada a versão mais recente na família de imagens Debian 10. Para mais informações sobre a utilização de famílias de imagens, consulte o artigo Práticas recomendadas para famílias de imagens.

  • IMAGE: uma versão específica da imagem do SO; por exemplo, debian-10-buster-v20200309. Se optar por especificar uma versão específica da imagem do SO, tem de substituir a flag --image-family pela flag --image.

• MACHINE_TYPE: o tipo de máquina das VMs. Se especificar um tipo de máquina N1, inclua a flag --accelerator para especificar o número e o tipo de GPUs a associar às suas VMs.

Por exemplo, suponha que quer criar um modelo de instância global para VMs de GPU que especifique as seguintes propriedades:

• Um tipo de máquina predefinido N1 com 2 vCPUs.

• Uma GPU NVIDIA T4 para associar às VMs.

• Debian como projeto de imagem.

• Debian 10 como família de imagens.

Para criar o modelo de instância de exemplo, use o seguinte 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 criar um modelo de instância, use um dos seguintes recursos:

• Para um modelo de instância regional, use o recurso google_compute_region_instance_template.
• Para um modelo de instância global, use o recurso google_compute_instance_template.

O exemplo seguinte cria um modelo de instância global que especifica um tipo de máquina predefinido N1 com 2 vCPUs e uma GPU NVIDIA T4 anexada:

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"
  }
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte os comandos básicos do Terraform.

REST

Para criar um modelo de instância para VMs com GPU, faça um pedido POST ao método instanceTemplates.insert. No corpo do pedido, inclua o campo onHostMaintenance e defina-o como TERMINATE.

Por exemplo, para criar um modelo de instância global para VMs de GPU, faça um pedido da seguinte forma:POST

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"
    }
  }
}

Substitua o seguinte:

• PROJECT_ID: o ID do projeto no qual quer criar o modelo de instância.

• INSTANCE_TEMPLATE_NAME: o nome do modelo de instância.

• IMAGE_PROJECT: o projeto de imagem que contém a imagem; por exemplo, debian-cloud. Para mais informações sobre os projetos de imagens suportados, consulte o artigo Imagens públicas.

• IMAGE ou IMAGE_FAMILY: especifique uma das seguintes opções:

  • IMAGE: uma versão específica da imagem do SO; por exemplo, debian-10-buster-v20200309.

  • IMAGE_FAMILY: uma família de imagens. Isto especifica a imagem do SO mais recente e não descontinuada. Por exemplo, se especificar family/debian-10, é usada a versão mais recente na família de imagens Debian 10. Para mais informações sobre a utilização de famílias de imagens, consulte o artigo Práticas recomendadas para famílias de imagens.

• MACHINE_TYPE: o tipo de máquina das VMs. Se especificar um tipo de máquina N1, inclua o campo guestAccelerators para especificar o número e o tipo de GPUs a associar às suas VMs.

Por exemplo, suponha que quer criar um modelo de instância global para VMs de GPU que especifique as seguintes propriedades:

• Um tipo de máquina predefinido N1 com 2 vCPUs.

• Uma GPU NVIDIA T4 para associar às VMs.

• Debian como projeto de imagem.

• Debian 10 como família de imagens.

Para criar o modelo de instância de exemplo, faça um pedido POST da seguinte forma:

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 mais opções de configuração ao criar um modelo de instância, consulte o artigo Criar um modelo de instância neste documento.

Crie um modelo de instância com uma imagem de contentor

Nota: a funcionalidade do Compute Engine que implementa contentores em VMs durante a criação de VMs foi descontinuada. Use os comandos docker run num script de arranque ou use a ferramenta cloud-init para configurar e executar contentores nas suas VMs e MIGs. Para mais informações, consulte o artigo Migre contentores implementados em VMs durante a criação de VMs.

Pode especificar uma imagem de contentor num modelo de instância. Por predefinição, o Compute Engine também inclui no modelo uma imagem do SO otimizado para contentores com o Docker instalado. Quando usa o modelo para criar uma nova instância, o contentor é iniciado automaticamente quando a instância é iniciada.

Consola

Nota: a opção Implementar contentor na Google Cloud consola foi descontinuada. Use o comando docker run equivalente para configurar e executar o contentor.

1. Aceda à página Modelos de instâncias.

   Aceda a Modelos de instâncias

2. Clique em Criar modelo de instância.

3. Na secção Contentor, clique em Implementar contentor.

4. Na caixa de diálogo Configurar contentor, especifique a Imagem do contentor a usar.

   • Pode especificar uma imagem do Container Registry ou do Artifact Registry. Por exemplo:
     • gcr.io/cloud-marketplace/google/nginx1:TAG, onde TAG é a etiqueta definida para uma versão específica da imagem do contentor NGINX disponível no Google Cloud Marketplace.
     • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 seleciona uma imagem de amostra hello-app armazenada no Artifact Registry.
   • Se usar uma imagem de contentor do Docker Hub, especifique sempre o nome completo da imagem Docker. Por exemplo, especifique o seguinte nome da imagem para implementar uma imagem de contentor do Apache: docker.io/httpd:2.4.

5. Opcionalmente, clique em Opções avançadas do contentor. Para mais informações, consulte Configurar opções para executar o seu contentor.

6. Clique em Criar.

gcloud

Nota: o comando da CLI gcloud está descontinuado.create-with-container Use o comando docker run equivalente para configurar e executar o contentor.

Use o comando gcloud compute instance-templates create-with-container:

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

Substitua o seguinte:

• INSTANCE_TEMPLATE_NAME: O nome do modelo a criar.
• CONTAINER_IMAGE: o nome completo da imagem do contentor a usar.

Por exemplo, o comando seguinte cria um novo modelo de instância com o nome nginx-vm. Uma instância de VM criada a partir deste modelo é iniciada e executa a imagem do contentor, gcr.io/cloud-marketplace/google/nginx1:TAG, quando a VM é iniciada.

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

Substitua TAG pela etiqueta definida para uma versão específica da imagem do contentor do NGINX disponível no Google Cloud Marketplace.

Também pode configurar as opções para executar o contentor.

Atenção: o Container Registry foi descontinuado. A partir de 18 de março de 2025, o Container Registry é encerrado e a gravação de imagens no Container Registry fica indisponível. Para ver detalhes sobre a descontinuação e como migrar para o Artifact Registry, consulte Descontinuação do Container Registry.

Crie um modelo de instância que especifique uma sub-rede

gcloud

Para criar um modelo de instância regional ou global, use o comando instance-templates create. Use a flag --subnet para colocar instâncias criadas a partir do modelo na sub-rede da sua escolha. A flag --subnet requer a flag --region.

Se quiser criar um modelo de instância regional, tem de usar a flag --instance-template-region para definir a região do modelo. Certifique-se de que usa uma sub-rede da mesma região onde quer criar o modelo de instância 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

Substitua o seguinte:

• INSTANCE_TEMPLATE_NAME: o nome do modelo de instância
• REGION: a região da sub-rede

• SUBNET_NAME_OR_URL: o nome da sub-rede ou o URL da mesma

  Nota: se usar o nome da sub-rede, a Google encontra essa sub-rede na região de destino (desde que exista nessa região). No entanto, se usar o URL da sub-rede, o modelo de instância só pode ser usado para criar instâncias na região específica associada ao URL da sub-rede.

• STACK_TYPE: Opcional: se o IPv6 está ativado na interface de rede predefinida. Podem ser usados os seguintes valores: IPV4_ONLY, IPV4_IPV6 ou IPV6_ONLY. Se não incluir este sinalizador, o valor predefinido é IPV4_ONLY.

• INSTANCE_TEMPLATE_REGION: a região onde quer criar o modelo de instância. Esta região tem de ser igual a REGION.

O exemplo seguinte cria um modelo denominado template-qa que apenas cria instâncias na sub-rede subnet-us-qa.

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

O resultado é semelhante ao seguinte:

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)

A utilização deste modelo para criar instâncias para um MIG (com ou sem dimensionamento automático) cria automaticamente a instância na região e sub-rede especificadas. Isto permite-lhe controlar a sub-rede de novas instâncias criadas para o balanceamento de carga.

Use imagens personalizadas ou públicas nos seus modelos de instâncias

Pode usar uma imagem personalizada ou uma imagem pública para os seus modelos de instâncias:

• Imagens personalizadas. Como os MIGs são concebidos para adicionar e remover instâncias com frequência, é útil criar uma imagem personalizada e especificá-la no modelo de instância. Pode preparar a imagem com as aplicações e as definições de que as VMs precisam, para não ter de configurar manualmente esses itens em VMs individuais no MIG.

• Imagens públicas. Pode criar um modelo de instância que use uma imagem pública e um script de arranque para preparar a instância depois de começar a ser executada.

As imagens personalizadas são mais determinísticas e iniciam-se mais rapidamente do que as VMs com scripts de arranque. No entanto, os scripts de arranque são mais flexíveis, o que ajuda a atualizar as apps e as definições nas suas instâncias.

Se estiver a gerir imagens através de famílias de imagens, pode especificar o nome da sua família de imagens personalizada ou pública no modelo de instância. Para mais informações sobre famílias de imagens, consulte as práticas recomendadas quando usar famílias de imagens no Compute Engine.

Nota: se a imagem que quer usar pertencer a um projeto diferente, pode continuar a usar essa imagem no seu modelo de instância, desde que o proprietário desse projeto conceda ao MIG acesso às imagens. Para mais informações, consulte o artigo Conceder a um MIG acesso a imagens.

O que se segue?

• Veja um modelo de instância para ver o respetivo ID e propriedades da instância.
• Crie uma VM a partir de um modelo de instância.
• Crie um grupo de instâncias geridas (MIG).
• Atualize as VMs num MIG existente para usar as propriedades de um modelo de instância diferente.
• Crie uma reserva para VMs.