Versão 1.8: Essa versão é compatível, conforme mencionado na política de compatibilidade de versão do Anthos, e oferece patches e atualizações mais recentes para vulnerabilidades de segurança, exposições e problemas que afetam os clusters do Anthos em bare metal. Veja os detalhes nas notas de lançamento 1.8. Esta é a versão mais recente. Para ver uma lista completa de cada lançamento de versões secundárias e de patches em ordem cronológica, consulte as notas de lançamento combinadas.

Versões disponíveis: 1.8  |   1.7  |   1.6

Como trabalhar com cargas de trabalho baseadas em VM

Nesta página, mostramos como implantar VMs em clusters do Anthos em Bare Metal usando o ambiente de execução de VM do Anthos. O ambiente de execução do Anthos VM usa o KubeVirt para orquestrar VMs em clusters, permitindo que você trabalhe com seus aplicativos e cargas de trabalho baseados em VM em um ambiente de desenvolvimento uniforme. Você pode ativar o ambiente de execução do Anthos VM ao criar um novo cluster e em clusters atuais.

Antes de começar

Para seguir estas instruções, é necessário ter um cluster em execução. Se você não fizer isso, siga as instruções no Guia de início rápido do clusters do Anthos em bare metal para configurar rapidamente um cluster na estação de trabalho.

Ativar o ambiente de execução da VM do Anthos

  1. Abra a configuração do cluster executando:

    kubectl --kubeconfig bmctl-workspace/CLUSTER_NAME/CLUSTER_NAME-kubeconfig edit cluster CLUSTER_NAME -n cluster-CLUSTER_NAME
    

    Substitua CLUSTER_NAME pelo nome do cluster.

  2. Adicione kubevirt à seção spec da configuração do cluster. Se o nó for compatível com a virtualização de hardware, defina useEmulation como false para melhorar o desempenho. Se a virtualização de hardware não for compatível ou você não tiver certeza, defina-a como true.

    spec:
      anthosBareMetalVersion: 1.8.3
      kubevirt:
        useEmulation: true
      bypassPreflightCheck: false
    
  3. Salve a configuração e verifique se o KubeVirt está ativado:

    kubectl --kubeconfig bmctl-workspace/CLUSTER_NAME/CLUSTER_NAME-kubeconfig get pods -n kubevirt
    

    Substitua CLUSTER_NAME pelo nome do cluster.

    O comando retorna algo como:

    NAME                              READY   STATUS    RESTARTS   AGE
    virt-api-767bc4ccd5-56fk2         1/1     Running   0          11d
    virt-api-767bc4ccd5-ms8tn         1/1     Running   0          11d
    virt-controller-c8468c84c-l4dzr   1/1     Running   0          11d
    virt-controller-c8468c84c-tljnj   1/1     Running   1          11d
    virt-handler-6wk5v                1/1     Running   0          11d
    virt-handler-ngth6                1/1     Running   0          11d
    virt-operator-7447547957-c6g5d    1/1     Running   1          11d
    virt-operator-7447547957-nl826    1/1     Running   0          11d
    

Instale o virtctl (em inglês)

  1. Instalar a ferramenta CLI virtctl como um plug-in kubectl

    export GOOGLE_APPLICATION_CREDENTIALS="bm-gcr.json"
    sudo -E ./bmctl install virtctl
    
  2. Verifique se o virtctl está instalado:

    kubectl plugin list
    

    virtctl será instalado se estiver listado na resposta.

Crie uma VM

Depois de ativar o KubeVirt no seu cluster e instalar o plug-in virtctl para kubectl, você pode começar a criar VMs no seu cluster usando o comando kubectl virt create vm. Antes de executar este comando, recomendamos configurar um arquivo cloud-init para garantir que você tenha acesso ao console para a VM depois que ela for criada.

Criar um arquivo cloud-init personalizado para acesso ao console

Há duas maneiras de criar um arquivo cloud-init personalizado. A maneira mais fácil é especificar a sinalização --os=<OPERATING_SYSTEM> ao criar a VM. Esse método configura automaticamente um arquivo cloud-init simples e funciona para os sistemas operacionais a seguir.

  • Ubuntu
  • CentOS
  • Debian
  • Fedora

Depois que a VM for criada, você poderá acessá-la pela primeira vez com as credenciais a seguir e alterar a senha:

