Aggiungi dischi da un pool di archiviazione alle VM

Console

Con la console Google Cloud, puoi creare un nuovo disco in una il pool di archiviazione tramite la pagina Pool di archiviazione o Pagina Dischi.

Nella pagina Pool di archiviazione:

1. Nella console Google Cloud, vai alla pagina Pool di archiviazione.

   Vai alla pagina Pool di archiviazione

2. Fai clic sul nome del pool di archiviazione per il quale vuoi creare del disco.

3. Nella pagina Gestisci il pool di archiviazione, fai clic su +Crea nuovo disco.

4. Nel riquadro Aggiungi nuovo disco, inserisci un nome per il disco.

5. Specifica o modifica i valori per cui non vuoi utilizzare il parametro predefinito.

6. Dopo aver specificato le proprietà del disco, fai clic su Salva.

7. Il nuovo disco dovrebbe essere visualizzato nella pagina Gestisci il pool di archiviazione. nella sezione Dischi del pool di archiviazione.

Nella pagina Crea disco:

1. Nella console Google Cloud, vai a Dischi > Pagina Crea un disco.

   Vai alla pagina Crea un disco

2. Inserisci un nome per il disco.

3. Seleziona la zona che contiene il pool di archiviazione da creare del disco.

4. Per Tipo di disco, scegli il tipo di disco che corrisponde al pool di archiviazione Hyperdisk, velocità effettiva Hyperdisk o Hyperdisk bilanciata.

5. Modifica i valori in Dimensioni, IOPS sottoposte a provisioning e Campi Velocità effettiva sottoposta a provisioning, se necessario.

6. Nella sezione Pool di archiviazione, seleziona Attiva pool di archiviazione, quindi scegli il nome del pool di archiviazione in cui creare il disco. Solo il pool di archiviazione esistente nella zona selezionata verrà visualizzato nell'elenco.

7. Dopo aver specificato le informazioni sul disco, fai clic su Crea.

gcloud

Per creare uno o più dischi in un pool di archiviazione, utilizza Comando gcloud compute disks create.

gcloud compute disks create DISK_NAME \
    --zone=ZONE \
    --storage-pool=STORAGE_POOL_NAME \
    --size=SIZE \
    --type=DISK_TYPE \
    --provisioned-iops=PROVISIONED_IOPS \
    --provisioned-throughput=PROVISIONED_THROUGHPUT

Sostituisci quanto segue:

• DISK_NAME: un nome univoco per il disco. Puoi fornire un elenco di nomi di dischi specificati dagli spazi per creare più dischi gli stessi attributi.
• ZONE: la zona in cui è stato creato il pool di archiviazione. Specifica questo valore nel formato regione-zona, ad esempio us-central1-a.
• STORAGE_POOL_NAME: il nome del pool di archiviazione in cui creare il disco
• SIZE: (facoltativo) la capacità del nuovo disco di cui è stato eseguito il provisioning. La il valore deve essere un numero intero seguito da un'unità di dimensione di GB per il gibibyte, o TB per tebibyte. Se non viene specificata alcuna dimensione, viene utilizzato il valore predefinito di 100 GB.
• DISK_TYPE: tipo di disco da creare. Deve corrispondere al tipo del pool di archiviazione Hyperdisk, hyperdisk-balanced o hyperdisk-throughput.
• PROVISIONED_IOPS: facoltativo: le IOPS di cui eseguire il provisioning per disco. Puoi utilizzare questo flag solo con i dischi Hyperdisk Balanced.
• PROVISIONED_THROUGHPUT: facoltativo: la velocità effettiva in mebibyte (MB) al secondo per eseguire il provisioning del disco.

REST

Per creare uno o più dischi in un pool di archiviazione, crea un POST utilizzando il metodo disks.insert. Includi name, sizeGb, type, storagePool, provisionedIops e provisionedThroughput proprietà. Per creare questo disco come disco non di avvio vuoto e non formattato, non specificare un'immagine di origine o uno snapshot di origine.

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

{
    "name": "DISK_NAME",
    "description": "DESCRIPTION",
    "type": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/DISK_TYPE",
    "sizeGb": "DISK_SIZE",
    "storagePool": "STORAGE_POOL_NAME",
    "provisionedIops": "IOPS_LIMIT",
    "provisionedThroughput": "THROUGHPUT_LIMIT",
}

