Criar e gerenciar discos virtuais no GKE em Bare Metal

Este documento é destinado aos proprietários de aplicativos que executam o GKE em bare metal. Neste documento, mostramos como criar e gerenciar recursos de disco para máquinas virtuais (VMs) que usam o ambiente de execução da VM no Google Distributed Cloud.

Antes de começar

Para concluir este documento, você precisa de acesso aos seguintes recursos:

Acesso ao GKE em um cluster Bare Metal versão 1.12.0 (anthosBareMetalVersion: 1.12.0) ou superior. Use qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, teste o GKE em Bare Metal no Compute Engine ou consulte a visão geral da criação de clusters.
A ferramenta do cliente virtctl instalada como um plug-in para o kubectl. Se necessário, instale a ferramenta de cliente virtctl.

Criar uma VM com um disco anexado

Ao criar uma VM, é possível anexar um disco de inicialização ou de dados, criar um disco com base em uma imagem (inclusive para o disco de inicialização) ou criar um disco em branco.

Disco em branco

Nesse cenário, você cria um disco em branco e o anexa à VM. Esse cenário permite criar um disco para armazenar dados do aplicativo.

Crie um manifesto que defina um VirtualMachineDisk e VirtualMachine, como my-vm.yaml, no editor que você escolher:
```
nano my-vm.yaml
```
Copie e cole a seguinte definição de YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME
```
Substitua:
- DISK_NAME: o nome do disco em branco que você está criando e anexando à sua VM.
  
  Observação: a partir do GKE em Bare Metal versão 1.13.0, quando você cria uma VM, o ambiente de execução de VMs no Google Distributed Cloud define os nomes dos discos especificados com virtualMachineDiskName como o número de série do disco. Para mais informações, consulte Como localizar discos.
- VM_NAME: o nome da VM que você está criando.
  
  Este exemplo cria um disco 10Gi em branco (10 gibibyte) chamado DISK_NAME. Na seção spec.disks da VM, você também precisa anexar um disco de inicialização, como um de uma imagem conforme mostrado na próxima seção.
Salve e feche o arquivo de manifesto no editor.
Crie a VM e o disco usando kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Substitua KUBECONFIG pelo caminho para o arquivo kubeconfig do cluster.

Da imagem

Neste cenário, você cria um disco usando uma imagem e o anexa à VM. Esse cenário permite criar um disco de inicialização, por exemplo, com base em uma imagem. Também é possível criar e anexar discos de dados de uma imagem.

Origens de imagem compatíveis

O ambiente de execução de VMs no Google Distributed Cloud permite uma variedade de formatos de imagem e oferece suporte a três tipos de origens de imagens que podem ser especificadas na especificação VirtualMachineDisk de dois minutos. Cada um dos exemplos a seguir cria um disco de 20 gibibytes de uma origem de imagem compatível diferente.

Protocolo de transferência de hipertexto (HTTP)

O exemplo de VirtualMachineDisk a seguir mostra a estrutura básica de uma origem de imagem HTTP. O campo url espera um URL HTTP ou HTTPS.

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    http:
      url: https://download.cirros-cloud.net/0.4.0/cirros-0.4.0-x86_64-disk.img
  size: 20GiB
  storageClassName: local-shared

Cloud Storage

O exemplo a seguir mostra como criar um disco a partir de uma imagem em um bucket do Cloud Storage. Se as credenciais padrão do aplicativo na máquina não forem suficientes para acessar o URL do Cloud Storage, será necessário fornecê-las. No exemplo a seguir, my-gcs é um secret contendo uma chave de conta de serviço codificada em Base64.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    gcs:
      url: gs://kubevirt-ci-vm-images/rhel8.2/rhel8_2_cloud.qcow2
      secretRef: my-gcs
  size: 20GiB
  storageClassName: local-shared
```
Se você usou chaves de conta de serviço salvas para criar seu cluster, é possível utilizar a chave da conta de serviço do Container Registry para acesso ao Cloud Storage. Se você criar uma conta de serviço separada para acessar o Cloud Storage, consulte Configurar uma conta de serviço com acesso ao bucket do Cloud Storage.

Use o comando a seguir para criar um Secret do Kubernetes a partir do arquivo de chave da conta de serviço salvo:
```
kubectl create secret generic SECRET_NAME --from-file=KEY_FILE --namespace default \
    --kubeconfig KUBECONFIG
```
Substitua:
- SECRET_NAME: o nome do Secret.
- KEY_FILE: caminho para o arquivo JSON da chave da conta de serviço transferido por download. Por exemplo, bmctl-workspace/.sa-keys/my-project-anthos-baremetal-gcr.json.
- KUBECONFIG: caminho para o arquivo kubeconfig do cluster
Para mais informações sobre o uso de credenciais para acessar o Cloud Storage, consulte Criar e usar credenciais para importar imagens do Cloud Storage.
Exemplo do Container Registry

