Cours de Commandes Linux avec Exemples

Enchaînés

Ce cours a pour objectif de vous familiariser avec les commandes Linux les plus courantes,
en vous proposant des exemples pratiques et enchaînés pour une meilleure
compréhension.

Introduction aux Commandes Linux

Une commande Linux est un programme ou un utilitaire qui s'exécute sur la ligne de
commande (CLI). Elle permet d'interagir avec le système d'exploitation via du texte et
d'automatiser diverses tâches.
Syntaxe générale d'une commande Linux :
nom_commande [option] [paramètre]
• Nom commande : La règle que vous souhaitez exécuter.
• Option ou flag : Modifie le comportement de la commande (ex: -l , --help ).
• Paramètre ou argument : Spécifie les informations nécessaires à la commande (ex: un
nom de fichier, un chemin).
Important : Toutes les commandes Linux sont sensibles à la casse.

Les Commandes Linux Essentielles

Nous allons explorer les commandes les plus utilisées, en les illustrant par des scénarios
concrets.
1. Commande ls (Lister le contenu)
La commande ls est utilisée pour lister le contenu d'un répertoire (fichiers et sous-
répertoires).
Syntaxe : ls [options] [répertoire_ou_chemin]
Exemples enchaînés :
1. Lister le contenu du répertoire actuel :
ls
(Cela affichera tous les fichiers et dossiers non cachés dans votre répertoire de travail
actuel.)
2. Lister tous les fichiers, y compris les fichiers cachés ( -a ) :
ls -a
(Vous verrez maintenant les fichiers et dossiers qui commencent par un point, comme
.bashrc .)
3. Lister le contenu avec des détails ( -l ) :
ls -l
(Affiche des informations détaillées comme les permissions, le propriétaire, la taille, la
date de modification, etc.)
4. Lister le contenu d'un répertoire spécifique (par exemple, /home ) :
ls /home
(Cela listera les utilisateurs présents sur le système.)
5. Lister le contenu de manière récursive ( -R ) pour voir les sous-dossiers :
ls -R
(Utile pour avoir une vue d'ensemble de l'arborescence des fichiers.)
6. Combiner les options pour une vue détaillée et récursive :
ls -lR
(Affiche tous les détails pour chaque fichier et dossier, y compris ceux des sous-
répertoires.)
2. Commande pwd (Afficher le répertoire de travail)
La commande pwd (Print Working Directory) affiche le chemin complet de votre répertoire
de travail actuel.
Syntaxe : pwd [options]
Exemples enchaînés :
1. Afficher votre répertoire actuel :
pwd
(Si vous êtes dans votre dossier personnel, la sortie sera probablement
/home/votre_nom_utilisateur .)
2. Utiliser pwd après avoir changé de répertoire :
cd /usr/local/bin
pwd
(La sortie devrait maintenant être /usr/local/bin , confirmant votre nouvel
emplacement.)
3. Comprendre les options -L (logique) et -P (physique) avec un lien symbolique :
(Supposons que vous avez un lien symbolique mon_lien qui pointe vers
/chemin/reel/dossier_cible )
mkdir -p /chemin/reel/dossier_cible
ln -s /chemin/reel/dossier_cible mon_lien
cd mon_lien
pwd -L
(Affichera le chemin logique : /home/votre_nom_utilisateur/mon_lien )
pwd -P
(Affichera le chemin physique : /chemin/reel/dossier_cible )
3. Commande cd (Changer de répertoire)
La commande cd (Change Directory) est utilisée pour naviguer entre les répertoires de
votre système Linux.
Syntaxe : cd [chemin_ou_répertoire]
Exemples enchaînés :
1. Aller à votre répertoire personnel :
cd
pwd
(Vous devriez être dans /home/votre_nom_utilisateur .)
 2. Aller à un répertoire spécifique (par exemple, /var/log ) :
cd /var/log
pwd
(Vous êtes maintenant dans le répertoire des journaux système.)
3. Remonter d'un niveau dans l'arborescence ( .. ) :
cd ..
pwd
(Si vous étiez dans /var/log , vous êtes maintenant dans /var .)
4. Retourner au répertoire précédent ( - ) :
cd /etc
pwd
(Vous êtes dans /etc .)
cd -
pwd
(Vous êtes de nouveau dans /var .)
5. Naviguer vers un sous-répertoire :
cd /home/votre_nom_utilisateur
mkdir mon_dossier_test
cd mon_dossier_test
pwd
(Vous êtes maintenant dans /home/votre_nom_utilisateur/mon_dossier_test .)
4. Commande mkdir (Créer un répertoire)
La commande mkdir (Make Directory) permet de créer un ou plusieurs répertoires.
Syntaxe : mkdir [options] nom_répertoire1 nom_répertoire2 ...
Exemples enchaînés :
1. Créer un nouveau répertoire dans le répertoire actuel :
cd
mkdir mon_nouveau_dossier
 ls
(Vous devriez voir mon_nouveau_dossier dans la liste.)
2. Créer plusieurs répertoires en une seule commande :
mkdir dossier1 dossier2 dossier3
ls
( dossier1 , dossier2 , dossier3
sont maintenant créés.)
3. Créer un répertoire avec des sous-répertoires parents manquants ( -p ) :
mkdir -p projets/annee2025/rapports
ls -R projets
(Cela créera projets , annee2025 à l'intérieur de projets , et rapports à l'intérieur de
annee2025 .)
4. Créer un répertoire avec des permissions spécifiques ( -m ) :
mkdir -m 700 dossiers_secrets
ls -ld dossiers_secrets
(Les permissions seront drwx------ , signifiant que seul le propriétaire peut lire, écrire et
exécuter.)
5. Commande rmdir (Supprimer un répertoire vide)
La commande rmdir (Remove Directory) est utilisée pour supprimer des répertoires, mais
uniquement s'ils sont vides.
Syntaxe : rmdir [options] nom_du_répertoire
Exemples enchaînés :
1. Supprimer un répertoire vide :
cd
mkdir dossier_a_supprimer
ls
(Vérifiez que dossier_a_supprimer est bien là.)
rmdir dossier_a_supprimer
ls
(Le dossier a disparu.)
 2. Tenter de supprimer un répertoire non vide (cela échouera) :
