Como se conectar a VMs que usam o Ambiente de execução de VM do Anthos

Este documento é destinado a proprietários de aplicativos que executam clusters do Anthos em bare metal. Neste documento, você verá como se conectar a máquinas virtuais (VMs) que usam o Ambiente de execução de VM do Anthos. É possível se conectar a VMs diretamente por um endereço IP ou usando ferramentas integradas para acesso SSH ou console.

Antes de começar

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

Configurar o acesso SSH sem senhas para VMs

O acesso SSH direto e sem senha à VM é facilitado por um agente convidado instalado pelo Anthos VM Runtime. Entre outras funções, o agente convidado instala e expira as chaves SSH. Esse recurso ativa um túnel SSH para acessar sua VM de clientes fora da rede do cluster.

Ativar o agente convidado

Para ativar o agente convidado:

  1. Verifique seu recurso personalizado VirtualMachine para confirmar se ele está configurado para ativar o agente convidado:

    kubectl get gvm VM_NAME -o yaml --kubeconfig KUBECONFIG
    

    O campo spec.osType precisa ser definido como o sistema operacional da VM, Linux ou Windows. A seção spec.guestEnvironment não pode ser configurada explicitamente como vazia. Se a seção estiver configurada como vazia (guestEnvironment: {}), será possível removê-la totalmente para ativar o agente convidado.

    O recurso personalizado VirtualMachine da VM que você quer acessar precisa ser assim:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachine
    metadata:
      name: sample-vm
    spec:
      compute:
        cpu:
          vcpus: 2
        memory:
          capacity: 4Gi
    ...
      osType: Linux
    ...
    
  2. Se necessário, use kubectl edit para atualizar o recurso personalizado VirtualMachine.

  3. Para verificar se o agente convidado está funcionando, confira o status no recurso personalizado da VM:

    kubectl get gvm VM_NAME --kubeconfig KUBECONFIG
    

    Quando o agente convidado estiver funcionando, você verá status: "True" para as condições GuestEnvironmentEnabled e GuestEnvironmentDataSynced.

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachine
    metadata:
      ...
      name: vm-sample-01
      ...
    status:
      conditions:
      - lastTransitionTime: "2022-10-05T22:40:26Z"
        message: ""
        observedGeneration: 1
        reason: UserConfiguration
        status: "True"
        type: GuestEnvironmentEnabled
      - lastTransitionTime: "2022-10-06T21:55:57Z"
        message: ""
        observedGeneration: 1
        reason: GuestEnvironmentDataSynced
        status: "True"
        type: GuestEnvironmentSynced
      ...
    

Ativar o acesso SSH sem senha

