Tutorial: criar e gerenciar uma VM do Linux no ambiente de execução de VM do Anthos

Neste tutorial, mostramos como criar e gerenciar uma máquina virtual (VM) do Linux em uma nova instalação do ambiente de execução de VM do Anthos. Você aprenderá o processo para criar e definir as dependências básicas, como StorageClass e rede virtual, e depois criar uma VM que usa esses recursos. Em seguida, você aprenderá a editar a VM, por exemplo, para adicionar um novo disco.

Objetivos

Configurar dependências básicas
- Criar um StorageClass para o ambiente de execução de VM do Anthos
- Criar uma rede virtual para ser usada pelas VMs
Criar um disco de inicialização de máquina virtual
Criar uma VM
Editar uma VM para adicionar um novo disco virtual

Antes de começar

Para concluir este tutorial, você precisa de acesso aos recursos e ferramentas a seguir:

Acesso a clusters do Anthos na versão bare metal 1.12.0 (anthosBareMetalVersion: 1.12.0) ou superior. Use qualquer tipo de cluster capaz de executar cargas de trabalho. Se necessário, tente clusters do Anthos em bare metal no Compute Engine ou consulte a visão geral de 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 um `StorageClass`

Use um StorageClass para definir o tipo de armazenamento que disponibiliza para as VMs. Diferentes classes de armazenamento podem ser mapeadas para um tipo diferente de hardware de armazenamento, sistema de arquivos ou desempenho.

Está fora do escopo deste tutorial fornecer instruções específicas para cada StorageClass e parceiro de armazenamento.

Os parceiros de armazenamento Anthos Ready fornecem drivers qualificados da Interface de Armazenamento de Contêiner (CSI, na sigla em inglês) que instalam e configuram os recursos personalizados necessários para o armazenamento. Para instalar o driver CSI no cluster, consulte a lista de parceiros de armazenamento compatíveis e siga as instruções.

Depois de instalar o driver CSI na plataforma de armazenamento, uma ou mais classes de armazenamento ficam disponíveis no cluster. Neste tutorial, use uma dessas classes de armazenamento para criar um disco rígido virtual.

O exemplo básico a seguir, NFS StorageClass, usa o driver CSI do NFS. Você define o endereço do servidor NFS e o caminho a ser usado no StorageClass. Todos os nós do cluster podem se conectar e usar este armazenamento NFS:

  apiVersion: storage.k8s.io/v1
  kind: StorageClass
  metadata:
    name: example-nfs
  provisioner: nfs.csi.k8s.io
  parameters:
    server: nfs-server.example.com
    path: /vm-share
  reclaimPolicy: Delete
  volumeBindingMode: Immediate
  mountOptions:
    - nconnect=8
    - nfsvers=4.1

Neste tutorial, use o nome de um StorageClass no seu próprio cluster.

O ambiente de execução da VM do Anthos gera automaticamente um perfil de armazenamento para cada StorageClass em um cluster. O perfil de armazenamento tem o mesmo nome do StorageClass associado. Os perfis de armazenamento oferecem opções de configuração adicionais associadas a cada StorageClass. Para mais informações sobre perfis de armazenamento, incluindo instruções de configuração, consulte Configurar perfis de armazenamento.

Criar uma rede virtual

As VMs conectam-se a uma rede virtual usando uma interface de rede virtual. A rede virtual permite que elas se comuniquem com outras VMs no cluster ou com recursos fora do cluster.

Neste tutorial, você cria uma rede virtual básica de camada 2 (L2) que pode usar um servidor DHCP externo. Ao ativar o uso de um servidor DHCP externo, é possível pular as configurações de DNS e gateway se elas são fornecidas pelo DHCP.

Para criar uma rede que usa um servidor DHCP externo, siga as etapas a seguir:

Crie um manifesto de Network, como dhcp-network.yaml, no editor de sua escolha:
```
nano dhcp-network.yaml
```
Copie e cole o seguinte manifesto YAML:
```
apiVersion: networking.gke.io/v1
kind: Network
  name: NETWORK_NAME
spec:
  type: L2
  nodeInterfaceMatcher:
    interfaceName: INTERFACE_NAME
  externalDHCP4: true
```
Substitua os seguintes valores:
- NETWORK_NAME: o nome da sua rede.
- INTERFACE_NAME: o nome da interface nos clusters do Anthos em nó bare metal para anexar a rede. Todos os nós precisam ter o mesmo nome de interface.
Nesse manifesto Network, os seguintes valores são definidos:
- As cargas de trabalho podem ter apenas um anexo L2 para essa rede. Essa é a única rede type que pode ser criada no ambiente de execução de VM do Anthos.
- O DHCP externo está ativado na rede. O servidor DHCP externo é responsável pela configuração de alocação de endereços IPv4, rotas, gateway e DNS para cargas de trabalho conectadas a essa rede.
Salve e feche o manifesto Network no seu editor.
Crie a rede usando kubectl:
```
kubectl apply -f use-dhcp-network.yaml
```

Criar um disco de inicialização de VM

Uma VM pode usar uma imagem de disco pré-criada ou inicializar a partir de uma imagem ISO para instalar manualmente o SO. Essas imagens de disco podem ser armazenadas e acessadas usando HTTP ou no Cloud Storage e acessadas usando um Secret.

Neste tutorial, você criará um disco de inicialização a partir da imagem de nuvem pública do Ubuntu Server 20.04 usando HTTP.

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
  storageClassName: STORAGE_CLASS_NAME
  source:
    http:
      url: https://cloud-images.ubuntu.com/releases/focal/release/ubuntu-20.04-server-cloudimg-amd64.img
