Criar um novo volume do Hyperdisk

É possível usar um volume do Hyperdisk Balanced, Hyperdisk Extreme ou Hyperdisk Throughput com sua instância do Compute Engine concluindo as seguintes tarefas:

  • Crie um volume do Hyperdisk em branco, que não seja de inicialização e zonal e o anexe à instância durante ou após a criação dela.
  • Formate e ative o volume para fornecer acesso a um sistema de dados ou arquivos.

Para volumes Hyperdisk Balanced, também é possível criar discos de inicialização e de dados.

Para informações gerais sobre o Hyperdisk, consulte Sobre o Hyperdisk.

Para adicionar um disco Hyperdisk Balanced High Availability à sua instância, use os procedimentos a seguir:

Antes de começar

Papéis e permissões necessárias

Para ter as permissões necessárias para adicionar um volume do Hyperdisk à sua instância, peça ao administrador para conceder a você os papéis do IAM a seguir no projeto:

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 adicionar um volume do Hyperdisk à sua instância. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para adicionar um volume do Hyperdisk à instância:

  • Para criar e anexar um volume do Hyperdisk:
    • compute.disks.create no projeto
    • compute.instances.attachDisk na instância
    • compute.disks.use no volume que você quer anexar à instância
  • Para formatar e ativar o volume anexado: compute.instances.setMetadata na instância
  • Para criar o volume de um Instant Snapshot do disco de inicialização de uma instância que tem uma conta de serviço anexada: iam.serviceAccounts.actAs na conta de serviço da instância

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

Valores aceitos para volumes do Hyperdisk

Limites de tamanho

O tamanho especificado para um volume do Hyperdisk precisa estar dentro dos intervalos listados na tabela a seguir.

Tipo de Hyperdisk Tamanho mínimo Tamanho máximo Tamanho padrão
Hyperdisk Balanced 4 GiB 64 TiB 100 GiB
Hyperdisk Balanced High Availability 4 GiB 64 TiB 100 GiB
Hyperdisk Extreme 64 GiB 64 TiB 1 TiB
Hyperdisk ML 4 GiB 64 TiB 100 GiB
Hyperdisk Throughput 2 TiB 32 TiB 2 TiB

No entanto, o tamanho de um volume do Hyperdisk anexado a uma instância não pode exceder os limites do Hyperdisk da instância.

Limites de desempenho

A tabela a seguir lista os limites de desempenho que podem ser especificados para cada tipo de Hyperdisk. No entanto, os níveis de IOPS e capacidade de processamento que você pode especificar também dependem do tamanho do volume. Para um resumo detalhado de cada limite, consulte a seção Limites de tamanho e desempenho para Hyperdisk Balanced, Hyperdisk Balanced High Availability, Hyperdisk Extreme, Hyperdisk ML e Hyperdisk Throughput.

Tipo de Hyperdisk Limite de IOPS Limite de capacidade de processamento (MiB/s)
Hyperdisk Balanced 160.000 2.400
Hyperdisk Balanced High Availability 100.000 2.400
Hiperdisco extremo 350.000 Não é possível provisionar um nível de capacidade de processamento para volumes do Hyperdisk Extreme. Cada volume recebe 250 MiB/s de capacidade de processamento a cada 1.000 IOPS, até 5.000 MiB/s.
Hyperdisk ML Não é possível provisionar um nível de IOPS, mas cada MiB/s de capacidade de processamento provisionada vem com 16 IOPS, até 33.554.432 IOPS. 2.097.152
Capacidade de processamento do hiperdisco Não é possível provisionar um nível de IOPS, mas cada MiB/s de capacidade de processamento provisionada vem com 4 IOPS, até 9.600 IOPS. 2.400

Variáveis de tipo de Hyperdisk

A tabela a seguir lista os valores de referência de cada tipo de Hyperdisk. Ao criar um volume do Hyperdisk com a Google Cloud CLI, o REST ou as bibliotecas de cliente do Cloud para o Compute Engine, indique o tipo de Hyperdisk a ser criado fornecendo o valor correspondente da tabela.

Tipo de disco Nome da referência
Hiperdisco equilibrado hyperdisk-balanced
Hyperdisk Balanced High Availability hyperdisk-balanced-high-availability
Hiperdisco extremo hyperdisk-extreme
Capacidade de processamento do hiperdisco hyperdisk-throughput
Hyperdisk ML hyperdisk-ml

