Aide-mémoire des commandes Linux — plus de 200 commandes par tâche

-P

afficher le chemin physique, liens symboliques résolus

-L

afficher le chemin logique, liens symboliques conservés (par défaut)

pwd

pwd -P

-l

format long : permissions, propriétaire, taille, date

-a

inclure les fichiers cachés (commençant par un point)

-h

tailles lisibles (avec -l) : 4.0K, 12M

-t

trier par date de modification, les plus récents d’abord

-r

inverser le tri

-S

trier par taille, les plus gros d’abord

-d

lister le répertoire lui-même, pas son contenu

-1

un nom par ligne

-R

parcourir récursivement les sous-répertoires

ls -lah

ls -ltr

ls -lS | head

ls -ld */

macOS/BSD : Les options ci-dessus fonctionnent sous macOS. La couleur s’active avec -G (les macOS récents acceptent aussi --color).

-L N

descendre d’au plus N niveaux

-a

inclure les fichiers cachés

-d

répertoires uniquement

-I pattern

ignorer les noms correspondant au motif

tree -L 2 -I 'node_modules|.git'

Non installé par défaut sur la plupart des distributions : apt install tree / dnf install tree.

-p

créer les répertoires parents si besoin ; pas d’erreur s’il existe

-m mode

définir les permissions, ex. -m 700

-v

afficher chaque répertoire créé

mkdir -p project/src/components

mkdir -p app/{src,tests,docs}

-p

supprimer aussi les répertoires parents vides

rmdir old-folder

-c

ne pas créer le fichier s’il n’existe pas

-t stamp

définir une date précise

-r ref

copier les horodatages d’un autre fichier

touch notes.txt

touch -t 202601011200 file

macOS/BSD : touch -d de GNU accepte du texte libre comme -d '2 days ago' ; sous macOS, -d n’accepte que AAAA-MM-JJThh:mm:SS.

-r, -R

copier les répertoires récursivement

-a

archive : récursif, conserve permissions, dates et liens symboliques

-i

demander avant d’écraser

-n

ne jamais écraser un fichier existant

-u

copier seulement si la source est plus récente (GNU)

-v

afficher chaque fichier copié

cp report.pdf ~/backup/

cp -a site/ /srv/site-backup

cp -i *.conf /etc/myapp/

macOS/BSD : Le cp de macOS a -a, -R, -i, -n mais pas -u. Avec le cp BSD, une barre oblique finale sur la source (cp -R src/ dst) copie le contenu de src, pas src lui-même.

-i

demander avant d’écraser

-n

ne jamais écraser

-v

afficher chaque déplacement

-t dir

déplacer dans rép (GNU ; pratique avec xargs)

mv draft.txt final.txt

mv *.jpg photos/

mv -n new.conf /etc/app/app.conf

mv remplace sans prévenir un fichier de destination existant, sauf avec -i ou -n.

-i

demander avant chaque suppression

-I

demander une seule fois avant de supprimer plus de trois fichiers ou en mode récursif (GNU)

-r

supprimer les répertoires et leur contenu

-f

ignorer les fichiers absents, ne jamais demander

-v

afficher chaque fichier supprimé

rm old.log

rm -i *.bak

rm -- -weird-name.txt

La ligne de commande n’a ni corbeille ni annulation. Supprimé, c’est perdu.

rm -rf build/

rm -rf -- "${BUILD_DIR:?}/"

Attention : Aucune confirmation, aucune annulation. Une espace en trop (rm -rf / tmp) ou une variable vide (rm -rf "$DIR/"*) supprime bien plus que prévu. GNU rm refuse de supprimer / lui-même (--preserve-root est le comportement par défaut), mais rien ne protège /home ni /etc. Lancez d’abord ls sur le chemin exact.

-s

lien symbolique (sans cette option, vous obtenez un lien physique)

-f

remplacer un lien existant

-n

traiter un lien existant vers un répertoire comme un simple fichier (à utiliser avec -f)

ln -s /opt/app/bin/app /usr/local/bin/app

ln -sfn releases/v2 current

La cible d’abord, puis le nom du nouveau lien : le même ordre que cp.

realpath ../config.yml

readlink -f /usr/bin/python3

macOS/BSD : Les macOS actuels ont realpath et readlink -f ; les très anciennes versions n’avaient ni l’un ni l’autre.

-i

afficher le type MIME (Linux)

-b

bref : omettre le nom du fichier

file download.bin

file -i notes.txt

macOS/BSD : Sous macOS, l’option MIME est -I (majuscule) ; -i minuscule y a un autre sens.

-c FORMAT

sortie personnalisée GNU : %s taille, %y date de modification, %U propriétaire, %a permissions en octal, %n nom

stat file.txt

stat -c '%a %U %s %n' *

macOS/BSD : macOS utilise -f, pas -c, avec d’autres lettres : stat -f '%Lp %Su %z %N' file.

-d

créer un répertoire au lieu d’un fichier

tmp=$(mktemp -d) && trap 'rm -rf "$tmp"' EXIT

-n

numéroter toutes les lignes