```
Substitua os seguintes valores:
- DISK_NAME: o nome escolhido para o disco. Este exemplo cria um disco 20Gi (20 gibibyte) chamado DISK_NAME usando uma imagem pública do Ubuntu Server 20.04.
- STORAGE_CLASS_NAME: a StorageClass que você quer usar para o VirtualMachineDisk.
  - Use kubectl get storageclass para listar o que está disponível no cluster.
Observação: pode levar de 15 a 20 minutos para fazer o download dessa imagem pública, criar o VirtualMachineDisk e aplicar a imagem do SO para o novo disco. O processo de criação do VirtualMachineDisk é muito mais rápido quando você usa uma imagem armazenada localmente. Na maioria dos cenários de produção, use um repositório de imagem HTTP local em vez de uma fonte pública externa a cada vez.
Salve e feche o manifesto VirtualMachineDisk no seu editor.
Crie o disco usando kubectl:
```
kubectl apply -f my-disk.yaml
```

Criar uma VM

Com uma rede virtual e um disco de inicialização criados nas seções anteriores, agora crie uma VM. A VM conecta-se à rede virtual e é inicializada pelo disco virtual. As instruções a seguir criam uma VM ao aplicar diretamente um arquivo de manifesto YAML VirtualMachine com a CLI kubectl.

Crie um manifesto que defina um 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: VirtualMachine
metadata:
  name: VM_NAME
spec:
  osType: linux
  compute:
    cpu:
      vcpus: VCPU_NUMBER
    memory:
      capacity: MEMORY_SIZE
  interfaces:
    - name: eth0
      networkName: NETWORK_NAME
      default: true
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
```
Substitua os seguintes valores:
- VM_NAME: o nome da VM.
- VCPU_NUMBER: o número de vCPUs opcionais a serem atribuídas à VM. Sem essa configuração, o padrão de duas vCPUs é atribuído.
  - É possível atribuir de 1 a 96 vCPUs a uma VM.
- MEMORY_SIZE: a quantidade de memória opcional a ser atribuída à VM. Sem essa configuração, o padrão de 4 GiB de memória é atribuído.
  - É possível atribuir entre 1M e 1T de memória a uma VM. Para mais informações, consulte Unidades de recurso de memória.
- NETWORK_NAME: o nome da rede criada em uma seção anterior.
- DISK_NAME: o nome do disco de inicialização criado na seção anterior. Esse disco é 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
```
Pode levar alguns minutos para criar a instância. Verifique o status da VM com o comando kubectl:
```
kubectl get gvm VM_NAME
```
O exemplo de saída a seguir mostra a VM em um estado Running:
```
NAME    STATUS    AGE   IP
MY_VM   Running   64s   192.168.2.124
```

Conectar-se à VM

Quando sua VM estiver em execução, conecte-se ao console dela. Com essa conexão do console, é possível realizar tarefas básicas, como configurar ainda mais a VM ou instalar um aplicativo.

Para acessar uma VM no console, execute kubectl:
```
kubectl virt ssh VM_NAME
```
Depois de se conectar ao console da VM, saia da sessão e do console da VM:
```
Ctrl + ]
```

Editar a VM

Durante o ciclo de vida da VM, convém editar a VM. Por exemplo, convém adicionar armazenamento para instalar um aplicativo em um disco dedicado ou usar armazenamento extra para o aplicativo.

Neste tutorial, crie um disco em branco e o anexe à VM. Esse cenário permite criar um disco para armazenar dados do aplicativo.

Crie um manifesto de VirtualMachineDisk, como my-data-disk.yaml, no editor de sua escolha:
```
nano my-data-disk.yaml
```
Copie e cole a seguinte definição de YAML:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachineDisk
metadata:
  name: DATA_DISK_NAME
spec:
  size: 10Gi
  storageClassName: STORAGE_CLASS_NAME
```
Substitua os seguintes valores:
- DATA_DISK_NAME: o nome escolhido para o disco de dados. Este exemplo cria um disco 10Gi (10 gibibyte).
- STORAGE_CLASS_NAME: a StorageClass que você quer usar para o VirtualMachineDisk.
  - Use kubectl get storageclass para listar o que está disponível no cluster.
Salve e feche o manifesto do disco no editor.
Crie o disco usando kubectl:
```
kubectl apply -f my-data-disk.yaml
```
Use kubectl para interromper a VM antes de anexar o novo disco virtual:
```
kubectl virt stop VM_NAME
```

Edite o recurso da VM:

kubectl edit gvm VM_NAME

Atualize o manifesto YAML da VirtualMachine para anexar o disco ao final da seção spec.disks da VM:

apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: VM_NAME
spec:
  ...
  disks:
    - boot: true
      virtualMachineDiskName: DISK_NAME
    - virtualMachineDiskName: DATA_DISK_NAME

Substitua DATA_DISK_NAME pelo nome do disco criado na etapa anterior.

Salve e feche o manifesto da VM atualizado no editor.
Use kubectl para iniciar a VM:
```
kubectl virt start VM_NAME
```

Limpar

Para excluir os recursos criados neste tutorial, siga estas etapas:

Exclua a VM:
```
kubectl delete -f my-vm.yaml
```

Exclua os recursos do VirtualMachineDisk:

kubectl delete -f my-data-disk.yaml
kubectl delete -f my-disk.yaml

Se você não quiser manter as dependências básicas no cluster, siga estas etapas:

Exclua a rede virtual:

kubectl delete -f use-dhcp-network.yaml

Para remover o driver CSI do cluster, siga as instruções do parceiro de armazenamento.