Crea un'istanza con dischi non di avvio aggiuntivi

Quando crei un'istanza di computing, puoi creare e collegare contemporaneamente altri dischi non di avvio all'istanza. Puoi anche scegliere dischi esistenti da collegare come dischi non di avvio.

Se vuoi creare un disco in modalità multi-writer, non puoi creare il disco contemporaneamente all'istanza. Devi prima creare il disco, quindi puoi collegarlo all'istanza.

Prima di iniziare

  • Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale la tua identità viene verificata per l'accesso a servizi e API di Google Cloud . Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:

    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. After installing the Google Cloud CLI, initialize it by running the following command: 

        gcloud init

        If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

      2. Set a default region and zone.

        3. REST

        Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

          After installing the Google Cloud CLI, initialize it by running the following command: 

          gcloud init

          If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

        Per saperne di più, consulta la sezione Autenticarsi per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud .

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare un'istanza con dischi non di avvio aggiunti, chiedi all'amministratore di concederti il ruolo IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare un'istanza con dischi non di avvio aggiunti. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare un'istanza con dischi non di avvio aggiunti, sono necessarie le seguenti autorizzazioni:

  • compute.instances.create sul progetto
  • Per creare un nuovo disco per l'istanza: compute.disks.create sul progetto

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Crea un'istanza con nuovi dischi non di avvio aggiuntivi

Per creare un'istanza con dischi non di avvio aggiuntivi creati e collegati, segui questi passaggi:

