Commandes Linux de base avec exemples pratiques

Ce guide offre aux opérateurs et aux développeurs un parcours pratique vers les commandes Linux les plus utiles. Vous allez mettre en place un laboratoire sûr dans votre répertoire personnel, pratiquer les opérations sur les fichiers et les processus, vérifier les résultats avec des sommes de contrôle et des listings, et apprendre à récupérer des erreurs courantes. Tous les exemples privilégient les options non destructives et les étapes réversibles, afin que vous puissiez développer vos réflexes en toute confiance.

Qui cela aide

• Les développeurs qui ont besoin d'une utilisation fiable du shell au quotidien.
• Les consultants DevOps qui enseignent ou standardisent les pratiques d'équipe.
• Les équipes de startups qui souhaitent des habitudes opérationnelles cohérentes et à faible risque.

Ce que vous allez accomplir

• Une zone de pratique sécurisée sous votre répertoire personnel.
• Des motifs de commande pour la navigation, l'inspection, la gestion des fichiers, les permissions, la recherche, la surveillance des processus et l'archivage.
• Des étapes de vérification qui prouvent que vos modifications ont fonctionné.
• Des techniques de récupération pour les modes de défaillance courants.

Les exemples construits sont clairement identifiés. N'exécutez pas de commandes avec des privilèges élevés sauf si c'est requis et compris.

Inventaire de version et d'environnement

Avant d'exécuter toute commande, confirmez sur quoi vous travaillez. De petites différences dans le shell, la distribution et les permissions peuvent changer le comportement. Enregistrez les éléments suivants. Les sorties d'exemple sont des exemples construits.

uname -r
grep '^PRETTY_NAME' /etc/os-release
echo $SHELL
bash --version | head -1
echo $PATH
echo $HOME; pwd
umask; id
df -h "$HOME" | awk 'NR==2 {print $4}'

Sorties d'exemple construites (les vôtres seront différentes) :

Chemin de configuration sûr

La façon la plus sûre d'apprendre est d'opérer dans un laboratoire jetable au sein de votre répertoire personnel et d'utiliser des garde-fous qui demandent confirmation ou permettent un retour arrière.

1) Créer un laboratoire jetable

LAB="$HOME/tmp/linux-basic-commands-lab"
mkdir -p "$LAB"
cd "$LAB"
pwd

Résultat attendu : pwd affiche le chemin de votre laboratoire. Si le répertoire existait déjà, mkdir -p est sûr et n'écrase rien.

Initialiser le contenu d'exemple :

# Créer des fichiers et répertoires pour la pratique
mkdir -p docs src bin data
printf "alpha\nbeta\ngamma\n" > data/greek.txt
printf "one\ntwo\nthree\n" > data/numbers.txt
printf "user: x:1000:1000: User,,,:/home/user:/bin/bash\n" > data/passwd.sample
printf "#!/usr/bin/env bash\necho Hello" > bin/hello.sh
chmod +x bin/hello.sh

Vérification :

ls -l
ls -l data bin

Résultat attendu : les répertoires existent, les fichiers sont présents, bin/hello.sh est exécutable (bit x défini pour votre utilisateur).

2) Naviguer et inspecter en toute sécurité

• Afficher le répertoire de travail : pwd
• Lister avec détails et tailles lisibles : ls -alh
• Afficher les fichiers les plus récents en premier : ls -lt
• Limiter la profondeur avec find pour éviter les surprises : find . -maxdepth 2 -type f -printf '%p\n'
• Voir le contenu d'un fichier sans inonder le terminal : head -n 5 fichier, tail -n 5 fichier, less fichier (quitter avec q)

Exemples :

pwd
ls -alh
find . -maxdepth 2 -type f -print
head -n 2 data/greek.txt

Résultat attendu : listings clairs et premières lignes de greek.txt.

3) Créer, copier, déplacer et supprimer avec garde-fous

Options et habitudes plus sûres :

• Utiliser -i (interactif) avec cp, mv, rm pour confirmer les écrasements ou suppressions.
• Utiliser -- pour terminer l'analyse des options quand les noms de fichiers commencent par des tirets.
• Mettre les chemins avec espaces entre guillemets : "Mon Fichier.txt".
• Faire une sauvegarde rapide avant modification : cp -a fichier{,.bak}.

Exemples :

# Copier sans écraser les fichiers existants
cp -ai data/greek.txt docs/
cp -ai data/numbers.txt docs/

# Déplacer un fichier, demander confirmation si la destination existe
mv -i docs/greek.txt docs/greek.list

# Créer un fichier en toute sécurité, refuser d'écraser un existant
touch -- greek.new

# Supprimer avec confirmation (o pour supprimer, n pour annuler)
rm -i docs/greek.list

Vérification :

ls -l docs
test -f docs/numbers.txt && echo OK || echo MANQUANT

Résultat attendu : docs contient numbers.txt ; greek.list supprimé si vous avez confirmé la suppression.

4) Permissions que vous pouvez inverser

Opérez uniquement à l'intérieur de $LAB.

# Afficher les bits de permission
ls -l bin/hello.sh