user: root
password: changeme

Se sua imagem contém um SO baseado em Linux diferente ou se você precisa de uma configuração mais avançada, crie manualmente um arquivo cloud-init personalizado e especifique o caminho para esse arquivo especificando a sinalização --cloud-init-file=<path/to/file>. Na forma mais básica, o arquivo cloud-init é um arquivo YAML que contém o seguinte:

#cloud-config
user: root
password: changeme
lock_passwd: false
chpasswd: {expire: false}
disable_root: false
ssh_authorized_keys:
- <ssh-key>

Para configurações mais avançadas, consulte Exemplos de configuração do Cloud.

Depois de determinar qual método usar, você está pronto para criar uma VM.

Execute o comando kubectl virt create vm.

É possível criar VMs com base em imagens públicas ou personalizadas.

Imagem pública

Se o cluster tiver uma conexão externa, crie uma VM a partir de uma imagem pública executando:

kubectl virt create vm VM_NAME \
    --boot-disk-access-mode=MODE \
    --boot-disk-size=DISK_SIZE \
    --boot-disk-storage-class="DISK_CLASS" \
    --cloud-init-file=FILE_PATH \
    --cpu=CPU_NUMBER \
    --image=IMAGE_NAME \
    --memory=MEMORY_SIZE

Substitua:

  • VM_NAME pelo nome da VM que você quer criar.
  • MODE pelo modo de acesso do disco de inicialização. Os valores possíveis são ReadWriteOnce (padrão) ou ReadWriteMany.
  • DISK_SIZE pelo tamanho que você quer para o disco de inicialização. O valor padrão é 20Gi.
  • DISK_CLASS pela classe de armazenamento do disco de inicialização. O valor padrão é local-shared. Para ver uma lista de classes de armazenamento disponíveis, execute kubectl get storageclass.
  • FILE_PATH pelo caminho completo do arquivo cloud-init personalizado. Dependendo da imagem, isso pode ser necessário para acessar o console à VM depois que ela é criada. Se você planeja configurar automaticamente o arquivo cloud-init com a sinalização --os, não especifique a sinalização --cloud-init-file. Se você especificar a sinalização --cloud-init-file, a sinalização --os será ignorada. Os valores acessíveis para --os são ubuntu, centos, debian e fedora.
  • CPU_NUMBER pelo número de CPUs que você quer configurar para a VM. O valor padrão é 1.
  • IMAGE_NAME pela imagem da VM, que pode ser ubuntu20.04 (padrão), centos8 ou um URL da imagem.
  • MEMORY_SIZE pelo tamanho da memória da VM. O valor padrão é 4Gi.

Imagem personalizada

Ao criar uma VM a partir de uma imagem personalizada, é possível especificar uma imagem de um servidor de imagens HTTP ou de uma imagem armazenada localmente.

Servidor de imagem HTTP

É possível configurar um servidor HTTP usando Apache ou nginx e fazer upload da imagem personalizada para a pasta exposta. Em seguida, crie uma VM a partir da imagem personalizada executando:

kubectl virt create vm VM_NAME \
    --boot-disk-access-mode=DISK_ACCESS_MODE \
    --boot-disk-size=DISK_SIZE \
    --boot-disk-storage-class=DISK_CLASS \
    --cloud-init-file=FILE_PATH \
    --cpu=CPU_NUMBER \
    --image=http://SERVER_IP/IMAGE_NAME \
    --memory=MEMORY_SIZE

Substitua:

  • VM_NAME pelo nome da VM que você quer criar.
  • DISK_ACCESS_MODE pelo modo de acesso do disco de inicialização. Os valores possíveis são ReadWriteOnce (padrão) ou ReadWriteMany.
  • DISK_SIZE pelo tamanho que você quer para o disco de inicialização. O valor padrão é 20Gi.
  • DISK_CLASS pela classe de armazenamento do disco de inicialização. O valor padrão é local-shared. Para ver uma lista de classes de armazenamento disponíveis, execute kubectl get storageclass.
  • FILE_PATH pelo caminho completo do arquivo cloud-init personalizado. Dependendo da imagem, isso pode ser necessário para acessar o console à VM depois que ela é criada. Se você planeja configurar automaticamente o arquivo cloud-init com a sinalização --os, não especifique a sinalização --cloud-init-file. Se você especificar a sinalização --cloud-init-file, a sinalização --os será ignorada. Os valores acessíveis para --os são ubuntu, centos, debian e fedora.
  • CPU_NUMBER pelo número de CPUs que você quer configurar para a VM. O valor padrão é 1.
  • SERVER_IP pelo endereço IP do servidor que hospeda a imagem.
  • IMAGE_NAME pelo nome do arquivo da imagem personalizada.
  • MEMORY_SIZE pelo tamanho da memória da VM. O valor padrão é 4Gi.

