Tutoriel: Déployer une VM existante dans un cluster Anthos à l'aide de l'environnement d'exécution des VM Anthos

Ce document fournit un guide par étapes pour déployer une charge de travail basée sur des machines virtuelles (VM) dans des clusters Anthos sur bare metal à l'aide de l'environnement d'exécution des VM Anthos. La charge de travail utilisée dans ce guide est un exemple d'application de point de vente. Cette application représente un terminal de point de vente classique qui s'exécute sur du matériel sur site dans un magasin.

Dans ce document, vous allez migrer cette application d'une VM vers un clusters Anthos sur bare metal et accéder à l'interface Web de l'application. Pour migrer une VM existante vers le cluster, vous devez d'abord créer une image disque de cette VM. L'image doit ensuite être hébergée dans un dépôt auquel le cluster peut accéder. Enfin, vous pouvez utiliser l'URL de cette image pour créer la VM. L'environnement d'exécution des VM Anthos s'attend à ce que les images soient au format qcow2. Si vous fournissez un autre type d'image, il est automatiquement converti au format qcow2. Pour éviter les conversions répétitives et permettre la réutilisation, vous pouvez convertir une image de disque virtuel et héberger l'image qcow2.

Ce document utilise l'image préparée à l'avance d'une instance de VM Compute Engine dans laquelle la charge de travail s'exécute en tant que service systemd. Suivez la même procédure pour déployer votre propre application.

Objectifs

Activer l'environnement d'exécution des VM Anthos et installer le plug-in virtctl
Déployer la charge de travail basée sur une VM
Se connecter à la VM et vérifier l'état de l'application
Accéder à la charge de travail basée sur une VM

Avant de commencer

Pour remplir ce document, vous avez besoin des ressources suivantes:

Accès à un cluster Anthos sur bare metal version 1.12.0 ou ultérieure créé en suivant le guide Exécuter des clusters Anthos sur bare metal sur des VM Compute Engine avec l'équilibreur de charge manuel. Ce document configure des ressources réseau pour que vous puissiez accéder à la charge de travail exécutée dans la VM via un navigateur. Si vous n'avez pas besoin de ce comportement, vous pouvez suivre ce document en utilisant n'importe quel clusters Anthos sur bare metal.
Une station de travail répondant aux exigences suivantes :
- A accès à votre cluster à l'aide de la CLI bmctl.
- A accès à votre cluster à l'aide de la CLI kubectl.

Activer l'environnement d'exécution des VM Anthos et installer le plug-in `virtctl`

La définition de ressources personnalisées (CRD) de l'environnement d'exécution des VM Anthos fait partie de tous les clusters Anthos sur bare metal depuis la version 1.10. Une instance de la ressource personnalisée VMRuntime est déjà créée lors de l'installation. Cependant, il est désactivé par défaut.

Activez l'environnement d'exécution des VM Anthos:
```
sudo bmctl enable vmruntime --kubeconfig KUBECONFIG_PATH
```
- KUBECONFIG_PATH: chemin d'accès au fichier de configuration Kubernetes du cluster d'utilisateur Anthos.
Vérifiez que VMRuntime est activé:
```
kubectl wait --for=jsonpath='{.status.ready}'=true vmruntime vmruntime
```
La préparation de VMRuntime peut prendre quelques minutes. Si ce n'est pas le cas, vérifiez plusieurs fois avec de courts délais. L'exemple de résultat suivant montre que VMRuntime est prêt:
```
vmruntime.vm.cluster.gke.io/vmruntime condition met
```

Installez le plug-in virtctl pour kubectl:

sudo -E bmctl install virtctl

L'exemple de résultat suivant montre que le processus d'installation du plug-in virtctl est terminé:

Please check the logs at bmctl-workspace/log/install-virtctl-20220831-182135/install-virtctl.log
[2022-08-31 18:21:35+0000] Install virtctl succeeded

Vérifiez l'installation du plug-in virtctl:

kubectl virt

L'exemple de résultat suivant montre que le plug-in virtctl est disponible et peut être utilisé avec kubectl:

Available Commands:
  addvolume         add a volume to a running VM
  completion        generate the autocompletion script for the specified shell
  config            Config subcommands.
  console           Connect to a console of a virtual machine instance.
  create            Create subcommands.
  delete            Delete  subcommands.
...

Déployer la charge de travail basée sur une VM

Lorsque vous déployez une VM dans des clusters Anthos sur bare metal, l'environnement d'exécution des VM Anthos attend une image de VM. Cette image sert de disque de démarrage pour la VM déployée.

