Kubevirt executando VMs em um cluster Kubernetes

Parece que fechamos o círculo à medida que o Kubernetes amadureceu e foi bastante ampliado nos últimos anos para fazer coisas realmente incríveis. Uma das coisas incríveis que você pode fazer agora com o Kubernetes é executar máquinas virtuais. Kubevirt torna isso possível. Neste post, vamos dar uma olhada no Kubevirt e sua funcionalidade.

O que é Kubevirt?

Vamos falar sobre Kubevirt e o que é exatamente. Kubevirt é uma solução de código aberto que permite que clusters Kubernetes executem e gerenciem máquinas virtuais, incluindo Linux e Windows, juntamente com cargas de trabalho de contêineres nativas do Kubernetes (pods) e permite que os desenvolvedores coloquem aplicativos em contêineres rapidamente. As empresas estão procurando maneiras de padronizar sua infraestrutura e usar ferramentas consistentes. Usar o Kubernetes para contêineres e máquinas virtuais ajuda nesse esforço.

Kubevirt fornece uma API de virtualização, permitindo que a API Kubernetes controle contêineres e várias máquinas virtuais, fornecendo uma plataforma de desenvolvimento unificada para ambos. Kubevirt faz parte da base de computação nativa em nuvem e conta com muitos colaboradores da comunidade.

Por que os desenvolvedores podem querer usar o Kubevirt?

Para equipes de desenvolvimento em transição para infraestrutura Kubernetes e computação em nuvem, especialmente aquelas com cargas de trabalho existentes baseadas em máquinas virtuais (VM) com instalações de sistemas operacionais convidados que não são fáceis de conteinerizar. KubeVirt preenche a lacuna entre as configurações tradicionais de VM e os ambientes modernos em contêineres para fluxos de trabalho de desenvolvimento até produção. Com o Kubevirt, você não precisa mais de um ambiente de hipervisor separado para executar as cargas de trabalho de suas máquinas virtuais. Também permite interagir com seus recursos do Kubernetes usando ferramentas padrão como kubectl.

A tecnologia Kubevirt proporciona uma transição mais suave e rápida para equipes com fluxos de trabalho baseados em máquinas virtuais para conteinerizar rapidamente cargas de trabalho virtualizadas. Ele permite que as equipes usem VMs de máquinas virtuais existentes para aplicativos enquanto trabalham em uma estratégia para implantar aplicativos residentes em arquiteturas baseadas em contêineres.

Arquitetura Kubevirt

Os usuários que interagem com os serviços de virtualização se comunicam por meio da API de virtualização para organizar as instâncias de máquina virtual (VMIs) desejadas. Com o Kubevirt, o Kubernetes é responsável por gerenciar agendamento, rede e armazenamento de dados para suas máquinas virtuais.

A seguir está um diagrama simplificado que mostra os princípios básicos de como os controladores e daemons adicionais se comunicam com o Kubernetes e onde os tipos adicionais são armazenados. A arquitetura do Kubevirt integra-se aos clusters Kubernetes existentes, aproveitando os componentes virtualizados restantes. Essa integração é possível graças ao Operador Kubevirt e às Definições de recursos personalizados (CRDs) que ampliam os recursos do Kubernetes.

Como você pode usar o Kubevirt?

Existem várias distribuições do Kubernetes que você pode usar para experimentar o Kubevirt e fornecer feedback sobre as soluções. Observe os seguintes guias de início rápido fornecidos por Kubevirt.io:

Colheitadeira Rancher: Kubevirt Fácil

Além disso, se você deseja uma solução dedicada para experimentar o Kubevirt de maneira fácil, o Rancher Harvester é uma solução de código aberto, contendo todos os pacotes necessários para executar o software Kubevirt que permite instalar o Harvester em servidores físicos ou máquinas virtuais aninhadas. Ele fornece gerenciamento de máquina virtual junto com a execução de pods nativos do Kubernetes e extração de imagens de contêiner do registro de contêiner.

Usando Kubevirt com Harvester, você pode executar suas VMs com construções de escalabilidade, segurança, rbac e desempenho para seu ambiente de carga de trabalho, da mesma forma que faria com seus pods de contêiner. Você pode dar uma olhada no projeto e na documentação do Harvester aqui: Harvester – Infraestrutura hiperconvergente de código aberto (harvesterhci.io). Você também pode conferir os repositórios e lançamentos oficiais aqui: GitHub – colheitadeira/colheitadeira: software de infraestrutura hiperconvergente (HCI) de código aberto.

Abaixo, inicializei o Harvester ISO e criei um novo cluster Harvester em seus nós.

Depois de instalar o Rancher Harvester e aguardar que o cluster Harvester e o IP de gerenciamento estejam prontos.

Fazendo login no Harvester.

