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.

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

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.

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:`

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

Créer 5 fichiers .log de tailles diverses.
find: les .log de plus de 5Mo.
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