Solução de problemas de máquinas virtuais

Esta página aborda a solução de problemas da máquina virtual (VM) para o operador de aplicativos (AO) no dispositivo isolado do Google Distributed Cloud (GDC).

Recuperar um disco de inicialização de VM completo

Se uma VM ficar sem espaço no disco de inicialização, por exemplo, quando um aplicativo preencher a partição do disco de inicialização com registros, os recursos críticos das VMs não vão funcionar. Talvez não seja possível adicionar uma nova chave SSH usando o recurso VirtualMachineAccessRequest ou estabelecer uma conexão SSH com a VM usando chaves atuais.

Nesta página, descrevemos as etapas para criar uma nova VM e anexar o disco para recuperar o conteúdo em uma nova VM como um disco adicional. Essas etapas demonstram o seguinte:

  • Uma conexão SSH bem-sucedida com a nova VM.
  • Aumente o espaço montando o disco para recuperar e excluir dados desnecessários.
  • Exclua a nova VM e substitua o disco original na VM original.

Antes de começar

Antes de continuar, verifique se você solicitou acesso à VM no nível do projeto. Siga as etapas fornecidas para atribuir o papel de administrador de máquina virtual do projeto (project-vm-admin).

Para operações de VM usando a CLI gdcloud, peça ao administrador do IAM do projeto para atribuir a você o papel de administrador de máquina virtual do projeto e o papel de leitor do projeto (project-viewer).

Para usar os comandos da interface de linha de comando (CLI) gdcloud, verifique se você baixou, instalou e configurou a CLI gdcloud. Todos os comandos para o dispositivo isolado do GDC usam a CLI gdcloud ou kubectl e exigem um ambiente de sistema operacional (SO).

Extrair o caminho do arquivo kubeconfig

Para executar comandos no servidor da API Management, verifique se você tem os seguintes recursos:

  1. Localize o nome do servidor da API Management ou pergunte ao administrador da plataforma (PA) qual é o nome do servidor.

  2. Faça login e gere o arquivo kubeconfig para o servidor da API Management se você não tiver um.

  3. Use o caminho para substituir MANAGEMENT_API_SERVER{"</var>"}} nestas instruções.

Recuperar um disco de VM sem espaço

Para recuperar um disco de inicialização de VM sem espaço, siga estas etapas:

  1. Pare a VM atual seguindo as instruções em Parar uma VM.

  2. Edite a VM:

    kubectl --kubeconfig ADMIN_KUBECONFIG edit \
    virtualmachine.virtualmachine.gdc.goog -n PROJECT VM_NAME

    Substitua o nome do disco da VM atual no campo spec por um novo nome de marcador de posição:

    ...
spec:
  disks:
  - boot: true
    virtualMachineDiskRef:
      name: VM_DISK_PLACEHOLDER_NAME

  3. Crie uma nova VM com um sistema operacional (SO) de imagem diferente da VM original. Por exemplo, se o disco original usar o SO ubuntu-2004, crie a nova VM com rocky-8.

  4. Anexe o disco original como um disco adicional à nova VM:

    ...
spec:
  disks:
  - boot: true
    autoDelete: true
    virtualMachineDiskRef:
      name: NEW_VM_DISK_NAME
  - virtualMachineDiskRef:
      name: ORIGINAL_VM_DISK_NAME

    Substitua:

    • NEW_VM_DISK_NAME: o nome que você dá ao novo disco da VM.
    • ORIGINAL_VM_DISK_NAME: o nome do disco da VM original.

  5. Depois de criar a VM e ela estiver em execução, estabeleça uma conexão SSH com ela seguindo as instruções em Conectar-se a uma VM.

  6. Crie um diretório e monte o disco original em um ponto de montagem. Por exemplo, /mnt/disks/new-disk.

  7. Verifique os arquivos e diretórios no diretório de montagem usando espaço extra:

    cd /mnt/disks/MOUNT_DIR
du -hs -- * | sort -rh | head -10

    Substitua MOUNT_DIR pelo nome do diretório em que você montou o disco original.

    O resultado será assim:

    18G   home
1.4G  usr
331M  var
56M   boot
5.8M  etc
36K   snap
24K   tmp
16K   lost+found
16K   dev
8.0K  run

  8. Verifique cada um dos arquivos e diretórios para conferir a quantidade de espaço que cada um está usando. Este exemplo verifica o diretório home, já que ele usa 18G de espaço.

    cd home
du -hs -- * | sort -rh | head -10

    O resultado será assim:

    17G   log_file
