Skip to content

Linux Aide-mémoire

Noyau de système d'exploitation de type Unix open source et distributions.

01

Démarrage

Commandes de fichiers de base

ls -la montre tous les fichiers, y compris les cachés. cd ~ va à la maison, cd - bascule vers le répertoire précédent. mkdir -p crée les répertoires parents au besoin. rm -r est nécessaire pour les répertoires non vides.

linux
# list files
ls -la          # long format, all files
ls -lh          # human-readable sizes
ls -lt          # sort by modification time

# current directory
pwd

# change directory
cd /home/user
cd ..           # go up one level
cd ~            # go home
cd -            # go to previous directory

# create/remove directories
mkdir newdir
mkdir -p path/to/dir   # create parents
rmdir emptydir
rm -r nonempty          # remove recursively

Obtenir de l'aide

man est le système de documentation principal. Sections : 1=commandes, 2=syscalls, 3=bibliothèque, 4=périphériques, 5=formats de fichiers, 8=administration. man -k (ou apropos) cherche dans les descriptions. --help donne un résumé concis. tldr fournit des exemples pratiques et s'installe séparément (npm install -g tldr).

linux
# manual pages
man ls                  # full documentation
man 5 crontab           # section 5 (file formats)
man -k password         # search by keyword (apropos)

# info pages (GNU tools, more detailed)
info coreutils
info ls

# quick help flags
command --help
ls --help
git --help

# tldr: community cheat sheets (install separately)
tldr tar
tldr find

# whatis: one-line description
whatis ls

# where is the binary / source / man page
whereis python3

Historique et raccourcis de commandes

!! répète la dernière commande (sudo !! est la classique correction du « sudo oublié »). !N lance la commande N de l'historique. !$ est le dernier argument. Ctrl+R est la recherche arrière interactive — appuyez à nouveau pour trouver des correspondances plus anciennes. L'historique se stocke dans ~/.bash_history ; HISTSIZE contrôle la taille en mémoire, HISTFILESIZE le fichier.

linux
# history expansion
history                 # show command history
!!                      # repeat last command
sudo !!                 # repeat last command as root
!42                     # run command #42 from history
!ls                     # run last command starting with ls
!$                      # last argument of last command
!!:gs/old/new/          # substitute in last command

# search history (interactive)
# Ctrl+R then type to search backward

# clear history
history -c              # clear current session
# edit ~/.bashrc HISTSIZE and HISTFILESIZE

# save and reload history
history -a              # append to history file
history -r              # reload from file

Types et identification de fichiers

file inspecte les magic bytes d'un fichier pour déterminer son vrai type — bien plus fiable que l'extension. ls -F ajoute des indicateurs de type (* exécutable, / répertoire, @ lien symbolique, = socket). stat montre les métadonnées complètes de l'inode y compris les trois horodatages : Access (atime), Modify (mtime, contenu), Change (ctime, métadonnées).

linux
# identify file type by content (not extension)
file document.pdf       # PDF document
file image.png          # PNG image data
file script.sh          # ASCII text executable
file /bin/ls            # ELF 64-bit LSB executable

# file with multiple files
file *.txt

# show MIME type
file --mime-type video.mp4   # video/mp4

# ls -F shows type indicator
ls -F
# file*       (executable)
# dir/        (directory)
# link@       (symlink)
# socket=     (socket)

# stat: detailed file info
stat file.txt
# Size, Blocks, IO Block, Device, Inode, Links,
# Access/Modify/Change/Birth times

Raccourcis de navigation du terminal

Ces raccourcis Readline fonctionnent dans bash et la plupart des shells. Ctrl+A/E sautent au début/fin de ligne. Ctrl+W/U/K suppriment du texte — Ctrl+Y le recolle (kill ring). Ctrl+R cherche dans l'historique. Ctrl+L efface l'écran. Ctrl+S gèle la sortie (cause fréquente de « terminal figé » — Ctrl+Q reprend). Apprenez-les pour accélérer nettement l'édition en ligne de commande.

linux
# cursor movement
Ctrl+A     # move to beginning of line
Ctrl+E     # move to end of line
Ctrl+B     # move back one char
Ctrl+F     # move forward one char

# editing
Ctrl+D     # delete char under cursor (or EOF/exit)
Ctrl+H     # delete char before cursor (backspace)
Ctrl+W     # delete word before cursor
Ctrl+U     # delete from cursor to beginning
Ctrl+K     # delete from cursor to end
Ctrl+Y     # paste (yank) deleted text back

# job control
Ctrl+C     # send SIGINT (interrupt)
Ctrl+Z     # suspend (send SIGTSTP)
Ctrl+D     # end of input / exit shell

# screen
Ctrl+L     # clear screen (same as clear)
Ctrl+S     # stop output (freeze)
Ctrl+Q     # resume output

# Alt shortcuts
Alt+B / Alt+F    # move back/forward by word
Alt+Backspace    # delete word backward

Variables d'environnement

Les variables d'environnement sont héritées par les processus enfants quand elles sont exportées. $PATH détermine où le shell cherche les commandes — les répertoires sont parcourus dans l'ordre, séparés par des deux-points. ~/.bashrc est sourcé pour les shells interactifs hors connexion ; ~/.profile ou ~/.bash_profile pour les shells de connexion. Sourcez toujours le fichier après édition pour appliquer les changements. Employez printenv VAR pour vérifier une variable sans expansion.

linux
# view all environment variables
env
printenv

# view specific variable
echo $HOME
echo $PATH
echo $USER

# set a variable (current shell only)
MYVAR="hello"
echo $MYVAR

# export to child processes
export PATH="$PATH:/opt/bin"
export EDITOR=nano

# set and export in one step
export MYVAR="hello"

# unset a variable
unset MYVAR

# common variables
# $HOME    user home directory
# $PATH    command search path
# $USER    current username
# $SHELL   current shell path
# $PWD     current working directory
# $OLDPWD  previous directory
# $PS1     prompt string

# persistent: add to ~/.bashrc or ~/.profile
echo 'export EDITOR=vim' >> ~/.bashrc
source ~/.bashrc
02

Opérations sur les fichiers

Copier des fichiers (cp)

cp copie les fichiers. -r (ou -R) est requise pour les répertoires. -i demande avant d'écraser (recommandé pour éviter les pertes de données). -p préserve les métadonnées ; -a est le mode archive (tout préserve, y compris les liens symboliques — idéal pour les sauvegardes). -u ne met à jour que si la source est plus récente. Employez toujours -i dans les scripts où l'écrasement est risqué.

linux
# copy a file
cp source.txt dest.txt

# copy to a directory
cp file.txt /backup/

# copy multiple files to a directory
cp file1.txt file2.txt /backup/

# copy directories recursively
cp -r src_dir/ dest_dir/

# interactive (prompt before overwrite)
cp -i file.txt /backup/

# preserve attributes (timestamps, permissions, ownership)
cp -p file.txt /backup/
cp -a src_dir/ dest_dir/    # archive mode (-rdp)

# only copy if source is newer
cp -u file.txt /backup/

# verbose (show what is being copied)
cp -v file.txt /backup/

# force overwrite
cp -f file.txt /backup/

Déplacer et renommer (mv)

mv sert à la fois à déplacer et renommer — il met à jour l'entrée de répertoire sans copier les données (instantané sur le même système de fichiers). -i demande avant d'écraser. mv -n empêche d'écraser les fichiers existants. La commande rename (basée Perl sur Debian/Ubuntu) emploie la regex pour le renommage en lot — bien plus puissant que des boucles mv. Note : la syntaxe de rename diffère entre distributions (version util-linux vs perl).

linux
# rename a file
mv oldname.txt newname.txt

# move file to another directory
mv file.txt /target/dir/

# move multiple files
mv file1.txt file2.txt /target/dir/

# interactive (prompt before overwrite)
mv -i file.txt /target/

# force overwrite
mv -f file.txt /target/

# no overwrite (don't replace existing)
mv -n file.txt /target/

# move only if newer
mv -u file.txt /target/

# verbose
mv -v olddir/ newdir/

# rename batch with rename command
rename 's/\.txt$/.md/' *.txt
rename .JPG .jpg *.JPG

Supprimer des fichiers (rm)

rm supprime définitivement les fichiers (pas de corbeille). -r est requise pour les répertoires. -rf est dangereuse — elle supprime récursivement sans demander ; vérifiez toujours deux fois le chemin. Ne lancez jamais rm -rf / ni rm -rf $VAR/ quand $VAR peut être vide. Envisagez trash-cli pour une suppression récupérable. find -delete est plus sûr pour la suppression par motif car on peut tester sans -delete d'abord.

linux
# remove a file
rm file.txt

# remove multiple files
rm file1.txt file2.txt

# interactive (prompt for each file)
rm -i file.txt

# force (ignore nonexistent, no prompt)
rm -f file.txt

# remove directory recursively
rm -r directory/
rm -rf directory/        # force + recursive (DANGEROUS)

# verbose
rm -v *.tmp

# remove files matching pattern
find . -name "*.bak" -delete
find . -name "*.log" -mtime +30 -delete

# safer alternative: trash-cli
trash-put file.txt
trash-list
trash-restore

Créer des fichiers (touch)

touch crée des fichiers vides ou met à jour les horodatages de fichiers existants. Sans options, il règle atime et mtime à l'heure courante. -t fixe un horodatage précis. -r copie l'horodatage d'un fichier de référence. Pour créer un fichier avec du contenu, employez la redirection (>) ou un here-document. touch sert couramment à créer des fichiers d'emplacement ou forcer make à reconstruire des cibles.

linux
# create an empty file
touch newfile.txt

# create multiple empty files
touch file1.txt file2.txt file3.txt

# update access and modification time to now
touch existing.txt

# set specific time (YYYYMMDDHHMM format)
touch -t 202401011200 file.txt       # Jan 1, 2024 12:00

# set only access time
touch -a file.txt

# set only modification time
touch -m file.txt

# use time from another file
touch -r reference.txt target.txt

# create file with content
echo "content" > file.txt
cat > file.txt << 'EOF'
line 1
line 2
EOF

Liens durs et symboliques (ln)

Les liens durs partagent le même inode (données) — en supprimer un n'efface pas les données tant que TOUS les liens existent. Ils ne peuvent traverser les systèmes de fichiers ni pointer vers des répertoires. Les liens symboliques sont des références de chemin — ils cassent si la cible bouge ou disparaît, mais peuvent traverser les systèmes de fichiers et pointer des répertoires. Employez ln -s pour les liens symboliques (le plus courant). readlink -f résout la chaîne complète jusqu'au vrai fichier.

linux
# hard link (same inode, same filesystem only)
ln original.txt hardlink.txt

# symbolic link (symlink, path reference)
ln -s /path/to/target symlink_name
ln -s original.txt softlink.txt

# force recreate a symlink
ln -sf /new/target symlink_name

# symbolic link to a directory
ln -s /var/log /home/user/logs

# view link target
readlink symlink
readlink -f symlink        # canonical absolute path
ls -l symlink              # show what it points to

# find broken symlinks
find . -type l ! -exec test -e {} \; -print

# count hard links to a file
ls -li file.txt            # 2nd column is link count

# remove a symlink
rm symlink_name
unlink symlink_name

Métadonnées de fichiers (stat, basename, dirname)

stat montre les métadonnées complètes de l'inode. basename et dirname décomposent les chemins — essentiels dans les scripts traitant des listes de fichiers. realpath résout les chemins relatifs et liens symboliques en chemins canoniques absolus. stat -c permet des formats de sortie personnalisés (%n=nom, %s=taille, %y=mtime, %a=permissions octales) — utile dans les scripts. Ces outils remplacent l'expansion de paramètres fragile pour la manipulation de chemins.

linux
# stat: full file information
stat file.txt
# Size: 1024  Blocks: 8  IO Block: 4096
# Device: 801h/2049d  Inode: 1234567
# Links: 1
# Access: (0644/-rw-r--r--)  Uid: 1000  Gid: 1000
# Access/Modify/Change: 2024-01-01 12:00:00

# custom format
stat -c '%n %s bytes' file.txt
stat -c '%y' file.txt            # modification time

# basename: extract filename from path
basename /var/log/syslog         # syslog
basename /var/log/syslog.log .log  # syslog

# dirname: extract directory from path
dirname /var/log/syslog          # /var/log

# realpath: resolve to absolute path
realpath ../file.txt
realpath -s symlink              # physical path (no symlink resolution)

# file size only
stat -c %s file.txt              # bytes
du -h file.txt | cut -f1         # human-readable
03

Opérations sur les répertoires

Créer des répertoires (mkdir)

mkdir -p crée les répertoires parents au besoin et ne se trompe pas si le répertoire existe déjà — essentiel pour des scripts idempotents. -m fixe directement les permissions (outrepasse umask). L'expansion d'accolades ({a,b,c}) combinée à mkdir -p crée des arbres complexes en une commande. C'est un pattern courant pour échafauder des structures de projet.

linux
# create a single directory
mkdir newdir

# create nested directories
mkdir -p path/to/deep/dir

# create multiple directories
mkdir dir1 dir2 dir3

# create with specific permissions
mkdir -m 755 publicdir
mkdir -m 700 privatedir

# verbose output
mkdir -v newdir

# create parent dirs with permissions
mkdir -p -m 755 /opt/myapp/{bin,lib,etc}

# create a directory tree at once
mkdir -p project/{src,tests,docs}
mkdir -p project/src/{main,utils}
mkdir -p project/{src/{main,utils},tests,docs}

Supprimer des répertoires (rmdir, rm)

rmdir ne retire que les répertoires vides — sûr mais limité. rm -r supprime récursivement les répertoires non vides. rm -rf est l'option nucléaire : vérifiez toujours le chemin d'abord. Le pattern find -empty -delete ne retire que les répertoires vides sans toucher aux remplis. Dans les scripts, vérifiez toujours que la variable est non vide avant rm -rf pour ne pas supprimer / par accident.

linux
# remove an empty directory
rmdir emptydir

# remove directory with contents
rm -r directory/

# force remove (no prompt)
rm -rf directory/

# remove empty directories recursively (find)
find . -type d -empty -delete
find . -type d -empty -exec rmdir {} \;

# remove directory with confirmation
rm -ri directory/

# safe removal pattern in scripts
DIR="/tmp/mydir"
if [ -n "$DIR" ] && [ -d "$DIR" ]; then
    rm -rf "$DIR"
fi

# move to trash instead
trash-put directory/

Listage de répertoires et arbre

ls -d */ ne liste que les répertoires. tree fournit une hiérarchie visuelle — -L limite la profondeur, -I exclut des motifs (incroyablement utile pour exclure node_modules/.git). Pour de grands arbres, combinez tree -d -L 2 pour un aperçu rapide. ls -1 (le chiffre un) liste un fichier par ligne — pratique pour piper vers wc -l pour compter.

linux
# list directory contents
ls -la                    # all files, long format
ls -lh                    # human-readable sizes
ls -lt                    # sort by time (newest first)
ls -lS                    # sort by size (largest first)
ls -lr                    # reverse order
ls -R                     # recursive listing
ls -d */                  # list only directories

# tree view (install separately: apt install tree)
tree                      # show directory tree
tree -L 2                 # limit depth to 2
tree -d                   # directories only
tree -a                   # include hidden files
tree -h                   # show file sizes
tree --dirsfirst          # dirs before files
tree -I 'node_modules|.git'  # ignore patterns
tree -H . -o tree.html    # output as HTML

# count files in directory
ls -1 | wc -l
find . -maxdepth 1 -type f | wc -l

Taille des répertoires (du)

