Se connecter aux VM qui utilisent l'environnement d'exécution des VM Anthos

Ce document est destiné aux propriétaires d'applications qui exécutent des clusters Anthos sur solution Bare Metal. Ce document explique comment se connecter à des machines virtuelles (VM) qui utilisent l'environnement d'exécution des VM Anthos. Vous pouvez vous connecter directement aux VM à l'aide d'une adresse IP, ou en utilisant des outils intégrés pour l'accès SSH ou console.

Avant de commencer

Pour suivre les instructions de ce document, vous devez disposer des ressources suivantes :

Une VM qui s'exécute dans l'un de vos clusters. Si nécessaire, créez une VM dans des clusters Anthos sur solution Bare Metal.
L'outil client virtctl, installé en tant que plug-in pour kubectl. Si nécessaire, installez l'outil client virtctl.

Configurer l'accès SSH sans mot de passe aux VM

L'accès SSH direct et sans mot de passe à votre VM est facilité par un agent invité installé par Anthos VM Runtime. Entre autres, l'agent invité installe et désactive les clés SSH. Cette fonctionnalité permet à un tunnel SSH d'accéder à votre VM à partir de clients extérieurs au réseau du cluster.

Activer l'agent invité

Pour activer l'agent invité :

Vérifiez votre ressource personnalisée VirtualMachine pour vérifier qu'elle est configurée pour activer l'agent invité :
```
kubectl get gvm VM_NAME -o yaml --kubeconfig KUBECONFIG
```
Le champ spec.osType doit être défini sur le système d'exploitation de votre VM, Linux ou Windows. La section spec.guestEnvironment ne doit pas être explicitement configurée comme étant vide. Si la section est configurée comme vide (guestEnvironment: {}), vous pouvez la supprimer entièrement pour activer l'agent invité.

Votre ressource personnalisée VirtualMachine pour la VM à laquelle vous souhaitez accéder doit se présenter comme suit :
```
apiVersion: vm.cluster.gke.io/v1
kind: VirtualMachine
metadata:
  name: sample-vm
spec:
  compute:
    cpu:
      vcpus: 2
    memory:
      capacity: 4Gi
...
  osType: Linux
...
```
Si nécessaire, utilisez kubectl edit pour mettre à jour la ressource personnalisée VirtualMachine.

Pour vérifier que l'agent invité fonctionne, vérifiez le status de votre ressource personnalisée de VM :

kubectl get gvm VM_NAME --kubeconfig KUBECONFIG

Lorsque l'agent invité fonctionne, vous voyez status: "True" pour les conditions GuestEnvironmentEnabled et 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
  ...

Activer l'accès SSH sans mot de passe

Pour activer l'accès SSH sans mot de passe pour votre VM, procédez comme suit :

Créez un fichier manifeste VirtualMachineAccessRequest, tel que vm-access-request.yaml, dans l'éditeur de votre choix :
```
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
```
Remplacez les éléments suivants :
- VMAR_NAME : nom de la ressource de demande d'accès
- VM_NAMESPACE : espace de noms de la VM à laquelle vous souhaitez accéder
- VM_NAME : nom de la VM à laquelle vous souhaitez accéder
- USERNAME : nom d'utilisateur de l'utilisateur qui accède à la VM
- PUBLIC_SSH_KEY : clé publique pour l'accès SSH. En général, il s'agit du contenu du fichier id_rsa.pub.
- EXPIRATION_TIME : le champ ttl (durée de vie) spécifie la durée de validité de la clé SSH.
  
  Par exemple, si vous spécifiez 30m, la clé SSH expire au bout de 30 minutes.
  
  Cette option utilise les unités suivantes :
  - s pour les secondes
  - m pour les minutes
  - h pour les heures
  - d pour les jours
Utilisez kubectl apply pour créer VirtualMachineAccessRequest à partir du fichier manifeste. Par exemple, si vous avez nommé votre fichier manifeste vm-access-request.yaml,
```
kubectl apply -f MANIFEST --kubeconfig KUBECONFIG
```
Remplacez les éléments suivants :
- MANIFEST : nom du fichier manifeste de requête d'accès. Par exemple, vm-access-request.yaml.
- KUBECONFIG : chemin d'accès au fichier kubeconfig du cluster qui héberge la VM à laquelle vous accédez

Pour vérifier que la configuration de votre requête d'accès a réussi, vérifiez l'état de VirtualMachineAccessRequest :

kubectl get vmar VMAR_NAME -o yaml --kubeconfig KUBECONFIG

Lorsque la configuration réussit, la section status inclut 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

Désactiver l'agent invité

Lorsque vous créez une VM et définissez le champ osType, l'agent invité est activé. Tant que cette fonctionnalité est en version preview, vous pouvez la désactiver en modifiant la ressource personnalisée VirtualMachine. La désactivation de l'agent invité désactive l'accès SSH sans mot de passe à votre VM.

