Criar modelos de instância

---

Nesta página, você aprenderá a criar e gerenciar modelos de instância. Com esses modelos, é possível especificar o tipo de máquina, a imagem do disco de inicialização, a rede e outras propriedades de VM que você quer usar ao criar instâncias de máquina virtual (VM).

É possível usar modelos de instância para fazer o seguinte:

• Criar VMs individuais.
• Criar VMs em um grupo gerenciado de instâncias (MIG).
• Criar reservas para VMs.
• Criar reservas futuras para VMs.

Antes de começar

• Leia quando e por que criar modelos deterministas de instância.
• Leia sobre os modelos de instâncias regionais e globais.
• Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine da seguinte maneira.
  

  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 os exemplos do Terraform nesta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e, em seguida, configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Confira mais informações em Set up authentication for a local development environment.

  Go

  Para usar os exemplos Go desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Confira mais informações em Set up authentication for a local development environment.

  Java

  Para usar os exemplos Java desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Confira mais informações em Set up authentication for a local development environment.

  Node.js

  Para usar os exemplos Node.js desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Confira mais informações em Set up authentication for a local development environment.

  Python

  Para usar os exemplos Python desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Confira mais informações em Set up authentication for a local development environment.

  REST

  Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

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

  gcloud init

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

Limitações

• A VPC compartilhada em interfaces diferentes de nic0 para modelos de instância é compatível com a gcloud CLI e a REST, mas não com o console do Google Cloud.
• Não é possível atualizar nem alterar um modelo de instância depois de criá-lo. Caso tenha um modelo desatualizado ou precise fazer alterações na configuração, crie outro modelo.
• Se você quiser especificar uma família de imagens em um modelo de instância, não poderá usar o console do Google Cloud. Em vez disso, use a CLI do Google Cloud ou a REST.
• Se quiser especificar um Persistent Disk regional em um modelo de instância, não poderá usar o console do Google Cloud. Em vez disso, use a CLI do Google Cloud ou a REST.
• É possível usar um modelo de instância para criar VMs com um disco de inicialização equilibrado de hiperdisco que estiver em um pool de armazenamento desde que o pool de armazenamento esteja na mesma zona que a VM foi criada. Não é possível usar modelos de instância global para criar VMs com discos não inicializáveis em um pool de armazenamento.

Criar um modelo de instância

A maioria das propriedades de VM que você pode especificar em uma solicitação para criar uma instância de VM individual também pode ser especificada para um modelo de instância, incluindo metadados de VM, scripts de inicialização, discos permanentes e contas de serviço. Especifique o tipo de máquina, o disco de inicialização e a rede.

Crie um modelo de instância regional ou global usando o console do Google Cloud, a CLI do Google Cloud ou a API. Para criar um modelo global de instância, também é possível usar o Terraform ou as bibliotecas de clientes do Cloud.

Permissões exigidas para a tarefa

Para executar esta tarefa, é necessário ter permissões:

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

Console

1. No Console do Google Cloud, acesse a página Modelos de instância.

   Acesse "Modelos de instância"

   As etapas restantes aparecem no console do Google Cloud.

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

5. Nos campos a seguir, aceite os valores padrão ou os modifique conforme necessário. Os valores padrão mudam com base na família de máquinas que você seleciona.

   • Selecione um tipo de máquina.
   • Para atualizar o tipo ou a imagem do disco de inicialização, clique em Alterar na seção Disco de inicialização.
   • Para atualizar a interface de rede ou as configurações de endereço IP, clique em Opções avançadas. Depois, clique em Rede e, depois, na interface de rede que você quer editar.

