Module find Ansible : recherche multi-fichiers par pattern

ansible.builtin.find: recherche plusieurs fichiers par pattern (glob ou regex), âge, taille, type. C'est l'équivalent de la commande find Unix mais avec résultat structuré (liste de dicts) consommable par loop: ensuite.

Là où stat: traite un fichier dont le chemin est connu, find: en parcourt plusieurs selon des critères. Cas d'usage typiques RHCE 2026 : nettoyer les vieux journaux de plus de sept jours, lister les binaires setuid, supprimer les fichiers temporaires.

Ce que vous allez apprendre

• Rechercher par pattern (patterns: glob ou use_regex: true).
• Filtrer par âge (age: 7d), taille (size: 10m), type (file_type:).
• Descendre récursivement avec recurse: true.
• Combiner find: + loop: + file: state: absent pour cleanup ciblé.
• Diagnostiquer un timeout sur un FS lent ou un dossier énorme.

Prérequis

• Connaître loop: et register: pour consommer le résultat.

Recherche par pattern

- name: Trouver tous les .log
  ansible.builtin.find:
    paths: /var/log
    patterns: '*.log'
  register: log_files

log_files.files est une liste de dicts (un par fichier trouvé) avec : path, size, mode, mtime, uid, gid, etc., comme un stat: par fichier.

Champs utiles du registre :

• log_files.files : liste des fichiers trouvés (dicts).
• log_files.matched : nombre total trouvé.
• log_files.examined : nombre de fichiers parcourus avant filtrage.

Filtrer par taille

- name: Trouver les .log de 10Mo et plus
  ansible.builtin.find:
    paths: /var/log
    patterns: '*.log'
    size: 10m
  register: big_logs

Format size: :

• 10m = au moins 10 mégaoctets (sans préfixe = >= 10m).
• -100k = moins de 100 kilooctets (préfixe - uniquement).
• 1g = au moins 1 gigaoctet.
• Suffixes : b (bytes), k, m, g, t.

Pas de préfixe + comme avec find Unix

Ansible rejette +10m (syntaxe find Unix). Sans préfixe = supérieur ou égal ; avec - = strictement inférieur.

Filtrer par âge

- name: Logs de plus de 7 jours
  ansible.builtin.find:
    paths: /var/log
    patterns: '*.log'
    age: 7d
  register: old_logs

- name: Fichiers tres recents (< 1h)
  ansible.builtin.find:
    paths: /var/log
    patterns: '*.log'
    age: -1h
  register: recent_logs

Format age: :

• 7d = 7 jours ou plus (basé sur mtime par défaut).
• -1h = moins d'1 heure (signe - = inférieur).
• Suffixes : s (secondes), m (minutes), h (heures), d (jours), w (semaines).

age_stamp:, choisir le timestamp de comparaison : mtime (défaut), atime, ctime.

Filtrer par type

Le module ne rend que des fichiers ordinaires tant qu'on ne lui dit rien, ce qui déroute la première fois qu'on cherche des dossiers et qu'aucun ne remonte. Le paramètre file_type: élargit la recherche aux répertoires, aux liens symboliques ou à tout ce qui existe sous le chemin visé. Les deux tâches suivantes montrent les deux cas les plus fréquents, un nettoyage de dossiers temporaires et un inventaire des liens de /etc.

- name: Trouver tous les dossiers
  ansible.builtin.find:
    paths: /tmp
    file_type: directory

- name: Trouver les symlinks
  ansible.builtin.find:
    paths: /etc
    file_type: link

Valeurs file_type: : file (défaut), directory, link, any.

Descente récursive

- name: Tous les .conf dans /etc et sous-dossiers
  ansible.builtin.find:
    paths: /etc
    patterns: '*.conf'
    recurse: true
  register: all_conf

- name: Compter
  ansible.builtin.debug:
    msg: "{{ all_conf.matched }} fichiers .conf trouves"

Performance : recurse: true sur / peut prendre des heures sur un système chargé. Toujours scoper avec paths: précis.

Pattern cleanup automatique