-A

afficher les tabulations en ^I et les fins de ligne en $ (GNU) ; révèle les fins de ligne CRLF

cat /etc/os-release

cat part1.txt part2.txt > whole.txt

cat -A script.sh | head

macOS/BSD : Le cat de macOS n’a pas -A ; utilisez cat -vet pour le même affichage.

tac access.log | head

macOS/BSD : Absent de macOS ; utilisez tail -r fichier.

Space / b

page suivante / précédente

/text

rechercher vers l’avant ; n suivant, N précédent

g / G

aller au début / à la fin

F

suivre le fichier comme tail -f ; Ctrl+C pour arrêter

q

quitter

-N

afficher les numéros de ligne

-S

ne pas renvoyer les longues lignes à la ligne (défilement horizontal)

less /var/log/syslog

journalctl -u nginx | less -S

-n N

N premières lignes (10 par défaut)

-c N

N premiers octets

-n -N

tout sauf les N dernières lignes (GNU)

head -n 20 data.csv

head -c 512 file.bin | xxd

macOS/BSD : Le head de macOS n’accepte pas les nombres négatifs.

-n N

N dernières lignes (10 par défaut)

-n +N

commencer à la ligne N

-f

continuer d’afficher à mesure que le fichier grossit

-F

suivre par nom, résiste à la rotation des journaux

tail -n 50 app.log

tail -F /var/log/nginx/access.log

tail -n +2 data.csv

Ctrl+O

enregistrer

Ctrl+X

quitter

Ctrl+W

rechercher

Ctrl+K / Ctrl+U

couper la ligne / coller

Alt+U

annuler

sudo nano /etc/hosts

La barre de raccourcis en bas de l’écran indique les touches ; ^ signifie Ctrl et M- signifie Alt.

i

mode insertion (saisir du texte)

Esc

retour au mode normal

:w / :q / :wq

enregistrer / quitter / enregistrer et quitter

:q!

quitter sans enregistrer

/text

rechercher ; n pour le suivant

dd / yy / p

supprimer la ligne / copier la ligne / coller

u / Ctrl+R

annuler / rétablir

vim +42 app.py

-u

format unifié (celui de patch et git)

-r

comparer des répertoires récursivement

-q

indiquer seulement si les fichiers diffèrent

-w

ignorer tous les espaces

-y

côte à côte

diff -u old.conf new.conf

diff -rq dir1/ dir2/

diff <(sort a.txt) <(sort b.txt)

Comparer des textes côte à côte dans le navigateur →

-a

ajouter à la fin au lieu d’écraser

make 2>&1 | tee build.log

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf

printf '%s\n' "$var"

printf '%-12s %6.2f\n' disk 93.5

echo -e et echo -n se comportent différemment selon les shells ; printf se comporte partout de la même façon.

xxd image.png | head

hexdump -C file.bin | head

xxd fait partie des paquets de vim ; hexdump est dans util-linux (bsdextrautils sur les Debian/Ubuntu récents).

-n N

seulement les chaînes d’au moins N caractères (4 par défaut)

strings -n 8 firmware.bin | less

Fait partie de binutils sous Linux.

ls -l deploy.sh

Le premier caractère est le type (- fichier, d répertoire, l lien symbolique). Viennent ensuite trois triplets : propriétaire, groupe, tous les autres. r=4, w=2, x=1, donc rwxr-x--- vaut 750.

Convertir rwx en octal avec le calculateur chmod →

-R

appliquer à un répertoire et à tout son contenu

-v

signaler chaque modification

chmod 644 index.html

chmod 755 deploy.sh

chmod 600 ~/.ssh/id_ed25519

Calculer le mode octal avec le calculateur chmod →

chmod +x script.sh

chmod go-w file

chmod -R u=rwX,go=rX site/

Construire les modes symbolique et octal avec le calculateur chmod →

find site/ -type d -exec chmod 755 {} +

find site/ -type f -exec chmod 644 {} +

Attention : Donne à tous les utilisateurs et à tout service compromis de la machine un accès en écriture à toute l’arborescence, rend tous les fichiers exécutables et fait refuser à OpenSSH les clés situées dans un ~/.ssh en 777. Appliqué à /etc ou /usr, il peut casser sudo et le système. Corrigez plutôt la propriété avec chown, ou utilisez les deux commandes find.

Choisir le mode le moins permissif qui fonctionne →

-R

récursif

user:

avec deux-points final et sans groupe, définit aussi le groupe sur le groupe de connexion de l’utilisateur

sudo chown -R www-data:www-data /var/www/site

sudo chown "$USER": file.txt

Attention : sudo chown -R sur /, /usr ou /etc efface les bits setuid et les propriétés dont dépendent sudo, passwd et les services ; la récupération passe généralement par une réinstallation. Vérifiez bien le chemin.

umask

umask 077

Le masque retire des bits : les fichiers partent de 666 et les répertoires de 777, donc 022 donne 644 et 755.

-i

shell de connexion root

-u user

exécuter en tant que cet utilisateur au lieu de root

-l