6. Opcional: se você escolher uma imagem compatível com a VM protegida, altere as configurações de VM protegida da VM:

   1. Clique em Opções avançadas e na guia Segurança.
   2. Se você quiser desativar a Inicialização segura, desmarque a caixa de seleção Ativar a Inicialização segura. A inicialização segura ajuda a proteger as instâncias de VM contra malware e rootkits nos níveis de inicialização e kernel. Para mais informações, consulte Inicialização segura.

   3. Se quiser desativar o módulo da plataforma virtual confiável (vTPM, na sigla em inglês), desmarque a caixa de seleção Ativar vTPM. O vTPM permite a Inicialização medida, que valida a integridade da VM antes e durante a inicialização. Para mais informações, consulte Módulo da plataforma virtual confiável (vTPM).

      Importante: ao desativar o vTPM, você também desativa o monitoramento de integridade, que depende dos dados coletados pela Inicialização medida.

   4. Se você quiser desativar o monitoramento de integridade, desmarque a caixa de seleção Ativar monitoramento de integridade. Com o monitoramento de integridade, você consegue monitorar a integridade da inicialização das instâncias de VM protegidas usando o Cloud Monitoring. Para mais informações, consulte Monitoramento de integridade.

7. Opcional: em Opções avançadas, clique nas guias para personalizar ainda mais o modelo. Por exemplo, adicione até 15 discos secundários que não sejam de inicialização.

8. Opcional: clique em REST equivalente para visualizar o corpo da solicitação 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, use a flag --instance-template-region para definir a região do modelo.

Crie um modelo de instância regional usando o seguinte comando:

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

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

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Se você não fornecer as configurações do modelo explícitas, o gcloud compute usará os seguintes valores padrão:

• Tipo de máquina: o tipo de máquina, por exemplo, n1-standard-1
• Imagem: a imagem mais recente do Debian
• Disco de inicialização: um novo disco de inicialização padrão nomeado conforme a VM
• Rede: a rede VPC padrão
• Endereço IP: um endereço IP externo temporário

Também é possível definir explicitamente essas configurações. Por exemplo:

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

é possível adicionar até 15 discos secundários que não sejam de inicialização. Especifique a sinalização --create-disk para cada disco secundário criado. Para criar discos secundários com base em uma imagem pública ou personalizada, especifique as propriedades image e image-project para cada disco na sinalização --create-disk. Para criar um disco em branco, não inclua essas propriedades. Se quiser, inclua as propriedades size e type do disco. Para especificar discos permanentes regionais, use a propriedade replica-zones.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --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

Dica: ao especificar os parâmetros de disco, os caracteres ^:^ especificam que o caractere de separação entre os valores é dois pontos (:) em vez da vírgula esperada (,).

Substitua:

• INSTANCE_TEMPLATE_NAME: o nome do modelo.
• REGION: a região em que você quer criar o modelo de instância regional.

• IMAGE_FAMILY: uma família de imagens a ser usada como disco que não é de inicialização

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

  Em vez disso, use a flag --image=IMAGE para especificar uma versão específica de uma imagem.

  Para discos vazios, não especifique a propriedade image-family ou image.

• DISK_IMAGE_PROJECT: o projeto que contém a imagem

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

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

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

• DISK_TYPE: (opcional) o tipo de disco a ser criado. Se não for especificado, o padrão será pd-standard ou pd-balanced, dependendo do tipo de máquina.

• ZONE e REMOTE_ZONE: a zona em que o Persistent Disk regional será criado e a zona em que ele será replicado.

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

Se tiver escolhido uma imagem compatível com a VM protegida, você poderá alterar as configurações de VM protegida da instância usando uma das sinalizações a seguir:

• --no-shielded-secure-boot: desativar a inicialização segura

  A inicialização segura ajuda a proteger as instâncias de VM contra malware e rootkits nos níveis de inicialização e kernel. Para mais informações, consulte Inicialização segura.

• --no-shielded-vtpm: desativar o módulo da plataforma virtual confiável (vTPM, na sigla em inglês)

  O vTPM permite a Inicialização medida, que valida a integridade da VM antes e durante a inicialização. Para mais informações, consulte Módulo da plataforma virtual confiável (vTPM).

  Importante: ao desativar o vTPM, você desabilita também o monitoramento de integridade, que depende dos dados coletados pela Inicialização medida.

