Chapitre 2.4 — Lire & éditer des fichiers

⏱️ TL;DR — Un serveur, c’est surtout des fichiers texte : de la config à lire et à modifier, des logs à consulter. Pour lire vite : cat (tout d’un coup), less (le pager, pour les gros fichiers — / pour chercher, q pour quitter), head et tail (le début / la fin). Le geste clé de l’ops : tail -f, qui suit un log en direct pendant que tu reproduis un bug. Pour chercher dans les fichiers : grep (et ses options -r, -i, -n, -v). Pour éditer au terminal : nano (simple : Ctrl+O pour écrire, Ctrl+X pour quitter) et un survol de vim (puissant, à modes — et son mème : comment en sortir ? Échap puis :wq).

🎯 Objectifs

• Afficher un fichier avec l’outil adapté à sa taille (cat, less, head, tail).
• Suivre un log en direct avec tail -f — le geste de dépannage clé.
• Chercher dans des fichiers avec grep et ses options essentielles.
• Éditer de la config au terminal avec nano, sans panique.
• Savoir ce qu’est vim, et surtout comment en sortir.
• Connaître wc, sort, uniq pour compter et trier.

Lire un fichier : le bon outil selon la taille

Afficher un fichier semble trivial, mais choisir le bon outil change tout, surtout sur un log de plusieurs milliers de lignes.

cat (concatenate) crache tout le fichier d’un coup dans le terminal. Parfait pour un petit fichier (une config de 20 lignes, un .env). Sur un gros fichier, il déroule tout et tu ne vois que la fin : à éviter.

cat .env                # affiche tout le fichier .env d'un coup
cat /etc/hostname       # parfait pour un fichier court

less est un pager : il affiche le fichier page par page, sans tout déverser. C’est l’outil pour les gros fichiers. Une fois dedans, on navigue :

less /var/log/nginx/access.log   # ouvre le log dans le pager

💡 Réflexe — Retiens q pour quitter less (et man, qui utilise le même moteur). C’est LA touche qui débloque le débutant coincé dans un affichage plein écran. Et /motif pour chercher une ligne précise dans un gros log : plus rapide que de scroller à la main.

head et tail montrent le début et la fin d’un fichier — par défaut 10 lignes.

head fichier.log           # les 10 PREMIÈRES lignes
head -n 30 fichier.log     # les 30 premières lignes
tail fichier.log           # les 10 DERNIÈRES lignes
tail -n 50 error.log       # les 50 dernières lignes (souvent les plus utiles)

Sur un log, ce qui t’intéresse est presque toujours la fin (les événements récents) : tail est ton ami.

Le geste clé : suivre un log en direct avec tail -f

Voici la commande que tu taperas des centaines de fois. tail -f (follow) affiche la fin d’un fichier puis reste ouvert et affiche les nouvelles lignes au fur et à mesure qu’elles arrivent. Le fichier « défile en direct » sous tes yeux.

tail -f /var/log/nginx/error.log   # suit le log d'erreurs Nginx EN DIRECT

L’usage type : tu ouvres tail -f sur le log, puis tu reproduis le bug (tu rafraîchis la page qui plante), et tu vois l’erreur apparaître en temps réel dans le terminal. C’est le pont entre « le site bug » et « voilà exactement pourquoi ». Pour arrêter de suivre : Ctrl+C.

🧭 Sur FormaCampus — Quand une page de formacampus.fr renvoie une 502, le premier geste de l’équipe est d’ouvrir deux tail -f côte à côte : un sur /var/log/nginx/error.log (que dit le proxy ?) et un sur les logs du service applicatif (journalctl -u formacampus -f, Partie 3). Puis on rejoue la requête. L’erreur s’affiche en direct : plus besoin de deviner. Ce simple réflexe transforme un dépannage d’une heure en une affaire de deux minutes.

Chercher dans les fichiers : grep

cat et less affichent ; grep filtre. Il parcourt un fichier (ou plusieurs) et n’affiche que les lignes qui contiennent un motif. Sur un log de 50 000 lignes, c’est ce qui te sauve.

grep "error" /var/log/nginx/error.log     # les lignes contenant "error"
grep "404" access.log                     # les lignes contenant "404"

Ses options essentielles :

grep -i "timeout" error.log          # "Timeout", "TIMEOUT", "timeout"… tout
grep -n "proxy_pass" nginx.conf      # avec le numéro de ligne, pour aller éditer
grep -r "formacampus" /etc/nginx/    # cherche dans TOUS les fichiers de /etc/nginx
grep -v "200" access.log             # tout SAUF les requêtes qui ont réussi (200)

grep -r est particulièrement utile pour répondre à « où cette valeur est-elle configurée ? » : tu cherches un nom de domaine ou un port dans tout /etc/nginx/ et tu trouves le fichier fautif, avec -n pour le numéro de ligne.

💡 Réflexe — grep prend toute sa puissance branché sur un pipe | (chapitre 2.5). On enverra la sortie d’une commande dans grep pour la filtrer : journalctl | grep error, ps aux | grep node. Retiens grep maintenant ; sa combinaison avec le pipe arrive au chapitre suivant, et c’est là que la magie opère.

Éditer au terminal : nano, l’éditeur qui ne pique pas

