Crea un pool Hyperdisk

Questo documento descrive come creare pool Hyperdisk. I pool Hyperdisk sono risorse di archiviazione a blocchi che ti aiutano a gestire le tue risorse di archiviazione a blocchi Hyperdisk in modo aggregato. I pool Hyperdisk sono disponibili nelle seguenti varianti:

Pool di archiviazione Hyperdisk: consigliati per la maggior parte dei workload
Hyperdisk Exapools: consigliato per workload molto grandi che richiedono più di 100 GiB/s di prestazioni simultanee

Per scoprire di più sui diversi tipi di pool Hyperdisk, consulta Panoramica dei pool Hyperdisk.

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.
  
  Nota:se hai installato gcloud CLI in precedenza, assicurati di avere l'ultima versione eseguendo gcloud components update.
Imposta una regione e una zona predefinite.

Go

Per utilizzare gli esempi di Go in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Java

Per utilizzare gli esempi Java in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Node.js

Per utilizzare gli esempi di Node.js in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

Installa Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
Se utilizzi una shell locale, crea le credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Non è necessario eseguire questa operazione se utilizzi Cloud Shell.

Se viene restituito un errore di autenticazione e utilizzi un provider di identità (IdP) esterno, verifica di aver acceduto a gcloud CLI con la tua identità federata.

Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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 e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per creare un pool Hyperdisk, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)
Per connetterti a un'istanza VM che può essere eseguita come service account: Service Account User (v1) (ruolo roles/iam.serviceAccountUser)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare un pool Hyperdisk. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare un pool Hyperdisk sono necessarie le seguenti autorizzazioni:

compute.storagePools.create sul progetto
compute.storagePools.setLabels sul progetto

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

Limitazioni

Quando crei pool di archiviazione Hyperdisk, si applicano le seguenti limitazioni:

Limiti delle risorse:

Puoi creare un pool di archiviazione Hyperdisk con una capacità sottoposta a provisioning massima di 5 PiB.
Puoi creare un massimo di 5 pool di archiviazione all'ora.
Puoi creare un massimo di 10 pool di archiviazione al giorno.
Puoi creare un massimo di 10 pool di archiviazione per progetto.
Non puoi modificare il modello di provisioning per un pool. Ad esempio, non puoi modificare un pool di archiviazione con capacità standard in un pool di archiviazione con capacità avanzata o un pool di archiviazione con prestazioni avanzate in un pool di archiviazione con prestazioni standard.
I pool sono una risorsa di zona.
Puoi creare fino a 10.000 dischi in un pool di archiviazione.
Puoi utilizzare i pool di archiviazione Hyperdisk solo con Compute Engine. Le istanze Cloud SQL non possono utilizzare i pool di archiviazione Hyperdisk.
Puoi modificare la capacità o le prestazioni sottoposte a provisioning di un pool di archiviazione al massimo due volte in un periodo di 24 ore.
Puoi creare solo dischi Hyperdisk bilanciato in un pool Hyperdisk bilanciato e solo dischi Hyperdisk Throughput in un pool Hyperdisk Throughput
Devi contattare il team dedicato all'account per modificare la capacità, gli IOPS o il throughput di un exapool.
Per eliminare un exapool, devi contattare il team dedicato al tuo account.

Limiti per i dischi in un pool di archiviazione:

In un pool è possibile creare nuovi dischi solo nello stesso progetto e nella stessa zona.
Non puoi spostare i dischi all'interno o all'esterno di un pool. Per spostare un disco all'interno o all'esterno di un pool, devi ricrearlo da uno snapshot. Per ulteriori informazioni, consulta Cambia il tipo di disco.
Per creare dischi di avvio in un pool, devi utilizzare un pool di archiviazione Hyperdisk bilanciato o un pool di espansione Hyperdisk bilanciato.
I pool non supportano dischi a livello di regione.
Non puoi clonare, creare snapshot istantanei o configurare la replica asincrona per i dischi in un pool.

Intervalli di capacità e limiti di prestazioni di cui è stato eseguito il provisioning

Quando crei un pool di archiviazione, la capacità di provisioning, le IOPS e il throughput non possono superare i limiti descritti in Limiti per i pool.

Crea un pool di archiviazione Hyperdisk

Per creare un nuovo pool di archiviazione Hyperdisk, utilizza la Google Cloud console, Google Cloud CLI o REST. Quando crei un pool di archiviazione, devi specificare le seguenti proprietà:

