guides/serveur/linux-essentials/comprendre-commandes-find-du.md

# Comprendre les commandes de diagnostic (find, du, grep)

Guide pédagogique pour comprendre les commandes utilisées dans le diagnostic du cache Forgejo.

---

## 1. La commande `find` : Chercher des fichiers

### Syntaxe de base

```bash
find [où chercher] [critères] [action]
```

### Exemples progressifs

**Exemple 1 : Lister tous les fichiers d'un dossier**
```bash
find /home/debian/forgejo/data/gitea/repo-archive
```

**Ce que ça fait :**
- Parcourt récursivement tout le dossier `repo-archive`
- Affiche tous les fichiers ET dossiers trouvés

---

**Exemple 2 : Seulement les fichiers (pas les dossiers)**
```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f
```

**Nouveau paramètre :**
- `-type f` : Filtre pour garder seulement les **f**ichiers (file)
- `-type d` : Pour les **d**ossiers (directory)

---

**Exemple 3 : Compter les fichiers**
```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f | wc -l
```

**Décortiquons :**
- `find ... -type f` : Trouve tous les fichiers
- `|` : "Pipe" = envoie le résultat à la commande suivante
- `wc -l` : **W**ord **C**ount avec `-l` (line) = compte les lignes

**Résultat :** Le nombre de fichiers trouvés (ex: `1189`)

---

### Filtres par date : `-mtime`, `-mmin`

**Les 3 formes :**

| Syntaxe | Signification | Exemple |
|---------|---------------|---------|
| `-mtime -1` | Modifié **moins de** 24h | Fichiers créés aujourd'hui |
| `-mtime 0` | Modifié **il y a exactement** 24h | Fichiers d'hier |
| `-mtime +1` | Modifié **plus de** 48h | Fichiers d'avant-hier ou plus |

**Note importante :**
- `-mtime` compte en **jours entiers** (multiples de 24h)
- `-mtime +1` signifie "plus de 1 jour complet" donc **≥ 2 jours** (48h)

**Pour plus de précision, utilisez `-mmin` (minutes) :**

| Syntaxe | Signification |
|---------|---------------|
| `-mmin -60` | Modifié dans les 60 dernières minutes (< 1h) |
| `-mmin +360` | Modifié il y a plus de 360 minutes (> 6h) |

**Exemple pratique :**
```bash
# Fichiers de moins de 6 heures
find repo-archive -type f -mmin -360

# Fichiers de plus de 6 heures
find repo-archive -type f -mmin +360
```

---

### L'opérateur `!` (NOT)

**Inverser une condition :**

```bash
find repo-archive -type f ! -mtime -1
```

**Signification :**
- `-mtime -1` : Fichiers de moins de 24h
- `!` : **NOT** (inverse la condition)
- Résultat : Fichiers de **PLUS de 24h**

**Équivalent :**
- `! -mtime -1` = `-mtime 0 -o -mtime +1` (24h-48h OU plus de 48h)

---

### La commande `-exec` : Exécuter une action sur chaque fichier

**Syntaxe :**
```bash
find [critères] -exec commande {} \;
```

**Composants :**
- `-exec` : Exécute une commande sur chaque fichier trouvé
- `commande` : La commande à exécuter (ex: `ls`, `du`, `rm`)
- `{}` : Remplacé par le chemin du fichier trouvé
- `\;` : Marque la fin de la commande (obligatoire)

**Exemple 1 : Afficher les détails de chaque fichier**
```bash
find repo-archive -type f -exec ls -lh {} \;
```

**Ce qui se passe :**
1. `find` trouve le fichier `/path/to/file1.zip`
2. Exécute : `ls -lh /path/to/file1.zip`
3. Trouve le fichier `/path/to/file2.zip`
4. Exécute : `ls -lh /path/to/file2.zip`
5. Etc.

---

**Exemple 2 : Supprimer tous les fichiers trouvés**
```bash
find repo-archive -type f -mmin +360 -exec rm {} \;
```

**⚠️ Attention :** Cette commande **supprime définitivement** les fichiers.

**Équivalent plus simple :**
```bash
find repo-archive -type f -mmin +360 -delete
```

L'option `-delete` est plus rapide et sûre que `-exec rm`.

---

### Différence entre `\;` et `+`

```bash
# Avec \; : Exécute la commande UNE FOIS par fichier (lent)
find repo-archive -type f -exec du -h {} \;
# → du -h file1.zip
# → du -h file2.zip
# → du -h file3.zip

# Avec + : Exécute la commande UNE FOIS avec TOUS les fichiers (rapide)
find repo-archive -type f -exec du -h {} +
# → du -h file1.zip file2.zip file3.zip
```

**Utilisez `+` quand possible, c'est beaucoup plus rapide.**

---

### La commande `-printf` : Format personnalisé

**Afficher des informations personnalisées :**

```bash
find repo-archive -type f -printf '%TY-%Tm-%Td\n'
```

