Réponse rapide : ubuntu autoinstall en 30 secondes

Voici les étapes clés :

1. Cloner le dépôt pxeless depuis GitHub
2. Rédiger un fichier user-data avec la configuration autoinstall + cloud-init
3. Récupérer l’image Docker deserializeme/pxeless depuis Docker Hub
4. Lancer la génération de l’ISO all-in-one
5. Flasher l’ISO sur une clé USB et booter

Pourquoi automatiser l’installation Ubuntu ?

Quiconque a déjà installé Ubuntu manuellement sur plus de deux ou trois machines connaît la douleur : cliquer sur les mêmes écrans, saisir les mêmes paramètres, attendre les mêmes téléchargements. Et au bout du compte, on oublie une option, un paquet, ou un réglage réseau. Le résultat ? Des machines hétérogènes, difficiles à maintenir, et un temps perdu considérable.

Le mécanisme ubuntu autoinstall (introduit avec Ubuntu 20.04 LTS) résout exactement ce problème. C’est le successeur du classique preseed de Debian, mais conçu spécifiquement pour le nouveau programme d’installation Subiquity. Il fonctionne via un fichier YAML déclaratif — le user-data — qui décrit l’intégralité de la configuration souhaitée : langue, clavier, partitionnement, utilisateurs, paquets, commandes post-installation…

Les avantages sont immédiats :

• Reproductibilité — Chaque machine est configurée à l’identique, versionnable en Git
• Rapidité — Plus d’interaction humaine, l’installation tourne en autonomie complète
• Scalabilité — Que ce soit 1 ou 100 machines, le processus reste le même
• Auditabilité — La configuration est un fichier texte, lisible et révisable

Et en ajoutant Docker dans l’équation, on élimine le dernier frein : la dépendance à un système Linux pour générer l’ISO. Le projet pxeless encapsule tous les outils nécessaires (xorriso, p7zip, sed, etc.) dans un conteneur Docker. Résultat : que vous soyez sur macOS, Windows ou Linux, vous pouvez builder votre ISO personnalisée sans installer quoi que ce soit sur votre machine.

Cas d’usage concrets

Prérequis

Étape 1 : Cloner pxeless et comprendre la structure

Le projet pxeless (par cloudymax) est un fork amélioré de ubuntu-autoinstall-generator qui ajoute deux fonctionnalités essentielles :

• Support eltorito + GPT — requis pour les ISO Ubuntu depuis la version 20.10, car le format de boot a changé
• Dockerisation complète — toute la chaîne de génération tourne dans un conteneur, rendant le processus portable

Commencez par cloner le dépôt :

git clone https://github.com/cloudymax/pxeless.git
cd pxeless

Voici les fichiers clés du projet :

pxeless/
├── Dockerfile                          # Image Docker avec tous les outils
├── image-create.sh                     # Script principal de génération
├── user-data.basic                     # Exemple de fichier user-data (config minimale)
├── user-data.advanced                  # Config user-data complète
└── extras/                             # Fichiers additionnels optionnels

Le script image-create.sh orchestre tout le processus : téléchargement de l’ISO source Ubuntu, extraction, injection du fichier user-data et meta-data, puis reconstruction de l’ISO bootable avec xorriso.

Étape 2 : Créer son fichier user-data (autoinstall + cloud-init)

Le fichier user-data est le cœur de la configuration ubuntu autoinstall. Il combine deux systèmes complémentaires :

• autoinstall (section principale) — gère le partitionnement, l’identité, les paquets et les commandes post-installation
• cloud-init (sous-section user-data) — gère la configuration système post-premier boot (timezone, locale, etc.)

Voici une version simplifiée inspirée du user-data.basic du projet pxeless. Le fichier original contient en plus une section storage, des packages supplémentaires et une configuration cloud-init avancée.

#cloud-config
autoinstall:
  version: 1
  update: yes
  keyboard: {layout: us, toggle: null, variant: ''}
  locale: en_US.UTF-8
  identity:
    hostname: pxeless
    password: "$6$rounds=4096$saltsaltlettuce$Lp/FV.2oOgew7GbM6Nr8KMGMBn7iFM0x9ZwLqtx9Y4QJmKvfcnS.2zx4MKmymCPQGpHS7gqYOiqWjvdCIV2uN."
    username: vmadmin
  ssh:
    allow-pw: true
    install-server: true
  user-data: # Cloud-init starts here
    disable_root: false
    users:
      - name: vmadmin
        gecos: VM administrator
        groups: users, admin, docker, sudo
        sudo: ALL=(ALL) NOPASSWD:ALL
        shell: /bin/bash
        lock_passwd: false
        passwd: "$6$rounds=4096$saltsaltlettuce$Lp/FV.2oOgew7GbM6Nr8KMGMBn7iFM0x9ZwLqtx9Y4QJmKvfcnS.2zx4MKmymCPQGpHS7gqYOiqWjvdCIV2uN."

Le mot de passe est un hash SHA-512 généré avec mkpasswd -m sha-512. Le projet fournit aussi un fichier user-data.advanced avec une configuration plus complète.