Zona
Tipo di pool di archiviazione
Modello di provisioning della capacità
Capacità sottoposta a provisioning del pool
Tipo provisioning prestazioni
IOPS e throughput sottoposti a provisioning del pool

Console

Vai alla pagina Crea un pool di archiviazione nella Google Cloud console.
Vai alla pagina Crea pool di archiviazione
Nel campo Nome, inserisci un nome univoco per il pool di archiviazione.
(Facoltativo) Nel campo Descrizione, inserisci una descrizione per il pool di archiviazione.
Seleziona la Regione e la Zona in cui creare il pool di archiviazione.
Scegli un valore per il Tipo di pool di archiviazione.
Scegli un tipo di provisioning nel campo Tipo di capacità e specifica la capacità di cui eseguire il provisioning per il pool di archiviazione nel campo Capacità pool di archiviazione. Puoi specificare una dimensione da 10 TiB a 1 PiB.

Per creare un pool di archiviazione con una grande capacità, potresti dover richiedere un aggiustamento delle quote.
Scegli un tipo di provisioning nel campo Tipo di prestazioni. Puoi utilizzare i seguenti tipi di provisioning con i pool di archiviazione Hyperdisk:
- Capacità standard: la capacità sottoposta a provisioning per ogni disco creato nel pool di archiviazione viene detratta dalla capacità totale sottoposta a provisioning del pool di archiviazione.
- Capacità avanzata: il pool di archiviazione trae vantaggio dal thin provisioning e dalla riduzione dei dati. Solo la quantità di dati effettivamente scritti viene detratta dalla capacità totale sottoposta a provisioning del pool di archiviazione.
- Prestazioni standard: le prestazioni di cui è stato eseguito il provisioning per ogni disco creato nel pool di archiviazione vengono detratte dalle prestazioni totali di cui è stato eseguito il provisioning del pool di archiviazione.
- Prestazioni avanzate: le prestazioni di cui è stato eseguito il provisioning per ogni disco beneficiano del thin provisioning. Solo la quantità di prestazioni utilizzata da un disco viene detratta dalle prestazioni totali sottoposte a provisioning del pool di archiviazione.
Per i pool di archiviazione Hyperdisk Balanced, nel campo IOPS sottoposte a provisioning, inserisci le IOPS di cui eseguire il provisioning per il pool di archiviazione.
Per un pool di archiviazione Hyperdisk Throughput o Hyperdisk Balanced, nel campo Throughput sottoposto a provisioning, inserisci il throughput di cui eseguire il provisioning per il pool di archiviazione.
Fai clic su Invia per creare il pool di archiviazione.

gcloud

Per creare un pool di archiviazione Hyperdisk, utilizza il comando gcloud compute storage-pools create.

gcloud compute storage-pools create NAME  \
    --zone=ZONE   \
    --storage-pool-type=STORAGE_POOL_TYPE   \
    --capacity-provisioning-type=CAPACITY_TYPE \
    --provisioned-capacity=POOL_CAPACITY   \
    --performance-provisioning-type=PERFORMANCE_TYPE \
    --provisioned-iops=IOPS   \
    --provisioned-throughput=THROUGHPUT   \
    --description=DESCRIPTION

Sostituisci quanto segue:

NAME: il nome univoco del pool di archiviazione.
ZONE: la zona in cui creare il pool di archiviazione, ad esempio us-central1-a.
STORAGE_POOL_TYPE: il tipo di disco da archiviare nel pool di archiviazione. I valori consentiti sono hyperdisk-throughput e hyperdisk-balanced.
CAPACITY_TYPE: facoltativo, il tipo di provisioning della capacità del pool di archiviazione. I valori consentiti sono advanced e standard. Se non specificato, viene utilizzato il valore advanced.
POOL_CAPACITY: la capacità totale di cui eseguire il provisioning per il nuovo pool di archiviazione, specificata in GiB per impostazione predefinita.
PERFORMANCE_TYPE: facoltativo, il tipo di provisioning per le prestazioni del pool di archiviazione. I valori consentiti sono advanced e standard. Se non specificato, viene utilizzato il valore advanced.
IOPS: le IOPS di cui eseguire il provisioning per il pool di archiviazione. Puoi utilizzare questo flag solo con i pool di archiviazione Hyperdisk Balanced.
THROUGHPUT: il throughput in MBps di cui eseguire il provisioning per il pool di archiviazione.
DESCRIPTION: facoltativo, una stringa di testo che descrive il pool di archiviazione.