Imagem armazenada localmente

Para armazenar a imagem personalizada localmente e criar uma VM a partir dela, execute:

kubectl virt create vm VM_NAME \
    --boot-disk-access-mode=DISK_ACCESS_MODE \
    --boot-disk-size=DISK_SIZE \
    --boot-disk-storage-class=DISK_CLASS \
    --cloud-init-file=FILE_PATH \
    --cpu=CPU_NUMBER \
    --image=IMAGE_PATH \
    --memory=MEMORY_SIZE \

Substitua:

  • VM_NAME pelo nome da VM que você quer criar.
  • DISK_ACCESS_MODE pelo modo de acesso do disco de inicialização. Os valores possíveis são ReadWriteOnce (padrão) ou ReadWriteMany.
  • DISK_SIZE pelo tamanho que você quer para o disco de inicialização. O valor padrão é 20Gi.
  • DISK_CLASS pela classe de armazenamento do disco de inicialização. O valor padrão é local-shared.
  • FILE_PATH pelo caminho completo do arquivo cloud-init personalizado. Dependendo da imagem, isso pode ser necessário para acessar o console à VM depois que ela é criada. Se você planeja configurar automaticamente o arquivo cloud-init com a sinalização --os, não especifique a sinalização --cloud-init-file. Se você especificar a sinalização --cloud-init-file, a sinalização --os será ignorada. Os valores acessíveis para --os são ubuntu, centos, debian e fedora.
  • CPU_NUMBER pelo número de CPUs que você quer configurar para a VM. O valor padrão é 1.
  • IMAGE_PATH pelo caminho do arquivo local para a imagem personalizada.
  • MEMORY_SIZE pelo tamanho da memória da VM. O valor padrão é 4Gi.

É possível alterar os valores padrão de sinalizações

O comando kubectl virt create vm usa valores padrão para preencher automaticamente sinalizações não especificadas quando o comando é executado. É possível alterar esses valores padrão executando:

kubectl virt config default FLAG

Substitua FLAG pela sinalização do parâmetro cujo valor padrão você quer alterar.

Exemplo: o comando a seguir altera a configuração padrão da CPU do padrão inicial de 1 para 2:

kubectl virt config default --cpu=2

Para ver uma lista de sinalizações compatíveis e os valores padrão atuais, execute:

kubectl virt config default -h

As configurações padrão são armazenadas no lado do cliente como um arquivo local chamado ~/.virtctl.default. Também é possível alterar as configurações padrão editando esse arquivo.

Acessar sua VM

Use estes métodos para acessar as VMs:

Acesso ao console

Para acessar uma VM no console, execute:

kubectl virt console VM_NAME

Substitua VM_NAME pelo nome da VM que você quer acessar.

Acesso ao VNC

Para acessar uma VM usando o VNC, execute:

# This requires remote-viewer from the virt-viewer package and a graphical desktop from where you run virtctl
kubectl virt vnc VM_NAME

Substitua VM_NAME pelo nome da VM que você quer acessar.

Acesso interno

Os endereços IP das VMs do cluster podem ser acessados diretamente por todos os outros pods no cluster. Para encontrar o endereço IP de uma VM, execute:

kubectl get vmi VM_NAME

Substitua VM_NAME pelo nome da VM que você quer acessar.

O comando retorna algo como:

NAME     AGE   PHASE     IP              NODENAME
vm1      13m   Running   192.168.1.194   upgi-bm002

Acesso externo