• --no-shielded-integrity-monitoring: desativar o monitoramento de integridade

  O monitoramento de integridade permite monitorar a integridade da inicialização das instâncias de VM protegidas usando o Cloud Monitoring. Para mais informações, consulte Monitoramento de integridade.

Para uma lista de todos os subcomandos e sinalizações disponíveis, consulte a referência de instance-templates.

Um modelo com as configurações padrão é semelhante a este:

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-10
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: e2-standard-2
  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 criar um modelo de instância, use o recurso google_compute_instance_template.

O exemplo a seguir do Terraform é semelhante ao seguinte comando da CLI gcloud:

gcloud compute instance-templates create my-instance-template \
    --machine-type=e2-standard-4 \
    --image-family=debian-9 \
    --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"
    ]
  }
}

Para saber como aplicar ou remover uma configuração do Terraform, consulte 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 uma solicitação POST para o método regionInstanceTemplates.insert da seguinte maneira:

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

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

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

Adicione até 15 discos de não inicialização secundários usando a propriedade disks, com um campo para cada disco adicional. Para cada disco adicional, você pode fazer o seguinte:

• Crie discos extras com uma imagem pública ou privada.
• Para adicionar um disco vazio, defina a entrada initializeParams sem o valor sourceImage.
• Para criar discos permanentes regionais, defina a entrada initializeParams com a propriedade replicaZones.

No corpo da solicitação, forneça 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:

• PROJECT_ID: o ID do projeto
• REGION: a região em que você quer criar o modelo de instância regional.
• INSTANCE_TEMPLATE_NAME: o nome do modelo de instância
• ZONE: a zona em que 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 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

    Isso cria a VM a partir da imagem do SO mais recente e não obsoleta. Por exemplo, se você especificar "sourceImage": "projects/debian-cloud/global/images/family/debian-10", o Compute Engine criará uma VM 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 práticas recomendadas ao usar famílias de imagens no Compute Engine.

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

• PROJECT_NAME: o projeto associado à VM.

• REMOTE_ZONE: a zona em que o disco regional será replicado.

Especifique uma das opções a seguir para a propriedade disks:

• Especifique initializeParams para criar discos de inicialização permanentes para cada instância. Adicione até 15 discos secundários que não sejam de inicialização usando a propriedade initializeParams de cada disco adicional. É possível criar discos usando imagens públicas ou personalizadas (ou famílias de imagens) em sourceImage, conforme mostrado no exemplo anterior. Para adicionar discos em branco, não especifique um sourceImage.

• Especifique source para anexar um disco de inicialização permanente atual. Se você anexar um disco de inicialização, só será possível criar uma instância do seu modelo.

Opcionalmente, é possível especificar as propriedades diskSizeGb, diskType e labels para initializeParams e a propriedade diskSizeGb para source.

Se você tiver escolhido uma imagem compatível com VM protegida, será possível alterar as configurações da VM protegida da VM usando os itens do corpo da solicitação booleana a seguir:

• enableSecureBoot: ativar ou desativar a inicialização segura

  A inicialização segura ajuda a proteger as instâncias de VM contra malware e rootkits nos níveis de inicialização e kernel. Para mais informações, consulte Inicialização segura.

• enableVtpm: ativar ou desativar o módulo de plataforma virtual confiável (vTPM, na sigla em inglês)

  O vTPM permite a Inicialização medida, que valida a integridade da VM antes e durante a inicialização. Para mais informações, consulte Módulo da plataforma virtual confiável (vTPM).

  Importante: ao desativar o vTPM, você também desativa o monitoramento de integridade, que depende dos dados coletados pela Inicialização medida.

• enableIntegrityMonitoring: ativar ou desativar o monitoramento de integridade.

  O monitoramento de integridade permite monitorar e verificar a integridade da inicialização do ambiente de execução das instâncias de VM protegidas usando relatórios do Cloud Monitoring. Para mais informações, consulte Monitoramento de integridade.

Para saber mais sobre os parâmetros de solicitação, consulte o método instanceTemplates.insert.