Para ativar o acesso SSH sem senha para sua VM:

  1. Crie um arquivo de manifesto de VirtualMachineAccessRequest, como vm-access-request.yaml, no editor de sua escolha:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineAccessRequest
    metadata:
      name: VMAR_NAME
      namespace: VM_NAMESPACE
    spec:
      vm: VM_NAME
      user: USERNAME
      ssh:
        key: PUBLIC_SSH_KEY
        ttl: EXPIRATION_TIME
    

    Substitua:

    • VMAR_NAME: o nome do recurso da solicitação de acesso.
    • VM_NAMESPACE: o namespace da VM que você quer acessar.
    • VM_NAME: o nome da VM que você quer acessar.
    • USERNAME: o nome de usuário do usuário que está acessando a VM.
    • PUBLIC_SSH_KEY: a chave pública para acesso ao SSH. Normalmente, é o conteúdo do arquivo id_rsa.pub.
    • EXPIRATION_TIME: o campo ttl (time to live) especifica o tempo de validade da chave SSH.

      Por exemplo, se você especificar 30m, a chave SSH expirará após 30 minutos.

      Essa sinalização usa as seguintes unidades:

      • s para segundos
      • m para minutos
      • h para horas
      • d para dias
  2. Use kubectl apply para criar o VirtualMachineAccessRequest usando o arquivo de manifesto. Por exemplo, se você nomeou seu arquivo de manifesto como vm-access-request.yaml,

    kubectl apply -f MANIFEST --kubeconfig KUBECONFIG
    

    Substitua:

    • MANIFEST: o nome do arquivo de manifesto da solicitação de acesso. Por exemplo, vm-access-request.yaml.
    • KUBECONFIG: o caminho para o arquivo kubeconfig do cluster que hospeda a VM que você está acessando.
  3. Para verificar se a configuração da solicitação de acesso foi bem-sucedida, verifique o status do VirtualMachineAccessRequest:

    kubectl get vmar VMAR_NAME -o yaml --kubeconfig KUBECONFIG
    

    Quando a configuração for bem-sucedida, a seção status incluirá state: configured:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachineAccessRequest
    metadata:
      ...
      annotations:
        kubectl.kubernetes.io/last-applied-configuration: |
          {"apiVersion":"vm.cluster.gke.io/v1","kind":"VirtualMachineAccessRequest",
          "metadata":{"annotations":{},"name":"vmar-sample","namespace":"default"},
          "spec":{"ssh":{"key":"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQ...jMLHFc=
              sample-user@sample-host","ttl":"5h"},"user":"sample-user","vm":"vm-sample-01"}}
      creationTimestamp: "2022-10-06T21:55:57Z"
      finalizers:
      - vm.cluster.gke.io/vmar-finalizer
      generation: 2
      name: vmar-sample
      namespace: default
      resourceVersion: "13033921"
      uid: 282d72ad-f48d-4e89-af22-336940ac9f58
    spec:
      ssh:
        key: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQ...jMLHFc= sample-user@sample-host
        ttl: 5m0s
      user: sample-user
      vm: vm-sample-01
    status:
      processedAt: "2022-10-06T21:55:57Z"
      state: configured
    

Desativar o agente convidado

Quando você cria uma nova VM e define o campo de osType, o agente convidado é ativado. Enquanto esse recurso estiver na visualização, é possível desativá-lo editando o recurso personalizado VirtualMachine. A desativação do agente convidado desativa o acesso SSH sem senha à VM.

Para desativar o agente convidado:

  1. Use kubectl para interromper a VM antes de fazer mudanças na configuração:

    kubectl virt stop VM_NAME --kubeconfig KUBECONFIG
    
  1. Edite o recurso da VM:

    kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG
    
  2. Atualize a configuração VirtualMachine para adicionar uma spec.guestEnvironment vazia explicitamente:

    apiVersion: vm.cluster.gke.io/v1alpha1
    kind: VirtualMachine
    metadata:
      name: vm-example
      namespace: default
    spec:
      compute:
      ...
      osType: Linux
      guestEnvironment: {}
    
  3. Salve e feche o manifesto da VM atualizado no editor.

  4. Use kubectl para iniciar a VM:

    kubectl virt start VM_NAME --kubeconfig KUBECONFIG
    

Conectar-se usando um endereço IP

Se a VM tiver um endereço IP acessível e você já tiver as credenciais para acessá-la, será possível se conectar usando um protocolo como SSH, VNC ou RDP.

Conectar pelo endereço IP

Para se conectar diretamente ao endereço IP da VM, use um dos seguintes métodos:

SSH

  1. Consulte os detalhes da VM para ver o endereço IP dela:

    kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
    

    Substitua os seguintes valores:

    • VM_NAME: o nome da sua VM.
    • VM_NAMESPACE: o namespace da sua VM.

    O exemplo de saída a seguir mostra as informações da VM e o endereço IP:

    NAME   STATUS    AGE   IP
    vm1    Running   7m    10.200.0.21
    
  2. Conecte-se à VM usando um cliente SSH:

    ssh USERNAME@IP_ADDRESS -i PATH_TO_KEY
    

    Substitua os seguintes valores:

    • USERNAME: o nome de usuário de uma conta na sua VM.
    • IP_ADDRESS: o endereço IP da VM recebido na etapa anterior.
    • PATH_TO_KEY: o caminho para a chave SSH privada.

VNC ou RDP

A computação de rede virtual (VNC, na sigla em inglês) e o protocolo de área de trabalho remota (RDP, na sigla em inglês) permitem usar o console gráfico para acessar a VM. Ao usar um endereço IP, é necessário ativar o VNC ou RDP no SO convidado antes de usar um deles para se conectar à VM. Para informações sobre como ativar e usar o VNC ou o RDP, consulte a documentação do SO convidado.

Também é necessário ter credenciais para fazer login na VM, como aquelas definidas para criar credenciais iniciais de usuário ao criar uma VM.

  1. Consulte os detalhes da VM para ver o endereço IP dela:

    kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
    

    Substitua os seguintes valores:

    • VM_NAME: o nome da sua VM.
    • VM_NAMESPACE: o namespace da sua VM.

    O exemplo de saída a seguir mostra as informações da VM e o endereço IP:

    NAME   STATUS    AGE   IP
    vm1    Running   7m    10.200.0.21
    
  2. Conecte-se ao endereço IP da VM recebida na etapa anterior usando uma ferramenta de cliente e a porta apropriada, como a porta VNC 5900 ou RDP 3389.

Conexão por um serviço

Se a VM se conectar ao pod-network padrão e não for possível se comunicar diretamente com o endereço IP da VM, exponha a VM por trás de um balanceador de carga Service.

  1. Crie um manifesto de Service, como my-service-load-balancer.yaml, no editor de sua escolha:

    nano my-service-load-balancer.yaml
    
  2. Copie e cole o seguinte manifesto YAML:

    apiVersion: v1
    kind: Service
    metadata:
      name: VM_NAME-service
    spec:
      selector:
        kubevirt/vm: VM_NAME
      ports:
      - name: PORT_NAME
        protocol: PROTOCOL_TYPE
        port: EXTERNAL_PORT
        targetPort: TARGET_PORT
      type: LoadBalancer
    

    Nesse tipo de manifesto Service, substitua os seguintes valores:

    • VM_NAME: o nome da VM a ser exposta para acesso remoto.
    • PORT_NAME: o nome do protocolo, como ssh, vnc ou rdp.
    • PROTOCOL_TYPE: o tipo de protocolo, como tcp para SSH e RDP ou udp para VNC.
    • EXTERNAL_PORT: o número da porta externa a ser exposta e ao qual você se conecta.
    • TARGET_PORT: a porta de destino, como 22 para SSH.
  3. Salve e feche o manifesto Service no seu editor.

  4. Crie Service usando kubectl:

    kubectl apply -f my-service-load-balancer.yaml  --kubeconfig KUBECONFIG
    
  5. Consiga o endereço EXTERNAL-IP do serviço do balanceador de carga:

    kubectl get service VM_NAME-service --kubeconfig KUBECONFIG
    

    O endereço IP do balanceador de carga é exibido, conforme mostrado no exemplo de saída a seguir:

    NAME          TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
    vm1-service   LoadBalancer   172.26.232.167   10.200.0.51   22:31141/TCP   6d20h
    
  6. Conecte-se ao endereço EXTERNAL-IP do balanceador de carga com um protocolo padrão, como o uso de um cliente SSH:

    ssh USERNAME@LOAD_BALANCER_IP_ADDRESS  -i PATH_TO_KEY
    

    Substitua os seguintes valores:

    • USERNAME: o nome de usuário de uma conta na sua VM.
    • LOAD_BALANCER_IP_ADDRESS: o endereço IP do balanceador de carga.
    • PATH_TO_KEY: o caminho para a chave SSH privada.

Conectar-se diretamente usando SSH

Se o cliente estiver conectado à mesma rede física que o cluster do Anthos em nós bare metal e você não precisar do uso de túneis SSH para se conectar ao cluster, use kubectl virt ssh.

  1. Se quiser usar SSH para conectar uma VM do Linux no console com o complemento virtctl:

    kubectl virt ssh USERNAME@VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
    

    Substitua os seguintes valores:

    • USERNAME: o nome de usuário para acessar sua VM. Essa conta será criada se não existir na VM.
    • VM_NAME: o nome da VM.
  2. Depois de se conectar usando a VM por SSH e não precisar mais da conexão, saia da sessão SSH:

    exit
    

Conectar-se diretamente usando o console

Se você não tiver conectividade de rede direta com a VM Linux para acesso SSH, conecte-se ao console da VM usando o console do Ambiente de execução de VM do Anthos. Esse método abre um console serial. Após a conexão, você recebe um prompt de comando, em vez de um console gráfico.

  1. Para acessar uma VM do Linux no console, use o complemento virtctl:

    kubectl virt console VM_NAME --kubeconfig KUBECONFIG
    

    Substitua VM_NAME pelo nome da VM.

    Quando solicitado, digite as credenciais de usuário da VM. Essas credenciais precisam existir na VM ou ser aplicadas quando ela for criada. Se necessário, consulte a seção a seguir para criar credenciais iniciais de usuário ao criar uma VM.

  2. Depois de se conectar ao console da VM e não precisar mais da conexão, saia da sessão e do console da VM:

    Ctrl + ]
    

Conectar-se diretamente com o VNC

É possível usar o comando kubectl virt vnc para abrir o console gráfico de Computação de rede virtual (VNC, na sigla em inglês) para acessar suas VMs. Esse método funciona para VMs que executam um SO convidado do Windows ou do Linux. Quando você usa o comando kubectl virt vnc, o Anthos VM Runtime abre o VNC para você, então não é necessário ativar o VNC no SO convidado.

Também é necessário ter credenciais para fazer login na VM, como aquelas definidas para criar credenciais iniciais de usuário ao criar uma VM.

  1. Para acessar uma VM com o VNC, use o complemento virtctl:

    kubectl virt vnc VM_NAME --kubeconfig KUBECONFIG
    

    Substitua VM_NAME pelo nome da VM.

    Quando solicitado, digite as credenciais de usuário da VM.

  2. Depois de se conectar à sessão de VNC da VM e não precisar mais da conexão, saia dela para encerrar a conexão do VNC.

Criar credenciais iniciais de usuário

Ao se conectar à VM usando o console, especifique as credenciais do usuário. O processo para criar credenciais iniciais de usuário é diferente para sistemas operacionais convidados com Linux e Windows.

SO convidado do Linux

Para VMs do Linux, as credenciais do usuário podem ser integradas às suas imagens personalizadas ou ser especificadas ao criar uma VM.

  • Use o parâmetro --configure-initial-password com o comando kubectl virt create:

    kubectl virt create vm VM_NAME \
        --image ubuntu20.04 \
        --os-type Linux \
        --configure-initial-password USERNAME:PASSWORD \
        --kubeconfig KUBECONFIG
    

    Substitua os seguintes valores:

    • VM_NAME: o nome da sua VM.
    • USERNAME: o nome de usuário da conta a ser criada na VM.
    • PASSWORD: senha da conta de usuário.

    Esse exemplo de comando cria uma VM Linux que executa o Ubuntu 20.04. É recomendável alterar as credenciais iniciais depois de fazer login pela primeira vez na VM.

A seguir