Accueil » Formations » Administration système » Conteneurs système et machines virtuelles avec Incus

Conteneurs système et machines virtuelles avec Incus

Incus permet de faire tourner, sur un même serveur Linux et avec une seule commande, des conteneurs système (de véritables distributions Linux légères, avec leur init et leurs services) et des machines virtuelles complètes. Ce cours explique son architecture, son installation, la gestion des instances, du stockage, du réseau, des profils, des sauvegardes et de l’accès distant, puis propose six travaux pratiques progressifs et une évaluation finale. Il s’adresse aux administrateurs, techniciens, DSI, RSSI et stagiaires, qu’ils gèrent un unique serveur dans une petite structure ou un parc de nœuds dans un grand groupe.

1. Pourquoi Incus

Incus est un gestionnaire d’instances open source (licence Apache 2.0) développé par la communauté Linux Containers, celle qui maintient aussi LXC. Il est né en 2023 comme fork communautaire de LXD, après la reprise de ce dernier par Canonical. Son principe : une API unique et une ligne de commande unique, incus, pour créer, configurer, sauvegarder et déplacer des conteneurs et des machines virtuelles.

En entreprise, il répond à plusieurs besoins concrets :

  • disposer rapidement d’environnements de test ou de recette isolés, créés et détruits en quelques secondes ;
  • héberger des services d’infrastructure (DNS interne, supervision, outils internes) dans des conteneurs légers, sans le coût d’une machine virtuelle par service ;
  • garder la possibilité de lancer une vraie machine virtuelle quand le besoin l’impose (noyau différent, Windows, isolation plus forte) ;
  • automatiser tout cela par l’API REST, des scripts ou des outils d’infrastructure as code.

Le projet publie deux types de versions. Les versions LTS sont maintenues sur une longue durée : la branche 7.0 LTS, dont la première version corrective est sortie en juillet 2026, est annoncée comme supportée jusqu’en juin 2031. Les versions de fonctionnalités mensuelles (7.1, 7.2…) apportent les nouveautés mais ne sont supportées que jusqu’à la sortie suivante. En production, on choisit donc en général une branche LTS. Pour un premier contact avec l’outil, l’article du blog consacré à Incus présente le projet et ses cas d’usage.

2. Conteneur système, conteneur applicatif, machine virtuelle

Trois technologies cohabitent souvent dans un même service informatique et il faut savoir les distinguer :

  • Le conteneur applicatif (Docker, Podman) empaquette une application et ses dépendances ; il exécute en principe un seul processus principal et se reconstruit à partir d’une image à chaque mise à jour.
  • Le conteneur système (LXC, Incus) se comporte comme un petit serveur : il démarre un système d’init, exécute plusieurs services, se met à jour avec apt ou dnf et s’administre comme une machine. Il partage le noyau de l’hôte, ce qui le rend très léger.
  • La machine virtuelle (QEMU/KVM, utilisé par Incus pour ses VM) émule un matériel complet et exécute son propre noyau. Elle consomme plus de ressources mais offre une isolation plus forte et peut faire tourner un autre système d’exploitation.

Schéma à retenir : sur un hôte Linux, le démon Incus pilote d’un côté des conteneurs qui partagent le noyau de l’hôte (cloisonnés par les espaces de noms, les cgroups et les profils de sécurité du noyau), de l’autre des VM qui reposent sur l’hyperviseur KVM, chacune avec son noyau. Les deux types d’instances se créent avec la même commande ; seule l’option --vm fait la différence.

Bonne pratique : choisissez le conteneur système par défaut pour les services Linux, et réservez la VM aux cas qui l’exigent (autre noyau, autre OS, exigence d’isolation forte, logiciel tiers non supporté en conteneur). Pour des applications packagées en images OCI, un moteur applicatif comme Podman reste souvent plus adapté : voir le panorama de Podman sur le blog.

3. Architecture : démon, client, API et serveurs d’images

