Skip to content

Debian pour DevOps : Configuration et Maîtrise

🎯 Objectifs de ce cours

À la fin, tu seras capable de :

✅ Comprendre Debian : Son rôle dans l'écosystème DevOps, sa stabilité, pourquoi elle est le standard
✅ Naviguer efficacement : Structure des répertoires, fichiers clés, organisation du FS
✅ Configurer ton environnement : Personnaliser ~/.bashrc, créer des alias, gérer le PATH
✅ Utiliser les outils essentiels : Bash, systemd, SSH, editeurs, curl, et AWK
✅ Faire la différence UI vs Headless : Quand utiliser une GUI, quand rester en serveur headless

🐧 Debian : C'est Quoi Exactement ?

Définition Rapide

Debian est une distribution Linux communautaire, 100% open source, réputée pour sa stabilité extrême et sa fiabilité. C'est sur elle que reposent Ubuntu, Linux Mint, Kali Linux, et beaucoup d'autres.

Pourquoi Debian en DevOps ?

Critère Score Détail
Stabilité ⭐⭐⭐⭐⭐ Pas de mise à jour cassante. Parfait pour production
Communauté ⭐⭐⭐⭐⭐ 1000+ contributeurs, énorme documentation
Paquet APT ⭐⭐⭐⭐⭐ Gestion dépendances automatique, 59k packages
Serveurs ⭐⭐⭐⭐⭐ C'est la base de la plupart des VPS
Apprentissage ⭐⭐⭐⭐ Assez simple pour débuter, assez puissant pour le vrai travail

Résumé : Si tu vas faire du DevOps en production, Debian sera probablement ton OS.