As VMs criadas no cluster têm endereços de rede de pods que só podem ser acessados de dentro do cluster. Para acessar VMs de cluster externamente:

  1. Exponha a VM como um serviço de balanceador de carga:

    kubectl virt expose vm VM_NAME \
        --port=LB_PORT \
        --target-port=VM_PORT \
        --type=LoadBalancer \
        --name=SERVICE_NAME
    

    Substitua:

    • VM_NAME pelo nome da VM que você quer acessar.
    • LB_PORT pela porta do serviço de balanceador de carga exposto.
    • VM_PORT pela porta da VM que você quer acessar por meio do serviço de balanceador de carga.
    • SERVICE_NAME pelo nome que você quer dar a esse serviço de balanceador de carga.
  2. Consiga o endereço IP externo do serviço do balanceador de carga:

    kubectl get svc SERVICE_NAME
    

    Substitua SERVICE_NAME pelo nome do serviço do balanceador de carga que expõe a VM.

    É possível acessar a porta de destino da VM por meio do endereço IP listado no campo EXTERNAL-IP da resposta.

Exemplo

Se você tiver uma VM chamada galaxy que quer acessar fora do cluster usando SSH, execute:

kubectl virt expose vm galaxy \
   --port=25022 \
   --target-port=22 \
   --type=LoadBalancer \
   --name=galaxy-ssh

Busque o endereço IP do balanceador de carga:

kubectl get svc galaxy-ssh

O comando retorna algo como:

NAME        TYPE          CLUSTER-IP     EXTERNAL-IP   PORT(S)           AGE
galaxy-ssh  LoadBalancer  10.96.250.76   21.1.38.202   25000:30499/TCP   4m40s

Agora é possível acessar a VM usando SSH por meio de 21.1.38.202:25022 (VIP:port) de fora do cluster:

ssh root@21.1.38.202:22 -p 25022

Inspecionar a telemetria da VM e os registros do console

Os registros de telemetria e console da VM foram integrados ao Console do Cloud. As informações de telemetria e os dados de registro são essenciais para monitorar o status das VMs e solucionar problemas com as VMs do cluster.

Telemetria da VM

O painel status da VM dos clusters do Anthos fornece dados de telemetria em tempo real para as VMs do cluster.

Para ver informações de telemetria das VMs do cluster:

  1. No Console do Cloud, selecione Monitoring ou clique neste botão:

    Acessar Monitoring

  2. Selecione Painéis.

    Painel de status da VM do cluster do Anthos na lista de painéis do Monitoring

  3. Clique em Status da VM dos clusters do Anthos na lista Todos os painéis.

    Detalhes do status da VM do cluster do Anthos

Registros do console da VM

Os registros do console em série da VM são transmitidos por streaming para o Cloud Logging e podem ser vistos no Explorador de registros.

Explorador de registros mostrando dados da VM do cluster Anthos

Excluir VMs e os recursos delas

Como excluir apenas a VM

kubectl virt delete vm VM_NAME

Substitua VM_NAME pelo nome da VM que você quer excluir.

Como excluir apenas discos da VM

kubectl virt delete disk DISK_NAME

Substitua DISK_NAME pelo nome do disco que você quer excluir. Se você tentar excluir um disco da VM antes de excluí-la, o disco será marcado para exclusão após a exclusão da VM.

Como excluir VMs e recursos

kubectl virt delete vm VM_NAME --all

Substitua VM_NAME pelo nome da VM que você quer excluir.

Se você quiser verificar os recursos usados pela VM que serão excluídos, especifique a sinalização --dry-run com --all.

Desativar ambiente de execução de VM do Anthos

Antes de desativar o ambiente de execução da VM do Anthos em um cluster, verifique se todas as VMs nesse cluster foram excluídas. A desativação do ambiente de execução do Anthos VM remove todas as implantações relacionadas ao KubeVirt, como pods e serviços nos namespaces do KubeVirt e do CDI.

  1. Verifique se há VMs existentes no cluster:

    kubectl get vm
    

    Se o comando mostrar que ainda há VMs no cluster, será necessário excluí-las antes de continuar.

  2. Abra a configuração do cluster executando:

    kubectl --kubeconfig bmctl-workspace/CLUSTER_NAME/CLUSTER_NAME-kubeconfig edit cluster CLUSTER_NAME -n cluster-CLUSTER_NAME
    

    Substitua CLUSTER_NAME pelo nome do cluster.

  3. Remova kubevirt da seção spec da configuração do cluster.

    spec:
      anthosBareMetalVersion: 1.8.3
      kubevirt:
        useEmulation: true
      bypassPreflightCheck: false
    
  4. Salve a configuração.

A seguir