Criar pools de armazenamento de hiperdisco

Os pools de armazenamento de hiperdisco são um novo recurso de armazenamento em blocos que ajuda a gerenciar o armazenamento em blocos de hiperdisco de maneira agregada. Os pools de armazenamento de hiperdisco estão disponíveis nas variantes de pool de armazenamento de capacidade de processamento e de pool de armazenamento balanceado por hiperdisco.

Especifique as seguintes propriedades ao criar um pool de armazenamento:

Zona
Tipo do pool de armazenamento
Tipo de provisionamento de capacidade
Capacidade provisionada do pool
Tipo de provisionamento de desempenho
IOPS e capacidade de processamento provisionadas do pool

Você pode usar a capacidade padrão, a capacidade avançada, o desempenho padrão ou os tipos de provisionamento de desempenho avançado com pools de armazenamento de hiperdisco:

Capacidade padrão: a capacidade provisionada para cada disco criado no pool de armazenamento é deduzido da capacidade provisionada total do pool de armazenamento.
Capacidade avançada: o pool de armazenamento se beneficia do provisionamento fino e da redução de dados. Apenas a quantidade de dados gravados reais é deduzida da capacidade provisionada total do pool de armazenamento.
Desempenho padrão: o desempenho provisionado para cada disco criado no pool de armazenamento é deduzido do desempenho total provisionado do pool de armazenamento.

Desempenho avançado: o desempenho provisionado para cada disco se beneficia do provisionamento fino. Somente a quantidade de desempenho usada por um disco é deduzida do desempenho provisionado total do pool de armazenamento.

Antes de começar

Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine da seguinte maneira.

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.

Papéis e permissões necessárias

Para receber as permissões necessárias para criar uma programação de snapshot, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Administrador da instância da computação (v1) (roles/compute.instanceAdmin.v1)
Para se conectar a uma instância de VM que possa ser executada como uma conta de serviço: Usuário da conta de serviço (v1) (papel roles/iam.serviceAccountUser )

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para criar um pool de armazenamento. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar um pool de armazenamento:

compute.storagePools.create no projeto
compute.storagePools.setLabels no projeto

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Limitações

Observe as seguintes limitações ao criar pools de armazenamento de hiperdisco:

Limites de recursos:

É possível criar um pool de armazenamento de hiperdisco com até 1 PiB de capacidade provisionada.
É possível criar até cinco pools de armazenamento por hora.
É possível criar até 10 pools de armazenamento por dia.
É possível criar no máximo 10 pools de armazenamento por projeto.
Não é possível alterar o modelo de provisionamento de um pool. Não é possível mudar um pool de armazenamento de capacidade padrão para um de desempenho avançado ou um de desempenho avançado para um de desempenho padrão.
Os pools de armazenamento são um recurso zonal.
É possível criar até 1.000 discos em um pool de armazenamento.
É possível usar pools de armazenamento de hiperdisco apenas com o Compute Engine. As instâncias do Cloud SQL não podem usar pools de armazenamento de hiperdisco.
É possível alterar a capacidade ou desempenho provisionado de um pool de armazenamento no máximo duas vezes em 24 horas.

Limites de discos em um pool de armazenamento:

Somente novos discos no mesmo projeto e zona podem ser criados em um pool de armazenamento.
Não é permitido mover discos para dentro ou fora de um pool de armazenamento. Para mover um disco para dentro ou fora de um pool de armazenamento, é necessário recriar o disco com base em um snapshot. Para mais informações, consulte Alterar o tipo de disco.
Para criar discos de inicialização em um pool de armazenamento, use um pool de armazenamento balanceado por hiperdisco.
Os pools de armazenamento não oferecem suporte a discos regionais.
Não é possível clonar, criar Instant Snapshots ou configurar a replicação assíncrona do Persistent Disk para discos em um pool de armazenamento.
Os discos Hyperdisk equilibrados em um pool de armazenamento não podem ser anexados a várias instâncias de computação.

Intervalos de capacidade e limites de desempenho provisionados

Ao criar um pool de armazenamento, a capacidade provisionada, IOPS e a capacidade de processamento estão sujeitas aos limites descritos em Limites para pools de armazenamento.

