Hyperdisk Storage Pools erstellen

Hyperdisk Storage Pools sind eine neue Blockspeicherressource, mit der Sie Ihren Hyperdisk Storage Pools insgesamt verwalten können. Hyperdisk Storage Pools sind in den Varianten von Hyperdisk Throughput Storage Pool und Hyperdisk Balanced Storage Pool verfügbar.

Beim Erstellen eines Speicherpools müssen Sie die folgenden Attribute angeben:

Zone
Speicherpooltyp
Kapazitätsbereitstellungstyp
Bereitgestellte Poolkapazität
Leistungsbereitstellungstyp
Vom Pool bereitgestellte IOPS und Durchsatz

Sie können die Bereitstellungstypen „Standardkapazität“, „Erweiterte Kapazität“, „Standardleistung“ oder „Erweiterte Leistung“ mit Hyperdisk Storage Pools verwenden:

Standardkapazität: Die bereitgestellte Kapazität für jedes im Speicherpool erstellte Laufwerk wird von der bereitgestellten Gesamtkapazität des Speicherpools abgezogen.
Erweiterte Kapazität: Der Speicherpool profitiert von einer schlanken Bereitstellung und Datenreduzierung. Nur die Menge der tatsächlich geschriebenen Daten wird von der bereitgestellten Gesamtkapazität des Speicherpools abgezogen.
Standardleistung: Die für jedes im Speicherpool erstellte Laufwerk bereitgestellte Leistung wird von der insgesamt bereitgestellten Leistung des Speicherpools abgezogen.

Erweiterte Leistung: Die Leistung für jedes Laufwerk profitiert von einer schlanken Bereitstellung. Nur die Leistung eines Laufwerks wird von der bereitgestellten Gesamtleistung des Speicherpools abgezogen.

Hinweise

Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich so bei Compute Engine authentifizieren.

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.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen eines Speicherpool benötigen:

Compute-Instanzadministrator (Version 1) (roles/compute.instanceAdmin.v1)
Verbindung zu einer VM-Instanz herstellen, die als Dienstkonto ausgeführt werden kann: Dienstkontonutzer (v1) (roles/iam.serviceAccountUser-Rolle)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Erstellen eines Speicherpools erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Erstellen eines Speicherpools erforderlich:

compute.storagePools.create für das Projekt
compute.storagePools.setLabels für das Projekt

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Beschränkungen

Beachten Sie beim Erstellen von Hyperdisk Storage Pools die folgenden Einschränkungen:

Ressourcenlimits:

Sie können einen Hyperdisk Storage Pool mit bis zu 1 PiB an bereitgestellter Kapazität erstellen.
Sie können maximal 5 Speicherpools pro Stunde erstellen.
Sie können maximal 10 Speicherpools pro Tag erstellen.
Sie können maximal 10 Speicherpools pro Projekt erstellen.
Sie können das Bereitstellungsmodell für einen Pool nicht ändern. Sie können einen Speicherpool mit Standardkapazität nicht in einen Speicherpool mit erweiterter Kapazität oder einen Speicherpool mit erweiterter Leistung nicht in einen Speicherpool mit Standardleistung ändern.
Speicherpools sind eine zonale Ressource.
Sie können bis zu 1.000 Laufwerke in einem Speicherpool erstellen.
Sie können Hyperdisk Storage Pools nur mit Compute Engine verwenden. Cloud SQL-Instanzen können keine Hyperdisk Storage Pools verwenden.
Sie können die bereitgestellte Kapazität oder Leistung eines Speicherpools innerhalb von 24 Stunden höchstens zweimal ändern.

Limits für Laufwerke in einem Speicherpool:

In einem Speicherpool können nur neue Laufwerke im selben Projekt und in derselben Zone erstellt werden.
Das Verschieben von Laufwerken in einen oder aus einem Speicherpool ist nicht zulässig. Wenn Sie ein Laufwerk in einen oder aus einem Speicherpool verschieben möchten, müssen Sie das Laufwerk aus einem Snapshot neu erstellen. Weitere Informationen finden Sie unter Laufwerkstyp ändern.
Wenn Sie Bootlaufwerke in einem Speicherpool erstellen möchten, müssen Sie einen Hyperdisk Balanced Storage Pool verwenden.
Speicherpools unterstützen keine regionalen Laufwerke.
Folgendes ist nicht möglich für Laufwerke in einem Speicherpool: Klonen ,Instant Snapshots erstellen oderAsynchrone Replikation für Persistent Disk konfigurieren.
Mit Hyperdisk abgestimmt-Laufwerke in einem Speicherpool können nicht an mehrere Compute-Instanzen angehängt werden.

Kapazitätsbereiche und bereitgestellte Leistungsgrenzen

Beim Erstellen eines Speicherpools unterliegen die bereitgestellte Kapazität, die IOPS und der Durchsatz den Limits, die unter Limits für Speicherpools beschrieben sind.

