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:

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:

  1. Crie um manifesto de Network, como dhcp-network.yaml, no editor de sua escolha:

    nano dhcp-network.yaml
    
  2. 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.
  3. Salve e feche o manifesto Network no seu editor.

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

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

    nano my-disk.yaml
    
  2. 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.
  3. Salve e feche o manifesto VirtualMachineDisk no seu editor.

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

  1. Crie um manifesto que defina um VirtualMachine, como my-vm.yaml, no editor que você escolher:

    nano my-vm.yaml
    
  2. 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.
    • 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.
  3. Salve e feche o manifesto no editor.

  4. Crie a VM e o disco usando kubectl:

    kubectl apply -f my-vm.yaml
    
  5. 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.

  1. Para acessar uma VM no console, execute kubectl:

    kubectl virt ssh VM_NAME
    
  2. 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.

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

    nano my-data-disk.yaml
    
  2. 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.
  3. Salve e feche o manifesto do disco no editor.

  4. Crie o disco usando kubectl:

    kubectl apply -f my-data-disk.yaml
    
  5. Use kubectl para interromper a VM antes de anexar o novo disco virtual:

    kubectl virt stop VM_NAME
    
  6. 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.

  7. Salve e feche o manifesto da VM atualizado no editor.

  8. Use kubectl para iniciar a VM:

    kubectl virt start VM_NAME
    

Limpar

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

  1. Exclua a VM:

    kubectl delete -f my-vm.yaml
    
  2. 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:

  1. Exclua a rede virtual:

    kubectl delete -f use-dhcp-network.yaml
    
  2. Para remover o driver CSI do cluster, siga as instruções do parceiro de armazenamento.

A seguir