Quand j’ai découvert Linux pour la première fois en BTS SIO, je me souviens avoir fixé ce terminal noir avec un mélange de fascination et d’appréhension. Aujourd’hui, après des années à former des étudiants et à administrer des serveurs, je peux vous affirmer une chose : maîtriser les commandes Linux de base transforme radicalement votre efficacité en informatique. Que vous prépariez votre BTS SIO via Parcoursup ou que vous débutiez simplement en administration système, ce guide vous accompagne pas à pas dans l’apprentissage des 15 commandes Linux indispensables pour débutants.

Pourquoi apprendre les commandes Linux en 2026

Linux fait tourner plus de 96 % des serveurs web dans le monde, selon la Linux Foundation. C’est aussi le système d’exploitation privilégié pour le cloud computing, la cybersécurité et le DevOps. En tant que formatrice, je constate chaque année que mes étudiants qui maîtrisent le terminal Linux décrochent plus facilement leurs stages et leurs premiers postes.

Concrètement, apprendre les commandes Linux vous permet de :

• Administrer des serveurs à distance via SSH, sans interface graphique
• Automatiser des tâches répétitives grâce aux scripts Bash
• Comprendre les environnements de déploiement (Docker, CI/CD, cloud)
• Réussir les épreuves pratiques du BTS SIO option SISR
• Renforcer votre profil pour les métiers de la cybersécurité et de l’infrastructure

Pas besoin d’installer une distribution complète pour commencer : Windows 10 et 11 intègrent WSL (Windows Subsystem for Linux), et vous pouvez aussi utiliser un terminal en ligne. Pour aller plus loin, je vous recommande de monter votre propre serveur Linux maison : c’est le meilleur terrain d’entraînement possible.

Naviguer dans le système de fichiers : pwd, ls et cd

La toute première chose à faire dans un terminal, c’est savoir où vous êtes et comment vous déplacer. Ces trois commandes constituent votre boussole.

1. pwd (Print Working Directory)

Cette commande affiche le chemin absolu du répertoire courant. C’est votre point de repère permanent.

$ pwd
/home/lucie/documents

Je recommande toujours à mes étudiants de taper pwd dès qu’ils sont perdus. C’est le réflexe numéro un à acquérir.

2. ls (List)

La commande ls liste le contenu d’un répertoire. Avec quelques options, elle devient incroyablement puissante :

# Liste simple
$ ls
Documents  Images  Musique  Téléchargements

# Liste détaillée avec fichiers cachés
$ ls -la
total 48
drwxr-xr-x 6 lucie lucie 4096 avr 10 14:30 .
drwxr-xr-x 3 root  root  4096 mar 15 09:00 ..
-rw-r--r-- 1 lucie lucie  220 mar 15 09:00 .bash_logout
-rw-r--r-- 1 lucie lucie 3526 mar 15 09:00 .bashrc
drwxr-xr-x 2 lucie lucie 4096 avr 10 14:30 Documents

# Liste triée par date de modification
$ ls -lt

# Liste avec tailles lisibles
$ ls -lh

Les options que j’utilise le plus souvent : -l pour le format détaillé, -a pour afficher les fichiers cachés (commençant par un point), et -h pour des tailles lisibles (Ko, Mo, Go).

3. cd (Change Directory)

cd vous permet de naviguer entre les répertoires :

# Aller dans un dossier
$ cd Documents

# Remonter d'un niveau
$ cd ..

# Aller directement dans le répertoire personnel
$ cd ~

# Revenir au répertoire précédent
$ cd -

# Chemin absolu
$ cd /var/log

Astuce que je partage systématiquement en cours : utilisez la touche Tab pour l’autocomplétion. Tapez cd Doc puis Tab, et le terminal complète automatiquement en cd Documents/. Cela évite les fautes de frappe et accélère considérablement votre travail.

Gérer fichiers et dossiers : mkdir, touch, cp, mv et rm

Maintenant que vous savez naviguer, passons à la gestion concrète des fichiers. Ces cinq commandes couvrent toutes les opérations courantes.

4. mkdir (Make Directory)

Crée un ou plusieurs répertoires :

# Créer un dossier
$ mkdir projets

# Créer une arborescence complète d'un coup
$ mkdir -p projets/web/css projets/web/js projets/web/images