Abaixo, criei uma nova máquina virtual Ubuntu 22.04 e inicializei a VM para instalação usando Kubevirt no Harvester. Muito legal! A experiência de gerenciamento no Harvester é ótima.

Configuração de arquivo YAML para máquina virtual Kubevirt

Uma das coisas muito legais de usar o Kubevirt para criar máquinas virtuais é a capacidade de descrevê-las em um arquivo YAML. Criando uma VM Ubuntu 22.04 LTS no Harvester, tive o seguinte código YAML para o manifesto da VM como exemplo na demonstração acima:

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  annotations:
    harvesterhci.io/vmRunStrategy: RerunOnFailure
    harvesterhci.io/volumeClaimTemplates: >-
      ({"metadata":{"name":"ubuntu-01-disk-0-fhsec","annotations":{"harvesterhci.io/imageId":"default/image-675pg"}},"spec":{"accessModes":("ReadWriteMany"),"resources":{"requests":{"storage":"20Gi"}},"volumeMode":"Block","storageClassName":"longhorn-image-675pg"}})
    kubevirt.io/latest-observed-api-version: v1
    kubevirt.io/storage-observed-api-version: v1alpha3
    network.harvesterhci.io/ips: '()'
  creationTimestamp: '2024-01-21T14:45:14Z'
  finalizers:
    - harvesterhci.io/VMController.UnsetOwnerOfPVCs
  generation: 2
  labels:
    harvesterhci.io/creator: harvester
    harvesterhci.io/os: ubuntu
  managedFields:
    - apiVersion: kubevirt.io/v1alpha3
      fieldsType: FieldsV1
      fieldsV1:
        f:metadata:
          f:annotations:
            f:kubevirt.io/latest-observed-api-version: {}
            f:kubevirt.io/storage-observed-api-version: {}
      manager: Go-http-client
      operation: Update
      time: '2024-01-21T14:45:15Z'
    - apiVersion: kubevirt.io/v1
      fieldsType: FieldsV1
      fieldsV1:
        f:metadata:
          f:annotations:
            .: {}
            f:harvesterhci.io/vmRunStrategy: {}
            f:harvesterhci.io/volumeClaimTemplates: {}
            f:network.harvesterhci.io/ips: {}
          f:finalizers:
            .: {}
            v:"harvesterhci.io/VMController.UnsetOwnerOfPVCs": {}
          f:labels:
            .: {}
            f:harvesterhci.io/creator: {}
            f:harvesterhci.io/os: {}
        f:spec:
          .: {}
          f:runStrategy: {}
          f:template:
            .: {}
            f:metadata:
              .: {}
              f:annotations:
                .: {}
                f:harvesterhci.io/sshNames: {}
              f:labels:
                .: {}
                f:harvesterhci.io/vmName: {}
            f:spec:
              .: {}
              f:accessCredentials: {}
              f:affinity: {}
              f:domain:
                .: {}
                f:cpu:
                  .: {}
                  f:cores: {}
                  f:sockets: {}
                  f:threads: {}
                f:devices:
                  .: {}
                  f:disks: {}
                  f:inputs: {}
                  f:interfaces: {}
                f:features:
                  .: {}
                  f:acpi:
                    .: {}
                    f:enabled: {}
                f:machine:
                  .: {}
                  f:type: {}
                f:resources:
                  .: {}
                  f:limits:
                    .: {}
                    f:cpu: {}
                    f:memory: {}
              f:evictionStrategy: {}
              f:hostname: {}
              f:networks: {}
              f:terminationGracePeriodSeconds: {}
              f:volumes: {}
      manager: harvester
      operation: Update
      time: '2024-01-21T14:45:36Z'
    - apiVersion: kubevirt.io/v1alpha3
      fieldsType: FieldsV1
      fieldsV1:
        f:status:
          .: {}
          f:conditions: {}
          f:created: {}
          f:printableStatus: {}
          f:ready: {}
          f:volumeSnapshotStatuses: {}
      manager: Go-http-client
      operation: Update
      subresource: status
      time: '2024-01-21T15:03:12Z'
  name: ubuntu-01
  namespace: default
  resourceVersion: '538511'
  uid: 3e3f0426-a70b-427b-8aba-113b3fa2a5e7
