Les essentiels de la ligne de commande Linux que tout développeur devrait connaître

Terminal avec du texte vert sur un écran sombre

La ligne de commande Linux est l'interface universelle pour les serveurs, les conteneurs, les pipelines CI et les environnements de développement. Que vous soyez connecté en SSH à un serveur de production à 2h du matin ou en train de déboguer un conteneur Docker, la maîtrise de ces commandes fait toute la différence entre confusion et assurance.

# Naviguer dans les répertoires
pwd                      # afficher le répertoire courant
cd /var/log              # chemin absolu
cd ..                    # remonter d'un niveau
cd -                     # revenir au répertoire précédent
cd ~                     # répertoire personnel

# Lister les fichiers
ls                       # liste simple
ls -la                   # format long + fichiers cachés
ls -lh                   # tailles de fichiers lisibles par l'humain
ls -lt                   # trier par date de modification (plus récent d'abord)

# Créer, copier, déplacer, supprimer
mkdir -p path/to/dir     # créer un répertoire + ses parents
cp -r source/ dest/      # copie récursive
mv oldname newname       # renommer ou déplacer
rm -rf directory/        # supprimer un répertoire et son contenu (irréversible !)
touch file.txt           # créer un fichier vide / mettre à jour l'horodatage

# Afficher et parcourir des fichiers
cat file.txt             # afficher le fichier entier
less file.txt            # visionneur paginé (q pour quitter, / pour chercher)
head -n 20 file.txt      # les 20 premières lignes
tail -n 20 file.txt      # les 20 dernières lignes
tail -f /var/log/app.log # suivre le journal en temps réel

Permissions de fichiers

Les permissions Linux s'expriment sous forme de trois ensembles de bits lecture/écriture/exécution pour le propriétaire, le groupe et les autres :

-rwxr-xr--  1 alice devs  4096 Apr 8 10:00 script.sh

Lecture de la chaîne de permissions : -rwxr-xr--