Como criar um modelo com base em uma instância atual

É possível usar a REST ou a gcloud CLI para salvar a configuração de uma instância de VM que já existe como um modelo de instância. Como opção, modifique a maneira como os discos de origem são definidos no modelo.

Se você precisar modificar outras propriedades, primeiro crie um modelo com base em uma instância atual e, em seguida, crie um modelo semelhante com outras modificações.

Aviso: se a instância atual contiver um endereço IP externo estático, esse endereço será copiado para o modelo de instância e poderá limitar o uso dele.

Permissões exigidas para a tarefa

Para executar esta tarefa, é necessário ter permissões:

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

gcloud

Use o comando gcloud compute instance-templates create com as sinalizações --source-instance e --source-instance-zone. Se você quiser criar um modelo de instância regional, use também 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 global de instância, use o seguinte comando:

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

Para modificar como os discos da instância de origem são definidos, adicione uma ou mais flags --configure-disk:

O exemplo a seguir cria um modelo de instância global a partir de uma instância atual e substitui o disco da instância de origem com as especificações fornecidas por você.

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:

• INSTANCE_TEMPLATE_NAME é o nome do modelo a ser criado.
• SOURCE_INSTANCE é o nome da instância a ser usada como modelo para o novo modelo.
• SOURCE_INSTANCE_ZONE é a zona que contém a instância de origem.
• REGION é a região em que você quer criar o modelo de instância regional.
• SOURCE_DISK é o nome de um disco de instância de origem que você quer substituir no modelo.

• INSTANTIATE_OPTIONS especifica se você precisa incluir o disco e qual imagem usar. Os valores válidos dependem do tipo de disco:

  • source-image ou source-image-family: válido somente para discos de inicialização e outros discos de leitura/gravação permanentes. Especifique esta opção se você quiser usar a mesma imagem de origem ou família de imagens de origem que foi usada para criar o disco na instância de VM de origem.

  • custom-image: válido somente para discos de inicialização e outros discos de leitura/gravação permanentes. Se quiser manter aplicativos e configurações das VMs de origem no modelo de instância, crie uma imagem personalizada e especifique-a ao criar o modelo. Se especificado, forneça o caminho ou URL para a imagem personalizada, conforme mostrado no exemplo a seguir. Como alternativa, também é possível especificar uma família de imagens usando o 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 somente leitura.

  • blank: válido apenas para discos permanentes que não sejam de inicialização e SSDs locais. Se especificado, quando o modelo for usado para criar uma nova instância, o disco será criado sem formatação. Formate e ative o disco em um script de inicialização para poder usá-lo em uma configuração escalonável.

  • do-not-include: válido apenas para discos permanentes que não sejam de inicialização e discos somente leitura.

• AUTO_DELETE especifica se o disco será excluído automaticamente quando a instância for excluída. Os valores válidos são: false, no, true e yes.

Por exemplo, o comando a seguir 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 definindo a exclusão automática como true e substituindo 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.

Na solicitação, especifique o campo sourceInstance. Para modificar a maneira como os discos da instância de origem são definidos, adicione um ou mais campos diskConfigs.

Por exemplo, faça a seguinte chamada para criar um modelo global de instância a partir de uma instância atual.

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:

• 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 ser usada como modelo para esse modelo de instância
• SOURCE_DISK o nome de um disco de instância de origem que você quer substituir no modelo

• INSTANTIATE_OPTIONS especifica se precisa incluir o disco e qual imagem usar

  Os valores válidos dependem do tipo de disco:

  • source-image ou source-image-family: válido somente para discos de inicialização e outros discos de leitura/gravação permanentes.

  • custom-image: válido somente para discos de inicialização e outros discos de leitura/gravação permanentes. Se quiser manter aplicativos e configurações das VMs de origem no modelo de instância, crie uma imagem personalizada e especifique-a ao criar o modelo. Se especificado, forneça o caminho ou URL para a imagem personalizada, conforme mostrado no exemplo a seguir. Como alternativa, também é possível especificar uma família de imagens usando o 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 somente leitura.

  • blank: válido apenas para discos permanentes que não sejam de inicialização e SSDs locais. Se especificado, quando o modelo for usado para criar uma nova instância, o disco será criado sem formatação. Formate e ative o disco em um script de inicialização para poder usá-lo em uma configuração escalonável.

  • do-not-include: válido apenas para discos permanentes que não sejam de inicialização e discos somente leitura.