Os registros de contêiner que estão em conformidade com a especificação de distribuição da Open Container Initiative (OCI) são compatíveis. No exemplo a seguir, criamos um disco a partir de uma imagem armazenada em um registro do Docker.
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: my-disk
spec:
  source:
    registry:
      url: docker://kubevirt/fedora-cloud-registry-disk-demo
  size: 20GiB
  storageClassName: local-shared
```

Formatos de imagem válidos

É possível usar qualquer um dos seguintes formatos de imagem ao criar um disco a partir de uma imagem:

Arquivo ZIP GNU (GZIP) (.gz)
RAW (.raw, .img)
Cópia QEMU na versão 2 da gravação (qcow2) imagem do disco (.qcow2)
Arquivo compactado em XZ (.xz)
Arquivo de disco da máquina virtual (VMDK) (.vmdk)
Arquivo de imagem de disco virtual (VDI) do VirtualBox (.vdi)
Arquivo de imagem de disco rígido virtual (VHD) (.vdh)
Arquivo do disco rígido virtual versão 2 (VDHX) (.vdhx)
Arquivo de imagem de disco ISO (.iso)

Exemplo de um disco criado a partir de uma imagem HTTP

As etapas a seguir criam um disco de inicialização a partir de uma imagem do Ubuntu:

Crie um manifesto que defina um VirtualMachineDisk e uma VirtualMachine, como my-vm.yaml, no editor que você escolher:
```
nano my-vm.yaml
```

Copie e cole a seguinte definição de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: VM_NAME-boot-dv
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv

Neste exemplo, criamos um disco 20Gi (20 gibibyte) chamado VM_NAME-boot-dv, usando uma imagem pública do Ubuntu. Na seção spec.disks da VM, o disco está definido como boot: true.

Salve e feche o manifesto no editor.
Crie a VM e o disco usando kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Substitua KUBECONFIG pelo caminho para o arquivo kubeconfig do cluster.

Disco atual

Nesse cenário, você cria um disco em branco e o anexa à VM. Esse cenário permite criar um disco para armazenar dados do aplicativo.

Crie um manifesto VirtualMachine, como my-vm.yaml, no editor de sua escolha:
```
nano my-vm.yaml
```

Copie e cole a seguinte definição de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: EXISTING_DISK_NAME

Neste exemplo, anexamos um disco chamado EXISTING_DISK_NAME.

Na seção spec.disks da VM, você também precisa anexar um disco de inicialização como de uma imagem, como mostrado na seção anterior.

Salve e feche o manifesto da VM no editor.
Crie a VM usando kubectl:
```
kubectl apply -f my-vm.yaml --kubeconfig KUBECONFIG
```
Substitua KUBECONFIG pelo caminho para o arquivo kubeconfig do cluster.

Como localizar discos

A partir do GKE em Bare Metal 1.13.0, quando você cria uma VM o ambiente de execução de VMs no Google Distributed Cloud usa os nomes dos discos especificados no recurso da VM para definir os números de série dos discos. Especificamente, os nomes especificados com spec.disks.virtualMachineDiskName no recurso personalizado VirtualMachine são usados no número de série dos discos. Esse recurso facilita a localização dos discos na VM quando você precisa executar operações de disco, como formatação ou montagem.

Por exemplo, se você criou uma VM e especificou um disco de inicialização chamado sample-boot-dv, seu recurso personalizado VirtualMachine será semelhante a este:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  osType: Linux
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: sample-vm-boot-dv
    - virtualMachineDiskName: attached-disk

Para VMs do Linux, ao fazer login na VM, é possível executar o seguinte comando para listar os discos pelo número de série:

ls -l /dev/disk/by-id/

A resposta será parecida com esta saída de exemplo, em que os nomes dos discos aparecem como números de série:

total 0
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentInstallation -> ../../sdb
lrwxrwxrwx 1 root root  9 Oct 19 17:17 ata-QEMU_HARDDISK_agentSADisk -> ../../sda
lrwxrwxrwx 1 root root  9 Oct 19 17:17 virtio-sample-boot-dv -> ../../vda
lrwxrwxrwx 1 root root 10 Oct 19 17:17 virtio-sample-boot-dv-part1 -> ../../vda1
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part14 -> ../../vda14
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-sample-boot-dv-part15 -> ../../vda15
lrwxrwxrwx 1 root root 11 Oct 19 17:17 virtio-attached-disk -> ../../vdb

Observe o seguinte comportamento situacional de recursos:

Se o valor virtualMachineDiskName tiver mais de 20 caracteres, o ambiente de execução de VMs no Google Distributed Cloud vai usar apenas os primeiros 20 caracteres como o número de série.
Se houver dois discos com os mesmos primeiros 20 caracteres, somente o primeiro terá um número de série.

Criar e anexar discos a uma VM

Se você já tiver uma VM, poderá criar e anexar discos para oferecer suporte aos ciclos de vida dos seus aplicativos. A VM precisa estar parada para poder ser anexada ao disco.

Disco em branco

Nesse cenário, você cria um disco em branco e o anexa à VM. Esse cenário permite criar um disco para armazenar dados do aplicativo.

Use kubectl para interromper a VM, se necessário:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Substitua:
- VM_NAME: o nome da VM que você quer alterar.
- KUBECONFIG: o caminho até o arquivo kubeconfig do cluster.

Edite seu recurso de VM atual, como my-vm:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Atualize o manifesto YAML VirtualMachine para adicionar uma seção VirtualMachineDisk na parte superior e, em seguida, anexe o disco ao final da seção spec.disks da VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

Este exemplo cria um disco 10Gi em branco (10 gibibyte) chamado DISK_NAME.

Salve e feche o manifesto da VM atualizado no editor.

Use kubectl para iniciar a VM:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Da imagem

Nesse cenário, você cria um disco com base em uma imagem de origem e o anexa à VM.

Use kubectl para interromper a VM, se necessário:
```
kubectl virt stop vm VM_NAME --kubeconfig KUBECONFIG
```
Substitua:
- VM_NAME: o nome da VM que você quer alterar.
- KUBECONFIG: o caminho até o arquivo kubeconfig do cluster.

Edite seu recurso de VM atual, como my-vm:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Atualize o manifesto VirtualMachine para adicionar uma seção VirtualMachineDisk na parte superior e, em seguida, anexe o disco ao final da seção spec.disks da VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi
  source:
    http:
      url: http://example.com/my-disk-img.qcow2
---
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  interfaces:
    - name: eth0
      networkName: pod-network
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: VM_NAME-boot-dv
    - virtualMachineDiskName: DISK_NAME

Neste exemplo, criamos um disco 10Gi (10 gibibyte) chamado DISK_NAME a partir da origem HTTP http://example.com/my-disk-img.qcow2.

Salve e feche o manifesto da VM atualizado no editor.

Use kubectl para iniciar a VM:

kubectl virt start vm VM_NAME --kubeconfig KUBECONFIG

Criar um disco

Nesse cenário, você cria os recursos de disco separadamente dos recursos de VM. Este cenário permite que você crie discos com antecedência e anexá-los às VMs conforme necessário.

Disco em branco

Para criar um disco em branco, siga as etapas abaixo.

Crie um manifesto VirtualMachineDisk, como my-disk.yaml, no editor de sua escolha:
```
nano my-disk.yaml
```

Copie e cole a seguinte definição de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 10Gi

Este exemplo cria um disco 10Gi em branco (10 gibibyte) chamado DISK_NAME.

Salve e feche o manifesto do disco no editor.
Crie o disco usando kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Substitua KUBECONFIG pelo caminho para o arquivo kubeconfig do cluster.

Da imagem

Para criar um disco com base em uma imagem, siga as etapas abaixo.

Crie um manifesto de VirtualMachineDisk, como my-disk.yaml, no editor de sua escolha:
```
nano my-disk.yaml
```

Copie e cole a seguinte definição de YAML:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DISK_NAME
spec:
  size: 20Gi
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img

Neste exemplo, criamos um disco 20Gi (20 gibibyte) chamado DISK_NAME, usando uma imagem pública do Ubuntu.

Salve e feche o manifesto do disco no editor.
Crie o disco usando kubectl:
```
kubectl apply -f my-disk.yaml --kubeconfig KUBECONFIG
```
Substitua KUBECONFIG pelo caminho para o arquivo kubeconfig do cluster.

A seguir

Crie e use credenciais para importar imagens do Cloud Storage.
Crie e use classes de armazenamento no GKE em Bare Metal.
Quando você não precisar mais de VMs ou dos respectivos recursos de disco virtual, exclua uma VM no GKE em bare metal.