Gestion des Conteneurs et des VM avec Incus

Une fois Incus installé, place à la manipulation quotidienne des instances. Ce guide couvre le registre d'images (chercher, filtrer, épingler une version), le lancement de conteneurs et de VM, la gestion des projets, l'accès par exec et shell, la configuration (limites, devices, profils), le transfert de fichiers et la console. Les commandes sont valables sur Incus 7.0.

Ce que vous allez apprendre

• Trouver et filtrer des images dans le registre.
• Démarrer des conteneurs et des VM, et fixer leurs ressources.
• Organiser avec des projets, exécuter des commandes par exec et shell.
• Configurer instances et profils, gérer fichiers et console.

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:

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 existe en version conteneur ou VM. Ces images sont mises à jour en continu, ce qui garde les environnements à jour.

Filtrer les images Incus

Pour lister les images d'une version et d'une architecture précises, comme Debian 13 sur arm64 :

incus image list images: debian/13 arm64

L'option -c personnalise 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 lats debian/13
+----------------------------------+--------------+-----------------+-----------+
|              ALIAS               | ARCHITECTURE |      TYPE       |   SIZE    |
+----------------------------------+--------------+-----------------+-----------+
| debian/13 (7 more)               | x86_64       | CONTAINER       | 100.42MiB |
+----------------------------------+--------------+-----------------+-----------+
| debian/13 (7 more)               | x86_64       | VIRTUAL-MACHINE | 346.74MiB |
+----------------------------------+--------------+-----------------+-----------+
| debian/13/cloud (3 more)         | x86_64       | CONTAINER       | 132.21MiB |
+----------------------------------+--------------+-----------------+-----------+

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:debian/13 local: --alias debian-lts-$(date +%Y%m%d)

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

Pour stocker ces images de manière centralisée et fiable, on configure un remote privé ou un serveur d'images maison, avec des sauvegardes régulières. L'automatisation de la production d'images détaille cette construction reproductible avec Packer et Ansible.

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:debian/13 mon-conteneur

Cette commande crée et démarre un conteneur nommé mon-conteneur à partir d'une image Debian 13. Pour une machine virtuelle, la même commande prend l'option --vm :

incus launch images:debian/13 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: 16167
Created: 2026/07/01 07:45 UTC
Last Used: 2026/07/01 07:45 UTC
Started: 2026/07/01 07:45 UTC

Operating System:
  OS: Debian GNU/Linux
  OS Version: 13
  Kernel Version: 6.12.94+deb13-amd64
  Hostname: ma-vm
  FQDN: localhost

Resources:
  Processes: 106
  CPU usage:
    CPU usage (in seconds): 3

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:debian/13 debian-vm-big --vm --device root,size=30GiB

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

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

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 | 10.107.24.37 (enp5s0) |      | VIRTUAL-MACHINE | 0         |
+---------------+---------+-----------------------+------+-----------------+-----------+
| mon-conteneur | RUNNING | 10.107.24.95 (eth0)   |      | CONTAINER       | 0         |
+---------------+---------+-----------------------+------+-----------------+-----------+

Gestion de projet dans Incus

Un projet dans Incus cloisonne un ensemble de ressources (conteneurs, VM, volumes, réseaux) dans un espace indépendant, pratique pour séparer test, développement et production. La vue globale, tous projets confondus, s'obtient avec --all-projects :

incus list --all-projects

Pour créer un projet, basculer d'un projet à l'autre et cloisonner finement les ressources, reportez-vous au guide dédié Profils et projets Incus, qui détaille la création, le basculement et les stratégies d'isolation.

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

Dans Incus, le cycle de vie d'une instance, conteneur ou VM, se pilote avec quatre commandes simples :

incus start mon-instance    # démarrer
incus stop mon-instance     # arrêter
incus restart mon-instance  # redémarrer
incus delete mon-instance   # supprimer une instance arrêtée, et toutes ses données

Une instance supprimée ne se récupère pas. Arrêter une instance puis afficher la vue globale montre l'état obtenu :

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

Incus atteint vos instances, conteneurs ou VM, sans configurer d'accès réseau : vous exécutez une commande dedans ou ouvrez son shell. Pour exposer un service ou piloter l'adressage IP des instances, voir le guide Réseau.

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

Vous prenez alors le contrôle total de l'instance, comme depuis 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

Les devices couvrent aussi les volumes de stockage et les cartes graphiques. Pour attacher un volume persistant, voir le guide Stockage ; pour exposer un GPU à une instance, voir le guide GPU.

Utilisation des profils dans Incus

Un profil centralise une configuration réutilisable (limites de ressources, périphériques, options) que l'on applique à une ou plusieurs instances. On liste les profils existants avec :

incus profile list

Puis on associe un ou plusieurs profils au lancement d'une instance avec l'option --profile :

incus launch images:debian/13 mon-instance --profile default --profile mon-profil

Pour créer un profil, y ajouter des paramètres, combiner plusieurs profils et comprendre leur priorité, reportez-vous au guide dédié Profils et projets Incus.

Configurer les instances avec cloud-init

Les conteneurs et les machines virtuelles peuvent être configurés au démarrage avec cloud-init, qui automatise des tâches comme l'installation de paquets, la configuration du réseau ou la création d'utilisateurs. Les variantes cloud des images (debian/13/cloud) embarquent l'agent qui lit cette configuration.

Gérer les Fichiers d'une Instance

Le client Incus gère les fichiers d'une instance sans passer par le réseau : ils se modifient ou se suppriment un à un, et s'envoient depuis ou vers 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>
incus file push -r <chemin_local> <nom_instance>/<chemin_du_repertoire>

La seconde forme, avec -r, envoie un répertoire avec tout son contenu.

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

À retenir

• Le registre d'images s'interroge avec incus image list images:, filtrable par distribution et architecture.
• incus launch crée et démarre une instance ; l'option --vm en fait une machine virtuelle.
• Les projets cloisonnent les ressources ; --all-projects donne la vue globale.
• incus exec et incus shell entrent dans une instance sans réseau ; incus file transfère des fichiers.
• Les profils centralisent une configuration réutilisable, appliquée à plusieurs instances.

FAQ : questions fréquentes sur les instances Incus

Comment lancer un conteneur ou une VM avec Incus ?

Comment lister les instances Incus en cours ?

Comment exécuter une commande ou entrer dans une instance Incus ?

Comment transférer un fichier vers ou depuis une instance Incus ?

×

📖 Voir la documentation →