Gérer des Conteneurs et des VM avec Incus

Après avoir découvert et installé Incus, il est maintenant temps de passer à la pratique ! Dans cet article, nous allons explorer comment utiliser le registry d’images et gérer vos instances Incus. Vous verrez comment télécharger, filtrer, et lancer des images de conteneurs ou de machines virtuelles, tout en apprenant à organiser vos environnements avec des projets. Enfin, nous verrons quelques commandes essentielles pour interagir avec vos instances de manière efficace.

Registry des images Incus

Incus utilise un système de remotes pour accéder à des images hébergées à distance. Le remote par défaut est appelé “images”, et il permet de télécharger des images officielles depuis un serveur central accessible via le préfixe images:.

Pour consulter les images disponibles dans le remote :images, il suffit de lancer :

incus image list images:

Registry des images Incus

Incus utilise des remotes pour accéder aux images de systèmes d’exploitation. Le remote par défaut, “images”, permet de télécharger des images depuis un serveur central sans configuration supplémentaire. Vous pouvez lister les images disponibles avec :

incus image list images:

Le serveur d’images accessible via images.linuxcontainers.org ↗ propose une grande variété d’images pour des distributions Linux comme Ubuntu, Debian, CentOS, et bien d’autres. Chaque image est classée par version et architecture (amd64, arm64), et est disponible pour des usages de conteneurs ou de VM.

Ces images sont constamment mises à jour pour garantir des environnements stables et sécurisés. Vous pouvez ainsi facilement choisir et lancer des conteneurs ou des machines virtuelles à partir de ces images.

Cela facilite la gestion de vos instances sur Incus tout en bénéficiant d’une large variété de distributions prêtes à l’emploi.

Filtrer les images Incus

Pour lister les images disponibles pour une version spécifique d’un système d’exploitation et une architecture donnée, comme Ubuntu 22.04 sur arm64, vous pouvez utiliser la commande suivante :

incus image list images: 22.04 arm64

Cette commande permet de filtrer les images Incus disponibles pour Ubuntu 22.04 avec l’architecture arm64. Cela vous affiche une liste des images correspondant à ces critères, comprenant des détails comme le fingerprint, la description, la taille et d’autres informations spécifiques.

Cela vous permet de cibler précisément les images correspondant à vos besoins. L’option -c permet de personnaliser les colonnes affichées.

Les colonnes disponibles incluent :

• l : alias court
• f : fingerprint
• d : description
• a : architecture
• s : taille
• u : date de téléversement
• t : type (conteneur ou machine virtuelle)

Par exemple, pour afficher uniquement l’alias, l’architecture, la taille et le type de l’image :

incus image list images: -c last  amd64 bookworm
+--------------------------+--------------+-----------+-----------------+
|          ALIAS           | ARCHITECTURE |   SIZE    |      TYPE       |
+--------------------------+--------------+-----------+-----------------+
| debian/12 (7 more)       | x86_64       | 87.29MiB  | CONTAINER       |
+--------------------------+--------------+-----------+-----------------+
| debian/12 (7 more)       | x86_64       | 353.61MiB | VIRTUAL-MACHINE |
+--------------------------+--------------+-----------+-----------------+
| debian/12/cloud (3 more) | x86_64       | 115.09MiB | CONTAINER       |
+--------------------------+--------------+-----------+-----------------+
| debian/12/cloud (3 more) | x86_64       | 381.37MiB | VIRTUAL-MACHINE |
+--------------------------+--------------+-----------+-----------------+

Et l’idempotence ?

Comment peut-on garantir l’idempotence lorsqu’il n’y a pas de tags pour les images dans Incus, comme c’est le cas dans Docker ? Sans tags, il est difficile de s’assurer que chaque instance utilise la même version exacte d’une image. Une solution consiste à utiliser des fingerprints d’images uniques et à créer des alias incluant la date, comme :

incus image copy images:ubuntu/22.04 local: --alias ubuntu-lts-$(date +%Y%m%d)

Cette méthode garantit que vous travaillez toujours avec la même version d’une image.

Mais, où stocker ces images de manière sûre ? Utiliser un serveur d’images distant ou configurer un remote privé peut être une solution pour gérer les images de manière centralisée et sécurisée. Vous pourriez envisager d’héberger ces images localement dans un environnement sécurisé avec des backups réguliers ou d’utiliser un stockage cloud résilient pour éviter tout risque de perte ou de corruption. Je proposerai une solution, une fois que j’aurai avancé dans ma découverte d’Incus.

Lancement d’instance Incus

Pour lancer une instance Incus à partir d’une image, vous pouvez utiliser la commande incus launch. Voici un exemple de commande pour lancer une instance de conteneur :

incus launch images:ubuntu/24.04 mon-conteneur