Dans ce tutoriel, vous allez migrer une charge de travail basée sur une VM Compute Engine vers un clusters Anthos sur bare metal. Cette VM Compute Engine a été créée, et l'exemple d'application de point de vente a été configuré pour s'exécuter en tant que service Systemd. Une image disque de cette VM et la charge de travail de l'application PoS ont été créées dans Google Cloud. Cette image a ensuite été exportée dans un bucket Cloud Storage en tant qu'image qcow2. Vous utiliserez cette image qcow2 préparée lors des étapes suivantes.

Le code source de ce document est disponible dans le dépôt GitHub anthos-samples. Vous allez utiliser les ressources de ce dépôt pour effectuer les étapes suivantes.

Déployer un StatefulSet MySQL L'application de point de vente s'attend à se connecter à une base de données MySQL pour stocker des informations sur l'inventaire et les paiements. Le dépôt du point de vente comporte un exemple de fichier manifeste qui déploie un objet StatefulSet MySQL, configure un objet ConfigMap associé et un objet Kubernetes Service. ConfigMap définit les identifiants de l'instance MySQL. Il s'agit des mêmes identifiants transmis dans l'application de point de vente.
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/point-of-sale/main/k8-manifests/common/mysql-db.yaml
```
Déployez la charge de travail de VM à l'aide de l'image qcow2 préparée:
```
kubectl virt create vm pos-vm \
    --boot-disk-size=80Gi \
    --memory=4Gi \
    --vcpu=2 \
    --image=https://storage.googleapis.com/pos-vm-images/pos-vm.qcow2
```
Cette commande crée un fichier YAML nommé d'après la VM (google-virtctl/pos-vm.yaml). Vous pouvez inspecter le fichier pour voir la définition de VirtualMachine et de VirtualMachineDisk. Au lieu d'utiliser le plug-in virtctl, vous pouvez avoir déployé la charge de travail de VM à l'aide des définitions de modèles de ressources Kubernetes (KRM), comme indiqué dans le fichier YAML créé.

Lorsque la commande s'exécute correctement, elle génère un résultat semblable à l'exemple suivant, qui explique les différentes ressources créées:
```
Constructing manifest for vm "pos-vm":
Manifest for vm "pos-vm" is saved to /home/tfadmin/google-virtctl/pos-vm.yaml
Applying manifest for vm "pos-vm"
Created gvm "pos-vm"
```
Vérifiez l'état de la création de la VM.

La ressource VirtualMachine est identifiée par la ressource vm.cluster.gke.io/v1.VirtualMachine dans l'environnement d'exécution des VM Anthos. Sa forme abrégée est gvm.

Lorsque vous créez une VM, les deux ressources suivantes sont créées:
- Un VirtualMachineDisk est un disque persistant sur lequel le contenu de l'image de VM est importé.
- Une machine virtuelle est l'instance de VM elle-même. Le Volume de données est installé dans VirtualMachine avant le démarrage de la VM.
Vérifiez l'état de VirtualMachineDisk. VirtualMachineDisk crée une ressource DataVolume en interne. L'image de VM est importée dans le volume de données installé dans la VM:
```
kubectl get datavolume
```
L'exemple de résultat suivant montre le début de l'importation d'image:
```
NAME              PHASE             PROGRESS   RESTARTS   AGE
pos-vm-boot-dv    ImportScheduled   N/A                   8s
```
Vérifiez l'état du VirtualMachine. VirtualMachine est à l'état Provisioning jusqu'à ce que DataVolume soit importé complètement:
```
kubectl get gvm
```
L'exemple de résultat suivant montre le VirtualMachine en cours de provisionnement:
```
NAME      STATUS         AGE     IP
pos-vm    Provisioning   1m
```
Attendez que l'image de VM soit entièrement importée dans DataVolume. Continuez à surveiller la progression pendant l'importation de l'image:
```
kubectl get datavolume -w
```
L'exemple de résultat suivant montre l'image disque en cours d'importation:
```
NAME              PHASE              PROGRESS   RESTARTS   AGE
pos-vm-boot-dv   ImportInProgress   0.00%                 14s
...
...
pos-vm-boot-dv   ImportInProgress   0.00%                 31s
pos-vm-boot-dv   ImportInProgress   1.02%                 33s
pos-vm-boot-dv   ImportInProgress   1.02%                 35s
...
```
Une fois l'importation terminée et le fichier DataVolume créé, l'exemple de résultat suivant affiche le PHASE de Succeeded :
```
kubectl get datavolume
```
```
NAME              PHASE             PROGRESS   RESTARTS   AGE
pos-vm-boot-dv    Succeeded         100.0%                14m18s
```
Remarque :La durée d'importation dépend de la taille de l'image de VM utilisée. L'image de VM Compute Engine décrite dans ce document mesure environ 5 Go et prend jusqu'à 15 minutes.
Vérifiez que VirtualMachine a bien été créé:
```
kubectl get gvm
```
Si la création a réussi, STATUS affiche RUNNING, comme illustré dans l'exemple suivant, avec l'adresse IP de la VM:
```
NAME      STATUS    AGE     IP
pos-vm    Running   40m     192.168.3.250
```

Se connecter à la VM et vérifier l'état de l'application

L'image utilisée pour la VM inclut un exemple d'application de point de vente. L'application est configurée pour se lancer automatiquement au démarrage en tant que service Systemd. Les fichiers de configuration des services système se trouvent dans le répertoire pos-systemd-services.

Se connecter à la console des VM Exécutez la commande suivante et appuyez sur Entrée après avoir vu le message Successfully connected to pos-vm…:
```
kubectl virt console pos-vm
```
Cette commande génère l'exemple de résultat suivant qui vous invite à saisir les identifiants:
```
Successfully connected to pos-vm console. The escape sequence is ^]