**Composants :**
- `-printf` : Affiche un format personnalisé (au lieu du nom du fichier)
- `%T` : Date de modification du fichier
- `%TY` : Année (2026)
- `%Tm` : Mois (02)
- `%Td` : Jour (05)
- `\n` : Saut de ligne

**Résultat :**
```
2026-02-03
2026-02-03
2026-02-04
2026-02-04
...
```

**Formater avec l'heure :**
```bash
find repo-archive -type f -printf '%TY-%Tm-%Td %TH:%TM\n'
```

**Résultat :**
```
2026-02-03 14:23
2026-02-03 14:45
2026-02-04 08:12
```

---

## 2. La commande `du` : Disk Usage (taille des fichiers)

### Syntaxe de base

```bash
du [options] [chemin]
```

### Options courantes

| Option | Signification | Exemple |
|--------|---------------|---------|
| `-s` | **S**ummary (résumé total) | Affiche seulement le total |
| `-h` | **H**uman-readable (Go, Mo) | `5.2G` au lieu de `5242880` |
| `-b` | **B**ytes (octets exacts) | Pour des calculs précis |
| `-c` | **C**umulé (total à la fin) | Ajoute une ligne de total |

### Exemples

**Voir la taille d'un dossier :**
```bash
du -sh /home/debian/forgejo/data/gitea/repo-archive
```

**Résultat :**
```
47G    /home/debian/forgejo/data/gitea/repo-archive
```

---

**Voir la taille de chaque sous-dossier :**
```bash
du -sh /home/debian/forgejo/data/gitea/*
```

**Résultat :**
```
4.0K    /home/debian/forgejo/data/gitea/actions_artifacts
8.0K    /home/debian/forgejo/data/gitea/conf
47G     /home/debian/forgejo/data/gitea/repo-archive
```

---

**Taille en octets (pour des comparaisons) :**
```bash
du -sb /home/debian/forgejo/data/gitea/repo-archive
```

**Résultat :**
```
50465865728    /home/debian/forgejo/data/gitea/repo-archive
```

**Utilité :** Pour comparer avec un seuil (ex: 10G = 10737418240 octets)

---

### Utiliser `du` avec `find`

**Calculer la taille totale des fichiers trouvés :**

```bash
find repo-archive -type f -exec du -ch {} + | tail -1
```

**Décortiquons :**
1. `find repo-archive -type f` : Trouve tous les fichiers
2. `-exec du -ch {} +` : Calcule la taille de chaque fichier
   - `-c` : Affiche un total à la fin
   - `-h` : Format lisible (Go, Mo)
   - `+` : Passe tous les fichiers en une fois (rapide)
3. `| tail -1` : Garde seulement la dernière ligne (le total)

**Résultat :**
```
47G    total
```

---

## 3. Pipeline de commandes avec `|`

### Concept du pipe `|`

Le pipe `|` envoie le **résultat** d'une commande à l'**entrée** de la suivante.

```bash
commande1 | commande2 | commande3
```

**Exemple concret :**
```bash
find repo-archive -type f | wc -l
```

**Ce qui se passe :**
1. `find` affiche tous les fichiers (un par ligne)
2. `|` envoie cette liste à `wc`
3. `wc -l` compte le nombre de lignes

---

### Chaînes courantes

**Compter + Trier :**
```bash
docker logs forgejo --since 24h | grep "archive" | wc -l
```

**Étapes :**
1. `docker logs forgejo --since 24h` : Affiche les logs des 24 dernières heures
2. `grep "archive"` : Garde seulement les lignes contenant "archive"
3. `wc -l` : Compte combien de lignes

---

**Extraire + Compter + Trier :**
```bash
docker logs forgejo --since 24h | grep "archive" | grep -oP '\d+\.\d+\.\d+\.\d+' | sort | uniq -c | sort -rn | head -5
```

**Étapes détaillées :**
1. `docker logs forgejo --since 24h` : Logs des 24h
2. `grep "archive"` : Lignes avec "archive"
3. `grep -oP '\d+\.\d+\.\d+\.\d+'` : Extrait les adresses IP (regex)
4. `sort` : Trie les IP alphabétiquement
5. `uniq -c` : Compte les occurrences de chaque IP unique
6. `sort -rn` : Trie par nombre décroissant
7. `head -5` : Garde les 5 premières

**Résultat :**
```
   2144 216.73.216.118
     42 192.168.1.100
     12 10.0.0.5
```

---

## 4. Commandes complémentaires

### `sort` : Trier

| Option | Signification |
|--------|---------------|
| `-h` | Trie en mode "humain" (comprend 10G > 2G) |
| `-r` | **R**everse (ordre décroissant) |
| `-n` | **N**umérique (trie les nombres correctement) |
| `-rn` | Numérique décroissant |

**Exemple :**
```bash
du -sh /var/* | sort -h
```

---

### `uniq` : Dédoublonner

| Option | Signification |
|--------|---------------|
| `-c` | **C**ount (compte les occurrences) |