Cette commande crée et démarre un conteneur nommé “mon-conteneur” basé sur une image Ubuntu 24.04. Ce conteneur tourne en arrière-plan, et vous pouvez ensuite interagir avec lui via Incus.

Pour lancer une instance de machine virtuelle, vous pouvez utiliser la même commande en ajoutant l’option --vm :

incus launch images:ubuntu/24.04 ma-vm --vm

Launching ma-vm

Pour vérifier de quel type est une instance, vous pouvez utiliser la commande suivante :

incus info ma-vm
Name: ma-vm
Status: RUNNING
Type: virtual-machine
Architecture: x86_64
PID: 132842
Created: 2024/10/22 16:31 CEST
Last Used: 2024/10/22 16:31 CEST
Started: 2024/10/22 16:31 CEST

Operating System:
  OS: Ubuntu
  OS Version: 24.04.1 LTS (Noble Numbat)
  Kernel Version: 6.8.0-47-generic
  Hostname: ma-vm
  FQDN: ma-vm

Resources:
  Processes: 13
  CPU usage:
    CPU usage (in seconds): 5
  Memory usage:
    Memory (current): 177.85MiB
  Network usage:
    enp5s0:
      Type: broadcast
      State: UP
      Host interface: tap90a262a2
      MAC address: 00:16:3e:90:26:a6
      MTU: 1500
      Bytes received: 0B
      Bytes sent: 3.44kB
      Packets received: 0
      Packets sent: 18
      IP addresses:
        inet6: fe80::216:3eff:fe90:26a6/64 (link)
    lo:
      Type: loopback
      State: UP
      MTU: 65536
      Bytes received: 57.27kB
      Bytes sent: 57.27kB
      Packets received: 804
      Packets sent: 804
      IP addresses:
        inet:  127.0.0.1/8 (local)
        inet6: ::1/128 (local)

Dans les détails retournés, vous verrez la mention Type: virtual-machine, indiquant que l’instance est une VM et non un conteneur. De plus, si vous examinez les propriétés, vous trouverez des informations sur QEMU, qui est l’hyperviseur utilisé pour exécuter cette VM.

Définir des ressources pour une instance

Pour créer une VM avec un disque de 30 GiB :

incus launch images:ubuntu/22.04 ubuntu-vm-big --vm --device root,size=30GiB

Pour limiter les ressources d’un conteneur à un vCPU et 192 MiB de RAM :

incus launch images:ubuntu/22.04 ubuntu-limited --config limits.cpu=1 --config limits.memory=192MiB

Cela vous permet de configurer vos ressources lors du lancement d’une instance.

Lister les instances Incus

Pour afficher la liste des instances en cours d’exécution, vous pouvez utiliser la commande incus list :

incus list

+---------------+---------+------+------+-----------------+-----------+
|     NAME      |  STATE  | IPV4 | IPV6 |      TYPE       | SNAPSHOTS |
+---------------+---------+------+------+-----------------+-----------+
| ma-vm         | RUNNING |      |      | VIRTUAL-MACHINE | 0         |
+---------------+---------+------+------+-----------------+-----------+
| mon-conteneur | RUNNING |      |      | CONTAINER       | 0         |
+---------------+---------+------+------+-----------------+-----------+

Gestion de projet dans Incus

Les projets dans Incus permettent d’organiser et d’isoler vos ressources (conteneurs, VM, volumes, réseaux) dans des environnements indépendants. Cela est particulièrement utile pour séparer des environnements de test, développement ou production.

Créer un projet

Pour créer un nouveau projet, utilisez la commande suivante :

incus project create mon-projet

Cela génère un espace indépendant où vous pourrez gérer des instances sans interférer avec d’autres projets.

Utiliser un projet

Pour exécuter des commandes dans le cadre d’un projet spécifique, il suffit de définir le projet actif :

incus project switch mon-projet

Toutes les commandes que vous exécutez après cette commande s’appliqueront à ce projet. Cela vous permet de gérer différentes ressources et configurations sans chevauchement entre projets.

incus list
+------+-------+------+------+------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+-------+------+------+------+-----------+

Et pourtant mes autres ressources sont bien présentes !

Comme vous pouvez le constater, la liste est vide, car nous n’avons pas encore créé de ressources. On peut lister toutes les ressouces de tous les projets avec la commande suivante :

incus list --all-projects

+---------+---------------+---------+------+------+-----------------+-----------+
| PROJECT |     NAME      |  STATE  | IPV4 | IPV6 |      TYPE       | SNAPSHOTS |
+---------+---------------+---------+------+------+-----------------+-----------+
| default | ma-vm         | RUNNING |      |      | VIRTUAL-MACHINE | 0         |
+---------+---------------+---------+------+------+-----------------+-----------+
| default | mon-conteneur | RUNNING |      |      | CONTAINER       | 0         |
+---------+---------------+---------+------+------+-----------------+-----------+