Adicionar um volume do Hyperdisk à instância

É possível criar e anexar um volume do Hyperdisk usando o console doGoogle Cloud , a Google Cloud CLI ou o REST.

O tamanho, a capacidade de processamento e as IOPS especificados ao criar um volume do Hyperdisk precisam estar no intervalo de valores aceitos.

Ao criar um volume do Hyperdisk Balanced, é possível permitir que várias instâncias acessem o disco simultaneamente criando-o no modo de vários gravadores.

Console

  1. Acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Clique no nome da instância em que quer adicionar um disco.

  3. Na página Detalhes da instância de VM, clique em editEditar.

  4. Na seção Armazenamento, em Discos adicionais, clique em Adicionar novo disco.

  5. Especifique um nome para o disco e, se quiser, uma descrição.

  6. Em Tipo de origem do disco, escolha a fonte de dados do disco:

    • Para criar um disco em branco, selecione Disco em branco.
    • Para criar o disco com base em uma imagem:
      1. Selecione Imagem.
      2. Em Imagem de origem, escolha a imagem de origem do disco.
    • Para criar o disco com base em um snapshot atual:
      1. Selecione Snapshot, Instant snapshot ou snapshot de arquivamento, dependendo se o snapshot de origem é um snapshot padrão, um instant snapshot ou um snapshot de arquivamento, respectivamente.
      2. Em Snapshot de origem, selecione o snapshot ou instant snapshot de origem na lista. Somente os snapshots no local selecionado são listados.

  7. Em Configurações de disco, escolha um tipo de disco na lista a seguir. Os valores especificados precisam estar no intervalo de valores compatíveis.

    1. Hiperdisco equilibrado. Também é possível alterar as configurações de Tamanho, IOPS provisionadas e Capacidade de processamento provisionada do disco padrão.
    2. Hiperdisco extremo Também é possível alterar as configurações padrão de Tamanho e IOPS provisionadas do disco.
    3. Hyperdisk ML. Também é possível alterar as configurações padrão de Tamanho e capacidade de processamento provisionada do disco.
    4. Capacidade do hiperdisco: também é possível alterar as configurações padrão de Tamanho e Capacidade provisionado do disco.

  8. Opcional: no título Nome do dispositivo, selecione a opção Usar nome de dispositivo personalizado. O nome inserido é usado para gerar um link simbólico para o disco, o que facilita a identificação dele.

  9. Clique em Concluído.

  10. Para aplicar as mudanças à instância, clique em Salvar.

gcloud

  1. Use o comando gcloud compute disks create para criar o volume do hiperdisco.

    gcloud compute disks create DISK_NAME \
    --zone=ZONE \
    --size=DISK_SIZE \
    --type=DISK_TYPE \
    --provisioned-iops=IOPS_LIMIT \
    --provisioned-throughput=THROUGHPUT_LIMIT \
    --access-mode=DISK_ACCESS_MODE

    Substitua:

    • DISK_NAME: o nome do novo disco.
    • ZONE: o nome da zona em que o novo disco está sendo criado.
    • DISK_SIZE: opcional: o tamanho do novo disco. O valor precisa ser um número inteiro seguido por uma unidade de tamanho de GB para gibibyte ou TB para tebibyte. Se nenhuma unidade de tamanho for especificada, 100 GB será usado como o valor padrão. Os valores aceitos para o tamanho do disco são:
      • Hiperdisco equilibrado: de 4 GiB a 64 TiB, inclusive, em incrementos de 1 GiB.
      • Hiperdisco extremo: de 64 GiB a 64 TiB, inclusive, em incrementos de 1 GiB.
      • Hyperdisk ML: de 4 GiB a 64 TiB, inclusive, em incrementos de 1 GiB.
      • Capacidade de processamento do hiperdisco: de 2 TiB a 32 TiB, inclusive, em incrementos de 1 GiB.
    • DISK_TYPE: o tipo do disco. Use um dos seguintes valores: hyperdisk-balanced, hyperdisk-extreme, hyperdisk-ml ou hyperdisk-throughput.
    • IOPS_LIMIT: opcional: para discos de hiperdisco equilibrado ou extremo, esse é o número de operações de E/S por segundo (IOPS) que o disco pode processar.
    • THROUGHPUT_LIMIT (opcional): para volumes de Hyperdisk Balanced, Hyperdisk ML ou Hyperdisk Throughput, é um número inteiro que representa a capacidade máxima, medida em MiB por segundo, que o disco pode oferecer.

    • DISK_ACCESS_MODE: opcional: como as instâncias de computação podem acessar os dados no disco. Os valores aceitos são:

      • READ_WRITE_SINGLE, para acesso de leitura e gravação de uma instância. Esse é o padrão.
      • READ_WRITE_MANY (somente Hyperdisk Balanced e Hyperdisk Balanced High Availability) para acesso de leitura e gravação simultâneo de várias instâncias.
      • READ_ONLY_MANY (somente Hyperdisk ML) para acesso simultâneo somente leitura de várias instâncias.

      Para definir o modo de acesso para discos do Hyperdisk Balanced High Availability, consulte Criar um disco regional.

  2. Opcional: use o comando gcloud compute disks describe DISK_NAME para conferir uma descrição do disco.

  3. Depois de criar o disco, anexe-o a uma instância.

