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 selecionando uma das seguintes opções:

      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
      2. Set a default region and zone.
      3. Go

        Para usar os exemplos Go desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

        1. Install the Google Cloud CLI.
        2. To initialize the gcloud CLI, run the following command:

          gcloud init
        3. If you're using a local shell, then create local authentication credentials for your user account:

          gcloud auth application-default login

          You don't need to do this if you're using Cloud Shell.

        Confira mais informações em Set up authentication for a local development environment.

        Java

        Para usar os exemplos Java desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

        1. Install the Google Cloud CLI.
        2. To initialize the gcloud CLI, run the following command:

          gcloud init
        3. If you're using a local shell, then create local authentication credentials for your user account:

          gcloud auth application-default login

          You don't need to do this if you're using Cloud Shell.

        Confira mais informações em Set up authentication for a local development environment.

        Node.js

        Para usar os exemplos Node.js desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

        1. Install the Google Cloud CLI.
        2. To initialize the gcloud CLI, run the following command:

          gcloud init
        3. If you're using a local shell, then create local authentication credentials for your user account:

          gcloud auth application-default login

          You don't need to do this if you're using Cloud Shell.

        Confira mais informações em Set up authentication for a local development environment.

        REST

        Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

          Install the Google Cloud CLI, then initialize it by running the following command:

          gcloud init

        Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

    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

    1. Acesse a página Criar um pool de armazenamento no console do Google Cloud.
      Acessar a página Criar pool de armazenamento
    2. No campo Nome, digite um nome exclusivo para o pool de armazenamento.
    3. Opcional: no campo Descrição, insira uma descrição para o pool de armazenamento.
    4. Selecione a Região e a Zona em que o pool de armazenamento será criado.
    5. Escolha um valor para o Tipo de pool de armazenamento.
    6. 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.

    7. Escolha um tipo de provisionamento no campo Tipo de desempenho.

    8. Para pools de armazenamento equilibrado por hiperdisco, no campo IOPS provisionadas, insira o IOPS a ser provisionado para o pool de armazenamento.

    9. 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.

    10. 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 = "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();

    A seguir