Thursday, September 24, 2026

Linux & Commandes Shell

bts eii · seconde année

Linux & Commandes Shell

Un cours complet d'administration système — pensé pour le Raspberry Pi et les serveurs Debian/Ubuntu, avec toutes les commandes essentielles regroupées dans des fenêtres copiables. Ouvre un terminal et essaie chaque commande en direct.

8 chapitres +90 commandes fenêtres copiables 100% hors-ligne Debian · Ubuntu · RPi OS

1. Introduction à Linux

Linux est un système d'exploitation libre et open source créé en 1991 par Linus Torvalds. Il est basé sur le noyau Linux et suit la philosophie Unix. Le système complet est souvent appelé GNU/Linux car il combine le noyau Linux avec les outils GNU développés par Richard Stallman.

Pourquoi GNU/Linux ? Le nom complet est GNU/Linux : GNU fournit les outils utilisateurs (ls, cp, mv, bash…) et Linux fournit le noyau. Les deux projets sont indépendants mais indissociables.
Distributions populaires
DistributionBaseUsage principalGestionnaire
UbuntuDebianDesktop, Serveurapt
Debian—Serveur, Stabilitéapt
Raspberry Pi OSDebianRaspberry Pi, embarquéapt
FedoraRed HatDesktop, développementdnf
CentOS / RockyRed HatServeur entreprisednf/yum
Arch Linux—Avancé, rolling releasepacman
Au BTS EII : tu travailleras principalement sur Raspberry Pi OS (pour les projets embarqués) et parfois sur Ubuntu/Debian (pour les serveurs). Les commandes apt couvrent les deux.
Structure du système de fichiers (FHS)

Linux organise tout en une seule arborescence qui part de la racine /. Contrairement à Windows, il n'y a pas de lettre de lecteur (C:\, D:\) — tout est sous /.

fenêtre 1 — arborescence FHS
/                 # Racine du système
├── /bin           # Binaires essentiels (ls, cp, mv...)
├── /boot          # Fichiers de démarrage, noyau
├── /dev           # Fichiers de périphériques
├── /etc           # Fichiers de configuration
├── /home          # Répertoires utilisateurs
├── /lib           # Bibliothèques partagées
├── /mnt           # Points de montage temporaires
├── /opt           # Logiciels optionnels
├── /proc          # Informations processus (virtuel)
├── /root          # Home de l'utilisateur root
├── /tmp           # Fichiers temporaires
├── /usr           # Programmes utilisateurs
└── /var           # Données variables (logs, cache)
Le terminal et le shell