Pour désactiver l'agent invité :

Utilisez kubectl pour arrêter votre VM avant de modifier la configuration :
```
kubectl virt stop VM_NAME --kubeconfig KUBECONFIG
```

Modifiez votre ressource de VM :

kubectl edit gvm VM_NAME --kubeconfig KUBECONFIG

Mettez à jour la configuration VirtualMachine pour ajouter explicitement une valeur spec.guestEnvironment vide :

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

Enregistrez et fermez le fichier manifeste mis à jour de la VM dans votre éditeur.

Utilisez kubectl pour démarrer la VM :

kubectl virt start VM_NAME --kubeconfig KUBECONFIG

Se connecter en utilisant une adresse IP

Si votre VM possède une adresse IP accessible et que vous disposez déjà des identifiants d'accès à la VM, vous pouvez vous connecter à l'aide d'un protocole tel que SSH, VNC ou RDP.

Se connecter via une adresse IP

Si vous pouvez vous connecter directement à l'adresse IP de votre VM, utilisez l'une des méthodes suivantes :

SSH

Obtenez les détails de votre VM pour afficher son adresse IP :
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Remplacez les valeurs suivantes :
- VM_NAME : nom de votre VM.
- VM_NAMESPACE : espace de noms de votre VM
L'exemple de résultat suivant affiche les informations et l'adresse IP de la VM :
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Connectez-vous à votre VM à l'aide d'un client SSH :
```
ssh USERNAME@IP_ADDRESS -i PATH_TO_KEY
```
Remplacez les valeurs suivantes :
- USERNAME : nom d'utilisateur d'un compte sur votre VM
- IP_ADDRESS : adresse IP de votre VM obtenue à l'étape précédente
- PATH_TO_KEY : chemin d'accès à la clé SSH privée

VNC ou RDP

Virtual Network Computing (VNC) et Remote Desktop Protocol (RDP) vous permettent d'accéder à votre VM via la console graphique. Lorsque vous utilisez une adresse IP, vous devez activer VNC ou RDP dans l'OS invité avant de pouvoir utiliser l'un d'entre eux pour vous connecter à la VM. Pour plus d'informations sur l'activation et l'utilisation de VNC ou de RDP, consultez la documentation de votre OS invité.

Vous avez également besoin des identifiants existants pour vous connecter à la VM, tels que ceux que vous définissez pour créer les identifiants utilisateur initiaux lors de la création de la VM.

