Puppet : L’outil open source pour automatiser la gestion de tes serveurs

Qu’est-ce que Puppet ?

Puppet est un outil open source de gestion de configuration qui automatise la gestion des serveurs et des applications en décrivant l’état souhaité des ressources. Créé en 2005 par Luke Kanies, il est distribué sous licence Apache 2.0 et utilise un langage déclaratif basé sur Ruby.

Concrètement, au lieu de te connecter manuellement à chaque serveur pour installer un paquet ou modifier un fichier, tu décris ce que tu veux dans un fichier de configuration. Puppet se charge du reste. Cette approche d’infrastructure as code change radicalement la manière de gérer un parc informatique.

Luke Kanies, le créateur, est parti d’un constat simple : l’administration système traditionnelle ne passait pas à l’échelle. En 2005, il a posé les bases d’un outil qui allait devenir un pilier du mouvement DevOps. Aujourd’hui, Puppet est utilisé par des milliers d’entreprises, des startups aux grands comptes.

Pourquoi utiliser Puppet ?

Gérer des serveurs à la main, c’est risqué. Une erreur de frappe, une configuration oubliée, et c’est le drame. Puppet élimine ce risque en garantissant que chaque machine est exactement dans l’état que tu as défini.

L’automatisation apporte trois bénéfices majeurs :

• Cohérence : tous tes serveurs sont configurés de manière identique. Fini les dérives entre les environnements de dev, staging et production.
• Idempotence : tu peux exécuter la même configuration 100 fois, le résultat sera le même. Si le serveur est déjà conforme, Puppet ne fait rien.
• Infrastructure as code : ta configuration est versionnée, testée et partagée comme du code applicatif. Les bonnes pratiques de développement s’appliquent à ton infrastructure.

Dans un environnement DevOps, Puppet s’intègre parfaitement avec les pipelines CI/CD. Il permet de provisionner rapidement des environnements reproductibles, que ce soit sur des machines physiques, des VMs ou des conteneurs.

Comment fonctionne Puppet ?

L’architecture de Puppet repose sur un modèle agent-serveur. Le serveur maître (master) stocke l’ensemble des configurations. Les agents installés sur chaque nœud viennent régulièrement interroger le master pour récupérer leur catalogue.

Voici le cycle de fonctionnement, étape par étape :

Les manifests sont au cœur du système. Ces fichiers texte avec l’extension .pp décrivent les ressources à gérer : paquets, services, fichiers, utilisateurs, etc. Le langage est déclaratif : tu décris l’état final, pas les étapes pour y arriver.

Installer Puppet : Guide pas à pas

Prêt à mettre les mains dans le cambouis ? On va installer Puppet sur Ubuntu 22.04 LTS. Pour tester sans risque, je te recommande d’utiliser Vagrant pour créer des machines virtuelles jetables.

Prérequis

Deux machines sous Ubuntu 22.04 (ou une seule si tu testes en mode standalone). Assure-toi que la résolution DNS fonctionne entre les deux : le master doit être joignable par les agents.

Étape 1 : Installer le serveur maître

Sur la machine qui fera office de master, exécute ces commandes :

wget https://apt.puppet.com/puppet7-release-jammy.deb
sudo dpkg -i puppet7-release-jammy.deb
sudo apt update
sudo apt install puppetserver

Le package puppetserver installe le master avec tous ses composants. Le service démarre automatiquement.

Étape 2 : Configurer le master

Édite le fichier /etc/puppetlabs/puppet/puppet.conf pour ajouter :

[master]
dns_alt_names = puppet,puppet.local

Cette directive permet aux agents de contacter le master sous différents noms. Redémarre ensuite le service :

sudo systemctl restart puppetserver

Étape 3 : Installer l’agent

Sur chaque nœud agent, installe le package agent :

wget https://apt.puppet.com/puppet7-release-jammy.deb
sudo dpkg -i puppet7-release-jammy.deb
sudo apt update
sudo apt install puppet-agent

Étape 4 : Connecter l’agent au master

Sur l’agent, édite /etc/puppetlabs/puppet/puppet.conf et ajoute :

[agent]
server = puppet.local

Lance une première exécution pour que l’agent génère un certificat :

sudo /opt/puppetlabs/bin/puppet agent --test

Sur le master, signe le certificat de l’agent :

sudo /opt/puppetlabs/bin/puppetserver ca sign --all

Utiliser Vagrant pour tester

Si tu n’as pas deux machines sous la main, Vagrant est ton meilleur allié. Un simple Vagrantfile bien configuré te permet de simuler une infrastructure complète sur ton poste.

Écrire son premier manifest Puppet

Maintenant que l’infrastructure est en place, passons à la pratique. On va créer un manifest qui installe et configure Apache.

Sur le master, crée le fichier /etc/puppetlabs/code/environments/production/manifests/site.pp :

node 'agent.local' {
  package { 'apache2':
    ensure => installed,
  }
  
  service { 'apache2':
    ensure => running,
    enable => true,
    require => Package['apache2'],
  }
  
  file { '/var/www/html/index.html':
    ensure  => file,
    content => "<h1>Bienvenue sur mon serveur géré par Puppet !</h1>",
    require => Package['apache2'],
  }
}