Lister les projets

Pour voir tous les projets existants :

incus project list

Vous pourrez ainsi gérer et surveiller facilement l’organisation de vos environnements sur Incus.

Gestion des instances dans Incus : démarrage, arrêt et suppression

Dans Incus, vous pouvez facilement gérer vos instances de conteneurs ou de VM à travers des commandes simples.

• Démarrer une instance :

  incus start mon-instance

  Cela lance le conteneur ou la VM spécifiée.

• Arrêter une instance :

  incus stop mon-instance

  Utilisez cette commande pour arrêter une instance.

• Redémarrer une instance :

  incus restart mon-instance

• Supprimer une instance :

  incus delete mon-instance

  Cette commande supprime l’instance stoppée, effaçant toutes ses données. Attention une instance supprimée ne peut pas être récupérée.

Vous pouvez également lister toutes les instances en cours avec :

incus stop --project default ma-vm
incus list --all-projects

+---------+---------------+---------+------+------+-----------------+-----------+
| PROJECT |     NAME      |  STATE  | IPV4 | IPV6 |      TYPE       | SNAPSHOTS |
+---------+---------------+---------+------+------+-----------------+-----------+
| default | ma-vm         | STOPPED |      |      | VIRTUAL-MACHINE | 0         |
+---------+---------------+---------+------+------+-----------------+-----------+
| default | mon-conteneur | RUNNING |      |      | CONTAINER       | 0         |
+---------+---------------+---------+------+------+-----------------+-----------+

Cela permet de vérifier l’état de toutes les instances et d’agir en conséquence.

Interagir avec les instances : commandes exec et accès au shell

Dans Incus, il est facile d’interagir avec vos instances (conteneurs ou VM) sans avoir besoin de les configurer pour l’accès réseau. Vous pouvez exécuter des commandes directement dans une instance ou accéder à son shell.

Exécuter une commande dans une instance

La commande exec permet de lancer une commande à l’intérieur d’un conteneur ou d’une VM. Voici comment exécuter une commande spécifique dans une instance :

incus exec mon-instance -- <commande>

Par exemple, pour mettre à jour la liste des paquets dans un conteneur Ubuntu :

incus exec mon-conteneur -- apt update

Accéder au shell de l’instance

Si vous souhaitez interagir directement avec une instance via un shell, vous pouvez utiliser bash ou sh en fonction du système d’exploitation de l’instance. Pour ouvrir une session shell dans une instance :

incus shell ma-vm

Cela vous permet de prendre le contrôle total de l’instance, comme si vous étiez connecté physiquement à son terminal.

Configurer des instances avec Incus

Vous pouvez configurer vos instances dans Incus en modifiant les propriétés, les options ou en ajoutant des devices. Voici les étapes pour gérer la configuration d’une instance :

• Utilisez incus config set pour définir des options comme les limites de mémoire ou CPU. Par exemple :

  incus config set ma-vm limits.memory=1GiB

• Pour ajouter un périphérique comme un disque à une instance :

  incus config device add ma-vm disk-storage-device disk source=/home/bob/Projets/incus path=/opt

Utilisation des profils dans Incus

Les profils dans Incus permettent de définir des configurations réutilisables pour les instances. Ils centralisent des paramètres comme les limites de ressources, les périphériques (disques, réseaux), et d’autres options. Lors de la création d’une instance, vous pouvez associer un ou plusieurs profils, facilitant ainsi la gestion de configurations communes à plusieurs conteneurs ou VM.

Créer un profil

incus profile create mon-profil

Ajouter des configurations à un profil

Par exemple, pour limiter la mémoire et le CPU d’un profil :

incus profile set mon-profil limits.cpu=2
incus profile set mon-profil limits.memory=512MiB

Utiliser un profil lors du lancement d’une instance

incus launch images:ubuntu/22.04 mon-instance --profile default --profile mon-profil

La commande suivante :

incus launch images:ubuntu/22.04 mon-instance --profile default --profile mon-profil

Si deux profils définissent des options identiques, le dernier profil mentionné dans la commande (mon-profil ici) aura priorité, permettant de surcharger les paramètres du profil default.

Lister les profils

incus profile list

Modifier un profil existant

Pour éditer un profil directement :

incus profile edit mon-profil

Vous êtes alors invité à modifier le fichier YAML du profil. Par exemple :

### This is a YAML representation of the profile.
### Any line starting with a '# will be ignored.
config:
  limits.cpu: "2"
  limits.memory: 512MiB
description: ""
devices: {}
name: mon-profil
used_by:
- /1.0/instances/mon-instance
project: default

Sauvegardez et quittez l’éditeur pour appliquer les modifications.

