Les 50 commandes Linux essentielles pour les débutants (avec exercices pratiques)

Que vous débutiez en informatique ou que vous administriez des serveurs en production, les commandes Linux sont votre outil quotidien. Dans ce guide, nous avons sélectionné les 50 commandes les plus utilisées, organisées par catégorie, avec des exemples concrets que vous pouvez tester immédiatement.

La différence avec les autres guides ? Chaque commande renvoie vers un lab interactif où vous pouvez la pratiquer sur un vrai terminal Ubuntu, sans rien installer.

Navigation dans le système de fichiers

Tout commence par savoir se déplacer dans l'arborescence. Ces 6 commandes représentent probablement 40% de votre utilisation quotidienne du terminal.

1. pwd — Où suis-je ?

pwd (Print Working Directory) affiche le chemin absolu du répertoire courant. C'est le GPS du terminal : quand vous êtes perdu, c'est la première commande à taper.

$ pwd
/home/ubuntu/projets

2. ls — Qu'y a-t-il ici ?

La commande la plus tapée au monde. ls liste le contenu d'un répertoire. Les options les plus utiles :

$ ls -la          # Liste détaillée avec fichiers cachés
$ ls -lh          # Tailles lisibles (Ko, Mo, Go)
$ ls -lt          # Tri par date de modification
$ ls -lS          # Tri par taille

Astuce : créez un alias alias ll='ls -lah' dans votre ~/.bashrc pour gagner du temps.

3. cd — Se déplacer

cd (Change Directory) est votre moyen de transport dans l'arborescence.

$ cd /var/log      # Chemin absolu
$ cd ..            # Remonter d'un niveau
$ cd ~             # Retour au home
$ cd -             # Revenir au répertoire précédent

4. tree — Visualiser l'arborescence

Affiche l'arborescence sous forme d'arbre. Idéal pour comprendre la structure d'un projet.

$ tree -L 2        # Limiter à 2 niveaux de profondeur
$ tree -d          # Afficher uniquement les répertoires

5. find — Chercher des fichiers

La commande de recherche la plus puissante de Linux. Elle parcourt récursivement l'arborescence selon vos critères.

$ find /var -name "*.log"           # Par nom
$ find . -size +100M               # Fichiers > 100 Mo
$ find /tmp -mtime +7 -delete      # Supprimer les fichiers de plus de 7 jours
$ find . -type f -name "*.js"      # Uniquement les fichiers JS

6. locate — Recherche rapide par index

Plus rapide que find car il utilise une base de données indexée. Pensez à lancer sudo updatedb pour mettre à jour l'index.

Manipulation de fichiers

7. cat — Afficher le contenu

Affiche le contenu d'un fichier d'un coup. Parfait pour les petits fichiers.

$ cat /etc/hostname
$ cat -n fichier.txt       # Avec numéros de ligne

8. less / more — Lire page par page

Pour les fichiers longs, less permet de naviguer avec les flèches. Tapez /motclé pour chercher, q pour quitter.

9. head et tail — Début et fin

$ head -20 access.log      # 20 premières lignes
$ tail -f /var/log/syslog  # Suivre en temps réel (logs)

Incontournable : tail -f est l'outil numéro 1 pour le debugging en production.

10. touch — Créer un fichier vide

$ touch index.html style.css app.js

11. cp — Copier

$ cp fichier.txt copie.txt
$ cp -r dossier/ backup/          # Copie récursive
$ cp -p fichier.txt /tmp/         # Préserver permissions et dates

12. mv — Déplacer ou renommer

$ mv ancien.txt nouveau.txt        # Renommer
$ mv *.log /var/log/archives/      # Déplacer

13. rm — Supprimer

$ rm fichier.txt
$ rm -r dossier/                   # Supprimer récursivement
$ rm -i fichier.txt                # Demander confirmation

Attention : il n'y a pas de corbeille sous Linux. rm est définitif.

14. mkdir / rmdir — Créer et supprimer des répertoires

$ mkdir -p projet/src/components   # Créer toute l'arborescence
$ rmdir dossier-vide/

Gestion des permissions

Sous Linux, chaque fichier a un propriétaire, un groupe et des permissions. Comprendre ce système est fondamental pour la sécurité.

15. chmod — Modifier les permissions

$ chmod 755 script.sh      # rwxr-xr-x (lecture/exécution pour tous)
$ chmod 600 secret.key     # rw------- (lecture/écriture propriétaire uniquement)
$ chmod +x script.sh       # Ajouter le droit d'exécution

16. chown — Changer le propriétaire

$ sudo chown www-data:www-data /var/www/html/ -R

17. chgrp — Changer le groupe

$ chgrp developers projet/

Gestion des processus

18. ps — Lister les processus

$ ps aux                   # Tous les processus
$ ps aux | grep nginx      # Filtrer par nom

19. top / htop — Moniteur en temps réel

htop est la version améliorée de top, avec une interface en couleur et la possibilité de trier par CPU, mémoire, etc.

20. kill / killall — Arrêter un processus

$ kill 1234                # Par PID
$ kill -9 1234             # Forcer l'arrêt
$ killall nginx            # Par nom

21. systemctl — Gérer les services

$ sudo systemctl status nginx
$ sudo systemctl restart nginx
$ sudo systemctl enable nginx      # Démarrer au boot

Réseau

22. curl — Requêtes HTTP