REST

  1. Crie uma solicitação POST para gerar um hiperdisco zonal usando o método disks.insert. Inclua as propriedades name, sizeGb, type, provisionedIops e provisionedThroughput. Para criar esse disco como um que não será inicializado e não estará formatado, recomendamos não especificar uma imagem ou snapshot de origem.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks
{
   "name": "DISK_NAME",
   "sizeGb": "DISK_SIZE",
   "type": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/DISK_TYPE",
   "provisionedIops": "IOPS_LIMIT",
   "provisionedThroughput": "THROUGHPUT_LIMIT",
   "accessMode": "DISK_ACCESS_MODE"
}

    Substitua:

    • PROJECT_ID: ID do projeto
    • ZONE: a zona em que a instância e o novo disco estão localizados.
    • DISK_NAME: o nome do novo disco
    • DISK_SIZE: opcional: o tamanho do novo disco. O valor precisa ser um número inteiro seguido por uma unidade de tamanho de GB para gibibytes ou TB para tebibytes.
    • DISK_TYPE: o tipo do disco. Para criar um volume de hiperdisco, use um dos seguintes valores: hyperdisk-balanced, hyperdisk-extreme, hyperdisk-ml ou hyperdisk-throughput.
    • IOPS_LIMIT: opcional: para Hiperdisco equilibrado e Hiperdisco extremo, esse é o número de operações de E/S por segundo que o disco pode processar.
    • THROUGHPUT_LIMIT (opcional): para volumes de Hyperdisk Balanced, Hyperdisk ML ou Hyperdisk Throughput, é um número inteiro que representa a capacidade máxima, medida em MiB por segundo, que o disco pode oferecer.

    • DISK_ACCESS_MODE: opcional: como as instâncias de computação podem acessar os dados no disco. Os valores aceitos são:

      • READ_WRITE_SINGLE, para acesso de leitura e gravação de uma instância. Esse é o padrão.
      • READ_WRITE_MANY (somente Hyperdisk Balanced e Hyperdisk Balanced High Availability) para acesso simultâneo de leitura e gravação de várias instâncias.
      • READ_ONLY_MANY (somente Hyperdisk ML) para acesso somente leitura simultâneo de várias instâncias.

      Para definir o modo de acesso para discos do Hyperdisk Balanced High Availability, consulte Criar um disco regional.

  2. Opcional: use o método compute.disks.get para conferir uma descrição do disco.

  3. Depois de criar o disco, anexe-o a qualquer instância em execução ou parada.

Go

// createHyperdisk creates a new Hyperdisk in the specified project and zone.
func createHyperdisk(w io.Writer, projectId, zone, diskName string) error {
	//   projectID := "your_project_id"
	//   zone := "europe-central2-b"
	//   diskName := "your_disk_name"

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

	// use format "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-throughput)".
	diskType := fmt.Sprintf("zones/%s/diskTypes/hyperdisk-balanced", zone)

	// Create the disk
	disk := &computepb.Disk{
		Name:   proto.String(diskName),
		Type:   proto.String(diskType),
		SizeGb: proto.Int64(10),
		Zone:   proto.String(zone),
	}

	req := &computepb.InsertDiskRequest{
		Project:      projectId,
		Zone:         zone,
		DiskResource: disk,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("Insert disk request failed: %v", err)
	}

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

	fmt.Fprintf(w, "Hyperdisk created: %v\n", diskName)
	return nil
}