Décortiquons chaque section

version: 1 — Obligatoire. Indique la version du schéma autoinstall. Pour l’instant, seule la version 1 existe.

locale et keyboard — Définit la langue du système et la disposition du clavier. Pour un serveur français : fr_FR et layout fr.

storage — Le partitionnement. L’option lvm crée automatiquement un schéma LVM standard. Vous pouvez aussi utiliser direct pour un partitionnement sans LVM, ou définir un schéma custom avec la syntaxe complète de curtin.

identity — Le compte utilisateur principal. Le mot de passe doit être hashé en SHA-512. Pour le générer :

# Sur un système avec le paquet whois installé :
mkpasswd -m sha-512 "votre-mot-de-passe"

# Ou via Docker si mkpasswd n'est pas disponible :
docker run --rm -it ubuntu:latest bash -c "apt update && apt install -y whois && mkpasswd -m sha-512"

ssh — Active le serveur OpenSSH et autorise (ou non) la connexion par mot de passe. Vous pouvez aussi injecter des clés SSH publiques via authorized-keys.

packages — Liste des paquets APT à installer automatiquement après l’installation de base. Ici on installe curl, git et docker.io pour avoir un serveur prêt à l’emploi.

late-commands — Commandes exécutées en fin d’installation, avant le reboot. Notez que le système cible est monté dans /target, d’où le chemin /target/etc/sudoers.

user-data — Cette sous-section est passée directement à cloud-init lors du premier boot. Elle utilise la syntaxe cloud-init standard (pas autoinstall). Ici on configure le fuseau horaire.

Configuration avancée : clés SSH et réseau statique

Pour un déploiement production, vous voudrez probablement injecter des clés SSH et configurer le réseau :

#cloud-config
autoinstall:
  version: 1
  locale: fr_FR
  keyboard:
    layout: fr
  network:
    network:
      version: 2
      ethernets:
        ens18:
          addresses:
            - 192.168.1.100/24
          routes: # gateway4 est déprécié depuis Ubuntu 22.10 — utiliser routes
            - to: default
              via: 192.168.1.1
          nameservers:
            addresses:
              - 1.1.1.1
              - 8.8.8.8
  storage:
    layout:
      name: lvm
  identity:
    hostname: prod-server-01
    username: admin
    password: "$6$rounds=4096$..."
  ssh:
    install-server: true
    allow-pw: false
    authorized-keys:
      - ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA... admin@workstation
  packages:
    - curl
    - git
    - docker.io
    - htop
    - unattended-upgrades
  late-commands:
    - echo 'admin ALL=(ALL) NOPASSWD:ALL' >> /target/etc/sudoers
    - curtin in-target --target=/target -- systemctl enable docker
  user-data:
    timezone: Europe/Paris
    package_update: true
    package_upgrade: true

Étape 3 : Récupérer l’image Docker pxeless

Pxeless fournit un Dockerfile qui embarque tout le nécessaire : p7zip, xorriso, wget, gpg et les autres utilitaires nécessaires à la manipulation d’ISO.

Récupérez l’image pré-construite depuis Docker Hub :

docker pull deserializeme/pxeless

Le téléchargement prend 1 à 2 minutes selon votre connexion. L’image pèse environ 300 Mo.

Vérifiez que l’image est bien disponible :

docker images | grep pxeless

Étape 4 : Générer l’ISO personnalisée

C’est ici que la magie opère. Le script image-create.sh va :

1. Télécharger l’ISO Ubuntu source (daily build par défaut)
2. L’extraire dans un répertoire temporaire
3. Injecter votre fichier user-data et le meta-data
4. Modifier la configuration GRUB pour activer autoinstall au boot
5. Reconstruire l’ISO bootable avec xorriso (support eltorito + GPT)

La commande complète :

docker run --rm --volume "$(pwd):/data" \
  --user $(id -u):$(id -g) deserializeme/pxeless \
  --all-in-one \
  --user-data user-data.basic \
  --code-name jammy \
  --use-release-iso

Décortiquons les options :

docker run --rm --volume "$(pwd):/data" deserializeme/pxeless \
  --all-in-one --user-data user-data.basic \
  --code-name jammy --use-release-iso \
  --extra-files /data/extras

Exemple production recommandé

Pour un déploiement en production, préférez une ISO release avec vérification GPG désactivée (si vous avez des problèmes de clé) et le kernel HWE :

docker run --rm --volume "$(pwd):/data" \
  --user $(id -u):$(id -g) deserializeme/pxeless \
  --all-in-one \
  --user-data my-user-data.yml \
  --code-name jammy \
  --use-release-iso \
  --use-hwe-kernel

L’ISO générée apparaîtra dans le répertoire courant sous le nom ubuntu-autoinstall-YYYY-MM-DD.iso (ex : ubuntu-autoinstall-2026-03-25.iso). Vous pouvez personnaliser ce nom avec l’option -d, --destination.

Vérifier l’ISO avant de flasher

Bonne pratique : montez l’ISO et vérifiez que votre user-data a bien été intégré avant de flasher une clé USB.

