Conéctate a las VM que usan el entorno de ejecución de VM de Anthos

Este documento está dirigido a los propietarios de aplicaciones que ejecutan clústeres de Anthos en equipos físicos. En este documento, se muestra cómo conectarse a las máquinas virtuales (VM) que usan el entorno de ejecución de VM de Anthos. Puedes conectarte directamente a las VM mediante una dirección IP o herramientas integradas para acceder a SSH o a la consola.

Antes de comenzar

Para completar este documento, necesitas acceso a los siguientes recursos:

Una VM que se ejecuta en uno de los clústeres. Si es necesario, crea una VM en clústeres de Anthos en un equipo físico.
La herramienta de cliente virtctl instalada como un complemento para kubectl. Si es necesario, instala la herramienta cliente de virtctl.

Configura el acceso SSH sin contraseña a las VM

El agente SSH invitado instala el acceso SSH directo y sin contraseña a la VM mediante un agente de VM de Anthos. Entre otras tareas, el agente invitado instala y vence las Llaves SSH. Esta función habilita un túnel SSH para acceder a la VM desde clientes fuera de la red del clúster.

Habilita el agente invitado

Para habilitar el agente invitado, sigue estos pasos:

Verifica el recurso personalizado VirtualMachine a fin de confirmar que esté configurado para habilitar el agente invitado:
```
kubectl get gvm VM_NAME -o yaml --kubeconfig KUBECONFIG
```
El campo spec.osType debe establecerse en el sistema operativo de la VM, Linux o Windows. La sección spec.guestEnvironment no se debe configurar de forma explícita como vacía. Si la sección está configurada como vacía (guestEnvironment: {}), puedes quitarla por completo para habilitar el agente invitado.

Tu recurso personalizado VirtualMachine para la VM a la que deseas acceder debería verse de la siguiente manera:
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
...
  osType: Linux
