Esta página foi traduzida pela API Cloud Translation.

Criar um novo volume do Hyperdisk

É possível usar um volume de hiperdisco extremo ou hiperdisco de capacidade de processamento com sua VM concluindo as seguintes tarefas:

Crie um volume do hiperdisco em branco, que não seja de inicialização e zonal e o anexe à VM como parte da criação dela ou como tarefas separadas.
Formate e ative o volume para fornecer acesso a um sistema de dados ou arquivos.

O processo é o mesmo para volumes de hiperdisco equilibrado, exceto que você também pode criar discos de inicialização do tipo hiperdisco equilibrado.

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

Antes de começar

Analise as limitações do Hyperdisk antes de adicionar um volume à sua VM.
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
  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 conseguir as permissões necessárias para adicionar um volume do Hyperdisk à VM, peça ao administrador para conceder a você os papéis do IAM a seguir no projeto:

Administrador da instância da computação (v1) (roles/compute.instanceAdmin.v1)
Para se conectar a uma VM que pode ser executada como uma conta de serviço: Usuário da conta de serviço (v1) (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 adicionar um volume do Hyperdisk à VM. Para conferir 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 à VM:

Para criar e anexar um volume do Hyperdisk:
- compute.disks.create no projeto
- compute.instances.attachDisk na VM
- compute.disks.use no volume que você quer anexar à VM
Para formatar e ativar o volume anexado: compute.instances.setMetadata na VM

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

Valores aceitos para volumes do Hyperdisk

Os valores usados ao criar ou modificar um volume do Hyperdisk precisam estar dentro do intervalo de valores máximo e mínimo descrito em Limites do Hyperdisk por disco.

Se você estiver modificando o tamanho de um volume do Hyperdisk anexado a uma VM, os novos valores não poderão ultrapassar Limites de hiperdisco por VM.

As IOPS e a capacidade de processamento provisionadas para um volume do Hyperdisk precisam seguir as regras descritas em Sobre o provisionamento de IOPS e capacidade do Hyperdisk.

Adicionar um volume do Hyperdisk à VM

É possível criar e anexar um volume do hiperdisco usando o console do Google 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 equilibrado ou do Hyperdisk balanceado de alta disponibilidade (Pré-lançamento), é possível permitir que várias VMs acessem o disco criando-o no modo de vários gravadores.

Console

Acesse a página Instâncias da VM.

Acessar instâncias de VM
Clique no nome da VM a que você quer adicionar um disco.
Na página Detalhes da instância de VM, clique em Editar.
Em Discos adicionais, clique em Adicionar novo disco.
Especifique um nome para o disco e, se quiser, uma descrição. Selecione Disco em branco como o Tipo de origem do disco.
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.
Opcional: para volumes do Hyperdisk equilibrado ou do Hyperdisk equilibrado de alta disponibilidade (pré-lançamento), é possível ativar a anexação do disco a várias VMs criando o disco no modo de vários gravadores. Em Modo de acesso, selecione Leitura e gravação de várias VMs.
Clique em Salvar.
Para aplicar as alterações à VM, clique em Salvar.

gcloud

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 equilibrado, Hyperdisk ML ou de capacidade de processamento do hiperdisco, é um número inteiro que representa a capacidade, medida em MiB por segundo, que o disco pode processar.
- DISK_ACCESS_MODE: opcional: como as VMs podem acessar os dados no disco. Os valores aceitos são:
  - READ_WRITE_SINGLE, para acesso de leitura e gravação de uma VM. Esse é o padrão.
  - READ_WRITE_MANY, para acesso de leitura e gravação de várias VMs.
  - READ_ONLY_MANY, para acesso somente leitura de várias VMs.
  É possível definir o modo de acesso para os seguintes tipos de disco:
  - Hiperdisco equilibrado
  - Hyperdisk ML
  - Hyperdisk Balanced High Availability (pré-lançamento)
Opcional: use o comando gcloud compute disks describe DISK_NAME para conferir uma descrição do disco.
Depois de criar o disco, anexe-o a uma VM.

REST

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 VM 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 equilibrado, Hyperdisk ML ou de capacidade de processamento do hiperdisco, é um número inteiro que representa a capacidade, medida em MiB por segundo, que o disco pode processar.
- DISK_ACCESS_MODE: como as VMs podem acessar os dados no disco. Os valores aceitos são:
  - READ_WRITE_SINGLE, para acesso de leitura e gravação de uma VM. Esse é o padrão.
  - READ_WRITE_MANY, para acesso de leitura e gravação de várias VMs.
  - READ_ONLY_MANY, para acesso somente leitura de várias VMs.
  É possível definir o modo de acesso para os seguintes tipos de disco:
  - Hiperdisco equilibrado
  - Hyperdisk ML
  - Hyperdisk Balanced High Availability (pré-lançamento)
Opcional: use o método compute.disks.get para conferir uma descrição do disco.
Depois de criar o disco, anexe-o a qualquer VM em execução ou interrompida.

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/(hyperdisk-balanced|hyperdisk-extreme|hyperdisk-throughput)".
    // 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 VM em execução ou interrompida.

Formatar e ativar o disco

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

Linux: consulte Como formatar e ativar um disco que não é de inicialização em uma VM do Linux
Windows: consulte Como formatar e ativar um disco que não é de inicialização em uma VM do Windows.

A seguir

Saiba como personalizar as IOPS e a capacidade dos volumes do hiperdisco.
Saiba como fazer backup dos discos usando snapshots regularmente para evitar perda não intencional de dados.