Configurer les instances avec cloud-init

Les conteneurs et les machines virtuelles peuvent être configurés au démarrage avec cloud-init. Cela permet d’automatiser des tâches de configuration telles que l’installation de packages, la configuration de réseaux, ou la création d’utilisateurs. J’ai écrit un guide sur l’utilisation de cloud-init.

Gérer les Fichiers d’une Instance

Vous pouvez gérer les fichiers d’une instance à l’aide du client Incus sans avoir besoin d’accéder à l’instance via le réseau. Les fichiers peuvent être modifiés ou supprimés individuellement, envoyés depuis ou vers la machine locale. Alternativement, vous pouvez monter le système de fichiers de l’instance sur la machine locale.

Pour les conteneurs, ces opérations sur les fichiers fonctionnent toujours et sont directement gérées par Incus. Pour les machines virtuelles, le processus incus-agent doit être en cours d’exécution à l’intérieur de la machine virtuelle pour que cela fonctionne.

Modifier les fichiers d’une instance

Pour modifier un fichier d’une instance depuis votre machine locale, utilisez la commande suivante :

incus file edit <nom_instance>/<chemin_du_fichier>

Par exemple, pour modifier le fichier /etc/hosts dans l’instance, utilisez la commande suivante :

incus file edit my-container/etc/hosts

Remarque : Le fichier doit déjà exister sur l’instance. Vous ne pouvez pas utiliser la commande edit pour créer un fichier dans l’instance.

Supprimer des fichiers de l’instance

Pour supprimer un fichier de votre instance, utilisez la commande suivante :

incus file delete <nom_instance>/<chemin_du_fichier>

Télécharger des fichiers de l’instance vers la machine locale

Pour télécharger un fichier de votre instance vers votre machine locale, utilisez la commande suivante :

incus file pull <nom_instance>/<chemin_du_fichier> <chemin_local_fichier>

Par exemple, pour extraire le fichier /etc/hosts vers le répertoire courant, utilisez la commande suivante :

incus file pull my-instance/etc/hosts .

Vous pouvez également télécharger un fichier de l’instance vers la sortie standard (stdout) et le rediriger vers la commande stdin d’un autre programme, par exemple pour consulter un fichier journal :

incus file pull my-instance/var/log/syslog - | less

Pour télécharger un répertoire avec tout son contenu, utilisez la commande suivante :

incus file pull -r <nom_instance>/<chemin_du_repertoire> <chemin_local>

Envoyer des fichiers de la machine locale vers l’instance

Pour envoyer un fichier de votre machine locale vers l’instance, utilisez la commande suivante :

incus file push <chemin_local_fichier> <nom_instance>/<chemin_du_fichier>

Pour envoyer un répertoire avec tout son contenu, utilisez la commande suivante :

incus file push -r <chemin_local> <nom_instance>/<chemin_du_repertoire>

Comment accéder à la console d’une instance

Vous pouvez utiliser la commande incus console pour vous connecter à la console d’une instance. La console est disponible dès le démarrage de l’instance, ce qui permet de consulter les messages de démarrage et de déboguer d’éventuels problèmes de lancement pour un conteneur ou une machine virtuelle.

Obtenir une console interactive

Pour obtenir une console interactive, utilisez la commande suivante :

incus console <nom_instance>

Afficher les logs de démarrage

Pour afficher uniquement les messages du journal, utilisez l’option --show-log :

incus console <nom_instance> --show-log

Démarrer une instance avec la console attachée

Vous pouvez également attacher directement la console lors du démarrage de l’instance :

incus start <nom_instance> --console

Accéder à la console graphique (pour les VM)

Pour les machines virtuelles, vous pouvez vous connecter à la console graphique, ce qui permet, par exemple, d’installer un système d’exploitation via une interface graphique ou d’exécuter un environnement de bureau.

L’avantage supplémentaire est que la console est disponible même si le processus incus-agent ne fonctionne pas encore.

Pour démarrer la console VGA avec une sortie graphique pour votre machine virtuelle, vous devez installer un client SPICE. Incus supporte ces deux clients :

• remote-viewer (souvent inclus dans le package virt-viewer)
• spicy (inclus dans le package spice-client-gtk ou spice-gtk-tools)

Ensuite, utilisez la commande suivante pour accéder à la console VGA avec sortie graphique :

incus console <nom_vm> --type vga

Conclusion

Avec ces bases sur l’utilisation d’Incus pour la gestion des images et des instances, vous êtes maintenant en mesure de déployer et de gérer vos environnements de conteneurs ou de machines virtuelles. Dans le prochain guide, nous aborderons Cloud-init, une fonctionnalité puissante pour automatiser la configuration de vos instances dès leur lancement. Cela vous permettra d’aller encore plus loin dans l’automatisation de vos déploiements.