- name: Trouver les .log > 1Mo
  ansible.builtin.find:
    paths: /tmp
    patterns: '*.log'
    size: 1m
  register: logs_to_clean

- name: Supprimer ces fichiers
  ansible.builtin.file:
    path: "{{ item.path }}"
    state: absent
  loop: "{{ logs_to_clean.files }}"
  loop_control:
    label: "{{ item.path }}"

Pattern find + loop: + file: state: absent. Idempotent : un 2e run trouve 0 fichier → loop: 0 itération.

Alternative shell : find /tmp -name '*.log' -size +1M -delete. Moins lisible, moins idempotent, mais plus rapide sur gros volumes.

Regex au lieu de glob

- name: Find avec regex Python
  ansible.builtin.find:
    paths: /var/log
    patterns: '.*-[0-9]{4}-[0-9]{2}\.log\.gz$'
    use_regex: true
  register: archived_logs

use_regex: true : patterns: devient une regex Python. Plus puissant que glob mais plus complexe.

Pièges courants

Trois de ces symptômes viennent de la syntaxe propre au module, qui n'est pas celle de la commande find du système : le préfixe + sur une taille, les fichiers cachés écartés par défaut et les liens symboliques laissés de côté. Le quatrième tient à la descente récursive, qui parcourt tout ce qui se trouve sous paths: avant qu'un seul filtre s'applique : c'est le point de départ qu'il faut resserrer, jamais le motif.

Symptôme	Cause	Fix
failed to process size: +10m	Préfixe + non accepté	Retirer le +, mettre juste 10m
Recherche très lente sur /	Pas de scope	Toujours paths: précis
Fichiers cachés ignorés	hidden: false (défaut)	Ajouter hidden: true
Symlinks suivis non voulus	follow: false (défaut, OK)	Vérifier valeur de follow:

Glissez pour voir

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• find: retourne <reg>.files (liste de dicts) + <reg>.matched (count).
• patterns: = glob par défaut, use_regex: true pour regex Python.
• size: 10m / age: 7d = filtres standards (pas de préfixe +).
• recurse: true = descente récursive (attention performance).
• file_type: : file / directory / link / any.
• Pattern find + loop + file: state: absent = cleanup idempotent.

Mettre en pratique

Un find: mal filtré supprime toujours plus que prévu, autant s'en rendre compte sur des fichiers jetables. Le lab vous fait générer sur db1.lab une série de journaux de tailles variées, les filtrer par patterns: puis par size:, et enchaîner loop: avec le module file: pour n'effacer que les plus volumineux. Les tests contrôlent les deux versants du cleanup : les petits fichiers encore là, les gros bel et bien partis.

Lab pratique

Module find : recherche multi-fichiers

$ dsoxlab run modules-diagnostic-find

Environnement : VM·Durée : ~30 min

Validé : l'état du système est vérifié après reboot, pas la commande tapée.

Première fois ? Qu'est-ce que dsoxlab et comment l'installer

dsoxlab est la ligne de commande qui prépare un environnement jetable (un shell isolé ou une VM), déroule le scénario du lab, puis vérifie l'état réel du système et calcule un score. Rien n'est installé ni cassé sur votre poste de travail.

Installer la CLI et brancher le catalogue, une seule fois :

uv tool install dsoxlab   # ou : pipx install dsoxlab
dsoxlab catalog add https://github.com/stephrobert/ansible-training

Lancer ce lab, puis valider votre travail :

dsoxlab run modules-diagnostic-find
dsoxlab check modules-diagnostic-find

Voir tous les labs : dsoxlab list-labs. Suivre sa progression : dsoxlab progress. Le guide complet de dsoxlab détaille l'installation, le calcul du score et les pièges.

Pour aller plus loin

• Modules wait_for et pause : Attendre l'apparition d'un fichier plutôt que de boucler sur des recherches successives.
• raw, command, shell, script : Pourquoi un shell: find reste tentant, et ce qu'il coûte en idempotence.
• debug, setup, add_host, group_by : Afficher la liste retournée par find avant d'enchaîner une suppression.

×

📖 Voir la documentation →