Esta página se ha traducido con Cloud Translation API.

Solución de problemas de máquinas virtuales

En esta página se explica cómo solucionar problemas de la máquina virtual (VM) del operador de aplicaciones (AO) en el dispositivo con espacio de aire de Google Distributed Cloud (GDC).

Recuperar un disco de arranque de una VM completa

Si una VM se queda sin espacio en el disco de arranque (por ejemplo, cuando una aplicación llena la partición del disco de arranque con registros), las funciones críticas de las VMs no funcionarán. Es posible que no puedas añadir una clave SSH nueva a través del recurso VirtualMachineAccessRequest ni establecer una conexión SSH con la VM mediante claves ya existentes.

En esta página se describen los pasos para crear una VM y adjuntar el disco para recuperar el contenido en una nueva VM como disco adicional. Estos pasos muestran lo siguiente:

Una conexión SSH correcta a la nueva VM.
Aumenta la cantidad de espacio montando el disco para recuperar y eliminar los datos innecesarios.
Elimina la nueva VM y sustituye el disco original por la VM original.

Antes de empezar

Antes de continuar, asegúrate de solicitar acceso a las máquinas virtuales a nivel de proyecto. Sigue los pasos indicados para asignar el rol Administrador de máquinas virtuales de proyecto (project-vm-admin).

Para realizar operaciones con máquinas virtuales mediante la interfaz de línea de comandos gdcloud, pide al administrador de gestión de identidades y accesos de tu proyecto que te asigne el rol Administrador de máquinas virtuales del proyecto y el rol Lector del proyecto (project-viewer).

Para usar los comandos de la gdcloud interfaz de línea de comandos (CLI), asegúrate de haber descargado, instalado y configurado la gdcloud CLI. Todos los comandos del dispositivo aislado de GDC usan la CLI gdcloud o kubectl y requieren un entorno de sistema operativo (SO).

Obtener la ruta del archivo kubeconfig

Para ejecutar comandos en el servidor de la API Management, asegúrate de tener los siguientes recursos:

Busca el nombre del servidor de la API Management o pregunta a tu administrador de plataforma cuál es.
Inicia sesión y genera el archivo kubeconfig del servidor de la API Management si no tienes uno.
Usa la ruta para sustituir MANAGEMENT_API_SERVER{"</var>"}} en estas instrucciones.

Recuperar un disco de VM sin espacio

Para recuperar el espacio de un disco de arranque de una máquina virtual, sigue estos pasos:

Detén la VM siguiendo los pasos para detener una VM.

Edita la VM:

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

Sustituye el nombre del disco de la VM en el campo spec por un nuevo nombre de marcador de posición:

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

Crea una VM con un sistema operativo de imagen diferente al de la VM original. Por ejemplo, si el disco original usa el SO ubuntu-2004, crea la nueva VM con rocky-8.
Acopla el disco original como disco adicional a la nueva VM:
```
...
spec:
  disks:
  - boot: true
    autoDelete: true
    virtualMachineDiskRef:
      name: NEW_VM_DISK_NAME
  - virtualMachineDiskRef:
      name: ORIGINAL_VM_DISK_NAME
```
Haz los cambios siguientes:
- NEW_VM_DISK_NAME: el nombre que le asignes al nuevo disco de la máquina virtual.
- ORIGINAL_VM_DISK_NAME: nombre del disco de la VM original.
Una vez que hayas creado la VM y esté en ejecución, establece una conexión SSH con ella siguiendo las instrucciones de Conectarse a una VM.
Crea un directorio y monta el disco original en un punto de montaje. Por ejemplo, /mnt/disks/new-disk.
Consulta los archivos y directorios del directorio de montaje con espacio adicional:
```
cd /mnt/disks/MOUNT_DIR
du -hs -- * | sort -rh | head -10
```
Sustituye MOUNT_DIR por el nombre del directorio en el que has montado el disco original.