lister ce que vous avez le droit d’exécuter

-k

oublier les identifiants en cache

sudo systemctl restart nginx

sudo !!

sudo -u postgres psql

-m

modifier (ajouter) une entrée

-x

supprimer une entrée

-b

supprimer toutes les entrées ACL

-R

récursif

-d

définir l’ACL par défaut héritée par les nouveaux fichiers

setfacl -m u:alice:rw report.xlsx

getfacl report.xlsx

setfacl -R -m g:devs:rwX /srv/app

Un + à la fin de la chaîne de permissions de ls -l indique que le fichier a une ACL.

sudo chattr +i /etc/resolv.conf

lsattr /etc/resolv.conf

Pris en charge sur ext4, XFS, Btrfs. Si « Operation not permitted » s’affiche même en root, vérifiez lsattr.

aux

tous les processus avec CPU, mémoire, utilisateur (style BSD)

-ef

tous les processus avec le PID parent (style System V)

-o

choisir les colonnes

--sort=-%mem

trier par mémoire, la plus élevée d’abord (procps)

ps aux | grep [n]ginx

ps aux --sort=-%mem | head

ps -o pid,ppid,etime,cmd -p 1234

macOS/BSD : Le ps de macOS n’a pas --sort ; utilisez ps aux -m (par mémoire) ou ps aux -r (par CPU).

P / M

trier par CPU / mémoire (top de Linux)

1

afficher chaque cœur du CPU

k

tuer un processus par son PID

q

quitter

-b -n 1

un instantané en mode batch, pour les scripts

top -b -n 1 | head -20

macOS/BSD : Le top de macOS est un autre programme : triez avec top -o cpu ou top -o mem.

F3 or /

rechercher

F4

filtrer

F6

choisir la colonne de tri

F9

envoyer un signal (kill)

t

vue en arbre

htop -u www-data

À installer avec apt install htop / dnf install htop.

-a

afficher la ligne de commande complète (procps sous Linux)

-f

chercher dans toute la ligne de commande, pas seulement le nom

-u user

uniquement les processus de cet utilisateur

-x

correspondance exacte du nom

pgrep -a nginx

pgrep -f 'python manage.py runserver'

macOS/BSD : Sous macOS, -a signifie « inclure les ancêtres » ; utilisez pgrep -lf pour voir les noms et les arguments.

pkill -f "node server.js"

pkill -HUP nginx

pgrep -af node

Les motifs sont des expressions régulières recherchées n’importe où dans le nom ; pkill node touche aussi nodejs-helper. Vérifiez d’abord avec pgrep.

(none) / -15 / -TERM

demander au processus de se terminer proprement (par défaut)

-9 / -KILL

arrêt forcé ; ne peut pas être intercepté, aucun nettoyage

-1 / -HUP

beaucoup de démons rechargent leur configuration

-l

lister les noms des signaux

kill 1234

kill -9 1234

kill %1

Essayez d’abord un simple kill et laissez quelques secondes : -9 saute le nettoyage, ce qui peut laisser des fichiers temporaires, des verrous et des données à moitié écrites.

killall firefox

Sous Linux, se trouve dans le paquet psmisc.

jobs

bg %1

fg %1

Ctrl+Z suspend le programme au premier plan (il s’arrête jusqu’à bg ou fg).

nohup ./server > server.log 2>&1 &

Pour tout ce qui doit durer, un service systemd (voir Services et journaux) ou tmux est plus robuste.

Ctrl+B d

se détacher (la session continue)

Ctrl+B c

nouvelle fenêtre

Ctrl+B % / Ctrl+B "

diviser gauche/droite / haut/bas

tmux ls

lister les sessions

tmux new -s deploy

tmux attach -t deploy

À installer avec votre gestionnaire de paquets. GNU screen est l’alternative plus ancienne (Ctrl+A d pour se détacher, screen -r pour se rattacher).

nice -n 19 tar -czf backup.tgz /data

sudo renice -n -5 -p 1234

La valeur nice va de -20 (priorité la plus haute) à 19 (la plus basse). Seul root peut descendre sous 0.

timeout 30s curl -s https://example.com/health

timeout -s KILL 5m ./job.sh

Se termine avec le code 124 si la limite de temps est atteinte.

sudo fuser -vm /mnt/usb

sudo fuser -v 8080/tcp

Attention : fuser -k tue sans confirmation tous les processus qui utilisent la cible ; sur un point de montage, cela peut inclure votre propre shell.

-a

tout

-r

version du noyau

-m

architecture de la machine : x86_64, aarch64

uname -r

uname -m

cat /etc/os-release

lsb_release -a

macOS/BSD : macOS : sw_vers.

uptime

La charge est le nombre de processus en cours d’exécution ou en attente. Comparez-la au nombre de CPU (nproc) : une charge de 4 sur 4 cœurs signifie une machine pleinement occupée.

free -h

macOS/BSD : macOS : vm_stat, ou top -l 1 | grep PhysMem.

Linux utilise la RAM libre comme cache disque : « free » paraît donc faible sur une machine en bonne santé. « available » correspond à ce que les programmes peuvent encore obtenir.

