Quand on gère des serveurs ou des environnements de développement aux
arborescences complexes, il devient vite indispensable de pouvoir retrouver
rapidement un fichier de log volumineux, un script oublié, ou un répertoire de
projet égaré. La commande find permet de fouiller efficacement dans
l’arborescence d’un système de fichiers, selon des critères comme le nom, la
taille, la date de modification ou encore les permissions. La maîtriser, c’est
gagner du temps au quotidien et éviter de perdre des heures à naviguer
manuellement dans des dossiers imbriqués.
Introduction à find
Section intitulée « Introduction à find »La commande find est l’un des outils les plus puissants et polyvalents
pour rechercher des fichiers et répertoires sous Linux. Contrairement à des
outils comme locate, qui s’appuie sur une base de données mise à jour
périodiquement, find effectue une recherche en temps réel dans le système de
fichiers.
Elle permet non seulement de localiser des fichiers par nom, mais aussi selon une multitude de critères :
- type de fichier (fichier, dossier, lien, etc.),
- taille,
- date de dernière modification ou d’accès,
- propriétaire ou groupe,
- permissions,
- et même d’exécuter une action automatique sur chaque fichier trouvé.
Par exemple, pour trouver tous les fichiers .log de plus de 100 Mo dans
/var/log :
find /var/log -type f -name "*.log" -size +100MOu encore, pour supprimer tous les fichiers temporaires de plus de 7 jours :
find /tmp -type f -mtime +7 -exec rm -f {} \;Avec find, on peut automatiser des nettoyages, des audits, des recherches
ciblées, ou encore des actions conditionnelles — directement en ligne de
commande, sans devoir écrire un script complet.
Syntaxe de base
Section intitulée « Syntaxe de base »La commande find repose sur une syntaxe très flexible qui peut sembler dense
au début, mais qui devient redoutablement efficace une fois maîtrisée. Elle suit
une structure simple :
find [chemin] [conditions] [actions]Composants principaux
Section intitulée « Composants principaux »- Chemin : le point de départ de la recherche. Exemple :
/,/home,.(répertoire courant). - Conditions : critères de sélection (nom, taille, date, type…).
- Actions : ce qu’on veut faire avec les résultats (afficher, supprimer, déplacer…).
Exemple minimal
Section intitulée « Exemple minimal »Pour lister tous les fichiers du répertoire courant et ses sous-dossiers :
find .Exemples avec critères
Section intitulée « Exemples avec critères »Rechercher tous les fichiers appelés config.php dans /var/www :
find /var/www -name "config.php"Rechercher sans tenir compte de la casse (-iname) :
find /home -iname "*.jpg"Afficher les fichiers trouvés avec leur chemin absolu :
find /etc -name "*.conf" -printSyntaxe avec actions
Section intitulée « Syntaxe avec actions »Exécuter une commande sur chaque fichier trouvé (exemple : suppression) :
find /tmp -type f -name "*.tmp" -exec rm {} \;Ici, {} est remplacé par chaque fichier trouvé et \; termine la commande
-exec.
La syntaxe de find est modulaire : on peut enchaîner autant de critères et
d’actions que nécessaire. C’est ce qui la rend à la fois très puissante et
parfaitement adaptable à chaque situation.
Recherche par nom
Section intitulée « Recherche par nom »L’un des usages les plus courants de find est la recherche de fichiers ou de
répertoires selon leur nom. Cette opération peut être précise ou plus souple
grâce aux jokers (*, ?) et à la gestion de la casse.
Rechercher un fichier par nom exact
Section intitulée « Rechercher un fichier par nom exact »Pour trouver un fichier nommé erreurs.log dans /var/log :
find /var/log -name "erreurs.log"Cette commande est sensible à la casse.
Rechercher un fichier sans tenir compte de la casse
Section intitulée « Rechercher un fichier sans tenir compte de la casse »Pour trouver un fichier comme Rapport.TXT, rapport.txt, ou RAPPORT.txt :
find /home -iname "rapport.txt"-iname ignore la casse des lettres, ce qui est utile dans des systèmes avec
des noms de fichiers incohérents.
Utiliser des jokers pour filtrer
Section intitulée « Utiliser des jokers pour filtrer »-
Tous les fichiers
.log:Fenêtre de terminal find /var/log -name "*.log" -
Tous les fichiers qui commencent par
backup:Fenêtre de terminal find /data -name "backup*" -
Tous les fichiers ayant exactement 5 caractères, suivis de
.txt:Fenêtre de terminal find . -name "?????.txt"
Rechercher plusieurs motifs avec -o
Section intitulée « Rechercher plusieurs motifs avec -o »Pour trouver tous les fichiers .sh ou .py :
find . \( -name "*.sh" -o -name "*.py" \)N’oubliez pas d’échapper les parenthèses avec \( et \).
Exclure un motif de la recherche
Section intitulée « Exclure un motif de la recherche »Pour ignorer tous les fichiers .bak :
find . -name "*.txt" ! -name "*.bak"La recherche par nom avec find est un réflexe quotidien pour retrouver un
fichier spécifique sans fouiller à la main. Grâce aux options comme -iname,
aux jokers et aux combinaisons logiques, vous pouvez rapidement cibler ce que
vous cherchez, même dans une arborescence complexe.
Recherche par type de fichier
Section intitulée « Recherche par type de fichier »Avec l’option -type, find permet de filtrer les résultats selon la nature
du fichier : fichier régulier, répertoire, lien symbolique, etc. C’est
indispensable pour cibler une catégorie précise de contenu.
Types de fichiers les plus courants
Section intitulée « Types de fichiers les plus courants »| Code | Type de fichier |
|---|---|
f | fichier régulier |
d | répertoire |
l | lien symbolique (symlink) |
c | périphérique caractère |
b | périphérique bloc |
s | socket |
p | tube nommé (FIFO) |
Trouver tous les fichiers réguliers
Section intitulée « Trouver tous les fichiers réguliers »find /etc -type fTrouver tous les dossiers
Section intitulée « Trouver tous les dossiers »find /home -type dTrouver tous les liens symboliques
Section intitulée « Trouver tous les liens symboliques »find /usr -type lRechercher un type avec un nom spécifique
Section intitulée « Rechercher un type avec un nom spécifique »Par exemple, trouver tous les répertoires nommés tmp :
find / -type d -name "tmp"Ou tous les fichiers .sh :
find . -type f -name "*.sh"Combiner avec d’autres critères
Section intitulée « Combiner avec d’autres critères »Exemple : tous les liens symboliques pointant vers un fichier .conf :
find /etc -type l -name "*.conf"Grâce à l’option -type, vous pouvez affiner très rapidement vos recherches et
éviter d’avoir des résultats parasites comme des répertoires alors que vous
cherchez des fichiers, ou inversement.
Recherche par taille
Section intitulée « Recherche par taille »find permet de localiser des fichiers en fonction de leur taille exacte ou
taille relative (plus grands ou plus petits que…). C’est très utile pour
repérer des fichiers trop volumineux, des vides à nettoyer, ou pour
auditer l’espace disque.
Syntaxe de base
Section intitulée « Syntaxe de base »find [chemin] -size [valeur]La valeur peut être exprimée dans différentes unités :
| Suffixe | Unité |
|---|---|
| c | octets |
| k | kilo-octets |
| M | méga-octets |
| G | giga-octets |
Exemples courants
Section intitulée « Exemples courants »Trouver les fichiers exactement de 1 Mo :
Section intitulée « Trouver les fichiers exactement de 1 Mo : »find /var/log -type f -size 1MFichiers de plus de 100 Mo :
Section intitulée « Fichiers de plus de 100 Mo : »find /var/log -type f -size +100MFichiers de moins de 10 Ko :
Section intitulée « Fichiers de moins de 10 Ko : »find . -type f -size -10kFichiers de taille 0 (vides) :
Section intitulée « Fichiers de taille 0 (vides) : »find /tmp -type f -size 0Rechercher dans une plage de taille
Section intitulée « Rechercher dans une plage de taille »Trouver les fichiers entre 1 Mo et 10 Mo :
find . -type f -size +1M -a -size -10M
-aest l’opérateur et logique (implicite si non précisé).
Utiliser find avec -size permet d’identifier facilement les gros fichiers
oubliés, les archives mal compressées, ou encore de nettoyer
automatiquement certains fichiers trop petits ou trop anciens. C’est une étape
essentielle dans toute tâche de maintenance disque.
Recherche par date
Section intitulée « Recherche par date »Avec find, il est possible de rechercher des fichiers en fonction de leur
date de dernière modification, d’accès, ou de changement de statut.
Cela permet de cibler précisément les fichiers récents, oubliés ou inactifs.
Trois types de dates
Section intitulée « Trois types de dates »| Option | Signification |
|---|---|
-mtime | dernière modification du contenu |
-atime | dernier accès au fichier |
-ctime | dernier changement de métadonnées (chmod, etc.) |
Les valeurs s’expriment en nombre de jours.
Exemples avec -mtime
Section intitulée « Exemples avec -mtime »Fichiers modifiés il y a exactement 7 jours :
Section intitulée « Fichiers modifiés il y a exactement 7 jours : »find . -type f -mtime 7Fichiers modifiés il y a plus de 30 jours :
Section intitulée « Fichiers modifiés il y a plus de 30 jours : »find /var/log -type f -mtime +30Fichiers modifiés il y a moins de 24h :
Section intitulée « Fichiers modifiés il y a moins de 24h : »find . -type f -mtime -1Exemples avec -atime (accès)
Section intitulée « Exemples avec -atime (accès) »Fichiers jamais relus depuis plus de 90 jours :
Section intitulée « Fichiers jamais relus depuis plus de 90 jours : »find /home -type f -atime +90Exemples avec -ctime (statut changé)
Section intitulée « Exemples avec -ctime (statut changé) »Fichiers dont les droits ou propriétaires ont changé récemment :
Section intitulée « Fichiers dont les droits ou propriétaires ont changé récemment : »find /etc -type f -ctime -2Astuce : combiner avec une action
Section intitulée « Astuce : combiner avec une action »Supprimer tous les fichiers temporaires non modifiés depuis 7 jours :
find /tmp -type f -mtime +7 -exec rm -f {} \;Ces options permettent de cibler précisément les fichiers à conserver ou à supprimer selon leur ancienneté. Idéal pour les politiques de rétention, la gestion de logs ou l’audit de fichiers dormants.
Recherche par permissions
Section intitulée « Recherche par permissions »find permet également de filtrer les fichiers en fonction de leurs droits
d’accès (permissions UNIX). C’est un outil précieux pour identifier des
fichiers trop permissifs, incorrectement configurés, ou pour réaliser
des audits de sécurité.
Syntaxe de base
Section intitulée « Syntaxe de base »find [chemin] -perm [mode]Le mode peut être exprimé en :
- notation symbolique (ex :
/u+s,/g=w) - notation octale (ex :
644,755,777)
Exemples avec notation octale
Section intitulée « Exemples avec notation octale »Fichiers ayant exactement les permissions 644 :
Section intitulée « Fichiers ayant exactement les permissions 644 : »find . -type f -perm 644Fichiers avec au moins les permissions 777 :
Section intitulée « Fichiers avec au moins les permissions 777 : »find . -type f -perm -777- Le tiret
-signifie que tous les bits donnés doivent être présents, mais d’autres peuvent l’être aussi.
Fichiers avec exactement 777, ni plus ni moins :
Section intitulée « Fichiers avec exactement 777, ni plus ni moins : »find . -type f -perm 0777Fichiers exécutables par tous :
Section intitulée « Fichiers exécutables par tous : »find /usr/bin -type f -perm -111(Le bit 1 = exécution, sur user, group et autres)
Recherche de fichiers SUID/SGID
Section intitulée « Recherche de fichiers SUID/SGID »Fichiers avec SUID (Set User ID) :
find / -type f -perm -4000Fichiers avec SGID (Set Group ID) :
find / -type f -perm -2000Ce sont souvent des fichiers sensibles, à surveiller en audit.
Utiliser -perm avec find permet de détecter rapidement des erreurs de
configuration, des fichiers exposés, ou simplement de valider des
droits dans des scripts de déploiement ou de vérification.
Recherche par propriétaire et groupe
Section intitulée « Recherche par propriétaire et groupe »Avec find, on peut filtrer les fichiers selon l’utilisateur (-user) ou
le groupe (-group) qui les possède. C’est particulièrement utile pour :
- repérer les fichiers appartenant à un ancien utilisateur,
- identifier des fichiers avec de mauvaises permissions d’accès,
- faire un audit de fichiers sensibles.
Recherche par utilisateur
Section intitulée « Recherche par utilisateur »Fichiers appartenant à l’utilisateur alice :
Section intitulée « Fichiers appartenant à l’utilisateur alice : »find /home -type f -user aliceFichiers non appartenant à un utilisateur spécifique :
Section intitulée « Fichiers non appartenant à un utilisateur spécifique : »find /var -type f ! -user rootRecherche par groupe
Section intitulée « Recherche par groupe »Fichiers appartenant au groupe www-data :
Section intitulée « Fichiers appartenant au groupe www-data : »find /var/www -type f -group www-dataFichiers ne faisant pas partie du groupe adm :
Section intitulée « Fichiers ne faisant pas partie du groupe adm : »find /var/log -type f ! -group admCombiner utilisateur et groupe
Section intitulée « Combiner utilisateur et groupe »Rechercher tous les fichiers appartenant à mysql:mysql :
find /var/lib/mysql -user mysql -group mysqlAvec une action
Section intitulée « Avec une action »Changer les permissions sur tous les fichiers appartenant à user1 :
find /srv -type f -user user1 -exec chmod 640 {} \;Grâce à ces options, on peut effectuer des recherches ciblées sur la propriété des fichiers, automatiser des corrections ou audits et garantir que les données sont bien contrôlées par les bons utilisateurs ou services.
Exécution de commandes sur les résultats
Section intitulée « Exécution de commandes sur les résultats »L’une des fonctionnalités les plus puissantes de find, c’est la possibilité
d’exécuter automatiquement une commande sur chaque fichier trouvé grâce à
l’option -exec. Cela permet de traiter, supprimer, déplacer, analyser ou
modifier les fichiers en une seule ligne.
Syntaxe de base
Section intitulée « Syntaxe de base »find [chemin] [critères] -exec commande {} \;{}est remplacé par le nom de chaque fichier trouvé\;marque la fin de la commande (\échappe le;pour le shell)
Exemples courants
Section intitulée « Exemples courants »Supprimer tous les fichiers .tmp
Section intitulée « Supprimer tous les fichiers .tmp »find /tmp -type f -name "*.tmp" -exec rm {} \;Changer les permissions des fichiers .sh
Section intitulée « Changer les permissions des fichiers .sh »find . -type f -name "*.sh" -exec chmod +x {} \;Compter les lignes dans chaque fichier .log
Section intitulée « Compter les lignes dans chaque fichier .log »find /var/log -type f -name "*.log" -exec wc -l {} \;Utilisation avec -ok pour confirmation
Section intitulée « Utilisation avec -ok pour confirmation »Pour exécuter une commande avec confirmation utilisateur :
find . -name "*.bak" -ok rm {} \;Chaque suppression est alors validée manuellement.
Utilisation avec xargs (pour plus d’efficacité)
Section intitulée « Utilisation avec xargs (pour plus d’efficacité) »Avec un grand nombre de fichiers, -exec peut être lent car chaque appel est
distinct. On peut utiliser xargs :
find . -type f -name "*.log" | xargs grep "erreur"Supprimer les fichiers de plus de 100 Mo :
Section intitulée « Supprimer les fichiers de plus de 100 Mo : »find /data -type f -size +100M -exec rm -f {} \;Grâce à -exec, find devient un véritable moteur d’automatisation : non
seulement vous trouvez les bons fichiers, mais vous pouvez immédiatement agir
dessus, sans écrire de boucle shell ou de script complexe.
Optimisation des recherches
Section intitulée « Optimisation des recherches »Dans les grandes arborescences ou pour des tâches automatisées, il est utile
d’optimiser les recherches avec find pour les rendre plus rapides, plus
ciblées et plus précises. Voici les options principales pour affiner vos
recherches.
Limiter la profondeur avec -maxdepth et -mindepth
Section intitulée « Limiter la profondeur avec -maxdepth et -mindepth »-maxdepth N : limite la descente à N niveaux de profondeur
Section intitulée « -maxdepth N : limite la descente à N niveaux de profondeur »Exemple : rechercher uniquement dans le répertoire courant (niveau 1) :
find . -maxdepth 1 -type f-mindepth N : ignore les N premiers niveaux
Section intitulée « -mindepth N : ignore les N premiers niveaux »Exemple : ignorer le répertoire courant et ne chercher que dans les sous-dossiers :
find . -mindepth 2 -type fOn peut combiner les deux :
find . -mindepth 2 -maxdepth 4 -name "*.log"Exclure un répertoire avec -prune
Section intitulée « Exclure un répertoire avec -prune »Pour ignorer un sous-dossier spécifique pendant la recherche :
find . -path "./node_modules" -prune -o -type f -name "*.js" -printImportant :
-prunedoit être combiné avec-oet
Optimiser les suppressions massives
Section intitulée « Optimiser les suppressions massives »Plutôt que :
find . -name "*.bak" -exec rm {} \;Préférez :
find . -name "*.bak" -print0 | xargs -0 rmCela gère les noms de fichiers avec espaces ou caractères spéciaux.
Utiliser des expressions simples en priorité
Section intitulée « Utiliser des expressions simples en priorité »Les critères simples comme -type, -name ou -mtime sont plus rapides à
évaluer. Placez-les en début de ligne pour un gain de performance.
Ces optimisations permettent de réduire les temps d’exécution, d’éviter des erreurs (fichiers sensibles dans un répertoire à ignorer) et de mieux contrôler la portée de vos recherches, surtout dans des scripts d’administration ou de sauvegarde.
Bonnes pratiques
Section intitulée « Bonnes pratiques »Pour tirer le meilleur parti de la commande find, il est essentiel d’adopter
des pratiques qui garantissent la fiabilité, la sécurité et la
performance de vos recherches, surtout en environnement de production.
Rediriger les erreurs
Section intitulée « Rediriger les erreurs »Pour éviter que les messages d’erreur polluent l’affichage, surtout lors de recherches sur tout le système :
find / -type f -name "*.conf" 2>/dev/nullCela masque les erreurs liées aux permissions refusées.
Toujours tester avec -print avant d’agir
Section intitulée « Toujours tester avec -print avant d’agir »Avant d’utiliser une commande destructive comme rm ou chmod, vérifiez les
fichiers ciblés :
find . -name "*.bak" -printPuis seulement après validation :
find . -name "*.bak" -exec rm {} \;Protéger les chemins avec guillemets
Section intitulée « Protéger les chemins avec guillemets »Utilisez toujours des guillemets autour des motifs :
find . -name "*.sh"Cela évite que le shell n’expande les jokers avant find.
Sécuriser les actions avec -ok
Section intitulée « Sécuriser les actions avec -ok »Pour toute commande risquée (comme supprimer ou modifier en masse), préférez
-ok :
find . -name "*.log" -ok rm {} \;Utiliser xargs avec -print0 pour plus de robustesse
Section intitulée « Utiliser xargs avec -print0 pour plus de robustesse »Pour traiter les noms de fichiers contenant des espaces ou des caractères spéciaux :
find . -type f -print0 | xargs -0 rmUtiliser des chemins absolus dans les scripts
Section intitulée « Utiliser des chemins absolus dans les scripts »Évitez les chemins relatifs dans les cron jobs ou scripts automatisés :
find /var/backups -type f -mtime +30 -exec rm {} \;Ces bonnes pratiques rendent vos recherches avec find plus précises,
sécurisées et adaptées aux environnements critiques, en évitant les
erreurs fréquentes ou les suppressions accidentelles.
Exercices pratiques : maîtriser la commande find sous Linux
Section intitulée « Exercices pratiques : maîtriser la commande find sous Linux »La commande find est un outil incontournable pour rechercher et filtrer des
fichiers ou répertoires sous Linux. Elle est particulièrement utile en
administration système pour gagner du temps et automatiser des actions sur de
grandes structures de fichiers.
Je vous propose de vous exercer avec une série de manipulations guidées pour
découvrir toutes les possibilités de find, puis de relever un challenge
final pour valider vos compétences.
👉 Travaux pratiques : TP 02-04 : Manipuler les fichiers avec
find
Ces exercices couvrent notamment :
- Recherche par nom, sensible ou non à la casse
- Filtrage par type d’élément (fichier, dossier, lien symbolique…)
- Sélection par taille ou vide
- Recherche par date de modification
- Exécution de commandes sur les fichiers trouvés avec
-exec
Vous apprendrez à :
- Gérer de grands arborescences rapidement
- Appliquer des actions ciblées à des fichiers
- Automatiser des nettoyages ou des permissions
Une fois ces exercices terminés, un challenge final vous permettra de mettre en application l’ensemble des fonctionnalités apprises.
Pourquoi pratiquer ?
Travailler avec find vous permet :
- De localiser des fichiers précis en quelques secondes
- D’automatiser des tâches avec des scripts simples
- D’être plus efficace dans la gestion de fichiers volumineux
Suivez les consignes en ligne, expérimentez les différentes options, et utilisez
man find pour approfondir votre maîtrise.
Contrôle de connaissances
Section intitulée « Contrôle de connaissances »Contrôle de connaissances
Validez vos connaissances avec ce quiz interactif
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
Lance le quiz et démarre le chronomètre
📋 Récapitulatif de vos réponses
Vérifiez vos réponses avant de soumettre. Cliquez sur une question pour la modifier.
Détail des réponses
Conclusion
Section intitulée « Conclusion »La commande find est un outil essentiel pour quiconque travaille
régulièrement en ligne de commande. Grâce à sa souplesse et à sa richesse
fonctionnelle, elle permet de retrouver, filtrer et manipuler efficacement des
fichiers dans n’importe quelle arborescence. Que ce soit pour une recherche
rapide, un nettoyage automatisé ou un audit de permissions, la maîtrise de
find fait gagner un temps précieux et renforce la qualité de vos scripts et
interventions système.
FAQ - Questions Fréquemment Posées
Section intitulée « FAQ - Questions Fréquemment Posées »La commande find est un outil puissant de recherche en temps réel dans le système de fichiers Linux, permettant de localiser fichiers et répertoires selon de multiples critères.
Comparaison avec d'autres outils
| Outil | Méthode | Vitesse | Fraîcheur | Usage |
|---|---|---|---|---|
| find | Parcours temps réel | Lente | 100% à jour | Recherche précise avec critères complexes |
| locate | Base de données | Très rapide | Mise à jour quotidienne | Recherche simple par nom |
| grep | Contenu de fichiers | Variable | Temps réel | Recherche dans le contenu |
Syntaxe de base
find [chemin] [critères] [actions]
# Exemples simples
find /home -name "*.log" # Fichiers .log dans /home
find . -type d -name "cache" # Répertoires nommés "cache"
find /var -size +100M # Fichiers > 100 Mo
find /tmp -mtime +7 -delete # Supprimer fichiers > 7 jours
Cas d'usage concrets
- Nettoyage : supprimer fichiers temporaires ou logs anciens
- Audit sécurité : détecter fichiers SUID/SGID ou permissions 777
- Sauvegarde sélective : archiver fichiers modifiés récemment
- Recherche avancée : combiner nom, taille, date, permissions
find et locate sont deux outils de recherche avec des approches radicalement différentes.
Comparaison détaillée
| Critère | find | locate |
|---|---|---|
| Méthode | Parcours du système de fichiers en temps réel | Recherche dans une base de données |
| Vitesse | Lent (parcourt physiquement les répertoires) | Très rapide (simple requête SQL) |
| Fraîcheur | 100% à jour (fichiers actuels) | Dépend de la dernière mise à jour (updatedb) |
| Base de données | Aucune | /var/lib/mlocate/mlocate.db |
| Critères | Multiples (nom, taille, date, permissions, etc.) | Nom de fichier uniquement |
| Ressources | CPU et I/O intensifs | Très léger |
| Permissions | Respecte les permissions de l'utilisateur | Affiche tous les fichiers indexés |
Mise à jour de la base locate
# Mettre à jour manuellement la base de données
sudo updatedb
# Vérifier la date de dernière mise à jour
ls -lh /var/lib/mlocate/mlocate.db
# Configuration (quotidienne par défaut via cron)
cat /etc/updatedb.conf
Exemples pratiques
# locate : recherche rapide par nom
locate nginx.conf # Instantané
locate -i readme # Insensible à la casse
# find : recherche précise avec critères
find /etc -name nginx.conf -type f # Plus lent mais précis
find /var/log -name "*.log" -mtime -1 # Fichiers modifiés < 24h
Quand utiliser quoi ?
- locate : recherche rapide de fichiers connus, système stable
- find : recherche précise, fichiers récents, critères multiples, scripts automatisés
La syntaxe de find suit une structure logique : find [chemin] [tests] [actions]
Structure détaillée
find [chemin_départ] [options] [tests/critères] [actions]
└─ où chercher └─ comment └─ quoi chercher └─ que faire
Composants
| Composant | Description | Exemples |
|---|---|---|
| Chemin | Point de départ de la recherche | /home, ., /var/log |
| Options | Modificateurs de comportement | -maxdepth 2, -mount |
| Tests | Critères de filtrage | -name, -type, -size, -mtime |
| Actions | Opérations sur résultats | -print, -delete, -exec |
Exemples progressifs
# 1. Simple : lister tous les fichiers
find /home/user
# 2. Avec test : fichiers .txt uniquement
find /home/user -name "*.txt"
# 3. Tests multiples : fichiers .txt > 1 Mo
find /home/user -name "*.txt" -size +1M
# 4. Avec action : supprimer fichiers .tmp
find /tmp -name "*.tmp" -delete
# 5. Complexe : logs > 100 Mo modifiés > 7 jours → archiver
find /var/log -name "*.log" -size +100M -mtime +7 -exec gzip {} \;
Opérateurs logiques
# ET implicite (par défaut)
find . -name "*.log" -size +10M # nom ET taille
# OU explicite
find . -name "*.log" -o -name "*.txt" # .log OU .txt
# Négation
find . ! -name "*.git" # tout SAUF .git
find . -not -user root # pas propriétaire root
# Groupement avec parenthèses
find . \( -name "*.log" -o -name "*.txt" \) -size +1M
Diagramme de flux
find /var/log
↓
[Tests] -name "*.log" → Non → Ignorer
↓ Oui
[Tests] -mtime +30 → Non → Ignorer
↓ Oui
[Action] -delete → Supprimer le fichier
La recherche par nom avec find offre plusieurs options selon la sensibilité à la casse et le type de correspondance.
Options de recherche
| Option | Sensibilité casse | Portée | Usage |
|---|---|---|---|
-name |
Sensible | Nom du fichier uniquement | Recherche exacte |
-iname |
Insensible | Nom du fichier uniquement | Recherche flexible |
-path |
Sensible | Chemin complet | Filtrage par arborescence |
-ipath |
Insensible | Chemin complet | Filtrage flexible |
-regex |
Sensible (par défaut) | Expression régulière | Recherche complexe |
Wildcards (jokers)
# * : n'importe quels caractères (0 ou plus)
find /var/log -name "*.log" # Tous les .log
find . -name "access*" # access.log, access_2024.log...
# ? : exactement un caractère
find . -name "file?.txt" # file1.txt, fileA.txt (pas file10.txt)
# [] : un caractère parmi une liste
find . -name "file[0-9].txt" # file0.txt à file9.txt
find . -name "[A-Z]*.txt" # Commence par majuscule
# Combinaisons
find . -name "[Dd]ocker*.[jt]son" # Docker.json, dockerfile.json...
Sensibilité à la casse
# -name : sensible à la casse
find . -name "README.md" # Trouve README.md uniquement
# -iname : insensible à la casse
find . -iname "readme.md" # Trouve README.md, readme.MD, ReadMe.md...
Recherche par chemin
# -path : inclure le chemin dans la recherche
find . -path "*/node_modules/*" # Fichiers dans node_modules
find . -path "*/test/*.js" # Fichiers .js dans répertoires test
# Exclure des chemins
find . -path "*/node_modules" -prune -o -name "*.js" -print
Regex (recherche avancée)
# Expression régulière sur le chemin complet
find . -regex ".*/[a-z]+\\.log" # Noms en minuscules + .log
# Regex POSIX étendue (-regextype posix-extended)
find . -regextype posix-extended -regex ".*\\.(jpg|png|gif)$"
Cas pratiques
# Fichiers de configuration
find /etc -name "*.conf"
# Scripts shell
find . -name "*.sh" -o -name "*.bash"
# Fichiers cachés
find ~ -name ".*" -type f
# Fichiers temporaires
find /tmp -name "*~" -o -name "*.tmp" -o -name "*.swp"
L'option -type permet de filtrer les résultats selon le type d'entrée dans le système de fichiers.
Types disponibles
| Type | Description | Exemple |
|---|---|---|
f |
Fichier régulier | Documents, scripts, exécutables |
d |
Répertoire (directory) | Dossiers |
l |
Lien symbolique (symlink) | Raccourcis système |
c |
Périphérique caractère | /dev/null, /dev/tty |
b |
Périphérique bloc | /dev/sda, disques |
p |
Tube nommé (pipe/FIFO) | Communication inter-processus |
s |
Socket | Communication réseau locale |
Exemples courants
# Fichiers réguliers uniquement
find /home -type f -name "*.pdf"
# Répertoires uniquement
find /var -type d -name "cache"
# Liens symboliques
find /usr/bin -type l
# Liens symboliques cassés (dead symlinks)
find /opt -type l ! -exec test -e {} \; -print
Combinaisons utiles
# Fichiers .sh exécutables
find . -type f -name "*.sh" -executable
# Répertoires vides
find /tmp -type d -empty
# Fichiers vides (0 octet)
find /var/log -type f -empty
# Sockets dans /var/run
find /var/run -type s
Cas d'usage spécifiques
# Auditer les liens symboliques dans /etc
find /etc -type l -ls
# Trouver tous les répertoires .git
find ~/projects -type d -name ".git"
# Lister les périphériques bloc
find /dev -type b
# Nettoyer les répertoires vides
find /tmp -type d -empty -delete
L'option -size permet de filtrer les fichiers selon leur taille, avec différentes unités et opérateurs.
Unités de taille
| Suffixe | Unité | Taille réelle |
|---|---|---|
c |
Octets (bytes) | 1 octet |
k |
Kilooctets | 1024 octets |
M |
Mégaoctets | 1024 Ko |
G |
Gigaoctets | 1024 Mo |
T |
Téraoctets | 1024 Go |
| (sans) | Blocs de 512 octets | Ancienne syntaxe |
Opérateurs
# Exactement N unités
find . -size 100k # Exactement 100 Ko
# Plus grand que (+)
find . -size +100M # Fichiers > 100 Mo
# Plus petit que (-)
find /var/log -size -1k # Fichiers < 1 Ko
# Plages (combinaison)
find . -size +10M -size -100M # Entre 10 Mo et 100 Mo
Exemples pratiques
# Logs volumineux (> 100 Mo)
find /var/log -type f -size +100M
# Fichiers vides (0 octet)
find /tmp -type f -size 0
# Cache Docker (images > 1 Go)
find /var/lib/docker -type f -size +1G
# Fichiers suspects (très petits ou très gros)
find /home -type f \( -size -10c -o -size +5G \)
Nettoyage et optimisation
# Supprimer fichiers temporaires > 100 Mo
find /tmp -type f -size +100M -mtime +7 -delete
# Archiver logs > 50 Mo
find /var/log -name "*.log" -size +50M -exec gzip {} \;
# Lister les 10 plus gros fichiers
find /home -type f -size +10M -exec ls -lh {} \; | sort -k5 -hr | head -10
Conversion d'unités
# 100 Mo = 102400 Ko = 104857600 octets
find . -size +100M
find . -size +102400k # Équivalent
find . -size +104857600c # Équivalent
find propose plusieurs options pour filtrer selon les horodatages (timestamps) des fichiers.
Options de date
| Option | Unité | Signification | Usage |
|---|---|---|---|
-mtime |
Jours | Modification du contenu | Fichiers édités il y a X jours |
-atime |
Jours | Accès en lecture | Fichiers consultés il y a X jours |
-ctime |
Jours | Changement de métadonnées | Permissions/propriétaire modifiés |
-mmin |
Minutes | Modification (minutes) | Fichiers modifiés récemment |
-amin |
Minutes | Accès (minutes) | Fichiers consultés récemment |
-cmin |
Minutes | Changement (minutes) | Métadonnées changées récemment |
-newer |
Référence | Plus récent qu'un fichier | Comparaison relative |
Opérateurs temporels
# +N : plus de N (strictement supérieur)
find /var/log -mtime +30 # Modifiés il y a PLUS de 30 jours
# -N : moins de N (strictement inférieur)
find /tmp -mtime -7 # Modifiés il y a MOINS de 7 jours
# N : exactement N
find . -mtime 0 # Modifiés aujourd'hui (dernières 24h)
Exemples concrets
# Fichiers récents (< 24h)
find /var/log -type f -mtime 0
find /var/log -type f -mmin -60 # Dernière heure
# Fichiers anciens (> 90 jours)
find /backup -type f -mtime +90
# Fichiers non utilisés (jamais accédés depuis 1 an)
find /opt -type f -atime +365
# Fichiers modifiés dans les 7 derniers jours
find /home -type f -mtime -7
Comparaison avec fichier référence
# Fichiers plus récents que reference.txt
find . -newer reference.txt
# Fichiers modifiés après une date précise
touch -t 202601010000 /tmp/marker # 1er janvier 2026
find /data -newer /tmp/marker
Combinaisons utiles
# Logs anciens ET volumineux
find /var/log -name "*.log" -mtime +30 -size +100M
# Fichiers récents d'un utilisateur spécifique
find /home -user alice -mtime -7
# Nettoyage cache (> 7 jours et non accédés)
find ~/.cache -type f -atime +7 -delete
Plages de dates
# Entre 7 et 30 jours
find /tmp -mtime +7 -mtime -30
# Modifiés aujourd'hui ou hier
find /var/log -mtime -2
L'option -perm permet de filtrer selon les permissions Unix, avec différents modes de correspondance.
Notations
| Notation | Exemple | Description |
|---|---|---|
| Octale | 755, 644 |
Permissions en chiffres (rwxr-xr-x) |
| Symbolique | u=rwx,g=rx,o=rx |
Permissions lisibles (user/group/other) |
Modes de correspondance
# Correspondance exacte (sans préfixe)
find . -perm 644 # Exactement rw-r--r--
# Au moins ces permissions (préfixe -)
find . -perm -644 # Au minimum rw-r--r-- (peut avoir +)
# Au moins une permission (préfixe /)
find . -perm /222 # Inscriptible par user OU group OU other
Exemples de sécurité
# Fichiers inscriptibles par tous (DANGER)
find / -type f -perm -002 2>/dev/null
find /var/www -perm /o+w # Symbolique
# Permissions 777 (très permissif)
find /home -type f -perm 0777
# Fichiers SUID (élévation privilèges)
find / -perm -4000 -type f 2>/dev/null
# Fichiers SGID
find / -perm -2000 -type f 2>/dev/null
# SUID + SGID (sticky bit)
find / -perm -6000 -type f 2>/dev/null
Audit des permissions
# Fichiers exécutables non propriétaire root
find /usr/bin -type f -perm -111 ! -user root
# Répertoires sans permission d'exécution
find /var -type d ! -perm -111
# Fichiers lisibles par tous dans /etc
find /etc -type f -perm -004
# Scripts shell non exécutables
find . -name "*.sh" ! -perm -100
Notation symbolique avancée
# Fichiers avec permission user write
find . -perm -u+w
# Fichiers avec permission group read
find . -perm -g+r
# Fichiers avec permission other execute
find /usr/local -perm -o+x
Corriger les permissions
# Retirer permissions d'écriture pour other
find /var/www -type f -perm /o+w -exec chmod o-w {} \;
# Ajouter permission d'exécution aux .sh
find . -name "*.sh" ! -perm -u+x -exec chmod u+x {} \;
# Répertoires : 755, fichiers : 644
find /var/www -type d -exec chmod 755 {} \;
find /var/www -type f -exec chmod 644 {} \;
Bits spéciaux
| Bit | Valeur | Signification |
|---|---|---|
| SUID | 4000 | S'exécute avec les droits du propriétaire |
| SGID | 2000 | S'exécute avec les droits du groupe |
| Sticky | 1000 | Seul le propriétaire peut supprimer (ex: /tmp) |
# Trouver tous les fichiers avec bits spéciaux
find / -perm /7000 -ls 2>/dev/null
find propose plusieurs options pour filtrer selon le propriétaire ou le groupe des fichiers.
Options disponibles
| Option | Type | Description | Exemple |
|---|---|---|---|
-user |
Nom ou UID | Fichiers appartenant à un utilisateur | alice, 1000 |
-group |
Nom ou GID | Fichiers appartenant à un groupe | www-data, 33 |
-uid |
UID uniquement | Recherche par identifiant numérique | 1000 |
-gid |
GID uniquement | Recherche par identifiant de groupe | 1000 |
-nouser |
Orphelin | Fichiers sans propriétaire existant | Audit sécurité |
-nogroup |
Orphelin | Fichiers sans groupe existant | Audit sécurité |
Exemples par nom
# Fichiers d'un utilisateur
find /home -user alice
# Fichiers d'un groupe
find /var/www -group www-data
# Fichiers root uniquement
find /etc -user root -type f
Exemples par ID (UID/GID)
# Recherche par UID
find /home -uid 1000
# Recherche par GID
find /var -gid 33 # www-data
# Utile après suppression utilisateur
find / -uid 1005 2>/dev/null # Utilisateur supprimé
Combinaisons avec permissions
# Fichiers de alice avec permissions 644
find /home/alice -user alice -perm 644
# Fichiers www-data inscriptibles par le groupe
find /var/www -group www-data -perm -g+w
# Fichiers non-root avec SUID (DANGER)
find / ! -user root -perm -4000 2>/dev/null
Audit de sécurité
# Fichiers sans propriétaire (orphelins)
find / -nouser 2>/dev/null
# Fichiers sans groupe
find / -nogroup 2>/dev/null
# Fichiers d'utilisateurs supprimés (UIDs invalides)
find /home -nouser -ls
# Fichiers appartenant à un utilisateur spécifique dans /tmp
find /tmp -user alice -type f
Changer la propriété
# Réassigner les fichiers orphelins
find / -nouser -exec chown root:root {} \;
# Changer le groupe de tous les fichiers d'un projet
find /var/www/projet -exec chgrp www-data {} \;
L'option -exec permet d'exécuter une commande sur chaque fichier trouvé par find.
Syntaxes -exec
| Syntaxe | Exécution | Usage | Performance |
|---|---|---|---|
-exec cmd {} \; |
Une commande par fichier | Actions simples | Lent (fork par fichier) |
-exec cmd {} + |
Commande groupée (batch) | Actions en masse | Rapide (comme xargs) |
Placeholder {}
Le symbole {} est remplacé par le chemin du fichier trouvé.
# Syntaxe de base
find /tmp -name "*.tmp" -exec rm {} \;
│ │ │
commande | placeholder | terminateur
Exemples pratiques
# Supprimer des fichiers
find /tmp -name "*.log" -exec rm {} \;
find /tmp -name "*.log" -delete # Équivalent plus rapide
# Changer les permissions
find /var/www -type f -exec chmod 644 {} \;
find /var/www -type d -exec chmod 755 {} \;
# Déplacer des fichiers
find . -name "*.bak" -exec mv {} /backup/ \;
# Copier des fichiers
find /src -name "*.conf" -exec cp {} /dest/ \;
# Archiver des logs
find /var/log -name "*.log" -mtime +30 -exec gzip {} \;
Syntaxe batch {} +
# Exécution groupée (plus rapide)
find /var/log -name "*.log" -exec rm {} +
# Équivaut à : rm file1.log file2.log file3.log...
# Vs syntaxe classique (lent)
find /var/log -name "*.log" -exec rm {} \;
# Équivaut à : rm file1.log && rm file2.log && rm file3.log...
Différence avec xargs
# -exec : intégré à find, gère les espaces
find . -name "*.txt" -exec cat {} \;
# xargs : pipeline, plus flexible
find . -name "*.txt" | xargs cat # ATTENTION aux espaces !
find . -name "*.txt" -print0 | xargs -0 cat # Sécurisé
Commandes complexes
# Exécuter plusieurs commandes
find . -name "*.jpg" -exec sh -c 'convert "$1" "${1%.jpg}.png"' _ {} \;
# Utiliser des variables
find . -type f -exec sh -c 'echo "Fichier: $1, Taille: $(stat -f%z "$1")"' _ {} \;
# Redirection dans -exec
find /var/log -name "*.log" -exec sh -c 'cat "$1" >> /tmp/all.log' _ {} \;
Bonnes pratiques
# 1. Toujours tester avec -print avant -exec
find /data -name "*.tmp" -print # Vérifier les résultats
find /data -name "*.tmp" -exec rm {} \; # Puis exécuter
# 2. Utiliser -ok pour confirmation interactive
find . -name "*.bak" -ok rm {} \; # Demande confirmation
# 3. Préférer {} + pour performances
find /logs -name "*.log" -exec gzip {} + # Batch
# 4. Gérer les erreurs
find / -name "*.conf" -exec cat {} \; 2>/dev/null
Actions intégrées (alternatives)
# -delete : supprimer (plus rapide que -exec rm)
find /tmp -name "*.tmp" -delete
# -print : afficher (par défaut)
find /etc -name "*.conf" -print
# -ls : affichage détaillé (comme ls -l)
find /var -size +100M -ls
L'option -ok fonctionne comme -exec, mais demande une confirmation utilisateur avant d'exécuter chaque commande.
Comparaison -exec vs -ok
| Option | Confirmation | Usage | Cas d'usage |
|---|---|---|---|
-exec |
Aucune | Exécution automatique | Scripts, actions sûres |
-ok |
Manuelle (y/n) | Exécution interactive | Suppressions critiques |
Syntaxe
find [chemin] [tests] -ok [commande] {} \;
│ │ │
confirmation fichier terminateur
Exemple interactif
# Supprimer avec confirmation
$ find /tmp -name "*.bak" -ok rm {} \;
< rm ... /tmp/file1.bak > ? y
< rm ... /tmp/file2.bak > ? n
< rm ... /tmp/file3.bak > ? y
# Chaque fichier demande confirmation (y = oui, n = non)
Cas d'usage sécurité
# Suppression de fichiers importants
find /home -name "*.conf" -ok rm {} \;
# Changement de permissions sensibles
find /etc -type f -ok chmod 600 {} \;
# Déplacement de fichiers critiques
find /backup -name "*.sql" -ok mv {} /archive/ \;
Alternative : -okdir
# Exécute la commande depuis le répertoire du fichier
find /var/log -name "*.log" -okdir gzip {} \;
# Plus sécurisé : évite les attaques par lien symbolique
Quand utiliser -ok ?
- Suppressions en masse : vérifier avant de supprimer
- Première exécution d'une commande find complexe
- Environnements sensibles : production, données critiques
- Apprentissage : comprendre ce que fait la commande
Alternative : test avec -print
# Méthode recommandée en production
# 1. Tester avec -print
find /data -name "*.tmp" -print
# 2. Vérifier les résultats
# 3. Exécuter avec -exec (ou -delete)
find /data -name "*.tmp" -delete
Plusieurs options permettent d'optimiser les performances de find en limitant la portée de la recherche.
Options d'optimisation
| Option | Description | Gain de performance |
|---|---|---|
-maxdepth N |
Limite la profondeur de recherche | ★★★ Très élevé |
-mindepth N |
Ignore les N premiers niveaux | ★★ Modéré |
-prune |
Exclut des répertoires entièrement | ★★★ Très élevé |
-mount (-xdev) |
Ne traverse pas les systèmes de fichiers | ★★ Modéré |
-quit |
Arrête après le premier résultat | ★★★ Maximal |
Limiter la profondeur
# Recherche uniquement dans le répertoire courant (pas de récursion)
find . -maxdepth 1 -name "*.txt"
# 2 niveaux maximum
find /var -maxdepth 2 -name "*.conf"
# Ignorer le répertoire courant (commencer à profondeur 2)
find /home -mindepth 2 -name "*.log"
# Combiner min et max
find /var -mindepth 2 -maxdepth 4 -type d
Exclure des répertoires avec -prune
# Exclure node_modules
find . -path "*/node_modules" -prune -o -name "*.js" -print
# Exclure .git et node_modules
find . \( -path "*/.git" -o -path "*/node_modules" \) -prune -o -type f -print
# Exclure /proc et /sys (système)
find / \( -path /proc -o -path /sys \) -prune -o -name "*.conf" -print
# Exclure plusieurs patterns
find /home \( -name ".cache" -o -name ".npm" -o -name ".local" \) -prune -o -type f -print
Ne pas traverser les montages
# Rester sur le système de fichiers actuel
find / -mount -name "*.log"
find / -xdev -name "*.log" # Alias
# Utile pour éviter /proc, /dev, NFS, etc.
find /home -xdev -type f -size +1G
Arrêt précoce
# Arrêter après le premier résultat
find /etc -name "nginx.conf" -quit
# Trouver un seul exemple
find /var/log -name "*.log" -print -quit
Exemples de performances
# LENT : recherche récursive complète
find /home -name "config.json" # Peut prendre plusieurs minutes
# RAPIDE : limiter la profondeur
find /home -maxdepth 3 -name "config.json" # Quelques secondes
# TRÈS RAPIDE : exclure les gros répertoires
find /home \( -path "*/node_modules" -o -path "*/.cache" \) -prune -o -name "config.json" -print
Benchmarks (exemple)
# Sans optimisation
time find /var -name "*.log"
# real: 2m15s
# Avec -maxdepth
time find /var -maxdepth 3 -name "*.log"
# real: 0m12s (11x plus rapide)
# Avec -prune
time find /var -path "*/docker" -prune -o -name "*.log" -print
# real: 0m08s (17x plus rapide)
Bonnes pratiques
- Toujours limiter la profondeur si possible :
-maxdepth - Exclure les répertoires système :
/proc,/sys,/dev - Exclure les répertoires volumineux :
node_modules,.git,vendor - Utiliser
-xdevpour ne pas traverser les montages - Placer les tests les plus sélectifs en premier (ex:
-nameavant-size) - Utiliser
-quitsi un seul résultat suffit
Template optimisé
# Recherche optimisée standard
find /chemin \
-maxdepth 5 \
-xdev \
\( -path "*/node_modules" -o -path "*/.git" \) -prune -o \
-type f -name "*.ext" -print
xargs permet de traiter les résultats de find en lots (batches), ce qui est beaucoup plus performant qu'exécuter une commande par fichier.
Avantages de xargs
| Caractéristique | -exec {} ; | -exec {} + | xargs |
|---|---|---|---|
| Exécutions | Une par fichier | Groupées | Groupées |
| Performance | Très lent | Rapide | Très rapide |
| Flexibilité | Limitée | Limitée | Élevée |
| Gestion espaces | Native | Native | Nécessite -0 |
Problème : espaces et caractères spéciaux
# DANGER : xargs basique casse avec les espaces
find . -name "*.txt" | xargs cat
# Fichier "mon document.txt" sera traité comme 2 fichiers : "mon" et "document.txt"
# SOLUTION : -print0 et -0
find . -name "*.txt" -print0 | xargs -0 cat
# ✅ Fonctionne correctement avec les espaces, tabulations, retours à la ligne
-print0 et -0 (NULL separator)
# find -print0 : séparateur NULL (\0) au lieu de \n
# xargs -0 : lit avec séparateur NULL
find /var/log -name "*.log" -print0 | xargs -0 ls -lh
# Fonctionnement
find . -print # Sortie : file1\nfile 2\nfile3\n
find . -print0 # Sortie : file1\0file 2\0file3\0
Exemples pratiques
# Compter les lignes de tous les fichiers .py
find . -name "*.py" -print0 | xargs -0 wc -l
# Rechercher un motif dans plusieurs fichiers
find /var/log -name "*.log" -print0 | xargs -0 grep "ERROR"
# Copier des fichiers
find /src -name "*.conf" -print0 | xargs -0 -I {} cp {} /dest/
# Supprimer en masse
find /tmp -name "*.tmp" -mtime +7 -print0 | xargs -0 rm
# Archiver
find /data -name "*.csv" -print0 | xargs -0 tar czf archive.tar.gz
Options utiles de xargs
# -I {} : placeholder personnalisé
find . -name "*.txt" | xargs -I {} mv {} {}.bak
# -n N : max N arguments par exécution
find . -type f | xargs -n 10 ls -l # 10 fichiers à la fois
# -P N : exécution parallèle (N processus)
find . -name "*.jpg" -print0 | xargs -0 -P 4 -I {} convert {} {}.png
# -t : afficher les commandes exécutées (debug)
find . -name "*.log" -print0 | xargs -0 -t gzip
Différence de performance
# Test : supprimer 10000 fichiers
# -exec {} \; : ~120 secondes (10000 forks)
time find /tmp/test -name "*.tmp" -exec rm {} \;
# -exec {} + : ~2 secondes (batches)
time find /tmp/test -name "*.tmp" -exec rm {} +
# xargs : ~1.5 secondes (optimal)
time find /tmp/test -name "*.tmp" -print0 | xargs -0 rm
Limites ARG_MAX
# Taille maximale des arguments
getconf ARG_MAX # Exemple : 2097152 (2 Mo)
# xargs divise automatiquement en lots
find / -name "*.log" -print0 | xargs -0 rm
# Si > ARG_MAX, xargs fait plusieurs appels automatiquement
Gestion des erreurs
# Continuer même en cas d'erreur
find . -name "*.txt" -print0 | xargs -0 -r cat
# -r : ne rien faire si entrée vide
# Rediriger les erreurs
find /var -name "*.conf" 2>/dev/null | xargs cat 2>/dev/null
Quand préférer -exec ?
- Commandes complexes avec redirections
- Besoin de confirmation (
-ok) - Compatibilité POSIX stricte
- Sécurité (moins de risque d'injection)
Quand préférer xargs ?
- Performances critiques (milliers de fichiers)
- Traitement parallèle (
-P) - Flexibilité des commandes
- Pipeline avec d'autres outils
Template sécurisé
# Modèle recommandé pour production
find /chemin \
-type f \
-name "pattern" \
-print0 | xargs -0 -r -P 4 commande
│ │ │ │ │
séparateur | | | +-- parallèle (4 processus)
NULL | | +-- ne rien faire si vide
| +-- lire NULL separator
+-- pipeline sécurisé
Utiliser find en production nécessite des précautions pour éviter les erreurs et garantir la fiabilité.
Checklist production
1. Toujours tester avec -print
# ❌ MAL : exécution directe
find /data -name "*.tmp" -delete
# ✅ BIEN : tester d'abord
find /data -name "*.tmp" -print # Vérifier les résultats
find /data -name "*.tmp" -delete # Puis exécuter
2. Rediriger les erreurs
# Supprimer les erreurs "Permission denied"
find / -name "*.conf" 2>/dev/null
# Rediriger erreurs vers un fichier
find /var -type f -size +1G 2>/var/log/find_errors.log
# Séparer stdout et stderr
find / -name "*.log" > found.txt 2> errors.txt
3. Protéger les motifs avec guillemets
# ❌ MAL : interprétation par le shell
find . -name *.txt # Le shell expand *.txt AVANT find
# ✅ BIEN : guillemets
find . -name "*.txt" # find reçoit le pattern intact
find . -name '*.txt' # Idem
4. Faire des backups avant actions destructives
# Sauvegarder avant suppression
find /data -name "*.old" -exec cp {} /backup/ \; -delete
# Archiver avant modification
tar czf backup_$(date +%Y%m%d).tar.gz /data
find /data -name "*.log" -exec gzip {} \;
5. Utiliser -ok pour confirmation (première fois)
# Confirmation interactive
find /etc -name "*.bak" -ok rm {} \;
# Puis automatiser une fois validé
find /etc -name "*.bak" -delete
Scripts robustes
#!/bin/bash
# Script de nettoyage sécurisé
set -euo pipefail # Arrêt sur erreur
# Variables
TARGET_DIR="/var/log"
MAX_AGE=30
LOG_FILE="/var/log/cleanup.log"
# Fonction de logging
log() {
echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}
# Vérifications préalables
if [[ ! -d "$TARGET_DIR" ]]; then
log "ERREUR: Répertoire $TARGET_DIR introuvable"
exit 1
fi
# Dry-run (mode test)
log "Mode TEST : fichiers qui seraient supprimés"
find "$TARGET_DIR" -name "*.log" -mtime +$MAX_AGE -print | tee -a "$LOG_FILE"
# Confirmation
read -p "Confirmer la suppression ? (y/N) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
log "Opération annulée"
exit 0
fi
# Exécution
log "Début du nettoyage"
COUNT=$(find "$TARGET_DIR" -name "*.log" -mtime +$MAX_AGE -delete -print | wc -l)
log "$COUNT fichiers supprimés"
Gestion des erreurs
# Continuer même si erreurs
find /var -name "*.log" -exec gzip {} \; 2>/dev/null || true
# Vérifier le code de retour
if ! find /data -name "*.tmp" -delete 2>/dev/null; then
echo "Erreur lors du nettoyage" >&2
exit 1
fi
Logging et audit
# Logger les fichiers traités
find /data -name "*.csv" -exec sh -c 'echo "Traité: $1" >> /var/log/process.log' _ {} \;
# Rapport détaillé
find /backup -type f -mtime -1 -ls > /var/log/backup_report_$(date +%Y%m%d).txt
Optimisations production
# Limiter la charge système avec ionice/nice
nice -n 19 ionice -c3 find /data -name "*.log" -exec gzip {} +
# Exécution en arrière-plan
nohup find / -name "*.tmp" -delete > /var/log/cleanup.log 2>&1 &
# Limitation ressources (cgroups)
systemd-run --scope -p CPUQuota=50% find /data -name "*.old" -delete
Checklist finale
- ✅ Tester avec
-printavant-deleteou-exec - ✅ Rediriger stderr (
2>/dev/nullou vers log) - ✅ Guillemets autour des patterns (
-name "*.txt") - ✅ Backups avant actions destructives
- ✅ Logging des opérations (audit trail)
- ✅ Confirmation pour première exécution (
-ok) - ✅ Optimiser avec
-maxdepth,-prune,-xdev - ✅ Limiter la charge système (
nice,ionice) - ✅ Monitoring des scripts (alertes si échec)
- ✅ Documentation du comportement attendu
Exemples de scripts production
# Nettoyage logs (cron quotidien)
0 2 * * * find /var/log -name "*.log" -mtime +90 -delete 2>>/var/log/cron_errors.log
# Archivage backups (cron hebdomadaire)
0 3 * * 0 find /backup -name "*.sql" -mtime +7 -exec gzip {} \; 2>&1 | logger -t backup
# Audit sécurité (cron quotidien)
0 4 * * * find / -perm -4000 -o -perm -2000 2>/dev/null | mail -s "SUID/SGID Audit" admin@example.com
find est un outil puissant pour les audits de sécurité et l'analyse du système de fichiers.
Types d'audits
| Type | Objectif | Niveau de risque |
|---|---|---|
| SUID/SGID | Détecter élévation de privilèges | 🔴 Critique |
| Permissions 777 | Fichiers trop permissifs | 🔴 Critique |
| World-writable | Répertoires inscriptibles par tous | 🔴 Critique |
| Fichiers volumineux | Gestion de l'espace disque | 🟡 Modéré |
| Fichiers anciens | Nettoyage et archivage | 🟢 Faible |
| Fichiers orphelins | Utilisateurs supprimés | 🟡 Modéré |
1. Audit SUID/SGID (bits spéciaux)
# Fichiers SUID (s'exécutent avec droits propriétaire)
find / -perm -4000 -type f -ls 2>/dev/null
# Fichiers SGID (s'exécutent avec droits groupe)
find / -perm -2000 -type f -ls 2>/dev/null
# SUID ET SGID
find / -perm -6000 -type f -ls 2>/dev/null
# SUID non-root (DANGEREUX)
find / -perm -4000 ! -user root -ls 2>/dev/null
# Rapport détaillé
find / \( -perm -4000 -o -perm -2000 \) -type f -printf "%M %u:%g %p\n" 2>/dev/null > /tmp/suid_audit.txt
2. Audit permissions trop permissives
# Fichiers 777 (tout le monde peut tout faire)
find / -type f -perm 0777 -ls 2>/dev/null
# Répertoires 777
find / -type d -perm 0777 -ls 2>/dev/null
# Fichiers inscriptibles par "other"
find /var/www -type f -perm -002 -ls
# Fichiers lisibles par tous dans /etc
find /etc -type f -perm -004 -ls
# Scripts exécutables world-writable (GRAVE)
find /usr/local/bin -type f -perm -111 -perm -002 -ls
3. Audit fichiers volumineux
# Fichiers > 1 Go
find / -type f -size +1G -exec ls -lh {} \; 2>/dev/null
# Top 20 fichiers les plus gros
find /var -type f -size +100M -exec ls -lh {} \; 2>/dev/null | sort -k5 -hr | head -20
# Logs > 100 Mo
find /var/log -name "*.log" -size +100M -printf "%s %p\n" | sort -nr
# Cache Docker volumineux
find /var/lib/docker -type f -size +500M -ls 2>/dev/null
4. Audit fichiers anciens/non utilisés
# Fichiers non modifiés depuis 1 an
find /home -type f -mtime +365 -ls
# Fichiers jamais accédés depuis 6 mois
find /opt -type f -atime +180 -ls
# Logs de plus de 90 jours
find /var/log -name "*.log" -mtime +90 -exec du -h {} \;
# Backups obsolètes
find /backup -name "*.tar.gz" -mtime +30 -ls
5. Audit répertoires world-writable
# Répertoires inscriptibles par tous (sauf /tmp avec sticky bit)
find / -type d -perm -002 ! -perm -1000 -ls 2>/dev/null
# Répertoires sans sticky bit dans /tmp
find /tmp -type d ! -perm -1000 -ls
6. Audit fichiers orphelins
# Fichiers sans propriétaire (utilisateur supprimé)
find / -nouser -ls 2>/dev/null
# Fichiers sans groupe
find / -nogroup -ls 2>/dev/null
# Combiné
find /home -nouser -o -nogroup 2>/dev/null
Rapports d'audit complets
#!/bin/bash
# Script d'audit sécurité complet
REPORT="/var/log/security_audit_$(date +%Y%m%d).txt"
echo "=== AUDIT SÉCURITÉ $(date) ===" > "$REPORT"
echo "\n### Fichiers SUID/SGID" >> "$REPORT"
find / \( -perm -4000 -o -perm -2000 \) -type f -ls 2>/dev/null >> "$REPORT"
echo "\n### Permissions 777" >> "$REPORT"
find / -type f -perm 0777 -ls 2>/dev/null >> "$REPORT"
echo "\n### Fichiers world-writable" >> "$REPORT"
find / -type f -perm -002 ! -type l -ls 2>/dev/null >> "$REPORT"
echo "\n### Fichiers > 1 Go" >> "$REPORT"
find / -type f -size +1G -ls 2>/dev/null >> "$REPORT"
echo "\n### Fichiers orphelins" >> "$REPORT"
find / \( -nouser -o -nogroup \) -ls 2>/dev/null >> "$REPORT"
# Envoyer le rapport
mail -s "Audit sécurité quotidien" admin@example.com < "$REPORT"
Automatisation (cron)
# /etc/cron.daily/security-audit
#!/bin/bash
# Audit SUID quotidien
find / -perm -4000 -type f -ls 2>/dev/null > /var/log/suid_$(date +%Y%m%d).log
# Alerte si nouveaux fichiers SUID
if ! diff -q /var/log/suid_*.log | tail -2; then
echo "ALERTE: Nouveaux fichiers SUID détectés" | mail -s "Sécurité: SUID" admin@example.com
fi
# Audit permissions 777
find /var/www -type f -perm 0777 -ls 2>/dev/null | \
mail -s "Fichiers 777 dans /var/www" admin@example.com
Tableaux de bord
# Statistiques disque
echo "Fichiers par taille:"
echo " < 1 Mo: $(find /data -type f -size -1M | wc -l)"
echo " 1-10 Mo: $(find /data -type f -size +1M -size -10M | wc -l)"
echo " 10-100 Mo: $(find /data -type f -size +10M -size -100M | wc -l)"
echo " > 100 Mo: $(find /data -type f -size +100M | wc -l)"
# Fichiers par âge
echo "Fichiers par ancienneté:"
echo " < 7 jours: $(find /data -mtime -7 | wc -l)"
echo " 7-30 jours: $(find /data -mtime +7 -mtime -30 | wc -l)"
echo " > 30 jours: $(find /data -mtime +30 | wc -l)"