$ curl -I https://example.com       # Headers uniquement
$ curl -s https://api.github.com   # Requête silencieuse
$ curl -X POST -d '{"key":"value"}' -H "Content-Type: application/json" http://localhost:3000/api

23. wget — Télécharger des fichiers

$ wget https://example.com/fichier.zip
$ wget -c url_fichier              # Reprendre un téléchargement interrompu

24. ping — Tester la connectivité

$ ping -c 4 google.com

25. ss / netstat — Ports et connexions

$ ss -tlnp                         # Ports en écoute
$ ss -s                            # Statistiques réseau

26. ip — Configuration réseau

$ ip addr show                     # Adresses IP
$ ip route show                    # Table de routage

27. scp / rsync — Transfert de fichiers

$ scp fichier.txt user@serveur:/tmp/
$ rsync -avz dossier/ user@serveur:/backup/    # Synchronisation incrémentale

Manipulation de texte

La puissance de Linux réside dans le chaînage de commandes texte. Maîtriser grep, sed et awk transforme votre productivité.

28. grep — Rechercher dans le texte

$ grep "error" /var/log/syslog
$ grep -r "TODO" ./src/            # Recherche récursive
$ grep -i "warning" log.txt        # Ignorer la casse
$ grep -c "error" log.txt          # Compter les occurrences

29. sed — Édition en flux

$ sed 's/ancien/nouveau/g' fichier.txt
$ sed -i 's/localhost/0.0.0.0/g' config.yml    # Modifier en place

30. awk — Traitement de données structurées

$ awk '{print $1, $4}' access.log              # Colonnes 1 et 4
$ df -h | awk '$5 > "80%" {print $1, $5}'      # Disques > 80%

31. sort et uniq — Trier et dédupliquer

$ sort fichier.txt | uniq -c | sort -rn         # Top des lignes les plus fréquentes

32. wc — Compter

$ wc -l fichier.txt                # Nombre de lignes
$ find . -name "*.js" | wc -l     # Nombre de fichiers JS

33. cut — Extraire des colonnes

$ cut -d: -f1 /etc/passwd          # Lister les noms d'utilisateurs

34. Le pipe | — Chaîner les commandes

Le pipe est le ciment de Linux. Il envoie la sortie d'une commande vers l'entrée de la suivante.

$ cat access.log | grep "POST" | awk '{print $7}' | sort | uniq -c | sort -rn | head -10

Cette ligne unique vous donne le top 10 des URLs POST les plus appelées dans vos logs. C'est la puissance du terminal.

Compression et archivage

35. tar — Créer et extraire des archives

$ tar -czvf archive.tar.gz dossier/    # Compresser
$ tar -xzvf archive.tar.gz            # Extraire
$ tar -tzvf archive.tar.gz            # Lister le contenu

36. zip / unzip

$ zip -r backup.zip dossier/
$ unzip backup.zip

Disque et système

37. df — Espace disque

$ df -h                            # Espace libre par partition

38. du — Taille des dossiers

$ du -sh /var/log/*                 # Taille de chaque sous-dossier
$ du -sh * | sort -rh | head -10   # Top 10 des plus gros dossiers

39. free — Mémoire RAM

$ free -h

40. uptime — Depuis quand tourne le serveur

$ uptime

41. uname — Informations système

$ uname -a                         # Tout afficher

Utilisateurs et sudo

42. sudo — Exécuter en root

$ sudo apt update
$ sudo su -                        # Devenir root

43. useradd / usermod — Gérer les utilisateurs

$ sudo useradd -m -s /bin/bash alice
$ sudo usermod -aG sudo alice      # Ajouter aux sudoers

44. passwd — Changer un mot de passe

$ sudo passwd alice

Édition de texte

45. nano — Éditeur simple

L'éditeur le plus accessible. Ctrl+O pour sauvegarder, Ctrl+X pour quitter.

46. vim — Éditeur puissant

Plus complexe mais infiniment plus productif une fois maîtrisé. i pour insérer, Esc puis :wq pour sauvegarder et quitter.

Commandes avancées

47. crontab — Tâches planifiées

$ crontab -e                       # Éditer les tâches
$ crontab -l                       # Lister les tâches
# Exemple: backup tous les jours à 2h du matin
# 0 2 * * * tar -czvf /backup/daily.tar.gz /var/www/

48. ssh — Connexion distante

$ ssh user@serveur
$ ssh -i cle.pem ubuntu@203.0.113.42

49. xargs — Construire des commandes

$ find . -name "*.tmp" | xargs rm      # Supprimer tous les .tmp
$ cat urls.txt | xargs -n1 curl -sI   # Tester chaque URL

50. alias — Créer des raccourcis

$ alias ll='ls -lah'
$ alias gs='git status'
$ alias dc='docker compose'
# Ajouter dans ~/.bashrc pour les rendre permanents

Tableau récapitulatif

Comment aller plus loin ?

Lire des commandes, c'est bien. Les pratiquer, c'est mieux. La meilleure façon de mémoriser ces commandes est de les utiliser dans un vrai terminal, avec des exercices guidés qui valident automatiquement vos réponses.

Notre parcours Linux comprend 80 labs interactifs qui couvrent toutes ces commandes et bien plus, organisés par niveau de difficulté (débutant → expert), avec un tuteur IA en français qui vous aide quand vous êtes bloqué.