Criar um pool de armazenamento de hiperdisco

Para criar um novo pool de armazenamento de hiperdisco, use o console do Google Cloud, a Google Cloud CLI ou a REST.

Console

Acesse a página Criar um pool de armazenamento no console do Google Cloud.
Acessar a página Criar pool de armazenamento
No campo Nome, digite um nome exclusivo para o pool de armazenamento.
Opcional: no campo Descrição, insira uma descrição para o pool de armazenamento.
Selecione a Região e a Zona em que o pool de armazenamento será criado.
Escolha um valor para o Tipo de pool de armazenamento.
Escolha um tipo de provisionamento no campo Tipo de capacidade e especifique a capacidade a ser provisionada para o pool de armazenamento no campo Capacidade do pool de armazenamento. O tamanho pode ser de 10 TiB a 1 PiB.

Para criar um pool de armazenamento com grande capacidade, talvez seja necessário solicitar uma cota maior.
Escolha um tipo de provisionamento no campo Tipo de desempenho.
Para pools de armazenamento equilibrado por hiperdisco, no campo IOPS provisionadas, insira o IOPS a ser provisionado para o pool de armazenamento.
Para um pool de armazenamento de capacidade de processamento de hiperdisco ou um pool de armazenamento equilibrado de hiperdisco, no campo Capacidade provisionada, insira a capacidade a ser provisionada para o pool de armazenamento.
Clique em Enviar para criar o pool de armazenamento.

gcloud

Para criar um pool de armazenamento de hiperdisco, use o 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

Substitua:

NAME: o nome do pool de armazenamento exclusivo.
ZONE: a zona em que o pool de armazenamento será criado, por exemplo, us-central1-a.
STORAGE_POOL_TYPE: o tipo de disco a ser armazenado no pool de armazenamento. Os valores permitidos são hyperdisk-throughput e hyperdisk-balanced.
CAPACITY_TYPE (opcional): o tipo de provisionamento de capacidade do pool de armazenamento. Os valores permitidos são advanced e standard. Se não for especificado, o valor advanced será usado.
POOL_CAPACITY: a capacidade total a provisionar para o novo pool de armazenamento, especificada em GiB por padrão.
PERFORMANCE_TYPE (opcional): o tipo de provisionamento de desempenho do pool de armazenamento. Os valores permitidos são advanced e standard. Se não for especificado, o valor advanced será usado.
IOPS: as IOPS a serem provisionadas para o pool de armazenamento. Só é possível usar essa sinalização com pools de armazenamento equilibrados de hiperdisco.
THROUGHPUT: a capacidade em MBps a ser provisionada para o pool de armazenamento.
DESCRIPTION (opcional): uma string de texto que descreve o pool de armazenamento.

REST

Construa uma solicitação POST para criar um pool de armazenamento de hiperdisco usando o método 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"
}

Substitua:

PROJECT_ID: o ID do projeto
ZONE: a zona em que o pool de armazenamento será criado, por exemplo, us-central1-a.
NAME: um nome exclusivo para o pool de armazenamento .
DESCRIPTION (opcional): uma string de texto que descreve o pool de armazenamento.
POOL_CAPACITY: a capacidade total a provisionar para o novo pool de armazenamento, especificada em GiB por padrão.
STORAGE_POOL_TYPE: o tipo de disco a ser armazenado no pool de armazenamento. Os valores permitidos são hyperdisk-throughput e hyperdisk-balanced.
IOPS: opcional: as IOPS a serem provisionadas para o pool de armazenamento. Só é possível usar essa sinalização com pools de armazenamento equilibrados de hiperdisco.
THROUGHPUT: opcional: a capacidade em MBps a ser provisionada para o pool de armazenamento.
CAPACITY_TYPE (opcional): o tipo de provisionamento de capacidade do pool de armazenamento. Os valores permitidos são advanced e standard. Se não for especificado, o valor advanced será usado.
PERFORMANCE_TYPE (opcional): o tipo de provisionamento de desempenho do pool de armazenamento. Os valores permitidos são advanced e standard. Se não for especificado, o valor advanced será usado.

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

A seguir

Saiba como gerenciar pools de armazenamento de hiperdisco.