Criar uma instância com discos extras que não sejam de inicialização

Neste documento, descrevemos como criar e anexar outros discos que não são de inicialização a uma instância do Compute Engine ao criar a instância.

As informações neste documento se aplicam à criação de uma instância de computação com discos zonais que não estão em um pool de hiperdisco. A lista a seguir descreve tarefas relacionadas e a documentação relevante.

Antes de começar

  • Configure a autenticação, caso ainda não tenha feito isso. Com isso, você confirma 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 selecionando uma das seguintes opções:

    Selecione a guia para como planeja usar as amostras nesta página:

    Console

    Quando você usa o console Google Cloud para acessar serviços Google Cloud e APIs, não é necessário configurar a autenticação.

    gcloud

    1. Instale a CLI do Google Cloud. Após a instalação, inicialize a Google Cloud CLI executando o seguinte comando: 

      gcloud init

      Ao usar um provedor de identidade (IdP) externo, primeiro faça login na CLI gcloud com sua identidade federada.

  • Defina uma região e uma zona padrão.

    • REST

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

      Instale a CLI do Google Cloud.

      Ao usar um provedor de identidade (IdP) externo, primeiro faça login na CLI gcloud com sua identidade federada.

    Saiba mais em Autenticar para usar REST na documentação de autenticação do Google Cloud .

Funções exigidas

Para receber as permissões necessárias para criar uma instância com discos não de inicialização adicionados, peça ao administrador para conceder a você o papel do IAM de Administrador da instância do Compute (v1) (roles/compute.instanceAdmin.v1) no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para criar uma instância com discos não de inicialização adicionados. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar uma instância com discos extras que não sejam de inicialização:

  • compute.instances.create no projeto
  • Para criar um disco para a instância: compute.disks.create no projeto
  • Para criar um disco com base em uma imagem: compute.images.useReadOnly na imagem de origem
  • Para criar um disco com base em um snapshot padrão ou de arquivamento: compute.snapshots.useReadOnly no snapshot de origem
  • Para criar um disco com base em um instant snapshot, se o disco de origem do instant snapshot for o disco de inicialização de uma instância com uma conta de serviço anexada: iam.serviceAccounts.actAs na conta de serviço da instância
  • Para criar um disco com base em um Instant Snapshot: compute.instantSnapshots.useReadOnly no Instant Snapshot de origem
  • Para criar um disco com base em um disco atual: compute.disks.useReadOnly no disco de origem

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Limitações

O número, o tamanho total combinado e o tipo de discos que podem ser anexados a uma instância dependem do tipo de máquina dela.

Por exemplo, as instâncias C4 não oferecem suporte a Persistent Disk. Além disso, o tamanho combinado de todos os discos anexados a uma instância c4-standard-2 não pode exceder 257 TiB, mas, para uma instância c4-standard-192, o limite é de 512 TiB.

Os limites detalhados de cada série de máquinas estão na seção Tipos de disco compatíveis da documentação da série. Para conferir os limites da série de máquinas da sua nova instância, consulte o link correspondente na tabela a seguir.

Tipos de máquinas de uso geral
 Tipos de máquina
otimizados para computação		 Tipos de máquina
com otimização de memória		 Tipos de máquina
com otimização de acelerador		 Tipos de máquina com otimização para armazenamento

Limites de tamanho do disco e nomes de referência

O tamanho especificado para um disco regional precisa estar dentro dos intervalos listados na tabela a seguir.

Ao criar um disco com a Google Cloud CLI, REST ou as bibliotecas de cliente do Cloud para Compute Engine, especifique o tipo de disco a ser criado com o valor correspondente da coluna Nome de referência na tabela a seguir.

Tipo de disco Nome da referência Tamanho mínimo Tamanho máximo Tamanho padrão
Hyperdisk Balanced hyperdisk-balanced 4 GiB 64 TiB1 100 GiB
Hyperdisk Balanced High Availability hyperdisk-balanced-high-availability 4 GiB 64 TiB 100 GiB
Hyperdisk Extreme hyperdisk-extreme 64 GiB 64 TiB 1 TiB
Hyperdisk Throughput hyperdisk-throughput 2 TiB 32 TiB 2 TiB
Hyperdisk ML hyperdisk-ml 4 GiB 64 TiB 100 GiB
Disco permanente equilibrado pd-balanced Por zona: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Persistent Disk (SSD) de desempenho pd-ssd Por zona: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Disco permanente padrão pd-standard Por zona: 10 GiB
Regional: 200 GiB		 64 TiB 500 GiB
Disco permanente extremo pd-extreme 500 GiB 64 TiB 1 TiB
1 Prévia: o C4 aceita um tamanho máximo de disco de 128 TiB. Para acessar esse recurso, entre em contato com hyperdisk-questions@google.com.

