Concepts Rudder : Techniques, Directives, Groupes et Règles

Mise à jour : 17/12/2025

Avant d’installer et de créer votre première configuration Rudder, il est essentiel de comprendre comment l’outil organise la gestion de configuration. Rudder repose sur 4 concepts fondamentaux qui s’emboîtent comme des pièces de puzzle.

Ce guide vous explique chaque concept, comment ils interagissent, et pourquoi cette organisation facilite la gestion d’infrastructures complexes.

La vision d’ensemble

Imaginez que vous voulez installer et configurer Apache sur tous vos serveurs web. Voici comment Rudder structure cette tâche :

┌─────────────────────────────────────────────────────────────────────────────┐
│                              RÈGLE (Rule)                                   │
│                    "Apache sur tous les serveurs web"                       │
│                                                                             │
│         ┌─────────────────────┐         ┌─────────────────────┐             │
│         │   DIRECTIVE         │         │   GROUPE (Group)    │             │
│         │ "Apache en HTTPS"   │  ─────► │ "Serveurs web"      │             │
│         │                     │         │                     │             │
│         │  ┌───────────────┐  │         │  • web-prod-01      │             │
│         │  │  TECHNIQUE    │  │         │  • web-prod-02      │             │
│         │  │ "Apache HTTP  │  │         │  • web-staging-01   │             │
│         │  │   Server"     │  │         │                     │             │
│         │  └───────────────┘  │         └─────────────────────┘             │
│         │                     │                                             │
│         │  enable_ssl: true   │                                             │
│         │  ssl_port: 443      │                                             │
│         └─────────────────────┘                                             │
└─────────────────────────────────────────────────────────────────────────────┘

En résumé :

La Technique définit comment faire quelque chose (installer Apache, gérer SSL…)
La Directive configure quoi faire exactement (activer SSL, port 443, chemin des certificats…)
Le Groupe définit qui est concerné (mes serveurs web)
La Règle combine Directive + Groupe pour dire “appliquer ceci à ceux-là”

Les Techniques : le “comment”

Qu’est-ce qu’une Technique ?

Une Technique est un “modèle réutilisable” qui décrit comment réaliser une tâche de configuration. C’est l’équivalent d’une recette de cuisine : elle liste les étapes à suivre pour obtenir un résultat.

Analogie : Si vous voulez faire un gâteau au chocolat, la Technique serait la recette qui explique les étapes (mélanger, cuire…). Mais la recette ne dit pas quelle marque de chocolat utiliser ni à quelle température exacte cuire — c’est le rôle de la Directive.

Les Techniques intégrées

Rudder est livré avec des dizaines de Techniques prêtes à l’emploi couvrant les besoins courants :

Catégorie	Exemples de Techniques
Paquets	Package management, APT repository
Fichiers	File content, File template, Permissions
Services	Service management, Systemd service
Utilisateurs	User management, Group management, SSH keys
Sécurité	Sudo management, SSH configuration, Firewall
Web	Apache HTTP Server, Nginx
Bases de données	PostgreSQL, MySQL
Monitoring	NTP, Time settings

Ces Techniques sont visibles dans Configuration Management → Techniques.

Créer ses propres Techniques

Pour des besoins spécifiques, vous pouvez créer vos propres Techniques de deux façons :

1. Via le Technique Editor (recommandé)

L’éditeur visuel intégré permet de créer des Techniques sans écrire de code :

Allez dans Configuration Management → Techniques
Cliquez sur Create
Ajoutez des “blocs” de configuration par glisser-déposer
Définissez les paramètres que l’utilisateur pourra renseigner

2. Via YAML/JSON (avancé)

Pour les utilisateurs expérimentés, les Techniques peuvent être écrites en code et versionnées dans Git :

# Exemple simplifié de Technique en YAML
name: "Mon application métier"
description: "Installe et configure notre app interne"
version: "1.0"
parameters:
  - name: APP_VERSION
    description: "Version de l'application"
    default: "latest"
  - name: APP_PORT
    description: "Port d'écoute"
    default: "8080"
method_calls:
  - method: package_present
    params:
      name: "mon-app=${APP_VERSION}"
  - method: service_started
    params:
      name: "mon-app"

Les Directives : le “quoi”

Qu’est-ce qu’une Directive ?

Une Directive est une instance paramétrée d’une Technique. Elle prend une Technique et lui donne des valeurs concrètes.

Analogie : Si la Technique est la recette du gâteau, la Directive dit “je veux ce gâteau avec du chocolat noir Valrhona, cuit 25 minutes à 180°C”.