...
4.0K  readme.md
4.0K  main.go

    O arquivo de exemplo log_file é um arquivo a ser limpo, já que consome 17G de espaço e não é necessário.

  9. Exclua os arquivos desnecessários que consomem espaço extra ou faça backup dos arquivos no novo disco de inicialização da VM:

    • Mova os arquivos que você quer manter:

      mv /mnt/disks/MOUNT_DIR/home/FILENAME/home/backup/

    • Exclua os arquivos que consomem espaço extra:

      rm /mnt/disks/MOUNT_DIR/home/FILENAME

      Substitua FILENAME pelo nome do arquivo que você quer mover ou excluir.

  10. Saia da nova VM e interrompa a VM.

  11. Edite a nova VM para remover o disco original do campo spec:

    kubectl --kubeconfig ADMIN_KUBECONFIG \
    edit virtualmachine.virtualmachine.gdc.goog -n PROJECT NEW_VM_NAME

    Remova a lista virtualMachineDiskRef que contém o nome do disco da VM original:

    spec:
  disks:
  - autoDelete: true
    boot: true
    virtualMachineDiskRef:
      name: NEW_VM_DISK_NAME
  - virtualMachineDiskRef: # Remove this list
      name: ORIGINAL_VM_DISK_NAME # Remove this disk name

  12. Edite a VM original e substitua VM_DISK_PLACEHOLDER_NAME definido na etapa dois pelo nome anterior:

    ...
spec:
  disks:
  - boot: true
    virtualMachineDiskRef:
      name: VM_DISK_PLACEHOLDER_NAME # Replace this name with the previous VM name

  13. iniciar a VM original; Se você liberou espaço suficiente, a VM será inicializada com sucesso.

  14. Se você não precisar da nova VM, exclua-a:

    kubectl --kubeconfig ADMIN_KUBECONFIG \
    delete virtualmachine.virtualmachine.gdc.goog -n PROJECT NEW_VM_NAME

Provisionar uma máquina virtual

Nesta seção, descrevemos como solucionar problemas que podem ocorrer ao provisionar uma nova máquina virtual (VM) no appliance isolado do Google Distributed Cloud (GDC).

O operador de aplicativo (AO) precisa executar todos os comandos no cluster de usuário padrão.

Não foi possível criar o disco

Se um PersistentVolumeClaim (PVC) estiver no estado Pending, revise as seguintes alternativas para resolver o estado:

  • A classe de armazenamento não é compatível com a criação de um PVC com o modo de acesso ReadWriteMany:

    1. Atualize o valor spec.dataVolumeTemplate.spec.pvc.storageClassName da máquina virtual com uma classe de armazenamento que ofereça suporte a um modo de acesso ReadWriteMany e use um driver da interface de armazenamento em contêiner (CSI) como provisionador de armazenamento.

    2. Se nenhuma outra classe de armazenamento no cluster puder fornecer a capacidade ReadWriteMany, atualize o valor spec.dataVolumeTemplate.spec.pvc.accessMode para incluir o modo de acesso ReadWriteOnce.

  • O driver CSI não consegue provisionar um PersistentVolume:

    1. Verifique se há uma mensagem de erro:

      kubectl describe pvc VM_NAME-boot-dv -n NAMESPACE_NAME

      Substitua as seguintes variáveis:

      • VM_NAME: o nome da máquina virtual.
      • NAMESPACE_NAME: o nome do namespace.

    2. Configure o driver para resolver o erro. Para garantir que o provisionamento de PersistentVolume funcione, crie um PVC de teste em um novo spec com um nome diferente do especificado em dataVolumeTemplate.spec.pvc:

      cat <<EOF | kubectl apply -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
  namespace: NAMESPACE_NAME
spec:
  storageClassName: standard-rwx
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
EOF

    3. Depois que o provisionamento do objeto PersistentVolume for concluído, exclua o PVC de teste após a verificação:

      kubectl delete pvc test-pvc -n NAMESPACE_NAME

Não é possível criar uma máquina virtual

Se o recurso de máquina virtual for aplicado, mas não chegar a um estado Running, siga estas etapas:

  1. Analise os registros da máquina virtual:

    kubectl get vm VM_NAME -n NAMESPACE_NAME

  2. Verifique o status do pod correspondente da máquina virtual:

    kubectl get pod -l kubevirt.io/vm=VM_NAME

    A saída mostra um status do pod. As opções possíveis são as seguintes:

O estado ContainerCreating

Se o pod estiver no estado ContainerCreating, siga estas etapas:

  1. Receba mais detalhes sobre o estado do pod:

    kubectl get pod -l kubevirt.io/vm=VM_NAME

  2. Se os volumes estiverem desmontados, verifique se todos os volumes especificados no campo spec.volumes foram montados corretamente. Se o volume for um disco, verifique o status dele.

  3. O campo spec.accessCredentials especifica um valor para montar uma chave pública SSH. Verifique se o secret foi criado no mesmo namespace que a máquina virtual.