mkdir dossier_non_vide
touch dossier_non_vide/[Link]
ls dossier_non_vide
(Confirmez la présence de [Link] .)
rmdir dossier_non_vide
(Vous obtiendrez une erreur car le dossier n'est pas vide.)
3. Supprimer une arborescence de répertoires vides ( -p ) :
mkdir -p parent/enfant/sous_enfant
ls -R parent
(Vérifiez la structure.)
rmdir -p parent/enfant/sous_enfant
ls
( parent devrait avoir disparu, car tous les sous-répertoires ont été supprimés et sont
devenus vides.)
6. Commande rm (Supprimer des fichiers et des répertoires)
La commande rm (Remove) est utilisée pour supprimer des fichiers et des répertoires.
Contrairement à rmdir , elle peut supprimer des répertoires non vides.
Syntaxe : rm [options] fichier1 fichier2 ...
Exemples enchaînés :
1. Créer un fichier et le supprimer :
cd
touch fichier_a_supprimer.txt
ls
(Vérifiez que fichier_a_supprimer.txt est présent.)
rm fichier_a_supprimer.txt
ls
(Le fichier a disparu.)
 2. Supprimer un répertoire non vide de manière récursive ( -r ) :
mkdir -p dossier_a_supprimer/sous_dossier
touch dossier_a_supprimer/fichier_dans_dossier.txt
ls -R dossier_a_supprimer
(Vérifiez la structure.)
rm -r dossier_a_supprimer
ls
(Le dossier et son contenu ont été supprimés.)
3. Supprimer avec confirmation ( -i ) :
touch autre_fichier.txt
rm -i autre_fichier.txt
(Le système vous demandera une confirmation avant de supprimer le fichier. Tapez y
pour confirmer.)
4. Forcer la suppression ( -f ) sans confirmation :
touch fichier_force.txt
rm -f fichier_force.txt
(Le fichier sera supprimé immédiatement sans aucune question.)
7. Commande cp (Copier des fichiers et des répertoires)
La commande cp (Copy) est utilisée pour copier des fichiers et des répertoires d'un
emplacement à un autre.
Syntaxe : cp [options] source destination
Exemples enchaînés :
1. Copier un fichier dans le même répertoire (créer une copie) :
cd
echo "Ceci est le contenu du fichier original." > fichier_original.txt
ls
(Vérifiez la présence de fichier_original.txt .)
cp fichier_original.txt fichier_copie.txt
ls
 (Vous devriez maintenant voir fichier_copie.txt .)
cat fichier_copie.txt
(Vérifiez que le contenu est identique.)
2. Copier un fichier vers un autre répertoire :
mkdir mon_dossier_destination
cp fichier_original.txt mon_dossier_destination/
ls mon_dossier_destination
( fichier_original.txt devrait être dans mon_dossier_destination .)
3. Copier un fichier en le renommant dans le répertoire de destination :
cp fichier_original.txt mon_dossier_destination/nouveau_nom_fichier.txt
ls mon_dossier_destination
( nouveau_nom_fichier.txt devrait être présent.)
4. Copier un répertoire et son contenu de manière récursive ( -R ) :
mkdir -p dossier_source/sous_dossier
echo "Contenu du fichier dans le sous-dossier." > dossier_source/sous_dossier/fichier_interne.txt
ls -R dossier_source
(Vérifiez la structure du dossier source.)
cp -R dossier_source/ dossier_destination_copie/
ls -R dossier_destination_copie
(Le dossier dossier_source et tout son contenu, y compris sous_dossier et
fichier_interne.txt , ont été copiés dans dossier_destination_copie .)
5. Copier avec conservation des attributs ( -a ) :
cp -a fichier_original.txt fichier_original_avec_attributs.txt
ls -l fichier_original.txt fichier_original_avec_attributs.txt
(Comparez les permissions, les dates, etc. Ils devraient être identiques.)
8. Commande mv (Déplacer ou Renommer des fichiers et des
répertoires)
La commande mv (Move) est principalement utilisée pour déplacer des fichiers ou des
répertoires d'un emplacement à un autre. Elle peut également être utilisée pour renommer
des fichiers ou des répertoires.
Syntaxe : mv [options] source destination
Exemples enchaînés :
1. Déplacer un fichier vers un autre répertoire :
cd
echo "Contenu à déplacer." > fichier_a_deplacer.txt
mkdir dossier_cible_mv
ls
(Vérifiez la présence de fichier_a_deplacer.txt et dossier_cible_mv .)
mv fichier_a_deplacer.txt dossier_cible_mv/
ls
( fichier_a_deplacer.txt ne devrait plus être là.)
ls dossier_cible_mv
( fichier_a_deplacer.txt devrait être dans dossier_cible_mv .)
2. Renommer un fichier dans le même répertoire :
cd dossier_cible_mv
ls
(Vérifiez la présence de fichier_a_deplacer.txt .)
mv fichier_a_deplacer.txt nouveau_nom_fichier.txt
ls
( fichier_a_deplacer.txt a été renommé en nouveau_nom_fichier.txt .)
3. Déplacer un fichier et le renommer en même temps :
cd
echo "Autre fichier." > autre_fichier.txt
mkdir nouveau_dossier_mv
mv autre_fichier.txt nouveau_dossier_mv/fichier_renomme_et_deplace.txt
ls
( autre_fichier.txt ne devrait plus être là.)
ls nouveau_dossier_mv
( fichier_renomme_et_deplace.txt devrait être dans nouveau_dossier_mv .)
4. Déplacer un répertoire :
cd
 mkdir -p dossier_source_mv/sous_dossier
echo "Fichier dans le dossier source." > dossier_source_mv/fichier_source.txt
mkdir dossier_destination_mv
mv dossier_source_mv/ dossier_destination_mv/
ls
( dossier_source_mv ne devrait plus être là.)
ls -R dossier_destination_mv
( dossier_source_mv et son contenu devraient être dans dossier_destination_mv .)
9. Commande touch (Créer un fichier vide ou mettre à jour la date)
La commande touch est utilisée pour créer un nouveau fichier vide ou pour mettre à jour la
date et l'heure de dernier accès et de dernière modification d'un fichier existant.
Syntaxe : touch [options] [nom_chemin_et_fichier]
Exemples enchaînés :
1. Créer un nouveau fichier vide :
cd
touch mon_nouveau_fichier.txt
ls -l mon_nouveau_fichier.txt
(Vous verrez mon_nouveau_fichier.txt avec la date et l'heure actuelles.)
2. Mettre à jour la date et l'heure d'un fichier existant :
sleep 2
touch mon_nouveau_fichier.txt
ls -l mon_nouveau_fichier.txt
(La date et l'heure de modification de mon_nouveau_fichier.txt devraient avoir été mises
à jour.)
3. Créer un fichier dans un répertoire spécifique :
mkdir -p documents/rapports
touch documents/rapports/rapport_final.docx
ls documents/rapports/
( rapport_final.docx est maintenant créé dans le sous-répertoire.)
10. Commande file (Déterminer le type de fichier)
La commande file est utilisée pour déterminer le type d'un fichier. Elle peut identifier le
type de données qu'un fichier contient (texte, image, exécutable, archive, etc.).
Syntaxe : file [nom_du_fichier]
Exemples enchaînés :
1. Vérifier le type d'un fichier texte :
cd
echo "Bonjour le monde" > mon_fichier_texte.txt
file mon_fichier_texte.txt
(La sortie devrait indiquer quelque chose comme mon_fichier_texte.txt: ASCII text .)
2. Vérifier le type d'un répertoire :
mkdir mon_dossier_test_file
file mon_dossier_test_file
(La sortie devrait être mon_dossier_test_file: directory .)
3. Vérifier le type d'un exécutable système :
file /bin/bash
(La sortie montrera des informations sur l'exécutable, par exemple ELF 64-bit LSB shared
object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/[Link].2, for
GNU/Linux 3.2.0, BuildID[sha1]=..., stripped .)
4. Vérifier le type d'un lien symbolique ( -k pour plus de détails) :
ln -s mon_fichier_texte.txt mon_lien_texte
file mon_lien_texte
(La sortie indiquera que c'est un lien symbolique vers mon_fichier_texte.txt .)
file -k mon_lien_texte
(Avec -k , elle affichera également le type du fichier cible du lien symbolique.)
11. Commandes zip et unzip (Compresser et Décompresser des
fichiers)
Les commandes zip et unzip sont utilisées pour compresser des fichiers dans une archive
ZIP et pour extraire des fichiers d'une archive ZIP, respectivement.
Syntaxe zip : zip [options] nom_fichier_zip fichier1 fichier2 ...
Syntaxe unzip : unzip [options] nom_fichier_zip
Exemples enchaînés :
1. Créer des fichiers à compresser :
cd
echo "Contenu du fichier 1." > [Link]
echo "Contenu du fichier 2." > [Link]
ls
(Vérifiez la présence de [Link] et [Link] .)
2. Compresser plusieurs fichiers dans une archive ZIP :
zip mes_fichiers.zip [Link] [Link]
ls
(Vous devriez voir mes_fichiers.zip .)
3. Vérifier le contenu de l'archive ZIP :
unzip -l mes_fichiers.zip
(Affiche la liste des fichiers contenus dans l'archive sans les extraire.)
4. Supprimer les fichiers originaux pour simuler une extraction :
rm [Link] [Link]
ls
(Les fichiers originaux ont disparu.)
5. Extraire les fichiers de l'archive ZIP :
unzip mes_fichiers.zip
ls
( [Link] et [Link]
sont de nouveau présents.)
6. Compresser un répertoire entier ( -r ) :
mkdir dossier_a_zipper
echo "Fichier dans le dossier." > dossier_a_zipper/fichier_interne.txt
 zip -r archive_dossier.zip dossier_a_zipper
ls
( archive_dossier.zip est créé.)
7. Extraire l'archive d'un dossier dans un répertoire spécifique ( -d ) :
mkdir extraction_dossier
unzip archive_dossier.zip -d extraction_dossier
ls extraction_dossier/dossier_a_zipper
(Le contenu du dossier zippé est maintenant dans extraction_dossier .)
12. Commande tar (Archiver des fichiers)
La commande tar (Tape Archive) est utilisée pour regrouper plusieurs fichiers ou
répertoires dans une seule archive. Elle est souvent utilisée en combinaison avec des outils
de compression comme gzip ou bzip2 .
Syntaxe : tar [options] nom_fichier_tar fichier1 fichier2 ...
Exemples enchaînés :
1. Créer des fichiers et un répertoire pour l'archivage :
cd
echo "Ligne 1" > fichier_tar_1.txt
echo "Ligne 2" > fichier_tar_2.txt
mkdir dossier_tar
echo "Fichier dans le dossier tar." > dossier_tar/fichier_interne_tar.txt
ls -R
(Vérifiez la présence des fichiers et du dossier.)
2. Créer une archive ( .tar ) sans compression ( -c pour créer, -f pour spécifier le
nom de l'archive) :
tar -cf mon_archive.tar fichier_tar_1.txt fichier_tar_2.txt dossier_tar
ls
(Vous devriez voir mon_archive.tar .)
3. Lister le contenu d'une archive ( -t ) :
tar -tf mon_archive.tar
 (Affiche la liste des fichiers et répertoires contenus dans l'archive.)
4. Extraire le contenu d'une archive ( -x ) :
mkdir extraction_tar
mv mon_archive.tar extraction_tar/
cd extraction_tar
tar -xf mon_archive.tar
ls -R
(Les fichiers et le dossier devraient être extraits dans le répertoire courant.)
cd ..
5. Créer une archive compressée avec gzip ( .[Link] ou .tgz ) :
tar -czf mon_archive_compressee.[Link] fichier_tar_1.txt fichier_tar_2.txt dossier_tar
ls
(Vous devriez voir mon_archive_compressee.[Link] .)
6. Extraire une archive compressée avec gzip :
mkdir extraction_tar_gz
mv mon_archive_compressee.[Link] extraction_tar_gz/
cd extraction_tar_gz
tar -xzf mon_archive_compressee.[Link]
ls -R
(Le contenu est extrait.)
cd ..
7. Créer une archive compressée avec bzip2 ( .tar.bz2 ou .tbz2 ) :
tar -cjf mon_archive_bzip2.tar.bz2 fichier_tar_1.txt fichier_tar_2.txt dossier_tar
ls
(Vous devriez voir mon_archive_bzip2.tar.bz2 .)
8. Extraire une archive compressée avec bzip2 :
mkdir extraction_tar_bz2
mv mon_archive_bzip2.tar.bz2 extraction_tar_bz2/
cd extraction_tar_bz2
tar -xjf mon_archive_bzip2.tar.bz2
 ls -R
(Le contenu est extrait.)
cd ..

14. Commande cat (Concaténer et Afficher des fichiers)

La commande cat (concatenate) est polyvalente. Son usage le plus simple est d'afficher le
contenu d'un fichier. Elle peut aussi être utilisée pour créer de nouveaux fichiers ou pour
combiner le contenu de plusieurs fichiers.
Syntaxe : cat [options] nom_du_fichier
Exemples enchaînés :
1. Afficher le contenu d'un fichier :
cd
echo "Première ligne." > fichier_cat_1.txt
echo "Deuxième ligne." > fichier_cat_2.txt
cat fichier_cat_1.txt
(Affiche : Première ligne. )
2. Afficher le contenu de plusieurs fichiers à la suite :
cat fichier_cat_1.txt fichier_cat_2.txt
(Affiche : Première ligne. puis Deuxième ligne.
sur la ligne suivante.)
3. Créer un nouveau fichier et y écrire du texte (avec redirection > ) :
cat > nouveau_fichier_cat.txt
(Le curseur attendra votre saisie. Tapez Ceci est le contenu du nouveau fichier. puis
appuyez sur Entrée , puis Ctrl+D pour sauvegarder et quitter.)
cat nouveau_fichier_cat.txt
(Vérifiez le contenu.)
4. Combiner le contenu de plusieurs fichiers dans un nouveau fichier :
cat fichier_cat_1.txt fichier_cat_2.txt > fichiers_combines.txt
cat fichiers_combines.txt
(Le nouveau fichier fichiers_combines.txt contient le texte des deux fichiers précédents.)
 5. Ajouter du contenu à un fichier existant (avec redirection >> ) :
echo "Troisième ligne." >> fichier_cat_1.txt
cat fichier_cat_1.txt
( fichier_cat_1.txt contient maintenant Première ligne. et Troisième ligne. .)
15. Commande grep (Rechercher des motifs dans des fichiers)
La commande grep (Global Regular Expression Print) permet de rechercher des lignes
spécifiques dans un fichier qui correspondent à un motif (expression régulière ou mot-clé).
Syntaxe : grep [options] mot-clé [fichier]
Exemples enchaînés :
1. Rechercher un mot-clé simple dans un fichier :
cd
echo -e "pomme\nbanane\norange\npoire\npomme" > [Link]
cat [Link]
(Vérifiez le contenu du fichier.)
grep "pomme" [Link]
(Affiche les lignes contenant "pomme".)
2. Rechercher un mot-clé en ignorant la casse ( -i ) :
echo "Apple" >> [Link]
grep -i "apple" [Link]
(Affiche les lignes contenant "pomme" ou "Apple".)
3. Afficher les lignes qui NE contiennent PAS le mot-clé ( -v ) :
grep -v "pomme" [Link]
(Affiche toutes les lignes sauf celles contenant "pomme".)
4. Compter le nombre d'occurrences du mot-clé ( -c ) :
grep -c "pomme" [Link]
(Affiche le nombre de lignes contenant "pomme".)
5. Rechercher dans plusieurs fichiers :
echo "fruit rouge" > couleur_fruits.txt
 grep "pomme" [Link] couleur_fruits.txt
(Affiche les lignes correspondantes dans les deux fichiers, en indiquant le nom du
fichier.)
6. Rechercher un mot-clé dans la sortie d'une autre commande (avec un pipe | ) :
ls -l | grep "txt"
(Affiche uniquement les lignes de la sortie de ls -l qui contiennent "txt", c'est-à-dire les
fichiers texte.)
7. Rechercher récursivement dans les répertoires ( -r ) :
mkdir -p recettes/fruits
echo "Recette de tarte aux pommes" > recettes/fruits/[Link]
grep -r "pommes" recettes/
(Trouve le mot "pommes" dans le fichier [Link] à l'intérieur du répertoire recettes .)
16. Commande sed (Éditeur de flux pour filtrer et transformer le texte)
La commande sed (Stream EDitor) est un puissant éditeur de flux qui permet de filtrer et
de transformer le texte. Elle est couramment utilisée pour rechercher et remplacer des
motifs dans les fichiers.
Syntaxe de base : sed [options] 'sous-commande/motif/remplacement/' fichier_entrée
Exemples enchaînés :
1. Préparer un fichier pour les exemples sed :
cd
echo -e "Le chat est noir.\nLe chien est blanc.\nLe cheval est marron." > [Link]
cat [Link]
(Vérifiez le contenu.)
2. Remplacer la première occurrence d'un motif sur chaque ligne
( s/motif/remplacement/ ) :
sed 's/Le/Un/' [Link]
(Remplace "Le" par "Un" uniquement la première fois qu'il apparaît sur chaque ligne.)
 3. Remplacer toutes les occurrences d'un motif sur chaque ligne
( s/motif/remplacement/g ) :
echo "Le chat et le chien sont des animaux." > [Link]
sed 's/Le/Un/g' [Link]
(Remplace toutes les occurrences de "Le" par "Un" sur la ligne.)
4. Remplacer un motif et sauvegarder les modifications dans un nouveau fichier :
sed 's/noir/gris/' [Link] > animaux_modifies.txt
cat animaux_modifies.txt
(Le fichier animaux_modifies.txt contient maintenant "Le chat est gris.")
5. Supprimer les lignes contenant un motif ( /motif/d ) :
sed '/chien/d' [Link]
(Affiche le contenu d' [Link]
sans la ligne contenant "chien".)
6. Insérer du texte avant chaque ligne ( i ) :
sed '1i\Voici la liste des animaux :\n' [Link]
(Insère une ligne au début du fichier. Notez le \n pour le saut de ligne et le \ avant le
i .)
7. Exécuter plusieurs commandes sed en une seule fois ( -e ) :
sed -e 's/chat/félin/' -e 's/chien/canin/' [Link]
(Remplace "chat" par "félin" et "chien" par "canin".)
17. Commande head (Afficher le début d'un fichier)
La commande head permet d'afficher les premières lignes d'un fichier. Par défaut, elle
affiche les 10 premières lignes.
Syntaxe : head [options] nom_de_fichier
Exemples enchaînés :
1. Préparer un fichier avec plusieurs lignes :
cd
seq 1 20 > [Link]
 cat [Link]
(Ce fichier contient les nombres de 1 à 20, chacun sur une nouvelle ligne.)
2. Afficher les 10 premières lignes (comportement par défaut) :
head [Link]
(Affiche les nombres de 1 à 10.)
3. Afficher un nombre spécifique de lignes ( -n ) :
head -n 5 [Link]
(Affiche les 5 premières lignes : 1 à 5.)
4. Afficher les premières octets ( -c ) :
head -c 10 [Link]
(Affiche les 10 premiers caractères/octets du fichier. Le résultat peut sembler étrange
car il coupe au milieu des nombres et des sauts de ligne.)
5. Utiliser head avec la sortie d'une autre commande (pipe | ) :
ls -l /etc | head -n 3
(Affiche les 3 premières lignes de la liste détaillée des fichiers dans le répertoire /etc .)
18. Commande tail (Afficher la fin d'un fichier)
La commande tail est l'inverse de head ; elle permet d'afficher les dernières lignes d'un
fichier. Par défaut, elle affiche les 10 dernières lignes.
Syntaxe : tail [options] nom_fichier
Exemples enchaînés :
1. Utiliser le fichier [Link] créé précédemment :
cat [Link]
(Rappel : ce fichier contient les nombres de 1 à 20.)
2. Afficher les 10 dernières lignes (comportement par défaut) :
tail [Link]
(Affiche les nombres de 11 à 20.)
 3. Afficher un nombre spécifique de lignes ( -n ) :
tail -n 5 [Link]
(Affiche les 5 dernières lignes : 16 à 20.)
4. Afficher les dernières octets ( -c ) :
tail -c 10 [Link]
(Affiche les 10 derniers caractères/octets du fichier.)
5. Utiliser tail avec la sortie d'une autre commande (pipe | ) :
ping -c 10 [Link] | tail -n 5
(Envoie 10 paquets ping à [Link] et affiche les 5 dernières lignes de la sortie, souvent
les statistiques de résumé.)
6. Surveiller un fichier en temps réel ( -f ) :
(Ouvrez un autre terminal ou utilisez Ctrl+Z pour mettre cette commande en arrière-
plan, puis bg pour la relancer en arrière-plan.)
tail -f /var/log/syslog
(Cette commande affichera les nouvelles lignes ajoutées au fichier syslog en temps
réel. Utile pour le débogage. Pour arrêter, utilisez Ctrl+C .)
19. Commande awk (Traitement de texte avancé)
La commande awk est un langage de programmation puissant conçu pour le traitement
de texte et l'analyse de données. Elle permet de rechercher des motifs (expressions
régulières) dans un fichier et d'effectuer des actions complexes sur les lignes
correspondantes.
Syntaxe de base : awk
des exemples enchaînés pour chaque commande afin de les rendre plus interactifs et
compréhensibles. /motif regex/{action}' fichier_entré[Link]`
Exemples enchaînés :
1. Préparer un fichier de données :
cd
echo -e "Nom:Ali[Link]Paris\nNom:Bo[Link]Lyon\nNom:Charli[Link]Marseille" > [Link]
 cat [Link]
(Ce fichier contient des données séparées par des deux-points.)
2. Afficher le contenu d'un fichier avec awk (équivalent à cat ) :
`awk
(Affiche chaque ligne du fichier.)
3. Afficher un champ spécifique (par défaut, les champs sont séparés par des espaces)
:
`awk
(Affiche le premier champ de chaque ligne, ici "Nom".)
4. Spécifier un délimiteur de champ ( -F ) et afficher des champs :
`awk -F
(Affiche le deuxième champ (le nom) et le troisième champ (l'âge) de chaque ligne,
séparés par un espace.)
5. Filtrer les lignes basées sur un motif et afficher des champs :
`awk -F
(Affiche le nom et l'âge des personnes dont l'âge est supérieur à 25.)
6. Calculer la somme d'une colonne :
`awk -F
(Calcule et affiche la somme des âges.)
7. Utiliser les blocs BEGIN et END :
awk -F
*( BEGIN s'exécute avant le traitement du fichier, END` après. Ici, on affiche un en-tête, puis
les noms et âges, puis un pied de page.)*
20. Commande sort (Trier des lignes de texte)
La commande sort permet de trier les lignes d'un fichier texte ou de l'entrée standard. Par
défaut, le tri est alphabétique et sensible à la casse.
Syntaxe : sort [options] [nom_du_fichier]
Exemples enchaînés :
 1. Préparer un fichier pour le tri :
cd
echo -e "banane\npomme\norange\nkiwi\nPomme" > fruits_sort.txt
cat fruits_sort.txt
(Vérifiez le contenu non trié.)
2. Trier un fichier alphabétiquement (par défaut) :
sort fruits_sort.txt
(Affiche : Pomme , banane , kiwi , orange , pomme . Notez que Pomme (majuscule)
vient avant banane (minuscule) en raison du tri ASCII.)
3. Trier en ignorant la casse ( -f ) :
sort -f fruits_sort.txt
(Affiche : banane , kiwi , orange , Pomme , pomme . Pomme et pomme sont
maintenant traités de la même manière.)
4. Trier en ordre inverse ( -r ) :
sort -r fruits_sort.txt
(Affiche : pomme , orange , kiwi , banane , Pomme .)
5. Trier numériquement ( -n ) :
echo -e "10\n2\n100\n5" > nombres_sort.txt
sort -n nombres_sort.txt
(Affiche : 2 , 5 , 10 , 100 . Sans -n , le tri serait alphabétique : 10 , 100 , 2 , 5 .)
6. Trier la sortie d'une autre commande (pipe | ) :
ls -l | sort -k 5 -n -r
(Liste les fichiers avec des détails, puis trie la sortie par la 5ème colonne (taille du
fichier) numériquement et en ordre décroissant. -k 5 spécifie la 5ème colonne, -n
pour numérique, -r pour inverse.)
21. Commande cut (Extraire des sections de lignes)
La commande cut permet de sélectionner des sections spécifiques de lignes d'un fichier et
de les afficher. Elle est utile pour extraire des colonnes de données.
Syntaxe : cut options fichier
Options courantes :
• -f : sélectionne un champ de ligne spécifique.
• -b : coupe la ligne d'une taille d'octet spécifiée.
• -c : sectionne la ligne en utilisant le caractère spécifié.
• -d : sépare les lignes en fonction des délimiteurs.
Exemples enchaînés :
1. Préparer un fichier de données délimité par des virgules :
cd
echo -e
"Nom,Prenom,Age,Ville\nAlice,Dupont,25,Paris\nBob,Martin,30,Lyon\nCharlie,Durand,22,Marseille" >
[Link]
cat [Link]
(Vérifiez le contenu.)
2. Extraire le premier champ (Nom) en utilisant la virgule comme délimiteur ( -d, -f1 )
:
cut -d',' -f1 [Link]
(Affiche : Nom , Alice , Bob , Charlie .)
3. Extraire plusieurs champs (Nom et Ville) :
cut -d',' -f1,4 [Link]
(Affiche : Nom,Ville , Alice,Paris , Bob,Lyon , Charlie,Marseille .)
4. Extraire une plage de champs (Prenom à Ville) :
cut -d',' -f2-4 [Link]
(Affiche : Prenom,Age,Ville , Dupont,25,Paris , etc.)
5. Extraire des caractères spécifiques ( -c ) :
echo "abcdefghij" > [Link]
cut -c1-5 [Link]
(Affiche : abcde .)
 cut -c1,3,5 [Link]
(Affiche : ace .)
6. Utiliser cut avec la sortie d'une autre commande (pipe | ) :
ls -l | cut -d' ' -f1,9-
(Liste les fichiers avec des détails, puis extrait les permissions (1er champ) et le nom du
fichier (à partir du 9ème champ) en utilisant l'espace comme délimiteur. Notez que 9-
signifie du 9ème champ jusqu'à la fin de la ligne.)
22. Commande diff (Comparer des fichiers)
La commande diff compare deux fichiers ligne par ligne et affiche les différences entre eux.
Elle est très utile pour suivre les modifications apportées aux fichiers de configuration ou au
code source.
Syntaxe : diff nom_du_fichier1 nom_du_fichier2
Exemples enchaînés :
1. Préparer deux fichiers avec des différences :
cd
echo -e "Ligne 1\nLigne 2\nLigne 3" > fichier_diff_1.txt
echo -e "Ligne 1\nLigne modifiée\nNouvelle ligne\nLigne 3" > fichier_diff_2.txt
cat fichier_diff_1.txt
cat fichier_diff_2.txt
(Vérifiez le contenu des deux fichiers.)
2. Comparer les deux fichiers :
diff fichier_diff_1.txt fichier_diff_2.txt
(La sortie montrera les lignes qui diffèrent, avec des symboles indiquant les ajouts ( > ),
les suppressions ( < ) et les modifications ( c ).)
3. Afficher les différences dans un format contextuel ( -c ) :
diff -c fichier_diff_1.txt fichier_diff_2.txt
(Ce format affiche quelques lignes de contexte autour des différences, ce qui facilite la
compréhension des changements.)
 4. Ignorer la casse lors de la comparaison ( -i ) :
echo -e "TEST" > fichier_diff_3.txt
echo -e "test" > fichier_diff_4.txt
diff fichier_diff_3.txt fichier_diff_4.txt
(Montrera une différence.)
diff -i fichier_diff_3.txt fichier_diff_4.txt
(Ne montrera aucune différence car la casse est ignorée.)
23. Commande tee (Afficher et Enregistrer la sortie)
La commande tee permet d'afficher la sortie d'une commande dans le terminal tout en
l'enregistrant simultanément dans un fichier. Elle est utile pour capturer des données pour
une analyse ultérieure ou pour le débogage.
Syntaxe : commande | tee [options] nom_de_fichier
Exemples enchaînés :
1. Afficher la sortie d'une commande et l'enregistrer dans un nouveau fichier :
cd
echo "Ceci est une ligne de test." | tee sortie_tee.txt
(La ligne "Ceci est une ligne de test." s'affiche dans le terminal, et un nouveau fichier
sortie_tee.txt est créé avec ce contenu.)
cat sortie_tee.txt
(Vérifiez le contenu du fichier.)
2. Ajouter la sortie à un fichier existant ( -a ) :
echo "Ceci est une deuxième ligne." | tee -a sortie_tee.txt
(La deuxième ligne s'affiche dans le terminal et est ajoutée à la fin de sortie_tee.txt .)
cat sortie_tee.txt
(Le fichier contient maintenant les deux lignes.)
3. Utiliser tee avec une commande système :
ls -l | tee liste_fichiers.txt
(La liste détaillée des fichiers s'affiche dans le terminal et est également enregistrée
dans liste_fichiers.txt .)
 cat liste_fichiers.txt
(Vérifiez le contenu du fichier.)
4. Rediriger la sortie vers plusieurs fichiers :
echo "Message important" | tee [Link] [Link]
(Le message est affiché et enregistré dans les deux fichiers.)
cat [Link]
cat [Link]
(Vérifiez le contenu de chaque fichier.)
24. Commande locate (Rechercher des fichiers dans une base de
données)
La commande locate est utilisée pour rechercher des fichiers par leur nom dans une base
de données pré-indexée du système. Elle est très rapide car elle ne parcourt pas le système
de fichiers en temps réel.
Syntaxe : locate [options] [mot-clé]
Exemples enchaînés :
1. Mettre à jour la base de données locate (nécessite sudo ) :
sudo updatedb
(Cette commande met à jour l'index des fichiers. Il est important de la lancer après avoir
créé de nouveaux fichiers pour que locate puisse les trouver.)
2. Rechercher un fichier simple :
cd
touch fichier_locate_test.txt
sudo updatedb
locate fichier_locate_test.txt
(Affiche le chemin complet du fichier fichier_locate_test.txt .)
3. Rechercher des fichiers en ignorant la casse ( -i ) :
locate -i "[Link]"
(Trouvera [Link] , [Link] , etc.)
 4. Limiter le nombre de résultats ( -n ) :
locate -n 5 "*.conf"
(Affiche les 5 premiers fichiers de configuration trouvés.)
5. Rechercher des fichiers qui existent réellement ( -e ) :
(Parfois, la base de données peut contenir des entrées pour des fichiers qui ont été
supprimés depuis la dernière updatedb .)
locate -e fichier_locate_test.txt
(Vérifie que le fichier existe toujours sur le système de fichiers.)
25. Commande find (Rechercher des fichiers en temps réel)
Contrairement à locate , la commande find parcourt le système de fichiers en temps réel
pour trouver des fichiers et des répertoires qui correspondent à des critères spécifiés. Elle
est plus lente que locate mais plus puissante et à jour.
Syntaxe : find [chemin] [options] expression
Exemples enchaînés :
1. Rechercher un fichier par son nom dans le répertoire actuel :
cd
touch fichier_find_test.txt
find . -name "fichier_find_test.txt"
(Le . indique le répertoire actuel. Affiche ./fichier_find_test.txt .)
2. Rechercher un fichier par son nom en ignorant la casse ( -iname ) :
find . -iname "Fichier_Find_Test.txt"
(Trouvera fichier_find_test.txt même si la casse est différente.)
3. Rechercher des fichiers par type ( -type ) :
• f pour fichier
• d pour répertoire
mkdir dossier_find_test
find . -type d -name "dossier_find_test"
(Trouve le répertoire dossier_find_test .)
 find . -type f -name "*.txt"
(Trouve tous les fichiers se terminant par .txt dans le répertoire actuel et ses sous-
répertoires.)
4. Rechercher des fichiers par taille ( -size ) :
• c pour octets
• k pour kilo-octets
• M pour méga-octets
echo "Contenu" > petit_fichier.txt
echo "" > grand_fichier.txt
head -c 1M /dev/urandom > grand_fichier.txt
find . -size +1k
(Trouve les fichiers de plus de 1 kilo-octet.)
find . -size -1k
(Trouve les fichiers de moins de 1 kilo-octet.)
5. Rechercher des fichiers modifiés dans les dernières N minutes ( -mmin ) ou N jours
( -mtime ) :
find . -mmin -5
(Trouve les fichiers modifiés dans les 5 dernières minutes.)
find . -mtime -1
(Trouve les fichiers modifiés dans les dernières 24 heures.)
6. Exécuter une commande sur les fichiers trouvés ( -exec ) :
find . -name "*.txt" -exec rm {} \;
(Trouve tous les fichiers .txt et les supprime. {} est un placeholder pour le nom du
fichier trouvé, et \; marque la fin de la commande exec .)
26. Commande sudo (Exécuter une commande en tant que
superutilisateur)
La commande sudo (superuser do) permet à un utilisateur autorisé d'exécuter une
commande en tant que superutilisateur (root) ou un autre utilisateur, sans avoir à se
connecter directement en tant que root. C'est un moyen sécurisé d'accorder des privilèges
administratifs.
Syntaxe : sudo [options] votre_commande
Exemples enchaînés :
1. Tenter une action nécessitant des privilèges sans sudo (cela échouera) :
cd /root
(Vous obtiendrez une erreur de permission car /root est le répertoire personnel de
l'utilisateur root.)
2. Accéder à un répertoire protégé avec sudo :
sudo ls /root
(Après avoir entré votre mot de passe utilisateur, la commande ls sera exécutée avec
les privilèges root, vous permettant de voir le contenu de /root .)
3. Installer un paquet (nécessite sudo ) :
sudo apt update
(Met à jour la liste des paquets disponibles. Vous devrez entrer votre mot de passe.)
sudo apt install htop
(Installe l'outil htop si ce n'est pas déjà fait. sudo est nécessaire pour modifier les
fichiers système.)
4. Éditer un fichier système avec sudo :
sudo nano /etc/hosts
(Ouvre le fichier /etc/hostsavec l'éditeur nano en tant que root, vous permettant de le
modifier. N'oubliez pas de sauvegarder et de quitter ( Ctrl+X , Y , Entrée ).)
27. Commandes su et whoami (Changer d'utilisateur et Vérifier
l'utilisateur actuel)
La commande su (substitute user) permet de changer d'utilisateur dans la session de
terminal. La commande whoami (who am I) affiche le nom de l'utilisateur effectif actuel.
Syntaxe su : su [options] [nom_d'utilisateur]
Syntaxe whoami : whoami
Exemples enchaînés :
1. Vérifier l'utilisateur actuel :
whoami
(Affiche votre nom d'utilisateur actuel.)
2. Passer à l'utilisateur root :
su -
(Le tiret - simule une connexion complète, chargeant l'environnement de l'utilisateur
root. Vous serez invité à entrer le mot de passe de root.)
whoami
(Devrait afficher root .)
exit
(Pour revenir à votre utilisateur précédent.)
3. Passer à un autre utilisateur spécifique :
(Supposons qu'il existe un utilisateur testuser sur votre système.)
su testuser
(Vous serez invité à entrer le mot de passe de testuser .)
whoami
(Devrait afficher testuser .)
exit
(Pour revenir à votre utilisateur précédent.)
4. Exécuter une commande en tant qu'un autre utilisateur sans changer de session :
su -c "ls /home/testuser" testuser
(Exécute la commande ls /home/testuser en tant que testuser sans changer de session.
Vous serez invité à entrer le mot de passe de testuser .)
28. Commande chmod (Changer les permissions de fichiers)
La commande chmod (change mode) permet de modifier les permissions d'accès aux
fichiers et aux répertoires. Sous Linux, il existe trois types de permissions (lecture r ,
écriture w , exécution x ) pour trois catégories d'utilisateurs (propriétaire u , groupe g ,
autres o ).
Syntaxe : chmod [options] [permissions] [fichier_ou_répertoire]
Les permissions peuvent être spécifiées de deux manières :
• Symbolique : u/g/o/a (utilisateur/groupe/autres/tous) +/-/= (ajouter/retirer/définir)
r/w/x (lecture/écriture/exécution)
• Numérique (octale) : Une combinaison de chiffres où r=4 , w=2 , x=1 . La somme de
ces chiffres donne la permission pour chaque catégorie (propriétaire, groupe, autres).
• 7 (rwx) = 4+2+1
• 6 (rw-) = 4+2+0
• 5 (r-x) = 4+0+1
• 4 (r--) = 4+0+0
• 0 (---) = 0+0+0
Exemples enchaînés :
1. Préparer un fichier pour les permissions :
cd
touch mon_fichier_permissions.txt
ls -l mon_fichier_permissions.txt
(Notez les permissions actuelles, par exemple -rw-rw-r-- .)
2. Ajouter la permission d'exécution au propriétaire (symbolique) :
chmod u+x mon_fichier_permissions.txt
ls -l mon_fichier_permissions.txt
(Les permissions devraient maintenant inclure x pour le propriétaire, par exemple -
rwxr--r-- .)
3. Retirer la permission d'écriture pour le groupe (symbolique) :
chmod g-w mon_fichier_permissions.txt
ls -l mon_fichier_permissions.txt
(Les permissions devraient être, par exemple, -rwxr-xr-- .)
 4. Définir des permissions spécifiques pour tous (numérique) :
chmod 755 mon_fichier_permissions.txt
ls -l mon_fichier_permissions.txt
(Permissions : rwxr-xr-x - propriétaire a tout, groupe et autres ont lecture et exécution.)
5. Définir des permissions pour un répertoire (numérique) :
mkdir mon_dossier_permissions
chmod 700 mon_dossier_permissions
ls -ld mon_dossier_permissions
(Permissions : drwx------ - seul le propriétaire peut accéder au dossier.)
6. Changer les permissions de manière récursive ( -R ) pour un répertoire et son
contenu :
echo "Contenu" > mon_dossier_permissions/fichier_interne.txt
chmod -R 644 mon_dossier_permissions
ls -l mon_dossier_permissions/fichier_interne.txt
ls -ld mon_dossier_permissions
(Le fichier interne et le dossier auront maintenant les permissions rw-r--r-- et rwxr-xr-x
respectivement, car chmod -R applique les permissions aux fichiers et aux répertoires
différemment pour le bit d'exécution.)
29. Commande chown (Changer le propriétaire et le groupe d'un
fichier)
La commande chown (change owner) permet de modifier le propriétaire et/ou le groupe
d'un fichier, d'un répertoire ou d'un lien symbolique. Cela nécessite généralement des
privilèges de superutilisateur ( sudo ).
Syntaxe : chown [options] nouveau_propriétaire[:nouveau_groupe] fichier1 fichier2 ...
Exemples enchaînés :
1. Préparer un fichier pour changer de propriétaire :
cd
touch fichier_chown.txt
 ls -l fichier_chown.txt
(Notez le propriétaire et le groupe actuels, par exemple votre_utilisateur votre_groupe .)
2. Changer le propriétaire d'un fichier (nécessite sudo ) :
(Supposons que vous avez un utilisateur testuser sur votre système. Si non, créez-en
un avec sudo adduser testuser .)
sudo chown testuser fichier_chown.txt
ls -l fichier_chown.txt
(Le propriétaire devrait maintenant être testuser .)
3. Changer le groupe d'un fichier (nécessite sudo ) :
(Supposons que vous avez un groupe testgroup sur votre système. Si non, créez-en un
avec sudo addgroup testgroup .)
sudo chown :testgroup fichier_chown.txt
ls -l fichier_chown.txt
(Le groupe devrait maintenant être testgroup . Le propriétaire reste inchangé.)
4. Changer le propriétaire ET le groupe d'un fichier (nécessite sudo ) :
sudo chown votre_utilisateur:votre_groupe fichier_chown.txt
ls -l fichier_chown.txt
(Le propriétaire et le groupe sont revenus à votre utilisateur et groupe par défaut.)
5. Changer le propriétaire et le groupe d'un répertoire et de son contenu de manière
récursive ( -R ) :
mkdir -p dossier_chown/sous_dossier
touch dossier_chown/fichier_interne_chown.txt
ls -lR dossier_chown
(Vérifiez les propriétaires et groupes actuels.)
sudo chown -R testuser:testgroup dossier_chown
ls -lR dossier_chown
(Le propriétaire et le groupe de dossier_chown et de tous ses contenus devraient
maintenant être testuser et testgroup .)
30. Commandes useradd , passwd et userdel (Gestion des utilisateurs)
Ces commandes sont utilisées pour gérer les comptes utilisateurs sur un système Linux.
Elles nécessitent des privilèges de superutilisateur ( sudo ).
• useradd : Crée un nouveau compte utilisateur.
• passwd : Définit ou modifie le mot de passe d'un utilisateur.
• userdel : Supprime un compte utilisateur.
Syntaxe useradd : useradd [options] nouveau_nom_utilisateur
Syntaxe passwd : passwd nom_utilisateur
Syntaxe userdel : userdel [options] nom_utilisateur
Exemples enchaînés :
1. Créer un nouvel utilisateur ( useradd ) :
sudo useradd nouvel_utilisateur
(Cette commande crée l'utilisateur, mais sans répertoire personnel ni mot de passe par
défaut.)
ls /home
(Vous remarquerez que nouvel_utilisateur n'a pas encore de répertoire personnel.)
2. Définir un mot de passe pour le nouvel utilisateur ( passwd ) :
sudo passwd nouvel_utilisateur
(Le système vous demandera de saisir et de confirmer le nouveau mot de passe pour
nouvel_utilisateur .)
su - nouvel_utilisateur
(Essayez de vous connecter en tant que nouvel_utilisateur avec le mot de passe que
vous venez de définir. Vous devriez être dans /home/nouvel_utilisateur si le répertoire a
été créé automatiquement par votre distribution, sinon vous serez dans / .)
exit
(Pour revenir à votre utilisateur précédent.)
3. Créer un utilisateur avec un répertoire personnel et un shell par défaut ( useradd -m
-s /bin/bash ) :
sudo useradd -m -s /bin/bash autre_utilisateur
ls /home
 (Vous devriez voir autre_utilisateur dans la liste des répertoires personnels.)
sudo passwd autre_utilisateur
(Définissez un mot de passe pour autre_utilisateur .)
4. Supprimer un utilisateur en conservant son répertoire personnel ( userdel ) :
sudo userdel nouvel_utilisateur
ls /home
(L'utilisateur nouvel_utilisateur est supprimé, mais son répertoire personnel peut
rester.)
5. Supprimer un utilisateur et son répertoire personnel ( userdel -r ) :
sudo userdel -r autre_utilisateur
ls /home
(L'utilisateur autre_utilisateur et son répertoire personnel devraient être supprimés.)
31. Commande df (Afficher l'utilisation de l'espace disque)
La commande df (disk free) affiche l'utilisation de l'espace disque des systèmes de fichiers
montés. Elle est utile pour vérifier l'espace disponible et utilisé sur vos partitions.
Syntaxe : df [options] [système de fichiers]
Exemples enchaînés :
1. Afficher l'utilisation de l'espace disque de tous les systèmes de fichiers :
df
(Affiche l'utilisation en blocs de 1K, ce qui n'est pas très lisible.)
2. Afficher l'utilisation de l'espace disque en format lisible par l'homme ( -h ) :
df -h
(Affiche les tailles en Go, Mo, Ko, ce qui est beaucoup plus facile à lire.)
3. Afficher l'utilisation de l'espace disque d'un système de fichiers spécifique :
df -h /home
(Affiche l'utilisation de l'espace disque pour la partition /home .)
4. Inclure les systèmes de fichiers de type tmpfs ( -T ) :
df -hT
 (Affiche le type de système de fichiers pour chaque entrée, y compris les systèmes de
fichiers temporaires en mémoire.)
5. Afficher les inodes libres et utilisés ( -i ) :
df -hi
(Les inodes sont des structures de données qui stockent des informations sur les
fichiers. Un manque d'inodes peut empêcher la création de nouveaux fichiers même s'il
reste de l'espace disque.)
32. Commande du (Estimer l'utilisation de l'espace disque des fichiers)
La commande du (disk usage) estime l'utilisation de l'espace disque par les fichiers et les
répertoires. Contrairement à df qui regarde les systèmes de fichiers, du examine les
fichiers et répertoires spécifiques.
Syntaxe : du [répertoire]
Exemples enchaînés :
1. Préparer un répertoire avec des fichiers de différentes tailles :
cd
mkdir -p test_du/sous_dossier
echo "petit" > test_du/fichier_petit.txt
head -c 10K /dev/urandom > test_du/fichier_moyen.bin
head -c 50K /dev/urandom > test_du/sous_dossier/fichier_grand.bin
ls -lR test_du
(Vérifiez la structure et les tailles des fichiers.)
2. Afficher l'utilisation de l'espace disque pour un répertoire et ses sous-répertoires :
du test_du
(Affiche la taille de chaque sous-répertoire et du répertoire principal en blocs de 1K.)
3. Afficher l'utilisation en format lisible par l'homme ( -h ) :
du -h test_du
(Affiche les tailles en Ko, Mo, Go, etc., ce qui est plus facile à lire.)
 4. Afficher le résumé total de l'utilisation ( -s ) :
du -sh test_du
(Affiche uniquement la taille totale du répertoire test_du et de son contenu.)
5. Afficher les tailles de tous les fichiers et répertoires dans le répertoire actuel :
du -ah .
(Le . représente le répertoire actuel. -a inclut tous les fichiers, pas seulement les
répertoires.)
6. Trier les résultats par taille et afficher les plus grands ( sort -rh ) :
du -ah . | sort -rh | head -n 10
(Affiche les 10 fichiers ou répertoires les plus volumineux dans le répertoire actuel, triés
par taille décroissante.)
33. Commande top (Afficher les processus en cours)
La commande top (table of processes) affiche en temps réel les processus en cours
d'exécution sur votre système Linux, ainsi que des informations sur l'utilisation des
ressources (CPU, mémoire).
Syntaxe : top [options]
Exemples enchaînés :
1. Lancer top pour voir les processus en temps réel :
top
(Vous verrez une interface dynamique affichant les processus triés par utilisation du
CPU. Appuyez sur q pour quitter.)
2. Trier les processus par utilisation de la mémoire ( M ) :
top
(Une fois dans l'interface top , appuyez sur M (Majuscule M) pour trier par utilisation
de la mémoire. Appuyez sur q pour quitter.)
3. Trier les processus par temps d'exécution ( T ) :
top
 (Une fois dans l'interface top , appuyez sur T (Majuscule T) pour trier par temps
d'exécution cumulé. Appuyez sur q pour quitter.)
4. Afficher uniquement les processus d'un utilisateur spécifique ( -u ) :
top -u votre_nom_utilisateur
(Affiche seulement les processus appartenant à votre_nom_utilisateur . Appuyez sur q
pour quitter.)
5. Mettre à jour l'affichage toutes les 5 secondes ( -d ) :
top -d 5
(L'affichage se rafraîchira toutes les 5 secondes au lieu des 3 secondes par défaut.
Appuyez sur q pour quitter.)
34. Commande htop (Moniteur de processus interactif)
htop est une alternative interactive et plus conviviale à top . Elle offre une interface
colorée et permet de faire défiler la liste des processus horizontalement et verticalement.
Syntaxe : htop [options]
Exemples enchaînés :
1. Installer htop (si ce n'est pas déjà fait) :
sudo apt install htop
(Ou sudo dnf install htop pour les systèmes basés sur Red Hat.)
2. Lancer htop :
htop
(Vous verrez une interface graphique interactive. Utilisez les flèches pour naviguer, F1
pour l'aide, F9 pour tuer un processus, F10 pour quitter.)
3. Trier les processus par CPU ou mémoire (dans htop ) :
(Dans l'interface htop , appuyez sur F6 pour choisir la colonne de tri, puis
sélectionnez CPU% ou MEM% .)
4. Rechercher un processus (dans htop ) :
(Dans l'interface htop , appuyez sur F3 pour lancer la recherche, tapez le nom du
 processus et appuyez sur Entrée .)
5. Afficher les processus en mode arborescence ( -t ) :
htop -t
(Affiche les processus sous forme d'arborescence, montrant les relations parent-
enfant.)
35. Commande ps (Afficher les processus en cours)
La commande ps (process status) affiche un instantané des processus en cours
d'exécution. Contrairement à top ou htop , elle ne met pas à jour les informations en
temps réel.
Syntaxe : ps [options]
Exemples enchaînés :
1. Afficher vos propres processus :
ps
(Affiche les processus associés à votre terminal actuel.)
2. Afficher tous les processus en cours d'exécution ( -A ou aux ) :
ps -A
(Affiche tous les processus sur le système.)
ps aux
(Affiche tous les processus avec des informations détaillées : utilisateur, PID, %CPU,
%MEM, etc. C'est une option très courante.)
3. Afficher les processus par utilisateur ( -u ) :
ps -u root
(Affiche tous les processus appartenant à l'utilisateur root .)
4. Afficher les processus par PID (Process ID) :
(D'abord, trouvez un PID, par exemple celui de sshd .)
ps aux | grep sshd
(Notez le PID de sshd .)
 ps -p <PID_de_sshd>
(Affiche les informations spécifiques à ce PID.)
5. Afficher une arborescence des processus ( -efH ) :
ps -efH
(Affiche tous les processus avec une arborescence hiérarchique, montrant les relations
parent-enfant.)
6. Combiner ps avec grep pour trouver un processus spécifique :
ps aux | grep firefox
(Trouve toutes les lignes de processus qui contiennent le mot "firefox".)
ps aux | grep firefox | grep -v grep
(Le grep -v grep est utilisé pour exclure la ligne grep firefox elle-même de la sortie.)
36. Commande uname (Afficher les informations du système)
La commande uname (unix name) affiche des informations détaillées sur votre système
Linux, y compris le nom du noyau, le nom d'hôte, la version du noyau, le type de machine,
etc.
Syntaxe : uname [options]
Exemples enchaînés :
1. Afficher le nom du noyau (comportement par défaut) :
uname
(Affiche généralement Linux .)
2. Afficher toutes les informations du système ( -a ) :
uname -a
(Affiche le nom du noyau, le nom d'hôte, la version du noyau, la date de compilation, le
type de machine, le processeur, la plateforme matérielle et le système d'exploitation.)
3. Afficher le nom du noyau ( -s ) :
uname -s
(Identique à uname sans option.)
 4. Afficher le nom du nœud du réseau (hostname) ( -n ) :
uname -n
(Affiche le nom d'hôte de votre machine.)
5. Afficher la version du noyau ( -v ) :
uname -v
(Affiche la version spécifique du noyau, y compris la date de compilation.)
6. Afficher la version du noyau ( -r ) :
uname -r
(Affiche la version de la publication du noyau, par exemple 5.15.0-105-generic .)
7. Afficher le type de machine ( -m ) :
uname -m
(Affiche l'architecture matérielle, par exemple x86_64 .)
37. Commande hostname (Afficher ou définir le nom d'hôte)
La commande hostname permet d'afficher ou de définir le nom d'hôte de votre système. Le
nom d'hôte est le nom donné à un ordinateur sur un réseau.
Syntaxe : hostname [options]
Exemples enchaînés :
1. Afficher le nom d'hôte actuel :
hostname
(Affiche le nom d'hôte de votre machine.)
2. Afficher l'adresse IP de votre serveur ( -i ) :
hostname -i
(Affiche l'adresse IP associée à votre nom d'hôte.)
3. Afficher l'alias du nom d'hôte ( -a ) :
hostname -a
(Si un alias est configuré pour votre nom d'hôte, il sera affiché.)
 4. Afficher le nom de domaine complet (FQDN) ( -f ) :
hostname -f
(Affiche le nom d'hôte complet, y compris le nom de domaine, par exemple
[Link] .)
5. Définir un nouveau nom d'hôte (nécessite sudo et est temporaire ou nécessite une
modification de fichier de configuration pour être permanent) :
sudo hostname nouveau_nom_hote
hostname
(Le nom d'hôte est maintenant nouveau_nom_hote pour la session en cours. Pour le
rendre permanent, il faut modifier /etc/hostname et /etc/hosts .)
38. Commande time (Mesurer le temps d'exécution d'une commande)
La commande time est utilisée pour mesurer le temps d'exécution d'une commande ou
d'un script. Elle fournit des informations sur le temps réel, le temps utilisateur et le temps
système.
Syntaxe : time commande_ou_script
Exemples enchaînés :
1. Mesurer le temps d'exécution d'une commande simple :
time ls -l /
(Affiche le temps pris par la commande ls -l / pour s'exécuter.)
2. Mesurer le temps d'exécution d'une commande plus complexe :
time find / -name "*.conf" > /dev/null
(Recherche tous les fichiers .conf
sur le système et redirige la sortie vers /dev/null
pour ne pas encombrer le terminal, mesurant ainsi le temps de recherche.)
3. Mesurer le temps d'exécution d'une série de commandes :
time (sleep 1 && echo "Première commande terminée." && sleep 2 && echo "Deuxième commande
terminée.")
(Exécute une séquence de commandes et mesure le temps total. Les parenthèses ()
créent un sous-shell pour que time mesure l'ensemble de la séquence.)
 4. Comprendre les sorties de time :
• real : Temps écoulé du début à la fin de la commande (temps "horloge murale").
• user : Temps CPU passé en mode utilisateur (exécution du code de l'application).
• sys : Temps CPU passé en mode noyau (appels système, I/O).

39. Commande systemctl (Gérer les services Systemd)

La commande systemctl est l'outil principal pour contrôler le système et le gestionnaire de
services systemd sur les distributions Linux modernes. Elle permet de gérer les services, les
unités, et de contrôler l'état du système.
Syntaxe : systemctl sous-commande [nom_du_service][options]
Exemples enchaînés :
1. Vérifier l'état d'un service (par exemple, apache2 ou nginx ) :
systemctl status apache2
(Affiche si le service est actif, inactif, en échec, etc., ainsi que les dernières lignes de
journal. Appuyez sur q pour quitter.)
2. Démarrer un service :
sudo systemctl start apache2
(Démarre le service Apache. Vérifiez son état avec systemctl status apache2 .)
3. Arrêter un service :
sudo systemctl stop apache2
(Arrête le service Apache. Vérifiez son état.)
4. Redémarrer un service :
sudo systemctl restart apache2
(Redémarre le service. Utile après des modifications de configuration.)
5. Recharger la configuration d'un service (sans l'arrêter) :
sudo systemctl reload apache2
(Si le service supporte le rechargement, il appliquera les nouvelles configurations sans
interruption de service.)
 6. Activer un service au démarrage du système :
sudo systemctl enable apache2
(Le service Apache démarrera automatiquement à chaque démarrage du système.)
7. Désactiver un service au démarrage du système :
sudo systemctl disable apache2
(Le service Apache ne démarrera plus automatiquement.)
8. Lister toutes les unités de service :
systemctl list-unit-files --type service
(Affiche tous les services connus par systemd et leur état (activé, désactivé, etc.).)
9. Lister les services en cours d'exécution :
systemctl list-units --type service --state running
(Affiche uniquement les services qui sont actuellement actifs et en cours d'exécution.)
40. Commande watch (Surveiller l'exécution d'une commande)
La commande watch exécute une commande de manière répétée et affiche sa sortie en
plein écran, ce qui est utile pour surveiller les changements dans la sortie d'une commande
au fil du temps.
Syntaxe : watch [options] nom_commande
Exemples enchaînés :
1. Surveiller l'heure système :
watch date
(Affiche l'heure actuelle et la met à jour toutes les 2 secondes par défaut. Appuyez sur
Ctrl+C pour quitter.)
2. Surveiller l'utilisation du disque en temps réel :
watch df -h
(Affiche l'utilisation de l'espace disque et la met à jour toutes les 2 secondes. Utile pour
voir comment l'espace disque évolue.)
3. Modifier l'intervalle de rafraîchissement ( -n ) :
watch -n 5 'ls -l'
 (Exécute ls -l toutes les 5 secondes. Les guillemets simples sont importants si la
commande contient des espaces ou des caractères spéciaux.)
4. Mettre en évidence les changements ( -d ) :
watch -d 'ls -l'
(Les changements dans la sortie de ls -l seront mis en évidence. Créez ou supprimez
un fichier dans un autre terminal pour voir l'effet.)
5. Surveiller les connexions réseau actives :
watch -n 1 'netstat -tulnp'
(Affiche les connexions réseau TCP et UDP toutes les secondes. Nécessite sudo pour
voir les noms de processus.)
41. Commande jobs (Gérer les tâches en arrière-plan)
La commande jobs affiche les tâches (commandes) qui sont en cours d'exécution ou qui
ont été suspendues dans la session shell actuelle. Elle est utile pour gérer les processus en
arrière-plan.
Syntaxe : jobs [options] [ID_Job]
Exemples enchaînés :
1. Lancer une commande en arrière-plan et vérifier les tâches :
sleep 100 &
(Le & à la fin envoie la commande sleep 100 en arrière-plan.)
jobs
(Affiche la tâche sleep 100 avec un numéro de job, par exemple [1] Running sleep 100 & .)
2. Lancer une autre commande en arrière-plan :
find / -name "*.log" > /dev/null &
jobs
(Vous devriez voir deux tâches en arrière-plan.)
3. Mettre une commande en arrière-plan après l'avoir lancée en avant-plan :
sleep 200
(La commande est en cours d'exécution. Appuyez sur Ctrl+Z pour la suspendre.)
 jobs
(La tâche est maintenant Stopped .)
bg
(Envoie la dernière tâche suspendue en arrière-plan.)
jobs
(La tâche est maintenant Running en arrière-plan.)
4. Ramener une tâche en avant-plan ( fg ) :
fg %1
(Ramène la tâche numéro 1 en avant-plan. Vous pouvez aussi simplement taper fg
pour la dernière tâche.)
(Appuyez sur Ctrl+C pour l'arrêter, ou Ctrl+Z pour la suspendre à nouveau.)
5. Afficher des informations détaillées sur les tâches ( -l ) :
jobs -l
(Affiche le PID (Process ID) de chaque tâche en plus des informations habituelles.)
42. Commande kill (Terminer des processus)
La commande kill est utilisée pour envoyer des signaux à des processus, le plus souvent
pour les terminer. Elle nécessite le PID (Process ID) du processus cible.
Syntaxe : kill [signal_option] ID_Processus
Signaux courants :
• 1 (SIGHUP) : Recharger la configuration.
• 9 (SIGKILL) : Terminer le processus immédiatement et sans avertissement (ne peut
pas être ignoré).
• 15 (SIGTERM) : Demander au processus de se terminer proprement (par défaut, peut
être ignoré).
Exemples enchaînés :
1. Lancer un processus en arrière-plan pour le tuer :
sleep 300 &
 jobs -l
(Notez le PID de la commande sleep .)
2. Terminer un processus proprement (SIGTERM, par défaut) :
kill <PID_de_sleep>
(Le processus sleepdevrait se terminer. Vérifiez avec jobs .)
3. Lancer un autre processus et le tuer de force (SIGKILL) :
sleep 300 &
jobs -l
(Notez le nouveau PID.)
kill -9 <PID_de_sleep>
(Le processus est tué immédiatement. Utilisez -9 en dernier recours si kill sans
option ne fonctionne pas.)
4. Tuer un processus par son nom ( pkill ou killall ) :
(Ces commandes sont plus pratiques pour tuer des processus sans connaître leur PID,
mais soyez prudent.)
sleep 300 &
pkill sleep
(Tue tous les processus nommés sleep .)
43. Commande shutdown (Arrêter ou Redémarrer le système)
La commande shutdown permet d'arrêter ou de redémarrer le système Linux de manière
contrôlée. Elle est essentielle pour s'assurer que tous les processus sont arrêtés proprement
et que les données sont sauvegardées.
Syntaxe : shutdown [option] [temps] [message]
Exemples enchaînés :
1. Arrêter le système immédiatement :
sudo shutdown now
(Équivalent à sudo shutdown -h now ou sudo poweroff . Le système s'arrêtera
immédiatement.)
 2. Arrêter le système après un délai (par exemple, 5 minutes) :
sudo shutdown +5 "Le système va s'arrêter dans 5 minutes pour maintenance."
(Les utilisateurs connectés recevront le message. Vous pouvez annuler avec sudo
shutdown -c .)
3. Arrêter le système à une heure précise (format 24 heures) :
sudo shutdown 23:00 "Sauvegardez votre travail, arrêt à 23h00."
(Le système s'arrêtera à 23h00.)
4. Redémarrer le système immédiatement :
sudo shutdown -r now
(Équivalent à sudo reboot . Le système redémarrera immédiatement.)
5. Annuler un arrêt ou un redémarrage programmé :
sudo shutdown -c
(Annule toute commande shutdown en attente.)
44. Commande ping (Tester la connectivité réseau)
La commande ping (Packet Internet Groper) est un utilitaire réseau utilisé pour tester la
joignabilité d'un hôte sur un réseau IP et pour mesurer le temps aller-retour des paquets.
Syntaxe : ping [option] [nom_hôte_ou_adresse_IP]
Exemples enchaînés :
1. Tester la connectivité avec un site web :
ping [Link]
(Envoie des paquets à [Link] indéfiniment. Appuyez sur Ctrl+C pour arrêter.)
2. Tester la connectivité avec une adresse IP :
ping [Link]
(Ping le serveur DNS public de Google.)
3. Envoyer un nombre limité de paquets ( -c ) :
ping -c 5 [Link]
(Envoie 5 paquets, puis s'arrête et affiche un résumé.)
 4. Modifier l'intervalle entre les paquets ( -i ) :
ping -c 10 -i 2 [Link]
(Envoie 10 paquets avec un intervalle de 2 secondes entre chaque envoi.)
5. Spécifier la taille des paquets ( -s ) :
ping -c 3 -s 1000 [Link]
(Envoie 3 paquets de 1000 octets de données.)
6. Afficher uniquement le résumé des statistiques ( -q ) :
ping -c 5 -q [Link]
(N'affiche pas les lignes de réponse individuelles, seulement le résumé final.)
45. Commande wget (Télécharger des fichiers depuis le web)
La commande wget est un utilitaire non interactif qui permet de télécharger des fichiers
depuis le web en utilisant les protocoles HTTP, HTTPS et FTP. Elle est très utile pour les
téléchargements en arrière-plan ou les scripts.
Syntaxe : wget [options] [URL]
Exemples enchaînés :
1. Télécharger un fichier simple :
cd
wget [Link]
(Télécharge la page [Link] du site [Link] dans le répertoire actuel.)
ls
(Vous devriez voir [Link] .)
2. Télécharger un fichier et le renommer ( -O ) :
wget -O ma_page.html [Link]
(Télécharge la page et l'enregistre sous le nom ma_page.html .)
3. Télécharger en arrière-plan ( -b ) :
wget -b [Link]
(Lance le téléchargement en arrière-plan. La progression sera enregistrée dans un
fichier wget-log .)
 tail -f wget-log
(Pour suivre la progression du téléchargement.)
4. Reprendre un téléchargement interrompu ( -c ) :
(Simulez une interruption en téléchargeant un gros fichier et en l'arrêtant avec Ctrl+C .)
wget -c [Link]
( wget reprendra le téléchargement là où il s'était arrêté.)
5. Télécharger un site web entier de manière récursive ( -r ) :
wget -r -l 1 [Link]
(Télécharge le site [Link] de manière récursive, avec une profondeur de 1
niveau. Soyez prudent avec cette option, elle peut télécharger beaucoup de données.)
46. Commande cURL (Transférer des données avec des URL)
La commande cURL (Client for URLs) est un outil polyvalent pour transférer des données
depuis ou vers un serveur en utilisant une URL. Elle supporte de nombreux protocoles
(HTTP, HTTPS, FTP, etc.) et est très utilisée pour les requêtes web et les tests d'API.
Syntaxe : curl [options] URL
Exemples enchaînés :
1. Afficher le contenu HTML d'une page web :
cd
curl [Link]
(Affiche le code source HTML de la page [Link] directement dans le terminal.)
2. Télécharger un fichier et l'enregistrer sous son nom d'origine ( -O ) :
curl -O [Link]
(Télécharge [Link] et l'enregistre sous le même nom dans le répertoire actuel.)
ls
(Vérifiez la présence de [Link] .)
3. Télécharger un fichier et l'enregistrer sous un nom spécifié ( -o ) :
curl -o ma_page_curl.html [Link]
(Télécharge [Link] et l'enregistre sous le nom ma_page_curl.html .)
 4. Effectuer une requête HTTP GET pour une API :
curl -X GET [Link]
(Récupère les données JSON du post avec l'ID 1 depuis une API de test.)
5. **Effectuer une requête HTTP POST avec des données JSON (`-X POST -H
'Content-Type: application/json' -d '{"title": "foo", "body": "bar", "userId": 1}'
[Link]
(Envoie des données JSON à l'API pour créer un nouveau post.)
1. Afficher les en-têtes de réponse ( -I ) :
curl -I [Link]
(Affiche uniquement les en-têtes HTTP de la réponse, sans le corps de la page.)
47. Commande scp (Copie sécurisée de fichiers à distance)
La commande scp (secure copy) permet de copier des fichiers et des répertoires de
manière sécurisée entre des hôtes sur un réseau, en utilisant le protocole SSH pour le
transfert de données et l'authentification.
Syntaxe : scp [options] [utilisateur@]hôte_source:chemin_source
[utilisateur@]hôte_destination:chemin_destination
Exemples enchaînés :
1. Préparer un fichier local à copier :
cd
echo "Ceci est un fichier à copier via scp." > fichier_local_scp.txt
ls
(Vérifiez la présence de fichier_local_scp.txt .)
2. Copier un fichier local vers un serveur distant :
(Remplacez utilisateur_distant et adresse_ip_serveur par vos propres informations.)
scp fichier_local_scp.txt utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/
(Vous serez invité à entrer le mot de passe de l'utilisateur distant. Le fichier sera copié
dans le répertoire personnel de l'utilisateur distant.)
 3. Copier un fichier d'un serveur distant vers votre machine locale :
scp utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/fichier_distant.txt .
(Le . à la fin signifie le répertoire actuel. Le fichier fichier_distant.txt sera copié depuis
le serveur distant vers votre répertoire local.)
4. Copier un répertoire de manière récursive ( -r ) :
mkdir -p dossier_local_scp/sous_dossier
echo "Fichier dans le dossier local." > dossier_local_scp/fichier_interne.txt
scp -r dossier_local_scp utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/
(Le répertoire dossier_local_scp et tout son contenu seront copiés sur le serveur
distant.)
5. Spécifier un port SSH différent ( -P ) :
(Si votre serveur SSH écoute sur un port autre que le 22 par défaut, par exemple 2222.)
scp -P 2222 fichier_local_scp.txt utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/
6. Limiter la bande passante ( -l ) :
scp -l 1000 fichier_local_scp.txt utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/
(Limite la bande passante à 1000 Kbit/s.)
48. Commande rsync (Synchroniser des fichiers et des répertoires)
La commande rsync (remote sync) est un outil puissant et polyvalent pour synchroniser
des fichiers et des répertoires entre deux emplacements, qu'ils soient locaux ou distants.
Elle est très efficace car elle ne transfère que les différences entre les fichiers.
Syntaxe : rsync [options] source destination
Exemples enchaînés :
1. Préparer des répertoires pour la synchronisation locale :
cd
mkdir -p source_rsync
mkdir -p destination_rsync
echo "Fichier 1" > source_rsync/[Link]
echo "Fichier 2" > source_rsync/[Link]
ls -l source_rsync
 ls -l destination_rsync
(Vérifiez les contenus.)
2. Synchroniser des fichiers d'un répertoire source vers un répertoire de destination
local :
rsync -av source_rsync/ destination_rsync/
(L'option -a pour archive mode (conserve les permissions, les propriétaires, les
horodatages, etc.), et -v pour verbose (affiche les détails du transfert). Le / à la fin de
source_rsync/ est important pour copier le contenu du répertoire, et non le répertoire
lui-même.)
ls -l destination_rsync
( [Link] et [Link]
devraient maintenant être dans destination_rsync .)
3. Modifier un fichier source et resynchroniser :
echo "Fichier 1 modifié" > source_rsync/[Link]
rsync -av source_rsync/ destination_rsync/
( rsync ne transférera que [Link] car [Link] n'a pas changé.)
cat destination_rsync/[Link]
(Vérifiez que le fichier est mis à jour.)
4. Supprimer un fichier source et resynchroniser avec suppression ( --delete ) :
rm source_rsync/[Link]
rsync -av --delete source_rsync/ destination_rsync/
(Le [Link] sera supprimé de destination_rsync car il n'existe plus dans
source_rsync .)
ls -l destination_rsync
( [Link] devrait avoir disparu.)
5. Synchroniser des fichiers vers un serveur distant (similaire à scp mais plus
efficace pour les mises à jour) :
(Remplacez utilisateur_distant et adresse_ip_serveur par vos propres informations.)
rsync -avz source_rsync/
utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/dossier_distant_rsync/
(L'option -z active la compression pendant le transfert, utile pour les connexions
lentes.)
 6. Synchroniser des fichiers depuis un serveur distant :
rsync -avz utilisateur_distant@adresse_ip_serveur:/home/utilisateur_distant/dossier_distant_rsync/
destination_rsync_from_remote/
(Copie les fichiers du serveur distant vers un nouveau répertoire local.)
49. Commande ip (Afficher et configurer les interfaces réseau)
La commande ip est un utilitaire moderne et puissant pour afficher et configurer les
interfaces réseau, les tables de routage, les adresses IP, etc. Elle remplace progressivement
les anciennes commandes comme ifconfig et route .
Syntaxe : ip [options] objet commande
Objets courants :
• address ou a : Gérer les adresses IP.
• link ou l : Gérer les interfaces réseau.
• route ou r : Gérer les tables de routage.
• neigh ou n : Gérer la table ARP (voisins).
Exemples enchaînés :
1. Afficher toutes les adresses IP configurées sur les interfaces :
ip a ou ip address show
(Affiche les adresses IP, les masques de sous-réseau, les états des interfaces (UP/DOWN),
etc.)
2. Afficher les informations détaillées d'une interface spécifique (par exemple, eth0
ou enp0s3 ) :
ip a show eth0
(Remplacez eth0 par le nom de votre interface réseau principale.)
3. Afficher l'état des interfaces réseau (up/down) :
ip link show
(Affiche les interfaces réseau et leur état, y compris si elles sont actives ou non.)
 4. Activer une interface réseau (nécessite sudo ) :
sudo ip link set eth0 up
(Active l'interface eth0 . Utile si une interface est DOWN .)
5. Désactiver une interface réseau (nécessite sudo ) :
sudo ip link set eth0 down
(Désactive l'interface eth0 . Soyez prudent, cela peut couper votre connexion.)
6. Afficher la table de routage :
ip r ou ip route show
(Affiche les routes par défaut, les routes vers les réseaux locaux, etc.)
7. Ajouter une adresse IP à une interface (temporaire, nécessite sudo ) :
sudo ip address add [Link]/24 dev eth0
(Ajoute l'adresse IP [Link] avec un masque de 24 bits à l'interface eth0 .)
ip a show eth0
(Vérifiez que la nouvelle adresse est bien là.)
8. Supprimer une adresse IP d'une interface (temporaire, nécessite sudo ) :
sudo ip address del [Link]/24 dev eth0
(Supprime l'adresse IP précédemment ajoutée.)
50. Commande netstat (Afficher les connexions réseau, les tables de
routage, etc.)
La commande netstat (network statistics) est utilisée pour afficher les connexions réseau
actives, les tables de routage, les statistiques d'interface, les connexions masquées, et bien
plus encore. Bien que ip soit plus moderne, netstat reste largement utilisé.
Syntaxe : netstat [options]
Exemples enchaînés :
1. Afficher toutes les connexions actives (TCP et UDP) :
netstat -a
(Affiche toutes les sockets en écoute et les connexions établies.)
 2. Afficher les connexions TCP uniquement :
netstat -at
(Le -t filtre pour TCP.)
3. Afficher les connexions UDP uniquement :
netstat -au
(Le -u filtre pour UDP.)
4. Afficher les ports d'écoute ( -l ) et les processus ( -p ) :
sudo netstat -ltnp
(Affiche les ports TCP en écoute, le numéro de port, et le PID/nom du programme qui
écoute. Nécessite sudo pour voir les noms de processus.)
5. Afficher les tables de routage ( -r ) :
netstat -r
(Affiche la table de routage du noyau, similaire à ip route show .)
6. Afficher les statistiques d'interface ( -i ) :
netstat -i
(Affiche des statistiques sur les interfaces réseau, comme le nombre de paquets
envoyés/reçus, les erreurs, etc.)
7. Afficher les connexions numériques (sans résolution de noms) ( -n ) :
netstat -an
(Affiche les adresses IP et les numéros de port au lieu des noms d'hôtes et des noms de
services, ce qui est plus rapide.)
51. Commande traceroute (Suivre le chemin des paquets réseau)
La commande traceroute permet de suivre le chemin qu'un paquet prend pour atteindre
une destination sur un réseau IP. Elle affiche la liste des routeurs (sauts) par lesquels le
paquet passe, ainsi que le temps de réponse de chaque saut.
Syntaxe : traceroute [options] destination
Exemples enchaînés :
 1. Tracer le chemin vers un site web :
traceroute [Link]
(Affiche la liste des routeurs entre votre machine et [Link] , avec les temps de
réponse pour chaque saut.)
2. Tracer le chemin vers une adresse IP :
traceroute [Link]
(Trace le chemin vers le serveur DNS public de Google.)
3. Limiter le nombre maximal de sauts ( -m ) :
traceroute -m 10 [Link]
(Limite le chemin à 10 sauts maximum. Utile pour les diagnostics rapides ou pour éviter
les boucles infinies.)
4. Ne pas résoudre les adresses IP en noms d'hôtes ( -n ) :
traceroute -n [Link]
(Affiche les adresses IP des routeurs au lieu de leurs noms d'hôtes, ce qui peut accélérer
le processus.)
5. Spécifier le protocole à utiliser ( -I pour ICMP, -T pour TCP) :
sudo traceroute -I [Link]
(Utilise des paquets ICMP ECHO pour le traçage, comme ping . Nécessite sudo .)
sudo traceroute -T [Link]
(Utilise des paquets TCP SYN pour le traçage, utile pour tester les pare-feu.)
52. Commande nslookup (Interroger les serveurs DNS)
La commande nslookup (name server lookup) est un outil en ligne de commande pour
interroger les serveurs DNS (Domain Name System) afin d'obtenir des informations sur les
noms de domaine et les adresses IP.
Syntaxe : nslookup [options] domaine-ou-ip [serveur-dns]
Exemples enchaînés :
1. Résoudre un nom de domaine en adresse IP :
nslookup [Link]
 (Affiche l'adresse IP associée à [Link] et le serveur DNS utilisé pour la requête.)
2. Résoudre une adresse IP en nom de domaine (requête inverse) :
nslookup [Link]
(Affiche le nom de domaine associé à l'adresse IP [Link].)
3. Spécifier un serveur DNS à interroger :
nslookup [Link] [Link]
(Interroge [Link] en utilisant le serveur DNS [Link].)
4. Rechercher un type d'enregistrement DNS spécifique ( set type= ) :
nslookup
set type=MX
[Link]
(Dans le mode interactif de nslookup , cette séquence affiche les enregistrements MX
(Mail Exchange) pour [Link] . Tapez exit pour quitter le mode interactif.)
5. Rechercher les enregistrements NS (Name Server) :
nslookup -type=NS [Link]
(Affiche les serveurs de noms responsables du domaine [Link] .)
53. Commande dig (Interroger les serveurs DNS de manière avancée)
La commande dig (domain information groper) est un outil plus avancé et flexible que
nslookup pour interroger les serveurs DNS. Elle est préférée par les administrateurs
système pour le dépannage DNS.
Syntaxe : dig [options] [serveur] [type] nom-ou-ip
Exemples enchaînés :
1. Résoudre un nom de domaine (enregistrement A par défaut) :
dig [Link]
(Affiche l'enregistrement A (adresse IP) de [Link] et des informations détaillées
sur la requête DNS.)
2. Rechercher un type d'enregistrement DNS spécifique (par exemple, MX pour les
serveurs de messagerie) :
 dig [Link] MX
(Affiche les enregistrements MX pour [Link] .)
3. Rechercher tous les enregistrements DNS ( ANY ) :
dig [Link] ANY
(Affiche tous les types d'enregistrements DNS disponibles pour [Link] .)
4. Effectuer une recherche DNS inversée (PTR) :
dig -x [Link]
(Résout l'adresse IP [Link] en son nom de domaine inverse.)
5. Spécifier un serveur DNS à interroger :
dig @[Link] [Link]
(Interroge [Link] en utilisant le serveur DNS [Link].)
6. Afficher une réponse courte ( +short ) :
dig [Link] +short
(Affiche uniquement l'adresse IP, sans les informations supplémentaires.)
54. Commande history (Afficher l'historique des commandes)
La commande history affiche la liste des commandes précédemment exécutées dans la
session shell actuelle. C'est un outil très utile pour retrouver des commandes, les réutiliser
ou les modifier.
Syntaxe : history [options]
Exemples enchaînés :
1. Afficher l'historique complet des commandes :
history
(Affiche une liste numérotée de toutes les commandes que vous avez tapées.)
2. Réexécuter une commande spécifique de l'historique :
(Notez le numéro d'une commande dans votre historique, par exemple 123.)
!123
(Exécute la commande qui correspond au numéro 123 dans votre historique.)
 3. Réexécuter la dernière commande :
!!
(Exécute la dernière commande que vous avez tapée.)
4. Rechercher dans l'historique (Ctrl+R) :
(Appuyez sur Ctrl+R dans votre terminal, puis commencez à taper un mot-clé. Le
terminal affichera la dernière commande correspondante. Appuyez plusieurs fois sur
Ctrl+R pour parcourir les correspondances précédentes.)
5. Effacer l'historique de la session actuelle ( -c ) :
history -c
history
(L'historique de la session actuelle est maintenant vide. Notez que cela n'efface pas
l'historique enregistré dans le fichier ~/.bash_history .)
6. Afficher les N dernières commandes :
history 10
(Affiche les 10 dernières commandes de l'historique.)
55. Commande man (Afficher le manuel d'une commande)
La commande man (manual) est essentielle pour obtenir de l'aide sur n'importe quelle
commande Linux. Elle affiche les pages de manuel, qui sont des documentations complètes
sur l'utilisation, les options et les exemples d'une commande.
Syntaxe : man [options] [numéro_de_section] nom_commande
Sections du manuel (les plus courantes) :
• 1 : Commandes exécutables (programmes shell)
• 2 : Appels système (fonctions fournies par le noyau)
• 3 : Fonctions de bibliothèque (fonctions dans les bibliothèques de programmes)
• 4 : Fichiers spéciaux (périphériques)
• 5 : Formats de fichiers et conventions (par exemple, /etc/passwd )
 • 6 : Jeux
• 7 : Divers (conventions, protocoles, etc.)
• 8 : Commandes d'administration système (nécessitant des privilèges root)
Exemples enchaînés :
1. Afficher le manuel d'une commande simple :
man ls
(Ouvre la page de manuel de la commande ls . Utilisez les flèches pour naviguer, q
pour quitter.)
2. Rechercher une commande dans les pages de manuel ( -k ) :
man -k network
(Recherche toutes les pages de manuel qui contiennent le mot "network" dans leur
description courte. Utile si vous ne connaissez pas le nom exact de la commande.)
3. Afficher une section spécifique du manuel :
man 5 passwd
(Affiche la page de manuel pour le format du fichier /etc/passwd (section 5), et non la
commande passwd (section 1).)
4. Rechercher une chaîne de caractères dans le manuel ouvert :
(Une fois dans une page de manuel, tapez / suivi du mot-clé que vous recherchez, puis
appuyez sur Entrée . Appuyez sur n pour passer à l'occurrence suivante.)
man grep
(Puis, dans le manuel, tapez /regex et appuyez sur Entrée .)
56. Commande echo (Afficher du texte ou des variables)
La commande echo est utilisée pour afficher une ligne de texte ou la valeur de variables
dans le terminal. Elle est très couramment utilisée dans les scripts shell.
Syntaxe : echo [options] [texte]
Exemples enchaînés :
 1. Afficher une simple chaîne de caractères :
echo "Bonjour le monde !"
(Affiche : Bonjour le monde ! )
2. Afficher la valeur d'une variable d'environnement :
echo $HOME
(Affiche le chemin de votre répertoire personnel.)
echo $PATH
(Affiche les chemins où le shell recherche les exécutables.)
3. Créer un fichier avec du contenu (redirection > ) :
echo "Ceci est la première ligne." > mon_fichier_echo.txt
cat mon_fichier_echo.txt
(Le fichier mon_fichier_echo.txt est créé avec le texte spécifié.)
4. Ajouter du contenu à un fichier existant (redirection >> ) :
echo "Ceci est la deuxième ligne." >> mon_fichier_echo.txt
cat mon_fichier_echo.txt
(La nouvelle ligne est ajoutée à la fin du fichier.)
5. Utiliser des séquences d'échappement ( -e ) :
echo -e "Ligne 1\nLigne 2\t(avec tabulation)"
(Le -e interprète les caractères spéciaux comme \n (nouvelle ligne) et \t
(tabulation).)
6. Afficher sans nouvelle ligne finale ( -n ) :
echo -n "Ceci est sur une seule ligne." ; echo "Ceci continue sur la même ligne."
(Les deux echo affichent leur texte sur la même ligne car le premier echo n'ajoute pas
de nouvelle ligne.)
57. Commande ln (Créer des liens entre fichiers)
La commande ln (link) est utilisée pour créer des liens entre des fichiers. Il existe deux
types de liens : les liens durs (hard links) et les liens symboliques (symbolic links ou soft
links).
Syntaxe : ln [options] source cible
Exemples enchaînés :
1. Préparer un fichier source :
cd
echo "Contenu du fichier original." > fichier_original_ln.txt
ls -li fichier_original_ln.txt
(Notez l'inode du fichier. L'inode est un identifiant unique pour un fichier sur le système
de fichiers.)
2. Créer un lien dur ( ln par défaut) :
ln fichier_original_ln.txt lien_dur.txt
ls -li fichier_original_ln.txt lien_dur.txt
(Les deux fichiers auront le même numéro d'inode, indiquant qu'ils pointent vers les
mêmes données sur le disque. Si vous modifiez l'un, l'autre sera également modifié.)
echo "Nouveau contenu." >> lien_dur.txt
cat fichier_original_ln.txt
(Le contenu de fichier_original_ln.txt a également changé.)
3. Créer un lien symbolique ( -s ) :
ln -s fichier_original_ln.txt lien_symbolique.txt
ls -li fichier_original_ln.txt lien_symbolique.txt
(Le lien symbolique aura un numéro d'inode différent et sera indiqué par un l au
début des permissions ( lrwxrwxrwx ). Il pointe vers le nom du fichier original.)
cat lien_symbolique.txt
(Affiche le contenu du fichier original.)
4. Comprendre la suppression :
• Lien dur : La suppression d'un lien dur ne supprime pas les données tant qu'il reste
au moins un lien dur pointant vers l'inode.
rm lien_dur.txt
ls -li fichier_original_ln.txt
(Le fichier original est toujours là.)
• Lien symbolique : La suppression du fichier original rend le lien symbolique "cassé"
ou "pendent" (il pointe vers rien).
 rm fichier_original_ln.txt
ls -li lien_symbolique.txt
(Le lien symbolique sera affiché en rouge ou avec une indication qu'il est cassé.)
58. Commandes alias et unalias (Créer et Supprimer des alias de
commandes)
Les commandes alias et unalias permettent de créer des raccourcis personnalisés pour
des commandes longues ou complexes. Cela peut améliorer considérablement l'efficacité et
la productivité en ligne de commande.
Syntaxe alias : alias nom=\'chaîne de caractères\'
Syntaxe unalias : unalias [nom]
Exemples enchaînés :
1. Afficher les alias existants :
alias
(Affiche une liste de tous les alias déjà définis sur votre système.)
2. Créer un alias simple :
alias ll=\'ls -alF\'
ll
(Maintenant, taper ll équivaut à taper ls -alF , ce qui est une commande courante
pour lister les fichiers de manière détaillée.)
3. Créer un alias avec plusieurs commandes :
alias maj=\'sudo apt update && sudo apt upgrade -y\'
maj
(Cet alias exécutera d'abord la mise à jour des listes de paquets, puis mettra à niveau
tous les paquets installés sans demander de confirmation.)
4. Supprimer un alias :
unalias ll
ll
(La commande ll ne fonctionnera plus, ou reviendra à son comportement par défaut
si elle était déjà un alias système.)
 5. Rendre un alias permanent :
(Les alias créés directement dans le terminal sont temporaires et disparaissent à la
fermeture de la session. Pour les rendre permanents, ajoutez-les à votre fichier de
configuration shell, par exemple ~/.bashrc ou ~/.zshrc .)
echo "alias c=\'clear\' " >> ~/.bashrc
source ~/.bashrc
c *(Maintenant, c` effacera l'écran à chaque nouvelle session.)*
59. Commande cal (Afficher un calendrier)
La commande cal (calendar) affiche un calendrier dans le terminal. Elle est simple mais
utile pour vérifier rapidement les dates.
Syntaxe : cal [options] [mois] [année]
Exemples enchaînés :
1. Afficher le calendrier du mois en cours :
cal
(Affiche le calendrier du mois actuel, avec le jour actuel en surbrillance.)
2. Afficher le calendrier d'un mois et d'une année spécifiques :
cal 12 2025
(Affiche le calendrier de décembre 2025.)
3. Afficher le calendrier d'une année entière :
cal 2025
(Affiche le calendrier complet de l'année 2025.)
4. Afficher le mois précédent, le mois actuel et le mois suivant ( -3 ) :
cal -3
(Utile pour avoir une vue d'ensemble rapide des mois adjacents.)
5. Afficher les numéros de semaine ( -w ) :
cal -w
(Ajoute les numéros de semaine à gauche du calendrier.)
60. Commandes apt et dnf (Gestionnaire de paquets)
Les commandes apt (Advanced Package Tool) et dnf (Dandified YUM) sont des
gestionnaires de paquets utilisés pour installer, mettre à jour, supprimer et gérer les
logiciels sur les systèmes Linux.
• apt est utilisé sur les distributions basées sur Debian (Ubuntu, Mint, etc.).
• dnf est utilisé sur les distributions basées sur Red Hat (Fedora, CentOS, RHEL).
Syntaxe apt : apt [options] sous-commande
Syntaxe dnf : dnf [options] sous-commande
Exemples enchaînés (avec apt pour l'exemple, remplacez par dnf si vous êtes sur
une distribution Red Hat) :
1. Mettre à jour la liste des paquets disponibles :
sudo apt update
(Télécharge les dernières informations sur les paquets depuis les dépôts configurés.
C'est la première étape avant toute installation ou mise à niveau.)
2. Mettre à niveau tous les paquets installés :
sudo apt upgrade
(Met à niveau tous les paquets installés vers leurs dernières versions disponibles.
Répondez y si demandé.)
3. Installer un nouveau paquet (par exemple, neofetch ) :
sudo apt install neofetch
(Installe le paquet neofetch , qui affiche des informations système stylisées. Répondez
y si demandé.)
neofetch
(Exécute la commande nouvellement installée.)
4. Supprimer un paquet :
sudo apt remove neofetch
(Supprime le paquet neofetch , mais conserve les fichiers de configuration.)
5. Supprimer un paquet et ses fichiers de configuration :
sudo apt purge neofetch
(Supprime le paquet et tous ses fichiers de configuration.)
6. Nettoyer les paquets inutiles :
sudo apt autoremove
(Supprime les paquets qui ont été installés comme dépendances et qui ne sont plus
nécessaires.)
7. Rechercher un paquet :
apt search htop
(Recherche le paquet htop dans les dépôts.)