Incus repose sur quelques composants simples :

  • Le démon tourne sur chaque serveur hôte. Il gère les instances, le stockage, le réseau et expose une API REST, localement par un socket Unix et, si on l’active, sur le réseau en HTTPS.
  • Le client incus envoie ses ordres à cette API. Le même client peut administrer plusieurs serveurs, appelés remotes, en préfixant le nom de l’instance par celui du serveur (srv1:web).
  • Les serveurs d’images fournissent des images prêtes à l’emploi. Le remote images: donne accès aux images communautaires des principales distributions (Debian, Ubuntu, Alpine, Rocky Linux…), en variantes conteneur et VM.
  • Les ressources partagées : pools de stockage, réseaux, profils et projets, que les instances utilisent.

Une instance est soit un conteneur, soit une VM. Elle est décrite par sa configuration (clés comme limits.cpu), ses périphériques (devices : disque racine, carte réseau, redirection de port…) et les profils qui lui sont appliqués. Comprendre ce modèle « configuration + devices + profils » est la clé de toute l’administration d’Incus.

4. Installation et initialisation

Incus est empaqueté par plusieurs distributions. Sur Debian stable, l’installation passe par les dépôts officiels :

sudo apt install incus

Le paquet incus-base suffit si l’on ne veut que des conteneurs ; le paquet incus ajoute la prise en charge des machines virtuelles. Selon la documentation Debian, si Incus a été installé sans les paquets recommandés, le bridge par défaut nécessite dnsmasq-base. Pour un pool ZFS, Btrfs ou LVM, il faut aussi les outils correspondants (zfsutils-linux, btrfs-progs, lvm2).

L’accès au démon est contrôlé par deux groupes Unix. Le groupe incus donne un accès restreint (projets dédiés à l’utilisateur), le groupe incus-admin un contrôle total du serveur :

sudo usermod -aG incus-admin <utilisateur>
newgrp incus-admin

Vient ensuite l’initialisation, qui crée le pool de stockage, le réseau et le profil par défaut :

sudo incus admin init            # mode interactif, question par question
sudo incus admin init --minimal  # valeurs par défaut, sans question

Le mode interactif demande notamment s’il faut créer un cluster, quel pilote de stockage utiliser, s’il faut créer un bridge réseau et s’il faut exposer l’API sur le réseau. Le mode minimal applique les options par défaut, dont le pilote de stockage dir : il suffit pour un poste d’administration ou un essai rapide, mais un serveur de production mérite une initialisation réfléchie.

Sécurité : l’appartenance au groupe incus-admin permet de créer des instances privilégiées et de monter des répertoires de l’hôte : elle doit être traitée comme un accès administrateur au serveur et réservée aux personnes qui ont déjà ce niveau de droits.

5. Cycle de vie des instances

Les commandes de base couvrent tout le cycle de vie d’une instance :

incus image list images:                      # images disponibles
incus launch images:debian/12 web01           # crée et démarre un conteneur
incus launch images:debian/12 vm01 --vm       # crée et démarre une VM
incus init images:debian/12 test01            # crée sans démarrer
incus list                                    # état, adresses IP, type
incus exec web01 -- bash                      # shell dans l'instance
incus file push hosts web01/etc/hosts         # copie vers l'instance
incus file pull web01/etc/hosts .             # copie depuis l'instance
incus stop web01 ; incus start web01
incus delete web01                            # instance arrêtée
incus delete vm01 --force                     # arrête puis supprime

La différence entre launch et init est importante : init crée l’instance sans la démarrer, ce qui laisse le temps d’ajuster sa configuration (cloud-init, limites, périphériques) avant le premier démarrage. incus info <instance> affiche l’état détaillé, la consommation et les snapshots ; avec --show-log, il ajoute le journal de démarrage, premier réflexe en cas d’instance qui refuse de démarrer. Pour une VM, incus console <instance> ouvre la console série (sortie par Ctrl+a puis q).

Les instances créées à partir de images: sont des systèmes minimaux : on les met à jour et on y installe des paquets comme sur n’importe quel serveur, avec incus exec ou en s’y connectant en SSH.

6. Stockage : pools, pilotes et volumes