Sostituisci quanto segue:

• PROJECT_ID: ID progetto
• ZONE: la zona in cui si trova il pool di archiviazione, ad esempio us-central1-a. Questa è la zona in cui il disco in cui eseguire la creazione.
• DISK_NAME: un nome univoco per il disco.
• DESCRIPTION: facoltativo: una stringa di testo che descrive disco.
• DISK_TYPE: il tipo di disco, che deve corrispondere al tipo di pool di archiviazione. Usa hyperdisk-throughput o hyperdisk-balanced.
• DISK_SIZE: (facoltativo) la dimensione del nuovo disco. Il valore deve essere un numero intero seguito da un'unità di dimensione di GB per i gibibyte o da TB per tebibyte. Se non viene specificata alcuna dimensione, viene utilizzato 100 GB come predefinito.
• STORAGE_POOL_NAME: il nome del pool di archiviazione in cui creare il disco.
• IOPS_LIMIT: facoltativo: le IOPS di cui eseguire il provisioning per disco. Puoi utilizzare questo flag solo con i dischi Hyperdisk bilanciati.
• THROUGHPUT_LIMIT: facoltativo. La velocità in mebibyte (MB) per secondo da eseguire il provisioning per il disco.

Vai

// createDiskInStoragePool creates a new Hyperdisk in the specified storage pool.
func createDiskInStoragePool(w io.Writer, projectId, zone, diskName, storagePoolName, diskType string) error {
	// Example usage:
	//   projectID := "your_project_id"
	//   zone := "europe-central2-b"
	//   diskName := "your_disk_name"
	//   storagePoolName := "https://www.googleapis.com/compute/v1/projects/your_project_id/zones/europe-central2-b/storagePools/your_storage_pool"
	//   diskType := "zones/europe-central2-b/diskTypes/hyperdisk-balanced"

	ctx := context.Background()
	client, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %v", err)
	}
	defer client.Close()

	// Create the disk resource
	disk := &computepb.Disk{
		Name:                  proto.String(diskName),
		Type:                  proto.String(diskType),
		SizeGb:                proto.Int64(50),
		Zone:                  proto.String(zone),
		StoragePool:           proto.String(storagePoolName),
		ProvisionedIops:       proto.Int64(10000),
		ProvisionedThroughput: proto.Int64(1024),
	}

	// Create the insert disk request
	req := &computepb.InsertDiskRequest{
		Project:      projectId,
		Zone:         zone,
		DiskResource: disk,
	}

	// Send the insert disk request
	op, err := client.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("Insert disk request failed: %v", err)
	}

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

	fmt.Fprintf(w, "Disk created in storage pool: %v\n", disk.Name)
	return nil
}

Java

import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateDiskInStoragePool {
  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";
    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";
    // Link to the storagePool you want to use. Use format :
    // https://www.googleapis.com/compute/v1/projects/%s/zones/%s/storagePools/%s"
    String storagePoolName = "YOUR_STORAGE_POOL_LINK";
    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-throughput)".
    // For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
    String diskType = String.format("zones/%s/diskTypes/hyperdisk-balanced", zone);
    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;
    // Optional: the IOPS to provision for the disk.
    // You can use this flag only with Hyperdisk Balanced disks.
    long provisionedIops = 3000;
    // Optional: the throughput in mebibyte (MB) per second to provision for the disk.
    long provisionedThroughput = 140;

    createDiskInStoragePool(projectId, zone, diskName, storagePoolName, diskType,
            diskSizeGb, provisionedIops, provisionedThroughput);
  }

  // Creates a hyperdisk in the storage pool
  public static Disk createDiskInStoragePool(String projectId, String zone, String diskName,
                                             String storagePoolName, String diskType,
                                             long diskSizeGb, long iops, long throughput)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (DisksClient client = DisksClient.create()) {
      // Create a disk.
      Disk disk = Disk.newBuilder()
              .setZone(zone)
              .setName(diskName)
              .setType(diskType)
              .setSizeGb(diskSizeGb)
              .setStoragePool(storagePoolName)
              .setProvisionedIops(iops)
              .setProvisionedThroughput(throughput)
              .build();

      InsertDiskRequest request = InsertDiskRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setDiskResource(disk)
              .build();

      // Wait for the insert disk operation to complete.
      Operation operation = client.insertAsync(request).get(1, TimeUnit.MINUTES);

      if (operation.hasError()) {
        System.out.println("Disk creation failed!");
        throw new Error(operation.getError().toString());
      }

      // Wait for server update
      TimeUnit.SECONDS.sleep(10);

      Disk hyperdisk = client.get(projectId, zone, diskName);

      System.out.printf("Hyperdisk '%s' has been created successfully", hyperdisk.getName());

      return hyperdisk;
    }
  }
}