O exemplo a seguir 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 a seguir mostra como as opções de substituição de discos são definidas no modelo.

Tipo de disco	Opções
Disco de inicialização	[Padrão] Use a mesma imagem de origem ou família de imagens que foi usada para criar o disco de inicialização 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 usando o seguinte formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Outros discos permanentes de leitura/gravação	[Padrão] Use a mesma imagem/família de imagens de origem que foi usada para criar o disco na instância de origem. Observação: se o disco da instância de origem não tiver uma imagem de origem ou uma propriedade de família de imagem desse tipo, ele será incluído no modelo como um disco vazio. Use o URL de qualquer imagem (personalizada ou pública), conforme descrito no exemplo anterior, ou especifique uma família de imagens usando o seguinte formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Use um disco vazio no modelo. Quando o modelo é usado para criar uma nova instância, esse disco é criado sem formatação. Formate e ative o disco em um script de inicialização para poder usá-lo em uma configuração escalonável. Não inclua o disco.
Discos somente de leitura	[Padrão] Inclua o disco no modo somente leitura. Não inclua o disco.
SSDs locais	[Padrão] Inclua um SSD local em branco. Quando o modelo é usado para criar uma nova instância, esse disco é criado sem formatação. Formate e ative o disco em um script de inicialização para poder usá-lo em uma configuração escalonável.

Também é possível modificar o atributo auto-delete para cada disco, especificando se ele precisa ser excluído ou não quando sua instância associada for excluída.

Por padrão, se nenhuma opção de modificação for especificada, a configuração do disco no modelo corresponderá à instância de origem.

Como criar um modelo de instância com base em um modelo atual

Não é possível atualizar um modelo de instância atual. No entanto, se um modelo de instância ficar desatualizado ou se você precisar fazer alterações, use o console para criar outro com propriedades semelhantes.

1. Acesse a página Modelos de instância.

   Acesse "Modelos de instância"

2. Clique no modelo da instância que você quer copiar e atualizar.

3. Clique em Criar semelhante.

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

5. Clique em Criar.

Criar um modelo de instância para VMs de GPU

Ao criar um modelo de instância, é possível configurá-lo para criar VMs com GPUs anexadas especificando o seguinte:

• Um tipo de máquina compatível com o tipo de GPU que você quiser. Se você quiser criar um modelo de instância regional, o tipo de GPU especificado no modelo precisa estar disponível em pelo menos uma zona na região.

• Uma política de manutenção que interrompa as VMs durante eventos de manutenção do host.

Observação: se você quiser executar cargas de trabalho de ciência de dados ou de machine learning, considere usar uma imagem de VM de aprendizado profundo ao criar um modelo de instância. O Deep Learning VM Images é um conjunto de imagens de VM predefinidas que acompanha frameworks de machine learning e ferramentas essenciais. Para mais informações sobre essas imagens, consulte Escolher uma imagem na documentação de imagens de VM de aprendizado profundo.

Permissões exigidas para a tarefa

Para executar esta tarefa, é necessário ter permissões:

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

Console

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

1. No Console do Google Cloud, acesse a página Modelos de instância.

   Acessar "Modelos de instância"

2. Clique em Criar modelo de instância.

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

4. Na seção Local, selecione uma das seguintes opções:

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

   • Para criar um modelo de instância regional, selecione Regional e escolha a região em que você quer criar o modelo de instância.

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

   1. Clique na guia 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 de GPU der suporte a estações de trabalho virtuais (vWS) NVIDIA RTX para cargas de trabalho de gráficos e você planeja executar cargas de trabalho com muitos gráficos, selecione Ativar estação de trabalho virtual (NVIDIA GRID).

   5. Na lista Tipo de máquina, selecione um tipo de máquina.