- — type de fichier (d = répertoire, l = lien symbolique)
rwx — propriétaire : lecture, écriture, exécution
r-x — groupe : lecture, exécution (pas d'écriture)
r-- — autres : lecture seule

chmod — modifier les permissions

# Notation symbolique
chmod u+x script.sh      # ajouter l'exécution pour le propriétaire
chmod g-w file.txt       # retirer l'écriture pour le groupe
chmod o=r file.txt       # définir les autres en lecture seule
chmod a+r file.txt       # ajouter la lecture pour tous (a = all)

# Notation numérique (octale)
chmod 755 script.sh      # rwxr-xr-x (courant pour les exécutables)
chmod 644 file.txt       # rw-r--r-- (courant pour les fichiers)
chmod 600 ~/.ssh/id_rsa  # rw------- (requis pour les clés SSH)
chmod 700 ~/.ssh/        # rwx------ (requis pour le répertoire .ssh)

Utilisez notre Calculateur Chmod pour construire visuellement des chaînes de permissions et comprendre la signification de chaque valeur octale.

Recherche et traitement du texte

# Rechercher des fichiers
find /var/log -name "*.log"               # rechercher par nom
find . -name "*.ts" -newer package.json   # fichiers plus récents que package.json
find . -type f -size +10M                 # fichiers de plus de 10 Mo
find . -name "node_modules" -prune        # exclure des répertoires

# Rechercher dans le contenu des fichiers
grep "error" app.log                      # chercher dans un fichier
grep -r "TODO" ./src                      # recherche récursive
grep -i "error" app.log                   # insensible à la casse
grep -n "error" app.log                   # afficher les numéros de ligne
grep -v "DEBUG" app.log                   # lignes NE correspondant PAS
grep -E "error|warning" app.log           # regex : error OU warning

# Traitement de flux texte
cat access.log | grep "404" | wc -l       # compter les erreurs 404
cat data.csv | cut -d',' -f1,3            # extraire les colonnes 1 et 3
cat file.txt | sort | uniq                # trier et dédupliquer
cat file.txt | sort | uniq -c | sort -rn  # compter les occurrences, trier par fréquence

awk — traitement par champs

# Afficher des champs spécifiques (séparés par tabulation par défaut)
awk '{print $1, $3}' file.txt

# Traiter un CSV (séparé par virgules)
awk -F',' '{print $2}' data.csv

# Sommer une colonne
awk -F',' '{sum += $3} END {print sum}' data.csv

# Afficher les lignes correspondant à un motif
awk '/ERROR/ {print $0}' app.log

sed — éditeur de flux

# Remplacer du texte
sed 's/foo/bar/' file.txt          # remplacer la première occurrence par ligne
sed 's/foo/bar/g' file.txt         # remplacer toutes les occurrences (global)
sed -i 's/foo/bar/g' file.txt      # modification en place (modifie le fichier)

# Supprimer des lignes
sed '/^#/d' file.txt               # supprimer les lignes de commentaires
sed '5,10d' file.txt               # supprimer les lignes 5 à 10

# Afficher des lignes spécifiques
sed -n '10,20p' file.txt           # afficher les lignes 10 à 20

Gestion des processus

# Voir les processus en cours
ps aux                             # tous les processus avec détails
ps aux | grep nginx                # trouver les processus nginx
top                                # visionneur de processus interactif
htop                               # visionneur interactif amélioré (si installé)

# Contrôle des processus
kill PID                           # envoyer SIGTERM (arrêt propre)
kill -9 PID                        # envoyer SIGKILL (forcer l'arrêt)
pkill nginx                        # tuer par nom
killall node                       # tuer tous les processus correspondants

# Tâches en arrière-plan
command &                          # exécuter en arrière-plan
jobs                               # lister les tâches en arrière-plan
fg %1                              # ramener la tâche 1 au premier plan
nohup command &                    # exécuter en ignorant le signal de déconnexion

# Ressources système
free -h                            # utilisation de la mémoire
df -h                              # utilisation de l'espace disque
du -sh /var/log/                   # taille d'un répertoire
lsof -i :3000                      # ce qui utilise le port 3000

Commandes réseau

# Connectivité
ping google.com                    # tester la connectivité
curl -I https://example.com        # en-têtes HTTP uniquement
curl -o file.zip https://example.com/file.zip  # télécharger un fichier
wget https://example.com/file.zip  # téléchargeur alternatif

# Inspecter les connexions
ss -tulpn                          # ports en écoute et processus
netstat -tulpn                     # alternative (systèmes plus anciens)
lsof -i :80                        # ce qui est sur le port 80

# DNS
dig example.com                    # résolution DNS
dig example.com MX                 # enregistrements MX
host example.com                   # résolution DNS simple
nslookup example.com               # requête DNS interactive

SSH et accès distant

# Se connecter à un serveur
ssh user@server.com
ssh -p 2222 user@server.com        # port non standard
ssh -i ~/.ssh/id_rsa user@server.com  # clé spécifique

# Copier des fichiers
scp file.txt user@server.com:~/    # copier vers le répertoire personnel distant
scp user@server.com:~/file.txt .   # copier depuis le distant
scp -r ./dist user@server.com:~/app/  # copie récursive

# Tunneling SSH (redirection de port)
ssh -L 5432:localhost:5432 user@server.com  # tunneliser une base de données distante vers un port local

Générez des paires de clés SSH pour une authentification sécurisée avec notre Générateur de clés SSH.

Environnement et shell

# Variables d'environnement
export API_KEY=abc123              # définir pour la session courante et les processus enfants
echo $API_KEY                      # afficher la variable
env                                # lister toutes les variables d'environnement
printenv PATH                      # afficher une variable spécifique
unset API_KEY                      # supprimer la variable

# Historique du shell
history                            # lister les commandes précédentes
!!                                 # répéter la dernière commande
!grep                              # répéter la dernière commande grep
Ctrl+R                             # recherche inverse dans l'historique (taper pour chercher)

# Raccourcis utiles
Ctrl+C                             # interrompre le processus courant
Ctrl+Z                             # suspendre en arrière-plan
Ctrl+L                             # effacer l'écran (identique à clear)
Ctrl+A                             # aller au début de la ligne
Ctrl+E                             # aller à la fin de la ligne
Ctrl+U                             # effacer la ligne avant le curseur

Pipes et redirections

# Pipes — enchaîner des commandes
ls -la | grep ".log" | wc -l

# Rediriger la sortie
command > file.txt                 # écraser le fichier avec stdout
command >> file.txt                # ajouter stdout au fichier
command 2> errors.txt              # rediriger stderr
command > all.txt 2>&1             # rediriger stdout + stderr vers le même fichier
command &> all.txt                 # raccourci pour ce qui précède

# /dev/null — ignorer la sortie
command > /dev/null 2>&1           # ignorer toute la sortie (exécution silencieuse)

Commandes en une ligne utiles pour les développeurs

# Rechercher et remplacer dans tous les fichiers d'un répertoire
find . -name "*.tsx" | xargs sed -i 's/OldComponent/NewComponent/g'

# Obtenir l'adresse IP publique
curl -s ifconfig.me

# Surveiller un fichier pour détecter les changements
watch -n 2 "ls -la uploads/"

# Compresser un répertoire
tar -czf archive.tar.gz ./directory/

# Extraire un tar.gz
tar -xzf archive.tar.gz

# Afficher les 10 fichiers les plus volumineux du répertoire courant
du -sh * | sort -rh | head -10

# Compter les lignes de code par type de fichier
find . -name "*.ts" | xargs wc -l | sort -rn | head -20

La ligne de commande récompense l'investissement. Chaque commande apprise devient un bloc de construction pour des combinaisons plus puissantes. Commencez par la navigation et grep, ajoutez ensuite les pipes, puis awk — et vous serez en mesure de gérer n'importe quelle tâche de traitement de texte qui se présentera.