25 commandes Linux puissantes que tout administrateur système doit connaître en 2026 (au-delà des bases)

Tout administrateur système Linux connaît les commandes ls, cd, grep et ps aux. Ce sont les bases. Mais les commandes qui vous sauvent la mise en production — celles qui vous permettent de diagnostiquer une fuite de mémoire en cas de forte charge, de tracer une connexion TCP mystérieuse, de trouver ce qui consomme vos inodes ou de récupérer une session après une déconnexion SSH — nécessitent du temps et de l'expérience pratique. Ce guide fait l'impasse sur les tutoriels et aborde directement les 25 commandes et pratiques que les administrateurs système expérimentés utilisent quotidiennement : analyse des processus, diagnostic réseau, gestion des disques et des fichiers, analyse des journaux et astuces pour optimiser votre productivité en ligne de commande. Tous les exemples sont contextualisés pour vous permettre de savoir quand et pourquoi utiliser chaque commande.

Section 1 : Analyse des processus et des performances

1. htop — Visualiseur de processus interactif

htop remplace top par une vue interactive avec code couleur. Appuyez sur F6 pour trier par colonne, F9 pour envoyer un signal et t pour afficher ou masquer l'arborescence des processus.

# Install if needed
sudo apt install htop   # Debian/Ubuntu
sudo dnf install htop   # RHEL/Fedora

# Launch with a specific user filter
htop -u nginx

# Show only processes from a specific PID tree
htop -p 1234

2. iotop — E/S disque en temps réel par processus

Lorsque vos disques sont utilisés à 100 % et que vous ne parvenez pas à identifier le processus responsable, iotop est la solution. Ce bloc affiche les taux de lecture/écriture en temps réel par processus, une information que ni top ni htop ne fournissent.

# Show only processes doing actual I/O (quieter output)
sudo iotop -o

# Accumulate I/O totals instead of instantaneous rates
sudo iotop -a

# Non-interactive mode — log to file every 2 seconds, 10 times
sudo iotop -bod 2 -n 10 > /tmp/iotop_log.txt

3. ss — Statistiques des sockets (remplace netstat)

netstat est obsolète sur les distributions Linux modernes. ss est plus rapide, plus détaillé et plus flexible.

# Show all listening TCP/UDP sockets with PID and process name
ss -tulpn

# Show established connections only
ss -tn state established

# Find all sockets belonging to a specific process
ss -tulpn | grep nginx

# Show socket memory usage
ss -tm

# Count connections per state
ss -tan | awk 'NR>1 {state[$1]++} END {for (s in state) print state[s], s}' | sort -rn

4. lsof — Lister les fichiers ouverts et les connexions réseau

lsof (Liste des fichiers ouverts) est un outil très polyvalent pour comprendre l'activité d'un processus. Sous Linux, tout est considéré comme un fichier : sockets, tubes et nœuds de périphériques inclus.

# See all files opened by a process (by name)
lsof -p $(pgrep nginx) | head -30

# Find which process is listening on port 443
lsof -i :443

# Find all network connections for a specific user
lsof -u www-data -i

# Find deleted files still held open (common cause of "disk full" after deletion)
lsof +L1

# Find what process has a file locked
lsof /var/log/syslog

5. strace — Traceur d'appels système

Lorsqu'une application se comporte mal et que les journaux ne vous disent rien, strace affiche chaque appel système qu'elle effectue — ouvertures de fichiers, connexions réseau, allocations de mémoire.

# Trace a running process by PID
sudo strace -p 1234 -e trace=network,file 2>&1 | head -50

# Trace a command from start — useful for startup failures
strace -e trace=open,openat,read /usr/bin/myapp 2>&1 | grep -E "open|ENOENT"

# Count system calls and show stats
strace -c -p 1234

# Follow child processes too
strace -f -p 1234 2>&1 | tail -20

Section 2 : Diagnostic du réseau

