Crea un'istanza con dischi non di avvio aggiuntivi

Questo documento descrive come creare e collegare dischi non di avvio aggiuntivi a un'istanza Compute Engine durante la creazione dell'istanza.

Le informazioni contenute in questo documento si applicano alla creazione di un'istanza di computing con dischi di zona che non si trovano in un pool Hyperdisk. Il seguente elenco descrive le attività correlate e la documentazione pertinente.

Prima di iniziare

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

    Seleziona la scheda relativa a come intendi utilizzare i campioni in questa pagina:

    Console

    Quando utilizzi la console Google Cloud per accedere ai servizi Google Cloud e alle API, non devi configurare l'autenticazione.

    gcloud

    1. Installa Google Cloud CLI. Dopo l'installazione, inizializza Google Cloud CLI eseguendo il comando seguente: 

      gcloud init

      Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  • Imposta una regione e una zona predefinite.

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

      Installa Google Cloud CLI.

      Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

    Per saperne di più, consulta Autenticati per usare 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 disco per l'istanza: compute.disks.create sul progetto
  • Per creare un disco da un'immagine: compute.images.useReadOnly sull'immagine di origine
  • Per creare un disco da uno snapshot standard o di archiviazione: compute.snapshots.useReadOnly sullo snapshot di origine
  • Per creare un disco da uno snapshot istantaneo, se il disco di origine dello snapshot istantaneo è il disco di avvio di un'istanza con un account di servizio collegato: iam.serviceAccounts.actAs sul account di servizio account dell'istanza
  • Per creare un disco da uno snapshot istantaneo: compute.instantSnapshots.useReadOnly nello snapshot istantaneo di origine
  • Per creare un disco da un disco esistente: compute.disks.useReadOnly sul disco di origine

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

Limitazioni

Il numero, la dimensione combinata totale e il tipo di dischi che puoi collegare a un'istanza dipendono dal tipo di macchina dell'istanza.

Ad esempio, le istanze C4 non supportano Persistent Disk. Inoltre, le dimensioni combinate di tutti i dischi collegati a un'istanza c4-standard-2 non possono superare i 257 TiB, mentre per un'istanza c4-standard-192 il limite è di 512 TiB.

I limiti dettagliati per ogni serie di macchine sono riportati nella sezione Tipi di dischi supportati all'interno della documentazione della serie di macchine. Per visualizzare i limiti per la serie di macchine della tua nuova istanza, consulta il link corrispondente nella tabella seguente.

Tipi di macchine per uso generico
 Tipi di macchine
ottimizzate per il calcolo		 Tipi di macchine ottimizzate per la memoria
 Tipi di macchine ottimizzate per l'acceleratore
 Tipi di macchine ottimizzate per l'archiviazione

Limiti di dimensione del disco e nomi di riferimento

La dimensione specificata per un disco regionale deve rientrare negli intervalli elencati nella tabella seguente.

Quando crei un disco con Google Cloud CLI, REST o le librerie client Cloud per Compute Engine, specifica il tipo di disco da creare con il valore corrispondente della colonna Nome di riferimento nella tabella seguente.