Chaque instance a un disque racine placé dans un pool de stockage. Incus propose plusieurs pilotes :

  • dir : un simple répertoire du système de fichiers de l’hôte. C’est le pilote par défaut, sans prérequis, mais sans copie à la volée ni quota efficace : les snapshots et les copies sont des copies complètes.
  • btrfs et zfs : systèmes de fichiers à copie sur écriture. Snapshots et clones quasi instantanés, quotas, compression (ZFS). Ce sont les choix les plus courants pour un serveur dédié.
  • lvm : volumes logiques, adaptés aux VM et aux organisations déjà outillées en LVM.
  • ceph (et CephFS) : stockage distribué, utilisé en cluster pour que les instances puissent changer de nœud sans copier leurs données.
incus storage create pool1 dir
incus storage create pool2 zfs                  # pool ZFS sur fichier image (loop)
incus storage create pool3 zfs source=my-tank   # pool ZFS existant
incus storage list
incus storage info pool2

Sans paramètre source, Incus crée un pool sur un fichier image (périphérique loop) dont la taille par défaut est de 20 % de l’espace libre, avec un minimum de 5 Gio et un maximum de 30 Gio. C’est pratique en laboratoire ; en production, on préfère un disque ou une partition dédiés, plus performants et plus faciles à surveiller. Une instance peut être placée dans un pool précis avec l’option --storage de incus launch, et la taille de son disque racine se fixe par le périphérique root :

incus launch images:debian/12 vm-big --vm --device root,size=30GiB
incus config device override vm01 root size=30GiB

Au-delà du disque racine, les volumes personnalisés permettent de stocker des données indépendamment du cycle de vie de l’instance (base de données, fichiers partagés), puis de les rattacher à une autre instance.

7. Réseau : bridge géré, pare-feu et publication de services

À l’initialisation, Incus crée en général un bridge géré, nommé incusbr0 par défaut, qui fournit aux instances une adresse par DHCP, un résolveur DNS et un accès sortant par NAT. Les instances sont donc joignables depuis l’hôte mais pas depuis le reste du réseau. Le profil par défaut rattache chaque nouvelle instance à ce bridge.

incus network get incusbr0 ipv4.address   # sous-réseau du bridge
incus network create labnet                # nouveau bridge (type par défaut)
incus network attach labnet web01 eth1     # carte supplémentaire

Point de vigilance fréquent : un pare-feu de l’hôte (UFW, firewalld) ou Docker installé sur le même serveur peut bloquer le DHCP, le DNS ou le transfert de paquets, et les instances restent alors sans adresse IP ou sans Internet. La documentation d’Incus donne les règles à ajouter, par exemple pour UFW :

sudo ufw allow in on incusbr0
sudo ufw route allow in on incusbr0
sudo ufw route allow out on incusbr0

Pour publier un service hébergé dans une instance, la solution la plus simple est le périphérique proxy, qui écoute sur un port de l’hôte et relaie vers l’instance :

incus config device add web01 http proxy listen=tcp:0.0.0.0:8080 connect=tcp:127.0.0.1:80

Dans une grande infrastructure, on rattache plutôt les instances directement à un VLAN existant (bridge de l’hôte ou interface macvlan), ou on utilise des réseaux OVN pour créer des réseaux virtuels distribués entre les nœuds d’un cluster.

8. Configuration, profils et cloud-init

La configuration d’une instance se modifie à chaud pour la plupart des limites de ressources :

incus launch images:debian/12 limited --config limits.cpu=1 --config limits.memory=192MiB
incus config set limited limits.memory=128MiB
incus config show limited

Un profil regroupe configuration et périphériques réutilisables. Le profil default est appliqué à toute nouvelle instance ; on crée des profils métier (« web », « base-de-données », « poste-de-test ») et on les combine, les derniers profils appliqués l’emportant sur les premiers, et la configuration propre à l’instance sur les profils :

incus profile create web
incus profile edit web < web.yaml
incus launch images:debian/12 web02 --profile default --profile web
incus profile add web01 web

