Crie uma instância numa sub-rede específica

---

Por predefinição, cada instância tem uma única interface de rede que determina a rede VPC que a instância usa. Pode criar uma instância com várias interfaces de rede, mas cada interface tem de se ligar a uma rede VPC diferente. Cada rede tem de ter, pelo menos, uma sub-rede, que define o intervalo de endereços IPv4 ou IPv6 que podem ser atribuídos à instância.

Para mais informações, consulte o seguinte:

• Endereços IP
• Crie uma instância que use endereços IPv6

Por predefinição, Google Cloud cria uma rede VPC de modo automático denominada default para cada projeto. Para usar uma rede diferente ou uma sub-rede que criou manualmente numa rede VPC no modo automático ou personalizado, tem de especificar a sub-rede quando cria a instância e configura a interface de rede.

Antes de começar

• 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.

  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. 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.

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

Funções necessárias

Para receber as autorizações de que precisa para criar uma instância com uma sub-rede específica, peça ao seu administrador para lhe conceder a função de IAM Administrador de instâncias do Compute (v1) (roles/compute.instanceAdmin.v1) no projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém as autorizações necessárias para criar uma instância com uma sub-rede específica. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

As seguintes autorizações são necessárias para criar uma instância com uma sub-rede específica:

• compute.instances.create no projeto
• Para especificar uma sub-rede para a sua instância: compute.subnetworks.use no projeto ou na sub-rede escolhida
• Para atribuir um endereço IP externo à instância quando usar uma rede de VPC: compute.subnetworks.useExternalIp no projeto ou na sub-rede escolhida

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Requisitos

Quando cria uma instância numa sub-rede, considere estas regras:

• Se não especificar uma rede ou uma sub-rede, o Compute Engine usa a rede VPC predefinida e a sub-rede automática que se encontra na mesma região que a instância.
• Se não especificar uma rede, o Compute Engine infere a rede a partir da sub-rede especificada.
• Se especificar uma rede, tem de especificar uma sub-rede e esta tem de pertencer à mesma rede. Caso contrário, a criação da instância falha.

Tem de criar a sub-rede que quer usar antes de criar a instância. Para mais informações, consulte o artigo Crie e faça a gestão de redes VPC.

Crie uma instância numa sub-rede específica

Para criar uma instância numa sub-rede específica, siga estes passos:

Consola

1. Na Google Cloud consola, aceda à página Criar uma instância.

   Aceda a Criar uma instância

   Se lhe for solicitado, selecione o seu projeto e clique em Continuar.

   É apresentada a página Criar uma instância, que mostra o painel Configuração da máquina.

2. No painel Configuração da máquina, faça o seguinte:

   1. No campo Nome, especifique um nome para a instância. Para mais informações, consulte a Convenção de nomenclatura de recursos.

   2. Opcional: no campo Zona, selecione uma zona para esta instância.

      A seleção predefinida é Qualquer. Se não alterar esta seleção predefinida, a Google escolhe automaticamente uma zona para si com base no tipo de máquina e na disponibilidade.

   3. Selecione a família de máquinas para a sua instância. A Google Cloud consola apresenta, em seguida, as séries de máquinas disponíveis para a família de máquinas selecionada. Estão disponíveis as seguintes opções de família de máquinas:

      • Utilização geral
      • Otimizado para computação
      • Otimizada para memória
      • Otimizado para armazenamento
      • GPUs

   4. Na coluna Série, selecione a série de máquinas para a sua instância.

      Se selecionou GPUs como a família de máquinas no passo anterior, selecione o tipo de GPU pretendido. A série de máquinas é, em seguida, selecionada automaticamente para o tipo de GPU selecionado.

   5. Na secção Tipo de máquina, selecione o tipo de máquina para a sua instância.

3. No menu de navegação, clique em Rede. No painel Rede apresentado, faça o seguinte:

   1. Para permitir o tráfego HTTP ou HTTPS para a instância, aceda à secção Firewall e selecione Permitir tráfego HTTP ou Permitir tráfego HTTPS.

      O Compute Engine adiciona uma etiqueta de rede à sua instância e cria a regra de firewall de entrada correspondente que permite todo o tráfego de entrada em tcp:80 (HTTP) ou tcp:443 (HTTPS). A etiqueta de rede associa a regra de firewall à instância. Para mais informações, consulte o artigo Vista geral das regras da firewall na documentação da firewall de nova geração do Google Cloud.

   2. Para especificar os detalhes da interface de rede, aceda à secção Interfaces de rede e clique em Adicionar uma interface de rede.

      Na secção Nova interface de rede apresentada, faça o seguinte:

      1. No campo Rede, selecione a rede de VPC que contém a sub-rede que criou.
      2. Na lista Sub-rede, selecione a sub-rede que a instância vai usar.
      3. No campo Tipo de pilha de IP, selecione o tipo de pilha de IP para a interface de rede.
      4. Para confirmar os detalhes da interface de rede, clique em Concluído.