Tipo di disco Nome del riferimento Dimensioni minime Dimensione massima Dimensioni predefinite
Hyperdisk bilanciato 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
Balanced Persistent Disk pd-balanced Zonale: 10 GiB
Regionale: 10 GiB		 64 TiB 100 GiB
Disco permanente (SSD) ad alte prestazioni pd-ssd Zonale: 10 GiB
Regionale: 10 GiB		 64 TiB 100 GiB
Standard Persistent Disk pd-standard Zonale: 10 GiB
Regionale: 200 GiB		 64 TiB 500 GiB
Disco permanente con carico estremo pd-extreme 500 GiB 64 TiB 1 TiB
1 Anteprima: C4 supporta una dimensione massima del disco di 128 TiB. Per accedere a questa funzionalità, contatta hyperdisk-questions@google.com.

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. Nel campo Regione, specifica la regione in cui vuoi che si trovi l'istanza.

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

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

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

    6. 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. Viene visualizzato il riquadro Sistema operativo e spazio di archiviazione.

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

  5. 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 Persistent Disk a livello di regione o Hyperdisk Balanced High Availability esistente nell'elenco Disco.

  6. (Facoltativo) Se il disco di avvio è un volume Hyperdisk Balanced, puoi impostare i limiti di prestazioni per il nuovo disco. I valori specificati devono rientrare nell'intervallo dei valori supportati.

  7. Facoltativo: per le opzioni di configurazione avanzata, espandi la sezione Mostra configurazioni avanzate.

    • Seleziona la modalità di collegamento del disco nel campo Modalità.
    • Scegli se conservare o eliminare il disco quando l'istanza viene eliminata selezionando l'opzione nel campo Regola di eliminazione.
    • Per semplificare l'identificazione del disco dal sistema operativo guest, specifica un nome dispositivo personalizzato. Sotto l'intestazione Nome dispositivo, seleziona l'opzione Utilizza un nome dispositivo personalizzato. Nel campo Nome dispositivo, inserisci una stringa da utilizzare come link simbolico per il disco.

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

  9. Per creare un nuovo disco non di avvio e collegarlo all'istanza, segui i passaggi riportati di seguito per ogni disco che vuoi aggiungere.

    1. Nella sezione Dischi aggiuntivi, fai clic su Aggiungi nuovo disco. Viene visualizzato il riquadro Aggiungi nuovo disco.

    2. Nella sezione Configurazione disco, nel campo Nome, specifica un nome per il disco non di avvio.

    3. (Facoltativo) Nel campo Descrizione, specifica una descrizione per il disco.

    4. Seleziona l'origine dati per il nuovo disco:

      • Per creare un disco vuoto e non formattato, seleziona Disco vuoto dall'elenco Tipo di disco di origine.
      • Per creare una copia dei dati esistenti, seleziona il tipo di origine per il disco non di avvio.

    5. Nell'elenco Tipo di disco, seleziona un tipo per il disco non di avvio. Il tipo di macchina deve supportare il tipo di disco.

    6. Nel campo Dimensioni, specifica le dimensioni del disco non di avvio.

    7. (Facoltativo) Se il nuovo disco è un volume Hyperdisk, puoi impostare i limiti di prestazioni per il nuovo disco. I valori che specifichi devono rientrare nell'intervallo di valori supportati e dipendono dal tipo di Hyperdisk, come segue:

      • Hyperdisk bilanciato. Puoi modificare le Dimensioni, le IOPS sottoposte a provisioning e il Throughput riservato del disco.
      • Hyperdisk Extreme. Puoi modificare le dimensioni e le IOPS sottoposte a provisioning del disco.
      • Hyperdisk ML. Puoi modificare le dimensioni e il Throughput riservato del disco.
      • Hyperdisk Throughput.Puoi modificare le dimensioni e il Throughput riservato del disco.

    8. Facoltativo: per le opzioni di configurazione avanzata, espandi la sezione Mostra configurazioni avanzate.

      • Seleziona la modalità di collegamento del disco nel campo Modalità.
      • Scegli se conservare o eliminare il disco quando l'istanza viene eliminata selezionando l'opzione nel campo Regola di eliminazione.
      • Per semplificare l'identificazione del disco dal sistema operativo guest, specifica un nome dispositivo personalizzato. Sotto l'intestazione Nome dispositivo, seleziona l'opzione Utilizza un nome dispositivo personalizzato. Nel campo Nome dispositivo, inserisci una stringa da utilizzare come link simbolico per il disco.

    9. Per confermare le opzioni e tornare al riquadro Sistema operativo e spazio di archiviazione, fai clic su Salva.

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

  10. (Facoltativo) Specifica le opzioni di backup e replica per l'istanza di calcolo. 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 di computing 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, seleziona la casella di controllo Replica asincrona.

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

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

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

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

gcloud

  1. Nella console Google Cloud , attiva Cloud Shell.

    Attiva Cloud Shell

    Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

  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 i valori per le seguenti 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 \
    --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

    Sostituisci quanto segue:

    • INSTANCE_NAME: il nome della nuova istanza.
    • ZONE: la zona in cui creare l'istanza.
    • MACHINE_TYPE: il tipo di macchina per l'istanza Ad esempio, c3-standard-4.
    • BOOT_DISK_IMAGE_PROJECT: il progetto contenente l'immagine. Ad esempio, per Debian, debian-cloud. Per trovare il progetto di immagini per le immagini pubbliche, vai alla pagina Dettagli del sistema operativo. Nella sezione Versioni GA del tuo sistema operativo, il progetto di immagine è elencato nella colonna Progetto di immagine della scheda Informazioni generali.

    • BOOT_DISK_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_NAME: (facoltativo) il nome del disco non di avvio.
      • SIZE_GB: (facoltativo) le dimensioni del disco non di avvio.
      • DISK_TYPE: il tipo di disco. Ad esempio: hyperdisk-balanced. Il tipo di macchina deve supportare il tipo di disco.
      • DISK_DEVICE_NAME: (facoltativo) il nome del disco visualizzato per il sistema operativo guest dopo la creazione dell'istanza.
      • DISK_IMAGE: (facoltativo) per creare un disco da un'immagine esistente, specifica una delle seguenti opzioni:
        • image=DISK_IMAGE_NAME: il nome dell'immagine che vuoi utilizzare per creare il disco non di avvio, ad esempio debian-12-bookworm-v20260210.
        • image-family=DISK_IMAGE_FAMILY: una famiglia di immagini da utilizzare per la creazione di un disco non di avvio, ad esempio debian-12.
      • DISK_IMAGE_PROJECT: (facoltativo) per creare un disco non di avvio da un'immagine esistente, specifica il progetto di immagini che contiene l'immagine.
      • REMOTE_ZONE: (facoltativo) se crei un disco regionale, specifica la zona in cui deve essere replicato il disco, ad esempio us-central1-b.

      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 saperne di più, 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 saperne di più, vedi Configura l'autenticazione per le librerie client. 

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 saperne di più, 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 saperne di più, vedi Configura l'autenticazione per le librerie client. 


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 saperne di più, 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 saperne di più, vedi Configura l'autenticazione per le librerie client. 

/**
 * 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 saperne di più, 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 saperne di più, vedi Configura l'autenticazione per le librerie client. 

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. Il tipo di macchina deve supportare il tipo di disco.
    • 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.

Dopo aver creato l'istanza, devi formattare tutti i dischi vuoti e montare tutti i dischi prima di poterli utilizzare.