REST

Crea una richiesta POST per creare un pool di archiviazione Hyperdisk utilizzando il metodo storagePools.insert.

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

{
    "name": "NAME",
    "description": "DESCRIPTION",
    "poolProvisionedCapacityGb": "POOL_CAPACITY",
    "storagePoolType": "projects/PROJECT_ID/zones/ZONE/storagePoolTypes/STORAGE_POOL_TYPE",
    "poolProvisionedIops": "IOPS",
    "poolProvisionedThroughput": "THROUGHPUT",
    "capacityProvisioningType": "CAPACITY_TYPE",
    "performanceProvisioningType": "PERFORMANCE_TYPE"
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto
ZONE: la zona in cui creare il pool di archiviazione, ad esempio us-central1-a.
NAME: un nome univoco per il pool di archiviazione .
DESCRIPTION: facoltativo, una stringa di testo che descrive il pool di archiviazione.
POOL_CAPACITY: la capacità totale di cui eseguire il provisioning per il nuovo pool di archiviazione, specificata in GiB per impostazione predefinita.
STORAGE_POOL_TYPE: il tipo di disco da archiviare nel pool di archiviazione. I valori consentiti sono hyperdisk-throughput e hyperdisk-balanced.
IOPS: facoltativo: le IOPS di cui eseguire il provisioning per il pool di archiviazione. Puoi utilizzare questo flag solo con i pool di archiviazione Hyperdisk Balanced.
THROUGHPUT: (Facoltativo) il throughput in MBps di cui eseguire il provisioning per il pool di archiviazione.
CAPACITY_TYPE: facoltativo, il tipo di provisioning della capacità del pool di archiviazione. I valori consentiti sono advanced e standard. Se non specificato, viene utilizzato il valore advanced.
PERFORMANCE_TYPE: facoltativo, il tipo di provisioning per le prestazioni del pool di archiviazione. I valori consentiti sono advanced e standard. Se non specificato, viene utilizzato il valore advanced.

Vai


// createHyperdiskStoragePool creates a new Hyperdisk storage pool in the specified project and zone.
func createHyperdiskStoragePool(w io.Writer, projectId, zone, storagePoolName, storagePoolType string) error {
	// projectID := "your_project_id"
	// zone := "europe-west4-b"
	// storagePoolName := "your_storage_pool_name"
	// storagePoolType := "projects/**your_project_id**/zones/europe-west4-b/diskTypes/hyperdisk-balanced"

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

	// Create the storage pool resource
	resource := &computepb.StoragePool{
		Name:                        proto.String(storagePoolName),
		Zone:                        proto.String(zone),
		StoragePoolType:             proto.String(storagePoolType),
		CapacityProvisioningType:    proto.String("advanced"),
		PerformanceProvisioningType: proto.String("advanced"),
		PoolProvisionedCapacityGb:   proto.Int64(10240),
		PoolProvisionedIops:         proto.Int64(10000),
		PoolProvisionedThroughput:   proto.Int64(1024),
	}

	// Create the insert storage pool request
	req := &computepb.InsertStoragePoolRequest{
		Project:             projectId,
		Zone:                zone,
		StoragePoolResource: resource,
	}

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

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

	// Retrieve and return the created storage pool
	storagePool, err := client.Get(ctx, &computepb.GetStoragePoolRequest{
		Project:     projectId,
		Zone:        zone,
		StoragePool: storagePoolName,
	})
	if err != nil {
		return fmt.Errorf("Get storage pool request failed: %v", err)
	}

	fmt.Fprintf(w, "Hyperdisk Storage Pool created: %v\n", storagePool.GetName())
	return nil
}

Java

import com.google.cloud.compute.v1.InsertStoragePoolRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.StoragePool;
import com.google.cloud.compute.v1.StoragePoolsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateHyperdiskStoragePool {
  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 storagePool.
    String zone = "us-central1-a";
    // Name of the storagePool you want to create.
    String storagePoolName = "YOUR_STORAGE_POOL_NAME";
    // The type of disk you want to create.
    // Storage types can be "hyperdisk-throughput" or "hyperdisk-balanced"
    String storagePoolType = String.format(
        "projects/%s/zones/%s/storagePoolTypes/hyperdisk-balanced", projectId, zone);
    // Optional: the capacity provisioning type of the storage pool.
    // The allowed values are advanced and standard. If not specified, the value advanced is used.
    String capacityProvisioningType = "advanced";
    // The total capacity to provision for the new storage pool, specified in GiB by default.
    long provisionedCapacity = 128;
    // the IOPS to provision for the storage pool.
    // You can use this flag only with Hyperdisk Balanced Storage Pools.
    long provisionedIops = 3000;
    // the throughput in MBps to provision for the storage pool.
    long provisionedThroughput = 140;
    // The allowed values are low-casing strings "advanced" and "standard".
    // If not specified, "advanced" is used.
    String performanceProvisioningType = "advanced";

    createHyperdiskStoragePool(projectId, zone, storagePoolName, storagePoolType,
            capacityProvisioningType, provisionedCapacity, provisionedIops,
        provisionedThroughput, performanceProvisioningType);
  }

  // Creates a hyperdisk storagePool in a project
  public static StoragePool createHyperdiskStoragePool(String projectId, String zone,
        String storagePoolName, String storagePoolType, String capacityProvisioningType,
        long capacity, long iops, long throughput, String performanceProvisioningType)
          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 (StoragePoolsClient client = StoragePoolsClient.create()) {
      // Create a storagePool.
      StoragePool resource = StoragePool.newBuilder()
              .setZone(zone)
              .setName(storagePoolName)
              .setStoragePoolType(storagePoolType)
              .setCapacityProvisioningType(capacityProvisioningType)
              .setPoolProvisionedCapacityGb(capacity)
              .setPoolProvisionedIops(iops)
              .setPoolProvisionedThroughput(throughput)
              .setPerformanceProvisioningType(performanceProvisioningType)
              .build();

      InsertStoragePoolRequest request = InsertStoragePoolRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setStoragePoolResource(resource)
              .build();

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

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

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

      StoragePool storagePool = client.get(projectId, zone, storagePoolName);

      System.out.printf("Storage pool '%s' has been created successfully", storagePool.getName());

      return storagePool;
    }
  }
}