Criar uma instância com novos discos extras que não são de inicialização

Para criar uma instância com outros discos não de inicialização criados e anexados, siga estas etapas:

Console

  1. No console do Google Cloud , acesse a página Criar uma instância.

    Acesse "Criar uma instância"

    Se solicitado, selecione o projeto e clique em Continuar.

    A página Criar uma instância aparece e 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 Convenção de nomenclatura de recursos.
    2. No campo Região, especifique onde você quer a instância.

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

      A seleção padrão é Qualquer. Se você não mudar essa seleção padrão, o Google vai escolher automaticamente uma zona com base no tipo de máquina e na disponibilidade.

    4. Selecione a família de máquinas para sua instância. O console do Google Cloud mostra as séries de máquinas disponíveis para a família de máquinas selecionada. As seguintes opções de família de máquinas estão disponíveis:

      • Uso geral
      • Otimizado para computação
      • Otimização de memória
      • Otimizado para armazenamento
      • GPUs

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

      Se você selecionou GPUs como a família de máquinas na etapa anterior, selecione o Tipo de GPU desejado. A série de máquinas é selecionada automaticamente para o tipo de GPU escolhido.

    6. Na seção Tipo de máquina, selecione o tipo de máquina para sua instância.

  3. No menu de navegação, clique em SO e armazenamento. O painel Sistema operacional e armazenamento é exibido.

  4. Para configurar o disco de inicialização, clique em Alterar. O painel Disco de inicialização aparece e mostra a guia Imagens públicas.

  5. Configure a fonte de dados para o disco de inicialização de uma das seguintes maneiras:

    • Para escolher uma imagem pública como fonte de dados do disco de inicialização, especifique o seguinte na guia Imagens públicas:

      1. Na lista Sistema operacional, selecione o tipo de SO.
      2. Na lista Versão, selecione a versão do SO.
      3. Na lista Tipo de disco de inicialização, selecione o tipo de disco de inicialização.
      4. No campo Tamanho (GB), especifique o tamanho do disco de inicialização.

    • Para escolher uma imagem personalizada como fonte de dados do disco de inicialização, clique em Imagens personalizadas e, na guia Imagens personalizadas que aparece, especifique o seguinte:

      1. Para selecionar o projeto de imagem, clique em Mudar e selecione o projeto que contém a imagem.
      2. Na lista Imagem, selecione a imagem que você quer importar.
      3. Na lista Tipo de disco de inicialização, selecione o tipo de disco de inicialização.
      4. No campo Tamanho (GB), especifique o tamanho do disco de inicialização.

    • Para escolher um snapshot padrão como a fonte de dados do disco de inicialização, clique em Snapshots e, na guia Snapshots que aparece, especifique o seguinte:

      1. Na lista Snapshot, selecione o snapshot.
      2. Na lista Tipo de disco de inicialização, selecione o tipo de disco de inicialização.
      3. No campo Tamanho (GB), especifique o tamanho do disco de inicialização.

    • Para escolher um snapshot de arquivamento como a fonte de dados do disco de inicialização, clique em Snapshots de arquivamento e, na guia Snapshots de arquivamento que aparece, especifique o seguinte:

      1. Na lista Snapshot de arquivamento, selecione o snapshot de arquivamento.
      2. Na lista Tipo de disco de inicialização, selecione o tipo de disco de inicialização.
      3. No campo Tamanho (GB), especifique o tamanho do disco de inicialização.

    • Para escolher um disco atual como disco de inicialização, clique em Discos atuais. Em seguida, na guia Discos atuais que aparece, selecione um Persistent Disk regional ou um volume do Hyperdisk Balanced High Availability na lista Disco.

  6. Opcional: se o disco de inicialização for um volume do Hyperdisk Balanced, defina limites de desempenho para o novo disco. Os valores especificados precisam estar no intervalo de valores compatíveis.

  7. Opcional: para ver as opções avançadas de configuração, expanda a seção Mostrar configurações avançadas.

    • Selecione o modo de anexo do disco no campo Modo.
    • Escolha manter ou excluir o disco quando a instância for excluída selecionando a opção no campo Regra de exclusão.
    • Para facilitar a identificação do disco no SO convidado, especifique um nome de dispositivo personalizado. No título Nome do dispositivo, selecione a opção Usar nome de dispositivo personalizado. No campo Nome do dispositivo, insira uma string para usar como um link simbólico para o disco.

  8. Para confirmar as opções do disco de inicialização e voltar ao painel SO e armazenamento, clique em Selecionar.

  9. Para criar um disco que não seja de inicialização e anexá-lo à sua instância, siga estas etapas para cada disco que você quer adicionar.

    1. Na seção Discos extras, clique em Adicionar novo disco. O painel Adicionar novo disco vai aparecer.

    2. Na seção Configuração do disco, no campo Nome, especifique um nome para o disco não inicializável.

    3. Opcional: no campo Descrição, especifique uma descrição para o disco.

    4. Selecione a origem de dados para o novo disco:

      • Para criar um disco vazio e não formatado, na lista Tipo de origem do disco, selecione Disco em branco.
      • Para criar uma cópia dos dados atuais, selecione o tipo de origem do disco não inicializável.

    5. Na lista Tipo de disco, selecione um tipo para o disco não inicializável. O tipo de máquina precisa ser compatível com o tipo de disco.

    6. No campo Tamanho, especifique o tamanho do disco que não é de inicialização.

    7. Opcional: se o novo disco for um volume do Hyperdisk, você poderá definir limites de desempenho para ele. Os valores especificados precisam estar no intervalo de valores compatíveis e dependem do tipo de Hyperdisk, da seguinte maneira:

      • Hiperdisco equilibrado. É possível mudar o Tamanho, as IOPS provisionadas e a Capacidade de processamento provisionada do disco.
      • Hiperdisco extremo É possível mudar o Tamanho e as IOPS provisionadas do disco.
      • Hyperdisk ML. É possível mudar o Tamanho e a Capacidade de processamento provisionada do disco.
      • Hyperdisk Throughput.É possível mudar o Tamanho e a Capacidade de processamento provisionada do disco.

    8. Opcional: para ver as opções avançadas de configuração, expanda a seção Mostrar configurações avançadas.

      • Selecione o modo de anexo do disco no campo Modo.
      • Escolha manter ou excluir o disco quando a instância for excluída selecionando a opção no campo Regra de exclusão.
      • Para facilitar a identificação do disco no SO convidado, especifique um nome de dispositivo personalizado. No título Nome do dispositivo, selecione a opção Usar nome de dispositivo personalizado. No campo Nome do dispositivo, insira uma string para usar como um link simbólico para o disco.

    9. Para confirmar as opções e voltar ao painel SO e armazenamento, clique em Salvar.

    Repita essa etapa para cada disco que não seja de inicialização que você quer criar e anexar à instância.

  10. Opcional: especifique opções de backup e replicação para sua instância de computação. No menu de navegação, clique em Proteção de dados. No painel Proteção de dados que aparece, especifique como você quer fazer backup e replicar os dados da sua instância de computação fazendo o seguinte:

    1. Para especificar como você quer fazer backup dos dados, selecione uma opção em Fazer backup dos dados.

    2. Para especificar como você quer replicar os dados, faça o seguinte:

      1. Se você quiser que os novos discos da instância sejam replicados de forma síncrona em uma segunda zona usando tipos de discos regionais, marque a caixa de seleção Discos regionais.
      1. Se você quiser que os discos da instância sejam replicados em uma segunda região usando a replicação assíncrona, marque a caixa de seleção Replicação assíncrona.

    3. Para usar as opções de proteção de dados especificadas apenas em discos não inicializáveis, marque a caixa de seleção Excluir discos de inicialização.

  11. No menu de navegação, clique em Rede. No painel Rede que aparece, faça o seguinte:

    1. Acesse a seção Firewall.

    2. Para permitir o tráfego HTTP ou HTTPS para a instância, selecione Permitir tráfego HTTP ou Permitir tráfego HTTPS.

      O Compute Engine adiciona uma tag de rede à 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 tag de rede associa a regra de firewall à instância. Para mais informações, consulte Visão geral das regras de firewall na documentação do Cloud Next Generation Firewall.

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

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

