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

Ce document est destiné aux propriétaires d'applications qui exécutent GKE sur une solution Bare Metal. Ce document explique comment vous connecter à des machines virtuelles (VM) qui utilisent l'environnement d'exécution de VM sur GDC. 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 GKE sur une solution Bare Metal.
L'outil client virtctl, installé en tant que plug-in de kubectl. Si nécessaire, installez l'outil client virtctl.

Configurer un 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 l'environnement d'exécution de VM sur GDC. Entre autres, l'agent invité installe et désactive les clés SSH. Cette fonctionnalité active un tunnel SSH pour accéder à votre VM depuis des clients situés en dehors du 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 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, mettez à jour la ressource personnalisée VirtualMachine à l'aide de kubectl edit.

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, status: "True" s'affiche 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. Il s'agit généralement 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 que vous 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 à l'aide de l'environnement d'exécution de VM dans la console GDC. 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 de VM sur GDC ouvre VNC pour vous. Vous n'êtes donc pas obligé de l'activer 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 des 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.

OS invité Windows

Procédez comme suit pour réinitialiser le mot de passe d'un utilisateur existant ou créer le mot de passe initial d'un nouvel utilisateur:

Activez l'agent invité dans votre VM Windows:
1. Configurez la VM pour activer l'agent invité.
2. Utilisez VNC ou RDP pour vous connecter à la VM.
3. Dans la VM, accédez au lecteur guest agent. Dans la plupart des cas, il s'agit du lecteur E:.
4. Utilisez PowerShell pour exécuter install.ps1.
  
  Cette action installe et démarre l'agent invité. L'agent invité démarre automatiquement pour les redémarrages de VM suivants.
5. Fermez la session à distance.
Sur votre poste de travail administrateur, exécutez la commande suivante pour réinitialiser (ou définir si vous utilisez un nouveau nom d'utilisateur) le mot de passe de la VM Windows:
```
kubectl virt reset-windows-password VM_NAME \
    --user=USERNAME \
    --namespace=VM_NAMESPACE
```
Remplacez les éléments suivants :
- VM_NAME : nom de la VM.
- USERNAME: nom d'utilisateur pour lequel vous souhaitez réinitialiser (ou définir) le mot de passe. Si le nom d'utilisateur est nouveau, la commande crée un compte Windows et définit le mot de passe initial.
- VM_NAMESPACE : (facultatif) espace de noms de la VM. Cette option est facultative. S'il n'est pas spécifié, l'espace de noms par défaut (default) est utilisé.
Pour réinitialiser (ou définir) le mot de passe sans invite de confirmation, utilisez l'option facultative --force. Lorsque vous utilisez l'option --force, l'invite vous avertit des conséquences d'une réinitialisation du mot de passe pour un compte existant. Sans l'option --force, la commande vous invite à confirmer la réinitialisation du mot de passe avec le texte suivant:
```
This command creates an account and sets an initial password for the
user USERNAME if the account does not already exist.
If the account already exists, resetting the password can cause the
LOSS OF ENCRYPTED DATA secured with the current password, including
files and stored passwords.

Would you like to set or reset the password for USERNAME (Y/n)?
```
Une fois que vous avez confirmé (ou forcé) la réinitialisation du mot de passe, la commande renvoie le nouveau mot de passe pour la VM et le nom d'utilisateur spécifiés:
```
Resetting and retrieving password for USERNAME on VM_NAME

vm_name:    VM_NAME
username:   USERNAME
password:   PASSWORD
```