Hyperdisk Storage Pool erstellen

Verwenden Sie zum Erstellen eines neuen Hyperdisk Storage Pools die Google Cloud Console, die Google Cloud CLI oder REST.

Console

Rufen Sie in der Google Cloud Console die Seite Speicherpool erstellen auf.
Seite "Storage Pool erstellen" aufrufen
Geben Sie im Feld Name einen eindeutigen Namen für den Speicherpool ein.
Optional: Geben Sie im Feld Beschreibung eine Beschreibung für den Speicherpool ein.
Wählen Sie die Region und die Zone aus, in der der Speicherpool erstellt werden soll.
Wählen Sie einen Wert für den Storage Pool-Typ aus.
Wählen Sie im Feld Kapazitätstyp einen Bereitstellungstyp aus und geben Sie im Feld Speicherpoolkapazität die Kapazität an, die für den Speicherpool bereitgestellt werden soll. Sie können eine Größe von 10 TiB bis 1 PiB angeben.

Zum Erstellen eines Speicherpools mit großer Kapazität müssen Sie möglicherweise ein höheres Kontingent anfordern.
Wählen Sie im Feld Leistungstyp einen Bereitstellungstyp aus.
Geben Sie bei Hyperdisk Balanced Storage Pools im Feld Bereitgestellte IOPS die IOPS ein, die für den Speicherpool bereitgestellt werden sollen.
Geben Sie für einen Hyperdisk Throughput Storage Pool oder einen Hyperdisk Balanced Storage Pool im Feld Bereitgestellter Durchsatz den Durchsatz ein, der für den Speicherpool bereitgestellt werden soll.
Klicken Sie auf Senden, um den Speicherpool zu erstellen.

gcloud

Verwenden Sie zum Erstellen eines Hyperdisk Storage Pools den Befehl 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

Ersetzen Sie Folgendes:

NAME: der eindeutige Name des Speicherpools.
ZONE: die Zone, in der der Speicherpool erstellt werden soll, z. B. us-central1-a
STORAGE_POOL_TYPE: der Typ des Laufwerks, das im Speicherpool gespeichert werden soll. Die zulässigen Werte sind hyperdisk-throughput und hyperdisk-balanced.
CAPACITY_TYPE: Optional: der Typ der Kapazitätsbereitstellung des Speicherpools. Die zulässigen Werte sind advanced, standard und . Wenn keine Angabe erfolgt, wird der Wert advanced verwendet.
POOL_CAPACITY: die Gesamtkapazität, die für den neuen Speicherpool bereitgestellt werden soll, standardmäßig in GiB angegeben.
PERFORMANCE_TYPE: Optional: der Typ der Leistungsbereitstellung des Speicherpools. Die zulässigen Werte sind advanced, standard und . Wenn keine Angabe erfolgt, wird der Wert advanced verwendet.
IOPS: die IOPS, die für den Speicherpool bereitgestellt werden sollen. Sie können dieses Flag nur mit Hyperdisk Balanced Storage Pools verwenden.
THROUGHPUT: der Durchsatz in MB/s, der für den Speicherpool bereitgestellt werden soll.
DESCRIPTION: Optional: ein Textstring, der den Speicherpool beschreibt.

REST

Erstellen Sie eine POST-Anfrage, um einen Hyperdisk Storage Pool mit der Methode storagePools.insert zu erstellen.

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

Ersetzen Sie Folgendes:

PROJECT_ID: die Projekt-ID
ZONE: die Zone, in der der Speicherpool erstellt werden soll, z. B. us-central1-a
NAME: ein eindeutiger Name für den Speicherpool.
DESCRIPTION: Optional: ein Textstring, der den Speicherpool beschreibt.
POOL_CAPACITY: die Gesamtkapazität, die für den neuen Speicherpool bereitgestellt werden soll, standardmäßig in GiB angegeben.
STORAGE_POOL_TYPE: der Typ des Laufwerks, das im Speicherpool gespeichert werden soll. Die zulässigen Werte sind hyperdisk-throughput und hyperdisk-balanced.
IOPS: Optional: die IOPS, die für den Speicherpool bereitgestellt werden sollen. Sie können dieses Flag nur mit Hyperdisk Balanced Storage Pools verwenden.
THROUGHPUT: Optional: Der Durchsatz in MB/s, der für den Speicherpool bereitgestellt werden soll.
CAPACITY_TYPE: Optional: der Typ der Kapazitätsbereitstellung des Speicherpools. Die zulässigen Werte sind advanced, standard und . Wenn keine Angabe erfolgt, wird der Wert advanced verwendet.
PERFORMANCE_TYPE: Optional: der Typ der Leistungsbereitstellung des Speicherpools. Die zulässigen Werte sind advanced, standard und . Wenn keine Angabe erfolgt, wird der Wert advanced verwendet.

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();

Nächste Schritte

Hyperdisk Storage Pools verwalten