6. ss -tulpn — La phrase choc essentielle

# The single most useful network command on any Linux server
ss -tulpn

# Output example:
# Netid State  Recv-Q Send-Q  Local Address:Port   Peer Address:Port  Process
# tcp   LISTEN 0      128     0.0.0.0:22            0.0.0.0:*         users:(("sshd",pid=892))
# tcp   LISTEN 0      511     0.0.0.0:80            0.0.0.0:*         users:(("nginx",pid=1203))
# tcp   LISTEN 0      511     0.0.0.0:443           0.0.0.0:*         users:(("nginx",pid=1203))

7. tcpdump — Capture du trafic réseau

# Capture HTTP traffic on eth0, save to file for Wireshark
sudo tcpdump -i eth0 -w /tmp/capture.pcap port 80

# Live capture — show DNS queries
sudo tcpdump -i any -n port 53

# Capture traffic to/from a specific host
sudo tcpdump -i eth0 host 192.168.1.100

# Show full packet content (ASCII) for HTTP
sudo tcpdump -i eth0 -A port 80 | grep -E "GET|POST|Host:"

# Capture only SYN packets (connection attempts)
sudo tcpdump -i eth0 "tcp[tcpflags] & tcp-syn != 0"

8. nmap — Découverte de réseau et analyse de ports

# Quick scan of a subnet — discover live hosts
nmap -sn 192.168.1.0/24

# Scan common ports on a single host
nmap -F 192.168.1.50

# Detect OS and service versions
sudo nmap -sV -O 192.168.1.50

# Scan for a specific port across a range of IPs
nmap -p 22 192.168.1.1-254 --open

# Full TCP connect scan with output to file
nmap -sT -p 1-65535 192.168.1.50 -oN /tmp/scan_results.txt

9. mtr — Traceroute + Ping dans un seul outil

mtr combine traceroute et ping en un affichage en temps réel qui montre la perte de paquets et la latence à chaque saut — bien plus utile qu'un traceroute à usage unique.

# Interactive real-time view
mtr 8.8.8.8

# Non-interactive report mode — 100 packets per hop
mtr --report --report-cycles 100 8.8.8.8

# Use TCP instead of ICMP (bypasses some firewalls)
mtr --tcp --port 443 rootpilot.fr

# Output as JSON
mtr --json 8.8.8.8

Section 3 : Gestion des disques et des fichiers

10. ncdu — Analyseur interactif d'utilisation du disque

du -sh * convient pour une vérification rapide. ncdu vous offre une arborescence triée et navigable de votre système de fichiers ; explorez-la pour trouver précisément ce qui consomme votre espace disque.

# Analyze current directory interactively
ncdu .

# Analyze the whole filesystem (run as root)
sudo ncdu /

# Export results to JSON for scripting
ncdu / -o /tmp/disk_usage.json --exclude /proc --exclude /sys

# Read previously saved analysis
ncdu -f /tmp/disk_usage.json

11. Rechercher — Recherche avancée de fichiers

# Find files modified in the last 24 hours
find /var/log -mtime -1 -type f -name "*.log"

# Find and delete files older than 30 days (dry run first with -print)
find /tmp -mtime +30 -type f -print
find /tmp -mtime +30 -type f -delete

# Find files larger than 100MB
find / -size +100M -type f 2>/dev/null | sort -k 5 -rh

# Find world-writable files (security audit)
find / -perm -0002 -type f 2>/dev/null | grep -v proc | grep -v sys

# Find SUID/SGID binaries
find / -perm /4000 -o -perm /2000 2>/dev/null | grep -v proc

12. rsync — Synchronisation de fichiers efficace

# Sync a directory to a remote host (with progress)
rsync -avz --progress /var/www/html/ user@backup-server:/backups/html/

# Dry run first — see what would change without doing it
rsync -avzn /source/dir/ /dest/dir/