Pourquoi séparer Technique et Directive ?

Cette séparation offre une grande flexibilité. Imaginons que vous gérez :

Des serveurs web de production (haute disponibilité)
Des serveurs web de staging (configuration de test)

Avec une seule Technique “Apache HTTP Server”, vous créez deux Directives :

Directive	Configuration
”Apache Production”	`max_workers: 400`, `enable_ssl: true`, `log_level: warn`
”Apache Staging”	`max_workers: 50`, `enable_ssl: false`, `log_level: debug`

Créer une Directive

Choisissez une Technique

Dans Configuration Management → Directives, parcourez les Techniques disponibles.
Créez la Directive

Cliquez sur une Technique, puis Create Directive.
Remplissez les paramètres

Chaque paramètre a :
- Un nom et une description
- Une valeur par défaut (modifiable)
- Parfois des options (menu déroulant, checkbox…)
Nommez et documentez

Donnez un nom explicite qui indique l’usage : “NTP - Serveurs Europe” plutôt que “NTP directive 1”.
Sauvegardez

La Directive existe mais n’est appliquée à personne tant qu’elle n’est pas associée à une Règle.

Bonnes pratiques pour les Directives

Un nom explicite qui indique le contexte : “SSH - Bastion servers”, “Users
- Dev team”
Documenter les choix de paramétrage dans la description
Versionner les Directives importantes via l’API ou Git

Les Groupes : le “qui”

Qu’est-ce qu’un Groupe ?

Un Groupe est un ensemble de nodes (machines) partageant des caractéristiques communes. Les Groupes définissent à qui s’appliquent les configurations.

Analogie : Dans une école, les élèves sont regroupés par classe. Quand le professeur dit “la classe de 3ème B doit lire ce livre”, tous les élèves de cette classe sont concernés — sans les nommer individuellement.

Types de Groupes

Rudder propose deux types de Groupes :

Groupes dynamiques

Les membres sont définis par des critères. La liste se met à jour automatiquement quand de nouvelles machines correspondent aux critères.

Exemple : “Toutes les machines avec OS = Ubuntu 22.04”

Groupes statiques

Les membres sont définis manuellement. Vous ajoutez/retirez explicitement chaque machine.

Exemple : “Les 3 serveurs du projet Alpha”

Les critères de Groupes dynamiques

Les Groupes dynamiques utilisent des critères basés sur l’inventaire collecté par Rudder :

Catégorie	Exemples de critères
Système	OS, version, architecture, kernel
Réseau	Hostname, adresse IP, nom de domaine
Matériel	RAM, CPU, fabricant, modèle
Logiciel	Paquets installés, version
Custom	Variables définies par vous

Exemples de requêtes dynamiques :

# Tous les serveurs Debian 12
OS Type = Debian AND OS Version = 12

# Machines avec plus de 8 Go de RAM
Physical Memory > 8192

# Serveurs dont le hostname commence par "web-"
Hostname matches ^web-.*

# Machines ayant nginx installé
Software = nginx

Groupes système

Rudder crée automatiquement des Groupes spéciaux :

All nodes — Toutes les machines acceptées
All Linux nodes — Toutes les machines Linux
All Windows nodes — Toutes les machines Windows
Rudder server — Le serveur Rudder lui-même

Ces Groupes ne peuvent pas être supprimés mais peuvent être utilisés dans vos Règles.

Organisation recommandée

Organisez vos Groupes en catégories logiques :

Groupes/
├── Par environnement/
│   ├── Production
│   ├── Staging
│   └── Développement
├── Par rôle/
│   ├── Serveurs web
│   ├── Bases de données
│   └── Bastions SSH
├── Par localisation/
│   ├── Datacenter Paris
│   └── Datacenter Dublin
└── Par projet/
    ├── Projet Alpha
    └── Projet Beta

Les Règles : l’assemblage final

Qu’est-ce qu’une Règle ?

Une Règle est le lien entre une Directive et un Groupe. Elle répond à la question : “Appliquer quoi à qui ?”

Analogie : Dans notre école, une Règle serait “Le cours de mathématiques (Directive) est dispensé à la classe de 3ème B (Groupe)”.

Anatomie d’une Règle