cloud-init complète les profils : la clé cloud-init.user-data contient un document #cloud-config (paquets à installer, utilisateurs, clés SSH, commandes) exécuté au premier démarrage. Il faut utiliser une image qui embarque cloud-init : sur le serveur images:, ce sont les variantes /cloud (par exemple images:debian/12/cloud). Profils et cloud-init permettent de passer d’instances « bricolées à la main » à des instances reproductibles, condition indispensable dès qu’un parc dépasse quelques machines.

9. Snapshots, sauvegardes et migration

Un snapshot fige l’état d’une instance à un instant donné et permet d’y revenir, par exemple avant une mise à jour :

incus snapshot create web01 avant-maj
incus snapshot restore web01 avant-maj
incus snapshot delete web01 avant-maj
incus info web01                              # liste les snapshots
incus config set web01 snapshots.schedule=@daily
incus config set web01 snapshots.expiry=2w

Un snapshot reste dans le même pool que l’instance : il protège contre une erreur de manipulation, pas contre la perte du disque ou du serveur. Pour une vraie sauvegarde, on exporte l’instance dans une archive, que l’on copie ailleurs selon la règle 3-2-1 :

incus export web01 web01-backup.tar.gz
incus import web01-backup.tar.gz web01-restaure

Enfin, incus copy et incus move copient ou déplacent une instance vers un autre serveur Incus déclaré comme remote ; un conteneur doit être arrêté avant d’être déplacé. Les archives produites peuvent être confiées à un outil de sauvegarde dédupliquée comme BorgBackup.

10. Projets : cloisonner équipes et environnements

Dès que plusieurs équipes ou plusieurs environnements partagent un serveur, la liste unique des instances devient difficile à lire et à sécuriser. Les projets d’Incus répondent à ce besoin : chaque projet possède ses propres instances et, selon sa configuration, ses propres profils, images, volumes et réseaux. Un projet « recette » et un projet « production » peuvent ainsi contenir chacun une instance nommée web01 sans conflit.

Les projets portent aussi des limites : nombre maximal d’instances, mémoire ou processeurs cumulés, interdiction des conteneurs privilégiés ou de certains types de périphériques. C’est l’outil qui permet de confier un espace à une équipe de développement sans lui donner les clés de tout le serveur. Le groupe incus vu au chapitre 4 s’appuie sur ce mécanisme : chaque utilisateur restreint travaille dans un projet qui lui est propre.

  • Dans une petite structure, deux ou trois projets suffisent souvent (production, tests, prestataire) et servent surtout à éviter les erreurs de manipulation.
  • Dans une grande organisation, les projets deviennent l’unité de délégation : un projet par équipe ou par application, des limites qui reflètent la capacité allouée, des droits attribués par l’annuaire d’entreprise via l’authentification OpenID Connect.

Bonne pratique : définissez la convention de nommage des projets, des instances et des profils avant que le parc ne grandisse. Renommer après coup des dizaines d’objets référencés par des scripts et par la supervision est toujours plus coûteux.

11. Sécurité et administration à distance

  • Conteneurs non privilégiés par défaut : l’utilisateur root d’un conteneur est mappé vers un utilisateur sans privilège de l’hôte (clé security.privileged, désactivée par défaut). Ne l’activez qu’en connaissance de cause : un conteneur privilégié n’offre pas de vraie frontière de sécurité.
  • Accès local : limitez le groupe incus-admin aux administrateurs ; donnez aux autres le groupe incus ou des projets restreints.
  • Accès distant : l’API s’expose avec incus config set core.https_address=:8443. Les clients s’authentifient par certificat TLS ; on les autorise avec un jeton à usage unique généré par incus config trust add <client>, puis incus remote add <nom> <jeton> côté client. N’ouvrez le port 8443 qu’au réseau d’administration.
  • Mises à jour : suivez une branche LTS et appliquez ses versions correctives ; mettez aussi à jour le système de chaque instance, qui ne bénéficie pas des mises à jour de l’hôte.
  • Revue des droits : incus config trust list liste les clients autorisés ; retirez sans attendre ceux qui ne servent plus.

12. Déployer et exploiter Incus : petite structure et grand groupe