# Mirror (delete files not in source)
rsync -avz --delete /source/ /dest/

# Exclude patterns
rsync -avz --exclude="*.log" --exclude="cache/" /app/ backup:/app/

# Bandwidth-limited sync (useful for large transfers on slow links)
rsync -avz --bwlimit=10000 /large/data/ backup:/large/data/

13. lsblk — Lister les périphériques de stockage par blocs

# Show all block devices with filesystem type and mount points
lsblk -f

# Show disk sizes and partitions in a tree
lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,FSTYPE

# Find which disk a specific path is on
df -h /var/lib/mysql | awk 'NR==2{print $1}' | xargs lsblk -o NAME,SIZE,MODEL

Section 4 : Analyse des journaux

14. journalctl — Requêtes du journal Systemd

# Follow logs in real time (like tail -f for systemd)
journalctl -f

# Logs for a specific service
journalctl -u nginx -f

# Logs since last boot
journalctl -b

# Errors and above since yesterday
journalctl --since yesterday -p err

# Last 100 lines of kernel logs
journalctl -k -n 100

# Export logs to JSON for analysis
journalctl -u ssh --since "2026-01-01" -o json > /tmp/ssh_logs.json

# Show disk usage of the journal
journalctl --disk-usage

# Vacuum old logs (keep last 2GB or 1 month)
sudo journalctl --vacuum-size=2G
sudo journalctl --vacuum-time=1month

15. awk — Lignes de commande pour l'analyse des journaux

# Count HTTP status codes from nginx access log
awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | sort -rn

# Top 10 IP addresses by request count
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head 10

# Find slow requests (response time > 1 second) — requires custom log format
awk '$NF > 1.0 {print $1, $7, $NF}' /var/log/nginx/access.log | sort -k3 -rn | head 20

# Sum bandwidth per IP from Apache log
awk '{sum[$1] += $10} END {for (ip in sum) printf "%st%.2f MBn", ip, sum[ip]/1048576}' 
    /var/log/apache2/access.log | sort -t$'t' -k2 -rn | head 10

16. multitail — Surveillance de plusieurs fichiers journaux

# Watch nginx error and access logs side by side
multitail /var/log/nginx/error.log /var/log/nginx/access.log

# Merge two logs with color-coding
multitail -ci white /var/log/syslog -ci yellow /var/log/auth.log

# Filter content with grep-like patterns
multitail -e "ERROR" /var/log/app.log

Section 5 : Productivité terminale

17. tmux — Multiplexeur de terminal

Si vous n'utilisez pas tmux, vous perdez en productivité chaque jour. Ce module vous permet d'exécuter plusieurs sessions de terminal au sein d'une même connexion SSH et de les maintenir actives après la déconnexion.

# Start a named session
tmux new -s mysession

# Detach (keep running): Ctrl+B then D
# Reattach to session
tmux attach -t mysession

# List active sessions
tmux ls

# Split window horizontally: Ctrl+B then "
# Split window vertically: Ctrl+B then %
# Switch pane: Ctrl+B then arrow keys
# New window: Ctrl+B then C
# Switch window: Ctrl+B then N (next) or P (prev)

# Copy/paste mode: Ctrl+B then [
# Start selection with Space, copy with Enter

18. fzf — Recherche floue pour tout

# Install
sudo apt install fzf

# Fuzzy search command history (better than Ctrl+R)
history | fzf

# Fuzzy find a file and open it
vim $(find . -type f | fzf)

# Fuzzy kill a process
kill -9 $(ps aux | fzf | awk '{print $2}')

# SSH into a host from your known_hosts
ssh $(cat ~/.ssh/known_hosts | awk '{print $1}' | fzf)

19. Astuces historiques — Recherche et réutilisation

# Search history interactively
Ctrl+R  # then type to filter

# Run last command as sudo
sudo !!

# Run last command with a substitution
^old^new

# Show last 20 commands matching a pattern
history | grep "docker" | tail -20