Décortiquons ce code :

• package { 'apache2': } : déclare une ressource de type paquet. L’attribut ensure => installed garantit qu’Apache est installé.
• service { 'apache2': } : déclare un service. ensure => running le démarre, enable => true l’active au boot.
• file { '/var/www/html/index.html': } : crée un fichier avec un contenu personnalisé.
• require : définit une dépendance. Le service ne démarre que si le paquet est installé.

Sur l’agent, lance :

sudo /opt/puppetlabs/bin/puppet agent --test

En quelques secondes, Apache est installé, démarré, et la page d’accueil est personnalisée. C’est ça, la magie de l’automatisation.

Utiliser les modules Puppet

Un module est un ensemble réutilisable de manifests, fichiers et templates. La communauté partage des milliers de modules sur Puppet Forge, la bibliothèque officielle.

Pour installer le module Apache officiel :

sudo /opt/puppetlabs/bin/puppet module install puppetlabs-apache

Ensuite, tu peux l’utiliser dans ton manifest avec une syntaxe simplifiée :

node 'agent.local' {
  class { 'apache':
    default_vhost => false,
  }
  
  apache::vhost { 'monsite.local':
    port    => 80,
    docroot => '/var/www/monsite',
  }
}

Le module gère automatiquement l’installation du paquet, la configuration du service et la création des virtual hosts. Un gain de temps énorme. Note le double deux-points dans apache::vhost : c’est la notation des types définis dans un module. Avec un seul, le manifest ne compile pas.

Créer ses propres modules avec le PDK

Le PDK (Puppet Development Kit) est l’outil officiel pour créer et valider des modules. Il fournit une structure standard et des tests automatisés. Il n’est pas disponible dans les dépôts Ubuntu : il faut le télécharger depuis le site officiel.

wget --content-disposition 'https://pm.puppet.com/cgi-bin/pdk_download.cgi?dist=ubuntu&rel=22.04&arch=amd64&ver=latest'
sudo dpkg -i pdk_*.deb
pdk new module mon_module

Cette dernière commande génère un squelette de module prêt à l’emploi, avec les dossiers manifests, templates et spec. Un pdk validate vérifie ensuite la syntaxe et le style de ton code.

Puppet vs Ansible, Chef, Salt : Lequel choisir ?

Le monde de la gestion de configuration ne se limite pas à Puppet. Ansible, Chef et Salt sont des alternatives populaires. Voici une comparaison pour t’aider à choisir.

Quand choisir Puppet ? Si tu gères une infrastructure de plus de 100 serveurs et que tu as besoin d’une conformité stricte, Puppet excelle. Son modèle déclaratif et son idempotence native garantissent que l’état des machines reste conforme dans la durée.

Quand choisir Ansible ? Pour des déploiements ponctuels ou des équipes qui débutent en automatisation. Ansible est plus simple à prendre en main, mais moins adapté aux très grandes infrastructures.

Chef et Salt sont des alternatives solides, mais leur courbe d’apprentissage et leur complexité les réservent souvent à des équipes déjà expérimentées.

Cas d’usage concrets de Puppet

Voyons comment Puppet brille dans la vraie vie. Voici trois scénarios qui illustrent sa puissance.

Déploiement d’une application web

Imagine que tu doives déployer une application PHP sur 20 serveurs web. Avec Puppet, tu écris un manifest qui installe Nginx, PHP-FPM, configure les virtual hosts et déploie le code source. Résultat : 20 serveurs opérationnels en moins de 10 minutes, avec une configuration parfaitement identique.

Gestion de la sécurité

La sécurité, c’est l’affaire de tous. Un module Puppet peut configurer automatiquement le pare-feu (iptables ou nftables), appliquer les règles de durcissement CIS, et s’assurer que les paquets de sécurité sont à jour. Si une règle est modifiée manuellement, Puppet la rétablit à la prochaine exécution.

Gestion des utilisateurs

Gérer des comptes utilisateurs sur 100 machines, c’est un cauchemar. Avec Puppet, tu définis les utilisateurs autorisés et leurs clés SSH dans un manifest central. Les comptes sont créés, mis à jour ou supprimés automatiquement. Un nouveau collaborateur arrive ? Ajoute-le dans le manifest, et en 30 minutes, il a accès à toutes les machines.

❓ Questions fréquentes

✍️ À propos de l'auteur

Laurent

Journaliste numérique

Journaliste numérique passionné par les mutations technologiques, je décrypte l'actualité du web pour Plan-E-Tech. Spécialiste de l'intelligence artificielle, de la cybersécurité et de l'écosystème no-code, j'ai à cœur de rendre les concepts techniques accessibles à tous. Toujours à l'affût des dernières tendances et des meilleurs outils digitaux, j'accompagne les entrepreneurs et les curieux dans leur compréhension de la révolution numérique. Mon objectif : te donner les clés pour maîtriser la tech au quotidien et booster ta productivité.