lscpu

make -j"$(nproc)"

macOS/BSD : macOS : sysctl -n hw.ncpu et sysctl -n machdep.cpu.brand_string.

-T

horodatages lisibles

-w

suivre les nouveaux messages

--level=err,warn

uniquement les problèmes

sudo dmesg -T | tail -30

sudo dmesg -T | grep -i 'out of memory'

vmstat 1 5

iostat -xz 1

iostat fait partie du paquet sysstat.

+%F

AAAA-MM-JJ

+%s

timestamp Unix (secondes)

-d 'text'

analyser une date : tomorrow, 2 days ago, @1700000000 (GNU)

-u

UTC

date '+%Y-%m-%d %H:%M:%S'

date +%s

date -d @1700000000

date -d '2 days ago' +%F

macOS/BSD : Le date de macOS n’a pas -d. Utilisez date -r 1700000000 pour un timestamp, date -v-2d pour « il y a 2 jours » et date -j -f '%Y-%m-%d' 2026-10-18 +%s pour analyser une date.

Convertir des timestamps avec le convertisseur de timestamp Unix →

-h

tailles lisibles

-T

afficher le type de système de fichiers (GNU)

-i

utilisation des inodes au lieu des octets

df -h

df -h .

df -i

macOS/BSD : Sous macOS, -T filtre par type au lieu de l’afficher.

-s

un total par argument

-h

tailles lisibles

-d N

limite de profondeur (forme longue GNU : --max-depth=N)

-x

rester sur un seul système de fichiers

du -sh /var/log

du -h -d 1 | sort -h

sudo du -xh -d 1 / | sort -h | tail

macOS/BSD : Le du de macOS a -d mais pas --max-depth.

sudo ncdu -x /

À installer avec apt install ncdu / dnf install ncdu.

-f

type de système de fichiers, étiquette, UUID, point de montage

lsblk

lsblk -f

macOS/BSD : macOS : diskutil list.

sudo umount /mnt/usb

sudo umount -l /mnt/nas

« target is busy » signifie qu’un processus l’utilise (souvent votre propre shell placé dans ce répertoire) : trouvez-le avec fuser -vm ou lsof.

UUID=3f6c...  /data  ext4  defaults,nofail  0  2

sudo mount -a

Une faute de frappe dans fstab peut faire démarrer la machine en mode d’urgence. Lancez toujours sudo mount -a (ou findmnt --verify) après modification.

sudo fdisk -l

sudo parted /dev/sdb print

Attention : Écrire une table de partitions (w dans fdisk, mklabel dans parted) rend inaccessibles les données existantes du disque. Vérifiez d’abord le nom du périphérique avec lsblk ; /dev/sda et /dev/sdb s’intervertissent facilement.

sudo mkfs.ext4 -L data /dev/sdb1

sudo mkfs.vfat -F 32 /dev/sdc1

Attention : Efface immédiatement le système de fichiers de la cible, sans confirmation si le périphérique n’est pas monté. Vérifiez le périphérique avec lsblk -f ; formater /dev/sda au lieu de /dev/sda1, ou le mauvais disque, le détruit.

sudo fsck -f /dev/sdb1

Attention : Ne lancez jamais fsck sur un système de fichiers monté en lecture-écriture : vous risquez de le corrompre. Démontez-le d’abord ou, pour le système de fichiers racine, démarrez sur un support de secours.

if= / of=

fichier ou périphérique d’entrée / de sortie

bs=4M

taille de bloc ; plus grand est plus rapide

status=progress

afficher les octets copiés (GNU)

conv=fsync

vider les tampons vers le périphérique avant de quitter

sudo dd if=ubuntu.iso of=/dev/sdX bs=4M status=progress conv=fsync

dd if=/dev/zero of=test.img bs=1M count=100

Attention : dd écrase la cible of= sans demander. Inverser if= et of=, ou choisir le mauvais /dev/sdX, efface ce disque. Vérifiez avec lsblk juste avant de lancer la commande.

macOS/BSD : macOS : ciblez /dev/rdiskN (d’après diskutil list) après diskutil unmountDisk, utilisez bs=4m et appuyez sur Ctrl+T pour voir la progression.

swapon --show

sudo fallocate -l 2G /swapfile && sudo chmod 600 /swapfile && sudo mkswap /swapfile && sudo swapon /swapfile

Sous Btrfs, un fichier d’échange demande des étapes supplémentaires (btrfs filesystem mkswapfile avec les btrfs-progs récents).

shred -u -n 3 secrets.txt

Attention : Irréversible. Notez aussi que ce n’est pas fiable sur les SSD, les systèmes de fichiers journalisés ou copy-on-write (Btrfs, ZFS) ni avec des instantanés ; pour une vraie protection, utilisez le chiffrement complet du disque.

ip -br a

ip a show eth0

hostname -I

macOS/BSD : macOS : ifconfig, ou ipconfig getifaddr en0.

ip remplace l’ancien ifconfig (net-tools), que beaucoup de distributions n’installent plus.