gcloud

  1. No console do Google Cloud , ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

  2. Execute o comando gcloud compute instances create para criar uma instância com discos extras que não sejam de inicialização.

    É possível incluir até 127 discos que não sejam de inicialização durante a criação da instância. Especifique a sinalização --create-disk para cada disco que não seja de inicialização criado.

    Para criar discos que não são de inicialização a partir de uma imagem pública ou de banco de imagem, especifique as propriedades image ou image-family e image-project na sinalização --create-disk. Para criar um disco em branco, não inclua essas propriedades.

    Você pode incluir valores para as seguintes propriedades:

    • Tamanho do disco: use a propriedade --size.
    • Tipo de disco: use a propriedade --type.
    • Discos regionais: inclua a propriedade replica-zones.
    gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --image-project=BOOT_DISK_IMAGE_PROJECT \
    BOOT_DISK_IMAGE_FLAG \
    --create-disk name=DISK_NAME,device-name=DISK_DEVICE_NAME,size=SIZE_GB,type=DISK_TYPE,image=DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,replica-zones=^:^ZONE:REMOTE_ZONE,boot=false

    Substitua:

    • INSTANCE_NAME: o nome da nova instância.
    • ZONE: a zona em que será criada a instância
    • MACHINE_TYPE: o tipo de máquina da instância. Por exemplo, c3-standard-4.
    • BOOT_DISK_IMAGE_PROJECT: o projeto que contém a imagem. Por exemplo, para o Debian, debian-cloud. Para encontrar o projeto de imagem de imagens públicas, acesse a página Detalhes do sistema operacional. Na seção Versões GA do seu SO, o projeto de imagem é listado na coluna Projeto de imagem da guia Informações gerais.

    • BOOT_DISK_IMAGE_FLAG: especifique uma destas opções:

      • Use a flag --image IMAGE_NAME para especificar uma versão específica de uma imagem pública ou personalizada. Por exemplo, --image debian-12-bookworm-v20241112.

      • Use a flag --image-family IMAGE_FAMILY_NAME para especificar uma família de imagens. Isso cria a instância que usa a imagem do SO mais recente e não obsoleta na família de imagens. Por exemplo, se você especificar --image-family debian-12, o Compute Engine usará a versão mais recente da imagem do SO na família de imagens Debian 12 ao criar a instância.

    • Nos discos extras, substitua:

      • DISK_NAME: opcional: o nome do disco que não é de inicialização.
      • SIZE_GB: opcional: o tamanho do disco que não é de inicialização.
      • DISK_TYPE: o tipo do disco. Por exemplo, hyperdisk-balanced. O tipo de máquina precisa ser compatível com o tipo de disco.
      • DISK_DEVICE_NAME: opcional: o nome do disco que é exibido para o SO convidado após a criação da instância.
      • DISK_IMAGE: opcional: para criar um disco de uma imagem atual, especifique uma das seguintes opções:
        • image=DISK_IMAGE_NAME: nome da imagem que você quer usar para criar o disco que não é de inicialização, por exemplo, debian-12-bookworm-v20260210.
        • image-family=DISK_IMAGE_FAMILY: uma família de imagens a ser usada ao criar um disco que não é de inicialização, por exemplo, debian-12.
      • DISK_IMAGE_PROJECT (opcional): para criar um disco não inicializável de uma imagem existente, especifique o projeto de imagem que contém a imagem.
      • REMOTE_ZONE: opcional: se você estiver criando um disco regional, especifique a zona em que o disco será replicado, por exemplo, us-central1-b.

      Para discos vazios, não especifique os parâmetros image, image-project ou image-family.

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

