Commandes distantes Salt : cibler les minions, grains et batch

Une fois le master et les minions en place, la première superpuissance de Salt est l'exécution distante : lancer une commande sur des dizaines de serveurs et lire tous les retours d'un coup. Ce guide vous apprend à cibler exactement les bons minions avec les matchers, à exécuter des modules idempotents comme pkg et service, puis à limiter l'impact d'une action avec l'exécution par batch. Public visé : administrateurs ayant déjà un master et des minions opérationnels.

Ce que vous allez apprendre

• Construire une commande Salt : cible plus fonction.
• Cibler les minions par glob, liste, grains et expressions composées.
• Exécuter des modules utiles : cmd, pkg, service.
• Limiter le rayon d'action avec --batch.
• Lire et interpréter les retours de tout le parc.

Prérequis

• Un master et au moins deux minions opérationnels. Si ce n'est pas encore le cas, suivez d'abord Découvrir Salt.
• Les minions de cet exemple s'appellent web1, db1 et proxy1, et portent chacun un grain role (respectivement web, db, proxy).

Anatomie d'une commande Salt

Toute commande d'exécution suit la même structure : salt suivi d'une cible, puis d'une fonction de module, puis d'éventuels arguments.

sudo salt '<cible>' <module>.<fonction> [arguments]