Calculer la plage réseau avec le calculateur de sous-réseau →

ip r

ip route get 1.1.1.1

sudo ip route add 10.20.0.0/16 via 192.168.1.1

Vérifier des plages CIDR avec le calculateur de sous-réseau →

ip link

sudo ip link set eth0 down && sudo ip link set eth0 up

Attention : Désactiver l’interface par laquelle vous êtes connecté en SSH coupe votre session.

-t / -u

TCP / UDP

-l

sockets en écoute uniquement

-p

afficher le processus (sudo pour voir ceux des autres utilisateurs)

-n

ports numériques, sans DNS

-s

totaux récapitulatifs

sudo ss -tulpn

ss -tn state established '( dport = :443 )'

ss -s

macOS/BSD : macOS : lsof -iTCP -sTCP:LISTEN -n -P, ou netstat -an.

ss remplace netstat ; netstat -tulpn fonctionne encore là où net-tools est installé.

-I

en-têtes uniquement (requête HEAD)

-L

suivre les redirections

-o file / -O

enregistrer dans un fichier / enregistrer sous le nom distant

-s / -S

silencieux / mais afficher quand même les erreurs

-f

échouer (code 22) sur un HTTP 4xx/5xx au lieu d’afficher la page d’erreur

-v

verbeux : en-têtes de requête et de réponse, TLS

curl -I https://example.com

curl -LO https://example.com/file.tar.gz

curl -s -o /dev/null -w '%{http_code}\n' https://example.com

curl -fsSL https://example.com/install.sh -o install.sh

Convertir une commande curl en Python, JavaScript ou Go →

-d data

corps de la requête ; implique POST

--data-binary @file

envoyer un fichier tel quel

-H header

ajouter un en-tête

-X METHOD

PUT, PATCH, DELETE…

-u user:pass

authentification basique

curl -H 'Content-Type: application/json' -d '{"name":"Ada"}' https://api.example.com/users

curl -H "Authorization: Bearer $TOKEN" https://api.example.com/me

curl -X DELETE https://api.example.com/users/42

Consulter la signification du code de statut reçu →

-c

reprendre un téléchargement partiel

-O file

enregistrer sous (-O- pour la sortie standard)

-q

silencieux

-r -np

récursif, sans jamais remonter au répertoire parent

wget -c https://example.com/big.iso

wget -qO- https://example.com/data.json | jq .

macOS/BSD : Absent de macOS par défaut ; utilisez curl -LO (curl -C - -LO pour reprendre).

dig +short example.com

dig MX example.com

dig @1.1.1.1 example.com

dig -x 8.8.8.8

dig +trace example.com

Nom du paquet : dnsutils (Debian/Ubuntu) ou bind-utils (Fedora/RHEL).

resolvectl status

sudo resolvectl flush-caches

macOS/BSD : macOS : sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder.

Uniquement sur les systèmes utilisant systemd-resolved (Ubuntu, Fedora par défaut).

-c N

s’arrêter après N paquets

-i sec

intervalle entre les paquets

-4 / -6

forcer IPv4 / IPv6

ping -c 4 example.com

Sous Linux et macOS, ping tourne jusqu’à Ctrl+C sauf avec -c (Windows s’arrête après 4). L’absence de réponse ne signifie pas toujours que l’hôte est hors ligne : beaucoup bloquent l’ICMP.

traceroute -n example.com

tracepath example.com

macOS/BSD : macOS a traceroute mais pas tracepath.

traceroute doit parfois être installé sous Linux ; tracepath (iputils) est généralement présent.

mtr -rw -c 100 example.com

Combine ping et traceroute. Une perte sur un seul saut intermédiaire vient généralement d’un routeur qui dépriorise l’ICMP ; une perte qui se prolonge jusqu’au bout est réelle.

-L 5432:localhost:5432

le port local 5432 atteint le port 5432 du serveur

-R 8080:localhost:3000

le port 8080 du serveur atteint votre port local 3000

-D 1080

proxy SOCKS sur le port local 1080

-N

pas de commande distante, juste le tunnel

ssh -N -L 5432:localhost:5432 alice@db-host

ssh -N -D 1080 alice@host

-r

copier des répertoires

-P port

port (P majuscule ; ssh utilise -p minuscule)

-i key

fichier d’identité

scp report.pdf alice@host:/tmp/

scp alice@host:/var/log/app.log .

scp -r -P 2222 site/ alice@host:~/

Depuis OpenSSH 9.0, scp utilise le protocole SFTP en arrière-plan. Pour les copies volumineuses ou répétées, rsync est plus rapide car il n’envoie que les modifications.

-a

archive : récursif, conserve permissions, dates, liens

-v

verbeux

-z

compresser pendant le transfert

-P

progression et reprise des fichiers partiels

-n

simulation : montrer ce qui se passerait

--exclude 'pattern'

ignorer des fichiers

-e 'ssh -p 2222'

options SSH personnalisées

rsync -avzP site/ deploy@host:/srv/site/

rsync -av --exclude 'node_modules' ./ /backup/app/