Terraform

Para gerar o código do Terraform, use o componente Código equivalente no console do Google Cloud .
  1. No console do Google Cloud , acesse a página Instâncias de VM.

    Acessar instâncias de VM

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

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

import (
	"context"
	"fmt"
	"io"

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

// createWithAdditionalDisk create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
func createWithAdditionalDisk(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_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()),
				},
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb: proto.Int64(11),
						DiskType:   proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(false),
					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("global/networks/default"),
				},
			},
		},
	}

	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 testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 


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


  /**
   * Create an AttachedDisk object to be used in VM instance creation. The created disk contains no
   * data and requires formatting before it can be used.
   *
   * @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
   * @return AttachedDisk object configured to be created as an empty disk.
   */
  private static AttachedDisk emptyDisk(String diskType, int diskSizeGb) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(false)
            // 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()
                    .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);
    }
  }

  /**
   * Create a new VM instance with Debian 11 operating system and a 11 GB additional empty disk.
   *
   * @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.
   * @return Instance object.
   */
  public static Instance createWithAdditionalDisk(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (ImagesClient imagesClient = ImagesClient.create()) {
      // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
      Image image = imagesClient.getFromFamily("debian-cloud", "debian-11");
      String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
      Vector<AttachedDisk> disks = new Vector<>();
      disks.add(diskFromImage(diskType, 10, true, image.getSelfLink()));
      disks.add(emptyDisk(diskType, 11));
      return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
          "global/networks/default", null);
    }
  }

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

