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, find: en parcourt plusieurs. Cas d'usage typiques RHCE 2026 : nettoyer les vieux logs (>7 jours), lister les binaires setuid, supprimer les fichiers temporaires.

Pressé ? Le pattern find + cleanup

# Trouver les vieux logs (>7 jours)
- ansible.builtin.find:
    paths: /var/log/myapp
    patterns: "*.log"
    age: 7d
    age_stamp: mtime          # mtime, atime, ctime
    recurse: true
  register: old_logs

- name: Supprimer les vieux logs trouvés
  ansible.builtin.file:
    path: "{{ item.path }}"
    state: absent
  loop: "{{ old_logs.files }}"
  loop_control:
    label: "{{ item.path }}"   # affiche juste le path, pas le dict complet
  become: true

Sécurité non négociable :

• paths: toujours absolu et restrictif, ne jamais utiliser find: avec un path variable non contrôlé sur /. Une variable mal interpolée peut transformer un cleanup en rm -rf /.
• Tester en check mode avant un cleanup en prod : --check exécute le find: mais pas le file: state=absent qui suit.
• recurse: true à manier avec précaution sur des chemins larges, peut être très lent et matcher trop.
• age: 7d est explicite, age: 7 (sans unité) = 7 secondes, pas 7 jours. Toujours mettre l'unité (s, m, h, d, w).

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.

Lab d'accompagnement

Cette page est jumelée au lab labs/modules-diagnostic/find/ dans stephrobert/ansible-training. Détails et commandes en bas de page : Pratiquer dans le lab.

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

- 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

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

À 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.

Pratiquer dans le lab

Cette page a un lab d'accompagnement : labs/modules-diagnostic/find/ dans stephrobert/ansible-training.

Challenge, sur db1.lab :

1. Créer 5 fichiers .log de tailles diverses.
2. find: les .log de plus de 5Mo.
3. Les supprimer en loop:.

Validation pytest+testinfra :

ansible-playbook solution.yml
pytest -v labs/modules-diagnostic/find/challenge/tests/

6 tests vérifient que les petits logs sont conservés et les gros logs supprimés.

Prochaines étapes

Module stat Pour stat sur UN fichier (find: traite N fichiers)

Module file Le compagnon de find: pour supprimer/modifier les fichiers trouvés

archive et unarchive Pour archiver les fichiers trouvés avant suppression

Pivot Modules Vue d'ensemble des modules diagnostic, fichiers, paquets

×

📖 Voir la documentation →