# Clear a specific history entry (e.g., accidentally typed a password)
history -d 1234

# Run command without saving to history (prepend space)
 sensitive_command_here

Section 6 : Répliques percutantes

20. Observez l'actualisation d'une commande en temps réel

# Refresh disk usage every 2 seconds
watch -n 2 df -h

# Watch connections to port 80
watch -n 1 "ss -tn | grep ':80'"

# Monitor log line count growth
watch -n 5 "wc -l /var/log/nginx/access.log"

21. xargs — Opérations par lots

# Delete files found by find (safer than -delete for complex pipelines)
find /tmp -name "*.tmp" -mtime +7 | xargs rm -f

# Restart multiple services
echo "nginx php8.2-fpm redis" | xargs -n 1 systemctl restart

# Run 4 parallel downloads
cat urls.txt | xargs -P 4 -I{} curl -O {}

22. sed — Édition de fichiers sur place

# Replace a value in a config file in-place
sed -i 's/max_connections = 100/max_connections = 500/g' /etc/mysql/mysql.conf.d/mysqld.cnf

# Delete lines matching a pattern
sed -i '/^#/d' /etc/nginx/nginx.conf   # Remove comment lines

# Insert a line after a match
sed -i '/server_name/a     return 301 https://$host$request_uri;' /etc/nginx/sites-enabled/default

# Extract lines between two patterns
sed -n '/START/,/END/p' logfile.txt

23. awk pour les statistiques système

# CPU usage percentage (single sample)
top -bn1 | grep "Cpu(s)" | awk '{print 100 - $8"%"}'

# Memory usage
free -m | awk 'NR==2{printf "Memory: %s/%sMB (%.1f%%)n", $3,$2,$3*100/$2}'

# Disk usage above 80%
df -h | awk 'NR>1 && $5+0 > 80 {print $0}'

24. curl pour les tests et diagnostics d'API

# Test a web server with full timing breakdown
curl -s -o /dev/null -w "DNS: %{time_namelookup}s | Connect: %{time_connect}s | TTFB: %{time_starttransfer}s | Total: %{time_total}sn" 
    https://rootpilot.fr

# Follow redirects and show final URL
curl -sL -o /dev/null -w "%{url_effective}n" http://example.com

# Test an API endpoint with JSON
curl -X POST https://api.example.com/endpoint 
    -H "Content-Type: application/json" 
    -H "Authorization: Bearer YOUR_TOKEN" 
    -d '{"key":"value"}' | python3 -m json.tool

25. Substitution de processus Bash et exécution parallèle

# Diff output of two remote commands without temp files
diff <(ssh server1 "cat /etc/nginx/nginx.conf") <(ssh server2 "cat /etc/nginx/nginx.conf")

# Run commands in parallel with & and wait
for host in web1 web2 web3; do
    ssh $host "systemctl restart nginx" &
done
wait
echo "All servers restarted"

# Parallel ping sweep
for i in $(seq 1 254); do
    ping -c 1 -W 1 192.168.1.$i >/dev/null 2>&1 && echo "192.168.1.$i UP" &
done | sort

Conclusion

Ces 25 commandes et modèles constituent la boîte à outils qui distingue un administrateur système Linux efficace d'un simple connaisseur. Le véritable savoir-faire ne réside pas dans la mémorisation des options, mais dans la capacité à choisir l'outil le plus adapté à chaque situation : iotop en cas de forte sollicitation du disque, ss lorsqu'un service prétend qu'aucun port n'est utilisé alors qu'un autre est manifestement à l'écoute, journalctl -p err pour un tri rapide des incidents, et tmux pour éviter toute perte de données suite à une déconnexion SSH. Intégrez ces commandes à votre mémoire et commencez à les combiner. Les meilleures commandes d'administration système sont toujours des enchaînements de plusieurs de ces outils fonctionnant de concert.