Dans une petite structure, un serveur unique bien dimensionné suffit souvent : pool ZFS ou Btrfs sur disques dédiés, bridge rattaché au réseau des serveurs, snapshots planifiés, export quotidien vers un stockage externe, administration depuis le poste de l’administrateur via un remote. Incus peut y remplacer plusieurs petites VM par des conteneurs bien plus légers.

Dans un grand groupe, Incus se déploie en cluster de plusieurs nœuds partageant un stockage distribué (Ceph) et des réseaux OVN ; les instances sont réparties entre nœuds et déplacées lors des maintenances. Les projets cloisonnent les équipes (quotas, droits), l’authentification peut s’appuyer sur OpenID Connect et l’ensemble se pilote par l’API, des playbooks Ansible ou le fournisseur Terraform/OpenTofu d’Incus. La supervision des nœuds s’intègre à l’outil en place, par exemple Zabbix ou Prometheus.

Dans les deux cas, la méthode est la même : un laboratoire d’abord (c’est l’objet des TP), des profils et des modèles cloud-init versionnés, une politique de sauvegarde testée par une restauration réelle, puis une montée en charge progressive. Face à une plateforme de virtualisation comme Proxmox VE, qui privilégie l’interface web et la gestion de VM, Incus se distingue par son API, sa ligne de commande et la légèreté des conteneurs système ; les deux approches coexistent souvent.

Exploitation au quotidien

Une fois les instances en production, le travail d’exploitation se résume à quelques routines, à documenter et, si possible, à automatiser :

  • Surveiller la capacité : remplissage des pools de stockage, mémoire et processeur de l’hôte, nombre d’instances. incus storage info et incus info donnent les chiffres ponctuels ; Incus expose aussi des métriques au format Prometheus, que l’outil de supervision peut collecter en continu.
  • Mettre à jour à deux niveaux : l’hôte (noyau, Incus, QEMU) selon la branche suivie, et chaque instance, qui possède son propre système de paquets. Un snapshot avant chaque mise à jour d’instance permet un retour arrière immédiat.
  • Renouveler les instances plutôt que les réparer quand c’est possible : avec des profils et des modèles cloud-init, recréer une instance propre est souvent plus rapide et plus sûr que de corriger une dérive de configuration.
  • Diagnostiquer : en cas de panne, on consulte successivement l’état de l’instance (incus list, incus info --show-log), le réseau (bridge, pare-feu de l’hôte) puis le système de l’instance elle-même (incus exec ou la console pour une VM).
  • Tester les sauvegardes : importer régulièrement une archive sous un autre nom et vérifier que le service redémarre, comme au TP06.

Ces routines sont les mêmes quelle que soit la taille du parc ; seule change la part d’automatisation. Sur un serveur unique, un script planifié et une check-list mensuelle suffisent ; sur un cluster de plusieurs dizaines de nœuds, elles s’intègrent aux outils de supervision, d’ordonnancement et de gestion des changements de l’entreprise.

Évaluation : Conteneurs système et machines virtuelles avec Incus

Répondez aux questions puis vérifiez votre score. Une seule bonne réponse par question.

1. Qu’est-ce qu’un conteneur système Incus partage avec son hôte, contrairement à une machine virtuelle ?
2. Que permet l’appartenance au groupe incus-admin ?
3. Quelle commande crée et démarre une machine virtuelle Debian 12 ?
4. Où Incus crée-t-il un pool Btrfs lancé sans paramètre source ?
5. Que fait le périphérique proxy listen=tcp:0.0.0.0:8080 connect=tcp:127.0.0.1:80 ajouté à web01 ?
6. Une clé limits.memory est définie dans un profil et sur l’instance. Quelle valeur s’applique ?
7. Pourquoi un snapshot ne remplace-t-il pas une sauvegarde ?
8. Pourquoi le contenu de cloud-init.user-data n’a-t-il aucun effet sur une instance existante créée depuis images:debian/12 ?

Pour aller plus loin sur le blog : Incus : conteneurs système et machines virtuelles sous une même API · Podman : des conteneurs sans démon, rootless et compatibles Docker · Proxmox : virtualisation open-source pour l’entreprise

Défiler vers le haut