# Retirer votre bit d'écriture et démontrer l'échec
chmod u-w bin/hello.sh
ls -l bin/hello.sh
# La tentative d'ajout devrait échouer avec Permission denied
echo '# more' >> bin/hello.sh || echo 'comme prévu : Permission denied'

# Restaurer le bit d'écriture
chmod u+w bin/hello.sh
ls -l bin/hello.sh

Résultat attendu : chmod bascule le bit d'écriture utilisateur ; l'ajout échoue quand u-w est défini ; réussit à nouveau après restauration.

Vérifier umask pour les permissions par défaut des fichiers :

umask

Valeurs typiques : 0022 ou 002. Gardez note pour le dépannage ultérieur.

5) Rechercher et filtrer du texte en toute sécurité

• Rechercher du texte récursivement : grep -R --line-number --color=auto MOTIF CHEMIN
• Correspondre aux mots entiers : grep -Rw "\<mot\>" CHEMIN
• Compter les lignes ou correspondances : wc -l fichier, grep -c MOTIF fichier
• Trier et compter les lignes uniques : sort fichier | uniq -c | sort -nr

Exemples :

# Trouver les occurrences de chiffres dans data
grep -R --line-number '[0-9]' data

# Compter les lignes dans greek.txt
wc -l data/greek.txt