Node.js

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a diskClient
const disksClient = new computeLib.DisksClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await disksClient.getProjectId();
// The zone where your VM and new disk are located.
const zone = 'us-central1-a';
// The name of the new disk
const diskName = 'disk-from-pool-name';
// The name of the storage pool
const storagePoolName = 'storage-pool-name';
// Link to the storagePool you want to use. Use format:
// https://www.googleapis.com/compute/v1/projects/{projectId}/zones/{zone}/storagePools/{storagePoolName}
const storagePool = `https://www.googleapis.com/compute/v1/projects/${projectId}/zones/${zone}/storagePools/${storagePoolName}`;
// The type of disk. This value uses the following format:
// "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-extreme|hyperdisk-ml|hyperdisk-throughput)".
// For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
const diskType = `zones/${zone}/diskTypes/hyperdisk-balanced`;
// Size of the new disk in gigabytes.
const diskSizeGb = 10;
// Optional: For Hyperdisk Balanced or Hyperdisk Extreme disks,
// this is the number of I/O operations per second (IOPS) that the disk can handle.
const provisionedIops = 3000;
// Optional: For Hyperdisk Balanced or Hyperdisk Throughput volumes,
// this is an integer that represents the throughput,
// measured in MiB per second, that the disk can handle.
const provisionedThroughput = 140;

async function callCreateComputeHyperdiskFromPool() {
  // Create a disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: diskName,
    type: diskType,
    zone,
    storagePool,
    provisionedIops,
    provisionedThroughput,
  });

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: disk,
  });

  let operation = response.latestResponse;

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

  const hyperdisk = (
    await disksClient.get({
      project: projectId,
      zone,
      disk: diskName,
    })
  )[0];

  console.log(JSON.stringify(hyperdisk));
}

await callCreateComputeHyperdiskFromPool();

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Inserisci un nome per l'istanza.

4. Imposta la zona sulla stessa in cui si trova il pool di archiviazione.

5. Scegli un tipo di macchina che supporti Hyperdisk Balanced, ad esempio H3.

6. Nella sezione Disco di avvio, fai clic su Cambia.

7. Nel riquadro Disco di avvio, imposta Tipo di disco di avvio su Hyperdisk Bilanciato.

8. Configura le proprietà per il disco.

9. Espandi Mostra configurazione avanzata.

10. Sotto l'intestazione Pool di archiviazione, seleziona Abilita pool di archiviazione.

11. Scegli dall'elenco il pool di archiviazione in cui creare il disco.

12. Al termine della configurazione del disco, fai clic su Seleziona.

13. Completa la configurazione delle proprietà della VM.

14. Fai clic su Crea.

    La console crea la VM nella zona specificata e il disco di avvio nel pool di archiviazione selezionato.

gcloud

Puoi creare il disco di avvio per una nuova VM nella utilizzando Comando gcloud compute instances create e include la proprietà storage-pool per il disco di avvio.

gcloud compute instances create VM_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --create-disk=boot=yes,type=hyperdisk-balanced,size=DISK_SIZE,provisioned-throughput=THROUGHPUT, \
    provisioned-iops=IOPS,image=projects/IMAGE_PROJECT/global/images/IMAGE, \
    storage-pool=STORAGE_POOL_NAME

Sostituisci quanto segue:

• VM_NAME: il nome della VM.
• ZONE: la regione e la zona in cui creare la VM, utilizzando il formato us-central1-a.
• MACHINE_TYPE: tipo di macchina della VM, ad esempio m3-ultramem-32.
• DISK_SIZE: le dimensioni, in GiB, del disco di avvio
• THROUGHPUT: la velocità effettiva di provisioning per il disco
• IOPS: le IOPS da eseguire il provisioning per il disco
• IMAGE_PROJECT: il progetto che contiene l'immagine
• IMAGE: specifica una delle seguenti opzioni:
  • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240213.
  • Una famiglia di immagini, che deve essere formattato come family/IMAGE_FAMILY. In questo modo viene creata l'istanza dall'immagine del sistema operativo più recente e non deprecata. Per Ad esempio, se specifichi family/debian-12, Compute Engine crea un'istanza VM che utilizza la versione più recente dell'immagine del sistema operativo nell'immagine debian-12 famiglia. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta Best practice per le famiglie di immagini.