Tôt ou tard, il faut modifier un fichier de config directement sur le serveur. Le choix débutant, simple et sans piège : nano.

nano /etc/nginx/sites-available/formacampus   # ouvre le fichier dans nano

nano affiche le fichier, tu tapes normalement (les flèches déplacent le curseur, tu écris, tu effaces). En bas de l’écran, il rappelle les raccourcis en permanence — pas besoin de les connaître par cœur. Le ^ signifie la touche Ctrl. Les deux qui comptent :

Le geste type : nano fichier, tu modifies, Ctrl+O puis Entrée pour sauvegarder, Ctrl+X pour sortir. C’est tout. nano est parfait pour éditer une config sans stress.

⚠️ Piège — Modifier un fichier de config sans le sauvegarder d’abord. Avant de toucher un fichier système important (config Nginx, sshd_config), fais-en une copie de sécurité : cp fichier fichier.bak. Si ta modification casse le service, tu restaures la copie et tu repars propre. Éditer en prod sans filet, c’est jouer à la roulette.

Survol de vim : puissant, à modes… et comment en sortir

Tu croiseras vim (ou son ancêtre vi) partout : c’est l’éditeur historique d’Unix, présent sur tous les serveurs, même minimalistes. Il est très puissant une fois maîtrisé, mais déroutant au premier contact, car il fonctionne par modes :

• Le mode Normal (celui à l’ouverture) : les touches ne tapent pas de texte, elles commandent (se déplacer, supprimer, coller).
• Le mode Insertion : là tu tapes du texte normalement. On y entre en appuyant sur i (insert).
• On revient au mode Normal avec la touche Échap.

Pour sauvegarder et quitter, on passe par des commandes qui commencent par : :

i           → passer en mode Insertion (pour taper du texte)
Échap       → revenir en mode Normal
:w          → sauvegarder (write)
:q          → quitter (quit)
:wq         → sauvegarder ET quitter
:q!         → quitter SANS sauvegarder (forcer, abandonner les changements)

Et voici le mème le plus célèbre de l’informatique : « comment quitter vim ? ». Des générations de développeurs se sont retrouvées piégées dans vim, tapant frénétiquement sans réussir à sortir. La réponse, à graver dans ta mémoire : appuie sur Échap, puis tape :wq et Entrée (pour sauvegarder et sortir), ou :q! et Entrée (pour sortir en abandonnant tes modifications).

💡 Réflexe — Pour ce cours, nano suffit à tout éditer sereinement. Apprends vim plus tard, quand tu voudras gagner en vitesse. Mais mémorise dès maintenant la porte de sortie de vim (Échap puis :q!) : un jour, une commande t’ouvrira vim sans prévenir (un git commit mal configuré, par exemple), et tu seras content de savoir sortir sans fermer brutalement le terminal.

Compter et trier : wc, sort, uniq

Trois petites commandes qui, combinées à grep et aux pipes, deviennent redoutables :

• wc (word count) compte. wc -l compte les lignes, wc -w les mots, wc -c les octets.
• sort trie les lignes (alphabétiquement par défaut, -n pour un tri numérique).
• uniq dédoublonne les lignes adjacentes identiques (d’où l’usage fréquent sort | uniq : trier d’abord pour regrouper les doublons).

wc -l access.log        # combien de lignes (donc de requêtes) dans le log ?
sort noms.txt           # trie les lignes par ordre alphabétique
sort ips.txt | uniq     # trie puis supprime les doublons consécutifs

On les cite ici ; leur vraie puissance se révèle enchaînées avec un pipe au chapitre suivant. Retiens l’idée : chacune fait une opération (compter, trier, dédoublonner), et on les assemble.

📚 La doc — Chacune de ces commandes a son man (man grep, man less, man nano). Pour grep, la page détaille les expressions régulières, qui décuplent sa puissance (chercher un motif complexe, pas juste un mot). Inutile de tout apprendre : connais les options de base (-i, -n, -r, -v) et ouvre le man quand tu as besoin de plus fin.

✏️ Exercices

Exercice 1 — Le bon outil pour lire. Pour chacun, dis quelle commande tu utilises et pourquoi : (a) afficher un .env de 15 lignes ; (b) explorer un access.log de 80 000 lignes en cherchant une IP ; (c) voir les 20 dernières erreurs d’un log ; (d) regarder les erreurs arriver en direct pendant que tu reproduis un bug.

Exercice 2 — Chasse dans les logs avec grep. Écris les commandes pour : (a) trouver toutes les lignes contenant « 502 » dans access.log, avec leur numéro de ligne ; (b) chercher « timeout » quelle que soit la casse ; (c) trouver dans tout /etc/nginx/ où apparaît « formacampus.fr ».

grep -n "502" access.log
grep -i "timeout" error.log
grep -r "formacampus.fr" /etc/nginx/

Exercice 3 — Sortir de vim. Un tutoriel t’a fait taper une commande qui a ouvert vim, tu as tapé du texte au hasard, et tu es bloqué : rien ne réagit comme prévu. Décris la séquence exacte de touches pour quitter sans rien sauvegarder.

🧠 Quiz de révision

Chapitre suivant : Pipes & redirections — on assemble enfin ces petits outils entre eux pour créer de vraies chaînes de traitement. La philosophie Unix en action.