Console

  1. Nella console Google Cloud , vai alla pagina Crea un'istanza.

    Vai a Crea un'istanza

    Se richiesto, seleziona il progetto e fai clic su Continua.

    Viene visualizzata la pagina Crea un'istanza, che contiene il riquadro Configurazione macchina.

  2. Nel riquadro Configurazione macchina, segui questi passaggi:

    1. Nel campo Nome, specifica un nome per l'istanza. Per ulteriori informazioni, consulta le convenzioni per la denominazione delle risorse.

    2. (Facoltativo) Nel campo Zona, seleziona una zona per l'istanza.

      La selezione predefinita è Qualsiasi. Se non modifichi questa selezione predefinita, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.

    3. Seleziona la famiglia di macchine per l'istanza. La console Google Cloud mostra le serie di macchine disponibili per la famiglia di macchine selezionata. Sono disponibili le seguenti opzioni per la famiglia di macchine:

      • Per uso generico
      • Ottimizzata per il calcolo
      • Ottimizzata per la memoria
      • Ottimizzata per l'archiviazione
      • GPU

    4. Nella colonna Serie, seleziona la serie di macchine per la tua istanza.

      Se nel passaggio precedente hai selezionato GPU come famiglia di macchine, seleziona il tipo di GPU che preferisci. La serie di macchine viene quindi selezionata automaticamente per il tipo di GPU selezionato.

    5. Nella sezione Tipo di macchina, seleziona il tipo di macchina per la tua istanza.

  3. Nel menu di navigazione, fai clic su Sistema operativo e spazio di archiviazione. Nel riquadro Sistema operativo e spazio di archiviazione visualizzato, completa i seguenti passaggi.

    Per scoprire di più sui parametri che puoi configurare durante l'aggiunta di nuovi dischi, consulta Informazioni su Persistent Disk e Informazioni su Google Cloud Hyperdisk.

    1. Per configurare il disco di avvio, fai clic su Cambia. Viene visualizzato il riquadro Disco di avvio con la scheda Immagini pubbliche.

    2. Configura l'origine dati per il disco di avvio in uno dei seguenti modi:

      • Per scegliere un'immagine pubblica come origine dati per il disco di avvio, nella scheda Immagini pubbliche specifica quanto segue:

        1. Nell'elenco Sistema operativo, seleziona il tipo di sistema operativo.
        2. Nell'elenco Versione, seleziona la versione del sistema operativo.
        3. Nell'elenco Tipo di disco di avvio, seleziona il tipo di disco di avvio.
        4. Nel campo Dimensioni (GB), specifica le dimensioni del disco di avvio.

      • Per scegliere un'immagine personalizzata come origine dati per il disco di avvio, fai clic su Immagini personalizzate e poi, nella scheda Immagini personalizzate visualizzata, specifica quanto segue:

        1. Per selezionare il progetto dell'immagine, fai clic su Cambia, quindi seleziona il progetto che contiene l'immagine.
        2. Nell'elenco Immagine, seleziona l'immagine che vuoi importare.
        3. Nell'elenco Tipo di disco di avvio, seleziona il tipo di disco di avvio.
        4. Nel campo Dimensioni (GB), specifica le dimensioni del disco di avvio.

      • Per scegliere uno snapshot standard come origine dati per il disco di avvio, fai clic su Snapshot e, nella scheda Snapshot visualizzata, specifica quanto segue:

        1. Nell'elenco Snapshot, seleziona lo snapshot.
        2. Nell'elenco Tipo di disco di avvio, seleziona il tipo di disco di avvio.
        3. Nel campo Dimensioni (GB), specifica le dimensioni del disco di avvio.

      • Per scegliere uno snapshot di archiviazione come origine dati per il disco di avvio, fai clic su Snapshot di archiviazione e poi, nella scheda Snapshot di archiviazione visualizzata, specifica quanto segue:

        1. Nell'elenco Snapshot di archiviazione, seleziona lo snapshot di archiviazione.
        2. Nell'elenco Tipo di disco di avvio, seleziona il tipo di disco di avvio.
        3. Nel campo Dimensioni (GB), specifica le dimensioni del disco di avvio.

      • Per scegliere un disco esistente come disco di avvio, fai clic su Dischi esistenti. Nella scheda Dischi esistenti visualizzata, seleziona un volume Permanent Disk a livello di regione o Hyperdisk bilanciato ad alta disponibilità esistente nell'elenco Disco.

    3. (Facoltativo) Per le opzioni di configurazione avanzata, espandi la sezione Mostra configurazioni avanzate.

    4. Per confermare le opzioni del disco di avvio e tornare al riquadro Sistema operativo e spazio di archiviazione, fai clic su Seleziona.

    5. Per creare un nuovo disco non di avvio e collegarlo all'istanza, fai clic su Aggiungi nuovo disco nella sezione Spazio di archiviazione aggiuntivo e backup delle VM.

      Nel riquadro Aggiungi nuovo disco visualizzato, segui questi passaggi:

      1. Nel campo Nome, specifica un nome per il disco non di avvio.
      2. Nell'elenco Tipo di disco di origine, seleziona il tipo di origine per il disco non di avvio.
      3. Nell'elenco Tipo di disco, seleziona un tipo per il disco non di avvio.
      4. Nel campo Dimensioni, specifica le dimensioni del disco non di avvio.
      5. Nella sezione Impostazioni allegati, segui questi passaggi:
      6. Nel campo Modalità, seleziona la modalità di collegamento del disco.
      7. Nel campo Regola di eliminazione, seleziona un'opzione per specificare che cosa accade al disco quando viene eliminata l'istanza.

      Ripeti questo passaggio per ogni disco non di avvio che vuoi creare e collegare all'istanza.

  4. Nel menu di navigazione, fai clic su Protezione dei dati. Nel riquadro Protezione dei dati visualizzato, specifica come eseguire il backup e la replica dei dati per l'istanza procedendo nel seguente modo.

    1. Per specificare come eseguire il backup dei dati, seleziona un'opzione per Effettua il backup dei dati.

    2. Per specificare la modalità di replica dei dati:

      1. Se vuoi che i nuovi dischi dell'istanza vengano replicati in modo sincrono in una seconda zona utilizzando i tipi di dischi a livello di regione, seleziona la casella di controllo Dischi regionali.
      1. Se vuoi che i dischi dell'istanza vengano replicati in una seconda regione utilizzando la Replica asincrona di Persistent Disk, seleziona la casella di controllo Replica asincrona.

    3. Se vuoi utilizzare le opzioni di protezione dei dati specificate solo sui dischi non di avvio, seleziona la casella di controllo Escludi dischi di avvio.

  5. Nel menu di navigazione, fai clic su Networking. Nel riquadro Networking visualizzato, segui questi passaggi:

    1. Vai alla sezione Firewall.

    2. Per consentire il traffico HTTP o HTTPS all'istanza, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

      Compute Engine aggiunge un tag di rete all'istanza e crea la regola firewall in entrata corrispondente che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS). Il tag di rete associa la regola firewall all'istanza. Per ulteriori informazioni, consulta la Panoramica delle regole firewall nella documentazione di Cloud Next Generation Firewall.

  6. (Facoltativo) Specifica altre opzioni di configurazione. Per ulteriori informazioni, consulta Opzioni di configurazione durante la creazione dell'istanza.

  7. Per creare e avviare l'istanza, fai clic su Crea.

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. Esegui il comando gcloud compute instances create per creare un'istanza con dischi non di avvio aggiuntivi.

    Puoi aggiungere fino a 127 dischi non di avvio durante la creazione dell'istanza. Specifica il flag --create-disk per ogni disco non di avvio che crei.

    Per creare dischi non di avvio da un'immagine pubblica o stock, specifica le proprietà image o image-family e image-project con il flag --create-disk. Per creare un disco vuoto, non includere queste proprietà.

    Facoltativamente, puoi includere le proprietà:

    • Dimensioni del disco: utilizza la proprietà --size
    • Tipo di disco: utilizza la proprietà --type
    • Dischi regionali: includi la proprietà replica-zones.
    gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --image-project=IMAGE_PROJECT \
    IMAGE_FLAG \
    --create-disk DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
    --create-disk device-name=DISK_NAME,replica-zones=^:^ZONE:REMOTE-ZONE,boot=false

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome della nuova istanza
    • ZONE: la zona in cui creare l'istanza
    • IMAGE_PROJECT: il progetto contenente l'immagine

    • IMAGE_FLAG: specifica una delle seguenti opzioni:

      • Utilizza il flag --image IMAGE_NAME per specificare una versione specifica di un'immagine pubblica o personalizzata. Ad esempio, --image debian-12-bookworm-v20241112.

      • Utilizza il flag --image-family IMAGE_FAMILY_NAME per specificare una famiglia di immagini. Questa operazione crea l'istanza che utilizza l'immagine sistema operativo più recente e non deprecata nella famiglia di immagini. Ad esempio, se specifichi --image-family debian-12, Compute Engine utilizza l'ultima versione dell'immagine sistema operativo nella famiglia di immagini Debian 12 durante la creazione dell'istanza.

    • Per dischi aggiuntivi, sostituisci quanto segue:

      • DISK_IMAGE: specifica una delle seguenti opzioni:
        • image=DISK_IMAGE_NAME: il nome dell'immagine che vuoi utilizzare per creare un disco non di avvio
        • image-family=DISK_IMAGE_FAMILY>: una famiglia di immagini da utilizzare per la creazione di un disco non di avvio
      • DISK_IMAGE_PROJECT: un progetto di immagini a cui appartiene l'immagine disco
      • SIZE_GB: (Facoltativo) dimensioni del disco non di avvio

      • DISK_TYPE: (Facoltativo) URL completo o parziale per il tipo del disco

        Ad esempio https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced. Per visualizzare i tipi di dischi disponibili in una o più zone, utilizza il comando gcloud compute disk-types list --zones=ZONE_LIST. Sostituisci ZONE_LIST con un elenco separato da virgole di zone.

      • DISK_NAME: (Facoltativo) il nome del disco visualizzato per il sistema operativo guest dopo la creazione dell'istanza

      • REMOTE_ZONE: la zona in cui deve essere replicato il disco

      Per i dischi vuoti, non specificare i parametri image, image-project o image-family.

      Per i dischi zonali, non specificare la proprietà del disco replica-zones.