6. Opcional: para alterar o valor padrão do tipo ou da imagem do disco de inicialização, na seção Disco de inicialização, clique em Alterar. Depois, siga as instruções para alterar o disco de inicialização.

7. Clique em Criar.

gcloud

Para criar um modelo de instância para VMs de GPU, use o comando instance-templates create com a sinalização --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:

• 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 imagem com suporte, consulte Imagens públicas.

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

  • IMAGE_FAMILY: uma família de imagens. Especifica a imagem do SO mais recente e não descontinuada. Por exemplo, se você especificar debian-10, a versão mais recente na família de imagens do Debian 10 será usada. Para mais informações sobre o uso de famílias de imagens, consulte 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 você decidir especificar uma versão específica da imagem do SO, será necessário substituir a flag --image-family pela flag --image.

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

Por exemplo, suponha que você queira criar um modelo de instância global para VMs de GPU que especifique as propriedades a seguir:

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

• Uma GPU NVIDIA T4 para anexar às VMs.

• Debian como o projeto de imagem.

• Debian 10 como a 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 para VMs de GPU, use o recurso google_compute_region_instance_template.

Por exemplo, para criar um modelo de instância global, que especifica um tipo de máquina predefinido N1 com duas vCPUs e uma GPU NVIDIA T4 anexada, use o seguinte 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"
  }
}

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

REST

Para criar um modelo de instância para VMs de GPU, faça uma solicitação POST para o método instanceTemplates.insert. No corpo da solicitação, 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 uma solicitação POST da seguinte maneira:

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:

• PROJECT_ID: o ID do projeto em que você 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 imagem com suporte, consulte 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. Especifica a imagem do SO mais recente e não descontinuada. Por exemplo, se você especificar family/debian-10, a versão mais recente na família de imagens do Debian 10 será usada. Para mais informações sobre o uso de famílias de imagens, consulte Práticas recomendadas para famílias de imagens.

• MACHINE_TYPE: o tipo de máquina das VMs Se você especificar um tipo de máquina N1, inclua a flag guestAccelerators para especificar o número e o tipo de GPUs a serem anexadas às VMs.

Por exemplo, suponha que você queira criar um modelo de instância global para VMs de GPU que especifique as propriedades a seguir:

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

• Uma GPU NVIDIA T4 para anexar às VMs.

• Debian como o projeto de imagem.

• Debian 10 como a família de imagens.

Para criar o modelo de instância de exemplo, faça uma solicitação POST da seguinte maneira:

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 Criar um modelo de instância neste documento.

Como criar um modelo de instância com uma imagem de contêiner

Especifique uma imagem de contêiner em um modelo de instância. Por padrão, o Compute Engine também inclui no modelo uma imagem do sistema operacional Container-Optimized com o Docker instalado. Quando você usa o modelo para criar uma nova instância, o contêiner é iniciado automaticamente à medida que a instância é iniciada.

Console

1. Acesse a página Modelos de instância.

   Acesse "Modelos de instância"

2. Clique em Criar modelo de instância.

3. Na seção Contêiner, clique em Implantar contêiner.

4. Na caixa de diálogo Configurar contêiner, especifique a Imagem de contêiner a ser usada.

   • É possível especificar uma imagem do Container Registry ou do Artifact Registry. Exemplo:
     • gcr.io/cloud-marketplace/google/nginx1:TAG, em que TAG é a tag definida para uma versão específica da imagem do contêiner NGINX disponível no Google Cloud Marketplace.
     • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 seleciona uma amostra de imagem hello-app armazenada no Artifact Registry.
   • Se você usar uma imagem de contêiner do Docker Hub, sempre especifique o nome completo da imagem do Docker. Por exemplo, forneça o seguinte nome para implantar uma imagem do contêiner Apache: docker.io/httpd:2.4