mkdir /tmp/iso-check
sudo mount -o loop ubuntu-autoinstall-$(date +%Y-%m-%d).iso /tmp/iso-check
ls /tmp/iso-check/nocloud/
cat /tmp/iso-check/nocloud/user-data
sudo umount /tmp/iso-check
rmdir /tmp/iso-check

Cas pratique : générer une ISO Ubuntu Desktop automatisée

L’autoinstall ne se limite pas aux serveurs. En combinant la section packages avec les métapaquets Ubuntu Desktop, vous pouvez générer une ISO qui installe automatiquement un poste de travail complet — interface graphique incluse.

Fichier user-data pour un poste de travail Ubuntu

Voici un exemple de user-data qui installe Ubuntu avec l’environnement GNOME complet, les outils essentiels et configure l’autologin :

#cloud-config
autoinstall:
  version: 1
  locale: fr_FR.UTF-8
  keyboard:
    layout: fr
  storage:
    layout:
      name: lvm
  identity:
    hostname: workstation
    username: admin
    # Générer avec : mkpasswd --method=SHA-512 --rounds=4096
    password: "$6$rounds=4096$saltsaltlettuce$Lp/FV.2oOgew7GbM6Nr8KMGMBn7iFM0x9ZwLqtx9Y4QJmKvfcnS.2zx4MKmymCPQGpHS7gqYOiqWjvdCIV2uN."
  ssh:
    install-server: false
  # Paquets installés pendant l'installation (via apt, avant le reboot)
  packages:
    - ubuntu-desktop          # GNOME complet (inclut gdm3, nautilus, etc.)
    - ubuntu-restricted-extras # Codecs multimedia, polices Microsoft
    - curl
    - git
    - wget
    - vim
    - build-essential
    - flatpak
    - gnome-software-plugin-flatpak
  # Fin de l'installation autoinstall — cloud-init commence ici
  user-data:
    disable_root: false
    users:
      - name: admin
        gecos: Administrateur
        groups: users, admin, sudo
        sudo: ALL=(ALL) NOPASSWD:ALL
        shell: /bin/bash
        lock_passwd: false
        passwd: "$6$rounds=4096$saltsaltlettuce$Lp/FV.2oOgew7GbM6Nr8KMGMBn7iFM0x9ZwLqtx9Y4QJmKvfcnS.2zx4MKmymCPQGpHS7gqYOiqWjvdCIV2uN."
    # Autologin GDM (optionnel)
    write_files:
      - path: /etc/gdm3/custom.conf
        content: |
          [daemon]
          AutomaticLoginEnable=true
          AutomaticLogin=admin
    # Commandes post-installation
    runcmd:
      # Ajouter le dépôt Flathub pour Flatpak
      - flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
      # Désactiver le screensaver au login automatique
      - sudo -u admin gsettings set org.gnome.desktop.screensaver lock-enabled false || true

Générer l’ISO Desktop avec pxeless

La commande de génération est identique, il suffit de pointer vers votre fichier user-data desktop :

docker run --rm --volume "$(pwd):/data" \
  --user $(id -u):$(id -g) deserializeme/pxeless \
  --all-in-one \
  --user-data user-data.desktop \
  --code-name jammy \
  --use-release-iso

Étape 5 : Flasher sur USB et booter

Une fois l’ISO générée, il ne reste plus qu’à la flasher sur une clé USB et à démarrer dessus.

Sur Linux / macOS

Identifiez d’abord le device de votre clé USB :

# Linux
lsblk

# macOS
diskutil list

Puis flashez avec dd :

export IMAGE_FILE="ubuntu-autoinstall.iso"

sudo fdisk -l | grep "Disk /dev/"
export DISK_NAME="/dev/sdb"

sudo umount "$DISK_NAME"
sudo dd bs=4M if=$IMAGE_FILE of="$DISK_NAME" status=progress oflag=sync

Sur Windows

Utilisez Rufus ou balenaEtcher pour flasher l’ISO. Sélectionnez le mode « DD Image » si Rufus le propose.

Boot et installation automatique

Branchez la clé USB sur la machine cible et démarrez dessus (via le BIOS/UEFI, touche F2/F12/Del selon le constructeur). Si tout est correctement configuré :

1. GRUB démarre et lance automatiquement l’autoinstall (pas de menu de sélection)
2. Le partitionnement, la copie des fichiers, la configuration et l’installation des paquets se font sans interaction
3. Les late-commands sont exécutés
4. La machine redémarre automatiquement
5. Au premier boot, cloud-init applique la section user-data (timezone, etc.)

Résultat : un serveur Ubuntu prêt à l’emploi, configuré exactement comme spécifié dans votre fichier user-data, accessible en SSH.

Erreurs courantes et solutions

Questions fréquentes

generate-iso:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker run --rm --volume "$(pwd):/data" --user $(id -u):$(id -g) deserializeme/pxeless --all-in-one --user-data user-data.basic --code-name jammy --use-release-iso
  artifacts:
    paths:
      - "*.iso"