4. Opcional: especifique outras opções de configuração. Para mais informações, consulte o artigo Opções de configuração durante a criação da instância.

5. Para criar e iniciar a instância, clique em Criar.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Usando a CLI do Google Cloud, siga as mesmas instruções para criar uma instância a partir de uma imagem pública ou uma captura de ecrã e inclua as flags de rede apresentadas nesta secção quando executar o comando gcloud compute instances create:

   gcloud compute instances create INSTANCE_NAME \
       --zone=ZONE \
       --machine-type=MACHINE_TYPE \
       --create-disk=boot=yes,image=projects/IMAGE_PROJECT/global/images/IMAGE,size=SIZE \
       --network=NETWORK_NAME \
       --subnet=SUBNET_NAME \
       --stack-type=STACK_TYPE \
       --private-network-ip=INTERNAL_IPV4_ADDRESS \
       --address=EXTERNAL_IPV4_ADDRESS \
       --nic-type=GVNIC
   

   Substitua o seguinte:

   • INSTANCE_NAME: o nome da instância do Compute
   • ZONE: a zona onde a instância é criada, como europe-west1-b. A região da instância é inferida a partir da zona.
   • MACHINE_TYPE: Opcional: o tipo de máquina a usar para a instância.
   • IMAGE_PROJECT: Opcional: o projeto de imagem que contém a imagem
   • IMAGE: Opcional: especifique uma das seguintes opções:
     • Uma versão específica da imagem do SO, por exemplo, rocky-linux-9-optimized-gcp-v20240717.
     • Uma família de imagens, que tem de estar formatada como family/IMAGE_FAMILY. Isto cria a instância a partir da imagem do SO mais recente e não descontinuada. Por exemplo, se especificar family/rocky-linux-9-optimized-gcp, o Compute Engine cria uma instância com a versão mais recente da imagem do SO na família de imagensGoogle Cloud otimizada para o Rocky Linux 9. Para mais informações sobre a utilização de famílias de imagens, consulte o artigo Práticas recomendadas para famílias de imagens.
   • SIZE: opcional: o tamanho do novo disco. O valor tem de ser um número inteiro. A unidade de medida predefinida é GiB.
   • NETWORK_NAME: opcional: nome da rede

   • SUBNET_NAME: nome da sub-rede a usar com a instância.

     Para ver uma lista de sub-redes na rede, use o comando gcloud compute networks subnets list.

   • STACK_TYPE: Opcional: o tipo de pilha para a interface de rede. STACK_TYPE tem de ser um dos seguintes: IPV4_ONLY, IPV4_IPV6 ou IPV6_ONLY (Pré-visualização). O valor predefinido é IPV4_ONLY.

   • INTERNAL_IPV4_ADDRESS: Opcional: o endereço IPv4 interno que quer que a instância de computação use na sub-rede de destino. Omita este sinalizador se não precisar de um endereço IP específico.

     Para especificar um endereço IPv6 interno, use a flag --internal-ipv6-address em alternativa.

   • EXTERNAL_IPV4_ADDRESS: Opcional: o endereço IPv4 externo estático a usar com a interface de rede. Tem de ter reservado um endereço IPv4 externo anteriormente. Efetue um dos seguintes passos:

     • Especifique um endereço IPv4 válido da sub-rede.
     • Use a flag --network-interface=no-address se não quiser que a interface de rede tenha um endereço IP externo.
     • Especifique address='' se quiser que a interface receba um endereço IP externo efémero.

     Para especificar um endereço IPv6 externo, use a flag --external-ipv6-address em alternativa.

Terraform

Para criar uma instância numa sub-rede específica, pode usar o recurso google_compute_instance.

# Create a VM in a custom VPC network and subnet

