Le Terminal : Ton Meilleur Ami DevOps
🎯 Objectifs de ce cours
À la fin, tu seras capable de :
✅ Naviguer comme un pro : Se déplacer dans l'arborescence du serveur les yeux fermés
✅ Lire et comprendre les logs : Trouver rapidement l'aiguille (erreur) dans la botte de foin
✅ Diagnostiquer les problèmes : "Pourquoi ça casse ?" → tu trouves en 2 minutes
✅ Gérer les processus et ressources : Pas de surprises en production
✅ Automatiser des tâches : Les mêmes commandes encore et encore ? Non merci !
✅ Tester des services : "Est-ce que mon API répond ?" → vérifier sans UI
✅ Chaîner des commandes : Transforme des données comme un magicien
❌ Le Problème : Le Terminal Te Fait Peur ?
C'est NORMAL. Au début, le terminal c'est :
Terminal
├─ Pas de boutons colorés
├─ Pas de souris
├─ Juste du texte
└─ Et une peur de tout casser
Mais voici la vérité :
| Avant DevOps | Après Terminal |
|---|---|
| "Pas de terminal, j'utilise GitHub Desktop" | "Je déploie en 30 secondes avec une commande" |
| "Comment je vois les logs ?" | "tail -f, c'est trop facile" |
| "Un serveur crash !" | "Je diagnostique, je fixe, tout va bien" |
Le terminal n'est pas compliqué. C'est juste différent.
Et une fois que tu maîtrises ? Tu es 10x plus productif.
🧱 Structure d'une Commande (C'est Facile !)
Format :
commande [options] [arguments]
Décomposons :
grep -i "error" app.log
│ │ │ │
│ │ │ └─→ Argument : le fichier dans lequel chercher
│ │ └─→ Valeur : "error"
│ └─→ Option : insensible à la casse (-i)
└─→ Commande : grep (rechercher)
C'est tout. Juste :
1. La commande
2. Des options (parfois)
3. Ce sur quoi agir
Exemples réels :
ls -la /var/log # Liste les logs avec détails
ps aux | grep nginx # Voir si nginx tourne
docker ps -a # Voir tous les conteneurs
🌳 L'Arborescence Linux (Le Plan De La Maison)
Avant de naviguer, comprends la structure :
/ Racine du système
├─ /home Les dossiers des users
│ └─ /home/tartempion Ton home (si user = tartempion)
├─ /var Données variables (logs, cache)
│ ├─ /var/log ← Les logs (TON MEILLEUR AMI)
│ └─ /var/www Les sites web
├─ /etc Les configurations
│ ├─ /etc/docker Config Docker
│ └─ /etc/nginx Config Nginx
├─ /opt Applications tierces
├─ /tmp Fichiers temporaires
└─ /root Home de root (le boss)
À retenir :
- /var/log = où regarder quand quelque chose casse
- /etc = où vivent les configurations
- /home = où les users traînent leurs trucs
- /opt = où tu installes tes apps
Maintenant, on explore !
📍 Navigation : Se Balader Dans Le Serveur
pwd : "Où je suis ?"
La première question quand tu ouvres un terminal :
pwd
# /var/www/myapp/src
Ça affiche ton emplacement exact. Très utile quand tu navigues partout.
cd : Se Déplacer
cd /var/log # Aller dans les logs
cd .. # Remonter d'un niveau
cd - # Revenir où j'étais avant
cd ~ # Aller chez toi (/home/tartempion)
Exemple :
$ cd /var/log
$ pwd
/var/log
$ cd nginx
$ pwd
/var/log/nginx
$ cd -
/var/log
ls : "Qu'est-ce qu'il y a ici ?"
ls # Simple
ls -l # Avec détails (permissions, taille, date)
ls -lah # Mieux : lisible + fichiers cachés
ls -la | grep "\.log" # Chercher les fichiers .log
Comprendre la sortie :
-rw-r--r-- 1 nginx nginx 2.5M Jan 27 14:32 access.log
│ │ │ │ │ │ │ │
│ │ │ │ │ │ │ └─ Nom du fichier
│ │ │ │ │ │ └─ Heure modification
│ │ │ │ │ └─ Date modification
│ │ │ │ └─ Taille (2.5 Megabytes)
│ │ │ └─ Groupe propriétaire
│ │ └─ Propriétaire (user nginx)
│ └─ Nombre de liens
└─ Permissions (rw- = propriétaire peut lire/écrire)
Les permissions : Important en DevOps ! Si un fichier n'a pas les bons droits, l'app ne peut pas le lire.
mkdir : Créer des Dossiers
mkdir /var/backups/app
mkdir -p /var/backups/app/$(date +%Y-%m-%d) # Crée tout d'un coup + date
Le -p c'est la magie : il crée les dossiers parent automatiquement.
📖 Lire Les Fichiers (L'Art De Trouver Les Bugs)
cat : Affiche Tout
cat /etc/nginx/nginx.conf
⚠️ Problème : Si le fichier est énorme (ex: log de 100 Go), ton terminal va freeze. Mauvaise idée.
Solution : Utilise head ou tail.
head : Les PREMIÈRES Lignes
head /var/log/app.log # Les 10 premières (défaut)
head -n 5 /var/log/app.log # Juste 5 lignes
Utilité : Vérifier rapidement le format d'un fichier.
tail : Les DERNIÈRES Lignes
tail /var/log/app.log # Les 10 dernières
tail -n 50 /var/log/app.log # Les 50 dernières
tail -f /var/log/app.log # Suivre EN TEMPS RÉEL (Ctrl+C pour arrêter)
tail -f est MAGIQUE : c'est comme "regarder le fichier se remplir en direct". Idéal pour déboguer en live !
Utilité :
- Déboguer pendant un déploiement
- Voir les erreurs au moment où elles arrivent
- Monitorer sans dashboard
less : Lire Confortablement
less /var/log/app.log
Ouvre le fichier en "pager". Tu peux :
- Scroll avec les flèches
- Chercher avec / (ex: /error)
- Quitter avec q
Parfait pour les gros fichiers.
🔍 Chercher Dans Les Fichiers (Le Pouvoir De grep)
grep = SEARCH DANS LES FICHIERS. C'EST LA BASE.
grep "error" app.log # Cherche les lignes avec "error"
grep -i "error" app.log # Insensible à la casse (Error, ERROR, error)
grep -c "error" app.log # Compte les occurrences
grep -n "error" app.log # Montre le numéro de ligne
grep "^ERROR" app.log # Commence par ERROR (^ = début ligne)
grep "error$" app.log # Finit par error ($ = fin ligne)
Exemples concrets DevOps :
# Trouver les erreurs SQL
grep "SQL" /var/log/app.log | head -20
# Compter les 404 dans les logs nginx
grep "404" /var/log/nginx/access.log | wc -l
# Chercher les Failed attempts
grep -i "failed" /var/log/auth.log
# Voir les déploiements réussis
grep "deployment successful" /var/log/deploy.log
Combiner grep avec d'autres : PUISSANCE !
# Voir les 10 dernières erreurs
grep "ERROR" app.log | tail -10
# Compter les erreurs par type
grep "ERROR" app.log | cut -d: -f2 | sort | uniq -c
C'est ça, faire du "data wrangling" en CLI !
📊 Compter, Trier, Transformer
wc : Compter Les Lignes/Mots
wc -l /var/log/app.log # Nombre de lignes
wc -w /var/log/app.log # Nombre de mots
Utilité : Évaluer la taille du problème.
grep "ERROR" app.log | wc -l
# 245
# → Il y a 245 erreurs. C'est pas bon !
sort : Trier
sort /var/log/app.log # Trier alphabétiquement
cat /etc/passwd | sort # Utilisateurs par ordre alphabétique
uniq : Supprimer Les Doublons
grep "ERROR" app.log | sort | uniq -c # Compter les erreurs uniques
Résultat :
10 Connection timeout
25 Database locked
5 Permission denied
Aha ! Les erreurs les plus fréquentes d'abord.
cut : Extraire Des Colonnes
cut -d: -f1 /etc/passwd # 1ère colonne (usernames)
cut -d, -f2 data.csv # 2ème colonne d'un CSV
Utilité : Parser des données structurées.
tr : Remplacer Des Caractères
echo "hello" | tr a-z A-Z # hello → HELLO
echo "a,b,c" | tr ',' '\n' # Remplacer virgules par retours
🎯 Chercher Des Fichiers (find)
find /var/log -name "*.log" # Tous les .log
find /var/log -name "*.log" -type f # Juste les fichiers (pas dossiers)
find /etc -name "*.conf" -mtime -7 # Configs modifiées les 7 derniers jours
find /var/log -size +100M # Fichiers > 100 MB
find /var/log -name "*.log" -delete # ATTENTION : Supprime (utiliser avec précaution!)
Utile pour :
- Trouver les gros fichiers (pourquoi le disque est plein ?)
- Trouver les vieux logs à nettoyer
- Chercher des fichiers de config
⚙️ Gérer Les Processus (Les Apps Qui Tournent)
ps aux : "Qu'est-ce qui tourne ?"
ps aux
Résultat :
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 225612 8488 ? Ss 09:00 0:01 /sbin/init
nginx 1234 0.2 0.5 456789 34567 ? S 09:15 0:30 nginx
Les colonnes importantes :
- PID : L'identifiant du processus
- %CPU : Consommation CPU (si > 80%, c'est grave)
- %MEM : Consommation RAM
- COMMAND : Quoi exactement tourne
ps aux | grep : Chercher UN Processus
ps aux | grep nginx # Nginx tourne ? Voir ses deets
ps aux | grep "node\|python" # Node OU Python
ps aux | grep python | grep -v grep # Astuce : exclure la recherche elle-même
Utilité DevOps :
# "Mon app Node crash pas mal"
ps aux | grep node
# → Vérifier la mémoire utilisée
# "Nginx n'a pas redémarré"
ps aux | grep nginx
# → Vérifier s'il tourne vraiment
kill : Terminer Un Processus
kill 1234 # Tuer proprement
kill -9 1234 # FORCE TO DIE (seulement si besoin)
pkill -f "node app.js" # Tuer par pattern
À retenir : kill -9 c'est l'arme nucléaire. Utilise seulement si nécessaire.
top / htop / btop : Monitoring En Temps Réel
top # Vue simple (toujours disponible)
htop # Vue plus jolie (si installé)
btop # Vue encore plus jolie (si installé)
Affiche :
- Processus qui consomment le plus
- CPU/RAM globale
- Charge du serveur
Quit avec q.
💾 Ressources Système : Disque, RAM, etc.
df -h : Espace Disque
df -h
Résultat :
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 100G 87G 13G 87% /
/dev/sda2 500G 450G 50G 90% /var
Interpretation :
- Si Use% > 85%, c'est un problème
- Si > 95%, c'est une URGENCE (le disque va lock)
Les logs remplissent souvent le disque :
du -sh /var/log # Taille totale des logs
du -sh /var/log/* # Taille par sous-dossier
free -h : Mémoire RAM
free -h
Résultat :
total used free
Mem: 32Gi 28Gi 4Gi
Si RAM libre < 10%, les apps vont ralentir.
uptime : Depuis Combien De Temps Ça Tourne ?
uptime
# up 45 days, 3:22, load average: 0.45, 0.52, 0.48
Comprendre "load average" :
- 0.45 : charge moyenne sur 1 minute
- 0.52 : charge moyenne sur 5 minutes
- 0.48 : charge moyenne sur 15 minutes
Si load > nombre de CPUs, c'est surchargé.
🌐 Réseau : Vérifier Que Ça Communique
ip addr / ip a : Configuration Réseau
ip a # Toutes les interfaces
ip a show eth0 # Juste eth0
À vérifier :
- Adresse IP assignée ?
- Interface UP (active) ?
ss : Ports Écoutés
ss -tulpn # Tous les ports écoutés
ss -tulpn | grep :80 # Est-ce que HTTP écoute ?
Résultat :
LISTEN 0 128 0.0.0.0:80 0.0.0.0:* users:(("nginx",pid=1234))
"nginx écoute sur le port 80" ✅
curl : Tester Une API/Service
curl http://localhost:8080 # Voir la réponse
curl -I http://localhost:8080 # Juste les headers (rapide)
curl http://api.example.com/health # Vérifier la santé d'une API
Codes HTTP :
- 200 = OK ✅
- 404 = Not found ❌
- 500 = Server error ❌
- 503 = Service down ❌
🔗 Pipelines : Chaîner Les Commandes
C'est là OÙ le terminal devient magique.
Le Pipe (|) : Passer La Sortie
ps aux | grep nginx
Signifie : "Affiche les processus, puis filtre pour nginx."
Autres exemples :
cat logs.txt | head -100 | tail -20 # Lignes 80 à 100
grep "ERROR" app.log | wc -l # Compter les erreurs
grep "ERROR" app.log | sort | uniq -c | sort -rn # Erreurs par fréquence
xargs : Appliquer Une Commande À Une Liste
find /var/log -name "*.log.1" | xargs rm # Supprimer tous les anciens logs
grep -l "error" *.log | xargs cat # Afficher le contenu des fichiers avec erreurs
Utile pour :
- Opérations en masse sur plusieurs fichiers
- Parser + agir
➡️ Redirection : Sauvegarder Les Résultats
Écrire Dans Un Fichier
ps aux > processes.txt # Sauvegarder les processus
grep "ERROR" app.log > errors.txt # Extraire les erreurs dans errors.txt
Attention : > ÉCRASE le fichier s'il existe.
Ajouter À Un Fichier
echo "Checkpoint 1" >> deployment.log # Ajoute à la fin
>> ne met pas en danger le fichier existant.
⚙️ Services : Systemctl
systemctl status nginx # État du service
systemctl restart nginx # Redémarrer
systemctl start nginx # Démarrer
systemctl stop nginx # Arrêter
systemctl enable nginx # Activer au démarrage
journalctl -u nginx -n 50 # 50 dernières lignes du log du service
Utilité DevOps :
# Nginx crash ?
systemctl restart nginx
# Vérifier si ça a marché
ps aux | grep nginx
🚀 Automatiser : Les Scripts
# Nettoyer les vieux logs automatiquement
find /var/log -name "*.log" -mtime +30 -delete
# Archiver les logs du jour
tar -czf /backup/logs-$(date +%Y-%m-%d).tar.gz /var/log/*.log
# Vérifier la santé de l'app toutes les minutes
while true; do
curl -s http://localhost:8080/health || echo "DOWN" >> alerts.log
sleep 60
done
📘 Aide : man & --help
man grep # Documentation complète
grep --help # Résumé rapide
man 5 passwd # Documentation du fichier /etc/passwd
🧾 Cheat Sheet : Les Commandes Essentielles
| But | Commande | Exemple |
|---|---|---|
| Où je suis ? | pwd |
pwd |
| Naviguer | cd |
cd /var/log |
| Lister | ls |
ls -lah |
| Lire début | head |
head -n 20 app.log |
| Lire fin (EN DIRECT!) | tail -f |
tail -f app.log |
| Chercher texte | grep |
grep "ERROR" *.log |
| Compter lignes | wc -l |
grep "ERROR" app.log \| wc -l |
| Trouver fichiers | find |
find /var/log -name "*.log" |
| Processus actifs | ps aux |
ps aux \| grep nginx |
| Espace disque | df -h |
df -h |
| Mémoire libre | free -h |
free -h |
| Monitoring | top ou htop |
htop |
| Tester une API | curl |
curl http://localhost:8080/health |
| Redémarrer service | systemctl restart |
systemctl restart nginx |
| Chaîner commandes | \| (pipe) |
ps aux \| grep nginx |
💡 Les Pièges (À Éviter !)
| ❌ Mauvaise Idée | ✅ La Bonne Façon |
|---|---|
cat huge_file.log |
tail -f huge_file.log |
ps aux (chercher mentalement) |
ps aux \| grep nginx |
| Ouvrir l'UI pour checker les logs | grep "error" app.log |
rm -rf / (OMG) |
Réfléchis avant de supprimer :-) |
| Chercher "quelque part" dans les logs | grep + find ensemble |
🎯 Checklist : Ton Premier Jour Au Terminal
- ✅ Tu sais faire
pwd,cd,ls - ✅ Tu peux lire un fichier sans le casser
- ✅ Tu trouves les erreurs avec
grep - ✅ Tu sais voir les processus (
ps aux) - ✅ Tu vérifies que l'API répond (
curl) - ✅ Tu checks l'espace disque (
df -h) - ✅ Tu relances un service (
systemctl restart) - ✅ Tu chaînes des commandes avec
|
🚀 Prochaines Étapes
Maintenant que tu maîtrises le terminal :
- Apprendre Docker : Conteneuriser une app
- Mettre en place une CI/CD : Déployer automatiquement
- Monitoring : Avec Prometheus/Grafana
- Infrastructure as Code : Terraform, Ansible
- Kubernetes : Orchestrer les conteneurs
Le terminal n'est que le début. C'est le fondement sur lequel tout le reste repose ! 🏗️
Bienvenue dans le monde du DevOps. Tu n'es jamais loin d'une ligne de commande. 💪