du mesure l'usage disque. -s (summary) ne montre que le total, -h le rend lisible. du -sh */ donne les tailles des sous-répertoires immédiats. sort -rh trie par taille lisible en sens inverse (les plus gros d'abord). --exclude saute des motifs. La différence apparent-size/défaut : apparent montre la taille logique du fichier, le défaut les blocs disque réellement alloués (pouvant être plus grands à cause de la taille de bloc).

linux
# size of current directory (total)
du -sh .

# size of specific directories
du -sh /var/log /tmp /home

# size of all subdirectories
du -sh */

# sort directories by size (largest first)
du -sh * | sort -rh

# find the 10 largest directories
du -sh * | sort -rh | head -10

# include hidden files/dirs
du -sh .[!.]*

# maximum depth
du -h --max-depth=1
du -h -d 1                  # short form

# apparent size vs disk usage
du -sh --apparent-size file  # logical size
du -sh file                   # actual disk blocks

# exclude directories
du -sh --exclude='*.log' .
du -sh --exclude=node_modules .

Pile de répertoires (pushd, popd)

pushd/popd gèrent une pile de répertoires — pushd enregistre le répertoire courant et navigue vers un nouveau ; popd revient à l'enregistré. dirs montre la pile. Plus puissant que cd - (qui ne bascule qu'entre deux répertoires). Utile dans les scripts qui doivent naviguer entre plusieurs répertoires et revenir. La syntaxe +N tourne ou retire par position.

linux
# push directory onto stack and cd into it
pushd /var/log
# pushes current dir, then cd to /var/log

# push another
pushd /tmp
# stack: /tmp /var/log /home/user

# pop back to previous directory
popd
# returns to /var/log

# list the directory stack
dirs
dirs -v           # verbose (numbered)
dirs -c           # clear the stack

# navigate by index
pushd +2          # rotate to 3rd entry
popd +1           # remove 2nd entry

# practical: save current dir, work, return
pushd /etc
cp config.conf ~/backup/
popd              # back to where we were

# alternative: use cd - for simple toggle
cd /var/log
cd -              # back to previous directory
04

Visualisation de fichiers

cat et tac

cat déverse tout le fichier sur stdout — bien pour les petits fichiers mais employez less/head pour les gros. cat -n numérote les lignes. cat -A révèle les caractères cachés (tabulations, fins de ligne) — utile pour déboguer des problèmes de formatage. tac inverse l'ordre des lignes (cat à l'envers). cat sert aussi à concaténer des fichiers et rediriger l'entrée. Pour visualiser de gros fichiers de façon interactive, employez less.

linux
# display entire file
cat file.txt

# concatenate multiple files
cat file1.txt file2.txt > combined.txt

# display with line numbers
cat -n file.txt

# display with non-printing characters
cat -A file.txt           # show tabs as ^I, line ends as $
cat -v file.txt           # show non-printing chars
cat -e file.txt           # show line ends as $
cat -t file.txt           # show tabs as ^I

# append to a file
cat >> file.txt << 'EOF'
appended line
EOF

# tac: reverse line order
tac file.txt              # last line first

# create file from stdin
cat > newfile.txt
# type content, Ctrl+D to end

Paginateur less

less est le paginateur standard — bien meilleur que more car il permet la navigation arrière. Les touches ressemblent à vim (j/k/g/G). / cherche en avant, ? en arrière. F entre en « mode suivi » (comme tail -f) pour surveiller des logs. less gère automatiquement les fichiers compressés si lesspipe est configuré. Appuyez sur v pour ouvrir le fichier courant dans votre $EDITOR pour des retouches rapides.

linux
# view a file
less file.txt

# view command output
dmesg | less
ls -la /etc | less

# navigation inside less:
#   space / f     forward one page
#   b             backward one page
#   j / k         down / up one line
#   g             go to beginning
#   G             go to end
#   /pattern      search forward
#   ?pattern      search backward
#   n             next match
#   N             previous match
#   v             open in editor ($EDITOR)
#   F             follow mode (like tail -f)
#   q             quit

# useful flags
less -N file.txt          # show line numbers
less -S file.txt          # chop long lines
less -i file.txt          # case-insensitive search
less +/pattern file.txt   # open at first match

# view compressed files
less file.gz              # auto-decompresses (if lesspipe installed)

head et tail

head montre le début, tail la fin d'un fichier. tail -f est essentiel pour surveiller les logs en temps réel. tail -F (majuscule) gère la rotation des fichiers (quand les logs sont renommés/tronqués) en rouvrant le fichier. head -n -N montre tout sauf les N dernières lignes. Pour les gros fichiers, head/tail sont instantanés (ils ne lisent pas tout le fichier).

linux
# first 10 lines (default)
head file.txt
# last 10 lines (default)
tail file.txt

# first N lines
head -n 20 file.txt
head -20 file.txt

# last N lines
tail -n 20 file.txt
tail -20 file.txt

# all but last N lines
head -n -5 file.txt       # all except last 5 lines

# first N bytes
head -c 100 file.txt
tail -c 100 file.txt

# follow a log file (live updates)
tail -f /var/log/syslog

# follow with retry (handles log rotation)
tail -F /var/log/app.log

# show last 5 lines, then follow
tail -n 5 -f app.log

# multiple files
tail -n 5 file1.txt file2.txt

Voir des lignes précises