La cible décide quels minions reçoivent l'ordre. La fonction appartient à un module d'exécution (test, cmd, pkg, service, grains et des centaines d'autres). Comprendre le ciblage est ce qui sépare une commande utile d'une commande dangereuse : viser '*' pour un simple test est sain, mais viser '*' pour redémarrer un service peut couper tout le parc.

Cibler les minions : les matchers

La cible par défaut est un glob sur l'identifiant du minion. Mais Salt propose des matchers bien plus précis. Le tableau ci-dessous résume les plus utiles, puis chaque forme est illustrée sur le lab.

Matcher	Option	Vise...
Glob	(défaut)	Les identifiants correspondant au motif
Liste	-L	Une liste explicite d'identifiants
Grain	-G	Les minions dont un fait correspond
Composé	-C	Une combinaison logique de matchers
Nodegroup	-N	Un groupe nommé défini sur le master

Glissez pour voir

Par motif d'identifiant

Le glob filtre sur le nom du minion. Un motif web* ne retient que les serveurs web :

sudo salt 'web*' test.ping

web1:
    True

Par liste explicite

Quand les noms n'ont pas de motif commun, l'option -L énumère les cibles :

sudo salt -L 'web1,db1' test.ping

web1:
    True
db1:
    True

Par grain

C'est le ciblage le plus portable. L'option -G vise les minions selon un fait : leur système, leur architecture ou un rôle que vous leur avez attribué. Viser tous les serveurs Debian, quel que soit leur nom :

sudo salt -G 'os_family:Debian' test.ping

web1:
    True
db1:
    True
proxy1:
    True

Le ciblage par rôle est encore plus parlant, car il ne dépend ni du nom ni de la distribution :

sudo salt -G 'role:web' test.ping

web1:
    True

Par expression composée

L'option -C combine plusieurs matchers avec des opérateurs logiques (and, or, not). Un grain se préfixe alors par G@. Viser les serveurs web ou ceux dont le rôle est db :

sudo salt -C 'web* or G@role:db' test.ping

db1:
    True
web1:
    True

Par groupe nommé (nodegroup)

Répéter la même expression composée à chaque commande devient vite pénible. Un nodegroup nomme une expression de ciblage une seule fois dans la configuration du master, puis se réutilise avec -N. C'est la façon recommandée de figer des cibles récurrentes, sans dupliquer la logique.

/etc/salt/master.d/nodegroups.conf

nodegroups:
  webservers: 'G@role:web'
  donnees: 'G@role:db or G@role:proxy'

Après un redémarrage du master, chaque groupe se cible par son nom :

sudo salt -N webservers test.ping

web1:
    True

Préférez les grains aux noms

Un ciblage par grain (role, os_family) survit au renommage des serveurs et se transpose d'un parc à l'autre. Un ciblage par nom se casse dès que la convention de nommage change. Les grains feront l'objet d'un module dédié plus loin dans le parcours.

Exécuter des modules utiles

Salt expose des centaines de modules d'exécution. Trois reviennent en permanence au quotidien.

cmd : lancer une commande shell

cmd.run exécute une commande brute et rapatrie sa sortie. Pratique pour une information ponctuelle :

sudo salt '*' cmd.run 'grep PRETTY_NAME /etc/os-release'

web1:
    PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
db1:
    PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
proxy1:
    PRETTY_NAME="Debian GNU/Linux 13 (trixie)"

pkg : gérer les paquets

pkg est idempotent et multi-distributions : il installe un paquet seulement s'il manque. Installons Nginx sur les seuls serveurs web :

sudo salt -G 'role:web' pkg.install nginx

web1:
    ----------
    nginx:
        ----------
        new:
            1.26.3-3+deb13u7
        old:
    nginx-common:
        ----------
        new:
            1.26.3-3+deb13u7
        old:

Le champ old vide et new renseigné signalent une installation. Rejouons exactement la même commande :

sudo salt -G 'role:web' pkg.install nginx

web1:
    ----------

Le retour vide prouve l'idempotence : le paquet étant déjà présent, Salt ne fait rien. C'est toute la différence avec un cmd.run 'apt install nginx', qui relancerait apt à chaque fois.

service : piloter les services

service gère l'état des services. Vérifions que Nginx tourne bien après l'installation :

sudo salt -G 'role:web' service.status nginx

web1:
    True

cmd.run en dernier recours

cmd.run exécute n'importe quoi, mais Salt ignore si l'état est déjà atteint : il relance systématiquement. Cherchez toujours un module dédié (pkg, service, file, user) avant de tomber dans le shell brut. Les states, au guide suivant, généralisent cette logique déclarative.

Limiter l'impact avec le batch

Redémarrer un service sur tout le parc en même temps peut provoquer une coupure totale. L'option --batch applique la commande par vagues : Salt n'agit que sur un nombre (ou un pourcentage) de minions à la fois et attend que chaque vague réponde avant de continuer.

sudo salt '*' --batch 2 test.ping

Executing run on ['proxy1', 'web1']
proxy1:
    True
web1:
    True
Executing run on ['db1']
db1:
    True

Salt traite ici deux minions, attend leur réponse, puis passe au dernier. Vous pouvez exprimer la taille de vague en valeur absolue (--batch 2) ou en pourcentage (--batch 25%). Sur un service en frontal, ce réflexe évite l'indisponibilité générale : si une vague échoue, vous arrêtez avant d'avoir cassé l'ensemble.

Lire et interpréter les retours

Chaque minion renvoie un résultat structuré, affiché sous son identifiant. Pour un test.ping, c'est un simple True ; pour pkg.install, c'est un arbre décrivant les changements. En mode batch, Salt ajoute des métadonnées utiles : le jid (identifiant de job) et le retcode (0 si tout va bien).

Le jid permet de retrouver le résultat d'un job plus tard, même si votre terminal s'est fermé :

sudo salt-run jobs.lookup_jid <jid>

Un minion absent de la réponse (« Minion did not return ») n'a pas répondu dans le délai imparti : il est peut-être hors ligne, surchargé, ou en cours de ré-authentification. Le runner manage.up liste les minions réellement joignables pour lever le doute.

Formater les retours pour scripter

Par défaut, Salt affiche un format lisible à l'œil. Pour automatiser, demandez du JSON ou du YAML avec l'option --out : le résultat devient directement exploitable par jq ou n'importe quel script.

sudo salt --out=json 'web1' grains.item os osrelease

{
    "web1": {
        "os": "Debian",
        "osrelease": "13"
    }
}

Le format YAML est plus compact pour une valeur simple :

sudo salt --out=yaml 'web1' test.ping

web1: true

Découvrir les modules à la volée

Devant un besoin nouveau, sys.doc affiche la documentation d'une fonction et sys.list_modules liste les modules disponibles sur un minion. Par exemple, sudo salt 'web1' sys.doc test.ping rappelle que test.ping « n'est pas un ping ICMP » et renvoie simplement True.

Sécurité et bonnes pratiques

Le ciblage est un sujet de sécurité. Trois principes limitent les dégâts.

Tester la cible avant d'agir. Lancez d'abord un test.ping sur votre expression de ciblage : vous voyez exactement quels minions seraient touchés avant d'exécuter une action destructive.

Batcher les opérations à risque. Tout redémarrage ou reconfiguration en frontal passe par --batch, jamais en une seule salve sur '*'.

Restreindre qui peut publier. En production, tout le monde ne doit pas pouvoir lancer n'importe quelle commande sur n'importe quelle cible. Salt offre des ACL de publication côté master pour cadrer qui exécute quoi ; c'est un sujet du guide d'exploitation en production.

Dépannage

Symptôme	Cause probable	Solution
No minions matched the target	Motif ou grain erroné	Vérifier l'expression ; lister les grains avec grains.items
Un minion manque dans la réponse	Hors ligne ou délai dépassé	salt-run manage.up, vérifier le service salt-minion
cmd.run rejoue à chaque fois	Commande non idempotente	Utiliser un module dédié (pkg, service)
Ciblage -G sans résultat	Grain absent sur les minions	Vérifier salt '*' grains.get role
Le batch avance trop lentement	Vague trop petite	Augmenter --batch (valeur ou pourcentage)

Glissez pour voir

À retenir

1. Une commande Salt = une cible plus une fonction de module.
2. Les matchers ciblent par glob ('web*'), liste (-L), grain (-G) ou expression composée (-C).
3. Le ciblage par grains est portable : il survit au renommage et se transpose d'un parc à l'autre.
4. Préférer les modules idempotents (pkg, service) au cmd.run brut : le second passage de pkg.install ne change rien.
5. --batch protège les services en frontal en appliquant la commande par vagues.

Prochaines étapes

Le prochain module, Les states, fait le saut du déclaratif : décrire une fois l'état voulu d'un serveur au lieu d'enchaîner des commandes.

Les states Passer de l'ad-hoc au déclaratif : SLS, top file, highstate idempotent.

Le parcours Salt complet Situer les commandes distantes dans la formation, jusqu'à l'orchestration.

Panorama des outils de gestion de configuration Comparer l'exécution distante de Salt à l'approche d'Ansible et Chef.

×

📖 Voir la documentation →