macOS/BSD : Les macOS récents fournissent openrsync au lieu de rsync ; les options courantes fonctionnent, certaines plus rares non.

src/ signifie « le contenu de src » ; src sans barre oblique signifie « le dossier src ». Une erreur ici imbrique les dossiers (dest/src/…).

rsync -avn --delete site/ /srv/site/

rsync -av --delete site/ /srv/site/

Attention : Supprime dans dest tout ce qui n’est pas dans la source. Inverser source et destination, ou un chemin source vide ou erroné, efface la destination. Lancez toujours d’abord avec -n.

nc -zv db.internal 5432

nc -l 9000

Les options diffèrent selon les variantes de netcat : la version traditionnelle exige nc -l -p 9000.

sudo ufw status verbose

sudo ufw allow 22/tcp

sudo ufw allow from 10.0.0.0/8 to any port 5432

Attention : sudo ufw enable sur un serveur distant sans avoir d’abord autorisé SSH (ufw allow OpenSSH ou 22/tcp) vous bloque l’accès.

sudo firewall-cmd --list-all

sudo firewall-cmd --permanent --add-service=https && sudo firewall-cmd --reload

sudo firewall-cmd --permanent --add-port=8080/tcp

Sans --permanent, une règle ne dure que jusqu’au prochain rechargement ou redémarrage.

-m

créer le répertoire personnel (pas par défaut sur toutes les distributions)

-s /bin/bash

shell de connexion

-G group1,group2

groupes supplémentaires

sudo useradd -m -s /bin/bash alice && sudo passwd alice

Sous Debian/Ubuntu, adduser alice est la surcouche interactive plus conviviale qui crée le répertoire personnel et le mot de passe.

sudo usermod -aG docker alice

sudo usermod -aG sudo alice

Attention : Sans -a, usermod -G remplace tous les groupes supplémentaires de l’utilisateur, ce qui peut lui retirer l’accès à sudo. Les changements de groupe prennent effet à la prochaine connexion (ou lancez newgrp docker).

sudo userdel -r olduser

Attention : -r supprime définitivement le répertoire personnel et ses fichiers. Sauvegardez-le d’abord, ou verrouillez plutôt le compte (passwd -l).

sudo visudo -f /etc/sudoers.d/deploy

deploy ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart myapp

visudo vérifie la syntaxe avant d’enregistrer. Modifier /etc/sudoers avec un éditeur ordinaire et faire une faute de frappe peut priver tout le monde de sudo.

-c

créer

-z / -j / -J

compression gzip / bzip2 / xz

-f file

nom du fichier d’archive (juste après f)

-v

lister les fichiers au fur et à mesure

--exclude='pattern'

exclure des fichiers

tar -czf site-2026-10-18.tar.gz site/

tar -cJf logs.tar.xz --exclude='*.tmp' logs/

-x

extraire

-C dir

extraire dans rép (qui doit exister)

--strip-components=1

supprimer le dossier de premier niveau

tar -xf archive.tar.gz

tar -xzf app.tar.gz -C /opt/app --strip-components=1

tar --zstd -cf data.tar.zst data/

zstd -d file.zst

Nécessite GNU tar 1.31+ (ou un bsdtar récent) et le programme zstd.

-k

conserver l’original

-d

décompresser (comme gunzip)

-9

compression maximale

gzip -k access.log

zcat access.log.gz | grep 404

zgrep 500 access.log.*.gz

Sans -k, gzip remplace le fichier par sa version .gz.

zip -r site.zip site/

zip -r site.zip site/ -x '*.git*' '*/node_modules/*'

zip -e chiffre avec l’ancien schéma ZipCrypto, qui est faible. Utilisez 7z ou gpg pour une vraie confidentialité.

7z x archive.7z

7z a -p backup.7z docs/

7z l archive.rar

Paquet : p7zip-full / 7zip sous Debian/Ubuntu, p7zip ou 7zip sous Fedora/Arch.

sha256sum ubuntu.iso

sha256sum -c SHA256SUMS --ignore-missing

macOS/BSD : macOS : shasum -a 256 fichier (et shasum -a 256 -c SUMSFILE).

Calculer le hash d’un texte ou d’un fichier dans le navigateur →

-name

motif glob sensible à la casse

-iname

insensible à la casse

-path

chercher dans le chemin complet

find . -name '*.log'

find / -iname 'nginx.conf' 2>/dev/null

-mtime -1

modifiés au cours des dernières 24 heures

-mtime +30

il y a plus de 30 jours

-mmin -60

au cours des 60 dernières minutes

-newer ref

plus récents que le fichier ref

find /var/log -type f -mtime +30

find . -type f -mmin -15

find /tmp/app -name '*.tmp' -mtime +7 -print

find /tmp/app -name '*.tmp' -mtime +7 -delete

Attention : L’ordre compte : -delete agit là où il apparaît, donc find . -delete -name "*.tmp" supprime tout sous . avant même que le test sur le nom ne soit appliqué. Placez -delete en dernier et lancez d’abord avec -print.

locate -i nginx.conf

sudo updatedb