sed -n 'Np' imprime des numéros de lignes précis. awk avec NR (numéro d'enregistrement) est plus flexible pour plages et conditions. L'astuce (head; tail) montre les deux extrémités d'un gros fichier. nl et cat -n numérotent les lignes. hexdump/xxd affichent les fichiers binaires en hexa — essentiel pour inspecter des fichiers non texte, déboguer des formats ou récupérer des données.

linux
# show line N (e.g., line 10)
sed -n '10p' file.txt

# show lines M to N
sed -n '10,20p' file.txt
awk 'NR>=10 && NR<=20' file.txt

# show first and last N lines
(head -5; echo "..."; tail -5) < file.txt

# show lines matching pattern
sed -n '/pattern/p' file.txt
awk '/pattern/' file.txt

# show every Nth line
awk 'NR % 3 == 0' file.txt     # every 3rd line
sed -n '0~3p' file.txt          # every 3rd line (GNU)

# number lines
nl file.txt
cat -n file.txt
grep -n "" file.txt

# show file in hex
hexdump -C file.bin
xxd file.bin
od -A x -t x1z file.bin

Comptage de mots et lignes (wc)

wc (word count) rapporte les lignes (-l), mots (-w), octets (-c), caractères (-m, respecte l'encodage) et la longueur de la plus longue ligne (-L). Avec plusieurs fichiers, il montre les comptes par fichier et un total. Le pattern grep | wc -l compte les lignes correspondantes — mais grep -c est plus efficace (pas de pipe). Pour compter les fichiers, ls -1 | wc -l est rapide, mais find est plus exact pour les comptes récursifs.

linux
# count lines, words, and bytes
wc file.txt
#   10   50  300 file.txt
#  lines words bytes

# count lines only
wc -l file.txt

# count words only
wc -w file.txt

# count characters only
wc -m file.txt

# count bytes only
wc -c file.txt

# count the longest line length
wc -L file.txt

# count files in a directory
ls -1 | wc -l
find . -type f | wc -l

# count total lines in multiple files
wc -l *.py

# count matching lines (grep + wc)
grep "error" log.txt | wc -l

# count unique lines
sort file.txt | uniq | wc -l
07

Traitement de texte

sed — éditeur de flux

sed édite des flux de texte de façon non interactive. s substitue (g pour global) ; d supprime ; p imprime. -i édite en place (testez toujours sans -i d'abord, ou employez -i.bak pour une sauvegarde). Le délimiteur peut être n'importe quel caractère — employez | ou # pour les chemins afin d'éviter d'échapper les slashes. -E active la regex étendue avec une syntaxe de groupes de capture plus propre. sed traite ligne par ligne.

linux
# substitute (replace first occurrence per line)
sed 's/old/new/' file.txt

# substitute all occurrences (global)
sed 's/old/new/g' file.txt

# case-insensitive (GNU sed)
sed 's/old/new/gi' file.txt

# in-place editing
sed -i 's/old/new/g' file.txt
sed -i.bak 's/old/new/g' file.txt   # keep backup

# delete lines
sed '/^#/d' file.txt           # delete comment lines
sed '/^$/d' file.txt           # delete blank lines
sed '5d' file.txt              # delete line 5
sed '5,10d' file.txt           # delete lines 5-10

# print specific lines
sed -n '10,20p' file.txt       # lines 10-20
sed -n '/pattern/p' file.txt   # matching lines

# different delimiter for paths
sed 's|/usr/local|/opt|g' paths.txt

# extended regex with capture groups
sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/' dates.txt

# multiple commands
sed -e 's/a/A/g' -e 's/b/B/g' file.txt

awk — traitement de colonnes

awk est un mini-langage de programmation pour les données en colonnes. $1, $2... sont les champs ; $0 toute la ligne ; $NF le dernier champ. -F règle le séparateur d'entrée ; OFS la sortie. BEGIN tourne avant le traitement, END après. NR est le numéro d'enregistrement (ligne) ; NF le compte de champs. awk est idéal pour le traitement CSV/TSV, l'analyse de logs et les rapports — bien plus puissant que cut.

linux
# print columns (default separator: whitespace)
awk '{print $1}' file.txt           # first column
awk '{print $1, $3}' file.txt       # columns 1 and 3
awk '{print $NF}' file.txt          # last column
awk -F: '{print $1}' /etc/passwd    # split on :

# filter and print
awk '$3 > 100' file.txt             # col 3 > 100
awk '$1 == "ERROR" {print $2}' log  # col 2 of ERROR lines
awk 'NR == 5' file.txt              # 5th line only
awk 'NR >= 10 && NR <= 20' file.txt # lines 10-20

# BEGIN and END blocks (sum, average)
awk '{sum += $1} END {print sum}' nums.txt
awk '{sum += $2; count++} END {print sum/count}' data.txt

# field separator and output
awk -F, 'BEGIN {OFS="|"} {print $1, $2}' csv.txt

# count lines matching pattern
awk '/error/ {count++} END {print count}' log

# built-in variables: NR (row), NF (fields), FS, OFS
awk '{print NR, NF, $0}' file.txt

cut et paste

cut extrait des champs (-f avec -d délimiteur) ou des positions de caractères (-c). Rapide mais limité — pas de support des guillemets, les CSV avec virgules citées le cassent. paste fusionne des fichiers côte à côte. join combine des fichiers sur un champ trié commun (comme un JOIN SQL). expand/unexpand convertissent entre tabulations et espaces. Pour du CSV complexe, employez awk ou un outil dédié comme csvkit.

linux
# cut: extract fields by delimiter
cut -d: -f1 /etc/passwd            # field 1, delimiter :
cut -d, -f2,3 data.csv             # fields 2 and 3

# cut: extract character positions
cut -c1-5 file.txt                 # characters 1-5
cut -c1- file.txt                  # from char 1 to end

# cut: extract bytes (for multibyte)
cut -b1-10 file.txt

# paste: merge files line by line
paste file1.txt file2.txt          # tab-separated
paste -d',' file1.txt file2.txt    # comma-separated

# paste: serial (all lines of file1, then file2)
paste -s file1.txt                 # lines into one line
paste -s -d',' file1.txt file2.txt

# join: combine on a common field
join -t, -1 1 -2 1 file1.csv file2.csv

# expand/unexpand tabs
expand file.txt                    # tabs to spaces
unexpand -a file.txt               # spaces to tabs

sort et uniq

sort ordonne les lignes (-n numérique, -r inverse, -h lisible, -k champ, -t délimiteur). uniq ne retire que les doublons ADJACENTS — passez toujours par sort d'abord. uniq -c compte ; sort -rn donne le classement par fréquence. comm compare deux fichiers TRIÉS : -12 montre le commun, -23 seulement dans le premier, -13 seulement dans le second. Le pattern sort | uniq -c | sort -rn est le pipeline classique d'analyse de fréquence.

linux
# sort lines
sort file.txt                      # alphabetical
sort -n nums.txt                   # numeric
sort -rn nums.txt                  # reverse numeric
sort -h sizes.txt                  # human-readable (1K, 2M, 3G)
sort -R file.txt                   # random order
sort -u file.txt                   # sort + unique

# sort by field
sort -t: -k3 -n /etc/passwd        # by 3rd field, numeric
sort -t, -k2 data.csv              # by 2nd field

# sort by multiple keys
sort -k1,1 -k2n file.txt           # key1 alpha, key2 numeric

# uniq: filter adjacent duplicates
sort file.txt | uniq               # unique lines
sort file.txt | uniq -c            # count occurrences
sort file.txt | uniq -d            # only duplicates
sort file.txt | uniq -u            # only unique lines

# top 10 most frequent lines
sort file.txt | uniq -c | sort -rn | head -10

# compare two sorted files
comm -12 <(sort a.txt) <(sort b.txt)   # common lines
comm -23 <(sort a.txt) <(sort b.txt)   # only in a
comm -13 <(sort a.txt) <(sort b.txt)   # only in b

tr — traduire des caractères

tr traduit ou supprime des caractères (pas de regex — juste des ensembles de caractères). -d supprime, -s serre les répétitions, -c complète (inverse l'ensemble). Parfait pour la conversion de casse, l'échange de délimiteurs et le nettoyage de données. tr ',' '\n' convertit un CSV en une valeur par ligne. tr -cd '0-9' n'extrait que les chiffres. Note : tr travaille sur des caractères, pas des chaînes, il ne peut remplacer de motifs multi-caractères — employez sed pour cela.

linux
# translate characters
echo "Hello" | tr 'a-z' 'A-Z'       # HELLO (uppercase)
echo "Hello" | tr 'A-Z' 'a-z'       # hello (lowercase)

# swap characters
echo "abc" | tr 'abc' 'bca'         # bca

# delete characters
echo "hello" | tr -d 'l'            # heo
echo "Hello World" | tr -d ' '      # HelloWorld

# squeeze repeated characters
echo "aaabbbccc" | tr -s 'abc'      # abc
tr -s ' ' < file.txt                # squeeze repeated spaces

# complement (delete everything except)
echo "Hello123" | tr -cd '0-9'      # 123 (keep digits only)
echo "Hello123" | tr -cd 'A-Za-z'   # Hello

# convert delimiter
echo "a,b,c" | tr ',' '\n'          # a\nb\nc (one per line)
echo "a,b,c" | tr ',' '\t'          # tab-separated

# ROT13 cipher
echo "Hello" | tr 'A-Za-z' 'N-ZA-Mn-za-m'

# remove non-printable characters
tr -cd '\11\12\15\40-\176' < file.txt

tee et column

tee divise la sortie vers un fichier et stdout — essentiel pour logger dans les pipelines. sudo tee écrit dans des fichiers exigeant root sans faire tourner tout le pipeline en root. column -t aligne le texte en colonnes nettes (parfait pour afficher des CSV). -s précise le délimiteur d'entrée, -o le séparateur de sortie. fmt et fold reforment le texte — fmt joint les paragraphes, fold coupe en dur à une largeur.

linux
# tee: write to file AND stdout
echo "hello" | tee file.txt
echo "hello" | tee -a file.txt       # append

# tee to multiple files
echo "data" | tee f1.txt f2.txt f3.txt

# tee in a pipeline (log while transforming)
ls -la | tee output.txt | grep ".py"

# tee with sudo (write to privileged file)
echo "config" | sudo tee /etc/myapp.conf

# column: format as aligned columns
column -t file.txt
echo -e "a b c\n1 2 3" | column -t

# column with custom delimiter
column -t -s, data.csv
column -t -s: /etc/passwd

# column with specific separator for output
column -t -o " | " file.txt

# fmt: reformat paragraph width
fmt -w 60 file.txt

# fold: wrap lines at width
fold -w 80 file.txt
fold -w 80 -s file.txt   # break at spaces only
08

Permissions et propriété

Voir les permissions

Les permissions sont trois triplets : propriétaire, groupe, autres. Chaque position vaut r(4), w(2), x(1). Donc 755 = rwxr-xr-x, 644 = rw-r--r--. Pour les répertoires, x signifie « peut accéder » (y entrer avec cd), r « peut lister », w « peut créer/supprimer des fichiers ». stat -c '%a' montre les permissions octales. Le premier caractère de ls -l est le type de fichier (- fichier, d répertoire, l lien symbolique, b bloc, c caractère).

linux
# view file permissions
ls -l file.txt
# -rw-r--r-- 1 user group 1024 Jan 1 10:00 file.txt
#  ^^^ ^^^ ^^^
#  owner group others
#  rwx  r-x  r-x  = 755

# permission breakdown:
# - = regular file, d = directory, l = symlink
# r = read (4), w = write (2), x = execute (1)

# view all files in directory
ls -la

# view permissions recursively
ls -lR /var/www

# view in octal format
stat -c '%a %n' file.txt        # 644 file.txt
stat -c '%a %n' *

# check current umask
umask                           # e.g., 0022

# directory permissions:
# r = list contents
# w = create/delete files
# x = access (cd into) directory

chmod — mode numérique

Notation numérique (octale) : chaque chiffre représente propriétaire, groupe, autres. r=4, w=2, x=1 — on les somme. 755 (rwxr-xr-x) pour répertoires et exécutables ; 644 (rw-r--r--) pour fichiers ordinaires ; 600 (rw-------) pour fichiers privés. Pour les serveurs web, le standard est dirs=755, files=644. Le pattern récursif basé find applique des permissions différentes aux répertoires et fichiers — chmod -R ne sait pas le faire.

linux
# numeric (octal) notation
chmod 755 script.sh        # rwxr-xr-x
chmod 644 file.txt         # rw-r--r--
chmod 600 secrets.txt      # rw------- (private)
chmod 777 publicdir/       # rwxrwxrwx (DANGEROUS)
chmod 700 ~/.ssh           # rwx------ (for SSH)

# common patterns
chmod 755 directory/       # dirs: owner full, others read+execute
chmod 644 file.txt         # files: owner read+write, others read
chmod 600 config.env       # sensitive files: owner only
chmod 666 shared.txt       # everyone read+write (no execute)
chmod 444 readonly.txt     # everyone read only

# recursive
chmod -R 755 project/
chmod -R 644 *.txt          # won't work; use find

# recursive: dirs 755, files 644 (common web server setup)
find . -type d -exec chmod 755 {} \;
find . -type f -exec chmod 644 {} \;

# permission reference:
# 7=rwx 6=rw 5=rx 4=r 3=wx 2=w 1=x 0=none

chmod — mode symbolique

La notation symbolique se lit mieux pour les changements incrémentaux : u/g/o/a (qui), +/-/= (action), r/w/x/X (quoi). X (majuscule) met l'exécution seulement pour les répertoires ou les fichiers qui l'ont déjà — parfait pour un chmod récursif. --reference copie les permissions d'un autre fichier. Le sticky bit (+t) sur un répertoire signifie que seuls les propriétaires des fichiers peuvent les supprimer (employé sur /tmp).

linux
# symbolic notation
chmod u+x script.sh        # add execute for user
chmod g-w file.txt         # remove write for group
chmod o+r file.txt         # add read for others
chmod a+x script.sh        # add execute for all (a=all)

# combined changes
chmod u+x,g-w,o=r file.txt # user +x, group -w, others = read only
chmod ug+x file.txt        # add execute for user and group
chmod a=r file.txt         # set everyone to read only

# copy permissions from reference
chmod --reference=template.txt file.txt

# recursive
chmod -R u+rwX,go+rX .     # X = execute only for dirs/executables

# symbolic targets:
# u = user (owner)
# g = group
# o = others
# a = all (default)
# operators: + (add), - (remove), = (set exactly)
# permissions: r, w, x, X (execute if dir or already exec), s (SUID/SGID), t (sticky)

# set sticky bit on directory
chmod +t /tmp/shared
chmod 1777 /tmp/shared

chown et chgrp

chown change la propriété (exige root ou sudo). Format : owner:group — omettez le groupe pour ne changer que le propriétaire, omettez le propriétaire (avec les deux-points) pour ne changer que le groupe. -R récuse dans les répertoires. chgrp est un raccourci de chown :group. --from ne change que si le propriétaire courant correspond (conditionnel). Pour les serveurs web, chown -R www-data:www-data est le standard. Employez toujours -h avec les liens symboliques pour changer le lien, pas la cible.

linux
# change owner
chown alice file.txt
chown alice file1.txt file2.txt

# change owner and group
chown alice:developers file.txt
chown alice:developers project/

# recursive
chown -R alice:developers project/

# change group only
chgrp developers file.txt
chown :developers file.txt        # alternative

# verbose
chown -v alice file.txt

# reference (copy ownership from another file)
chown --reference=reference.txt file.txt

# change ownership only if currently owned by specific user
chown --from=bob alice file.txt

# symbolic links (by default, changes the link target)
chown -h alice symlink            # change the link itself

# common patterns
chown -R www-data:www-data /var/www
chown root:root /etc/sudoers

# view ownership
ls -l file.txt                    # shows owner and group
stat -c '%U:%G' file.txt          # just owner:group

umask

umask fixe les permissions par défaut des fichiers et répertoires nouvellement créés. C'est un masque — des bits sont retirés du défaut (666 pour les fichiers, 777 pour les répertoires). Valeurs courantes : 022 (standard, fichiers 644/répertoires 755), 077 (privé, fichiers 600/répertoires 700), 002 (partagé par groupe, fichiers 664/répertoires 775). Réglez-le dans ~/.bashrc ou /etc/profile pour la persistance. Note : umask ne peut AJOUTER de permissions, seulement en retirer.

linux
# view current umask
umask                  # e.g., 0022
umask -S               # symbolic: u=rwx,g=rx,o=rx

# set umask
umask 022              # new files: 644, dirs: 755
umask 077              # new files: 600, dirs: 700 (private)
umask 002              # new files: 664, dirs: 775 (group-writable)

# how umask works:
# default file perms: 666 (rw-rw-rw-)
# default dir perms:  777 (rwxrwxrwx)
# umask is SUBTRACTED (mask removed)
# umask 022: file = 666-022 = 644, dir = 777-022 = 755
# umask 077: file = 666-077 = 600, dir = 777-077 = 700

# set permanently: add to ~/.bashrc
echo 'umask 022' >> ~/.bashrc

# for security-sensitive environments
umask 077              # only owner can access new files

# for shared group work
umask 002              # group members can write new files

# umask does not affect execute bit on files
# (files are created without execute by default)

Permissions spéciales (SUID, SGID, Sticky)

SUID (4xxx) : le programme tourne avec les privilèges du propriétaire du fichier — passwd en a besoin pour modifier /etc/shadow en root. SGID (2xxx) : sur les exécutables, tourne avec les privilèges du groupe ; sur les répertoires, les nouveaux fichiers héritent du groupe du répertoire (utile pour les projets partagés). Sticky bit (1xxx) : sur les répertoires, seul le propriétaire du fichier (ou du répertoire/root) peut supprimer — employé sur /tmp. Auditez régulièrement les fichiers SUID/SGID car ce sont des vecteurs d'élévation de privilèges.

linux
# SUID (Set User ID): runs as file owner
chmod u+s /usr/bin/passwd       # 4755 -> rwsr-xr-x
chmod 4755 myprogram

# SGID (Set Group ID): runs as group owner
chmod g+s /shared/dir           # dirs: new files inherit group
chmod 2755 /shared/project

# Sticky bit: only file owner can delete
chmod +t /tmp                   # 1777 -> rwxrwxrwt
chmod 1777 /shared/upload

# view special permissions
ls -l /usr/bin/sudo
# -rwsr-xr-x  (s in user position = SUID)
ls -ld /tmp
# drwxrwxrwt  (t in others position = sticky)

# find SUID files (security audit)
find / -perm -4000 -type f 2>/dev/null

# find SGID files
find / -perm -2000 -type f 2>/dev/null

# find sticky directories
find / -perm -1000 -type d 2>/dev/null

# numeric special bits:
# 1 = sticky, 2 = SGID, 4 = SUID
# chmod 4755 = SUID + 755
# chmod 2755 = SGID + 755
# chmod 1777 = sticky + 777

# uppercase S/T means execute bit is NOT set (usually an error)
# rws = SUID + execute, rwS = SUID without execute
09

Utilisateurs et groupes

Gestion des utilisateurs

useradd crée des utilisateurs (bas niveau ; adduser est un enveloppeur plus sympathique sur Debian). -m crée le répertoire maison ; -s règle le shell ; -c le nom complet ; -G ajoute à des groupes supplémentaires. usermod -aG ajoute aux groupes sans retirer les existants (employez toujours -a avec -G). userdel -r retire le répertoire maison. passwd règle les mots de passe. /etc/passwd stocke les infos utilisateur ; /etc/shadow les hachages de mots de passe.

linux
# add a new user
sudo useradd -m -s /bin/bash alice
# -m: create home directory
# -s: specify login shell

# add user with full options
sudo useradd -m -s /bin/bash -c "Alice Smith" -G sudo,docker alice

# set password
sudo passwd alice

# delete a user
sudo userdel alice
sudo userdel -r alice         # remove home directory too

# modify user
sudo usermod -aG docker alice   # append to group (-a = append)
sudo usermod -s /bin/zsh alice  # change shell
sudo usermod -L alice           # lock account
sudo usermod -U alice           # unlock account
sudo usermod -l newname oldname # rename user

# view user info
id alice                      # uid, gid, groups
finger alice                  # detailed info (if installed)

# change login shell
chsh -s /bin/zsh

# list all users
cat /etc/passwd | cut -d: -f1
getent passwd | cut -d: -f1

Gestion des groupes

Les groupes organisent les utilisateurs pour un accès partagé. groupadd/groupdel/groupmod gèrent les groupes. usermod -aG (ajouter au groupe) est la façon standard d'ajouter un utilisateur — sans -a, on remplacerait TOUS ses groupes supplémentaires. gpasswd est un outil alternatif. /etc/group stocke les définitions de groupes. newgrp démarre un nouveau shell avec un groupe primaire différent (utile pour créer des fichiers devant appartenir au groupe).

linux
# create a group
sudo groupadd developers

# create group with specific GID
sudo groupadd -g 2000 developers

# delete a group
sudo groupdel developers

# modify group
sudo groupmod -n devs developers    # rename
sudo groupmod -g 2001 developers    # change GID

# add user to group
sudo usermod -aG docker alice       # append to group
sudo gpasswd -a alice developers    # alternative

# remove user from group
sudo gpasswd -d alice developers
sudo deluser alice developers       # Debian/Ubuntu

# list groups
cat /etc/group | cut -d: -f1
getent group

# view groups for a user
groups alice
id alice

# set group administrator
sudo gpasswd -A alice developers

# temporarily switch primary group
newgrp developers                  # new shell with group as primary

# view group members
getent group developers            # lists members
grep developers /etc/group

Gestion des mots de passe

passwd change les mots de passe. -l verrouille un compte (ajoute ! au hachage) ; -u déverrouille. -e force un changement de mot de passe à la prochaine connexion. chage gère les politiques de vieillissement : -M (jours max), -m (jours min), -W (jours d'avertissement), -E (date d'expiration). Les hachages se stockent dans /etc/shadow (lisible seulement par root), pas dans /etc/passwd. Une bonne politique exige des changements réguliers avec exigences de complexité.

linux
# change your own password
passwd

# change another user's password (requires root)
sudo passwd alice

# set password interactively
sudo passwd alice
# Enter new password: ******
# Retype new password: ******

# lock/unlock a password
sudo passwd -l alice          # lock (prepends !)
sudo passwd -u alice          # unlock

# force password change on next login
sudo passwd -e alice
sudo chage -d 0 alice

# set password aging policy
sudo chage -M 90 alice        # max 90 days
sudo chage -m 7 alice         # min 7 days between changes
sudo chage -W 7 alice         # warn 7 days before expiry
sudo chage -E 2025-12-31 alice # expire on date

# view password aging info
chage -l alice

# password quality: /etc/login.defs
# PASS_MAX_DAYS   90
# PASS_MIN_DAYS   7
# PASS_MIN_LEN    12
# PASS_WARN_AGE   7

# check password hash in /etc/shadow
sudo grep alice /etc/shadow

Commandes d'information utilisateur

whoami montre votre nom d'utilisateur courant ; id les uid/gid/groupes. who liste tous les utilisateurs connectés ; w ajoute ce qu'ils exécutent. last montre l'historique des connexions depuis /var/log/wtmp ; lastb les tentatives échouées depuis /var/log/btmp. getent passwd interroge la base d'utilisateurs (LDAP inclus si configuré). Ces commandes sont essentielles pour l'administration système et l'audit de l'activité utilisateur.

linux
# who am I
whoami                       # current username
id                           # uid, gid, groups
echo $USER                   # from environment

# who is logged in
who                          # all logged-in users
w                            # detailed (what they're doing)
users                        # just usernames

# last logins
last                         # recent logins
last -n 10                   # last 10 logins
last alice                   # alice's logins
last reboot                  # reboot history

# failed login attempts
lastb                       # bad login attempts (requires root)

# user account info
finger alice                 # detailed info (if installed)
getent passwd alice          # /etc/passwd entry

# group membership
groups                       # your groups
groups alice                 # alice's groups
id alice                     # uid, gid, all groups

# check if user exists
id alice && echo "exists" || echo "not found"
getent passwd alice

# list all users with home directories
getent passwd | awk -F: '{print $1, $6}'

su et sudo

su change d'utilisateur (exige le mot de passe de la cible) ; sudo exécute une commande en root (exige votre mot de passe). su - démarre un shell de connexion (charge le profil de l'utilisateur cible). sudo est préféré pour l'audit : les commandes sont journalisées dans /var/log/auth.log. visudo édite /etc/sudoers en sécurité (valide la syntaxe avant enregistrement). Les règles NOPASSWD sont commodes mais réduisent la sécurité. sudo !! répète la dernière commande en root — la classique correction du « sudo oublié ».

linux
# switch to root
su                           # needs root password
su -                         # login shell (loads root's profile)

# switch to another user
su - alice                   # login as alice
su alice                     # as alice, keep current env

# run a single command as root
sudo command
sudo apt update

# run a command as another user
sudo -u alice command
sudo -u www-data php script.php

# edit a file as root
sudo vim /etc/fstab
sudoedit /etc/fstab          # safer alternative

# sudo with environment
sudo -E command              # preserve environment variables

# list sudo privileges
sudo -l                      # what can I run?
sudo -l -U alice             # what can alice run?

# sudo configuration
sudo visudo                  # edit /etc/sudoers safely
# /etc/sudoers.d/ for individual rules
# alice ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx

# run previous command as root
sudo !!                      # classic fix for forgetting sudo

# sudo timeout: 5 min by default
sudo -v                      # extend timeout
sudo -k                      # kill timeout (require password next time)
10

Gestion des processus

ps — liste des processus

ps montre un instantané des processus. aux (BSD) et -ef (System V) sont les deux styles courants. Le pattern « ps aux | grep » est partout (employez l'astuce [n]ginx pour ne pas matcher grep). pstree montre les relations parent-enfant. --sort=-%mem trie par usage mémoire (trouve les gouffres de ressources). États clés : R=actif, S=endormi, D=sommeil ininterruptible, Z=zombie, T=arrêté. Pour la surveillance en temps réel, employez top ou htop.

linux
# list processes (BSD style)
ps aux                       # all processes, full format
ps aux | grep nginx          # find specific process

# list processes (System V style)
ps -ef                       # all processes
ps -ef | grep python

# list processes in a tree
ps auxf                      # forest/tree view
pstree                       # dedicated tree tool
pstree -p                    # with PIDs

# show specific user's processes
ps -u alice

# show process by PID
ps -p 1234
ps -p 1234 -o pid,ppid,cmd

# custom output format
ps -eo pid,ppid,user,%mem,%cpu,cmd --sort=-%mem | head

# show threads
ps -eLf | grep java          # show threads (LWP)

# ps output columns:
# PID    process ID
# PPID   parent process ID
# USER   owner
# %CPU   CPU usage
# %MEM   memory usage
# VSZ    virtual memory size (KB)
# RSS    resident set size (KB)
# STAT   process state (R=running, S=sleeping, Z=zombie)
# START  start time
# TIME   CPU time
# CMD    command

top et htop

top est le moniteur de processus temps réel intégré. Commandes clés : M (trier par mémoire), P (par CPU), k (tuer), q (quitter). Le mode -b (batch) sort du texte pour les scripts. htop est une alternative supérieure (coloré, défilable, souris, vue arbre) — installez avec apt install htop. glances donne un aperçu système complet. Pour trouver ce qui consomme, top/htop trié par %CPU ou %MEM est l'outil réflexe.

linux
# real-time process monitor
top

# top interactive commands:
#   P       sort by CPU usage
#   M       sort by memory usage
#   N       sort by PID
#   T       sort by running time
#   k       kill a process (enter PID)
#   r       renice (change priority)
#   1       show per-CPU stats
#   u       filter by user
#   H       show threads
#   c       toggle full command path
#   W       write settings to ~/.toprc
#   q       quit

# run top with specific sorting
top -o %MEM                  # sort by memory
top -o %CPU                  # sort by CPU

# batch mode (for scripts)
top -b -n 1                  # one snapshot
top -b -n 1 | head -20       # top 20 processes

# monitor specific user
top -u alice

# htop: better interactive viewer (install separately)
htop                         # colorized, mouse support
htop -p 1234                 # monitor specific PID

# glance: alternative system monitor
glances                      # needs installation

kill et killall

kill envoie des signaux par PID ; killall/pkill par nom. Essayez toujours SIGTERM (défaut) d'abord — il permet un nettoyage gracieux. SIGKILL (-9) est brutal et immédiat ; le processus ne peut l'attraper, il peut donc laisser des ressources en mauvais état. En dernier recours seulement. pkill -f matche la ligne de commande complète. kill -l liste tous les signaux. Le pattern « kill; sleep; kill -9 » donne au processus une chance de se nettoyer avant de forcer.

linux
# send signal to a process by PID
kill 12345                   # SIGTERM (graceful, default)
kill -15 12345               # SIGTERM explicitly
kill -9 12345                # SIGKILL (force, cannot be caught)
kill -HUP 12345              # SIGHUP (reload config)

# kill by name
killall nginx                # kill all nginx processes
pkill -f "python app.py"     # match full command line
pkill -u alice               # kill all of alice's processes

# common signals
kill -l                      # list all signals
# SIGTERM (15)  - graceful termination (default)
# SIGKILL (9)   - force kill (cannot be caught)
# SIGINT (2)    - interrupt (Ctrl+C)
# SIGHUP (1)    - hangup (often reload config)
# SIGSTOP (19)  - pause (cannot be caught)
# SIGCONT (18)  - resume
# SIGUSR1/USR2  - user-defined signals

# graceful then forceful
kill 12345; sleep 2; kill -9 12345 2>/dev/null

# kill background job
kill %1                      # kill job 1

# find and kill by port
fuser -k 8080/tcp            # kill process using port 8080
kill $(lsof -t -i:8080)      # alternative

Jobs en arrière-plan et contrôle

Ajouter & exécute en arrière-plan. jobs liste les jobs actifs ; fg/bg passent entre premier plan et arrière-plan. Ctrl+Z suspend le job de premier plan. wait bloque jusqu'à la fin des jobs d'arrière-plan. nohup et disown empêchent tous deux le processus de mourir à la fermeture du terminal — nohup pour les nouvelles commandes, disown pour celles déjà en cours. Pour du travail persistant, employez plutôt tmux ou screen.

linux
# run in background (append &)
sleep 100 &
# [1] 12345   (job 1, PID 12345)

# list jobs
jobs
jobs -l                      # with PIDs

# bring to foreground / send to background
fg                           # foreground the current job
fg %1                        # foreground job 1
bg %2                        # background job 2

# Ctrl+Z: suspend foreground job, then resume in background
# Ctrl+Z sends SIGTSTP
bg                           # resume in background

# wait for background jobs
wait                         # wait for all
wait $!                      # wait for last background job
wait 12345                   # wait for specific PID

# disown: detach from shell (survives logout)
long_task &
disown %1

# nohup: run immune to hangups (survives logout)
nohup ./script.sh > output.log 2>&1 &

# run at lower priority
nice -n 10 ./backup.sh &

# parallel execution
cmd1 & cmd2 & cmd3 &
wait                         # wait for all to finish

nice et renice — priorité des processus

Les valeurs de nice vont de -20 (priorité la plus haute) à 19 (la plus basse). Les utilisateurs ordinaires ne peuvent qu'abaisser la priorité (valeurs positives) ; root peut l'élever (négatives). Le défaut est 0. nice démarre un processus avec une priorité ; renice change un processus en cours. Pour les tâches intensives en E/S, ionice contrôle la priorité disque (classes : 1=realtime, 2=best-effort, 3=idle). cpulimit étrangle l'usage CPU — utile pour des tâches d'arrière-plan qui ne doivent pas gêner.

linux
# nice: start a process with adjusted priority
nice ./script.sh             # default: +10 (lower priority)
nice -n 10 ./backup.sh       # priority 10 (lower)
nice -n -5 ./critical.sh     # higher priority (needs root)

# renice: change priority of running process
renice 5 -p 12345            # PID 12345 to priority 5
renice 10 -u alice           # all of alice's processes
renice -5 -p 12345           # higher priority (needs root)

# view priorities
ps -l                        # NI column shows nice value
top                          # NI column

# nice values:
#  -20  highest priority (most favorable)
#    0  default
#   19  lowest priority (least favorable)
# only root can set negative (higher) priority

# practical: run CPU-intensive task at low priority
nice -n 19 make -j4 &

# ionice: I/O priority
ionice -c 3 ./backup.sh      # idle I/O priority
ionice -c 2 -n 7 ./backup.sh # best-effort, low

# cpulimit: limit CPU usage (install separately)
cpulimit -p 12345 -l 50      # limit to 50% CPU

Système de fichiers /proc

/proc est un système de fichiers virtuel (sans stockage disque) qui expose les informations du noyau et des processus. /proc/PID/ contient les données par processus. /proc/cpuinfo, /proc/meminfo montrent le matériel. /proc/sys/ contient les paramètres de noyau ajustables (équivalent sysctl). Écrire dans /proc/sys/ change immédiatement les réglages du noyau (employez sysctl pour la persistance). /proc/mounts montre les systèmes de fichiers montés. C'est l'interface principale entre l'espace utilisateur et le noyau.

linux
# /proc: virtual filesystem with kernel/process info
# process info by PID
cat /proc/1234/status        # process status
cat /proc/1234/cmdline       # command line (null-separated)
ls -l /proc/1234/fd/         # open file descriptors
cat /proc/1234/environ       # environment variables (null-separated)

# system info
cat /proc/cpuinfo            # CPU information
cat /proc/meminfo            # memory information
cat /proc/version            # kernel version
cat /proc/uptime             # uptime in seconds
cat /proc/loadavg            # load average

# network info
cat /proc/net/tcp            # TCP connections
cat /proc/net/dev            # network interface stats

# kernel settings
ls /proc/sys/                # sysctl parameters
cat /proc/sys/net/ipv4/ip_forward
echo 1 > /proc/sys/net/ipv4/ip_forward  # enable IP forwarding

# mount info
cat /proc/mounts             # mounted filesystems
cat /proc/filesystems        # supported filesystem types

# view process memory maps
cat /proc/1234/maps          # memory mappings
pmap 1234                    # formatted version
11

Informations système

uname et hostname

uname montre les infos du noyau (-a pour tout). hostname montre/fixe le nom du système — hostnamectl set-hostname le rend persistant. /etc/os-release est la façon standard d'identifier la distribution (fonctionne sur tout Linux moderne). lscpu donne des infos détaillées d'architecture CPU. dmidecode lit les données BIOS/SMBIOS. Ces commandes sont le premier pas de toute tâche d'administration pour comprendre sur quoi on travaille.

linux
# kernel and system info
uname                        # kernel name: Linux
uname -a                     # all info
uname -r                     # kernel release: 5.15.0-91-generic
uname -m                     # machine hardware: x86_64
uname -n                     # network node (hostname)
uname -p                     # processor type
uname -o                     # operating system: GNU/Linux

# hostname
hostname                     # current hostname
hostname -f                  # fully qualified domain name
hostname -I                  # all IP addresses

# set hostname (persistent)
sudo hostnamectl set-hostname myserver

# distribution info
cat /etc/os-release          # distro name and version
lsb_release -a               # Ubuntu/Debian specific
cat /etc/debian_version      # Debian version

# kernel version
cat /proc/version
dmesg | grep "Linux version"

# system architecture
arch                         # e.g., x86_64
dpkg --print-architecture    # Debian/Ubuntu

# BIOS/hardware info
sudo dmidecode -t system     # system info
sudo dmidecode -t bios       # BIOS info
lshw                         # hardware list
lscpu                        # CPU details

df — espace disque libre

df rapporte l'espace disque des systèmes de fichiers. -h (lisible) est essentielle. -T montre le type de système de fichiers (ext4, xfs, btrfs, tmpfs, nfs). -i montre l'usage des inodes — on peut manquer d'inodes avant de manquer d'espace (courant avec beaucoup de petits fichiers). -x exclut des types (utile pour filtrer les systèmes virtuels comme tmpfs). Quand le disque est plein, vérifiez d'abord df -h, puis employez du pour trouver les répertoires gourmands.

linux
# show disk space for all filesystems
df                           # all mounted filesystems
df -h                        # human-readable (K, M, G)
df -H                        # SI units (KB, MB, GB)

# specific filesystem
df -h /home                  # space for /home
df -h /dev/sda1              # specific device

# filesystem type
df -T                        # show type (ext4, xfs, tmpfs, etc.)
df -Th                       # human-readable + type

# exclude specific types
df -x tmpfs -x devtmpfs      # exclude virtual filesystems

# inodes (file count limit)
df -i                        # inode usage
df -ih                       # human-readable inode usage

# local filesystems only
df -l

# show total
df -h --total

# find the filesystem using the most space
df -h | sort -rh -k5 | head

# real-time: watch disk space
watch -n 5 df -h

du — usage disque

du mesure l'usage disque. -s (summary) ne montre que les totaux ; -h est lisible. du -sh * donne les tailles des sous-répertoires immédiats. sort -rh trie par valeurs lisibles. --apparent-size montre la taille logique du fichier vs les blocs disque réels. --exclude saute des motifs. Pour trouver ce qui consomme l'espace, le workflow : df -h (quel système est plein) → du -sh * (quel répertoire) → find (quels fichiers).

linux
# size of current directory
du -sh .

# size of specific directories
du -sh /var/log /tmp /home

# size of all immediate subdirectories
du -sh */
du -sh * | sort -rh          # sorted largest first

# top 10 largest directories
du -sh * | sort -rh | head -10

# maximum depth
du -h -d 1                   # depth 1 only
du -h --max-depth=2

# include hidden files
du -sh .[!.]*

# apparent size (logical, not disk blocks)
du -sh --apparent-size file

# exclude patterns
du -sh --exclude='*.log' .
du -sh --exclude=node_modules .

# total of multiple directories
du -sh /var/log /var/lib /tmp | tail -1

# find largest files (not just directories)
find / -type f -exec ls -lhS {} + 2>/dev/null | head -10
find . -type f -printf '%s %p\n' | sort -rn | head -10

# sort all subdirectories by size
du -sh ./*/* | sort -rh | head -20

free — usage mémoire

free montre l'usage mémoire. La colonne 'available' est la plus significative — elle estime la mémoire disponible pour démarrer de nouvelles applications sans swap. Linux emploie volontairement la RAM libre comme cache (buff/cache) pour accélérer les lectures disque ; c'est récupéré à la demande, donc un 'free' bas est normal. L'usage du swap doit être surveillé — un swap élevé avec échanges actifs (si/so dans vmstat) indique une pression mémoire.

linux
# show memory usage
free                         # in KB
free -h                      # human-readable
free -m                      # in MB
free -g                      # in GB

# continuous update
free -h -s 1                 # update every 1 second
watch -n 1 free -h           # alternative

# output:
#               total   used   free   shared  buff/cache  available
# Mem:           16G     4G     2G     0.5G       10G          11G
# Swap:          8G      0G     8G

# detailed memory info
cat /proc/meminfo

# key fields:
# total       total RAM
# used        used by applications
# free        completely free
# buff/cache  kernel buffers and page cache
# available   estimate of memory available for new apps

# IMPORTANT: Linux uses free RAM for cache
# 'available' is more meaningful than 'free'
# Cache is reclaimed on demand, so don't panic if 'free' is low

# swap info
swapon --show                # show swap devices
cat /proc/swaps

# clear cache (requires root, use with caution)
sudo sysctl vm.drop_caches=3   # free pagecache, dentries, inodes

# process memory usage
ps aux --sort=-%mem | head -10  # top memory consumers

uptime et charge système

uptime montre depuis combien de temps le système tourne et la charge moyenne (moyennes 1/5/15 minutes). La charge moyenne représente le nombre moyen de processus attendant le CPU — elle devrait rester sous le nombre de cœurs CPU. vmstat montre CPU, mémoire et E/S en temps réel — la colonne 'r' (processus prêts) et 'si/so' (swap entrant/sortant) sont les indicateurs clés. iostat et sar (du paquet sysstat) fournissent des données E/S détaillées et historiques.

linux
# system uptime and load average
uptime
# 10:30:00 up 5 days,  3:21,  2 users,  load average: 0.50, 0.35, 0.25

# load average: 1min, 5min, 15min
#   = average number of processes waiting for CPU
#   rule of thumb: should be < number of CPU cores

# check CPU count
nproc                         # number of CPU cores
lscpu | grep "^CPU(s):"

# detailed load and context switches
cat /proc/loadavg
# 0.50 0.35 0.25 2/500 12345

# vmstat: system stats over time
vmstat 1 5                    # every 1 second, 5 times
# procs --memory-- ---swap-- -----io---- -system-- ------cpu-----
# r  b   swpd   free   buff  cache  si  so    bi    bo   in   cs us sy id wa

# iostat: I/O statistics (needs sysstat package)
iostat 1                      # every 1 second
iostat -x 1                   # extended stats

# mpstat: per-CPU statistics
mpstat -P ALL 1

# sar: historical system activity
sar -u                        # CPU usage history
sar -r                        # memory usage history

# who is logged in
who
w                             # with what they're doing
12

Réseau

ping et traceroute

ping teste l'accessibilité et mesure la latence par ICMP echo. -c limite le compte (sinon il tourne sans fin). traceroute montre chaque saut jusqu'à la destination — utile pour diagnostiquer où la connectivité échoue. mtr combine traceroute et ping continu (excellent pour les problèmes intermittents). dig interroge les enregistrements DNS (plus détaillé que nslookup). nc (netcat) -z teste si un port TCP est ouvert sans envoyer de données.

linux
# test connectivity
ping google.com
ping -c 4 google.com         # 4 packets then stop
ping -i 0.5 google.com       # 0.5s interval
ping -W 2 google.com         # 2s timeout per packet

# ping with timestamp
ping -D google.com           # unix timestamps

# check if host is reachable
ping -c 1 -W 1 host && echo "up" || echo "down"

# trace network path
traceroute google.com
traceroute -n google.com     # no DNS resolution (faster)
mtr google.com               # traceroute + ping (continuous)

# trace with TCP (bypasses ICMP blocking)
tcptraceroute google.com 443

# DNS lookup
dig example.com
dig +short example.com       # just the IP
dig MX example.com           # mail records
dig NS example.com           # name servers
dig @8.8.8.8 example.com     # specific DNS server

# alternative DNS tools
nslookup example.com
host example.com
host -t MX example.com

# check open ports
nc -zv google.com 443        # check if port 443 is open
nc -zv google.com 80 443 22  # check multiple ports

netstat et ss

ss est le remplaçant moderne de netstat — plus rapide et détaillé. -tlnp montre les ports TCP en écoute avec noms de processus (root requis pour -p). Pour trouver ce qui emploie un port : ss -tlnp | grep :PORT ou lsof -i :PORT. ip remplace ifconfig/route (du paquet iproute2). Point clé : -n évite la résolution DNS (bien plus rapide). Vérifiez 'state established' pour les connexions actives. netstat est déprécié mais encore très répandu.

linux
# ss: modern socket statistics (replaces netstat)
ss -tlnp                     # listening TCP ports + process
ss -tunap                    # all TCP/UDP connections
ss -s                        # socket summary

# netstat: classic network statistics
netstat -tlnp                # listening TCP ports
netstat -tunap               # all connections
netstat -rn                  # routing table
netstat -i                   # interface statistics

# common ss/netstat flags:
# -t  TCP
# -u  UDP
# -l  listening sockets only
# -n  numeric (no DNS resolution, faster)
# -a  all sockets
# -p  show process using socket (needs root)
# -r  routing table

# find what's listening on a port
ss -tlnp | grep :80
lsof -i :8080                # alternative

# check established connections
ss -tn state established

# show all connections to a specific host
ss -tn dst google.com

# view network interfaces
ip addr                      # modern
ip a                         # short form
ifconfig                     # legacy

# view routing table
ip route                     # modern
route -n                     # legacy

# view interface statistics
ip -s link
ifconfig eth0

curl — client HTTP

curl est le client HTTP essentiel en ligne de commande. -X règle la méthode ; -d envoie des données POST ; -H règle les en-têtes ; -L suit les redirections ; -O enregistre avec le nom distant ; -s est silencieux (pour les scripts) ; -w '%{http_code}' extrait le seul code de statut. Pour les API JSON, combinez -H 'Content-Type: application/json' avec -d. -u fournit l'auth basique. Pour tester les API REST, curl est le standard universel.

linux
# basic GET request
curl https://api.example.com/data

# save to file
curl -O https://example.com/file.zip     # save with remote filename
curl -o file.zip https://example.com/file.zip  # custom name

# follow redirects
curl -L https://short.url/abc

# HTTP methods
curl -X POST https://api.example.com/users
curl -X PUT -d '{"name":"Alice"}' https://api.example.com/users/1
curl -X DELETE https://api.example.com/users/1

# send data
curl -d "name=Alice&age=30" https://api.example.com/form
curl -H "Content-Type: application/json" \
     -d '{"name":"Alice"}' https://api.example.com/users

# headers
curl -H "Authorization: Bearer TOKEN" \
     -H "Accept: application/json" \
     https://api.example.com/data

# verbose / headers only
curl -v https://example.com                # verbose
curl -I https://example.com                # headers only

# authentication
curl -u user:pass https://api.example.com  # basic auth
curl --netrc-file ~/.netrc https://...     # netrc

# download with progress bar
curl --progress-bar -O https://example.com/largefile.iso

# get HTTP status code only
curl -s -o /dev/null -w "%{http_code}" https://example.com

# retry on failure
curl --retry 3 --retry-delay 5 https://example.com

# pass query parameters
curl "https://api.example.com/search?q=linux&page=2"

wget — télécharger des fichiers

wget télécharge des fichiers de façon non interactive. -c reprend les téléchargements interrompus (essentiel pour les gros fichiers). -m met les sites en miroir (avec -k pour la conversion des liens). -r récuse avec -l pour la profondeur. -i lit les URLs depuis un fichier. wget est meilleur que curl pour les téléchargements récursifs/miroir et la reprise — curl emploie -C - pour reprendre. --limit-rate étrangle la bande passante. wget gère automatiquement redirections et cookies.

linux
# download a file
wget https://example.com/file.zip

# download with custom name
wget -O myfile.zip https://example.com/file.zip

# download in background
wget -b https://example.com/largefile.iso

# resume interrupted download
wget -c https://example.com/largefile.iso

# mirror a website
wget -m https://example.com
wget -m -k -K -E https://example.com  # convert links for local viewing

# recursive download (limited depth)
wget -r -l 2 https://example.com

# download all files of a type
wget -r -A pdf https://example.com/documents/

# continue and retry
wget -t 5 --waitretry=10 https://example.com/file.zip

# quiet mode (no output)
wget -q https://example.com/file.zip

# download from a list of URLs
wget -i urls.txt

# authentication
wget --user=user --password=pass https://example.com/protected

# set user agent
wget --user-agent="Mozilla/5.0" https://example.com

# limit download speed
wget --limit-rate=200k https://example.com/file.zip

# ignore certificate errors
wget --no-check-certificate https://example.com/file.zip

ip et ifconfig

ip (de iproute2) est le remplaçant moderne d'ifconfig/route. ip a montre les adresses ; ip link la couche 2 ; ip route la table de routage. Les changements avec ip sont temporaires (perdus au redémarrage) — pour la persistance, éditez /etc/netplan/ (Ubuntu), /etc/network/interfaces (Debian), ou employez nmcli (NetworkManager). ifconfig est déprécié mais encore très employé. Pour le sans-fil, employez iw/iwconfig.

linux
# view network interfaces (modern)
ip addr show                  # all interfaces
ip a                          # short form
ip a show eth0                # specific interface

# view link status
ip link show
ip -s link show eth0          # with statistics

# bring interface up/down
sudo ip link set eth0 up
sudo ip link set eth0 down

# assign IP address
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr del 192.168.1.100/24 dev eth0

# routing table
ip route show
ip route                      # short form
sudo ip route add default via 192.168.1.1

# view ARP table
ip neigh                      # neighbors (ARP)
arp -a                        # legacy

# DNS configuration
cat /etc/resolv.conf

# ifconfig (legacy, still common)
ifconfig                      # all interfaces
ifconfig eth0                 # specific interface
sudo ifconfig eth0 192.168.1.100 netmask 255.255.255.0 up

# change MAC address
sudo ip link set dev eth0 address 00:11:22:33:44:55

# view wireless info
iwconfig                      # wireless interfaces
iw list                       # wireless capabilities

# network manager (desktop)
nmcli device status
nmcli connection show

Recherche DNS (dig, nslookup)

dig est l'outil de recherche DNS le plus puissant. +short donne une sortie concise. Types d'enregistrements courants : A (IPv4), AAAA (IPv6), MX (mail), NS (serveurs de noms), TXT (texte/SPF), CNAME (alias). @server interroge un serveur DNS précis. -x fait la recherche inverse (IP vers nom). +trace montre le chemin complet de résolution depuis les serveurs racine. host est une alternative plus simple. Les vérifications de propagation DNS comparent les résultats entre plusieurs serveurs.

linux
# dig: detailed DNS lookup
dig example.com
dig +short example.com        # just the IP address
dig example.com A             # A record (IPv4)
dig example.com AAAA          # AAAA record (IPv6)
dig example.com MX            # mail exchange
dig example.com NS            # name servers
dig example.com TXT           # TXT records (SPF, etc.)
dig example.com SOA           # start of authority

# query specific DNS server
dig @8.8.8.8 example.com
dig @1.1.1.1 example.com MX

# reverse DNS lookup
dig -x 1.2.3.4
dig -x 8.8.8.8 +short

# trace DNS resolution path
dig +trace example.com

# JSON output (for scripting)
dig +json example.com

# nslookup: simpler alternative
nslookup example.com
nslookup example.com 8.8.8.8   # use specific server

# host: concise output
host example.com               # IP address
host -t MX example.com        # mail records
host -t NS example.com        # name servers
host 8.8.8.8                   # reverse lookup

# check DNS propagation
# compare results from multiple servers
for dns in 8.8.8.8 1.1.1.1 9.9.9.9; do
    echo "=== $dns ==="
    dig @$dns example.com +short
done

# flush DNS cache
sudo systemd-resolve --flush-caches   # systemd
sudo resolvectl flush-caches          # newer systemd
13

Gestion des paquets

apt (Debian/Ubuntu)

apt est le frontal convivial de dpkg/apt-get (Debian/Ubuntu). Lancez toujours apt update avant install/upgrade pour rafraîchir la liste des paquets. upgrade conserve les paquets ; full-upgrade peut en retirer pour résoudre les dépendances. purge retire les fichiers de config. autoremove nettoie les dépendances orphelines. dpkg -S trouve quel paquet possède un fichier. apt-mark hold empêche un paquet d'être mis à jour (utile pour des versions épinglées).

linux
# update package list
sudo apt update

# upgrade installed packages
sudo apt upgrade             # upgrade without removing
sudo apt full-upgrade        # upgrade, may remove packages
sudo apt dist-upgrade        # alias for full-upgrade

# install packages
sudo apt install nginx
sudo apt install nginx=1.18* # specific version
sudo apt install -y nginx    # no prompt

# remove packages
sudo apt remove nginx        # remove but keep config
sudo apt purge nginx         # remove including config
sudo apt autoremove          # remove unused dependencies
sudo apt clean               # clean downloaded packages

# search for packages
apt search nginx
apt-cache search web server

# show package info
apt show nginx
apt-cache policy nginx       # available versions

# list installed packages
apt list --installed
dpkg -l | grep nginx

# list files installed by a package
dpkg -L nginx
dpkg -S /usr/bin/curl        # which package owns a file

# add PPA (Ubuntu)
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

# hold package (prevent upgrade)
sudo apt-mark hold nginx
sudo apt-mark unhold nginx

dnf/yum (RHEL/Fedora/CentOS)

dnf remplace yum sur Fedora/RHEL/CentOS 8+ modernes. Les commandes sont semblables. dnf provides (ou yum provides) trouve quel paquet fournit un fichier — essentiel pour trouver les dépendances manquantes. rpm -ql liste les fichiers d'un paquet installé ; rpm -qf trouve le propriétaire d'un fichier. EPEL fournit des paquets supplémentaires pour RHEL/CentOS. dnf groupinstall installe des groupes de paquets (comme Development Tools). yum fonctionne encore comme lien symbolique vers dnf sur beaucoup de systèmes.

linux
# dnf: modern Fedora/RHEL/CentOS
sudo dnf install nginx
sudo dnf update              # update all packages
sudo dnf upgrade             # same as update
sudo dnf remove nginx

# search
dnf search nginx
dnf list available           # all available packages
dnf list installed           # installed packages

# package info
dnf info nginx
dnf provides /usr/bin/curl   # which package provides a file

# clean cache
sudo dnf clean all

# group install
dnf groupinstall "Development Tools"
dnf group list

# yum: older CentOS/RHEL (still available)
sudo yum install nginx
sudo yum update
sudo yum remove nginx
yum search nginx
yum provides /usr/bin/curl

# enable EPEL repository (Extra Packages for Enterprise Linux)
sudo dnf install epel-release

# list dependencies
dnf repoquery --requires nginx
dnf repoquery --deplist nginx

# downgrade a package
sudo dnf downgrade nginx

# view package files
rpm -ql nginx                # files installed by package
rpm -qi nginx                # package info
rpm -qf /usr/bin/curl        # which package owns file

pacman (Arch Linux)

pacman est le gestionnaire de paquets d'Arch Linux. -Syu est la commande de mise à jour essentielle (mettez toujours tout le système à jour, jamais partiellement). -S installe, -R retire, -Q interroge le local. -Rs retire avec les dépendances inutilisées ; -Rns retire aussi la config. Arch est en rolling release — les mises à jour partielles ne sont pas gérées et peuvent casser le système. L'AUR (Arch User Repository) fournit les paquets communautaires via des helpers comme yay/paru.

linux
# update system
sudo pacman -Syu            # sync repos + upgrade all
# ALWAYS update the full system on Arch

# install packages
sudo pacman -S nginx
sudo pacman -S --needed nginx  # don't reinstall if up to date

# remove packages
sudo pacman -R nginx         # remove package only
sudo pacman -Rs nginx        # remove + unused deps
sudo pacman -Rns nginx       # remove + deps + config

# search packages
pacman -Ss nginx             # search repos
pacman -Qs nginx             # search installed

# package info
pacman -Si nginx             # info from repos
pacman -Qi nginx             # info from installed
pacman -Ql nginx             # list files
pacman -Qo /usr/bin/curl     # which package owns file

# list orphaned packages
pacman -Qdt

# clean cache
sudo pacman -Sc             # clean old packages
sudo pacman -Scc            # clean all cache

# query local database
pacman -Q                   # all installed packages
pacman -Qe                  # explicitly installed
pacman -Qm                  # foreign (AUR) packages

# AUR (Arch User Repository)
# install yay or paru for AUR support
yay -S package-name         # install from AUR

# downgrade a package
sudo pacman -U /var/cache/pacman/pkg/package-1.0-1.x86_64.pkg.tar.zst

Trouver des paquets

Trouver des paquets par mot-clé (apt/dnf search) ou par fichier (apt-file/dnf provides/pacman -F) est essentiel quand on reçoit « command not found ». La question « quel paquet possède ce fichier » (dpkg -S / rpm -qf / pacman -Qo) est inestimable pour comprendre ce qui est installé. apt-file (Debian) et pacman -F (Arch) cherchent dans les bases de fichiers de paquets non encore installés — utile pour trouver quel paquet fournit un en-tête ou une bibliothèque nécessaire.

linux
# Debian/Ubuntu
apt search keyword
apt-cache search keyword
apt list --installed | grep keyword

# RHEL/Fedora
dnf search keyword
yum search keyword

# Arch
pacman -Ss keyword

# search by file name/path
# Debian: apt-file (separate package)
sudo apt install apt-file
sudo apt-file update
apt-file find /usr/bin/curl
apt-file search curl.h

# RHEL/Fedora
dnf provides /usr/bin/curl
dnf provides *curl.h
yum whatprovides /usr/bin/curl

# Arch
pacman -F /usr/bin/curl
pacman -Fy                  # update file database first

# check if package is installed
dpkg -l | grep nginx         # Debian
rpm -q nginx                 # RHEL
pacman -Q nginx              # Arch

# list files installed by a package
dpkg -L nginx                # Debian
rpm -ql nginx                # RHEL
pacman -Ql nginx             # Arch

# find which package owns a file
dpkg -S /usr/bin/curl         # Debian
rpm -qf /usr/bin/curl         # RHEL
pacman -Qo /usr/bin/curl      # Arch

# show package dependencies
apt-cache depends nginx      # Debian
dnf repoquery --requires nginx  # RHEL
pacman -Si nginx             # Arch

Gestion des dépôts

Les dépôts sont des sources de paquets. Sur Debian/Ubuntu, les PPAs (Personal Package Archives) fournissent des logiciels tiers — ajoutez toujours la clé de signature pour vérifier les paquets. /etc/apt/sources.list.d/ héberge les fichiers de dépôts personnalisés. Sur RHEL/Fedora, dnf config-manager gère les dépôts ; EPEL est essentiel pour RHEL. Sur Arch, éditez /etc/pacman.conf. Vérifiez toujours les clés GPG pour prévenir l'installation de paquets malveillants. apt policy et dnf repolist montrent les dépôts configurés.

linux
# Debian/Ubuntu: add repository
sudo add-apt-repository ppa:deadsnakes/ppa
sudo add-apt-repository "deb https://packages.example.com/ubuntu jammy main"

# remove repository
sudo add-apt-repository --remove ppa:deadsnakes/ppa

# add repository manually
echo "deb https://packages.example.com/ubuntu jammy main" | \
    sudo tee /etc/apt/sources.list.d/example.list

# add signing key (Debian)
wget -qO- https://example.com/key.gpg | \
    sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/example.gpg

# list repositories
apt policy                   # show configured repos
grep -r "" /etc/apt/sources.list.d/

# RHEL/Fedora: enable repository
sudo dnf config-manager --add-repo https://example.com/repo.repo
sudo dnf install epel-release  # enable EPEL
sudo dnf repolist              # list enabled repos
sudo dnf repolist all          # list all repos

# enable/disable a repo
sudo dnf config-manager --set-enabled epel
sudo dnf config-manager --set-disabled epel

# Arch: edit /etc/pacman.conf
# [custom]
# Server = https://example.com/$repo/os/$arch

# verify package integrity
dpkg --verify                 # Debian
rpm -Va                       # RHEL
14

Gestion des services (systemd)

Contrôle des services

systemctl gère les services systemd. start/stop/restart sont les opérations de base. reload envoie un signal pour relire la config sans redémarrage complet (gracieux). status montre l'état courant et les logs récents. mask empêche complètement qu'un service démarre (même manuellement) — plus fort que disable. is-active et is-enabled sont utiles dans les scripts (renvoient 0 pour actif/activé).

linux
# start/stop/restart services
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx
sudo systemctl reload nginx    # reload config without restart

# try-restart (only if running)
sudo systemctl try-restart nginx

# reload or restart (reload if possible, otherwise restart)
sudo systemctl reload-or-restart nginx

# send signal to service
sudo systemctl kill nginx
sudo systemctl kill -s HUP nginx

# check service status
sudo systemctl status nginx
systemctl is-active nginx       # active/inactive
systemctl is-enabled nginx      # enabled/disabled
systemctl is-failed nginx       # failed/running

# show service logs (recent)
sudo systemctl status nginx

# mask a service (prevent from starting)
sudo systemctl mask nginx
sudo systemctl unmask nginx

# reset failed state
sudo systemctl reset-failed

# emergency: reboot/poweroff
sudo systemctl reboot
sudo systemctl poweroff
sudo systemctl halt
sudo systemctl suspend

Statut et détails du service

systemctl status donne une vue complète : état, PID, usage mémoire/CPU et logs récents. systemctl cat montre le fichier unit (y compris les surcharges). systemctl edit crée un fichier de surcharge drop-in sans modifier l'original — sûr pour personnaliser des services fournis par le vendeur. Après édition des fichiers unit, lancez daemon-reload pour informer systemd. list-dependencies montre ce qu'un service exige.

linux
# detailed status
systemctl status nginx
# Shows: loaded state, active state, recent log entries, cgroup info

# just the active state
systemctl is-active nginx       # "active" or "inactive"

# is it enabled at boot?
systemctl is-enabled nginx      # "enabled" or "disabled"

# check if service failed
systemctl is-failed nginx

# list dependencies
systemctl list-dependencies nginx

# show service file
systemctl cat nginx
systemctl cat nginx.service

# show service properties
systemctl show nginx
systemctl show -p ExecStart nginx

# view service file location
systemctl show -p FragmentPath nginx

# edit service file (override)
sudo systemctl edit nginx       # creates override file
sudo systemctl edit --full nginx  # edit full unit file

# reload systemd after editing unit files
sudo systemctl daemon-reload

# list sockets
systemctl list-sockets

# check all failed services
systemctl --failed

Activer/désactiver les services

enable fait démarrer un service au boot (crée des liens symboliques) ; disable les retire. --now combine enable/disable avec start/stop. list-unit-files montre tous les services disponibles (installés mais peut-être pas en cours) ; list-units ceux chargés/actifs. La cible par défaut (multi-user = mode texte, graphical = GUI) remplace les runlevels traditionnels. Employez --state= pour filtrer par statut.

linux
# enable service to start at boot
sudo systemctl enable nginx

# enable and start in one command
sudo systemctl enable --now nginx

# disable (don't start at boot)
sudo systemctl disable nginx

# disable and stop in one command
sudo systemctl disable --now nginx

# re-enable (apply symlink changes)
sudo systemctl reenable nginx

# check if enabled
systemctl is-enabled nginx

# list enabled services
systemctl list-unit-files --state=enabled

# list all service unit files
systemctl list-unit-files --type=service

# list running services
systemctl list-units --type=service --state=running

# list all loaded services
systemctl list-units --type=service

# list services by state
systemctl list-units --type=service --state=failed
systemctl list-units --type=service --state=exited

# default boot target
systemctl get-default          # usually graphical.target or multi-user.target

# change boot target
sudo systemctl set-default multi-user.target  # text mode (runlevel 3)
sudo systemctl set-default graphical.target    # GUI mode (runlevel 5)

Lister et filtrer les services

list-units montre ce qui est actuellement chargé en mémoire ; list-unit-files ce qui est installé sur disque. --type filtre par type d'unité (service, socket, timer, mount, target). --state filtre par statut (running, exited, failed, enabled, disabled). Les timers (timers systemd) sont le remplaçant natif systemd des jobs cron — ils gèrent l'ordonnancement par dépendances et sont visibles via list-timers. --reverse montre ce qui dépend d'une unité.

linux
# list all active units
systemctl list-units

# list only services
systemctl list-units --type=service

# list by state
systemctl list-units --type=service --state=running
systemctl list-units --type=service --state=exited
systemctl list-units --type=service --state=failed

# list all unit files (installed)
systemctl list-unit-files --type=service

# list by state (unit files)
systemctl list-unit-files --state=enabled
systemctl list-unit-files --state=disabled
systemctl list-unit-files --state=masked

# list by target (runlevel)
systemctl list-units --type=target

# list sockets
systemctl list-units --type=socket
systemctl list-sockets

# list timers (replaces cron for many tasks)
systemctl list-timers
systemctl list-timers --all

# list mounts
systemctl list-units --type=mount

# show all units (including inactive)
systemctl list-units --all

# show specific unit type
systemctl list-units --type=service --all

# count services by state
systemctl list-units --type=service --no-legend | wc -l
systemctl list-units --type=service --state=running --no-legend | wc -l

# find services that depend on a unit
systemctl list-dependencies --reverse nginx

journalctl — logs système

journalctl interroge le journal systemd (logging structuré). -f suit en temps réel. -u filtre par unité (service). -b filtre par boot (-b -1 = boot précédent). --since/--until emploient des expressions de temps flexibles. -p filtre par priorité (emerg à debug). Le journal persiste entre les redémarrages (stocké dans /var/log/journal/). --vacuum-time et --vacuum-size contrôlent l'usage disque. journalctl remplace /var/log/messages sur les systèmes systemd.

linux
# view all logs (newest last)
journalctl

# follow logs (like tail -f)
journalctl -f

# today's logs
journalctl --since today
journalctl -u nginx --since today

# specific time range
journalctl --since "2024-01-01" --until "2024-01-02"
journalctl --since "1 hour ago"
journalctl --since "30 min ago"

# logs for a specific service
journalctl -u nginx
journalctl -u nginx -f          # follow
journalctl -u nginx --since "1 hour ago"

# logs for current boot
journalctl -b                   # current boot
journalctl -b -1                # previous boot
journalctl --list-boots         # list all boots

# filter by priority
journalctl -p err               # errors only
journalctl -p warning           # warnings and above
# 0=emerg, 1=alert, 2=crit, 3=err, 4=warning, 5=notice, 6=info, 7=debug

# filter by process
journalctl _PID=1234
journalctl _UID=1000

# show kernel messages only
journalctl -k

# output format
journalctl -o json              # JSON format
journalctl -o short-iso         # ISO timestamps
journalctl --no-pager           # no pager (for scripts)

# clear old logs
sudo journalctl --vacuum-time=7d    # keep last 7 days
sudo journalctl --vacuum-size=100M  # keep 100MB max
15

Tâches planifiées (Cron)

Bases de crontab

crontab -e édite vos tâches planifiées. Le format est : minute heure jour-du-mois mois jour-de-semaine commande. * signifie « tous ». */N signifie « tous les N ». Cron tourne avec un environnement minimal — employez toujours des chemins absolus pour commandes et scripts. Les scripts devraient régler PATH explicitement. La sortie est envoyée par email à l'utilisateur (configurez MAILTO dans crontab) ou redirigez vers un fichier de log. Les tâches globales vont dans /etc/crontab ou les répertoires /etc/cron.*/.

linux
# edit your crontab
crontab -e

# list your crontab entries
crontab -l

# remove all crontab entries
crontab -r

# edit another user's crontab (requires root)
sudo crontab -u alice -e
sudo crontab -u alice -l

# crontab entry format:
# minute hour day-of-month month day-of-week command
# 0-59   0-23 1-31          1-12  0-6 (0=Sunday)
#
# *  *  *  *  *  command to execute
# |  |  |  |  |
# |  |  |  |  +----- day of week (0-7) (0 or 7 is Sunday)
# |  |  |  +------- month (1-12)
# |  |  +--------- day of month (1-31)
# |  +----------- hour (0-23)
# +------------- minute (0-59)

# examples:
# run every day at 2:30 AM
30 2 * * * /home/user/backup.sh

# run every Monday at 9 AM
0 9 * * 1 /home/user/weekly-report.sh

# run every 15 minutes
*/15 * * * * /home/user/check.sh

# run at reboot
@reboot /home/user/startup.sh

# system-wide cron: /etc/crontab
# adds a user column:
# minute hour day month week USER command
*/30 * * * * root /usr/local/bin/check.sh

# cron directories (run all scripts inside)
/etc/cron.daily/    # daily
/etc/cron.hourly/   # hourly
/etc/cron.weekly/   # weekly
/etc/cron.monthly/  # monthly

Syntaxe du planning cron

Cron emploie 5 champs : minute (0-59), heure (0-23), jour-du-mois (1-31), mois (1-12), jour-de-semaine (0-7, où 0 et 7 sont dimanche). * signifie tous ; */N tous les N ; les virgules séparent les valeurs ; les tirets définissent des plages. Jour-de-semaine et jour-du-mois sont en OU quand les deux sont précisés (pas en ET). L'astuce du dernier jour du mois vérifie si demain est le 1er. Testez toujours un planning cron avec un simple echo avant de déployer de vraies tâches.

linux
# every minute
* * * * * command

# every 5 minutes
*/5 * * * * command

# every hour at minute 0
0 * * * * command

# every day at midnight
0 0 * * * command

# every day at 2:30 AM
30 2 * * * command

# every Monday at 8 AM
0 8 * * 1 command

# every weekday (Mon-Fri) at 9 AM
0 9 * * 1-5 command

# every weekend (Sat and Sun) at 10 AM
0 10 * * 0,6 command

# every month on the 1st at midnight
0 0 1 * * command

# every quarter (Jan, Apr, Jul, Oct) on the 1st
0 0 1 1,4,7,10 * command

# every 15 minutes during business hours
*/15 9-17 * * 1-5 command

# twice a day (midnight and noon)
0 0,12 * * * command

# every 2 hours
0 */2 * * * command

# last day of month (tricky — use date check)
0 0 28-31 * * [ "$(date +%d -d tomorrow)" = "01" ] && /script.sh

# run on specific date (Jan 1 at midnight)
0 0 1 1 * command

Chaînes cron spéciales

Les chaînes spéciales (@daily, @weekly, etc.) sont des raccourcis pour des plannings courants — plus lisibles que le format à 5 champs. @reboot tourne une fois au démarrage du système. MAILTO contrôle où la sortie est envoyée par email — videz-le pour désactiver. Cron emploie un environnement minimal (PATH limité, pas de profil shell) — réglez toujours PATH explicitement ou employez des chemins absolus. La redirection de sortie est essentielle : sans elle, la sortie part par email ou se perd.

linux
# predefined special strings (GNU cron)
@reboot     command    # run once at startup
@yearly     command    # once a year: 0 0 1 1 *
@annually   command    # same as @yearly
@monthly    command    # once a month: 0 0 1 * *
@weekly     command    # once a week: 0 0 * * 0
@daily      command    # once a day: 0 0 * * *
@midnight   command    # same as @daily
@hourly     command    # once an hour: 0 * * * *

# examples
@reboot /home/user/startup.sh
@daily /home/user/backup.sh >> /var/log/backup.log 2>&1
@hourly /usr/local/bin/health-check.sh

# set MAILTO for email notifications
MAILTO="[email protected]"
@daily /home/user/report.sh

# disable email (discard output)
MAILTO=""
@daily /home/user/cleanup.sh > /dev/null 2>&1

# environment variables in crontab
PATH=/usr/local/bin:/usr/bin:/bin
SHELL=/bin/bash
HOME=/home/user
@daily /home/user/script.sh

# redirect output to log
@daily /home/user/script.sh >> /home/user/cron.log 2>&1

# log with timestamp
@daily echo "$(date): starting" >> /home/user/cron.log; /home/user/script.sh >> /home/user/cron.log 2>&1

# check cron service is running
systemctl status cron
systemctl status crond

anacron

anacron est conçu pour les machines pas toujours allumées (portables, ordinateurs de bureau). Contrairement à cron, il exécute les jobs manqués au démarrage du système. Il ne gère que la granularité quotidienne/hebdomadaire/mensuelle. Le champ delay ajoute une attente aléatoire pour empêcher tous les jobs de démarrer d'un coup. Les timers systemd sont l'alternative moderne — ils gèrent un ordonnancement façon cron, peuvent rattraper les jobs manqués (Persistent=true) et s'intègrent à journalctl pour les logs.

linux
# anacron: run periodic jobs even if system was off
# /etc/anacrontab format:
# period  delay  job-id  command
#   1     5      daily   /home/user/daily.sh
#   7     10     weekly  /home/user/weekly.sh
#   30    15     monthly /home/user/monthly.sh

# view anacron config
cat /etc/anacrontab

# anacron directories (system-wide)
ls /etc/cron.daily/
ls /etc/cron.weekly/
ls /etc/cron.monthly/

# run anacron manually
sudo anacron -d            # run jobs in foreground with debug
sudo anacron -f            # force run all jobs
sudo anacron -u            # update timestamps only (don't run)

# run a specific job
sudo anacron -j daily      # run the 'daily' job

# check when jobs last ran
ls -l /var/spool/anacron/

# difference between cron and anacron:
# cron:
#   - requires system to be running at scheduled time
#   - minimum resolution: 1 minute
#   - per-user crontabs
#
# anacron:
#   - catches up missed jobs after downtime
#   - minimum resolution: 1 day
#   - system-wide only (runs as root)
#   - good for laptops/desktops that aren't always on

# systemd timers: modern alternative to cron
systemctl list-timers
sudo systemctl enable --now mytask.timer

at — tâches planifiées ponctuelles

at planifie des commandes ponctuelles (contrairement au planning récurrent de cron). Les heures peuvent être absolues (10:30, minuit) ou relatives (now + 30 minutes). atq liste les jobs en attente ; atrm les retire. batch tourne quand la charge système est sous 0,8 (configurable). Les jobs at tournent avec l'environnement de l'utilisateur. Exige le service atd. Utile pour des rappels, tâches différées ou programmer un arrêt sans rester connecté.

linux
# schedule a command for later
echo "backup.sh" | at midnight
echo "shutdown -h now" | at 2am tomorrow

# interactive scheduling
at 2:30 PM
at> /home/user/report.sh
at> Ctrl+D                  # press Ctrl+D to submit

# schedule relative to now
at now + 30 minutes
at> echo "30 min passed" > /tmp/notice.txt
at> Ctrl+D

at now + 2 hours
at now + 1 day
at now + 1 week

# schedule for a specific time
at 10:30 AM
at 10:30 AM tomorrow
at 10:30 AM 2025-12-25
at 10:30 AM Dec 25

# list pending jobs
atq
at -l

# view a specific job
at -c 5                      # show job #5

# remove a job
atrm 5                       # remove job #5
at -d 5                      # alternative

# batch: run when load is low
batch
at> /home/user/heavy-computation.sh
at> Ctrl+D

# enable atd service
sudo systemctl enable --now atd

# check atd is running
systemctl status atd
16

Archives et compression

tar — créer et extraire

tar regroupe des fichiers en une seule archive (sans compression par défaut). Les flags sont mnémoniques : c=créer, x=eXtraire, t=liste, f=fichier, v=verbeux. -C précise le répertoire d'extraction. --exclude saute des motifs. tar préserve permissions, propriété et horodatages. Employez toujours tar -tf pour prévisualiser le contenu avant d'extraire d'une source non fiable. Le flag -f doit être suivi du nom de fichier.

linux
# create a tar archive (no compression)
tar -cf archive.tar file1.txt file2.txt
tar -cf archive.tar directory/

# extract a tar archive
tar -xf archive.tar
tar -xf archive.tar -C /target/dir/    # extract to specific directory

# list contents without extracting
tar -tf archive.tar
tar -tvf archive.tar          # verbose (with details)

# verbose create/extract
tar -cvf archive.tar dir/     # show files being added
tar -xvf archive.tar          # show files being extracted

# append files to existing archive
tar -rf archive.tar newfile.txt

# extract specific files
tar -xf archive.tar path/to/file.txt
tar -xf archive.tar "file*.txt"

# exclude files
tar -cf archive.tar dir/ --exclude="*.log"
tar -cf archive.tar dir/ --exclude="node_modules"

# common flags:
# c = create
# x = extract
# t = list
# f = file (specify archive name)
# v = verbose
# r = append
# u = update (only newer files)
# C = change to directory

# preserve permissions (default for root)
tar -cpf archive.tar dir/     # p = preserve permissions

# show what would be done (dry run)
tar -tf archive.tar | head -10

tar avec compression

tar gère plusieurs algorithmes de compression par flags : z (gzip), j (bzip2), J (xz), --zstd (zstd). gzip est le standard (rapide, partout) ; bzip2 compresse mieux mais plus lentement ; xz le meilleur ratio mais le plus lent ; zstd moderne (le plus rapide, bon ratio). Le tar moderne détecte automatiquement la compression à l'extraction, donc -xf fonctionne pour tout format. Le niveau de compression (1-9) échange vitesse contre taille. Pour les sauvegardes, xz ou zstd sont préférés.

linux
# tar + gzip (most common, .tar.gz or .tgz)
tar -czf archive.tar.gz dir/        # create
tar -xzf archive.tar.gz             # extract
tar -tzf archive.tar.gz             # list

# tar + bzip2 (better compression, slower)
tar -cjf archive.tar.bz2 dir/       # create
tar -xjf archive.tar.bz2            # extract
tar -tjf archive.tar.bz2            # list

# tar + xz (best compression, slowest)
tar -cJf archive.tar.xz dir/        # create
tar -xJf archive.tar.xz             # extract
tar -tJf archive.tar.xz             # list

# tar + zstd (fast + good ratio, modern)
tar --zstd -cf archive.tar.zst dir/ # create
tar --zstd -xf archive.tar.zst      # extract

# specify compression level (1-9, default 6)
GZIP=-9 tar -czf archive.tar.gz dir/    # max gzip compression
XZ_OPT=-9e tar -cJf archive.tar.xz dir/ # max xz compression

# compression comparison:
# gzip:  fast, medium compression (.tar.gz)
# bzip2: medium, good compression (.tar.bz2)
# xz:    slow, best compression (.tar.xz)
# zstd:  fastest, good compression (.tar.zst)

# extract: tar auto-detects compression
tar -xf archive.tar.gz    # works without -z flag
tar -xf archive.tar.xz    # works without -J flag

# compress to stdout (for piping)
tar -cz dir/ | ssh user@host "cat > backup.tar.gz"

zip et unzip

zip est courant sur Windows et très largement géré. -r récuse les répertoires ; -e chiffre avec un mot de passe (demandé) ; -x exclut des motifs ; -s découpe en plusieurs parties (utile pour les gros fichiers). unzip -l liste ; -d extrait dans un répertoire ; -t teste l'intégrité. Contrairement à tar+gzip, zip compresse chaque fichier individuellement, permettant l'accès aléatoire aux fichiers de l'archive. Pour le partage multiplateforme, zip est le choix le plus sûr.

linux
# create a zip archive
zip archive.zip file1.txt file2.txt

# zip a directory recursively
zip -r archive.zip directory/

# zip with password (encryption)
zip -e -r archive.zip directory/
zip -P password archive.zip file.txt   # password on command line (insecure)

# zip with specific compression level (0-9)
zip -9 -r archive.zip directory/       # maximum compression

# zip excluding files
zip -r archive.zip dir/ -x "*.log" -x "*/node_modules/*"

# split archive into parts
zip -s 100m archive.zip largefile.iso   # 100MB parts

# update/add files to existing zip
zip archive.zip newfile.txt

# list contents
unzip -l archive.zip
unzip -v archive.zip            # verbose with details

# extract
unzip archive.zip
unzip archive.zip -d /target/dir/

# extract specific files
unzip archive.zip file1.txt

# test archive integrity
unzip -t archive.zip

# extract to stdout
unzip -p archive.zip file.txt

# zipinfo: detailed listing
zipinfo archive.zip
zipinfo -1 archive.zip          # just filenames

gzip et gunzip

gzip compresse des fichiers uniques (pas des archives — employez tar pour plusieurs fichiers). Il remplace l'original par un fichier .gz ; employez -k pour le garder. -c sort vers stdout (pratique pour piper). zcat/zless lisent les fichiers compressés sans extraire. gzip ne traite qu'un fichier à la fois, donc tar + gzip est le standard pour les répertoires. Le niveau 9 donne le plus petit fichier mais prend plus de temps ; le niveau 1 est le plus rapide.

linux
# compress a single file (replaces original)
gzip file.txt                # creates file.txt.gz, removes file.txt

# keep the original file
gzip -k file.txt             # keep original
gzip -c file.txt > file.txt.gz  # alternative (to stdout)

# set compression level (1-9, default 6)
gzip -1 file.txt             # fastest, least compression
gzip -9 file.txt             # slowest, best compression

# decompress
gunzip file.txt.gz           # creates file.txt, removes .gz
gzip -d file.txt.gz          # same as gunzip
gunzip -c file.txt.gz > file.txt  # keep original
gunzip -k file.txt.gz        # keep original (GNU)

# compress multiple files (each gets its own .gz)
gzip file1.txt file2.txt file3.txt

# recursive (compress all files in directory)
gzip -r directory/

# test integrity
gzip -t file.txt.gz

# list compression info
gzip -l file.txt.gz
# compressed  uncompressed  ratio  uncompressed_name
#       1234        5678    78.3%  file.txt

# zcat: view compressed file without extracting
zcat file.txt.gz
zcat file.txt.gz | grep "error"

# zless: pager for compressed files
zless file.txt.gz

# concatenate and decompress
cat file1.txt.gz file2.txt.gz | gunzip > combined.txt

# compress stdin
echo "data" | gzip > data.gz
tar -cf - dir/ | gzip > archive.tar.gz

xz et bzip2

bzip2 compresse mieux que gzip mais plus lentement. xz (LZMA) offre le meilleur ratio mais est le plus lent — idéal pour l'archivage. zstd est le choix moderne : décompression la plus rapide avec bon ratio. lz4 est extrêmement rapide mais au ratio plus faible. Pour distribuer des logiciels, xz est préféré (téléchargement le plus petit). Pour la compression en temps réel, zstd ou lz4. bzcat/xzcat/zcat lisent les fichiers compressés sans extraire — utile pour l'analyse de logs.

linux
# bzip2: better compression than gzip
bzip2 file.txt               # compress (replaces original)
bzip2 -k file.txt            # keep original
bunzip2 file.txt.bz2         # decompress
bzip2 -d file.txt.bz2        # same as bunzip2

# bzip2 compression level (1-9, default 9)
bzip2 -9 file.txt

# bzcat: view bzip2-compressed file
bzcat file.txt.bz2 | grep "pattern"

# xz: best compression ratio
xz file.txt                  # compress (replaces original)
xz -k file.txt               # keep original
xz -d file.txt.xz            # decompress
unxz file.txt.xz             # same as xz -d

# xz compression level (0-9, default 6)
xz -9 file.txt               # maximum compression

# xz with extreme compression (very slow)
xz -9e file.txt

# xzcat: view xz-compressed file
xzcat file.txt.xz

# zstd: fast modern compressor
zstd file.txt                # compress
zstd -d file.txt.zst         # decompress
zstd -19 file.txt            # max compression
zstd -k file.txt             # keep original

# lz4: extremely fast
lz4 file.txt                 # compress
lz4 -d file.txt.lz4          # decompress

# compare compression ratios
ls -lh file.txt file.txt.gz file.txt.bz2 file.txt.xz

# benchmark compression
time gzip -9 file.txt
time xz -9 file.txt
17

SSH et accès distant

Connexion SSH

ssh se connecte de façon sécurisée à des machines distantes. -p précise un port non standard ; -i choisit une clé privée. ssh-copy-id installe votre clé publique pour une authentification sans mot de passe (bien plus sûr que les mots de passe). -v aide à diagnostiquer les problèmes de connexion (négociation de clé, étapes d'authentification). -X active le forwarding X11 pour les apps GUI distantes. Pour les connexions fréquentes, configurez ~/.ssh/config avec des alias.

linux
# basic connection
ssh user@hostname
ssh [email protected]
ssh [email protected]

# specify port (default 22)
ssh -p 2222 user@host

# use a specific private key
ssh -i ~/.ssh/id_ed25519 user@host

# run a single command and exit
ssh user@host "uname -a"
ssh user@host "ls -la /var/log"

# verbose (debug connection issues)
ssh -v user@host
ssh -vv user@host            # more verbose
ssh -vvv user@host           # most verbose

# forward X11 (GUI applications)
ssh -X user@host
ssh -Y user@host             # trusted X11 forwarding

# compression (slow connections)
ssh -C user@host

# keep alive
ssh -o ServerAliveInterval=60 user@host

# force SSH version
ssh -1 user@host             # SSH protocol 1 (insecure, avoid)
ssh -2 user@host             # SSH protocol 2 (default, secure)

# copy SSH key to remote (passwordless login)
ssh-copy-id user@host
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host
ssh-copy-id -p 2222 user@host

# test connection without running commands
ssh -T user@host

Gestion des clés SSH

Les clés Ed25519 sont recommandées (plus petites, plus rapides et plus sûres que RSA). La clé privée doit être en chmod 600 ou SSH la refuse. ssh-agent garde les phrases secrètes en mémoire pour ne la taper qu'une fois par session ; ssh-add -l liste les clés chargées. ssh-keygen -R retire un hôte de known_hosts (utile après une réinstallation du serveur). Vérifiez toujours les empreintes des hôtes hors bande pour prévenir les attaques de l'homme du milieu. Ne partagez jamais et ne commitez jamais votre clé privée.

linux
# generate an SSH key pair (Ed25519, recommended)
ssh-keygen -t ed25519 -C "[email protected]"

# generate RSA key (4096 bits, if Ed25519 not supported)
ssh-keygen -t rsa -b 4096 -C "[email protected]"

# generate with custom filename
ssh-keygen -t ed25519 -f ~/.ssh/id_server -C "server key"

# generate without passphrase (automated scripts)
ssh-keygen -t ed25519 -N "" -f ~/.ssh/deploy_key

# copy public key to remote server
ssh-copy-id user@host

# view public key
cat ~/.ssh/id_ed25519.pub

# view fingerprint
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

# key files:
# ~/.ssh/id_ed25519       private key (keep secret! chmod 600)
# ~/.ssh/id_ed25519.pub   public key (can share)

# authorized_keys on remote server
# add your public key to: ~/.ssh/authorized_keys
cat ~/.ssh/id_ed25519.pub | ssh user@host "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

# SSH agent (manages keys in memory)
eval "$(ssh-agent -s)"        # start agent
ssh-add ~/.ssh/id_ed25519     # add key to agent
ssh-add -l                   # list loaded keys
ssh-add -D                   # remove all keys from agent

# remove or change a key passphrase
ssh-keygen -p -f ~/.ssh/id_ed25519

# verify host key fingerprint (avoid MITM)
ssh-keygen -l -f /etc/ssh/ssh_host_ed25519_key.pub

# known_hosts management
ssh-keygen -R 192.168.1.100   # remove a host entry
ssh-keygen -F 192.168.1.100   # find a host entry

# key permissions (critical!)
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

SCP — copie sécurisée

scp emploie SSH pour un transfert de fichiers chiffré. -r pour les répertoires, -P (majuscule !) pour le port (ssh emploie le -p minuscule). Pour les transferts grands ou fréquents, préférez rsync à scp — rsync reprend les transferts interrompus et n'envoie que les différences. scp est en cours de dépréciation au profit de sftp dans les versions récentes d'OpenSSH, mais reste très répandu et simple pour des copies rapides.

linux
# copy local file to remote
scp file.txt user@host:/path/to/dest/
scp file.txt user@host:~/        # home directory

# copy remote file to local
scp user@host:/var/log/syslog ./
scp -r user@host:/var/log /tmp/  # recursive (directory)

# copy between two remote hosts
scp user1@host1:/file user2@host2:/dest

# specify port
scp -P 2222 file.txt user@host:/dest

# preserve attributes (timestamps, perms)
scp -p file.txt user@host:/dest

# compress during transfer
scp -C bigfile.tar user@host:/dest

# limit bandwidth (KB/s)
scp -l 1000 file user@host:/dest    # ~1 MB/s

Fichier de config SSH

~/.ssh/config permet de créer des alias d'hôtes, évitant de longues commandes ssh aux nombreux flags. Un simple 'ssh dev' se connecte avec tous les bons réglages. Les wildcards (*.internal) s'appliquent aux hôtes correspondants. Ce fichier doit être en chmod 600. IdentitiesOnly yes empêche SSH d'essayer chaque clé de ~/.ssh (ce qui cause « too many authentication failures »). C'est la plus grande amélioration de qualité de vie de SSH.

linux
# ~/.ssh/config - simplify connections
Host dev
    HostName dev.example.com
    User alice
    Port 2222
    IdentityFile ~/.ssh/id_dev

Host prod
    HostName prod.example.com
    User deploy
    IdentityFile ~/.ssh/id_deploy
    ServerAliveInterval 60

# wildcard: all hosts in a domain
Host *.internal
    User admin
    ForwardAgent yes

# use: ssh dev  (instead of ssh -p 2222 [email protected])
#      scp file prod:/tmp/

# common useful options
Host *
    ServerAliveInterval 60      # keep connection alive
    ServerAliveCountMax 3       # disconnect after 3 missed
    AddKeysToAgent yes          # auto-add keys to agent
    IdentitiesOnly yes          # only use specified keys

Port forwarding et tunnels

Le port forwarding tunnelise le trafic par le canal chiffré de SSH. -L (local) expose un service distant sur votre machine ; -R (remote) fait l'inverse (utile pour atteindre une machine derrière NAT) ; -D crée un proxy SOCKS. -fN tourne en arrière-plan sans shell. ProxyJump (-J) est la façon moderne de sauter par des hôtes bastion — bien plus propre que du SSH imbriqué. Essentiel pour accéder de façon sécurisée aux services internes.

linux
# local forward: access remote service locally
# local:8080 -> remote:80
ssh -L 8080:localhost:80 user@host
# then open http://localhost:8080 in browser

# local forward to a third host via jump server
ssh -L 8080:internal.db:3306 user@jumphost

# remote forward: expose local service to remote
# remote:8080 -> local:80
ssh -R 8080:localhost:80 user@host

# dynamic forward (SOCKS proxy)
ssh -D 1080 user@host
# then configure browser to use SOCKS5 proxy at localhost:1080

# run in background (no command, no terminal)
ssh -fN -L 8080:localhost:80 user@host

# jump host / proxy jump (OpenSSH 7.3+)
ssh -J user@jumphost [email protected]
# or in ~/.ssh/config:
#   Host internal
#       ProxyJump jumphost

# forward ports in config file
Host db
    HostName db.internal
    LocalForward 3306 localhost:3306
18

Gestion des disques

Lister les périphériques bloc

lsblk est la façon moderne de lister disques et partitions (remplaçant fdisk -l pour la visualisation). df montre l'espace disque des systèmes de fichiers (-h lisible, -i pour les inodes — si les inodes sont pleins, impossible de créer des fichiers même avec de l'espace libre). du mesure les tailles de répertoires ; le pattern « sort -rh | head » trouve les gouffres d'espace. Lancez du avec --max-depth pour limiter la profondeur de récursion.

linux
# list block devices (modern, recommended)
lsblk                         # tree view
lsblk -f                      # with filesystem info
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT
lsblk -d                      # don't print partitions

# old way: list disks and partitions
sudo fdisk -l
sudo fdisk -l /dev/sda        # specific disk

# view partition table
sudo parted -l
sudo parted /dev/sda print

# filesystem disk space
df -h                         # human-readable
df -hT                        # with filesystem type
df -i                         # inode usage
df -h /                       # specific mount

# directory space usage
du -sh /path                  # summary
du -sh /*                     # top-level dirs
du -h --max-depth=1 /var      # one level deep
du -ah /var | sort -rh | head -10   # 10 largest

Monter et démonter

mount attache des systèmes de fichiers ; umount les détache. Si « target is busy », employez -l (lazy) pour détacher dès que plus utilisé. /etc/fstab définit les montages du démarrage — testez toujours avec « mount -a » après édition avant de redémarrer ! La forme UUID= est plus fiable que /dev/sdX (qui peut changer au reboot). findmnt donne une vue plus propre que mount.

linux
# mount a filesystem
sudo mount /dev/sdb1 /mnt/data
sudo mount -t ext4 /dev/sdb1 /mnt/data

# mount with options
sudo mount -o ro /dev/sdb1 /mnt/data          # read-only
sudo mount -o noexec /dev/sdb1 /mnt/data      # no executables
sudo mount -o uid=1000,gid=1000 /dev/sdb1 /mnt  # set owner

# mount an ISO image
sudo mount -o loop ubuntu.iso /mnt/iso

# unmount
sudo umount /mnt/data
sudo umount /dev/sdb1

# lazy unmount (busy filesystem)
sudo umount -l /mnt/data

# force unmount
sudo umount -f /mnt/data

# list mounted filesystems
mount | column -t
findmnt                        # cleaner tree view

# /etc/fstab - persistent mounts
# <device>  <mount>  <type>  <options>  <dump>  <pass>
# /dev/sdb1  /data    ext4   defaults   0       2

Créer et formater des partitions

Employez GPT (label gpt) pour les disques de plus de 2 To ; MBR (msdos) est le défaut historique. ext4 est le défaut Linux sûr ; XFS est courant sur RHEL/CentOS ; Btrfs offre instantanés et compression. Vérifiez TOUJOURS deux fois le nom du périphérique avant mkfs — il détruit toutes les données ! fsck vérifie/répare les systèmes de fichiers (lancez-le sur des systèmes démontés par prudence). parted est non interactif et scriptable, contrairement à fdisk.

linux
# interactive partition editor
sudo fdisk /dev/sdb
#   m = help, n = new, p = print, d = delete, w = write, q = quit

# GPT partitioning (for disks > 2TB)
sudo parted /dev/sdb mklabel gpt
sudo parted /dev/sdb mkpart primary ext4 0% 100%

# MBR partitioning
sudo parted /dev/sdb mklabel msdos
sudo parted /dev/sdb mkpart primary ext4 1MiB 100%

# format filesystem
sudo mkfs.ext4 /dev/sdb1           # ext4 (Linux default)
sudo mkfs.xfs /dev/sdb1            # XFS (RHEL default)
sudo mkfs.btrfs /dev/sdb1          # Btrfs
sudo mkfs.ntfs /dev/sdb1           # NTFS (Windows)
sudo mkfs.vfat /dev/sdb1           # FAT32

# label a filesystem
sudo e2label /dev/sdb1 mydata      # ext4
sudo xfs_admin -L mydata /dev/sdb1 # xfs

# check filesystem for errors
sudo fsck /dev/sdb1
sudo fsck -y /dev/sdb1             # auto-repair

Gestion des volumes logiques (LVM)

LVM abstrait les disques physiques en volumes logiques flexibles. Avantage clé : on peut redimensionner les volumes et s'étendre sur plusieurs disques. La hiérarchie est PV (physique) -> VG (groupe de volumes, un pool) -> LV (volume logique, ce qu'on formate/monte). Le redimensionnement est en ligne pour ext4 (resize2fs) et XFS (xfs_growfs, croissance seulement). Les instantanés permettent des sauvegardes cohérentes. LVM est standard sur RHEL/Fedora.

linux
# LVM layers: PV -> VG -> LV
# physical volume (disk/partition)
sudo pvcreate /dev/sdb /dev/sdc
sudo pvdisplay
sudo pvs                        # summary

# volume group (pool of PVs)
sudo vgcreate myvg /dev/sdb /dev/sdc
sudo vgdisplay
sudo vgs

# logical volume (carved from VG)
sudo lvcreate -L 50G -n mylv myvg
sudo lvcreate -l 100%FREE -n mylv myvg   # use all space
sudo lvdisplay
sudo lvs

# use the LV (path: /dev/<vg>/<lv>)
sudo mkfs.ext4 /dev/myvg/mylv
sudo mount /dev/myvg/mylv /mnt/data

# resize LV (ext4)
sudo lvextend -L +10G /dev/myvg/mylv
sudo resize2fs /dev/myvg/mylv    # grow filesystem

# resize LV (xfs)
sudo lvextend -L +10G /dev/myvg/mylv
sudo xfs_growfs /mnt/data

# snapshot (point-in-time copy)
sudo lvcreate -L 5G -s -n mysnap /dev/myvg/mylv

Swap et mémoire

Le swap étend la mémoire physique avec de l'espace disque. Les fichiers de swap (créés avec fallocate/mkswap) sont plus simples que les partitions de swap et tout aussi performants sur les noyaux modernes. swappiness (0-100) contrôle l'agressivité du swap du noyau — des valeurs basses gardent plus en RAM (bon pour les bases de données). free -h est le résumé mémoire rapide ; /proc/meminfo a le détail. vmstat 1 montre les stats mémoire/cpu/io en cours.

linux
# show swap usage
swapon --show
free -h

# create a swap file (modern method)
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# make permanent (add to /etc/fstab)
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# remove swap file
sudo swapoff /swapfile
sudo rm /swapfile

# adjust swappiness (0-100, lower = less swap use)
cat /proc/sys/vm/swappiness       # default 60
sudo sysctl vm.swappiness=10      # runtime
# permanent: add to /etc/sysctl.conf

# memory info
free -h                           # summary
cat /proc/meminfo                 # detailed
vmstat 1                          # continuous
19

Pipes et redirection

Flux standards et redirection

Chaque processus a trois flux : stdin (0), stdout (1), stderr (2). > redirige stdout (>> ajoute) ; 2> redirige stderr. 2>&1 fusionne stderr vers la destination de stdout (l'ordre compte — mettez-le en dernier). &> est le raccourci Bash de >fichier 2>&1. Les here-docs (<<EOF) alimentent une entrée multi-lignes ; citer le délimiteur ('EOF') désactive l'expansion des variables. /dev/null est le trou noir pour jeter la sortie.

linux
# three standard streams:
#   stdin  (0) - input
#   stdout (1) - normal output
#   stderr (2) - error output

# redirect stdout to file (overwrite)
echo "hello" > file.txt

# append stdout to file
echo "world" >> file.txt

# redirect stderr to file
ls /nonexistent 2> errors.log

# redirect both stdout and stderr
ls / /nonexistent > all.log 2>&1
ls / /nonexistent &> all.log        # bash shortcut

# discard output (send to /dev/null)
command > /dev/null 2>&1

# redirect stdin from file
sort < unsorted.txt
wc -l < file.txt

# here-string (feed string to stdin)
grep "error" <<< "some error text"

# here-document (multi-line input)
cat << EOF
Line one
Line two with $HOME expanded
EOF

# quoted here-doc (no expansion)
cat << 'EOF'
$HOME stays literal
EOF

Pipes et pipelines

Les pipes (|) relient le stdout d'une commande au stdin d'une autre, bâtissant de puissants pipelines. tee divise la sortie vers un fichier et stdout (parfait pour logger tout en visualisant). La substitution de processus <(cmd) traite la sortie d'une commande comme un fichier temporaire — essentiel pour des commandes comme diff et comm qui attendent des arguments fichiers. Par défaut, le code de sortie d'un pipeline est celui de la dernière commande ; set -o pipefail le fait échouer si une étape échoue.

linux
# pipe: connect stdout to stdin
command1 | command2

# count files
ls | wc -l

# find and kill
ps aux | grep nginx | grep -v grep

# filter and sort
cat access.log | grep "404" | sort | uniq -c | sort -rn | head

# chain transformations
cat data.csv | cut -d, -f2 | sort | uniq -c | sort -rn

# tee: write to file AND stdout
command | tee output.log
command | tee -a output.log        # append

# pipe stderr too
command 2>&1 | grep error

# pipefail: catch failures in pipeline
set -o pipefail                    # pipeline fails if any command fails

# process substitution (command as file)
diff <(ls dir1) <(ls dir2)
comm <(sort file1) <(sort file2)
while read line; do echo "$line"; done < <(grep pattern file)

xargs et exécution parallèle

xargs convertit stdin en arguments de commande — essentiel pour piper la sortie de find vers des commandes comme rm, cp ou grep. Employez TOUJOURS -0 avec find -print0 pour gérer les noms de fichiers avec espaces/sauts de ligne. -I {} permet de placer l'argument n'importe où dans la commande. -P N lance N commandes en parallèle. GNU parallel est une alternative plus puissante (barres de progression, exécution distante, reprise). Ne lancez jamais « xargs rm » sans tester d'abord — employez -t pour prévisualiser ou -p pour confirmer.

linux
# xargs: build arguments from stdin
echo "a b c" | xargs mkdir

# one argument per line
find . -name "*.bak" | xargs rm

# handle spaces in filenames (null-delimited)
find . -name "*.log" -print0 | xargs -0 rm

# limit arguments per command
find . -name "*.txt" | xargs -n 1 cp -t /dest/

# show commands before running
find . -name "*.bak" | xargs -t rm

# prompt before each command
find . -name "*.bak" | xargs -p rm

# replace string with argument
find . -name "*.jpg" | xargs -I {} convert {} {}.png

# parallel execution (GNU parallel is more powerful)
find . -name "*.png" | xargs -P 4 -I {} convert {} {}.jpg   # 4 parallel

# GNU parallel (if installed)
parallel -j 4 convert {} {.}.jpg ::: *.png
parallel gzip ::: *.log

Substitution de commande et groupement

$() capture la sortie d'une commande (préféré aux backticks — s'imbrique proprement, sans échappement). { } groupe des commandes dans le shell courant (notez les espaces et le ; final) ; ( ) tourne dans un sous-shell (les changements comme cd n'affectent pas le parent). && et || sont des opérateurs de court-circuit — « A && B || C » imite un ternaire mais est bugué si B peut échouer. Employez-les pour des one-liners concis, mais préférez if/else pour des scripts robustes.

linux
# command substitution: use output as argument
files=$(ls *.txt)
today=$(date +%Y-%m-%d)
echo "Today is $today"

# backtick form (legacy, avoid)
files=`ls *.txt`

# arithmetic expansion
result=$(( 5 * 3 ))
count=$(( count + 1 ))

# group commands with { } (runs in current shell)
{ cd /tmp; ls; pwd; } > output.txt

# subshell with ( ) (runs in child process)
(cd /tmp && make clean && make)    # doesn't change your cwd

# sequential execution
cmd1 ; cmd2            # run cmd2 regardless of cmd1
cmd1 && cmd2           # run cmd2 only if cmd1 succeeds
cmd1 || cmd2           # run cmd2 only if cmd1 fails

# background
cmd &                  # run in background
cmd1 & cmd2 &          # both in parallel

# conditional pipeline
grep -q "error" log.txt && echo "found" || echo "not found"

Patterns de pipelines utiles

Ces patterns combinent pipes, redirection et outils de texte en one-liners puissants. Le pattern « sort | uniq -c | sort -rn | head » est l'analyseur de fréquence universel. awk + sort + uniq est la trousse standard d'analyse de logs. La substitution de processus <(sort ...) alimente une entrée triée à join/comm. Citez toujours les caractères spéciaux dans les motifs tr. Ces pipelines incarnent la philosophie Unix : de petits outils combinés pour résoudre des problèmes complexes.

linux
# top 10 largest files
du -ah . | sort -rh | head -10

# find most frequent log entries
cat access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head

# extract and count HTTP status codes
awk '{print $9}' access.log | sort | uniq -c | sort -rn

# find files modified in last 24h, grouped by size
find . -mtime -1 -type f -exec du -h {} + | sort -rh

# unique IPs that hit /admin
grep "/admin" access.log | awk '{print $1}' | sort -u

# word frequency in a text file
tr -s ' ' '\n' < file.txt | sort | uniq -c | sort -rn | head

# join CSV files on first field
join -t, <(sort -t, -k1 file1.csv) <(sort -t, -k1 file2.csv)

# parallel downloads
cat urls.txt | xargs -n 1 -P 4 wget -q

# find which process uses the most memory
ps aux | sort -nk 4 | tail -5

# count lines matching pattern across files
grep -c "ERROR" *.log | awk -F: '{sum+=$2} END {print sum}'

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.