Node.js

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

// Instantiate a storagePoolClient
const storagePoolClient = new computeLib.StoragePoolsClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await storagePoolClient.getProjectId();
// Name of the zone in which you want to create the storagePool.
const zone = 'us-central1-a';
// Name of the storagePool you want to create.
// storagePoolName = 'storage-pool-name';
// The type of disk you want to create. This value uses the following format:
// "projects/{projectId}/zones/{zone}/storagePoolTypes/(hyperdisk-throughput|hyperdisk-balanced)"
const storagePoolType = `projects/${projectId}/zones/${zone}/storagePoolTypes/hyperdisk-balanced`;
// Optional: The capacity provisioning type of the storage pool.
// The allowed values are advanced and standard. If not specified, the value advanced is used.
const capacityProvisioningType = 'advanced';
// The total capacity to provision for the new storage pool, specified in GiB by default.
const provisionedCapacity = 10240;
// The IOPS to provision for the storage pool.
// You can use this flag only with Hyperdisk Balanced Storage Pools.
const provisionedIops = 10000;
// The throughput in MBps to provision for the storage pool.
const provisionedThroughput = 1024;
// Optional: The performance provisioning type of the storage pool.
// The allowed values are advanced and standard. If not specified, the value advanced is used.
const performanceProvisioningType = 'advanced';

async function callCreateComputeHyperdiskPool() {
  // Create a storagePool.
  const storagePool = new compute.StoragePool({
    name: storagePoolName,
    poolProvisionedCapacityGb: provisionedCapacity,
    poolProvisionedIops: provisionedIops,
    poolProvisionedThroughput: provisionedThroughput,
    storagePoolType,
    performanceProvisioningType,
    capacityProvisioningType,
    zone,
  });

  const [response] = await storagePoolClient.insert({
    project: projectId,
    storagePoolResource: storagePool,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Storage pool: ${storagePoolName} created.`);
}

await callCreateComputeHyperdiskPool();

Crea un Exapool Hyperdisk

Gli Exapool Hyperdisk sono disponibili a livello generale con una lista consentita. Per creare un exapool Hyperdisk, contatta il team dedicato all'account.

Crea un pool Hyperdisk Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Console

gcloud

Go

Java

Node.js

REST

Ruoli e autorizzazioni richiesti

Autorizzazioni obbligatorie

Limitazioni

Intervalli di capacità e limiti di prestazioni di cui è stato eseguito il provisioning

Crea un pool di archiviazione Hyperdisk

Console

gcloud

REST

Vai

Java

Node.js

Crea un Exapool Hyperdisk

Passaggi successivi

Crea un pool Hyperdisk