Chapitre 2.3 — Naviguer & manipuler

⏱️ TL;DR — Voici la boîte à outils du déplacement. Pour regarder : ls (et ls -la, ls -lh), pwd, cd, tree. Pour créer : mkdir -p (dossiers), touch (fichiers vides). Pour copier / déplacer / supprimer : cp -r, mv, et rm — dont le redoutable rm -rf, qu’on manie avec un chemin absolu et le cerveau branché. Pour relier : ln -s (liens symboliques, cruciaux pour les déploiements par releases). Pour retrouver : find (par nom, type, date). Et deux réflexes qui changent la vie : la complétion par Tab et l’historique (flèche haut). Chaque commande fait une chose — on explique laquelle, pas juste la syntaxe.

🎯 Objectifs

• Te déplacer et inspecter avec cd, pwd, ls (et ses options utiles).
• Créer dossiers et fichiers (mkdir -p, touch).
• Copier, déplacer, renommer et supprimer (cp -r, mv, rm) sans dégât.
• Comprendre les liens symboliques (ln -s) et à quoi ils servent en prod.
• Retrouver un fichier avec find.
• Gagner en vitesse avec la complétion Tab et l’historique.

Regarder autour de soi : ls, pwd, cd

Avant d’agir, on regarde. Ces trois commandes ne modifient rien : abuse-en.

• pwd (print working directory) affiche le dossier où tu te trouves. Ta boussole.
• ls (list) liste le contenu d’un dossier. Sans argument, il liste le dossier courant.
• cd (change directory) te déplace dans un autre dossier.

ls seul est utile, mais ses options le rendent bien plus parlant :

ls              # liste simple des fichiers et dossiers visibles
ls -l           # format LONG : permissions, propriétaire, taille, date, nom
ls -a           # inclut les fichiers cachés (ceux qui commencent par .)
ls -la          # les deux : format long + fichiers cachés
ls -lh          # format long avec tailles LISIBLES (4.0K, 2.3M) au lieu d'octets
ls -lt          # trié par date de modification (le plus récent en haut)

Une ligne de ls -l se lit comme ça :

-rw-r--r-- 1 deploy deploy 1240 Jul 15 09:32 .env
drwxr-xr-x 2 deploy deploy 4096 Jul 14 18:10 public

Le tout premier caractère dit le type : - pour un fichier ordinaire, d pour un dossier, l pour un lien. Le reste (les rwx) décrit les permissions — sujet entier de la Partie 3. Pour l’instant, retiens juste que ls -l te dit quoi, à qui, quelle taille, quand.

Pour te déplacer avec cd :

cd /var/log         # va dans /var/log (chemin absolu)
cd nginx            # descend dans le sous-dossier nginx (relatif)
cd ..               # remonte d'un cran (dossier parent)
cd ~                # retourne dans ton dossier personnel
cd                  # idem : cd sans argument = retour à la maison
cd -                # retourne au dossier PRÉCÉDENT (bascule pratique)

💡 Réflexe — Le premier geste en arrivant dans un dossier inconnu : ls -la puis pwd. Tu vois tout (y compris les fichiers cachés comme .env ou .git) et tu confirmes où tu es. Ces deux commandes ne changent rien : c’est de l’observation pure, à faire sans hésiter.

Voir l’arborescence : tree et ls -R

Pour visualiser un dossier et ses sous-dossiers d’un coup, deux options :

ls -R           # liste récursive : le dossier et tout ce qu'il contient, en profondeur
tree            # affiche une jolie arborescence en arbre (si installé)
tree -L 2       # limite l'arbre à 2 niveaux de profondeur

tree n’est pas toujours installé par défaut ; on l’ajoute avec apt install tree (Partie 5 pour la gestion des paquets). ls -R est toujours disponible et rend un service voisin, en moins joli.

Créer : mkdir et touch

• mkdir (make directory) crée un dossier.
• touch crée un fichier vide (ou met à jour la date d’un fichier existant).

mkdir logs                  # crée le dossier "logs" dans le dossier courant
mkdir -p sites/formacampus  # -p : crée toute la chaîne, même les parents manquants
touch notes.txt             # crée un fichier vide notes.txt