# Créer plusieurs dossiers en une commande
$ mkdir documents images videos

L’option -p (parents) est indispensable : elle crée tous les répertoires intermédiaires sans erreur si certains existent déjà.

5. touch

Bien que sa fonction première soit de modifier la date de modification d’un fichier, touch est surtout utilisé pour créer des fichiers vides :

# Créer un fichier vide
$ touch index.html

# Créer plusieurs fichiers
$ touch style.css script.js readme.md

6. cp (Copy)

Copie des fichiers ou des dossiers :

# Copier un fichier
$ cp fichier.txt copie_fichier.txt

# Copier un fichier dans un autre répertoire
$ cp config.ini /home/lucie/backup/

# Copier un dossier entier (récursif)
$ cp -r projets/ projets_backup/

# Copier en préservant les permissions et dates
$ cp -a source/ destination/

7. mv (Move)

Déplace ou renomme des fichiers et dossiers :

# Renommer un fichier
$ mv ancien_nom.txt nouveau_nom.txt

# Déplacer un fichier dans un dossier
$ mv rapport.pdf Documents/

# Déplacer plusieurs fichiers
$ mv *.jpg Images/

8. rm (Remove)

Supprime des fichiers et dossiers. Attention : il n’y a pas de corbeille en ligne de commande. Ce qui est supprimé est définitivement perdu.

# Supprimer un fichier
$ rm fichier_inutile.txt

# Supprimer avec demande de confirmation
$ rm -i fichier_important.txt

# Supprimer un dossier et son contenu
$ rm -r ancien_projet/

# Supprimer un dossier vide (plus sûr)
$ rmdir dossier_vide/

Je dis toujours à mes étudiants : n’utilisez jamais rm -rf / ou des variantes avec des jokers trop larges. Vérifiez deux fois votre commande avant d’appuyer sur Entrée. L’option -i (interactif) est votre filet de sécurité.

Lire et manipuler le contenu des fichiers : cat, head, tail et grep

Savoir lire le contenu des fichiers sans les ouvrir dans un éditeur est une compétence fondamentale, surtout quand vous travaillez sur un serveur distant.

9. cat (Concatenate)

Affiche le contenu intégral d’un fichier :

# Afficher un fichier
$ cat /etc/hostname
serveur-web-01

# Afficher avec numéros de lignes
$ cat -n script.sh
     1	#!/bin/bash
     2	echo "Bonjour"
     3	exit 0

# Concaténer deux fichiers dans un troisième
$ cat partie1.txt partie2.txt > document_complet.txt

Pour les fichiers longs, préférez less qui permet de naviguer page par page avec les flèches.

10. head et tail

Ces deux commandes complémentaires affichent respectivement le début et la fin d’un fichier :

# Les 10 premières lignes (défaut)
$ head /var/log/syslog

# Les 20 premières lignes
$ head -n 20 access.log

# Les 10 dernières lignes
$ tail /var/log/syslog

# Suivre un fichier en temps réel (idéal pour les logs)
$ tail -f /var/log/apache2/error.log

L’option tail -f est l’une de mes préférées : elle affiche les nouvelles lignes ajoutées au fichier en temps réel. Indispensable pour surveiller les logs d’un serveur web ou déboguer une application.

11. grep (Global Regular Expression Print)

grep recherche des motifs dans le contenu des fichiers. C’est probablement la commande que j’utilise le plus au quotidien :

# Rechercher un mot dans un fichier
$ grep "error" /var/log/syslog

# Recherche insensible à la casse
$ grep -i "warning" application.log

# Rechercher récursivement dans tous les fichiers d'un dossier
$ grep -r "TODO" projets/

# Afficher les numéros de lignes
$ grep -n "function" script.js

# Compter le nombre d'occurrences
$ grep -c "404" access.log
247

Combinée avec d’autres commandes via le pipe (|), grep devient un outil de filtrage extrêmement puissant. Par exemple : cat access.log | grep "POST" | grep "login" pour trouver toutes les tentatives de connexion dans un log Apache.

Permissions et gestion des utilisateurs : chmod, chown et sudo

La gestion des permissions est au cœur de la sécurité Linux. Comprendre ces trois commandes est essentiel, surtout si vous vous orientez vers l’option SISR du BTS SIO ou vers la cybersécurité.