Terraform

Per generare il codice Terraform, puoi utilizzare il componente Codice equivalente nella console Google Cloud .
  1. Nella console Google Cloud , vai alla pagina Istanze VM.

    Vai a Istanze VM

  2. Fai clic su Crea istanza.
  3. Specifica i parametri che ti interessano.
  4. Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e quindi sulla scheda Terraform per visualizzare il codice Terraform.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine per Go.

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine per Java.

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine per Node.js.

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine per Python.

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Puoi creare fino a 127 dischi non di avvio al momento della creazione di un'istanza utilizzando la proprietà initializeParams per ogni disco aggiuntivo. Crea dischi aggiuntivi con un'immagine pubblica o privata. Per aggiungere un disco vuoto, definisci la voce initializeParams senza valore sourceImage. Includi la proprietà del disco replicaZones per creare dischi regionali anziché zonali.

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

Sostituisci quanto segue:

  • PROJECT_ID: l'ID del progetto in cui creare la VM.
  • ZONE: la zona in cui creare la VM.
  • MACHINE_TYPE_ZONE: la zona contenente il tipo di macchina da utilizzare per la nuova VM.
  • MACHINE_TYPE: il tipo di macchina, predefinita o personalizzata, per la nuova VM
  • VM_NAME: il nome della nuova VM
  • IMAGE_PROJECT: il progetto contenente l'immagine
    Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto di immagini.
  • IMAGE: specifica una delle seguenti opzioni:

    • IMAGE: una versione specifica di un'immagine pubblica.

      Ad esempio, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

    • IMAGE_FAMILY: una famiglia di immagini.

      In questo modo, la VM viene creata dall'immagine sistema operativo più recente e non deprecata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dall'ultima versione dell'immagine sistema operativo nella famiglia di immagini Debian 10.

  • Per dischi aggiuntivi, sostituisci quanto segue:

    • SIZE_GB: dimensioni del disco.
    • DISK_IMAGE o
    • DISK_IMAGE_FAMILY: specifica un'immagine di origine o una famiglia di immagini per il disco non di avvio:
      • DISK_IMAGE: il nome dell'immagine che vuoi utilizzare come disco non di avvio. Ad esempio, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
      • DISK_IMAGE_FAMILY: una famiglia di immagini da utilizzare come disco non di avvio. Ad esempio, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
    • DISK_TYPE: URL completo o parziale per il tipo del disco. Ad esempio: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced.
    • DISK_NAME: (Facoltativo). Il nome del disco visualizzato per il sistema operativo guest dopo la creazione della VM.

    • REMOTE_ZONE: la zona in cui replicare il disco regionale.

    Per i dischi vuoti, non specificare la proprietà sourceImage.

    Per i dischi zonali, non specificare la proprietà replicaZones.

  • NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.

  • ENABLE_SECURE_BOOT: (Facoltativo) se hai scelto un'immagine che supporta le funzionalità Shielded VM, Compute Engine attiva per impostazione predefinita il Virtual Trusted Platform Module (vTPM) e il monitoraggio dell'integrità. Compute Engine non attiva l'Avvio protetto per impostazione predefinita.

    Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM attivate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni Shielded VM devi arrestarla.

Formatta e monta i dischi prima di utilizzarli.