**Important :** `uniq` ne fonctionne que sur des données **triées**.

```bash
# ❌ Mauvais (données non triées)
echo -e "a\nb\na" | uniq -c

# ✅ Bon (trier d'abord)
echo -e "a\nb\na" | sort | uniq -c
```

---

### `head` / `tail` : Garder les premières/dernières lignes

```bash
# Garder les 10 premières lignes
command | head -10

# Garder les 10 dernières lignes
command | tail -10

# Garder seulement la dernière ligne
command | tail -1
```

---

## 5. Exemples complets avec explications

### Exemple 1 : Trouver les gros fichiers

**Commande :**
```bash
find /home -type f -size +100M -exec ls -lh {} \; 2>/dev/null | sort -k5 -h | tail -20
```

**Décortiquons pas à pas :**

| Partie | Rôle |
|--------|------|
| `find /home` | Cherche dans /home |
| `-type f` | Seulement les fichiers |
| `-size +100M` | Plus de 100 MB |
| `-exec ls -lh {} \;` | Affiche les détails de chaque fichier trouvé |
| `2>/dev/null` | Masque les erreurs (permissions refusées) |
| `sort -k5 -h` | Trie par la 5ème colonne (taille) en mode humain |
| `tail -20` | Garde les 20 derniers = les plus gros |

---

### Exemple 2 : Distribution des fichiers par date

**Commande :**
```bash
find repo-archive -type f -printf '%TY-%Tm-%Td\n' | sort | uniq -c
```

**Décortiquons :**

| Partie | Rôle |
|--------|------|
| `find repo-archive -type f` | Trouve tous les fichiers |
| `-printf '%TY-%Tm-%Td\n'` | Affiche la date de chaque fichier (format YYYY-MM-DD) |
| `sort` | Trie les dates |
| `uniq -c` | Compte combien de fichiers par date |

**Résultat :**
```
    676 2026-02-03
    513 2026-02-04
```

**Interprétation :** 676 fichiers créés le 3 février, 513 le 4 février.

---

### Exemple 3 : Taille totale des fichiers récents

**Commande :**
```bash
find repo-archive -type f -mtime -1 -exec du -ch {} + | tail -1
```

**Décortiquons :**

| Partie | Rôle |
|--------|------|
| `find repo-archive -type f` | Trouve tous les fichiers |
| `-mtime -1` | Modifiés dans les dernières 24h |
| `-exec du -ch {} +` | Calcule la taille avec total à la fin |
| `tail -1` | Garde la dernière ligne (le total) |

**Résultat :**
```
5.9G    total
```

---

## 6. Cas pratique : Diagnostic du cache Forgejo

**Objectif :** Comprendre pourquoi le cache fait 47G.

### Étape 1 : Taille totale

```bash
du -sh /home/debian/forgejo/data/gitea/repo-archive
```

**Résultat :** `47G`

---

### Étape 2 : Nombre de fichiers

```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f | wc -l
```

**Résultat :** `1189 fichiers`

---

### Étape 3 : Distribution par date

```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f -printf '%TY-%Tm-%Td\n' | sort | uniq -c
```

**Résultat :**
```
    676 2026-02-03
    513 2026-02-04
```

**Interprétation :** Tous les fichiers datent de 2-3 jours. Le cron n'a pas nettoyé ou les bots régénèrent constamment.

---

### Étape 4 : Taille des fichiers récents vs anciens

**Fichiers de moins de 24h :**
```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f -mtime -1 | wc -l
```
**Résultat :** `239 fichiers`

```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f -mtime -1 -exec du -ch {} + | tail -1
```
**Résultat :** `5.9G`

---

**Fichiers de plus de 24h :**
```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f ! -mtime -1 | wc -l
```
**Résultat :** `957 fichiers`

```bash
find /home/debian/forgejo/data/gitea/repo-archive -type f ! -mtime -1 -exec du -ch {} + | tail -1
```
**Résultat :** `42G`

---

**Conclusion :**
- 239 fichiers récents (24h) = 5.9G → **Normal**
- 957 fichiers anciens (24h+) = 42G → **PROBLÈME** (auraient dû être supprimés)

**Cause :** Le cron ne s'est pas exécuté OU Fail2ban n'a pas banni les bots assez vite.

---

## Résumé des commandes essentielles

```bash
# Taille d'un dossier
du -sh /path/to/folder

# Nombre de fichiers
find /path -type f | wc -l

# Taille totale des fichiers
find /path -type f -exec du -ch {} + | tail -1

# Fichiers de plus de 6h
find /path -type f -mmin +360

# Supprimer fichiers de plus de 6h
find /path -type f -mmin +360 -delete

# Distribution par date
find /path -type f -printf '%TY-%Tm-%Td\n' | sort | uniq -c

# Top 20 gros fichiers
find /path -type f -size +100M -exec ls -lh {} \; | sort -k5 -h | tail -20
```