12. chmod (Change Mode)

Modifie les permissions d’accès aux fichiers et dossiers. Linux utilise un système à trois niveaux : propriétaire (u), groupe (g), autres (o), avec trois types de droits : lecture (r=4), écriture (w=2), exécution (x=1).

# Rendre un script exécutable
$ chmod +x mon_script.sh

# Notation numérique : rwxr-xr-- (propriétaire : tout, groupe : lecture+exécution, autres : lecture)
$ chmod 754 mon_script.sh

# Donner tous les droits au propriétaire, lecture seule aux autres
$ chmod 744 config.ini

# Appliquer récursivement à un dossier
$ chmod -R 755 site_web/

Voici un aide-mémoire pour la notation octale que je distribue en cours :

• 7 (rwx) : lecture + écriture + exécution
• 6 (rw-) : lecture + écriture
• 5 (r-x) : lecture + exécution
• 4 (r–) : lecture seule
• 0 (—) : aucun droit

13. chown (Change Owner)

Change le propriétaire et/ou le groupe d’un fichier :

# Changer le propriétaire
$ sudo chown lucie fichier.txt

# Changer propriétaire et groupe
$ sudo chown lucie:www-data /var/www/html/index.html

# Changer récursivement
$ sudo chown -R www-data:www-data /var/www/site/

Cette commande nécessite généralement les droits administrateur, d’où l’utilisation de sudo.

14. sudo (Super User Do)

sudo exécute une commande avec les privilèges de l’administrateur (root) :

# Mettre à jour la liste des paquets
$ sudo apt update

# Installer un logiciel
$ sudo apt install nginx

# Éditer un fichier système
$ sudo nano /etc/hosts

# Devenir root temporairement
$ sudo -i

Règle d’or que je répète sans cesse : n’utilisez sudo que lorsque c’est strictement nécessaire. Travailler en permanence en root est une très mauvaise habitude qui expose votre système à des erreurs potentiellement catastrophiques. Chaque commande sudo doit être réfléchie.

Commandes système et réseau essentielles

Pour compléter votre arsenal, voici la quinzième commande indispensable, accompagnée de quelques bonus qui vous seront utiles au quotidien.

15. man (Manual)

La commande man affiche le manuel détaillé de n’importe quelle commande :

# Consulter le manuel de grep
$ man grep

# Rechercher dans le manuel
$ man -k "file search"

# Version courte avec --help
$ ls --help

Je considère man comme la commande la plus importante de toutes. Elle vous rend autonome. Avant de chercher sur internet, prenez le réflexe de consulter le manuel. Vous y trouverez des explications précises, des options que vous ne connaissiez pas et des exemples d’utilisation.

Bonus : commandes réseau utiles

Si vous étudiez les bases du réseau informatique, ces commandes vous seront précieuses :

# Vérifier la connectivité réseau
$ ping google.com

# Afficher la configuration réseau
$ ip addr show

# Voir les connexions actives
$ ss -tuln

# Analyser le chemin réseau
$ traceroute web-sio.fr

# Télécharger un fichier
$ wget https://exemple.com/fichier.zip
$ curl -O https://exemple.com/api/data.json

Pour approfondir l’analyse réseau, je vous recommande de consulter notre tutoriel Wireshark pour débutants qui complète parfaitement ces commandes.

Tableau d’équivalences Linux/Windows/PowerShell

Si vous venez du monde Windows, ce tableau de correspondance vous aidera à faire la transition. J’ai également inclus les commandes PowerShell équivalentes pour ceux qui travaillent dans les deux environnements.

Les 5 erreurs fréquentes des débutants Linux

Après des années de formation, j’ai identifié les erreurs qui reviennent le plus souvent. Les connaître vous évitera bien des frustrations.

Erreur 1 : travailler en root en permanence

C’est l’erreur la plus dangereuse. Quand vous êtes root, aucune protection ne vous empêche de détruire le système. Un simple rm -rf / par mégarde, et votre serveur est anéanti. Utilisez toujours votre compte utilisateur normal et réservez sudo aux commandes qui l’exigent réellement.

Erreur 2 : ignorer les messages d’erreur

Linux vous donne des messages d’erreur précis et utiles. « Permission denied » signifie que vous n’avez pas les droits nécessaires. « No such file or directory » indique un chemin incorrect. Lisez ces messages attentivement avant de chercher une solution sur internet.