pos-from-public-image login:
```
Utiliser le compte utilisateur et le mot de passe suivants. Ce compte a été configuré dans la VM d'origine à partir de laquelle l'image de la machine virtuelle d'exécution de la VM Anthos a été créée.
- Nom d'utilisateur de connexion: abmuser
- Mot de passe : abmworks

Vérifiez l'état des services de l'application de point de vente. L'application de point de vente comprend trois services: API, Inventaire et Paiements. Ces services s'exécutent tous en tant que services système.

Les trois services se connectent tous les uns aux autres via localhost. Cependant, l'application se connecte à la base de données MySQL à l'aide d'un service Kubernetes mysql-db créé à l'étape précédente. Ce comportement signifie que la VM est automatiquement connectée au même réseau que Pods et Services, ce qui permet une communication fluide entre les charges de travail de VM et d'autres applications conteneurisées. Vous n'avez rien à faire pour que le Services de Kubernetes soit accessible à partir des VM déployées via l'environnement d'exécution des VM Anthos.

sudo systemctl status pos*

L'exemple de résultat suivant affiche l'état des trois services et du service du système racine, pos.service:

● pos_payments.service - Payments service of the Point of Sale Application
    Loaded: loaded (/etc/systemd/system/pos_payments.service; enabled; vendor >
    Active: active (running) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
  Main PID: 750 (payments.sh)
      Tasks: 27 (limit: 4664)
    Memory: 295.1M
    CGroup: /system.slice/pos_payments.service
            ├─750 /bin/sh /pos/scripts/payments.sh
            └─760 java -jar /pos/jars/payments.jar --server.port=8083

● pos_inventory.service - Inventory service of the Point of Sale Application
    Loaded: loaded (/etc/systemd/system/pos_inventory.service; enabled; vendor>
    Active: active (running) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
  Main PID: 749 (inventory.sh)
      Tasks: 27 (limit: 4664)
    Memory: 272.6M
    CGroup: /system.slice/pos_inventory.service
            ├─749 /bin/sh /pos/scripts/inventory.sh
            └─759 java -jar /pos/jars/inventory.jar --server.port=8082

● pos.service - Point of Sale Application
    Loaded: loaded (/etc/systemd/system/pos.service; enabled; vendor preset: e>
    Active: active (exited) since Tue 2022-06-21 18:55:30 UTC; 1h 10min ago
  Main PID: 743 (code=exited, status=0/SUCCESS)
      Tasks: 0 (limit: 4664)
    Memory: 0B
    CGroup: /system.slice/pos.service

Jun 21 18:55:30 pos-vm systemd[1]: Starting Point of Sale Application...
Jun 21 18:55:30 pos-vm systemd[1]: Finished Point of Sale Application.

● pos_apiserver.service - API Server of the Point of Sale Application
    Loaded: loaded (/etc/systemd/system/pos_apiserver.service; enabled; vendor>
    Active: active (running) since Tue 2022-06-21 18:55:31 UTC; 1h 10min ago
  Main PID: 751 (api-server.sh)
      Tasks: 26 (limit: 4664)
    Memory: 203.1M
    CGroup: /system.slice/pos_apiserver.service
            ├─751 /bin/sh /pos/scripts/api-server.sh
            └─755 java -jar /pos/jars/api-server.jar --server.port=8081

Quittez la VM. Pour quitter la connexion à la console, utilisez la séquence d'échappement ^] en appuyant sur Ctrl + ].

Accéder à la charge de travail basée sur une VM

Si votre cluster a été configuré en suivant le guide Exécuter des clusters Anthos sur bare metal sur des VM Compute Engine avec l'équilibreur de charge manuel, il dispose d'une ressource Ingress appelée pos-ingress. Cette ressource achemine le trafic de l'adresse IP publique de l'équilibreur de charge d'entrée vers le service de serveur d'API de l'exemple d'application de point de vente.

Si votre cluster ne dispose pas de cette ressource Ingress, créez-la en appliquant le fichier manifeste suivant:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-samples/main/anthos-bm-gcp-terraform/resources/manifests/pos-ingress.yaml

anthos-bm-gcp-terraform/resources/manifests/pos-ingress.yaml

Afficher sur GitHub

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: pos-ingress
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: api-server-svc
            port:
              number: 8080

Créez une Service Kubernetes qui achemine le trafic vers la VM. La ressource Ingress achemine le trafic vers ce Service:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-samples/main/anthos-vmruntime/pos-service.yaml

L'exemple de résultat suivant confirme la création d'un service:

service/api-server-svc created

anthos-vmruntime/pos-service.yaml

Afficher sur GitHub

apiVersion: v1
kind: Service
metadata:
  name: api-server-svc
spec:
  selector:
    kubevirt/vm: pos-vm
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8081

Obtenez l'adresse IP publique de l'équilibreur de charge Ingress. L'équilibreur de charge Ingress achemine le trafic en fonction des règles de ressources Ingress. Vous disposez déjà d'une règle pos-ingress pour transférer les requêtes vers le serveur d'API Service. Cet Service transmet les requêtes à la VM:
```
INGRESS_IP=$(kubectl get ingress/pos-ingress -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo $INGRESS_IP
```
L'exemple de résultat suivant affiche l'adresse IP de l'équilibreur de charge Ingress:
```
172.29.249.159 # you might have a different IP address
```
Accédez à l'application à l'aide de l'adresse IP de l'équilibreur de charge Ingress dans un navigateur. Les captures d'écran suivantes illustrent le système simple de point de vente avec deux éléments. Vous pouvez cliquer sur les articles plusieurs fois si vous souhaitez en commander plusieurs et passer une commande avec le bouton Payer. Cette expérience montre que vous avez déployé une charge de travail classique basée sur des VM dans un cluster Anthos à l'aide de l'environnement d'exécution des VM Anthos.

Interface utilisateur de l'application de point de vente — Interface de l'application de point de vente (cliquez sur l'image pour l'agrandir)

Effectuer un nettoyage

Vous pouvez supprimer toutes les ressources créées dans ce tutoriel ou ne supprimer que la VM et conserver les ressources réutilisables. La section Supprimer une VM dans des clusters Anthos sur bare metal détaille les options disponibles.

Tout supprimer

Supprimez l'environnement d'exécution des VM Anthos VirtualMachine ainsi que toutes les ressources:

kubectl virt delete vm pos-vm --all

L'exemple de résultat suivant confirme la suppression:

vm "pos-vm" used the following resources:
    gvm: pos-vm
    VirtualMachineDisk: pos-vm-boot-dv
Start deleting the resources:
    Deleted gvm "pos-vm".
    Deleted VirtualMachineDisk "pos-vm-boot-dv".

Supprimer uniquement la VM

Supprimer uniquement la VM permet de conserver le VirtualMachineDisk qui est créé. Cela permet de réutiliser cette image de VM et de gagner du temps sur l'importation de l'image lors de la création d'une VM.
```
kubectl virt delete vm pos-vm
```
L'exemple de résultat suivant confirme la suppression:
```
vm "pos-vm" used the following resources:
    gvm: pos-vm
    VirtualMachineDisk: pos-vm-boot-dv
Start deleting the resources:
    Deleted gvm "pos-vm".
```

Étapes suivantes

La VM d'origine utilisée dans ce guide est une instance Compute Engine qui exécute Ubuntu 20.04 LTS. L'image de cette VM est accessible publiquement via le bucket Cloud Storage pos-vm-images. Pour en savoir plus sur la configuration et l'image de la VM, consultez les instructions du dépôt du point de vente.
Lorsque vous créez une VM dans un cluster Anthos à l'aide de la commande kubectl virt create vm pos-vm, un fichier YAML nommé d'après la VM (google-virtctl/pos-vm.yaml) est créé. Vous pouvez inspecter le fichier pour voir la définition de VirtualMachine et de VirtualMachineDisk. Au lieu d'utiliser le plug-in virtctl, vous pouvez déployer une VM à l'aide des définitions KRM, comme indiqué dans le fichier YAML créé.