Un Peu d'Histoire

  • 1993 : Ian Murdock crée Debian avec une vision radicale : un OS communautaire, gratuit, basé sur des principes open source stricts
  • 2004 : Ubuntu naît basée sur Debian (en gardant l'ADN)
  • Aujourd'hui : Debian est installée sur des millions de serveurs mondiaux

Ce qu'il faut retenir : Debian est LA fondation. Elle n'évolue pas vite, mais elle ne casse jamais.

📊 Structure des Répertoires Debian (FS)

Debian suit la norme FHS (Filesystem Hierarchy Standard). Voici les dossiers clés pour un DevOps :

Dossiers Critiques

/bin              → Commandes essentielles (ls, cp, rm, etc.)
/boot             → Fichiers de démarrage (kernel, bootloader)
/etc              → Configuration des applications (TRÈS IMPORTANT EN DEVOPS)
/home             → Dossiers personnels des utilisateurs
/lib              → Bibliothèques partagées (dépendances)
/opt              → Logiciels additionnels installés manuellement
/root             → Dossier personnel du root (admin)
/sbin             → Commandes système (pour root)
/usr              → Programmes et données système
/var              → Données variables (logs, databases, cache)

Les 3 Dossiers Clés pour DevOps

1️⃣ /etc - Configuration centrale

/etc/nginx          # Config Nginx
/etc/systemd        # Config services
/etc/security       # Permissions, sudoers
/etc/hosts          # Résolution DNS locale

Pourquoi c'est crucial ? C'est le cœur de la configuration. Chaque application a sa config ici.

2️⃣ /var/log - Les logs (VOTRE RADAR)

/var/log/syslog          # Logs système
/var/log/auth.log        # Logs authentification (SSH, sudo)
/var/log/nginx/          # Logs Nginx
/var/log/docker/         # Logs Docker

Pourquoi c'est crucial ? En DevOps, les logs sont votre première source d'info quand quelque chose casse.

3️⃣ /opt - Apps personnalisées

/opt/myapp          # Votre application custom
/opt/monitoring      # Votre stack monitoring

Pourquoi c'est crucial ? C'est où vous installez vos apps maison.

💻 UI vs Headless (Mode Serveur)

Avec Interface Graphique (UI)

Qu'est-ce que c'est ?
Debian avec GNOME, KDE, Xfce, etc. Fenêtres, souris, des icônes.

Quand l'utiliser :
- Machine de développement locale
- Postes de travail
- Apprentissage initial (c'est plus facile)

Problème : Bouffe des ressources (CPU, RAM). Jamais en production.

Headless (Sans GUI)

Qu'est-ce que c'est ?
Aucune interface graphique. Seulement le terminal. Léger, rapide, efficace.

Quand l'utiliser :
- ✅ Serveurs production (99% des cas)
- ✅ Conteneurs Docker
- ✅ VPS/Cloud
- ✅ Tout où vous accédez via SSH

Avantage : Moins de ressources, plus de sécurité (moins de surface d'attaque).

Réalité DevOps : Vous allez travailler 100% en headless. Acceptez-le dès maintenant.

⚙️ Configurer Votre Environnement Debian

Le Fichier ~/.bashrc (VOTRE CONFIG PERSONNELLE)

C'est le fichier magique qui s'exécute chaque fois que vous ouvrez un terminal.

# Afficher le contenu
cat ~/.bashrc

# Éditer (avec nano pour les débutants)
nano ~/.bashrc

Ce que l'on peut faire dedans :
- Créer des alias (raccourcis)
- Modifier le prompt (apparence du $)
- Définir des variables d'environnement
- Charger des fonctions personnalisées

🔗 Alias : Les Raccourcis DevOps

Au lieu de taper des commandes longues, créez des alias :

# Dans ~/.bashrc, ajoutez :
alias lsa='ls -la'                    # Liste détaillée
alias cls='clear'                     # Effacer l'écran
alias up='cd ..'                      # Aller au dossier parent
alias ports='netstat -tlnp'           # Voir les ports ouverts (DevOps!)
alias logs='tail -f /var/log/syslog'  # Suivre les logs en temps réel
alias dps='docker ps'                 # Voir les containers (si vous utilisez Docker)

Après modification :

source ~/.bashrc  # Rechargez la config

🎨 Personnaliser le Prompt (PS1)

L'invite de commande par défaut est user@host:path$. Vous pouvez la personnaliser :

# Simple mais informatif
PS1='\u@\h:\w\$ '

# Avec couleurs (pour les DevOps visuels !)
PS1='\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '

# Codes utiles :
# \u = utilisateur
# \h = hostname
# \w = répertoire actuel
# \t = temps
# \$ = $ ou # (si root)

📍 Variables d'Environnement

Les variables d'environnement sont des valeurs que tout programme peut lire. Exemples courants :

# Ajouter dans ~/.bashrc

# Java pour certaines apps
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64

# Langue
export LANG=en_US.UTF-8

# Proxy si vous en utlisez un
export http_proxy=http://proxy.example.com:8080
export https_proxy=http://proxy.example.com:8080

# Vérifier toutes les variables
env | sort

🛣️ PATH : Comment Linux Trouve les Commandes

C'est Quoi ?

PATH est une variable spéciale qui dit au système : "Cherche les programmes dans ces dossiers".

Visualiser le PATH

echo $PATH
# Résultat ressemble à :
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Quand vous tapez ls, Linux cherche dans ces dossiers (dans l'ordre) jusqu'à trouver ls.

Ajouter un Dossier au PATH (Temporaire)

Pour la session actuelle seulement :

export PATH=$PATH:/opt/myapp/bin

# Vérifier
echo $PATH

Dès qu'on ferme le terminal, c'est oublié.

Ajouter au PATH (Permanent)

Ajoutez cette ligne à ~/.bashrc :

# Éditer
nano ~/.bashrc

# Ajouter cette ligne à la fin
export PATH=$PATH:/opt/myapp/bin:/usr/local/go/bin

# Recharger
source ~/.bashrc

Cas DevOps courant : Ajouter des binaires customs, Go, Node, etc.

🛠️ Les Outils Essentiels Préinstallés

Debian vient avec 59k packages. Voici les plus importants pour DevOps :

1. 🐚 Bash (Shell)

C'est l'interpréteur de commandes. Vous l'utilisez tous les jours.

# Scripts basiques
bash myscript.sh

# Vérifier la version
bash --version

Vous l'utiliserez pour : Boucles, conditions, automatisation, cronjobs.

2. 🔧 systemd (Gestionnaire de Services)

C'est le système qui gère les services (Nginx, Docker, PostgreSQL, etc.)

# Voir l'état d'un service
systemctl status nginx

# Démarrer / Arrêter
systemctl start nginx
systemctl stop nginx

# Activer au démarrage
systemctl enable nginx

# Voir tous les services
systemctl list-units --type=service

Crucial en DevOps : Vous allez utiliser systemctl tous les jours.

3. 🔒 OpenSSH (Connexions sécurisées)

Pour se connecter à des serveurs distants :

# Connexion SSH basique
ssh user@host

# Avec clé privée
ssh -i ~/.ssh/id_rsa user@host

# Vérifier que SSH est lancé
sudo systemctl status ssh

# Voir les logs SSH (pour déboguer)
sudo tail -f /var/log/auth.log

Crucial en DevOps : SSH est votre cordon ombilical avec les serveurs.

4. ✏️ Vim et Nano (Éditeurs de Texte)

Pour éditer les fichiers de config rapidement.

Nano (plus facile pour débuter) :

nano /etc/nginx/nginx.conf

# Ctrl+O = Sauvegarder
# Ctrl+X = Quitter

Vim (plus puissant mais compliqué) :

vim /etc/nginx/nginx.conf

# ESC + :wq = Sauvegarder et quitter
# ESC + :q! = Quitter sans sauvegarder

Pro tip : Vim est 10x plus rapide si vous maîtrisez, mais Nano suffit pour débuter.

5. 📥 curl et wget (Télécharger du Web)

Pour récupérer des fichiers ou faire des requêtes HTTP.

# curl = plus polyvalent
curl https://api.example.com/data
curl -X POST -d "data" https://api.example.com

# wget = simple et orienté téléchargement
wget https://example.com/file.tar.gz
wget -r https://example.com/  # Télécharger un site entier

# curl avec authentification
curl -u user:password https://api.example.com

Cas DevOps : Tester des APIs, télécharger des packages, checker des URLs.

6. 🔍 AWK (Traitement de Texte Puissant)

AWK c'est magique pour parser des logs et fichiers texte.

# Afficher la 1ère colonne de chaque ligne
awk '{print $1}' /var/log/syslog

# Compter les lignes
awk 'END {print NR}' /var/log/syslog

# Filtrer et afficher
awk '/ERROR/ {print $1, $3, $5}' /var/log/syslog

# Calculs
awk '{sum += $2} END {print "Total:", sum}' data.txt

# Exemple réel : Voir les IPs qui se connectent en SSH
awk '/ssh/ {print $NF}' /var/log/auth.log | sort | uniq -c

Cas DevOps : Parser les logs, analyser les performances, extraire les données.

📋 Outils Bonus (Très Courants)

# grep = chercher du texte (ESSENTIEL)
grep "ERROR" /var/log/syslog

# sed = éditer du texte en masse
sed 's/oldtext/newtext/g' file.txt

# less = afficher des gros fichiers facilement
less /var/log/syslog

# find = chercher des fichiers
find /opt -name "*.log" -type f

# ps = voir les processus
ps aux | grep nginx

# top = surveiller les ressources en temps réel
top

# netstat = voir les connexions réseau
netstat -tlnp | grep LISTEN

📝 À faire en pratique - Votre Premier Jour sur Debian

  • ✅ Ouvrir un terminal et vérifier votre $PATH : echo $PATH
  • ✅ Éditer ~/.bashrc et ajouter 3 alias utiles
  • ✅ Taper source ~/.bashrc pour recharger
  • ✅ Tester vos alias
  • ✅ Afficher la structure avec tree /etc (ou ls -la /etc)
  • ✅ Lire les logs : tail -f /var/log/syslog
  • ✅ Voir les services : systemctl list-units --type=service
  • ✅ Faire un curl https://google.com pour tester la connection
  • ✅ Utiliser awk sur un fichier de log

🎯 Prochaines Étapes

Maintenant que vous comprenez Debian en tant que base, vous êtes prêt pour : - Administrer des services (Nginx, Docker, Databases) - Écrire des scripts (bash, Python) - Automatiser avec Ansible/Terraform - Déployer en production

Debian est votre fondation solide. Construisez dessus ! 🚀