• STORAGE_POOL_NAME: il nome del pool di archiviazione per la creazione con il nuovo disco.

REST

Puoi creare il disco di avvio per una nuova VM nel pool di archiviazione creando una richiesta POST Metodo instances.insert e include la proprietà storagePool per il disco di avvio.

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

{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
         "deviceName": "BOOT_DISK_DEVICE_NAME",
         "initializeParams": {
            "diskSizeGb": "DISK_SIZE",
            "diskType": "DISK_TYPE",
            "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
            "boot": true,
            "provisionedIops": "IOPS_LIMIT",
            "provisionedThroughput": "THROUGHPUT_LIMIT",
            "storagePool": "POOL_URL"
         }
      }
   ]
}

Sostituisci quanto segue:

• PROJECT_ID: ID progetto
• ZONE: la zona in cui si trova il pool di archiviazione, ad esempio us-central1-a. Questa è la zona in cui si trovano la VM e il disco di avvio in cui è stato creato.
• VM_NAME: il nome della VM.
• MACHINE_TYPE: tipo di macchina della VM, ad esempio m3-ultramem-32.
• BOOT_DISK_DEVICE_NAME: il nome del dispositivo per il disco di avvio
• DISK_SIZE: la dimensione, in GiB, del disco di avvio
• DISK_TYPE: il tipo di disco, specificato come URI
• IMAGE_PROJECT: il progetto che contiene l'immagine
• IMAGE: specifica una delle seguenti opzioni:
  • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240213.
  • Una famiglia di immagini, che deve essere formattato come family/IMAGE_FAMILY. Questo crea l'istanza dall'immagine sistema operativo più recente e non deprecata. Ad esempio, se specifichi family/debian-12, Compute Engine crea una VM utilizzando la versione più recente dell'immagine del sistema operativo nella famiglia di immagini debian-12. Per saperne di più sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.
• IOPS_LIMIT: le IOPS di cui eseguire il provisioning per il disco
• THROUGHPUT_LIMIT: la velocità effettiva di provisioning per il disco
• POOL_URL: il pool di archiviazione in cui viene creato il nuovo disco. Puoi fornirlo come URL parziale o completo della risorsa. Per Ecco alcuni valori validi:
  • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • zones/ZONE/storagePools/STORAGE_POOL_NAME

Console

Segui questi passaggi per creare una nuova VM con la console dischi aggiuntivi non di avvio:

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Inserisci un nome per la VM.

4. Imposta la zona sulla stessa in cui si trova il pool di archiviazione.

5. Scegli un tipo di macchina che supporti il tipo di disco utilizzato dall' pool di archiviazione.

6. Espandi la sezione Opzioni avanzate.

7. Espandi Dischi.

8. Fai clic su add Aggiungi nuovo disco.

9. Nel riquadro Aggiungi nuovo disco, inserisci le informazioni del disco. Imposta il tipo di disco in modo che corrisponda al tipo di pool di archiviazione.

10. Nella sezione Pool di archiviazione, seleziona Abilita pool di archiviazione.

11. Nel campo Seleziona un pool di archiviazione, seleziona il pool di archiviazione in cui creare il disco.

12. Al termine della configurazione del disco, fai clic su Salva.

13. Completa la configurazione delle proprietà della VM.

14. Fai clic su Crea.

    La console crea la VM nella zona specificata e crea disco non di avvio nel pool di archiviazione selezionato.

gcloud

Puoi creare nuovi dischi in un pool di archiviazione durante la creazione delle VM utilizzando Il comando gcloud compute instances create e include la proprietà storage-pool per il disco.

gcloud compute instances create VM_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --create-disk=auto-delete=yes,boot=yes,device-name=BOOT_DISK_DEVICE_NAME,image=IMAGE_NAME, \
    size=BOOT_DISK_SIZE,type=BOOT_DISK_TYPE
    --create-disk=auto-delete=yes,boot=no,device-name=DATA_DISK_DEVICE_NAME,size=DATA_DISK_SIZE, \
    type=DATA_DISK_TYPE,provisioned-iops=IOPS,provisioned-throughput=THROUGHPUT, \
    storage_pool=STORAGE_POOL_NAME