┌──────────────────────────────────────────────────────────────┐
│                         RÈGLE                                │
│              "Durcissement serveurs web"                     │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   Directives incluses :                                      │
│   ┌─────────────────┐  ┌─────────────────┐                   │
│   │ SSH hardening   │  │ Firewall rules  │                   │
│   └─────────────────┘  └─────────────────┘                   │
│   ┌─────────────────┐                                        │
│   │ Users - webteam │                                        │
│   └─────────────────┘                                        │
│                                                              │
│   Groupes ciblés :                                           │
│   ┌─────────────────┐  ┌─────────────────┐                   │
│   │ Serveurs web    │  │ Load balancers  │                   │
│   │ (dynamique)     │  │ (statique)      │                   │
│   └─────────────────┘  └─────────────────┘                   │
│                                                              │
│   Statut : ● Activée                                         │
└──────────────────────────────────────────────────────────────┘

Plusieurs Directives, plusieurs Groupes

Une Règle peut inclure :

Plusieurs Directives — Pour regrouper des configurations liées
Plusieurs Groupes — Pour cibler différents ensembles de machines

Exemple concret :

La Règle “Baseline sécurité” pourrait inclure :

Directives : SSH durcissement + Firewall + NTP + Sudo
Groupes : Production + Staging

Créer une Règle

Allez dans Configuration Management → Rules
Cliquez sur Create
Nommez la Règle

Choisissez un nom descriptif : “Baseline Linux - Production” plutôt que “Rule 1”.
Sélectionnez les Directives

Cochez les Directives à inclure. Vous pouvez en ajouter plusieurs.
Sélectionnez les Groupes

Cochez les Groupes ciblés. Une machine dans plusieurs Groupes recevra la Directive une seule fois.
Activez la Règle

Par défaut, les nouvelles Règles sont désactivées. Activez-la quand vous êtes prêt.
Sauvegardez

Les nodes concernés recevront la configuration à leur prochaine exécution (toutes les 5 minutes par défaut).

États d’une Règle

État	Signification
Enabled	La Règle est active et sera appliquée
Disabled	La Règle existe mais n’est pas appliquée
Draft	En cours d’édition, non sauvegardée

Comment tout s’articule

Récapitulons avec un exemple complet :

Scénario

Vous voulez que tous vos serveurs web aient :

Le paquet nginx installé
Le service nginx démarré
Un fichier de configuration standardisé

Étapes dans Rudder

Technique : Vous utilisez la Technique intégrée “Package management” et “Service management” (ou créez une Technique custom “Nginx standard”)
Directive : Vous créez une Directive “Nginx Production” avec :
- Package : nginx
- Service : nginx
- Config : /etc/nginx/nginx.conf avec votre contenu
Groupe : Vous créez un Groupe dynamique “Serveurs web” avec le critère :
- Hostname matches ^web-.* OU
- Tag webserver = true
Règle : Vous créez la Règle “Nginx sur serveurs web” qui lie :
- Directive “Nginx Production”
- Groupe “Serveurs web”

Ce qui se passe ensuite

Toutes les 5 minutes, chaque agent contacte le serveur
Le serveur calcule les politiques applicables à chaque node
L’agent reçoit les politiques et les applique
L’agent rapporte l’état de conformité (succès, réparation, erreur)

Pièges courants

Directive sans Règle

Une Directive seule ne fait rien. C’est juste une configuration “en attente”. Il faut créer une Règle pour l’appliquer.

Règle trop large

Évitez d’appliquer une Règle au groupe “All nodes” sans réflexion. Testez d’abord sur un petit groupe.

Conflits de Directives

Si deux Directives modifient le même fichier avec des contenus différents, le résultat peut être imprévisible. Planifiez vos configurations pour éviter les chevauchements.

Groupes dynamiques trop complexes

Des critères trop complexes rendent le débogage difficile. Préférez des critères simples et créez plusieurs Groupes si nécessaire.

À retenir

Technique = Comment faire (le modèle réutilisable)
Directive = Quoi faire exactement (les paramètres concrets)
Groupe = Qui est concerné (ensemble de machines)
Règle = L’assemblage Directive + Groupe
Les Groupes dynamiques se mettent à jour automatiquement selon les critères
Une Directive sans Règle n’est appliquée nulle part
Testez toujours sur un petit groupe avant de déployer largement

Passez à la pratique

Vous maîtrisez maintenant les 4 concepts fondamentaux de Rudder. L’étape suivante : les mettre en œuvre sur une infrastructure réelle.

Prochaine étape recommandée : Votre premier cas d’usage Rudder — Créez votre première Technique, Directive, Groupe et Règle en 15 minutes.

Pour aller plus loin :

Documentation officielle Techniques ↗ — Référence complète des Techniques intégrées