# Afficher les lignes uniques à travers les fichiers data
cat data/*.txt | sort | uniq -c | sort -nr

Résultat attendu : lignes de numbers.txt correspondantes ; greek.txt a 3 lignes ; comptages uniques affichés.

6) Inspection des processus et du système

• Lister vos processus : ps -u "$USER" -o pid,ppid,cmd --sort=pid
• Format complet système : ps -ef | head
• Trouver les processus par nom : pgrep -af motif
• Vue rapide mémoire et CPU : top (quitter avec q)
• Résumé d'utilisation disque : df -h (systèmes de fichiers) et du -sh "$LAB" (répertoire)

Exemples :

ps -u "$USER" -o pid,ppid,cmd --sort=pid | head
pgrep -af bash
free -h || cat /proc/meminfo | head -5
df -h | head
du -sh "$LAB"

Résultat attendu : shells en cours d'exécution et résumés mémoire/disque apparaissent. Si free n'est pas disponible, /proc/meminfo fournit les détails.

7) Archivage et sommes de contrôle

• Créer une archive tar : tar -czf archive.tgz REPERTOIRE
• Lister le contenu d'une archive : tar -tzf archive.tgz | head
• Extraire : tar -xzf archive.tgz -C DESTINATION
• Générer des sommes de contrôle : sha256sum fichier

Exemples :

# Instantané du laboratoire
cd "$LAB"
tar -czf lab-snapshot.tgz .
sha256sum lab-snapshot.tgz > lab-snapshot.tgz.sha256

# Vérifier la somme de contrôle
sha256sum -c lab-snapshot.tgz.sha256

# Inspecter le contenu de l'archive sans extraire
tar -tzf lab-snapshot.tgz | head

Résultat attendu : la vérification de la somme de contrôle signale OK ; le listing de l'archive montre vos fichiers et répertoires.

8) Redirection et pipelines sans surprises

• Ajouter au lieu d'écraser : >> (plus sûr). Si vous devez écraser, envisagez une sauvegarde d'abord.
• Protéger contre l'écrasement avec : set -o noclobber (dans votre session shell courante), puis utiliser >| pour forcer l'écrasement uniquement quand c'est intentionnel.

Exemples :

set -o noclobber
printf 'sécurité-d\'abord\n' > data/safety.txt
# Le prochain écrasement devrait échouer à cause de noclobber
printf 'oups\n' > data/safety.txt || echo 'comme prévu : impossible d\'écraser'
# Forcer l'écrasement intentionnellement
printf 'écrasement\n' >| data/safety.txt
set +o noclobber

Vérification :

tail -n 1 data/safety.txt

Résultat attendu : la dernière ligne est "écrasement" après l'écrasement forcé.

9) Utilisation plus sûre de Find pour les modifications en masse

Prévisualiser avec print, puis appliquer en utilisant -exec seulement après examen.

# Prévisualiser les fichiers candidats d'abord
find "$LAB/data" -type f -name '*.txt' -print

# Après confirmation de la liste, les copier vers docs
find "$LAB/data" -type f -name '*.txt' -exec cp -ai '{}' "$LAB/docs/" ';'

Vérification :

ls -l "$LAB/docs" | grep '\.txt' || true

Résultat attendu : docs contient les fichiers .txt copiés.

Vérification et diagnostics

Les motifs de vérification vous gardent honnête et empêchent la dérive.

• Le répertoire existe et vous appartient :

[ -d "$LAB" ] && [ -w "$LAB" ] && echo OK || echo PAS_OK

• Intégrité de la copie avec taille et somme de contrôle :

cp -a data/greek.txt docs/greek.txt
stat --format '%s' data/greek.txt docs/greek.txt
sha256sum data/greek.txt docs/greek.txt

Résultat attendu : tailles égales ; sommes de contrôle identiques.

• Le changement de permission a pris effet :

before=$(stat -c '%A %a' bin/hello.sh)
chmod u-w bin/hello.sh
after=$(stat -c '%A %a' bin/hello.sh)
echo "before=$before after=$after"
chmod u+w bin/hello.sh

Résultat attendu : le bit d'écriture utilisateur bascule entre activé/désactivé.

• Confirmer quelle commande va s'exécuter :

which ls || type -a ls
command -V grep

Résultat attendu : chemins vers les binaires ou builtins du shell sont affichés.

• Confirmer les hypothèses d'environnement :

echo "SHELL=$SHELL"
echo "UMASK=$(umask)"

Résultat attendu : valeurs affichées pour audit ou inclusion dans un runbook.

Modes de défaillance et récupération

Cette section liste les pièges courants, comment les identifier et comment récupérer rapidement. Les exemples et nombres sont construits.

Motifs de retour arrière sur lesquels vous pouvez compter

• Sauvegarde locale avant modification pour fichiers uniques :

cp -a cible{,.bak}
# Plus tard, pour restaurer
diff -u cible.bak cible || true
mv -i cible.bak cible

• Instantané d'un répertoire avant modifications en masse :

cp -a rep rep.prechangement.$(date +%Y%m%d%H%M%S)
# Restaurer si nécessaire (remet l'ancienne copie en place)
rm -rf rep && mv rep.prechangement.* rep

Note : Utilisez ceci dans votre laboratoire. Pour les données de production, préférez des procédures de sauvegarde/restauration testées.

• Inverser les changements de permissions :

# Enregistrer l'état avant
stat -c '%a' fichier > fichier.perms
# Changer et tester
chmod g-w fichier
# Revenir en arrière
chmod $(cat fichier.perms) fichier

• Récupérer des fichiers déplacés ou mal placés :

# Rechercher depuis une racine connue
find "$LAB" -type f -name 'greek*' -print

Liste de contrôle des opérations

Utilisez cette liste courte pour exécuter les tâches de routine de façon sûre et cohérente.

Préparation

• Confirmer l'environnement : uname -r; grep '^PRETTY_NAME' /etc/os-release; echo $SHELL; umask
• S'assurer de l'espace dans $HOME : df -h "$HOME"
• Configurer le laboratoire : LAB="$HOME/tmp/linux-basic-commands-lab"; mkdir -p "$LAB"; cd "$LAB"

Navigation et inspection

• pwd; ls -alh; find . -maxdepth 2 -type f -print
• head/tail/less pour voir le contenu

Opérations sur fichiers (Utiliser les garde-fous)

• Copier : cp -ai SRC DST
• Déplacer/renommer : mv -i ANCIEN NOUVEAU
• Supprimer : rm -i FICHIER
• Sauvegarde rapide : cp -a fichier{,.bak}

Permissions

• Inspecter : ls -l FICHIER; stat -c '%A %a' FICHIER
• Changer (réversible) : chmod u-w FICHIER; chmod u+w FICHIER

Recherche et filtrage

• grep -R --line-number MOTIF CHEMIN
• wc -l FICHIER; sort FICHIER | uniq -c | sort -nr

État des processus et du système

• ps -u "$USER" -o pid,ppid,cmd --sort=pid | head
• df -h; du -sh "$LAB"

Archivage et sommes de contrôle

• tar -czf instantané.tgz .; sha256sum instantané.tgz > instantané.tgz.sha256
• sha256sum -c instantané.tgz.sha256

Vérification après modifications

• stat --format '%s' SRC DST; sha256sum SRC DST
• grep ou wc -l pour confirmer les attentes de contenu

Récupération

• Utiliser les sauvegardes : mv -i fichier.bak fichier
• Inverser les permissions : chmod $(cat fichier.perms) fichier
• Trouver les fichiers mal placés : find "$LAB" -type f -name 'motif'

Nettoyage (Quand terminé)

• cd "$HOME"; rm -rf "$LAB" (confirmer avec pwd d'abord)

Aide-mémoire concis des commandes courantes

Le tableau construit suivant résume les catégories, exemples et conseils de sécurité que vous pouvez adapter à vos propres runbooks.

Conclusion

Vous disposez maintenant d'une approche sûre et vérifiable des commandes Linux essentielles, incluant une disposition de laboratoire jetable, des options par défaut non destructives et des motifs de vérification reproductibles. Gardez les habitudes suivantes au premier plan : prévisualisez avec find ou printf avant d'agir ; privilégiez les confirmations -i et les sauvegardes avec cp -a fichier{,.bak} ; prouvez les résultats avec stat, les sommes de contrôle et les comptages de lignes ; enregistrez les états de permission avant de les modifier. Comme prochaine étape, adaptez la liste de contrôle et les tableaux à vos runbooks d'équipe. Commencez par un scénario pilote étroit et mesurable (comme la standardisation des routines de copie, déplacement et archivage dans les répertoires personnels) qui est facile à inspecter localement avant d'adopter dans des environnements partagés. Cela maintient le risque faible et construit une confiance opérateur cohérente.