El resultado debería ser similar al siguiente:
```
18G   home
1.4G  usr
331M  var
56M   boot
5.8M  etc
36K   snap
24K   tmp
16K   lost+found
16K   dev
8.0K  run
```
Revisa cada uno de los archivos y directorios para verificar la cantidad de espacio que ocupa cada uno. En este ejemplo se comprueba el directorio home, ya que utiliza 18G de espacio.
```
cd home
du -hs -- * | sort -rh | head -10
```
El resultado debería ser similar al siguiente:
```
17G   log_file
...
4.0K  readme.md
4.0K  main.go
```
El archivo de ejemplo log_file es un archivo que se puede eliminar, ya que ocupa 17G de espacio y no es necesario.
Elimina los archivos que no necesites y que consuman espacio adicional, o crea una copia de seguridad de los archivos en el nuevo disco de arranque de la VM:
- Mueve los archivos que quieras conservar:
```
mv /mnt/disks/MOUNT_DIR/home/FILENAME/home/backup/
```
- Elimina los archivos que ocupan espacio adicional:
```
rm /mnt/disks/MOUNT_DIR/home/FILENAME
```
  Sustituye FILENAME por el nombre del archivo que quieras mover o eliminar.
Cierra sesión en la nueva VM y detenla.

Edita la nueva VM para quitar el disco original del campo spec:

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

Elimina la lista virtualMachineDiskRef que contiene el nombre del disco de la 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

Edita la VM original y sustituye VM_DISK_PLACEHOLDER_NAME que has definido en el paso dos por el nombre anterior:

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

Inicia la VM original. Si has liberado suficiente espacio, la máquina virtual se iniciará correctamente.

Si no necesitas la nueva VM, elimínala:

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

Aprovisionar una máquina virtual

En esta sección se describe cómo solucionar los problemas que pueden surgir al aprovisionar una nueva máquina virtual en el dispositivo aislado de Google Distributed Cloud (GDC).

El operador de aplicaciones (AO) debe ejecutar todos los comandos en el clúster de usuario predeterminado.

No se puede crear el disco

Si un PersistentVolumeClaim (PVC) está en estado Pending, consulta las siguientes alternativas para resolver el estado:

La clase de almacenamiento no admite la creación de un PVC con el modo de acceso ReadWriteMany:
1. Actualiza el valor spec.dataVolumeTemplate.spec.pvc.storageClassName de la máquina virtual con una clase de almacenamiento que admita el modo de acceso ReadWriteMany y que use un controlador de interfaz de almacenamiento de contenedores (CSI) como proveedor de almacenamiento.
2. Si ninguna otra clase de almacenamiento del clúster puede proporcionar la función ReadWriteMany, actualiza el valor spec.dataVolumeTemplate.spec.pvc.accessMode para incluir el modo de acceso ReadWriteOnce.
El controlador de CSI no puede aprovisionar un PersistentVolume:
1. Comprueba si hay algún mensaje de error:
```
kubectl describe pvc VM_NAME-boot-dv -n NAMESPACE_NAME
```
  Sustituye las siguientes variables:
  - VM_NAME: nombre de la máquina virtual.
  - NAMESPACE_NAME: el nombre del espacio de nombres.
2. Configura el controlador para solucionar el error. Para asegurarte de que el aprovisionamiento de PersistentVolume funciona, crea un PVC de prueba en un spec nuevo con un nombre diferente al especificado en 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. Una vez que se haya aprovisionado correctamente el objeto PersistentVolume, elimina el PVC de prueba después de la verificación:
```
kubectl delete pvc test-pvc -n NAMESPACE_NAME
```

No se puede crear una máquina virtual

Si el recurso de máquina virtual se aplica, pero no llega al estado Running, sigue estos pasos:

Revisa los registros de la máquina virtual:

kubectl get vm VM_NAME -n NAMESPACE_NAME

Comprueba el estado del pod correspondiente de la máquina virtual:
```
kubectl get pod -l kubevirt.io/vm=VM_NAME
```
El resultado muestra el estado del pod. Estas son las opciones posibles:

Estado `ContainerCreating`

Si el pod está en el estado ContainerCreating, sigue estos pasos:

Obtén más detalles sobre el estado del pod:

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

Si los volúmenes están desmontados, asegúrate de que todos los volúmenes especificados en el campo spec.volumes se hayan montado correctamente. Si el volumen es un disco, comprueba su estado.
El campo spec.accessCredentials especifica un valor para montar una clave pública SSH. Asegúrate de que el secreto se cree en el mismo espacio de nombres que la máquina virtual.

Si no hay suficientes recursos en el clúster para crear el pod, sigue estos pasos:

Si el clúster no tiene suficientes recursos de computación para programar el pod de la máquina virtual, elimina otros pods que no quieras para liberar recursos.
Reduce los valores spec.domain.resources.requests.cpu y spec.domain.resources.requests.memory de la máquina virtual.

El estado `Error` o `CrashLoopBackoff`