Fourni par plocate ou mlocate ; l’index est reconstruit chaque jour, donc les fichiers créés aujourd’hui peuvent manquer tant que updatedb n’a pas tourné.

-i

ignorer la casse

-n

afficher les numéros de ligne

-v

inverser : lignes qui ne correspondent pas

-w

mots entiers uniquement

-c

compter les lignes correspondantes

-o

n’afficher que la partie correspondante

-F

chaîne fixe, sans regex

grep -n 'ERROR' app.log

grep -v '^#' nginx.conf | grep -v '^$'

grep -c 'Failed password' /var/log/auth.log

-r

récursif

-l

noms de fichiers uniquement

--include='*.py'

uniquement ces fichiers

--exclude-dir=node_modules

ignorer des dossiers

grep -rn 'TODO' src/

grep -rl --include='*.php' 'mysql_connect' .

grep -rn --exclude-dir={.git,node_modules} 'apiKey' .

grep -E 'error|warn' app.log

grep -Eo '[0-9]{1,3}(\.[0-9]{1,3}){3}' access.log | sort | uniq -c | sort -rn | head

grep -P '\d{4}-\d{2}-\d{2}' file

macOS/BSD : -E fonctionne partout ; -P (PCRE) est une fonctionnalité GNU qui n’est pas disponible dans toutes les versions de macOS.

Tester le motif dans le testeur de regex →

g

remplacer toutes les correspondances de la ligne, pas seulement la première

-E

regex étendue (groupes sans barres obliques inversées)

I

correspondance insensible à la casse (GNU)

sed 's/http:/https:/g' links.txt

sed 's|/usr/local|/opt|g' paths.txt

sed -E 's/([0-9]+)px/\1rem/g' style.css

sed -i 's/^#Port 22/Port 2222/' /etc/ssh/sshd_config

sed -i.bak 's/foo/bar/g' config.ini

macOS/BSD : Le sed de macOS exige un argument après -i : sed -i '' 's/foo/bar/g' file. GNU sed lit '' comme le script : la seule forme qui fonctionne sur les deux est -i.bak.

-F sep

séparateur de champs (par défaut : suites d’espaces/tabulations)

$1 … $NF

champs ; $NF est le dernier, $0 la ligne entière

NR

numéro de ligne

awk '{print $1}' access.log

awk -F: '{print $1, $7}' /etc/passwd

awk -F, 'NR>1 {print $2}' data.csv

cut -d, -f1,3 data.csv

cut -d: -f1 /etc/passwd

cut -c1-10 file

cut considère chaque délimiteur comme une séparation de champ : deux espaces donnent un champ vide. Pour une sortie alignée par des espaces, utilisez awk.

-n

numérique

-r

inverse

-h

tailles lisibles : 2K < 1M < 3G

-k 2,2

trier uniquement sur le champ 2

-t ,

séparateur de champs

-u

supprimer les doublons

-V

ordre des versions : 1.9 < 1.10

du -sh * | sort -h

sort -t, -k3,3nr data.csv

sort -u emails.txt > unique.txt

-c

préfixer chaque ligne par son nombre d’occurrences

-d

uniquement les lignes répétées

-u

uniquement les lignes uniques

sort ips.txt | uniq -c | sort -rn | head

uniq ne fusionne que les doublons adjacents : triez d’abord.

wc -l access.log

ls | wc -l

grep -c '' file

Compter les mots et les caractères dans le navigateur →

tr 'a-z' 'A-Z' < in.txt

tr -d '\r' < windows.txt > unix.txt

tr -s ' ' < file

tr '\n' ',' < list.txt

tr ne lit que l’entrée standard : redirigez le fichier avec <.

-0

entrée séparée par des NUL (à combiner avec find -print0) ; sans problème avec les espaces

-n N

au plus N arguments par commande

-P N

exécuter N commandes en parallèle

-I {}

remplacer {} par chaque ligne d’entrée

-r

ne pas exécuter la commande si l’entrée est vide (GNU)

find . -name '*.log' -print0 | xargs -0 rm -f

cat urls.txt | xargs -n 1 -P 4 curl -sO

ls *.png | xargs -I {} cp {} /backup/{}

macOS/BSD : GNU xargs exécute la commande une fois même si l’entrée est vide, sauf avec -r ; le xargs de macOS ignore par défaut une entrée vide et accepte -r pour la compatibilité.

.

affichage indenté

-r

chaînes brutes, sans guillemets

-c

compact, un résultat par ligne

.[]

parcourir un tableau

select(cond)

garder les éléments correspondants

jq . response.json

jq -r '.items[].name' data.json

jq -r '.[] | select(.active) | .email' users.json

curl -s https://api.github.com/repos/jqlang/jq | jq '.stargazers_count'

À installer avec apt/dnf install jq. Fourni avec les macOS récents.

Formater et valider du JSON dans le navigateur →

printf '%s' 'user:pass' | base64

echo dXNlcjpwYXNz | base64 -d

base64 -w 0 image.png > image.b64