spec:
  runStrategy: RerunOnFailure
  template:
    metadata:
      annotations:
        harvesterhci.io/sshNames: '()'
      creationTimestamp: null
      labels:
        harvesterhci.io/vmName: ubuntu-01
    spec:
      affinity: {}
      domain:
        cpu:
          cores: 2
          sockets: 1
          threads: 1
        devices:
          disks:
            - bootOrder: 1
              cdrom:
                bus: sata
              name: disk-0
            - disk:
                bus: virtio
              name: cloudinitdisk
          inputs:
            - bus: usb
              name: tablet
              type: tablet
          interfaces:
            - macAddress: 52:54:00:de:68:02
              masquerade: {}
              model: virtio
              name: default
        features:
          acpi:
            enabled: true
        machine:
          type: q35
        memory:
          guest: 1948Mi
        resources:
          limits:
            cpu: '2'
            memory: 2Gi
          requests:
            cpu: 125m
            memory: 1365Mi
      evictionStrategy: LiveMigrate
      hostname: ubuntu-01
      networks:
        - name: default
          pod: {}
      terminationGracePeriodSeconds: 120
      volumes:
        - name: disk-0
          persistentVolumeClaim:
            claimName: ubuntu-01-disk-0-fhsec
        - cloudInitNoCloud:
            networkDataSecretRef:
              name: ubuntu-01-ixwie
            secretRef:
              name: ubuntu-01-ixwie
          name: cloudinitdisk
status:
  conditions:
    - lastProbeTime: null
      lastTransitionTime: '2024-01-21T15:03:09Z'
      status: 'True'
      type: Ready
    - lastProbeTime: null
      lastTransitionTime: null
      status: 'True'
      type: LiveMigratable
  created: true
  printableStatus: Running
  ready: true
  volumeSnapshotStatuses:
    - enabled: false
      name: disk-0
      reason: 2 matching VolumeSnapshotClasses for longhorn-image-675pg
    - enabled: false
      name: cloudinitdisk
      reason: Snapshot is not supported for this volumeSource type (cloudinitdisk)

Usando a interface de linha de comando virtctl

Você também pode interagir com suas máquinas virtuais Kubevirt usando a ferramenta de linha de comando virtctl. Pode ser necessário instalar o virtctl. Porém, ao trabalhar com o Harvester, ele é instalado por padrão.

Observe os seguintes comandos:

• adicionar volume – adicionar um volume a uma VM em execução
• conclusão – gera o script de preenchimento automático para o shell especificado
• console – conectar-se a um console de uma instância de máquina virtual
• expor – expor uma instância de máquina virtual, uma máquina virtual ou um conjunto de réplicas de instância de máquina virtual como um novo serviço
• lista fs – retorna a lista completa de sistemas de arquivos disponíveis na máquina convidada
• convidados – inicia um shell no pod libguestfs
• guestosinfo – retornar informações do agente convidado sobre o sistema operacional
• ajuda – ajuda sobre qualquer comando
• imagem-upload – carrega uma imagem VM para um DataVolume/PersistentVolumeClaim
• memória–jogar fora – despejar a memória de uma VM em execução em um determinado pvc
• migrar – migrar uma máquina virtual
• migrar–cancelar – cancelar a migração de uma máquina virtual
• pausa – passe uma máquina virtual
• permitido–dispositivos – liste os dispositivos permitidos para vmis
• porta–avançar – encaminhar portas locais para uma máquina virtual ou instância de máquina virtual
• remover volume – remover um volume de uma VM em execução
• reiniciar – reiniciar uma máquina virtual
• scp – arquivos scp de/para uma instância de máquina virtual
• macio–reinício – reinicialização suave de uma instância de máquina virtual
• ééh – abre uma conexão SSH para uma instância de máquina virtual
• começar – iniciar uma máquina virtual
• parar – parar uma máquina virtual
• retomar – retomar uma máquina virtual
• usbredir – redirecionar um dispositivo USB para uma instância de máquina virtual
• Lista de usuários – retornar lista completa de usuários logados na máquina convidada
• versão – imprimir as informações da versão do cliente e do servidor
• vnc – abrir uma conexão vnc para uma instância de máquina virtual

Perguntas frequentes sobre máquinas virtuais Kubevirt e Kubernetes

Resumindo o Kubevirt como uma excelente ferramenta no ecossistema Kubernetes

Neste blog de introdução ao Kubevirt, vimos que é uma ferramenta interessante e poderosa para executar ambientes Kubernetes. Ele permite que uma empresa aproveite o poder de aplicativos modernos em pods e máquinas virtuais do Kubernetes no nó do cluster Kubernetes para todas as suas necessidades de virtualização. Isso faz do Kubernetes não apenas um ambiente para contêineres, mas também para VMs.

Como ele usa a API Kubernetes, os desenvolvedores e engenheiros de DevOps podem usar as poderosas APIs Kubernetes para automatizar muitos aspectos do ambiente, incluindo políticas, e aplicar esses mesmos endpoints de API para automatizar suas operações de máquina virtual. Como a execução do Kubernetes está se tornando cada vez mais interessante e usada por organizações em todo o mundo, estou me perguntando quantas estão interessadas em migrar dos hipervisores tradicionais e usar o Kubernetes para tudo. Se você já migrou VMs para Kubernetes, quais resultados você viu e quais problemas encontrou? Você está usando isso ou está interessado em usar no núcleo ou na borda? Há algum recurso que está faltando entre o Kubevirt e os produtos hipervisores tradicionais? Deixe-me saber nos comentários ou nos fóruns.