L’option -p de mkdir est précieuse : sans elle, mkdir sites/formacampus échoue si sites n’existe pas encore. Avec -p, la commande crée sites puis formacampus, sans se plaindre si un maillon existe déjà. On l’utilise tout le temps dans les scripts de déploiement.

Copier, déplacer, renommer : cp et mv

• cp (copy) copie : l’original reste, une copie est créée.
• mv (move) déplace — et sert aussi à renommer (déplacer un fichier « vers un nouveau nom », c’est le renommer).

cp config.example .env          # copie config.example vers un nouveau fichier .env
cp -r public/ backup-public/    # -r (récursif) : copie un DOSSIER et tout son contenu
mv rapport.txt rapports/        # DÉPLACE rapport.txt dans le dossier rapports/
mv ancien.txt nouveau.txt       # RENOMME (déplace "vers" un nouveau nom)

Note importante : pour copier un dossier, il faut l’option -r (récursif), qui dit « prends le dossier et tout ce qu’il contient ». cp sans -r ne copie que des fichiers simples et se plaint face à un dossier. mv, lui, n’a pas besoin de -r : déplacer un dossier déplace naturellement son contenu.

⚠️ Piège — cp et mv écrasent sans prévenir le fichier de destination s’il existe déjà. mv brouillon.txt important.txt remplace important.txt par le brouillon, sans confirmation, sans corbeille. Pour te protéger, l’option -i (interactive) demande confirmation avant d’écraser : cp -i, mv -i. Un bon réflexe sur des fichiers qui comptent.

Supprimer : rm — et le danger de rm -rf

rm (remove) supprime. Et sous Linux, supprimer, c’est définitif : pas de corbeille, pas de « annuler ». Ce qui est effacé est effacé.

rm brouillon.txt        # supprime le fichier brouillon.txt (définitif !)
rm -i vieux.log         # -i : demande confirmation avant de supprimer
rm -r vieux-dossier/    # -r (récursif) : supprime un DOSSIER et tout son contenu
rm -rf node_modules/    # -r + -f (force) : supprime tout, sans confirmation ni erreur

L’option -f (force) supprime sans poser de question et sans se plaindre si le fichier n’existe pas. Combinée à -r, tu obtiens rm -rf : « supprime ce dossier et tout ce qu’il contient, sans rien demander ». C’est puissant et pratique… et c’est aussi la commande qui a détruit le plus de serveurs de l’histoire.

⚠️ Piège — La commande rm -rf est la tronçonneuse de Linux. Un espace de trop, une variable vide, un mauvais dossier courant, et tu effaces bien plus que prévu. L’exemple tristement célèbre : rm -rf / chemin (avec un espace parasite après le /) qui vise la racine au lieu du dossier voulu. Règles de survie : (1) jamais de rm -rf sans relire deux fois ; (2) utilise un chemin absolu explicite ; (3) fais d’abord un ls sur la même cible pour voir ce que tu vas supprimer ; (4) en cas de doute, ls d’abord, rm ensuite.

🔒 Sécurité — Il n’y a pas de corbeille au terminal Linux. La seule « annulation » possible, c’est une sauvegarde faite avant l’erreur. C’est l’une des raisons pour lesquelles ce cours insiste tant sur les sauvegardes testées (Partie 15). Sur un serveur de prod, considère chaque rm comme irréversible — parce qu’il l’est.

Relier : les liens symboliques ln -s

Un lien symbolique (symlink) est un fichier spécial qui pointe vers un autre fichier ou dossier — un peu comme un raccourci. On le crée avec ln -s (link, symbolic) :

ln -s /var/www/formacampus/releases/2026-07-15 /var/www/formacampus/current
#      ^^^^ la CIBLE (vers où ça pointe)          ^^^^ le NOM du lien créé

Ici, current est un lien qui pointe vers une release datée. L’intérêt : tout le monde (Nginx, ton app) parle de /var/www/formacampus/current, et pour déployer une nouvelle version, il suffit de repointer le lien current vers un nouveau dossier daté. Le basculement est instantané, et le rollback aussi (on repointe vers l’ancienne release). C’est le cœur du déploiement « par releases » qu’on construira en Partie 13.