Sostituisci quanto segue:

• VM_NAME: il nome della VM.
• ZONE: la regione e la zona in cui creare la VM, utilizzando il formato us-central1-a
• MACHINE_TYPE: il tipo di macchina della VM
• BOOT_DISK_DEVICE_NAME: il nome del dispositivo per il disco di avvio
• IMAGE_NAME: il nome dell'immagine del sistema operativo da installare sul disco di avvio, ad esempio debian-12-bookworm-v20240213
• BOOT_DISK_SIZE: le dimensioni, in GiB, del disco di avvio
• BOOT_DISK_TYPE: tipo di disco
• DATA_DISK_DEVICE_NAME: nome dispositivo disco per il disco dati
• DATA_DISK_SIZE: la dimensione del disco dati in GiB
• DATA_DISK_TYPE: il tipo di disco dati, hyperdisk-balanced o hyperdisk-throughput
• IOPS: le IOPS di cui eseguire il provisioning per il disco
• THROUGHPUT: la velocità effettiva da eseguire il provisioning per il disco
• STORAGE_POOL_NAME: il nome univoco del pool di archiviazione in cui vuoi creare il disco.

REST

Puoi creare nuovi dischi in un pool di archiviazione durante la creazione della VM creando una richiesta POST Metodo instances.insert e includere la proprietà storagePool per i dischi aggiuntivi.

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

{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
        "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
        },
        "boot":true
      },
      {
        "deviceName": "DEVICE_NAME",
        "boot":false,
        "initializeParams": {
           "diskSizeGb": "DISK_SIZE",
           "diskType": "DISK_TYPE",
           "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
           "provisionedIops": "IOPS_LIMIT",
           "provisionedThroughput": "THROUGHPUT_LIMIT",
           "storagePool": "POOL_URL"
        }
      }
   ]
}

Sostituisci quanto segue:

• PROJECT_ID: ID progetto
• ZONE: la zona in cui si trova il pool di archiviazione, ad esempio us-central1-a. Questa è la zona in cui si trovano la VM e il disco di avvio in cui è stato creato.
• VM_NAME: il nome della VM.
• MACHINE_TYPE: tipo di macchina della VM, ad esempio m3-ultramem-32.
• IMAGE_PROJECT: il progetto che contiene l'immagine
• IMAGE: specifica una delle seguenti opzioni:
  • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240213.
  • Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. Questo crea l'istanza dall'immagine sistema operativo più recente e non deprecata. Per Ad esempio, se specifichi family/debian-12, Compute Engine crea un'istanza VM che utilizza la versione più recente dell'immagine del sistema operativo nell'immagine debian-12 famiglia. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta Best practice per le famiglie di immagini.
• DEVICE_NAME: il nome del dispositivo per il disco dati
• DISK_SIZE: la dimensione, in GiB, del disco dati
• DISK_TYPE: il tipo di disco, specificato come URI
• IOPS_LIMIT: le IOPS di cui eseguire il provisioning per il disco
• THROUGHPUT_LIMIT: la velocità effettiva di provisioning per il disco
• POOL_URL: il pool di archiviazione in cui viene creato il nuovo disco. Puoi fornirlo come URL parziale o completo della risorsa. Per Ecco alcuni valori validi:
  • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • zones/ZONE/storagePools/STORAGE_POOL_NAME

Console

1. Nella console Google Cloud, vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

2. Fai clic su Crea modello istanza.

3. Inserisci un nome per il modello di istanza.

4. Scegli Regionale per la località e nel campo Regione scegli la regione in cui si trova il pool di archiviazione.

5. Scegli un tipo di macchina che supporti Hyperdisk Balanced, ad esempio C3.

6. Nella sezione Disco di avvio, fai clic su Cambia.

7. Nel riquadro Disco di avvio, imposta Tipo di disco di avvio su Hyperdisk Bilanciato.

8. Configura le proprietà per il disco.

9. Espandi Mostra configurazione avanzata.

10. Sotto l'intestazione Pool di archiviazione, seleziona Abilita pool di archiviazione.

11. Scegli dall'elenco il pool di archiviazione in cui creare il disco.

12. Al termine della configurazione del disco, fai clic su Seleziona.