macOS/BSD : Le base64 de macOS ne coupe pas les lignes par défaut et n’a pas -w. Utilisez -d pour décoder (les anciens macOS utilisaient -D).

Encoder ou décoder en Base64 dans le navigateur →

sudo systemctl restart nginx

sudo systemctl reload nginx

Testez la configuration avant de redémarrer quand c’est possible, ex. sudo nginx -t, pour qu’une faute de frappe ne mette pas le site hors ligne.

-u unit

un seul service

-f

suivre

-n N

N dernières lignes

--since '1 hour ago'

aussi : today, yesterday, 2026-10-18 09:00

-p err

priorité err et plus grave

-b / -b -1

démarrage actuel / démarrage précédent

-e

aller à la fin

journalctl -u nginx -f

journalctl -u myapp --since '10 min ago'

journalctl -b -1 -p err

journalctl --disk-usage

sudo journalctl --vacuum-size=500M

sudo journalctl --vacuum-time=14d

Pour une limite permanente, définissez SystemMaxUse= dans /etc/systemd/journald.conf.

sudo tail -f /var/log/syslog

sudo tail -f /var/log/auth.log

Certaines distributions (Fedora, Arch) ne conservent les journaux que dans le journal systemd, sauf si rsyslog est installé.

crontab -e

crontab -l

crontab -l > crontab.bak

Construire et comprendre le planning avec le générateur d’expressions cron →

30 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

*/15 * * * * /usr/local/bin/check.sh

0 9 * * 1-5 /usr/local/bin/report.sh

@reboot /usr/local/bin/startup.sh

Cron s’exécute avec un PATH minimal et sans profil de shell : utilisez des chemins absolus. Un % dans la commande doit être échappé en \%.

Vérifier la signification d’une expression cron →

crontab -l > ~/crontab.bak && crontab -r

crontab ~/crontab.bak

Attention : Supprime toutes vos tâches cron sans confirmation, et la touche r est juste à côté du e sur le clavier. Certaines implémentations de cron proposent -i pour demander d’abord (crontab -ri).

0 3 * * * root /usr/local/bin/cleanup.sh

ls /etc/cron.daily/

Sous Debian et Ubuntu, les fichiers de /etc/cron.d dont le nom contient un point sont ignorés : nommez-le backup, pas backup.cron.

echo 'systemctl restart myapp' | sudo at 02:00

echo './report.sh' | at now + 30 minutes

atq

atrm 3

Nécessite le paquet at et le service atd en cours d’exécution.

ls -l > listing.txt

echo 'done' >> progress.log

set -o noclobber

Le shell vide le fichier avant l’exécution de la commande : sort file > file vous laisse donc un fichier vide. Écrivez dans un nouveau nom, puis utilisez mv.

echo "Today is $(date +%A)"

echo $(( 1024 * 4 ))

diff <(ls dir1) <(ls dir2)

Les accents graves `commande` sont l’ancienne forme de $(commande) ; $( ) s’imbrique et se lit mieux.

ls *.jpg

rm photo-??.png

cp config.{yml,yml.bak}

shopt -s globstar; ls **/*.md

Les globs ne correspondent pas aux fichiers cachés par défaut (shopt -s dotglob change cela). Si rien ne correspond, bash transmet le motif tel quel, sauf si shopt -s nullglob est activé.

export NODE_ENV=production

DEBUG=1 ./app

printenv | sort

unset DEBUG

Perdues à la fermeture du shell. Placez les export dans ~/.bashrc (shells interactifs) ou ~/.profile (shells de connexion) pour les conserver.

sudo !!

cd !$

!42

^foo^bar

Avec HISTCONTROL=ignorespace (par défaut sous Ubuntu, via ignoreboth), une commande tapée avec une espace au début n’est pas enregistrée : pratique pour les commandes contenant des secrets.

Ctrl+R

rechercher en arrière dans l’historique ; appuyez de nouveau pour des correspondances plus anciennes

Ctrl+A / Ctrl+E

début / fin de ligne

Ctrl+U / Ctrl+K

couper jusqu’au début / jusqu’à la fin de la ligne

Ctrl+W

couper le mot précédent

Ctrl+Y

coller ce que vous avez coupé

Alt+B / Alt+F

reculer / avancer d’un mot

Alt+.

insérer le dernier argument de la commande précédente

Ctrl+L

effacer l’écran

Ctrl+C

annuler la commande en cours

Ctrl+D

fin de saisie ; quitte le shell sur une ligne vide

Tab Tab

afficher les complétions

bind -P | less

Aide-mémoire des raccourcis clavier Mac →

#!/usr/bin/env bash
set -euo pipefail
name="${1:-world}"
if [[ -f "$name.txt" ]]; then
  echo "found $name.txt"
fi
for f in *.log; do
  echo "$f"
done

chmod +x script.sh && ./script.sh Ada

bash -x script.sh

$1 … $9 sont les arguments, "$@" les contient tous, $# indique leur nombre. [[ ]] est propre à bash ; utilisez [ ] dans les scripts sh POSIX.

Boucles et conditions bash comparées à CMD et PowerShell →