Java 


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateHyperdisk {
  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 disk.
    String zone = "europe-central2-b";
    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";
    // The type of disk you want to create. This value uses the following format:
    // "zones/{zone}/diskTypes/{disktype}".
    // disktype is one of hyperdisk-balanced, hyperdisk-extreme, hyperdisk-throughput
    // hyperdisk-ml, hyperdisk-balanced-high-availability
    // For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
    String diskType = String.format("zones/%s/diskTypes/hyperdisk-balanced", zone);
    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;
    // Optional: For Hyperdisk Balanced or Hyperdisk Extreme disks,
    // this is the number of I/O operations per second (IOPS) that the disk can handle
    long provisionedIops = 3000;
    // Optional: For Hyperdisk Balanced or Hyperdisk Throughput volumes,
    // this is an integer that represents the throughput,
    // measured in MiB per second, that the disk can handle.
    long provisionedThroughput = 140;

    createHyperdisk(projectId, zone, diskName, diskType, diskSizeGb,
            provisionedIops, provisionedThroughput);
  }

  // Creates a hyperdisk in a project
  public static Disk createHyperdisk(String projectId, String zone, String diskName,
                                     String diskType, long diskSizeGb, long provisionedIops,
                                     long provisionedThroughput)
          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 (DisksClient client = DisksClient.create()) {
      // Create a disk.
      Disk disk = Disk.newBuilder()
              .setZone(zone)
              .setName(diskName)
              .setType(diskType)
              .setSizeGb(diskSizeGb)
              .setProvisionedIops(provisionedIops)
              .setProvisionedThroughput(provisionedThroughput)
              .build();

      InsertDiskRequest request = InsertDiskRequest.newBuilder()
              .setProject(projectId)
              .setZone(zone)
              .setDiskResource(disk)
              .build();

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

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

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

      Disk hyperdisk = client.get(projectId, zone, diskName);

      System.out.printf("Hyperdisk '%s' has been created successfully", hyperdisk.getName());

      return hyperdisk;
    }
  }
}

Node.js 

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

// Instantiate a diskClient
const disksClient = new computeLib.DisksClient();
// 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 disksClient.getProjectId();

// The zone where your VM and new disk are located.
// zone = 'europe-central2-b';

// The name of the new disk
// diskName = 'disk-name';

// The type of disk. This value uses the following format:
// "zones/{zone}/diskTypes/(hyperdisk-balanced|hyperdisk-extreme|hyperdisk-ml|hyperdisk-throughput)".
// For example: "zones/us-west3-b/diskTypes/hyperdisk-balanced"
const diskType = `zones/${zone}/diskTypes/hyperdisk-balanced`;
// Size of the new disk in gigabytes.
const diskSizeGb = 10;
// Optional: For Hyperdisk Balanced or Hyperdisk Extreme disks,
// this is the number of I/O operations per second (IOPS) that the disk can handle.
const provisionedIops = 3000;
// Optional: For Hyperdisk Balanced or Hyperdisk Throughput volumes,
// this is an integer that represents the throughput,
// measured in MiB per second, that the disk can handle.
const provisionedThroughput = 140;

async function callCreateComputeHyperdisk() {
  // Create a disk
  const disk = new compute.Disk({
    sizeGb: diskSizeGb,
    name: diskName,
    zone,
    type: diskType,
    provisionedIops,
    provisionedThroughput,
  });

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: disk,
  });

  let operation = response.latestResponse;

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

  console.log(`Disk: ${diskName} created.`);
}

await callCreateComputeHyperdisk();

Depois de criar o disco, anexe-o a qualquer instância em execução ou parada.

Formatar e ativar o disco

Depois de criar e anexar o novo disco a uma instância, você precisa formatar e montar o disco para que o sistema operacional possa usar o espaço de armazenamento disponível.

A seguir