5. Se quiser, clique em Opções de contêiner avançadas. Para mais informações, consulte Como configurar opções para executar seu contêiner.

6. Clique em Criar.

gcloud

Use o comando gcloud compute instance-templates create-with-container (em inglês).

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

Substitua:

• INSTANCE_TEMPLATE_NAME: o nome do modelo a ser criado;
• CONTAINER_IMAGE: o nome completo da imagem do contêiner a ser usada.

Por exemplo, o comando a seguir cria um novo modelo de instância chamado nginx-vm. Uma instância de VM criada a partir desse modelo inicia e executa a imagem de contêiner, 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 tag definida para uma versão específica da imagem do contêiner NGINX disponível no Google Cloud Marketplace.

Você também pode configurar opções para executar seu contêiner.

Atenção: o Container Registry foi descontinuado e está programado para ser desativado. As organizações que não usaram o Container Registry antes de 8 de janeiro de 2024 terão novos repositórios gcr.io hospedados no Artifact Registry por padrão. A partir de 15 de maio de 2024, os projetos do Google Cloud sem uso anterior do Container Registry só serão compatíveis com a hospedagem e o gerenciamento de imagens para o domínio gcr.io no Artifact Registry.

A desativação do Container Registry está programada para 18 de março de 2025. Para detalhes sobre a descontinuação, consulte Suspensão de uso do Container Registry.

Como criar um modelo de instância que especifica 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 escolhida. A flag --subnet exige a sinalização --region.

Se você quiser criar um modelo de instância regional, use a flag --instance-template-region para definir a região do modelo. Use uma sub-rede da mesma região em que você quer criar o modelo de instância regional.

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

Substitua:

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

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

  Observação: se você usar o nome da sub-rede, o Google a encontrará na região de destino, desde que ela exista nesse local. Porém, se usar o URL da sub-rede, o modelo de instância só poderá ser usado para criar instâncias na região específica associada ao URL da sub-rede.

• INSTANCE_TEMPLATE_REGION: a região em que você quer criar o modelo de instância. Precisa ser igual a REGION.

No exemplo a seguir, criamos um modelo chamado template-qa que gera instâncias apenas na sub-rede subnet-us-qa.

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

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)

O uso desse modelo para criar instâncias de um MIG com ou sem escalonamento automático, gera automaticamente a instância na região e na sub-rede especificadas. Isso permite controlar a sub-rede de novas instâncias criadas para balanceamento de carga.

Como usar imagens personalizadas ou públicas nos modelos de instância

É possível usar uma imagem personalizada ou uma imagem pública para os modelos de instância:

• Imagens personalizadas. Como os MIGs foram projetados para adicionar e remover instâncias com frequência, vale a pena criar uma imagem personalizada e especificá-la no modelo de instância. Prepare a imagem com os aplicativos e as configurações necessários para que as VMs não precisem configurar manualmente esses itens em VMs individuais no MIG.

• Imagens públicas. É possível criar um modelo de instância que use uma imagem pública e um script de inicialização para preparar essa instância assim que ela começar a ser executada.

As imagens personalizadas têm caráter mais determinista e são inicializadas mais rapidamente do que as VMs com scripts de inicialização. No entanto, esses scripts são mais flexíveis e permitem que você atualize os apps e as configurações nas suas instâncias com mais facilidade.

Se você estiver gerenciando imagens usando famílias de imagens, especifique 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 práticas recomendadas ao usar famílias de imagens no Compute Engine.

Observação: se a imagem que você quer usar pertencer a um projeto diferente, ainda será possível usá-la no modelo de instância, desde que o proprietário desse projeto conceda ao MIG acesso às imagens. Para mais informações, consulte Como conceder ao MIG acesso às imagens.

A seguir

• Criar uma VM a partir de um modelo de instância
• Crie um grupo de instâncias gerenciadas por zona (MIG).
• Crie um MIG regional.
• Atualize as VMs em um MIG atual para usar a configuração de um novo modelos
• Crie uma reserva para duas VMs.