/**
 * 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 compute = require('@google-cloud/compute');

// Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
async function createWithAdditionalDisk() {
  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',
        },
        {
          initializeParams: {
            diskSizeGb: '11',
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: false,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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.');
}

createWithAdditionalDisk();

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Compute Engine: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Python do Compute Engine.

Para autenticar-se no Compute Engine, configure o Application Default Credentials. Para mais informações, acesse Configurar a autenticação para bibliotecas de cliente. 

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 empty_disk(
    disk_type: str, disk_size_gb: int, boot: bool = False, auto_delete: bool = True
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. The created disk contains
    no data and requires formatting before it can be used.

    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
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created as an empty disk.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    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.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return 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_additional_disk(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system on a 20 GB disk
    and a 25 GB additional empty disk.

    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.

    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, 20, True, newest_debian.self_link),
        empty_disk(disk_type, 25),
    ]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

Crie até 127 discos que não sejam de inicialização no momento em que criar uma instância usando a propriedade initializeParams para cada disco extra. Crie discos extras com uma imagem pública ou privada. Para adicionar um disco vazio, defina a entrada initializeParams sem o valor sourceImage. Inclua a propriedade de disco replicaZones para criar discos regionais em vez de zonais.

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
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "sourceImage":"projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE",
            "diskType":"DISK_TYPE"
         }
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "diskType":"DISK_TYPE"
         },
      },
      {
         "boot": false,
         "deviceName":"DISK_NAME",
         "initializeParams": {
            "diskType": "DISK_TYPE",
            "replicaZones": [
               "projects/PROJECT_ID/zones/ZONE",
               "projects/PROJECT_ID/zones/REMOTE_ZONE"
            ]
         }
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Substitua:

  • PROJECT_ID: ID do projeto em que a VM será criada
  • ZONE: zona em que a VM será criada
  • MACHINE_TYPE_ZONE: a zona que contém o tipo de máquina que será usado para a nova VM.
  • MACHINE_TYPE: tipo de máquina, predefinida ou personalizada, para a nova VM.
  • VM_NAME: nome da nova VM.
  • IMAGE_PROJECT: o projeto que contém a imagem
    Por exemplo, se você especificar debian-10 como a família de imagens, especifique debian-cloud como projeto de imagem.
  • IMAGE: especifique uma destas 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

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

  • Nos discos extras, substitua:

    • SIZE_GB: tamanho do disco;
    • DISK_IMAGE ou
    • DISK_IMAGE_FAMILY: especifique uma imagem de origem ou família de imagens para o disco que não é de inicialização:
      • DISK_IMAGE: nome da imagem que você quer usar como um disco que não é de inicialização. Por exemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
      • DISK_IMAGE_FAMILY: uma família de imagens a ser usada como disco que não é de inicialização. Por exemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
    • DISK_TYPE: URL completo ou parcial do tipo do disco. Por exemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced. O tipo de máquina precisa ser compatível com o tipo de disco.
    • DISK_NAME: opcional. O nome do disco exibido para o SO convidado após a criação da VM.

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

    Para discos vazios, não especifique a propriedade sourceImage.

    Para discos zonais, não especifique a propriedade replicaZones.

  • NETWORK_NAME: a rede VPC que você quer usar para a VM. Você pode especificar default para usar sua rede padrão.

  • ENABLE_SECURE_BOOT: opcional: se você escolher uma imagem compatível com recursos da VM protegida, o Compute Engine ativa, por padrão, o módulo de plataforma virtual confiável (vTPM) e o monitoramento de integridade. Por padrão, o Compute Engine não ativa a Inicialização segura.

    true Se você especificar enableSecureBoot para , o Compute Engine criará uma VM com todos os três recursos da VM protegida já ativados. Depois que o Compute Engine iniciar a VM, será preciso interrompê-la se você quiser modificar as opções de VM protegida.

Depois de criar a instância, formate os discos em branco e ative todos os discos antes de usá-los.