Para resolver los pods en estado Error o CrashLoopBackoff, recupera los registros del pod de cálculo de la máquina virtual:

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

El estado `Running` y el fallo de la máquina virtual

Si el pod está en estado Running, pero la máquina virtual falla, sigue estos pasos:

Consulta los registros del pod de registro de la máquina virtual:
```
kubectl logs -l  kubevirt.io/vm=VM_NAME  -c log
```
Si el registro muestra errores al iniciar la máquina virtual, compruebe el dispositivo de arranque correcto de la máquina virtual. Asigna el valor spec.domain.devices.disks.bootOrder del disco de arranque principal al valor 1. Usa el siguiente ejemplo como referencia:
```
…
  spec:
      domain:
        devices:
          disks:
          - bootOrder: 1
            disk:
              bus: virtio
            name: VM_NAME-boot-dv
  …
```

Para solucionar problemas de configuración con la imagen de la máquina virtual, crea otra máquina virtual con una imagen diferente.

Acceder a la consola en serie

En esta sección se describe cómo usar la consola en serie de una instancia de VM para depurar problemas de arranque y de red, solucionar problemas de instancias que no funcionan correctamente, interactuar con el gestor de arranque unificado (GRUB) y realizar otras tareas de solución de problemas.

Interactuar con un puerto serie es comparable a usar una ventana de terminal: la entrada y la salida están en modo texto, sin compatibilidad con la interfaz gráfica. El sistema operativo de la instancia, el sistema básico de entrada y salida (BIOS), a menudo escribe la salida en los puertos serie y acepta entradas como comandos.

Para acceder a la consola serie, consulta las siguientes secciones:

Configurar el nombre de usuario y la contraseña

De forma predeterminada, las imágenes del sistema Linux de GDC no están configuradas para permitir inicios de sesión basados en contraseñas para usuarios locales.

Si tu máquina virtual ejecuta una imagen preconfigurada con el inicio de sesión en la consola en serie, puedes configurar una contraseña local en la máquina virtual e iniciar sesión a través de la consola en serie. En las máquinas virtuales de GDC Linux, el nombre de usuario y la contraseña se configuran mediante una secuencia de comandos de inicio guardada como secreto de Kubernetes durante la creación de la máquina virtual o después.

En las siguientes instrucciones se describe cómo configurar una contraseña local después de crear la máquina virtual. Para configurar el nombre de usuario y la contraseña, sigue estos pasos:

Crea un archivo de texto.
En el archivo de texto, configura el nombre de usuario y la contraseña:
```
#!/bin/bash
username="USERNAME"
password="PASSWORD"
sudo useradd -m -s /bin/bash "$username"
echo "$username:$password" | sudo chpasswd
sudo usermod -aG sudo "$username"
```
Haz los cambios siguientes:
- USERNAME: el nombre de usuario que quieras añadir.
- PASSWORD: la contraseña del nombre de usuario. Evita las contraseñas básicas, ya que algunos sistemas operativos pueden requerir una longitud y una complejidad mínimas.
Crea la secuencia de comandos de inicio como un secreto de Kubernetes:
```
kubectl --kubeconfig=ADMIN_KUBECONFIG create secret \
generic STARTUP_SCRIPT_NAME -n PROJECT_NAMESPACE \
--from-file=STARTUP_SCRIPT_PATH
```
Haz los cambios siguientes:
- PROJECT_NAMESPACE: el espacio de nombres del proyecto en el que reside la VM.
- STARTUP_SCRIPT_NAME: the name you give to the startup script. For example,configure-credentials`.
- STARTUP_SCRIPT_PATH: la ruta de acceso a la secuencia de comandos de inicio que contiene el nombre de usuario y la contraseña que has configurado.
Detén la VM.
Edita la especificación de la VM:
```
kubectl --kubeconfig=ADMIN_KUBECONFIG edit gvm \
-n PROJECT_NAMESPACE VM_NAME
```
Sustituye VM_NAME por el nombre de la VM que quieras añadir a la secuencia de comandos de inicio.

En el campo startupScripts, añade la referencia del secreto de Kubernetes que has creado en el paso 3:

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

Inicia la VM.
- Si estás trabajando en una VM nueva, omite este paso.

Acceder a la consola en serie de la VM

Para empezar a acceder a la consola en serie de la VM, haz lo siguiente:

Conéctese a la consola serie:

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

Cuando se te pida, introduce el nombre de usuario y la contraseña que definiste en Configurar nombre de usuario y contraseña.