resource "google_compute_instance" "custom_subnet" {
  name         = "my-vm-instance"
  tags         = ["allow-ssh"]
  zone         = "europe-west1-b"
  machine_type = "e2-small"
  network_interface {
    network    = google_compute_network.custom.id
    subnetwork = google_compute_subnetwork.custom.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
}

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

Para gerar o código do Terraform, pode usar o componente Código equivalente na Google Cloud consola.

1. Na Google Cloud consola, aceda à página Instâncias de VM.

   Aceder a Instâncias de VM

2. Clique em Criar instância.
3. Especifique os parâmetros pretendidos.
4. Na parte superior ou inferior da página, clique em Código equivalente e, de seguida, clique no separador Terraform para ver o código Terraform.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Go Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

import (
	"context"
	"fmt"
	"io"

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

// createInstanceWithSubnet creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
func createInstanceWithSubnet(w io.Writer, projectID, zone, instanceName, networkLink, subnetworkLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// networkLink := "global/networks/default"
	// subnetworkLink := "regions/region/subnetworks/subnetwork_name"

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

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
	newestDebianReq := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", err)
	}

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: newestDebian.SelfLink,
						DiskType:    proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name:       proto.String(networkLink),
					Subnetwork: proto.String(subnetworkLink),
				},
			},
		},
	}

	op, err := instancesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance created\n")

	return nil
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Java Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source
   * for the new disk.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param sourceImage source image to use when creating this disk. You must have read access to
   * this disk. This can be one of the publicly available images or an image from one of your
   * projects. This value uses the following format:
   * "projects/{project_name}/global/images/{image_name}"
   * @return AttachedDisk object configured to be created using the specified image.
   */
  private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceImage(sourceImage)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

Node.js

Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Node.js Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const networkLink = 'global/networks/default';
// const subnetworkLink = 'regions/europe-central2/subnetworks/default';

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

// Creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
async function createInstanceWithSubnet() {
  const instancesClient = new compute.InstancesClient();
  const imagesClient = new compute.ImagesClient();

  // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
  const [newestDebian] = await imagesClient.getFromFamily({
    project: 'debian-cloud',
    family: 'debian-11',
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: newestDebian.selfLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: networkLink,
          subnetwork: subnetworkLink,
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance created.');
}

createInstanceWithSubnet();

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no guia de início rápido do Compute Engine com bibliotecas cliente. Para mais informações, consulte a documentação de referência da API Python Compute Engine.

Para se autenticar no Compute Engine, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


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_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_subnet(
    project_id: str, zone: str, instance_name: str, network_link: str, subnet_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system in specified network and subnetwork.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
    instance = create_instance(
        project_id,
        zone,
        instance_name,
        disks,
        network_link=network_link,
        subnetwork_link=subnet_link,
    )
    return instance

REST

Siga as REST instruções para criar uma instância a partir de uma imagem pública ou de uma captura de ecrã, mas especifique o campo subnet no corpo do pedido.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME",
         "subnetwork":"regions/REGION/subnetworks/SUBNET_NAME",
         "stackType":"STACK_TYPE"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Substitua o seguinte:

• PROJECT_ID: ID do projeto no qual criar a VM
• ZONE: zona na qual criar a VM
• MACHINE_TYPE_ZONE: zona que contém o tipo de máquina a usar para a nova VM
• MACHINE_TYPE: tipo de máquina, predefinido ou personalizado, para a nova VM
• VM_NAME: name da nova VM
• IMAGE_PROJECT: project que contém a imagem
  Por exemplo, se especificar debian-10 como a família de imagens, especifique debian-cloud como o projeto de imagens.
• IMAGE: especifique uma das seguintes opções:

  • IMAGE: uma versão específica de uma imagem pública

    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.

• NETWORK_NAME: Opcional: a rede VPC que quer usar para a VM. Pode especificar default para usar a sua rede predefinida.
• REGION: região onde existe a sub-rede especificada. Tem de ser a mesma região que a VM.
• SUBNET_NAME: nome da sub-rede a usar
• STACK_TYPE: opcional: o tipo de pilha para a interface de rede. Pode especificar uma das seguintes opções: IPV4_ONLY, IPV4_IPV6 ou IPV6_ONLY. O valor predefinido é IPV4_ONLY.

• ENABLE_SECURE_BOOT: Opcional: se escolheu uma imagem que suporta as funcionalidades da VM protegida, o Compute Engine ativa, por predefinição, o módulo de plataforma fidedigna virtual (vTPM) e a monitorização da integridade. O Compute Engine não ativa o Arranque seguro por predefinição.

  Se especificar true para enableSecureBoot, o Compute Engine cria uma VM com todas as três funcionalidades da VM protegida ativadas. Depois de o Compute Engine iniciar a VM, para modificar as opções da VM protegida, tem de parar a VM.

Nota: uma interface de rede só pode ter um endereço IPv6, interno ou externo, mas não ambos.

O que se segue?

• Saiba como verificar o estado de uma instância para ver quando está pronta a usar.
• Saiba como estabelecer ligação à sua instância.