...
```
Si es necesario, usa kubectl edit para actualizar el recurso personalizado VirtualMachine.

Para verificar que el agente invitado funcione, verifica status en tu recurso personalizado de VM:

kubectl get gvm VM_NAME --kubeconfig KUBECONFIG

Cuando el agente invitado funciona, verás status: "True" para las condiciones GuestEnvironmentEnabled y 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
  ...

Habilitar el acceso SSH sin contraseña

Para habilitar el acceso SSH sin contraseña para tu VM, sigue estos pasos:

Crea un archivo de manifiesto VirtualMachineAccessRequest, como vm-access-request.yaml, en el editor que elijas:
```
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
```
Reemplaza lo siguiente:
- VMAR_NAME: Es el nombre del recurso de la solicitud de acceso.
- VM_NAMESPACE: Es el espacio de nombres de la VM a la que deseas acceder.
- VM_NAME: Es el nombre de la VM a la que deseas acceder.
- USERNAME: Es el nombre de usuario para el usuario que accede a la VM.
- PUBLIC_SSH_KEY: Es la clave pública para el acceso SSH. Por lo general, este es el contenido del archivo id_rsa.pub.
- EXPIRATION_TIME: El campo ttl (tiempo de actividad) especifica cuánto tiempo es válida la Llave SSH.
  
  Por ejemplo, si especificas 30m, la clave SSH vence después de 30 minutos.
  
  En esta marca, se usan las siguientes unidades:
  - s para los segundos
  - m para los minutos
  - h para las horas
  - d para los días
Usa kubectl apply para crear el VirtualMachineAccessRequest a partir del archivo de manifiesto. Por ejemplo, si le pusiste el nombre vm-access-request.yaml al archivo de manifiesto,
```
kubectl apply -f MANIFEST --kubeconfig KUBECONFIG
```
Reemplaza lo siguiente:
- MANIFEST: Es el nombre del archivo de manifiesto de la solicitud de acceso. Por ejemplo, vm-access-request.yaml
- KUBECONFIG: La ruta de acceso al archivo kubeconfig del clúster que aloja la VM a la que accedes.

Para verificar que la configuración de tu solicitud de acceso se realizó de forma correcta, verifica el estado de VirtualMachineAccessRequest:

kubectl get vmar VMAR_NAME -o yaml --kubeconfig KUBECONFIG

Cuando la configuración se realiza de forma correcta, la sección status incluye 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

Inhabilita el agente invitado

Cuando creas una VM nueva y configuras el campo osType, el agente invitado se habilita. Mientras esta función está en vista previa, puedes inhabilitarla si editas el recurso personalizado VirtualMachine. Si inhabilitas el agente invitado, se inhabilita el acceso SSH sin contraseña a tu VM.

Para inhabilitar el agente invitado, sigue estos pasos:

Usa kubectl para detener la VM antes de realizar cambios en la configuración:
```
kubectl virt stop VM_NAME --kubeconfig KUBECONFIG
```

Edita tu recurso de VM:

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Actualiza la configuración de VirtualMachine para agregar un spec.guestEnvironment vacío de forma explícita:

apiVersion: vm.cluster.gke.io/v1alpha1
kind: VirtualMachine
metadata:
  name: vm-example
  namespace: default
spec:
  compute:
  ...
  osType: Linux
  guestEnvironment: {}

Guarda y cierra el manifiesto de VM actualizado en el editor.

Usa kubectl para iniciar la VM:

kubectl virt start VM_NAME --kubeconfig KUBECONFIG

Conéctate con una dirección IP

Si tu VM tiene una dirección IP accesible y ya tienes las credenciales para acceder a la VM, puedes conectarte mediante un protocolo, como SSH, VNC o RDP.

Conéctate a través de la dirección IP

Si puedes conectarte directamente a la dirección IP de tu VM, usa uno de los siguientes métodos:

SSH

Obtén los detalles de tu VM para ver su dirección IP:
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Reemplaza los siguientes valores:
- VM_NAME: el nombre de tu VM.
- VM_NAMESPACE: Es el espacio de nombres de la VM.
En el siguiente resultado de ejemplo, se muestra la información de la VM y la dirección IP:
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Conéctate a la VM con un cliente SSH:
```
ssh USERNAME@IP_ADDRESS -i PATH_TO_KEY
```
Reemplaza los siguientes valores:
- USERNAME: Es el nombre de usuario de una cuenta en tu VM.
- IP_ADDRESS: Es la dirección IP de la VM que obtuviste en el paso anterior.
- PATH_TO_KEY: Es la ruta a la Llave SSH privada.

VNC o RDP

La computación en red virtual (VNC) y el protocolo de escritorio remoto (RDP) te permiten usar la consola gráfica para acceder a tu VM. Cuando usas una dirección IP, debes habilitar VNC o RDP en el SO invitado antes de poder usar cualquiera de las dos para conectarte a la VM. Para obtener información sobre cómo habilitar y usar VNC o RDP, consulta la documentación de tu SO invitado.

También necesitas credenciales existentes para acceder a la VM, como las que defines para crear credenciales de usuario iniciales cuando creas una VM.

Obtén los detalles de tu VM para ver su dirección IP:
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Reemplaza los siguientes valores:
- VM_NAME: el nombre de tu VM.
- VM_NAMESPACE: Es el espacio de nombres de la VM.
En el siguiente resultado de ejemplo, se muestra la información de la VM y la dirección IP:
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Conéctate a la dirección IP de tu VM obtenida en el paso anterior con una herramienta cliente y el puerto adecuado, como el puerto VNC 5900 o el puerto RDP 3389.

Conéctate a través de un objeto Service

Si tu VM se conecta a pod-network predeterminada y no puedes comunicarte directamente con la dirección IP de tu VM, expón la VM detrás de un balanceador de cargas Service.

Crea un manifiesto Service, como my-service-load-balancer.yaml, en el editor que elijas:
```
nano my-service-load-balancer.yaml
```
Copia y pega el siguiente manifiesto 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
```
En este tipo de manifiesto Service, reemplaza los siguientes valores:
- VM_NAME: el nombre de tu VM que se va a exponer para el acceso remoto.
- PORT_NAME: el nombre de tu protocolo, como ssh, vnc o rdp.
- PROTOCOL_TYPE: el tipo de protocolo, como tcp para SSH y RDP, o udp para VNC.
- EXTERNAL_PORT: el número de puerto externo que se va a exponer y que usas para conectarte.
- TARGET_PORT: el puerto de destino, como 22 para SSH.
Guarda y cierra el manifiesto Service en tu editor.

Crea Service mediante kubectl:

kubectl apply -f my-service-load-balancer.yaml  --kubeconfig KUBECONFIG

Obtén la dirección EXTERNAL-IP del servicio del balanceador de cargas:

kubectl get service VM_NAME-service --kubeconfig KUBECONFIG

Se muestra la dirección IP del balanceador de cargas, como se muestra en el siguiente resultado de ejemplo:

NAME          TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
vm1-service   LoadBalancer   172.26.232.167   10.200.0.51   22:31141/TCP   6d20h