Se não houver recursos suficientes no cluster para criar o pod, siga estas etapas:

  1. Se o cluster não tiver recursos de computação suficientes para programar o pod da máquina virtual, remova outros pods indesejados para liberar recursos.

  2. Reduza os valores spec.domain.resources.requests.cpu e spec.domain.resources.requests.memory da máquina virtual.

O estado Error ou CrashLoopBackoff

Para resolver pods nos estados Error ou CrashLoopBackoff, recupere os registros do pod de computação da máquina virtual:

kubectl logs -l  kubevirt.io/vm=VM_NAME  -c compute

O estado Running e a falha da máquina virtual

Se o pod estiver no estado Running, mas a máquina virtual falhar, siga estas etapas:

  1. Confira os registros do pod de registro da máquina virtual:

    kubectl logs -l  kubevirt.io/vm=VM_NAME  -c log

  2. Se o registro mostrar erros na inicialização da máquina virtual, verifique o dispositivo de inicialização correto dela. Defina o valor spec.domain.devices.disks.bootOrder do disco de inicialização principal com o valor de 1. Use o exemplo a seguir como referência:

    …
  spec:
      domain:
        devices:
          disks:
          - bootOrder: 1
            disk:
              bus: virtio
            name: VM_NAME-boot-dv
  …

Para resolver problemas de configuração com a imagem da máquina virtual, crie outra máquina virtual com uma imagem diferente.

Acessar o console serial

Nesta seção, descrevemos como usar o console serial de uma instância de VM para depurar problemas de inicialização e rede, resolver problemas em instâncias com mau funcionamento, interagir com o Grand Unified Bootloader (GRUB) e realizar outras tarefas de solução de problemas.

Interagir com uma porta serial é comparável ao uso de uma janela de terminal: a entrada e a saída estão no modo de texto, sem suporte para interface gráfica. O sistema operacional (SO) da instância, a entrada e saída básicas (BIOS), geralmente grava a saída nas portas seriais e aceita entradas como comandos.

Para acessar o console serial, siga as seções abaixo:

Configurar nome de usuário e senha

Por padrão, as imagens de sistema do Linux do GDC não são configuradas para permitir logins baseados em senha para usuários locais.

Se a VM estiver executando uma imagem pré-configurada com login do console serial, você poderá configurar uma senha local na VM e fazer login pelo console serial. Em VMs do Linux do GDC, você configura o nome de usuário e a senha usando um script de inicialização salvo como um secret do Kubernetes durante ou após a criação da VM.

As instruções a seguir descrevem como configurar uma senha local após a criação da VM. Para configurar o nome de usuário e a senha, siga estas etapas:

  1. Crie um arquivo de texto.

  2. No arquivo de texto, configure o nome de usuário e a senha:

    #!/bin/bash
username="USERNAME"
password="PASSWORD"
sudo useradd -m -s /bin/bash "$username"
echo "$username:$password" | sudo chpasswd
sudo usermod -aG sudo "$username"

    Substitua:

    • USERNAME: o nome de usuário que você quer adicionar.
    • PASSWORD: a senha do nome de usuário Evite senhas básicas, já que alguns sistemas operacionais podem exigir um tamanho e uma complexidade mínimos.

  3. Crie o script de inicialização como um secret do Kubernetes:

    kubectl --kubeconfig=ADMIN_KUBECONFIG create secret \
generic STARTUP_SCRIPT_NAME -n PROJECT_NAMESPACE \
--from-file=STARTUP_SCRIPT_PATH

    Substitua:

    • PROJECT_NAMESPACE: o namespace do projeto em que a VM reside.
    • STARTUP_SCRIPT_NAME: the name you give to the startup script. For example,configure-credentials`.
    • STARTUP_SCRIPT_PATH: o caminho para o script de inicialização que contém o nome de usuário e a senha configurados.

  4. Pare a VM.

  5. Edite a especificação da VM:

    kubectl --kubeconfig=ADMIN_KUBECONFIG edit gvm \
-n PROJECT_NAMESPACE VM_NAME

    Substitua VM_NAME pelo nome da VM a ser adicionada ao script de inicialização.

  6. No campo startupScripts, adicione a referência ao secret do Kubernetes criado na etapa três:

    spec:
  compute:
    memory: 8Gi
    vcpus: 8
  disks:
  - boot: true
    virtualMachineDiskRef:
      name: disk-name 
  startupScripts:
  - name: STARTUP_SCRIPT_NAME
    scriptSecretRef:
      name: STARTUP_SCRIPT_NAME

  7. Iniciar a VM.

    • Se você estiver trabalhando em uma nova VM, pule esta etapa.

Acessar o console serial da VM

Para começar a acessar o console serial da VM, faça o seguinte:

  1. Conecte-se ao console serial:

    gdcloud compute connect-to-serial-port VM_NAME \
--project PROJECT_NAMESPACE

  2. Quando solicitado, digite o nome de usuário e a senha definidos em Configurar nome de usuário e senha.