🧭 Sur FormaCampus — C’est exactement la mécanique que FormaCampus utilisera pour déployer sans coupure. Chaque déploiement crée un dossier daté sous releases/, on y installe le nouveau build, et une fois qu’il est prêt, on bascule le lien current dessus avec ln -s. Si la nouvelle version a un souci, on repointe current vers la release précédente : rollback en une seconde, sans rebuild. Les liens symboliques, qui semblent anecdotiques ici, sont la clé d’un déploiement pro.

Retrouver un fichier : find

Quand tu ne sais plus où est un fichier, find le cherche pour toi en parcourant l’arborescence. Sa logique : où chercher, puis quel critère.

find /var/www -name "*.log"        # tous les fichiers .log sous /var/www
find . -type f -name ".env"        # les FICHIERS (-type f) nommés .env, depuis ici
find /etc -type d -name "nginx"    # les DOSSIERS (-type d) nommés nginx sous /etc
find /var/log -name "*.log" -mtime -1   # les .log modifiés il y a MOINS d'1 jour

Décodons les critères courants : -name "motif" filtre par nom (les guillemets protègent le *), -type f ne garde que les fichiers, -type d que les dossiers, et -mtime -1 sélectionne ce qui a été modifié il y a moins d’un jour (-mtime = modification time). find est verbeux mais puissant : c’est le couteau suisse de la recherche.

Il existe aussi locate, plus rapide car il interroge une base de données pré-construite des fichiers plutôt que de tout parcourir. Revers : cette base doit être à jour (updatedb), donc locate peut rater un fichier créé il y a une minute. find est toujours à jour (il regarde le disque en direct) mais plus lent. Pour un serveur, find est le choix par défaut.

📚 La doc — find a des dizaines de critères et sait même agir sur ce qu’il trouve (-exec). N’essaie pas de tout mémoriser : retiens -name, -type, -mtime, et ouvre man find pour le reste. La page de manuel donne des exemples prêts à adapter. C’est le réflexe : on n’apprend pas find par cœur, on sait où le retrouver.

Aller plus vite : Tab, historique, clear

Deux réflexes multiplient ta vitesse au terminal — et réduisent les fautes de frappe :

• La complétion par Tab : commence à taper un nom de fichier ou de commande, appuie sur Tab, et le shell complète pour toi. Ambigu ? Appuie deux fois sur Tab pour voir les possibilités. Non seulement c’est plus rapide, mais ça évite les fautes de frappe dans les chemins — donc les erreurs de cible.
• L’historique : la flèche haut rappelle tes commandes précédentes (flèche bas pour redescendre). La commande history affiche toute la liste. Et Ctrl+R lance une recherche dans l’historique (tape quelques lettres, il retrouve la commande). Inutile de retaper une longue commande : on la rappelle.

history            # affiche l'historique de tes commandes
clear              # nettoie l'écran (l'historique reste, seul l'affichage est vidé)

💡 Réflexe — Prends l’habitude d’appuyer sur Tab en permanence, pour chaque chemin. C’est le meilleur rempart contre les fautes de frappe dans les noms de fichiers — celles qui font agir sur la mauvaise cible. Un rm sur un chemin complété par Tab est bien plus sûr qu’un chemin tapé à la main. La vitesse et la sécurité, dans une seule touche.

✏️ Exercices

Exercice 1 — Prépare un dossier de déploiement. En partant de ton dossier personnel, crée l’arborescence apps/formacampus/releases/, puis un fichier vide apps/formacampus/.env. Quelles commandes tapes-tu ?

mkdir -p ~/apps/formacampus/releases
touch ~/apps/formacampus/.env

Exercice 2 — Copier vs déplacer. Tu veux garder config.prod.yml intact et en avoir une version de travail nommée config.yml. Quelle commande ? Et si tu voulais au contraire renommer définitivement config.prod.yml en config.yml (sans garder l’original) ?

Exercice 3 — Le rm qui fait peur. Un collègue est dans son dossier personnel et veut vider un dossier de build. Il tape rm -rf build mais s’est trompé et a en tête rm -rf / par habitude. Explique en une phrase pourquoi rm -rf / est catastrophique, et donne deux précautions à prendre avant tout rm -rf.

🧠 Quiz de révision

Chapitre suivant : Lire & éditer des fichiers — afficher, suivre un log en direct, chercher avec grep, et modifier de la config au clavier.