Créer des pools de stockage Hyperdisk

Les pools de stockage Hyperdisk sont une nouvelle ressource de stockage de blocs ; ils vous aident à gérer votre stockage de blocs Hyperdisk dans son ensemble. Les pools de stockage Hyperdisk sont déclinés en deux variantes : les pools de stockage "Hyperdisk Throughput" et les pools de stockage "Hyperdisk équilibré".

Lorsque vous créez un pool de stockage, vous devez spécifier les propriétés suivantes :

Zone
Type de pool de stockage
Type de provisionnement de capacité
Capacité provisionnée pour le pool
Type de provisionnement des performances
IOPS et débit provisionnés pour le pool

Vous pouvez utiliser les types de provisionnement de capacité Standard, de capacité Advanced, de performances Standard ou de performances Advanced avec les pools de stockage Hyperdisk :

Capacité Standard : la capacité provisionnée pour chaque disque créé dans le pool de stockage est déduite de la capacité provisionnée totale du pool de stockage.
Capacité Advanced : le pool de stockage bénéficie de l'allocation dynamique de capacité et de la réduction des données. Seule la quantité de données effectivement écrites est déduite de la capacité provisionnée totale du pool de stockage.
Performances Standard : les performances provisionnées pour chaque disque créé dans le pool de stockage sont déduites des performances provisionnées totales du pool de stockage.

Performances Advanced : les performances provisionnées pour chaque disque bénéficient de l'allocation dynamique de capacité. Seule la quantité de performances utilisée par un disque est déduite des performances provisionnées totales du pool de stockage.

Avant de commencer

Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine comme suit :

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Rôles et autorisations requis

Pour obtenir les autorisations nécessaires pour créer un pool de stockage, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Administrateur d'instances Compute (v1) (roles/compute.instanceAdmin.v1)
Pour se connecter à une instance de VM pouvant être exécutée en tant que compte de service : Utilisateur du compte de service (v1) (rôle roles/iam.serviceAccountUser)

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer un pool de stockage. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer un pool de stockage :

compute.storagePools.create sur le projet
compute.storagePools.setLabels sur le projet

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Limites

Tenez compte des limites suivantes lorsque vous créez des pools de stockage Hyperdisk :

Limites de ressources :

Vous pouvez créer un pool de stockage Hyperdisk avec jusqu'à 1 Pio de capacité provisionnée.
Vous pouvez créer jusqu'à cinq pools de stockage par heure.
Vous pouvez créer jusqu'à 10 pools de stockage par jour.
Vous pouvez créer au maximum 10 pools de stockage par projet.
Vous ne pouvez pas modifier le modèle de provisionnement d'un pool, ni modifier un pool de stockage de capacité Standard en un pool de stockage de capacité Advanced, ni un pool de stockage de performances Advanced en un pool de stockage de performances Standard.
Les pools de stockage sont des ressources zonales.
Vous pouvez créer jusqu'à 1 000 disques dans un pool de stockage.
Les pools de stockage Hyperdisk ne sont utilisables qu'avec Compute Engine. Les instances Cloud SQL ne peuvent pas utiliser de pools de stockage Hyperdisk.
Vous pouvez modifier la performance ou la capacité provisionnée d'un pool de stockage au maximum deux fois au cours d'une période de 24 heures.

Limites applicables aux disques d'un pool de stockage :

Les disques créés dans un pool de stockage doivent se trouver dans le même projet et dans la même zone.
Il n'est pas possible de déplacer des disques dans ou hors d'un pool de stockage. Pour déplacer un disque dans un pool de stockage ou en dehors, vous devez le recréer à partir d'un instantané. Pour en savoir plus, consultez la page Modifier le type de disque.
Pour créer des disques de démarrage dans un pool de stockage, vous devez utiliser un pool de stockage "Hyperdisk équilibré".
Les pools de stockage ne sont pas compatibles avec les disques régionaux.
Vous ne pouvez pas cloner de disques, en créer des instantanés immédiats ni en configurer la réplication asynchrone sur disque persistant dans un pool de stockage.
Les disques Hyperdisk Balanced d'un pool de stockage ne peuvent pas être associés à plusieurs instances de calcul.

Plages de capacité et limites de performances provisionnées

Lorsque vous créez un pool de stockage, la capacité, les IOPS et le débit provisionnés sont soumis aux limites décrites dans la section Limites pour les pools de stockage.

Créer un pool de stockage Hyperdisk

Pour créer un pool de stockage Hyperdisk, vous pouvez utiliser la console Google Cloud, la Google Cloud CLI ou l'API REST.

Console