Le terminal est l'interface texte pour interagir avec le système. Le shell (généralement Bash) est l'interpréteur de commandes. Le prompt se compose de : utilisateur@hôte:répertoire_courant$ — le symbole change ($ pour un utilisateur normal, # pour root).

fenêtre 2 — anatomie d'un prompt
user@hostname:~$ commande -options arguments

# Exemples de prompts :
pi@raspberrypi:~$     # Utilisateur normal ($)
root@server:/etc#      # Utilisateur root (#)

2. Navigation dans le système

Se déplacer dans l'arborescence et lister les fichiers : ce sont les deux opérations les plus fréquentes sous Linux. Maîtrise-les, tu les utiliseras mille fois par jour.

Chemin de travail et déplacements
fenêtre 3 — pwd & cd
pwd                    # Print Working Directory — affiche le chemin actuel
cd /chemin             # Change Directory — se déplacer
cd ..                  # Remonter d'un niveau
cd ~                   # Aller au répertoire home
cd -                   # Retourner au répertoire précédent
cd                     # Sans argument = retour au home
Lister les fichiers (ls)

ls est la commande la plus utilisée après cd. Avec ses nombreuses options, elle peut afficher presque tout ce que tu veux savoir sur des fichiers.

fenêtre 4 — ls et ses options
ls                     # Liste simple
ls -l                  # Liste détaillée (permissions, taille, date)
ls -a                  # Afficher les fichiers cachés (commencent par .)
ls -la                 # Combinaison -l et -a
ls -lh                 # Tailles lisibles (Ko, Mo, Go)
ls -R                  # Liste récursive (sous-dossiers)
ls -lt                 # Trier par date de modification
ls -lS                 # Trier par taille
ls -lh /var/log/     # Liste détaillée d'un dossier précis
Lecture d'un ls -l : -rw-r--r-- 1 user group 1024 Jan 15 10:30 fichier.txt — Permissions | Liens | Propriétaire | Groupe | Taille | Date | Nom
Chemins absolus vs relatifs
TypeDescriptionExemple
AbsoluCommence par / (racine)/home/pi/documents
RelatifDepuis le répertoire actuel./documents ou documents
fenêtre 5 — symboles spéciaux
# Symboles spéciaux
.    # Répertoire actuel
..   # Répertoire parent
~    # Home de l'utilisateur (/home/user)
-    # Répertoire précédent (cd -)

3. Gestion des fichiers

Créer, copier, déplacer, supprimer — les opérations de base que tu feras en permanence sur n'importe quel système Linux.

Créer des fichiers et dossiers
fenêtre 6 — créer fichiers & dossiers
touch fichier.txt      # Créer un fichier vide (ou MAJ date)
mkdir dossier           # Créer un répertoire
mkdir -p a/b/c         # Créer une arborescence complète
echo "texte" > fichier # Créer avec contenu (écrase)
echo "texte" >> fichier # Ajouter à la fin (append)
Copier et déplacer
fenêtre 7 — cp & mv
cp source destination       # Copier un fichier
cp -r dossier/ dest/       # Copier récursivement (dossiers)
cp -i source dest           # Demander confirmation si existe
cp -v source dest           # Mode verbose (affiche les actions)

mv source destination       # Déplacer ou renommer
mv ancien.txt nouveau.txt   # Renommer un fichier
mv -i source dest           # Confirmation si écrasement
Supprimer
fenêtre 8 — rm & rmdir
rm fichier              # Supprimer un fichier
rm -r dossier/          # Supprimer récursivement
rm -f fichier           # Forcer (sans confirmation)
rm -rf dossier/         # Forcer récursivement ⚠️ DANGEREUX
rm -i fichier           # Demander confirmation
rmdir dossier           # Supprimer dossier VIDE uniquement
ATTENTION : rm -rf / ou rm -rf * peut détruire tout le système ! Il n'y a pas de corbeille sous Linux en ligne de commande. Toujours vérifier avant d'exécuter. Sur le Raspberry Pi, garde toujours une copie de ta carte SD.
Afficher le contenu d'un fichier
fenêtre 9 — cat, less, head, tail, wc
cat fichier             # Afficher tout le contenu
less fichier            # Afficher avec pagination (q pour quitter)
more fichier            # Pagination simple
head fichier            # Premières 10 lignes
head -n 20 fichier     # Premières 20 lignes
tail fichier            # Dernières 10 lignes
tail -f fichier         # Suivre en temps réel (logs)
wc fichier              # Compter lignes, mots, caractères
wc -l fichier           # Compter uniquement les lignes
Astuce : tail -f /var/log/syslog est indispensable pour suivre les logs en temps réel sur un Raspberry Pi ou un serveur. Combiné à grep error tu détectes immédiatement les problèmes.
Rechercher : find & grep
fenêtre 10 — find & grep
find /chemin -name "*.txt"    # Chercher par nom
find . -type f                  # Chercher fichiers uniquement
find . -type d                  # Chercher dossiers uniquement
find . -size +10M               # Fichiers > 10 Mo

grep "motif" fichier           # Chercher dans un fichier
grep -r "motif" dossier/      # Chercher récursivement
grep -i "motif" fichier       # Ignorer la casse
grep -n "motif" fichier       # Afficher numéros de ligne
grep -v "motif" fichier       # Inverser (lignes SANS motif)

4. Permissions et propriété

Sous Linux, chaque fichier a un propriétaire et des permissions. C'est l'un des piliers de la sécurité du système. Le modèle est simple mais strict : trois catégories (utilisateur, groupe, autres) × trois droits (lecture, écriture, exécution).

Comprendre les permissions
fenêtre 11 — décodage des permissions
# Format : -rwxrwxrwx
#          │└┬┘└┬┘└┬┘
#          │ │  │  └── Autres (o)
#          │ │  └───── Groupe (g)
#          │ └──────── Propriétaire (u)
#          └────────── Type (- fichier, d dossier, l lien)

# Signification :
r = read    (lecture)    = 4
w = write   (écriture)   = 2
x = execute (exécution)  = 1
- = aucune  permission    = 0
OctalBinairePermissionsDescription
7111rwxLecture + Écriture + Exécution
6110rw-Lecture + Écriture
5101r-xLecture + Exécution
4100r--Lecture seule
0000---Aucune permission
Modifier les permissions : chmod
fenêtre 12 — chmod symbolique & octal
# Mode symbolique
chmod u+x script.sh     # Ajouter exécution au propriétaire
chmod g-w fichier       # Retirer écriture au groupe
chmod o=r fichier       # Définir lecture seule pour autres
chmod a+r fichier       # Ajouter lecture à tous (all)

# Mode octal (le plus courant)
chmod 755 script.sh     # rwxr-xr-x (scripts exécutables)
chmod 644 fichier.txt   # rw-r--r-- (fichiers normaux)
chmod 700 secret/       # rwx------ (privé)
chmod 777 fichier       # rwxrwxrwx (tout le monde) ⚠️ à éviter
chmod -R 755 dossier/  # Récursif sur dossier
Propriété : chown & chgrp
fenêtre 13 — chown & chgrp
chown user fichier           # Changer le propriétaire
chown user:group fichier     # Changer propriétaire et groupe
chown -R user dossier/      # Récursivement
chgrp group fichier          # Changer uniquement le groupe
sudo — SuperUser DO

sudo permet d'exécuter une commande avec les privilèges root (administrateur). Sur Ubuntu/Raspberry Pi OS, le premier utilisateur créé a automatiquement les droits sudo.

fenêtre 14 — sudo
sudo commande           # Exécuter en tant que root
sudo -i                  # Ouvrir un shell root
sudo -u user commande  # Exécuter en tant qu'autre utilisateur
sudo !!                 # Répéter dernière commande avec sudo
Règle de sécurité : n'utilise sudo que quand c'est nécessaire, et jamais dans un script non vérifié. Rester en root en permanence est dangereux : une mauvaise commande peut détruire le système.

5. Gestion des processus

Un processus est un programme en cours d'exécution. Sous Linux, chaque processus a un identifiant unique appelé PID (Process ID). Savoir lister, surveiller et tuer un processus est essentiel en administration système.

Afficher les processus
fenêtre 15 — ps, top, htop, pgrep
ps                      # Processus du terminal actuel
ps aux                  # Tous les processus (format BSD)
ps -ef                  # Tous les processus (format System V)
ps aux | grep nom      # Filtrer par nom

top                     # Moniteur temps réel (q pour quitter)
htop                    # Moniteur amélioré (si installé)

pgrep nom               # Trouver PID par nom
pidof programme         # PID d'un programme
Colonnes importantes de ps aux : USER (propriétaire), PID (identifiant), %CPU (utilisation processeur), %MEM (mémoire), COMMAND (la commande lancée). Pour un serveur saturé, tri par %CPU ou %MEM pour trouver le coupable.
Contrôler les processus
fenêtre 16 — kill, jobs, fg/bg
kill PID                # Terminer un processus (SIGTERM, propre)
kill -9 PID             # Forcer l'arrêt (SIGKILL, brutal)
killall nom             # Tuer par nom
pkill motif             # Tuer par motif de nom

# Gestion de l'avant / arrière-plan
commande &              # Lancer en arrière-plan
jobs                    # Lister les jobs en arrière-plan
fg                      # Ramener au premier plan
bg                      # Continuer en arrière-plan
Ctrl+Z                  # Suspendre le processus actuel
Ctrl+C                  # Interrompre le processus actuel
Services systemd

Depuis 2015, la majorité des distributions utilisent systemd pour gérer les services (daemons). Un service est un programme qui tourne en arrière-plan en permanence (serveur web, SSH, cron…).

fenêtre 17 — systemctl
sudo systemctl start   service    # Démarrer
sudo systemctl stop    service    # Arrêter
sudo systemctl restart service    # Redémarrer
sudo systemctl status  service    # État du service
sudo systemctl enable  service    # Activer au démarrage
sudo systemctl disable service    # Désactiver au démarrage
systemctl list-units --type=service --state=running  # Services actifs

6. Commandes réseau

Qu'il s'agisse de configurer un Raspberry Pi en Wi-Fi, de diagnostiquer un problème de connexion ou de se connecter à un serveur distant, les commandes réseau sont incontournables.

Configuration IP
fenêtre 18 — ip & hostname
ip addr                 # Afficher les interfaces (moderne)
ip a                    # Alias court
ifconfig                # Afficher interfaces (ancien, déprécié)
hostname -I             # Adresse IP locale uniquement

ip link set eth0 up    # Activer une interface
ip link set eth0 down  # Désactiver une interface
Diagnostic réseau
fenêtre 19 — ping, traceroute, netstat, dig
ping google.com         # Tester la connectivité
ping -c 4 192.168.1.1   # 4 pings seulement

traceroute google.com   # Tracer le chemin réseau
tracepath google.com    # Alternative sans root

netstat -tuln           # Ports en écoute
ss -tuln                # Alternative moderne à netstat

nslookup google.com     # Résolution DNS
dig google.com          # Requête DNS détaillée

curl https://example.com   # Tester une page web
wget https://example.com/file # Télécharger un fichier
Diagnostic typique d'un Raspberry Pi : ping 8.8.8.8 teste la connexion IP, ping google.com teste le DNS. Si le premier marche et pas le second → problème DNS. Si aucun ne marche → problème de routage/IP.
SSH — Secure Shell

SSH est le protocole standard pour administrer un serveur Linux à distance. Une fois la connexion SSH ouverte, tu obtiens un shell complet comme si tu étais devant la machine.

fenêtre 20 — ssh & scp
ssh user@192.168.1.10        # Connexion SSH standard
ssh -p 2222 user@host        # Port personnalisé
ssh-keygen                       # Générer clés SSH (id_rsa)
ssh-copy-id user@host         # Copier clé publique

scp fichier user@host:/chemin   # Copier vers serveur
scp user@host:/chemin local    # Copier depuis serveur
scp -r dossier/ user@host:    # Copier dossier
Sécurité SSH : sur un Raspberry Pi exposé à Internet, désactive immédiatement le login par mot de passe et active uniquement l'authentification par clé. Sinon ton Pi sera scanné et piraté en quelques heures.

7. Gestion des paquets

Un gestionnaire de paquets installe, met à jour et supprime les logiciels. Chaque famille de distributions a le sien : apt pour Debian/Ubuntu/Raspberry Pi OS, dnf pour Fedora/RHEL, pacman pour Arch.

APT (Debian / Ubuntu / Raspberry Pi OS)
fenêtre 21 — apt : installer, mettre à jour, supprimer
sudo apt update              # Mettre à jour la liste des paquets
sudo apt upgrade             # Mettre à jour les paquets installés
sudo apt full-upgrade        # Mise à jour complète (peut supprimer)

sudo apt install paquet     # Installer un paquet
sudo apt remove paquet      # Désinstaller (garde la config)
sudo apt purge paquet       # Désinstaller + supprimer la config
sudo apt autoremove          # Supprimer paquets orphelins

apt search mot-cle           # Rechercher un paquet
apt show paquet              # Informations sur un paquet
apt list --installed         # Lister les paquets installés
Workflow typique sur Raspberry Pi : avant toute installation, fais toujours sudo apt update puis sudo apt upgrade. Cela met à jour l'index des paquets disponibles et évite d'installer une version obsolète.
Comparatif des gestionnaires
DistributionGestionnaireInstallerMettre à jour
Debian / Ubuntu / RPi OSaptapt install pkgapt update && apt upgrade
Fedora / RHELdnfdnf install pkgdnf upgrade
Arch Linuxpacmanpacman -S pkgpacman -Syu
Alpineapkapk add pkgapk upgrade

8. Scripts Bash

Un script Bash est un fichier texte contenant une suite de commandes shell, exécuté de haut en bas. C'est l'outil de base pour automatiser toute tâche d'administration : sauvegarde, monitoring, déploiement, installation.

Structure d'un script

La première ligne #!/bin/bash (appelée shebang) indique au système d'utiliser Bash pour interpréter le fichier. Sans elle, le script s'exécute avec le shell par défaut, ce qui peut varier.

fenêtre 22 — script complet d'exemple
#!/bin/bash
# Mon premier script — sauvegarde du dossier Documents

# Variables
NOM="Documents"
VERSION=$(uname -r)

# Affichage
echo "Bienvenue dans $NOM"
echo "Version du noyau : $VERSION"

# Condition
if [ -f /etc/passwd ]; then
    echo "Le fichier existe"
fi

# Boucle
for i in 1 2 3; do
    echo "Itération $i"
done
📌 Pour exécuter ce script, copie-le dans un fichier script.sh, puis chmod +x script.sh et ./script.sh.
Variables et arguments
fenêtre 23 — variables & arguments
# Variables
VAR="valeur"           # Pas d'espace autour de =
echo $VAR              # Utiliser la variable
echo "${VAR}_suite"    # Avec accolades

# Arguments du script
$0                     # Nom du script
$1, $2, $3...          # Arguments positionnels
$#                     # Nombre d'arguments
$@                     # Tous les arguments
$?                     # Code retour dernière commande

# Substitution de commande
DATE=$(date +%Y-%m-%d)
FILES=$(ls -1 | wc -l)
Tests et conditions
fenêtre 24 — tests fichiers, chaînes, numériques
# Tests sur fichiers
[ -f fichier ]    # Fichier existe
[ -d dossier ]    # Dossier existe
[ -r fichier ]    # Fichier lisible
[ -w fichier ]    # Fichier modifiable
[ -x fichier ]    # Fichier exécutable

# Tests sur chaînes
[ -z "$VAR" ]     # Chaîne vide
[ -n "$VAR" ]     # Chaîne non vide
[ "$A" = "$B" ]   # Égalité
[ "$A" != "$B" ]  # Différence

# Tests numériques
[ $A -eq $B ]    # Égal (equal)
[ $A -ne $B ]    # Différent (not equal)
[ $A -lt $B ]    # Inférieur (less than)
[ $A -gt $B ]    # Supérieur (greater than)
[ $A -le $B ]    # Inférieur ou égal
[ $A -ge $B ]    # Supérieur ou égal
Redirections et pipes
fenêtre 25 — redirections & pipes
# Redirections
commande >  fichier     # Sortie vers fichier (écrase)
commande >> fichier     # Sortie vers fichier (ajoute)
commande <  fichier     # Entrée depuis fichier
commande 2> erreurs     # Erreurs vers fichier
commande &> tout        # Sortie + erreurs
commande 2>/dev/null   # Ignorer les erreurs

# Pipes (chaîner les commandes)
cat fichier | grep motif | wc -l
ps aux | grep apache | awk '{print $2}'
ls -la | sort -k5 -n   # Trier par taille
Exécuter un script
fenêtre 26 — exécuter un script
# Rendre exécutable
chmod +x script.sh

# Exécuter
./script.sh            # Depuis le répertoire actuel
bash script.sh         # Avec bash explicite
source script.sh       # Dans le shell actuel
. script.sh            # Alias de source
Bon réflexe : avant d'écrire un script, essaie chaque commande manuellement dans ton terminal. Une fois que toutes les commandes marchent une par une, assemble-les dans un fichier et ajoute la gestion d'erreurs. Tu éviteras ainsi 90% des bugs.
Cours Linux & Shell — BTS 2EII — Lycée Moulay Youssef, Tanger