Erreur 3 : ne pas utiliser l’autocomplétion

La touche Tab est votre meilleure alliée. Elle complète automatiquement les noms de fichiers, de commandes et de chemins. Un double appui sur Tab affiche toutes les possibilités. Ne pas l’utiliser, c’est se priver d’un gain de temps considérable et s’exposer à des fautes de frappe.

Erreur 4 : copier-coller des commandes sans les comprendre

Je vois régulièrement des étudiants copier des commandes trouvées sur des forums sans savoir ce qu’elles font. Avant d’exécuter quoi que ce soit, utilisez man ou --help pour comprendre chaque option. Une commande incomprise est une commande dangereuse.

Erreur 5 : ne pas faire de sauvegardes avant de modifier des fichiers système

Avant de modifier un fichier de configuration, prenez l’habitude de le copier :

$ sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.backup

Cette simple précaution vous permet de restaurer la configuration d’origine en cas de problème. Combinée avec les commandes Git, cette pratique de versioning devient encore plus puissante.

Exercices pratiques progressifs

La théorie ne suffit pas. Voici trois exercices de difficulté croissante que je donne à mes étudiants de première année.

Exercice 1 : organisation de projet (niveau débutant)

Créez l’arborescence suivante pour un projet web, puis vérifiez le résultat :

# Créer la structure
$ mkdir -p mon-site/{css,js,images,pages}
$ touch mon-site/index.html
$ touch mon-site/css/style.css
$ touch mon-site/js/app.js
$ touch mon-site/pages/{about.html,contact.html}

# Vérifier le résultat
$ ls -R mon-site/

Exercice 2 : analyse de logs (niveau intermédiaire)

Créez un fichier de logs simulé et analysez-le :

# Créer un faux fichier de log
$ echo '192.168.1.10 - GET /index.html 200
192.168.1.15 - POST /login 401
192.168.1.10 - GET /style.css 200
10.0.0.5 - GET /admin 403
192.168.1.15 - POST /login 200
10.0.0.5 - GET /admin 403' > access.log

# Trouver toutes les erreurs 403
$ grep "403" access.log

# Compter les tentatives de connexion
$ grep -c "login" access.log

# Voir les 3 dernières lignes
$ tail -n 3 access.log

Exercice 3 : gestion des permissions (niveau avancé)

# Créer un script
$ echo '#!/bin/bash
echo "Bonjour depuis mon premier script !"' > salut.sh

# Essayer de l'exécuter (erreur attendue)
$ ./salut.sh
bash: ./salut.sh: Permission denied

# Ajouter le droit d'exécution
$ chmod +x salut.sh

# Exécuter le script
$ ./salut.sh
Bonjour depuis mon premier script !

Pour un environnement d’entraînement complet, pensez à configurer un homelab étudiant avec une machine virtuelle Linux dédiée à vos exercices.

Ressources pour aller plus loin

Une fois ces 15 commandes maîtrisées, vous êtes prêt à approfondir. Voici le parcours que je recommande à mes étudiants :

Étape 1 : consolider les bases (semaines 1 à 2)

Pratiquez les 15 commandes de ce guide quotidiennement. Utilisez VS Code avec un terminal intégré pour combiner édition de code et ligne de commande dans le même environnement.

Étape 2 : passer aux scripts Bash (semaines 3 à 4)

Apprenez à enchaîner les commandes dans des scripts pour automatiser vos tâches. Le site LinuxCommand.org propose un excellent cours gratuit.

Étape 3 : découvrir l’administration système (mois 2)

Explorez la gestion des services (systemctl), des paquets (apt, dnf) et du réseau. Notre guide sur Ansible pour débutants vous permettra ensuite d’automatiser l’administration de plusieurs serveurs.

Étape 4 : valider vos compétences

Pensez aux certifications informatique gratuites comme le Linux Essentials du LPI ou les parcours proposés par Red Hat. Ces certifications sont reconnues par les employeurs et valorisent votre CV.

Pour compléter votre boîte à outils de développeur, n’hésitez pas à explorer également les meilleurs outils pour étudiants en informatique et à créer votre portfolio avec GitHub Pages pour mettre en valeur vos projets.