Obtenez les détails de votre VM pour afficher son adresse IP :
```
kubectl get gvm VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Remplacez les valeurs suivantes :
- VM_NAME : nom de votre VM.
- VM_NAMESPACE : espace de noms de votre VM
L'exemple de résultat suivant affiche les informations et l'adresse IP de la VM :
```
NAME   STATUS    AGE   IP
vm1    Running   7m    10.200.0.21
```
Connectez-vous à l'adresse IP de votre VM obtenue à l'étape précédente en utilisant un outil client sur le port approprié (port VNC 5900 ou port RDP 3389 par exemple).

Se connecter via un service

Si votre VM se connecte à la VM pod-network par défaut et que vous ne pouvez pas communiquer directement avec l'adresse IP de votre VM, exposez la VM derrière un équilibreur de charge Service.

Créez un fichier manifeste Service, tel que my-service-load-balancer.yaml, dans l'éditeur de votre choix :
```
nano my-service-load-balancer.yaml
```
Copiez et collez le fichier manifeste YAML suivant :
```
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
```
Dans ce type de fichier manifeste Service, remplacez les valeurs suivantes :
- VM_NAME : nom de votre VM à exposer pour un accès à distance.
- PORT_NAME : nom de votre protocole, tel que ssh, vnc ou rdp.
- PROTOCOL_TYPE : type de protocole, tel que tcp pour SSH et RDP, ou udp pour VNC.
- EXTERNAL_PORT : numéro de port externe à exposer et que vous utilisez pour vous connecter.
- TARGET_PORT : port cible, tel que 22 pour SSH
Enregistrez et fermez le fichier manifeste Service dans votre éditeur.

Créez Service en utilisant kubectl :

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

Obtenez l'adresse EXTERNAL-IP du service d'équilibrage de charge :

kubectl get service VM_NAME-service --kubeconfig KUBECONFIG

L'adresse IP de l'équilibreur de charge s'affiche, comme illustré dans l'exemple de résultat suivant :

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

Connectez-vous à l'adresse EXTERNAL-IP de l'équilibreur de charge avec un protocole standard, par exemple via un client SSH :
```
ssh USERNAME@LOAD_BALANCER_IP_ADDRESS  -i PATH_TO_KEY
```
Remplacez les valeurs suivantes :
- USERNAME : nom d'utilisateur d'un compte sur votre VM.
- LOAD_BALANCER_IP_ADDRESS : adresse IP de votre équilibreur de charge.
- PATH_TO_KEY : chemin d'accès à la clé SSH privée

Se connecter directement via SSH

Si votre client est connecté au même réseau physique que votre cluster Anthos sur nœuds Bare Metal et que vous n'avez pas besoin de vous connecter en SSH aux clusters, vous pouvez vous connecter en utilisant kubectl virt ssh.

Pour utiliser SSH afin de vous connecter à une VM Linux à partir de la console avec le module complémentaire virtctl, procédez comme suit :
```
kubectl virt ssh USERNAME@VM_NAME --namespace VM_NAMESPACE --kubeconfig KUBECONFIG
```
Remplacez les valeurs suivantes :
- USERNAME : nom d'utilisateur permettant d'accéder à votre VM. Ce compte est créé s'il n'existe pas sur la VM.
- VM_NAME : nom de votre VM.
Après vous être connecté à la VM via SSH et une fois que vous n'avez plus besoin de la connexion, quittez la session SSH :
```
exit
```

Se connecter directement via la console

Si vous ne disposez pas d'une connectivité réseau directe à votre VM Linux pour l'accès SSH, connectez-vous à la console de la VM en utilisant la console d'exécution de l'environnement d'exécution des VM Anthos. Cette méthode ouvre une console série. Au moment de la connexion, une invite de commande s'affiche, et non une console graphique.

Pour accéder à une VM Linux à partir de la console, utilisez le module complémentaire virtctl :
```
kubectl virt console VM_NAME --kubeconfig KUBECONFIG
```
Remplacez VM_NAME par le nom de votre VM.

Lorsque vous y êtes invité, saisissez les identifiants d'utilisateur pour votre VM. Ces identifiants doivent exister sur la VM ou être appliqués au moment de sa création. Si nécessaire, consultez la section suivante pour créer les identifiants utilisateur initiaux lorsque vous créez une VM.
Une fois que vous êtes connecté à la console de la VM et que vous n'avez plus besoin de la connexion, quittez la session et la console de la VM :
```
Ctrl + ]
```

Se connecter directement via VNC

Vous pouvez utiliser la commande kubectl virt vnc pour ouvrir la console graphique de Virtual Network Computing (VNC) pour accéder à vos VM. Cette méthode fonctionne pour les VM exécutant un OS invité Windows ou Linux. Lorsque vous utilisez la commande kubectl virt vnc, l'environnement d'exécution des VM Anthos ouvre VNC automatiquement. Vous n'êtes donc pas obligé d'activer VNC dans l'OS invité.

Vous avez besoin des identifiants existants pour vous connecter à la VM, tels que ceux que vous définissez pour créer les identifiants utilisateur initiaux lors de la création de la VM.

Pour accéder à une VM à l'aide de VNC, utilisez le module complémentaire virtctl :
```
kubectl virt vnc VM_NAME --kubeconfig KUBECONFIG
```
Remplacez VM_NAME par le nom de votre VM.

Lorsque vous y êtes invité, saisissez les identifiants d'utilisateur pour votre VM.
Après vous être connecté à la session VNC de la VM et une fois que vous n'avez plus besoin de la connexion, déconnectez-vous de la VM pour fermer la connexion VNC.

Créer les identifiants utilisateur initiaux

Lorsque vous vous connectez à votre VM en utilisant la console, vous devez spécifier les identifiants d'utilisateur. Le processus de création d'identifiants utilisateur initiaux diffère pour les systèmes d'exploitation invités Linux et Windows.

OS invité Linux

Pour les VM Linux, les identifiants utilisateur peuvent être intégrés à vos images personnalisées ou être spécifiés lors de la création d'une VM.

Utilisez le paramètre --configure-initial-password avec la commande kubectl virt create :
```
kubectl virt create vm VM_NAME \
    --image ubuntu20.04 \
    --os-type Linux \
    --configure-initial-password USERNAME:PASSWORD \
    --kubeconfig KUBECONFIG
```
Remplacez les valeurs suivantes :
- VM_NAME : nom de votre VM.
- USERNAME : nom d'utilisateur du compte à créer sur la VM
- PASSWORD : mot de passe du compte utilisateur
Cet exemple de commande crée une VM Linux qui exécute Ubuntu 20.04. Il est recommandé de modifier les identifiants initiaux après vous être connecté à la VM.

Remarque : Pour modifier les identifiants d'une VM existante, connectez-vous à la VM en utilisant kubectl virt console VM_NAME, puis mettez à jour les identifiants dans le système d'exploitation invité.