Accédez à la page Créer un pool de stockage dans la console Google Cloud.
Accéder à la page "Créer un pool de stockage"
Dans le champ Nom, saisissez un nom unique pour le pool de stockage.
Facultatif : Dans le champ Description, saisissez une description du pool de stockage.
Sélectionnez la région et la zone dans lesquelles créer le pool de stockage.
Renseignez une valeur pour le champ Type de pool de stockage.
Choisissez un type de provisionnement dans le champ Type de capacité et spécifiez la capacité à provisionner pour le pool de stockage dans le champ Capacité du pool de stockage. Vous pouvez spécifier une taille comprise entre 10 Tio et 1 Pio.

Pour créer un pool de stockage de grande capacité, vous devrez peut-être demander un quota plus élevé.
Sélectionnez un type de provisionnement dans le champ Type de performances.
Pour les pools de stockage "Hyperdisk équilibré", dans le champ IOPS provisionnées, saisissez les IOPS à provisionner pour le pool de stockage.
Pour un pool de stockage "Hyperdisk Throughput" ou un pool de stockage "Hyperdisk équilibré", dans le champ Débit provisionné, saisissez le débit à provisionner pour le pool de stockage.
Cliquez sur Envoyer pour créer le pool de stockage.

gcloud

Pour créer un pool de stockage Hyperdisk, utilisez la commande 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

Remplacez les éléments suivants :

NAME : nom unique du pool de stockage.
ZONE : zone dans laquelle créer le pool de stockage, par exemple us-central1-a.
STORAGE_POOL_TYPE : type de disque dédié au stockage dans le pool de stockage. Les valeurs autorisées sont hyperdisk-throughput et hyperdisk-balanced.
CAPACITY_TYPE : (facultatif) type de provisionnement de capacité pour le pool de stockage. Les valeurs autorisées sont advanced et standard. Si cette option n'est pas spécifiée, la valeur advanced est utilisée.
POOL_CAPACITY : capacité totale à provisionner pour le nouveau pool de stockage, spécifiée par défaut en Gio.
PERFORMANCE_TYPE : (facultatif) type de provisionnement des performances du pool de stockage. Les valeurs autorisées sont advanced et standard. Si cette option n'est pas spécifiée, la valeur advanced est utilisée.
IOPS : IOPS à provisionner pour le pool de stockage. Vous ne pouvez utiliser cette option qu'avec des pools de stockage "Hyperdisk équilibré".
THROUGHPUT : débit en Mbit/s à provisionner pour le pool de stockage.
DESCRIPTION : (facultatif) chaîne de texte décrivant le pool de stockage.

REST

Envoyez une requête POST pour créer un pool de stockage Hyperdisk à l'aide de la méthode 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"
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet
ZONE : zone dans laquelle créer le pool de stockage, par exemple us-central1-a.
NAME : nom unique du pool de stockage.
DESCRIPTION : (facultatif) chaîne de texte décrivant le pool de stockage.
POOL_CAPACITY : capacité totale à provisionner pour le nouveau pool de stockage, spécifiée par défaut en Gio.
STORAGE_POOL_TYPE : type de disque dédié au stockage dans le pool de stockage. Les valeurs autorisées sont hyperdisk-throughput et hyperdisk-balanced.
IOPS : (facultatif) IOPS à provisionner pour le pool de stockage. Vous ne pouvez utiliser cette option qu'avec des pools de stockage "Hyperdisk équilibré".
THROUGHPUT : (facultatif) débit en Mbit/s à provisionner pour le pool de stockage.
CAPACITY_TYPE : (facultatif) type de provisionnement de capacité pour le pool de stockage. Les valeurs autorisées sont advanced et standard. Si cette option n'est pas spécifiée, la valeur advanced est utilisée.
PERFORMANCE_TYPE : (facultatif) type de provisionnement des performances du pool de stockage. Les valeurs autorisées sont advanced et standard. Si cette option n'est pas spécifiée, la valeur advanced est utilisée.

Go


// 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 = "europe-central2-b";
    // Name of the storagePool you want to create.
    String storagePoolName = "YOUR_STORAGE_POOL_NAME";
    // The type of disk you want to create. This value uses the following format:
    // "projects/%s/zones/%s/storagePoolTypes/hyperdisk-throughput|hyperdisk-balanced"
    String storagePoolType = "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.
    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;

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

  // 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)
          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)
              .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 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.
const 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;

async function callCreateComputeHyperdiskPool() {
  // Create a storagePool.
  const storagePool = new compute.StoragePool({
    name: storagePoolName,
    poolProvisionedCapacityGb: provisionedCapacity,
    poolProvisionedIops: provisionedIops,
    poolProvisionedThroughput: provisionedThroughput,
    storagePoolType,
    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(),
    });
  }

  const createdStoragePool = (
    await storagePoolClient.get({
      project: projectId,
      zone,
      storagePool: storagePoolName,
    })
  )[0];

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

await callCreateComputeHyperdiskPool();

Étape suivante

Découvrez comment gérer les pools de stockage Hyperdisk.