Conéctate a la dirección EXTERNAL-IP del balanceador de cargas con un protocolo estándar, como el uso de un cliente SSH:
```
ssh USERNAME@LOAD_BALANCER_IP_ADDRESS  -i PATH_TO_KEY
```
Reemplaza los siguientes valores:
- USERNAME: el nombre de usuario de una cuenta en tu VM.
- LOAD_BALANCER_IP_ADDRESS: la dirección IP de tu balanceador de cargas.
- PATH_TO_KEY: Es la ruta a la Llave SSH privada.

Conéctate directamente con SSH

Si tu cliente está conectado a la misma red física que tu clúster de Anthos alojado en nodos de equipos físicos y no necesitas el uso de túneles SSH para conectarte al clúster, puedes conectarte mediante kubectl virt ssh.

Si quieres usar SSH para conectar una VM de Linux desde la consola con el complemento virtctl, sigue estos pasos:
```
kubectl virt ssh USERNAME@VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Reemplaza los siguientes valores:
- USERNAME: el nombre de usuario para acceder a tu VM. Esta cuenta se crea si no existe en la VM.
- VM_NAME: El nombre de tu VM.
Después de conectarte de forma correcta con SSH a la VM y de que ya no necesites la conexión, sal de la sesión de SSH:
```
exit
```

Conéctate directamente con la consola

Si no tienes conectividad de red directa a tu VM de Linux para el acceso SSH, conéctate a la consola de la VM mediante la consola del entorno de ejecución de VM de Anthos. Este método abre una consola en serie. Cuando se establece la conexión, se muestra un símbolo del sistema en lugar de una consola gráfica.

Para acceder a una VM de Linux desde la consola, usa el complemento virtctl:
```
kubectl virt console VM_NAME --kubeconfig KUBECONFIG
```
Reemplaza VM_NAME por el nombre de tu VM.

Cuando se te solicite, ingresa las credenciales de usuario para la VM. Estas credenciales deben existir en la VM o aplicarse cuando se crea la VM. Si es necesario, consulta la siguiente sección para crear credenciales de usuario iniciales cuando crees una VM.
Después de conectarte de forma correcta a la consola de la VM y de que ya no necesites la conexión, sal de la sesión de VM y de la consola:
```
Ctrl + ]
```

Conéctate directamente con VNC

Puedes usar el comando kubectl virt vnc para abrir la consola gráfica de Virtual Network Computing (VNC) a fin de acceder a tus VM. Este método funciona para las VM que ejecutan un SO invitado de Windows o Linux. Cuando usas el comando kubectl virt vnc, se abre VNC de la VM de Anthos por ti, por lo que no es necesario que habilites la VNC en el SO invitado.

Necesitas credenciales existentes para acceder a la VM, como las que defines para crear credenciales de usuario iniciales cuando creas una VM.

Para acceder a una VM con VNC, usa el complemento virtctl:
```
kubectl virt vnc VM_NAME --kubeconfig KUBECONFIG
```
Reemplaza VM_NAME por el nombre de tu VM.

Cuando se te solicite, ingresa las credenciales de usuario para la VM.
Después de conectarte de forma correcta a la sesión de VNC de la VM y de que ya no necesites la conexión, sal de la VM para cerrar la conexión.

Crea credenciales de usuario iniciales

Cuando te conectas a tu VM con la consola, debes especificar las credenciales del usuario. El proceso de creación de credenciales de usuario iniciales difiere para los sistemas operativos invitados de Linux y Windows.

SO invitado de Linux

Para las VM de Linux, las credenciales de usuario se pueden integrar en tus imágenes personalizadas o se pueden especificar cuando creas una VM.

Usa el parámetro --configure-initial-password con el comando kubectl virt create:
```
kubectl virt create vm VM_NAME \
    --image ubuntu20.04 \
    --os-type Linux \
    --configure-initial-password USERNAME:PASSWORD \
    --kubeconfig KUBECONFIG
```
Reemplaza los siguientes valores:
- VM_NAME: el nombre de tu VM.
- USERNAME: Es el nombre de usuario de la cuenta que se creará en la VM.
- PASSWORD: Es la contraseña de la cuenta de usuario.
Este comando de ejemplo crea una VM de Linux que ejecuta Ubuntu 20.04. Se recomienda cambiar las credenciales iniciales después de acceder por primera vez a la VM.

Nota: Para cambiar las credenciales en una VM existente, conéctate a la VM mediante kubectl virt console VM_NAME y, luego, actualiza las credenciales dentro del SO invitado.