13. Completa la configurazione delle proprietà della VM.

14. Fai clic su Crea.

    Il modello crea la VM nella zona specificata e crea l'avvio nel pool di archiviazione selezionato.

gcloud

Puoi specificare un modello di istanza in cui creare il disco del libro un pool di archiviazione utilizzando Comando gcloud compute instance-templates create e include la proprietà storage-pool per il disco di avvio.

gcloud compute instance-templates create TEMPLATE_NAME \
    --instance-template-region=REGION \
    --machine-type=MACHINE_TYPE \
    --create-disk=boot=yes,type=hyperdisk-balanced,size=DISK_SIZE,provisioned-throughput=THROUGHPUT, \
    provisioned-iops=IOPS,image=projects/IMAGE_PROJECT/global/images/IMAGE, \
    storage-pool=STORAGE_POOL_NAME

Sostituisci quanto segue:

• TEMPLATE_NAME: il nome del modello di istanza.
• REGION: la regione in cui vuoi creare la regione modello di istanza. La regione deve contenere la zona in cui si trova il pool di archiviazione.
• MACHINE_TYPE: tipo di macchina da utilizzare durante la creazione della VM ad esempio h3-standard-88.
• DISK_SIZE: la dimensione, in GiB, del disco
• THROUGHPUT: la velocità effettiva di provisioning per il disco
• IOPS: le IOPS di cui eseguire il provisioning per il disco
• IMAGE_PROJECT: il progetto che contiene l'immagine
• IMAGE: specifica una delle seguenti opzioni:
  • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240213.
  • Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. Questo crea l'istanza dall'immagine sistema operativo più recente e non deprecata. Per Ad esempio, se specifichi family/debian-12, Compute Engine crea un'istanza VM che utilizza la versione più recente dell'immagine del sistema operativo nell'immagine debian-12 famiglia. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta Best practice per le famiglie di immagini.
• STORAGE_POOL_NAME: il nome del pool di archiviazione per la creazione con il nuovo disco.

REST

Puoi creare il disco di avvio per una nuova VM nel pool di archiviazione creando una richiesta POST Metodo instances.insert e include la proprietà storagePool per il disco di avvio.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
{
   "name": "VM_NAME",
   "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
   "disks": [
      {
         "deviceName": "BOOT_DISK_DEVICE_NAME",
         "initializeParams": {
            "diskSizeGb": "DISK_SIZE",
            "diskType": "DISK_TYPE",
            "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
            "boot": true,
            "provisionedIops": "IOPS_LIMIT",
            "provisionedThroughput": "THROUGHPUT_LIMIT",
            "storagePool": "POOL_URL"
         }
      }
   ]
}

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto
• VM_NAME: il nome della VM.
• ZONE: la zona in cui si trova il pool di archiviazione, ad esempio us-central1-a. Questa è la zona in cui si trovano la VM e il disco di avvio in cui è stato creato.
• MACHINE_TYPE: tipo di macchina della VM, ad esempio m3-ultramem-32.
• BOOT_DISK_DEVICE_NAME: il nome del dispositivo per il disco di avvio
• DISK_SIZE: la dimensione, in GiB, del disco di avvio
• DISK_TYPE: il tipo di disco, specificato come URI
• IMAGE_PROJECT: il progetto che contiene l'immagine
• IMAGE: specifica una delle seguenti opzioni:
  • Una versione specifica dell'immagine del sistema operativo, ad esempio debian-12-bookworm-v20240213.
  • Una famiglia di immagini, che deve essere formattato come family/IMAGE_FAMILY. Questo crea l'istanza dall'immagine sistema operativo più recente e non deprecata. Per Ad esempio, se specifichi family/debian-12, Compute Engine crea un'istanza utilizzando la versione più recente dell'immagine del sistema operativo in debian-12 famiglia di immagini. Per saperne di più sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.
• IOPS_LIMIT: le IOPS di cui eseguire il provisioning per il disco
• THROUGHPUT_LIMIT: la velocità effettiva di provisioning per il disco
• POOL_URL: il pool di archiviazione in cui viene creato il nuovo disco. Puoi fornirlo come URL parziale o completo della risorsa. Per Ecco alcuni valori validi:
  • https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • projects/PROJECT_ID/zones/ZONE/storagePools/STORAGE_POOL_NAME
  • zones/ZONE/storagePools/STORAGE_POOL_NAME