diff --git a/01-introduction-concepts.md b/01-introduction-concepts.md
new file mode 100644
index 0000000..a3645b3
--- /dev/null
+++ b/01-introduction-concepts.md
@@ -0,0 +1,71 @@
+# 01 - Introduction à Git et au versionnage
+
+[🏠 Accueil](README.md) | [02 - Installation et Configuration →](02-installation-configuration.md)
+
+---
+
+## 1. Qu'est-ce que Git ?
+
+**Git** est un système de contrôle de version distribué créé par Linus Torvalds en 2005.
+C'est l'outil le plus utilisé au monde pour gérer les versions de code source et suivre l'historique des modifications d'un projet.
+
+![Git Logo](https://git-scm.com/images/logos/downloads/Git-Logo-2Color.png)
+
+### Pourquoi Git est essentiel en DevOps Azure ?
+
+En DevOps Azure, tout est code : les infrastructures (Terraform, Bicep), les pipelines CI/CD, les configurations Kubernetes, les scripts Azure CLI. Git est le fil conducteur qui relie chaque modification à un contexte et une personne.
+
+- **🏗️ Versionnage de l'Infrastructure as Code** : Suivez chaque modification de vos fichiers Terraform, Bicep ou ARM templates.
+- **🤝 Collaboration d'équipe** : Plusieurs ingénieurs travaillent simultanément sur la même infrastructure sans écraser leurs modifications.
+- **🔄 Reproductibilité** : Retournez à l'état exact de votre infrastructure à n'importe quel point dans le temps.
+- **🚀 Intégration CI/CD** : Déclenchez automatiquement un `terraform apply` ou un déploiement AKS à chaque merge sur `main`.
+- **🔍 Audit et conformité** : Identifiez qui a modifié une règle de sécurité, un RBAC ou un pare-feu Azure, quand et pourquoi.
+
+---
+
+## 2. Les concepts fondamentaux
+
+| Concept | Description | Analogie DevOps |
+|---|---|---|
+| **Repository (Dépôt)** | Conteneur qui stocke tout l'historique du projet | Un dépôt Terraform avec tout son historique |
+| **Commit** | Snapshot de vos fichiers à un instant T | Un état figé de votre infrastructure Azure |
+| **Branch (Branche)** | Ligne de développement indépendante | Un environnement de staging isolé |
+| **Merge (Fusion)** | Combinaison de deux branches | Promotion d'une feature en production |
+| **Remote** | Version du dépôt hébergée sur un serveur | Votre repo GitHub ou Azure DevOps Repos |
+
+---
+
+## 3. Architecture Git : Distribué vs Centralisé
+
+Contrairement aux systèmes centralisés (SVN, CVS), Git est **distribué**. Chaque ingénieur possède une copie complète de l'historique, permettant de travailler hors ligne et de créer des branches sans toucher au serveur central.
+
+### Les trois états de Git
+
+1. **Working Directory** : Vos fichiers actuels (`main.tf`, `deployment.yaml`, etc.).
+2. **Staging Area (Index)** : Zone de préparation avant le commit.
+3. **Repository (.git)** : Base de données contenant tout l'historique.
+
+```text
+Working Directory  ─────►  Staging Area  ─────►  Repository
+   (main.tf modifié)         (Préparé)            (Commité)
+```
+
+---
+
+## 4. Git dans l'écosystème DevOps Azure
+
+Git est la pierre angulaire de toute la chaîne DevOps :
+
+```
+Code / IaC        CI/CD              Cloud Azure
+──────────        ──────             ───────────
+git push    →   GitHub Actions   →   az deployment
+            →   terraform plan   →   Azure Resources
+            →   docker build     →   ACR / AKS
+```
+
+Les plateformes principales utilisées en entreprise pour héberger les dépôts Git sont **GitHub** (avec GitHub Actions pour le CI/CD) et **Azure DevOps Repos** (avec Azure Pipelines).
+
+---
+
+[🏠 Accueil](README.md) | [02 - Installation et Configuration →](02-installation-configuration.md)
diff --git a/02-installation-configuration.md b/02-installation-configuration.md
new file mode 100644
index 0000000..bb6c20b
--- /dev/null
+++ b/02-installation-configuration.md
@@ -0,0 +1,134 @@
+# 02 - Installation et Configuration
+
+[← 01 - Introduction](01-introduction-concepts.md) | [🏠 Accueil](README.md) | [03 - Premiers pas →](03-premiers-pas.md)
+
+---
+
+## 1. Installation de Git
+
+### 🍎 macOS
+```bash
+# Avec Homebrew
+brew install git
+# Ou via Xcode
+xcode-select --install
+```
+
+### 🐧 Linux (Debian/Ubuntu)
+```bash
+sudo apt-get update
+sudo apt-get install git
+```
+
+### 🪟 Windows
+Téléchargez Git depuis [git-scm.com](https://git-scm.com/download/win) ou installez [Git for Windows](https://gitforwindows.org/).
+
+---
+
+## 2. Configuration initiale (OBLIGATOIRE)
+
+Avant votre premier commit, vous devez configurer votre identité :
+
+```bash
+# Identité (apparaîtra dans l'historique)
+git config --global user.name "Votre Prénom Nom"
+git config --global user.email "votre.email@example.com"
+
+# Éditeur par défaut (ex: VS Code)
+git config --global core.editor "code --wait"
+
+# Branche par défaut
+git config --global init.defaultBranch main
+```
+
+### Voir la configuration
+```bash
+git config --list
+```
+
+---
+
+## 3. Les Alias : Gagner du temps
+Créez des raccourcis pour les commandes fréquentes :
+
+```bash
+git config --global alias.st status
+git config --global alias.co checkout
+git config --global alias.br branch
+git config --global alias.ci commit
+git config --global alias.lg 'log --oneline --graph --all --decorate'
+```
+
+Usage : `git st` au lieu de `git status`.
+
+---
+
+## 4. Authentification SSH (Recommandé)
+
+L'authentification par **clé SSH** est plus sécurisée et plus pratique que le mot de passe : vous n'avez plus à vous authentifier à chaque `push` ou `pull`.
+
+### Étape 1 : Générer une paire de clés SSH
+
+```bash
+# Générer une clé ED25519 (algorithme moderne et recommandé)
+ssh-keygen -t ed25519 -C "votre.email@example.com"
+
+# Laisser le chemin par défaut (~/.ssh/id_ed25519)
+# Définir une passphrase (optionnel mais conseillé)
+```
+
+### Étape 2 : Démarrer l'agent SSH et ajouter la clé
+
+```bash
+# Démarrer l'agent SSH en arrière-plan
+eval "$(ssh-agent -s)"
+
+# Ajouter votre clé privée à l'agent
+ssh-add ~/.ssh/id_ed25519
+```
+
+### Étape 3 : Copier la clé publique
+
+```bash
+# Afficher la clé publique (à copier)
+cat ~/.ssh/id_ed25519.pub
+```
+
+### Étape 4 : Ajouter la clé sur GitHub / GitLab
+
+**GitHub** : `Settings` → `SSH and GPG keys` → `New SSH key` → Coller la clé publique.
+
+**GitLab** : `Preferences` → `SSH Keys` → Coller la clé publique.
+
+### Étape 5 : Tester la connexion
+
+```bash
+# GitHub
+ssh -T git@github.com
+# Réponse attendue : "Hi username! You've successfully authenticated..."
+
+# GitLab
+ssh -T git@gitlab.com
+```
+
+### Utiliser SSH au lieu de HTTPS
+
+```bash
+# Cloner avec SSH (au lieu de HTTPS)
+git clone git@github.com:username/mon-projet.git
+
+# Changer un remote existant de HTTPS vers SSH
+git remote set-url origin git@github.com:username/mon-projet.git
+```
+
+> 💡 **Astuce** : Sur macOS, ajoutez ces lignes dans `~/.ssh/config` pour que la passphrase soit mémorisée dans le trousseau :
+> ```
+> Host github.com
+>   AddKeysToAgent yes
+>   UseKeychain yes
+>   IdentityFile ~/.ssh/id_ed25519
+> ```
+
+---
+
+[← 01 - Introduction](01-introduction-concepts.md) | [🏠 Accueil](README.md) | [03 - Premiers pas →](03-premiers-pas.md)
diff --git a/03-premiers-pas.md b/03-premiers-pas.md
new file mode 100644
index 0000000..8430a48
--- /dev/null
+++ b/03-premiers-pas.md
@@ -0,0 +1,110 @@
+# 03 - Premiers pas : Créer et gérer un dépôt
+
+[← 02 - Configuration](02-installation-configuration.md) | [🏠 Accueil](README.md) | [04 - Maîtrise des branches →](04-maitrise-branches.md)
+
+---
+
+## 1. Initialiser ou Cloner un dépôt
+
+### Nouveau projet local
+```bash
+mkdir infra-azure
+cd infra-azure
+git init
+```
+
+### Récupérer un projet existant
+```bash
+# Via HTTPS
+git clone https://github.com/username/infra-azure.git
+
+# Via SSH (recommandé, voir module 02)
+git clone git@github.com:username/infra-azure.git
+```
+
+---
+
+## 2. Le cycle de vie d'un fichier
+
+En DevOps Azure, vos fichiers sont typiquement des configurations IaC (`.tf`, `.bicep`), des manifests Kubernetes (`.yaml`) ou des scripts Azure CLI (`.sh`).
+
+### Vérifier l'état
+```bash
+git status
+```
+
+### Ajouter des modifications (Staging)
+```bash
+git add main.tf              # Fichier Terraform spécifique
+git add kubernetes/           # Tout un dossier de manifests
+git add .                    # Tout le dossier actuel
+```
+
+### Créer un commit (Snapshot)
+```bash
+git commit -m "feat: add AKS cluster Terraform module"
+```
+
+---
+
+## 3. Consulter l'historique
+
+### Liste des commits
+```bash
+git log                # Complet
+git log --oneline      # Résumé (idéal pour voir les changements d'infra)
+git log --graph        # Vue graphique des branches
+```
+
+### Voir les modifications d'un commit
+```bash
+git show <commit_hash>
+# Affiche le diff exact : quelles lignes de main.tf ont changé
+```
+
+### Voir les différences non committées
+```bash
+git diff               # Working directory vs Staging
+git diff --staged      # Staging vs dernier commit
+```
+
+---
+
+## 4. Structure typique d'un dépôt IaC Azure
+
+```
+infra-azure/
+├── terraform/
+│   ├── main.tf          # Ressources principales
+│   ├── variables.tf     # Déclaration des variables
+│   ├── outputs.tf       # Valeurs exportées
+│   └── versions.tf      # Contraintes de versions
+├── kubernetes/
+│   ├── deployment.yaml
+│   └── service.yaml
+├── scripts/
+│   └── bootstrap.sh     # Script Azure CLI d'initialisation
+├── .github/
+│   └── workflows/
+│       └── deploy.yml   # Pipeline CI/CD GitHub Actions
+├── .gitignore
+└── README.md
+```
+
+---
+
+## 💡 Conseil : Commits atomiques en IaC
+
+Un commit IaC doit représenter **une seule ressource ou une seule décision d'architecture**. Ne mélangez pas la création d'un AKS et la configuration d'un Key Vault dans le même commit. Cela facilite les revues et les retours en arrière en cas d'incident.
+
+```bash
+# ✅ Bon : un commit = une ressource
+git commit -m "feat: add Azure Key Vault for secrets management"
+
+# ❌ Mauvais : tout dans un commit
+git commit -m "update infra"
+```
+
+---
+
+[← 02 - Configuration](02-installation-configuration.md) | [🏠 Accueil](README.md) | [04 - Maîtrise des branches →](04-maitrise-branches.md)
diff --git a/04-maitrise-branches.md b/04-maitrise-branches.md
new file mode 100644
index 0000000..090d493
--- /dev/null
+++ b/04-maitrise-branches.md
@@ -0,0 +1,132 @@
+# 04 - Maîtriser les branches
+
+[← 03 - Premiers pas](03-premiers-pas.md) | [🏠 Accueil](README.md) | [05 - Collaboration et Remotes →](05-collaboration-remotes.md)
+
+---
+
+## 1. Pourquoi utiliser des branches ?
+Les branches permettent d'isoler le développement. En DevOps Azure, chaque modification d'infrastructure (nouveau module Terraform, mise à jour d'un manifest Kubernetes, ajout d'un pipeline) passe par une branche dédiée avant d'être fusionnée dans `main` — qui représente l'état **déployé en production**.
+
+---
+
+## 2. Gérer les branches
+
+### Créer et naviguer
+```bash
+git branch feature/aks-cluster       # Créer
+git switch feature/aks-cluster       # Basculer
+# OU (syntaxe moderne pour créer et changer)
+git switch -c feature/aks-cluster
+```
+
+### Nommage recommandé en DevOps Azure
+
+| Préfixe | Usage | Exemple |
+|---|---|---|
+| `feature/` | Nouvelle ressource ou fonctionnalité | `feature/keyvault-integration` |
+| `fix/` | Correction de configuration | `fix/nsg-rule-typo` |
+| `hotfix/` | Correctif urgent en production | `hotfix/aks-node-pool-crash` |
+| `release/` | Préparation d'une version | `release/v2.1.0` |
+| `chore/` | Maintenance (docs, refacto) | `chore/update-providers` |
+
+### Fusionner (Merge)
+```bash
+git switch main
+git merge feature/aks-cluster
+```
+
+---
+
+## 3. Stratégies courantes
+
+**GitHub Flow** : Une branche `main` stable, chaque feature part de `main` et y retourne après review. Adapté aux déploiements continus (CD) où chaque merge déclenche un `terraform apply`.
+
+**Git Flow** : Plus structuré, avec branches `develop`, `release` et `hotfix`. Recommandé quand vous gérez plusieurs environnements Azure (dev, staging, prod) avec des cycles de release planifiés.
+
+---
+
+## 4. Résoudre les conflits
+
+Un conflit survient quand deux branches modifient la même ligne — par exemple, deux ingénieurs qui ont chacun modifié la taille d'un node pool AKS dans `main.tf`.
+
+1. Tentez le merge : `git merge feature/X`.
+2. Si conflit, ouvrez le fichier et cherchez les marqueurs `<<<<<<<`, `=======`, `>>>>>>>`.
+3. Éditez pour garder le bon code (concertez-vous avec le collègue !).
+4. Marquez comme résolu : `git add <fichier>`.
+5. Finalisez : `git commit`.
+
+---
+
+## 5. Rebase : Réécrire l'historique proprement
+
+Le `rebase` est une alternative au `merge`. Au lieu de créer un commit de fusion, il **réapplique** vos commits sur la pointe d'une autre branche, produisant un historique linéaire et lisible.
+
+### Rebase simple
+
+```bash
+# Situation : vous êtes sur feature/aks-cluster
+# et main a avancé depuis que vous avez branché
+
+git switch feature/aks-cluster
+git rebase main
+# Git réapplique vos commits un par un sur la pointe de main
+```
+
+**Avant rebase :**
+```
+main:    A──B──C
+feature:    \──D──E
+```
+
+**Après rebase :**
+```
+main:    A──B──C
+feature:          D'──E'
+```
+
+### Rebase interactif : `git rebase -i`
+
+Le rebase interactif permet de **nettoyer vos commits avant de les partager** : fusionner des micro-commits, reformuler des messages, supprimer des commits inutiles.
+
+```bash
+# Réécrire les 3 derniers commits
+git rebase -i HEAD~3
+```
+
+Un éditeur s'ouvre avec la liste de vos commits :
+
+```
+pick a1b2c3 feat: add AKS node pool configuration
+pick d4e5f6 fix typo in variables.tf
+pick g7h8i9 wip: debug output
+
+# Commandes disponibles :
+# pick   = conserver le commit tel quel
+# reword = conserver mais modifier le message
+# squash = fusionner avec le commit précédent
+# drop   = supprimer le commit
+```
+
+**Exemple : fusionner les 3 commits en un seul**
+
+```
+pick a1b2c3 feat: add AKS node pool configuration
+squash d4e5f6 fix typo in variables.tf
+squash g7h8i9 wip: debug output
+```
+
+Git fusionnera les trois en un seul commit propre et vous demandera de rédiger le message final.
+
+### Merge vs Rebase : quand choisir ?
+
+| Situation | Recommandation |
+|---|---|
+| Branche partagée avec l'équipe | `merge` (ne pas réécrire l'historique public) |
+| Branche locale avant une PR | `rebase` (historique propre et linéaire) |
+| Synchroniser sa feature avec main | `rebase main` |
+
+> ⚠️ **Règle d'or** : Ne jamais faire de `rebase` sur une branche déjà poussée et partagée avec d'autres développeurs. Cela réécrit l'historique et crée des conflits pour tout le monde.
+
+---
+
+[← 03 - Premiers pas](03-premiers-pas.md) | [🏠 Accueil](README.md) | [05 - Collaboration et Remotes →](05-collaboration-remotes.md)
diff --git a/05-collaboration-remotes.md b/05-collaboration-remotes.md
new file mode 100644
index 0000000..4ebdcec
--- /dev/null
+++ b/05-collaboration-remotes.md
@@ -0,0 +1,75 @@
+# 05 - Collaboration avec des dépôts distants
+
+[← 04 - Branches](04-maitrise-branches.md) | [🏠 Accueil](README.md) | [06 - Commandes Avancées →](06-commandes-avancees-debogage.md)
+
+---
+
+## 1. Qu'est-ce qu'un remote ?
+
+C'est la version de votre dépôt hébergée sur un serveur. En DevOps Azure, vous utiliserez principalement **GitHub** (avec GitHub Actions) ou **Azure DevOps Repos** (avec Azure Pipelines).
+
+### Gérer les remotes
+```bash
+git remote add origin git@github.com:mon-org/infra-azure.git
+git remote -v          # Voir la liste des remotes
+git remote remove origin   # Supprimer un remote
+```
+
+---
+
+## 2. Synchroniser le code
+
+### Envoyer (Push)
+```bash
+git push origin main
+git push -u origin feature/aks-cluster   # -u lie la branche locale à la distante
+```
+
+### Récupérer (Fetch / Pull)
+
+- **Fetch** : Télécharge les commits distants sans les fusionner — utile pour inspecter avant d'intégrer.
+- **Pull** : Télécharge ET fusionne (Fetch + Merge).
+
+```bash
+git fetch origin         # Inspecter sans risque
+git pull origin main     # Récupérer et fusionner
+```
+
+---
+
+## 3. Workflow collaboratif DevOps Azure
+
+En équipe, chaque modification d'infrastructure passe par une **Pull Request (PR)** — aussi appelée **Merge Request** sur GitLab/Azure DevOps. Cela garantit qu'une revue humaine a lieu avant tout déploiement.
+
+```
+1. Pull les dernières modifs de main
+2. Créer une branche feature/fix
+3. Modifier les fichiers IaC (Terraform, Bicep, YAML)
+4. Commit et Push la branche
+5. Ouvrir une Pull Request
+6. Revue du code + terraform plan automatique (CI)
+7. Approbation et Merge dans main
+8. Déploiement automatique déclenché (CD)
+```
+
+### Bonnes pratiques pour une PR d'infrastructure
+
+- **Titre clair** : `feat: add AKS cluster with autoscaling` plutôt que `update infra`
+- **Description** : expliquer *pourquoi* le changement, pas juste *quoi*
+- **Lier un ticket** : `Closes #42` pour tracer la décision
+- **Inclure le plan Terraform** : joindre la sortie de `terraform plan` en commentaire pour faciliter la review
+
+---
+
+## 4. Protection de la branche `main`
+
+En entreprise, la branche `main` est **protégée** : personne ne peut pusher directement dessus. Tout passe par une PR approuvée. Configurez cela dans :
+
+**GitHub** : `Settings → Branches → Add branch protection rule`
+- ✅ Require pull request reviews before merging
+- ✅ Require status checks to pass (votre CI/CD)
+- ✅ Restrict who can push to matching branches
+
+---
+
+[← 04 - Branches](04-maitrise-branches.md) | [🏠 Accueil](README.md) | [06 - Commandes Avancées →](06-commandes-avancees-debogage.md)
diff --git a/06-commandes-avancees-debogage.md b/06-commandes-avancees-debogage.md
new file mode 100644
index 0000000..70d98f5
--- /dev/null
+++ b/06-commandes-avancees-debogage.md
@@ -0,0 +1,129 @@
+# 06 - Commandes avancées et débogage
+
+[← 05 - Collaboration](05-collaboration-remotes.md) | [🏠 Accueil](README.md) | [07 - Meilleures Pratiques DevOps →](07-meilleures-pratiques-devops.md)
+
+---
+
+## 1. Annuler des modifications
+
+### Restaurer un fichier (Undo local)
+```bash
+# Annuler les modifications locales sur un fichier IaC
+git restore main.tf
+git restore kubernetes/deployment.yaml
+```
+
+### Unstage un fichier
+```bash
+# Retirer du staging sans perdre les modifications
+git restore --staged main.tf
+```
+
+### Annuler des commits (Reset)
+
+- `--soft` : Annule le commit, garde les modifs stagées — utile pour reformuler un message.
+- `--mixed` : Annule le commit et le staging, garde les fichiers modifiés.
+- `--hard` : Annule tout (⚠️ DANGER : perte de données).
+
+```bash
+# Annuler le dernier commit mais garder les modifications
+git reset --soft HEAD~1
+
+# Annuler complètement (uniquement si jamais pushé)
+git reset --hard HEAD~1
+```
+
+> ⚠️ **Règle d'or** : N'utilisez jamais `reset --hard` sur des commits déjà poussés vers le remote. Utilisez `git revert` à la place (crée un commit d'annulation sans réécrire l'historique).
+
+```bash
+# Annuler un commit déjà pushé, en toute sécurité
+git revert <commit_hash>
+```
+
+---
+
+## 2. Stash : Mettre de côté
+
+Utile quand vous devez changer de branche en urgence (ex: hotfix de prod) sans committer un travail inachevé sur votre module Terraform.
+
+```bash
+git stash                                    # Sauvegarder le travail en cours
+git stash push -m "wip: AKS node pool config"  # Avec un message descriptif
+git stash list                               # Voir la liste des stashs
+git stash pop                                # Récupérer et supprimer le dernier
+git stash apply stash@{1}                    # Appliquer sans supprimer
+```
+
+---
+
+## 3. Débogage et Recherche
+
+### Blame : qui a modifié quoi ?
+
+Indispensable en audit : identifier qui a modifié une règle de sécurité ou une configuration réseau.
+
+```bash
+git blame main.tf
+git blame kubernetes/deployment.yaml
+```
+
+### Bisect : trouver le commit fautif
+
+`git bisect` effectue une recherche binaire dans l'historique pour identifier quel commit a introduit un problème (ex: une règle NSG qui bloque du trafic).
+
+```bash
+git bisect start
+git bisect bad                  # Le commit actuel est cassé
+git bisect good v1.2.0          # Cette version fonctionnait
+
+# Git vous positionne sur un commit intermédiaire
+# Testez, puis indiquez :
+git bisect good   # ou
+git bisect bad
+
+# Quand Git a trouvé le commit fautif :
+git bisect reset  # Revenir à l'état normal
+```
+
+### Reflog : votre filet de sécurité ultime
+
+Le reflog enregistre **toutes** les actions Git, même les reset. Si vous avez supprimé des commits par erreur, le reflog vous sauve.
+
+```bash
+git reflog                        # Voir tout l'historique des actions
+git checkout HEAD@{3}             # Revenir à l'état d'il y a 3 actions
+```
+
+---
+
+## 4. Tags : versionner vos releases Azure
+
+Les tags marquent les versions déployées en production. En DevOps Azure, un tag déclenche souvent un pipeline de déploiement.
+
+```bash
+# Créer un tag annoté
+git tag -a v1.2.0 -m "Release: add AKS autoscaling and Key Vault integration"
+
+# Pousser le tag vers le remote (déclencheur CI/CD possible)
+git push origin v1.2.0
+
+# Pousser tous les tags
+git push origin --tags
+
+# Lister les tags
+git tag -l
+```
+
+### Utilisation dans GitHub Actions
+
+```yaml
+# Déclencher un déploiement Azure uniquement sur un tag
+on:
+  push:
+    tags:
+      - 'v*'
+```
+
+---
+
+[← 05 - Collaboration](05-collaboration-remotes.md) | [🏠 Accueil](README.md) | [07 - Meilleures Pratiques DevOps →](07-meilleures-pratiques-devops.md)
diff --git a/07-meilleures-pratiques-devops.md b/07-meilleures-pratiques-devops.md
new file mode 100644
index 0000000..318cde8
--- /dev/null
+++ b/07-meilleures-pratiques-devops.md
@@ -0,0 +1,154 @@
+# 07 - Meilleures pratiques pour le DevOps Azure
+
+[← 06 - Avancé](06-commandes-avancees-debogage.md) | [🏠 Accueil](README.md) | [08 - Workflows et Automation →](08-workflows-automation.md)
+
+---
+
+## 1. Le .gitignore : Critique pour l'IaC Azure
+
+En Infrastructure as Code, certains fichiers ne doivent **jamais** être versionnés : états Terraform, credentials Azure, fichiers générés. Un secret commité est un secret compromis.
+
+```gitignore
+# ============================================
+# TERRAFORM
+# ============================================
+# État Terraform (contient des données sensibles en clair)
+*.tfstate
+*.tfstate.*
+.terraform/
+.terraform.lock.hcl
+
+# Fichiers de plan (peuvent contenir des secrets)
+*.tfplan
+
+# Variables locales (surcharges personnelles)
+*.auto.tfvars
+!example.tfvars          # Garder les fichiers d'exemple
+
+# ============================================
+# AZURE CREDENTIALS & SECRETS
+# ============================================
+.env
+.env.*
+!.env.example            # Garder le template
+*.pem
+*.key
+service-principal.json
+azure-credentials.json
+
+# ============================================
+# HELM / KUBERNETES
+# ============================================
+charts/*.tgz
+values-prod.yaml         # Valeurs de production avec secrets
+
+# ============================================
+# OUTILS & IDE
+# ============================================
+.DS_Store
+.idea/
+.vscode/settings.json    # Garder .vscode/extensions.json
+__pycache__/
+*.pyc
+```
+
+### Utiliser les secrets Azure Key Vault
+
+Ne stockez jamais de secrets dans Git. Utilisez **Azure Key Vault** :
+
+```bash
+# Récupérer un secret depuis Key Vault dans un pipeline
+az keyvault secret show \
+  --vault-name mon-keyvault \
+  --name "db-password" \
+  --query value -o tsv
+```
+
+Dans GitHub Actions, utilisez les **GitHub Secrets** pour stocker les credentials du Service Principal Azure.
+
+---
+
+## 2. Conventional Commits
+
+Les messages de commit structurés permettent de générer des changelogs automatiques et de déclencher des actions CI/CD conditionnelles.
+
+| Préfixe | Usage DevOps Azure | Exemple |
+|---|---|---|
+| `feat:` | Nouvelle ressource Azure | `feat: add Azure Container Registry` |
+| `fix:` | Correction de configuration | `fix: correct NSG inbound rule for port 443` |
+| `docs:` | Documentation | `docs: add runbook for AKS scaling` |
+| `chore:` | Maintenance, mise à jour | `chore: bump azurerm provider to 3.85` |
+| `perf:` | Optimisation | `perf: enable AKS node autoprovisioning` |
+| `ci:` | Pipeline CI/CD | `ci: add terraform plan step on PR` |
+| `refactor:` | Restructuration IaC | `refactor: split network module from main.tf` |
+
+### Format complet
+
+```
+<type>(<scope>): <description courte>
+
+[Corps optionnel : expliquer le POURQUOI, pas le QUOI]
+
+[Footer : liens, breaking changes]
+```
+
+**Exemple réel :**
+
+```
+feat(aks): add autoscaling to node pool
+
+Enable cluster autoscaler with min 2 / max 10 nodes to handle
+peak loads without manual intervention.
+
+Closes #87
+```
+
+---
+
+## 3. Structurer son dépôt IaC
+
+Un dépôt bien structuré facilite la collaboration et la navigation.
+
+### Structure recommandée (mono-repo)
+
+```
+infra-azure/
+├── modules/               # Modules Terraform réutilisables
+│   ├── aks/
+│   │   ├── main.tf
+│   │   ├── variables.tf
+│   │   └── outputs.tf
+│   ├── network/
+│   └── keyvault/
+├── environments/          # Configuration par environnement
+│   ├── dev/
+│   │   ├── main.tf        # Appelle les modules
+│   │   └── terraform.tfvars
+│   ├── staging/
+│   └── prod/
+├── kubernetes/            # Manifests K8s par application
+│   └── app-backend/
+├── .github/workflows/     # Pipelines CI/CD
+├── .gitignore
+└── README.md
+```
+
+---
+
+## 4. Git LFS pour les artefacts binaires
+
+Si votre dépôt contient de gros fichiers binaires (certificats, archives Helm, images de base), utilisez **Git LFS** pour ne pas alourdir le dépôt.
+
+```bash
+# Installer Git LFS
+git lfs install
+
+# Tracker les fichiers .tgz (archives Helm)
+git lfs track "*.tgz"
+git add .gitattributes
+git commit -m "chore: configure Git LFS for Helm archives"
+```
+
+---
+
+[← 06 - Avancé](06-commandes-avancees-debogage.md) | [🏠 Accueil](README.md) | [08 - Workflows et Automation →](08-workflows-automation.md)
diff --git a/08-workflows-automation.md b/08-workflows-automation.md
new file mode 100644
index 0000000..10b3a10
--- /dev/null
+++ b/08-workflows-automation.md
@@ -0,0 +1,252 @@
+# 08 - Workflows et Automation
+
+[← 07 - Pratiques DevOps](07-meilleures-pratiques-devops.md) | [🏠 Accueil](README.md) | [09 - Exercices →](09-exercices.md)
+
+---
+
+## 1. Pre-commit Hooks pour l'IaC Azure
+
+Les hooks Git sont des scripts exécutés automatiquement avant chaque commit. En DevOps Azure, ils permettent de valider la qualité de votre code Terraform, YAML et Bicep **avant** qu'il n'atteigne le dépôt.
+
+### Installation
+
+```bash
+pip install pre-commit
+```
+
+### Configuration : `.pre-commit-config.yaml`
+
+```yaml
+# .pre-commit-config.yaml
+repos:
+  # Vérifications générales
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace       # Espaces en fin de ligne
+      - id: end-of-file-fixer         # Saut de ligne final
+      - id: check-yaml                # Syntaxe YAML (K8s, pipelines)
+      - id: check-added-large-files   # Bloque fichiers > 500 KB
+        args: ['--maxkb=500']
+      - id: detect-private-key        # Détecte les clés privées accidentelles
+
+  # Formatage et validation Terraform
+  - repo: https://github.com/antonbabenko/pre-commit-terraform
+    rev: v1.88.0
+    hooks:
+      - id: terraform_fmt             # Formate automatiquement les .tf
+      - id: terraform_validate        # Valide la syntaxe Terraform
+      - id: terraform_tflint          # Linting Terraform (bonnes pratiques)
+      - id: terraform_docs            # Génère la doc des modules
+
+  # Linting YAML (manifests Kubernetes, pipelines)
+  - repo: https://github.com/adrienverge/yamllint
+    rev: v1.35.1
+    hooks:
+      - id: yamllint
+        args: ['--strict']
+
+  # Détection de secrets dans le code (Azure credentials, tokens)
+  - repo: https://github.com/Yelp/detect-secrets
+    rev: v1.4.0
+    hooks:
+      - id: detect-secrets
+        args: ['--baseline', '.secrets.baseline']
+```
+
+### Activation
+
+```bash
+# Installer les hooks (une seule fois par développeur)
+pre-commit install
+
+# Tester sur tous les fichiers existants
+pre-commit run --all-files
+
+# Mettre à jour les versions des hooks
+pre-commit autoupdate
+```
+
+---
+
+## 2. CI/CD GitHub Actions pour Azure
+
+GitHub Actions permet de déclencher automatiquement des validations et déploiements Azure à chaque modification du dépôt.
+
+### Workflow complet : Terraform sur Azure
+
+```yaml
+# .github/workflows/terraform.yml
+name: Terraform Azure CI/CD
+
+on:
+  pull_request:
+    branches: [ main ]
+  push:
+    branches: [ main ]
+
+env:
+  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+
+jobs:
+  terraform-validate:
+    name: Validate
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Terraform
+        uses: hashicorp/setup-terraform@v3
+        with:
+          terraform_version: '1.7.0'
+
+      - name: Terraform Init
+        run: terraform init
+        working-directory: ./environments/prod
+
+      - name: Terraform Format Check
+        run: terraform fmt -check -recursive
+
+      - name: Terraform Validate
+        run: terraform validate
+        working-directory: ./environments/prod
+
+  terraform-plan:
+    name: Plan
+    needs: terraform-validate
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Terraform
+        uses: hashicorp/setup-terraform@v3
+
+      - name: Terraform Init
+        run: terraform init
+        working-directory: ./environments/prod
+
+      - name: Terraform Plan
+        id: plan
+        run: terraform plan -no-color -out=tfplan
+        working-directory: ./environments/prod
+
+      # Publier le plan en commentaire de la PR
+      - name: Comment PR with Plan
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const output = `#### Terraform Plan 📋
+            \`\`\`
+            ${{ steps.plan.outputs.stdout }}
+            \`\`\``;
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: output
+            })
+
+  terraform-apply:
+    name: Apply
+    needs: terraform-validate
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Terraform
+        uses: hashicorp/setup-terraform@v3
+
+      - name: Terraform Init
+        run: terraform init
+        working-directory: ./environments/prod
+
+      - name: Terraform Apply
+        run: terraform apply -auto-approve
+        working-directory: ./environments/prod
+```
+
+### Déclencheurs courants (`on:`)
+
+| Déclencheur | Usage DevOps Azure |
+|---|---|
+| `pull_request` | Lancer `terraform plan` et afficher le diff en PR |
+| `push: branches: [main]` | Lancer `terraform apply` après merge |
+| `push: tags: ['v*']` | Déployer une release versionnée |
+| `workflow_dispatch` | Déploiement manuel depuis l'interface GitHub |
+| `schedule` | Audit de conformité quotidien |
+
+---
+
+## 3. Git + Docker + Azure Container Registry (ACR)
+
+En DevOps Azure, les images Docker sont poussées vers **Azure Container Registry (ACR)** et déployées sur **AKS**. Le hash du commit Git garantit la traçabilité.
+
+### Tagger une image avec le hash Git
+
+```bash
+COMMIT_HASH=$(git rev-parse --short HEAD)
+ACR_NAME="monregistry.azurecr.io"
+IMAGE="mon-app"
+
+# Construire
+docker build -t ${ACR_NAME}/${IMAGE}:${COMMIT_HASH} .
+
+# S'authentifier sur ACR
+az acr login --name monregistry
+
+# Pousser
+docker push ${ACR_NAME}/${IMAGE}:${COMMIT_HASH}
+```
+
+### Workflow GitHub Actions : Build → ACR → AKS
+
+```yaml
+name: Build and Deploy to AKS
+
+on:
+  push:
+    branches: [ main ]
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login Azure
+        uses: azure/login@v2
+        with:
+          creds: ${{ secrets.AZURE_CREDENTIALS }}
+
+      - name: Build and push to ACR
+        run: |
+          COMMIT_HASH=$(git rev-parse --short HEAD)
+          az acr build \
+            --registry monregistry \
+            --image mon-app:${COMMIT_HASH} \
+            --image mon-app:latest .
+
+      - name: Deploy to AKS
+        uses: azure/k8s-deploy@v4
+        with:
+          manifests: kubernetes/deployment.yaml
+          images: monregistry.azurecr.io/mon-app:${{ github.sha }}
+```
+
+> 🔍 **Traçabilité** : L'image `mon-app:a3f5c12` en production correspond exactement au commit `a3f5c12` dans Git. En cas d'incident, `git show a3f5c12` révèle le changement exact qui a causé le problème.
+
+---
+
+[← 07 - Pratiques DevOps](07-meilleures-pratiques-devops.md) | [🏠 Accueil](README.md) | [09 - Exercices →](09-exercices.md)
diff --git a/09-exercices.md b/09-exercices.md
new file mode 100644
index 0000000..da38e5e
--- /dev/null
+++ b/09-exercices.md
@@ -0,0 +1,60 @@
+# 09 - Exercices : Pratique de Git en DevOps Azure
+
+[← 08 - Automation](08-workflows-automation.md) | [🏠 Accueil](README.md) | [10 - Projet Fil Rouge →](10-projet-fil-rouge.md)
+
+---
+
+## 📝 Niveau 1 : Bases
+
+1. Configurez votre identité Git (nom, email) et votre éditeur par défaut.
+2. Initialisez un dépôt nommé `git-devops-practice`.
+3. Créez un fichier `versions.tf` contenant la contrainte de version Terraform suivante et faites votre premier commit :
+   ```hcl
+   terraform {
+     required_version = ">= 1.5.0"
+     required_providers {
+       azurerm = {
+         source  = "hashicorp/azurerm"
+         version = "~> 3.85"
+       }
+     }
+   }
+   ```
+4. Créez un alias `git lg` pour `log --oneline --graph --all --decorate`.
+5. Configurez la branche par défaut sur `main`.
+
+---
+
+## 🌿 Niveau 2 : Branches
+
+1. Créez une branche `feature/add-resource-group`.
+2. Ajoutez un fichier `main.tf` avec une ressource Azure Resource Group vide et committez avec un message conventionnel (`feat:`).
+3. Retournez sur `main` et fusionnez la branche.
+4. Supprimez la branche feature.
+5. **Bonus** : Reproduisez l'exercice en utilisant `rebase` au lieu de `merge`, puis comparez l'historique avec `git log --graph`.
+
+---
+
+## 🤝 Niveau 3 : Collaboration
+
+1. Créez un dépôt sur GitHub nommé `git-devops-practice`.
+2. Liez votre dépôt local au remote via SSH.
+3. Poussez votre branche `main`.
+4. Créez une branche `feature/add-vnet`, ajoutez un fichier `network.tf` avec un commentaire, et poussez-la.
+5. Ouvrez une Pull Request sur GitHub depuis `feature/add-vnet` vers `main`, ajoutez une description expliquant le changement, puis fusionnez-la.
+6. Récupérez le résultat en local (`git pull`) et supprimez la branche locale.
+
+---
+
+## 🔒 Niveau 4 : Sécurité et bonnes pratiques
+
+1. Créez un fichier `.gitignore` adapté à un projet Terraform + Azure (ignorez les fichiers `.tfstate`, `.terraform/`, `.env`).
+2. Créez volontairement un fichier `.env` contenant `AZURE_CLIENT_SECRET=mon_secret`, tentez de le commiter, et vérifiez que `.gitignore` l'empêche.
+3. Installez `pre-commit` et configurez un hook `detect-private-key`. Testez qu'il bloque un commit contenant une fausse clé privée.
+4. Créez un tag `v0.1.0` annoté sur votre dernier commit et poussez-le vers GitHub.
+
+[📖 Voir les solutions](11-solutions.md)
+
+---
+
+[← 08 - Automation](08-workflows-automation.md) | [🏠 Accueil](README.md) | [10 - Projet Fil Rouge →](10-projet-fil-rouge.md)
diff --git a/10-projet-fil-rouge.md b/10-projet-fil-rouge.md
new file mode 100644
index 0000000..cf3a43b
--- /dev/null
+++ b/10-projet-fil-rouge.md
@@ -0,0 +1,132 @@
+# 10 - Projet Fil Rouge : Déploiement d'une infrastructure AKS sur Azure
+
+[← 09 - Exercices](09-exercices.md) | [🏠 Accueil](README.md) | [11 - Solutions →](11-solutions.md)
+
+---
+
+## 🎯 Objectif
+
+Versionner et déployer une infrastructure Azure complète en utilisant Git selon le **Git Flow** : features, releases et hotfix. Ce projet simule les conditions réelles d'un Ingénieur DevOps Azure en entreprise.
+
+## 📋 Scénario
+
+Vous êtes Ingénieur DevOps chez **CloudOps Corp.** Votre mission : versionner le déploiement d'un cluster AKS avec son infrastructure réseau et son pipeline CI/CD, de la conception jusqu'au correctif en production.
+
+## 🌿 Schéma Git Flow du projet
+
+```
+main         ●─────────────────────────────●──────────────────●
+              \                           / \                  /
+develop        ●──────────●─────────────●   \                /
+                \         /                  \              /
+feature/...      ●───────●    release/v1.0.0  ●────────────●
+                                              hotfix/v1.0.1 ●──●
+```
+
+---
+
+## 🛠️ Phases du projet
+
+### Phase 1 : Initialisation
+
+**Contexte :** Le projet démarre. Vous posez les fondations du dépôt IaC.
+
+1. Initialisez le dépôt Git local nommé `infra-aks-cloudops`.
+2. Créez la structure de dossiers suivante :
+   ```
+   infra-aks-cloudops/
+   ├── modules/
+   │   ├── aks/
+   │   │   ├── main.tf
+   │   │   ├── variables.tf
+   │   │   └── outputs.tf
+   │   └── network/
+   │       ├── main.tf
+   │       └── variables.tf
+   ├── environments/
+   │   └── prod/
+   │       ├── main.tf
+   │       └── terraform.tfvars.example
+   ├── kubernetes/
+   │   └── .gitkeep
+   ├── .github/
+   │   └── workflows/
+   │       └── terraform.yml
+   ├── .gitignore
+   └── README.md
+   ```
+3. Configurez un `.gitignore` robuste (état Terraform, secrets Azure, fichiers générés).
+4. Faites un premier commit sur `main` : `"chore: initial IaC project structure"`.
+5. Créez la branche `develop` à partir de `main`.
+
+---
+
+### Phase 2 : Développement Feature
+
+**Contexte :** Vous développez le module Terraform pour créer le cluster AKS.
+
+1. Depuis `develop`, créez la branche `feature/aks-cluster-module`.
+2. Dans `modules/aks/main.tf`, écrivez la ressource Terraform `azurerm_kubernetes_cluster` avec un node pool par défaut.
+3. Dans `modules/aks/variables.tf`, déclarez les variables `cluster_name`, `resource_group_name`, `location`, `node_count`.
+4. Dans `modules/aks/outputs.tf`, exportez `kube_config` et `cluster_id`.
+5. Committez : `"feat(aks): add AKS cluster Terraform module"`.
+6. Dans `environments/prod/main.tf`, appelez le module AKS avec les valeurs de production.
+7. Committez : `"feat(prod): wire AKS module in production environment"`.
+8. Fusionnez `feature/aks-cluster-module` dans `develop`.
+9. Supprimez la branche feature.
+
+---
+
+### Phase 3 : Release
+
+**Contexte :** Le module AKS est validé, vous préparez la mise en production.
+
+1. Depuis `develop`, créez la branche `release/v1.0.0`.
+2. Mettez à jour le `README.md` avec les prérequis (Azure CLI, Terraform, permissions RBAC) et les instructions de déploiement.
+3. Committez : `"docs: add deployment instructions for v1.0.0"`.
+4. Complétez le workflow GitHub Actions `terraform.yml` avec les jobs `validate`, `plan` (sur PR) et `apply` (sur merge dans `main`).
+5. Committez : `"ci: add Terraform CI/CD pipeline for Azure"`.
+6. Fusionnez `release/v1.0.0` dans `main`.
+7. Taguez la version : `git tag -a v1.0.0 -m "Production release: AKS cluster v1.0.0"`.
+8. Fusionnez également `release/v1.0.0` dans `develop` (synchronisation).
+9. Supprimez la branche release.
+
+---
+
+### Phase 4 : Hotfix
+
+**Contexte :** 🚨 En production, une alerte de sécurité est levée ! Le cluster AKS a été créé avec l'API Server accessible publiquement (`api_server_authorized_ip_ranges` vide). Il faut restreindre l'accès en urgence directement depuis `main`.
+
+1. Depuis `main` (le code en production), créez la branche `hotfix/v1.0.1`.
+2. Dans `modules/aks/main.tf`, ajoutez la variable `api_server_authorized_ip_ranges` et appliquez-la sur la ressource `azurerm_kubernetes_cluster`.
+3. Dans `modules/aks/variables.tf`, déclarez la nouvelle variable avec une liste de CIDRs autorisés.
+4. Committez : `"fix(aks): restrict API server access to authorized IP ranges"`.
+5. Fusionnez `hotfix/v1.0.1` dans `main`.
+6. Taguez la correction : `git tag -a v1.0.1 -m "Security hotfix: restrict AKS API server access"`.
+7. Fusionnez `hotfix/v1.0.1` dans `develop`.
+8. Supprimez la branche hotfix.
+
+> ⚠️ **Règle d'or Git Flow** : Un hotfix part toujours de `main` (l'état de production) et doit être fusionné dans **les deux branches** : `main` ET `develop`.
+
+---
+
+## 📦 Livrable attendu
+
+À la fin du projet, vérifiez votre historique avec `git log --oneline --graph --all` :
+
+```
+* (tag: v1.0.1) Merge hotfix/v1.0.1 into main
+* fix(aks): restrict API server access to authorized IP ranges
+* (tag: v1.0.0) Merge release/v1.0.0 into main
+* ci: add Terraform CI/CD pipeline for Azure
+* docs: add deployment instructions for v1.0.0
+* feat(prod): wire AKS module in production environment
+* feat(aks): add AKS cluster Terraform module
+* chore: initial IaC project structure
+```
+
+[📖 Voir les solutions](11-solutions.md)
+
+---
+
+[← 09 - Exercices](09-exercices.md) | [🏠 Accueil](README.md) | [11 - Solutions →](11-solutions.md)
diff --git a/11-solutions.md b/11-solutions.md
new file mode 100644
index 0000000..e32e6ef
--- /dev/null
+++ b/11-solutions.md
@@ -0,0 +1,472 @@
+# 11 - Solutions des exercices
+
+[← 10 - Projet Fil Rouge](10-projet-fil-rouge.md) | [🏠 Accueil](README.md)
+
+---
+
+## 📝 Solution Niveau 1 : Bases
+
+```bash
+# Identité
+git config --global user.name "Nom Prénom"
+git config --global user.email "email@cloudops.com"
+
+# Éditeur par défaut
+git config --global core.editor "code --wait"
+
+# Branche par défaut
+git config --global init.defaultBranch main
+
+# Créer le dépôt
+mkdir git-devops-practice && cd git-devops-practice
+git init
+
+# Créer le fichier versions.tf et committer
+cat > versions.tf << 'EOF'
+terraform {
+  required_version = ">= 1.5.0"
+  required_providers {
+    azurerm = {
+      source  = "hashicorp/azurerm"
+      version = "~> 3.85"
+    }
+  }
+}
+EOF
+
+git add versions.tf
+git commit -m "chore: add Terraform version constraints"
+
+# Alias utiles
+git config --global alias.lg 'log --oneline --graph --all --decorate'
+git config --global alias.st status
+```
+
+---
+
+## 🌿 Solution Niveau 2 : Branches
+
+```bash
+# Créer et basculer sur la branche feature
+git switch -c feature/add-resource-group
+
+# Créer main.tf avec une ressource Azure Resource Group
+cat > main.tf << 'EOF'
+resource "azurerm_resource_group" "main" {
+  name     = var.resource_group_name
+  location = var.location
+}
+EOF
+
+git add main.tf
+git commit -m "feat: add Azure Resource Group resource"
+
+# Retourner sur main et fusionner
+git switch main
+git merge feature/add-resource-group
+
+# Supprimer la branche feature
+git branch -d feature/add-resource-group
+
+# --- BONUS : Même exercice avec rebase ---
+git switch -c feature/add-rg-v2
+echo '# network' > network.tf
+git add network.tf
+git commit -m "feat: add network placeholder"
+
+git switch main
+git switch -c feature/add-rg-v2
+# Simuler une avancée de main
+echo "# updated" >> versions.tf
+git add versions.tf
+git commit -m "chore: update comment"
+
+git switch feature/add-rg-v2
+git rebase main   # Historique linéaire, sans commit de merge
+
+git switch main
+git merge feature/add-rg-v2   # Fast-forward propre
+git branch -d feature/add-rg-v2
+
+# Comparer avec un merge classique :
+git log --oneline --graph
+```
+
+---
+
+## 🤝 Solution Niveau 3 : Collaboration
+
+```bash
+# 1. Lier le dépôt local à GitHub via SSH
+git remote add origin git@github.com:votre-user/git-devops-practice.git
+
+# 2. Pousser la branche main
+git push -u origin main
+
+# 3. Créer et pousser une branche feature
+git switch -c feature/add-vnet
+
+cat > network.tf << 'EOF'
+resource "azurerm_virtual_network" "main" {
+  name                = "vnet-cloudops-prod"
+  address_space       = ["10.0.0.0/16"]
+  location            = var.location
+  resource_group_name = var.resource_group_name
+}
+EOF
+
+git add network.tf
+git commit -m "feat(network): add Azure Virtual Network"
+git push -u origin feature/add-vnet
+
+# 4. Ouvrir une Pull Request depuis GitHub :
+#    GitHub → votre repo → "Compare & pull request"
+#    Titre : "feat(network): add Azure Virtual Network"
+#    Description : expliquer l'adresse CIDR choisie et pourquoi
+#    Cliquer "Create pull request" puis "Merge pull request"
+
+# 5. Récupérer le merge en local et nettoyer
+git switch main
+git pull origin main
+git branch -d feature/add-vnet
+```
+
+---
+
+## 🔒 Solution Niveau 4 : Sécurité et bonnes pratiques
+
+```bash
+# 1. Créer le .gitignore Terraform/Azure
+cat > .gitignore << 'EOF'
+# Terraform
+*.tfstate
+*.tfstate.*
+.terraform/
+.terraform.lock.hcl
+*.tfplan
+*.auto.tfvars
+!example.tfvars
+
+# Azure secrets
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+service-principal.json
+EOF
+
+git add .gitignore
+git commit -m "chore: add Terraform and Azure .gitignore"
+
+# 2. Tester que .gitignore bloque .env
+echo "AZURE_CLIENT_SECRET=mon_super_secret" > .env
+git status   # .env ne doit PAS apparaître
+git add .env 2>&1 || echo ".env correctement ignoré"
+
+# 3. Installer pre-commit et configurer detect-private-key
+pip install pre-commit
+
+cat > .pre-commit-config.yaml << 'EOF'
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: detect-private-key
+      - id: check-yaml
+      - id: trailing-whitespace
+EOF
+
+pre-commit install
+
+# Test : tenter de committer une fausse clé privée
+echo "-----BEGIN RSA PRIVATE KEY-----" > fake-key.pem
+git add fake-key.pem
+git commit -m "test: should be blocked"
+# → Le hook detect-private-key doit bloquer le commit
+
+# Nettoyage
+git restore --staged fake-key.pem
+rm fake-key.pem
+git add .pre-commit-config.yaml
+git commit -m "ci: add pre-commit hooks for security"
+
+# 4. Créer et pousser un tag
+git tag -a v0.1.0 -m "Initial IaC structure with security hooks"
+git push origin v0.1.0
+```
+
+---
+
+## 🚀 Solution Projet Fil Rouge
+
+### Phase 1 : Initialisation
+
+```bash
+mkdir infra-aks-cloudops && cd infra-aks-cloudops
+git init
+
+# Structure du projet
+mkdir -p modules/aks modules/network environments/prod kubernetes .github/workflows
+
+touch modules/aks/main.tf modules/aks/variables.tf modules/aks/outputs.tf
+touch modules/network/main.tf modules/network/variables.tf
+touch environments/prod/main.tf environments/prod/terraform.tfvars.example
+touch kubernetes/.gitkeep
+touch .github/workflows/terraform.yml
+touch README.md
+
+cat > .gitignore << 'EOF'
+*.tfstate
+*.tfstate.*
+.terraform/
+.terraform.lock.hcl
+*.tfplan
+*.auto.tfvars
+!*.tfvars.example
+.env
+*.pem
+*.key
+EOF
+
+git add .
+git commit -m "chore: initial IaC project structure"
+git switch -c develop
+```
+
+---
+
+### Phase 2 : Développement Feature
+
+```bash
+git switch -c feature/aks-cluster-module
+
+# Module AKS - main.tf
+cat > modules/aks/main.tf << 'EOF'
+resource "azurerm_kubernetes_cluster" "main" {
+  name                = var.cluster_name
+  location            = var.location
+  resource_group_name = var.resource_group_name
+  dns_prefix          = var.cluster_name
+
+  default_node_pool {
+    name       = "default"
+    node_count = var.node_count
+    vm_size    = "Standard_D2_v2"
+  }
+
+  identity {
+    type = "SystemAssigned"
+  }
+}
+EOF
+
+# Module AKS - variables.tf
+cat > modules/aks/variables.tf << 'EOF'
+variable "cluster_name" {
+  type        = string
+  description = "Nom du cluster AKS"
+}
+
+variable "resource_group_name" {
+  type        = string
+  description = "Nom du Resource Group Azure"
+}
+
+variable "location" {
+  type        = string
+  description = "Région Azure"
+  default     = "West Europe"
+}
+
+variable "node_count" {
+  type        = number
+  description = "Nombre de nœuds dans le node pool"
+  default     = 2
+}
+EOF
+
+# Module AKS - outputs.tf
+cat > modules/aks/outputs.tf << 'EOF'
+output "kube_config" {
+  value     = azurerm_kubernetes_cluster.main.kube_config_raw
+  sensitive = true
+}
+
+output "cluster_id" {
+  value = azurerm_kubernetes_cluster.main.id
+}
+EOF
+
+git add modules/aks/
+git commit -m "feat(aks): add AKS cluster Terraform module"
+
+# Environnement de production
+cat > environments/prod/main.tf << 'EOF'
+module "aks" {
+  source              = "../../modules/aks"
+  cluster_name        = "aks-cloudops-prod"
+  resource_group_name = "rg-cloudops-prod"
+  location            = "West Europe"
+  node_count          = 3
+}
+EOF
+
+git add environments/prod/main.tf
+git commit -m "feat(prod): wire AKS module in production environment"
+
+git switch develop
+git merge feature/aks-cluster-module
+git branch -d feature/aks-cluster-module
+```
+
+---
+
+### Phase 3 : Release
+
+```bash
+git switch -c release/v1.0.0
+
+cat > README.md << 'EOF'
+# Infrastructure AKS - CloudOps Corp
+
+## Prérequis
+- Azure CLI >= 2.50
+- Terraform >= 1.5.0
+- Permissions : Contributor sur la subscription Azure
+
+## Déploiement
+az login
+cd environments/prod
+terraform init
+terraform plan
+terraform apply
+EOF
+
+git add README.md
+git commit -m "docs: add deployment instructions for v1.0.0"
+
+cat > .github/workflows/terraform.yml << 'EOF'
+name: Terraform Azure CI/CD
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+env:
+  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: hashicorp/setup-terraform@v3
+      - run: terraform init
+        working-directory: ./environments/prod
+      - run: terraform validate
+        working-directory: ./environments/prod
+  apply:
+    needs: validate
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: hashicorp/setup-terraform@v3
+      - run: terraform init && terraform apply -auto-approve
+        working-directory: ./environments/prod
+EOF
+
+git add .github/workflows/terraform.yml
+git commit -m "ci: add Terraform CI/CD pipeline for Azure"
+
+git switch main
+git merge release/v1.0.0
+git tag -a v1.0.0 -m "Production release: AKS cluster v1.0.0"
+
+git switch develop
+git merge release/v1.0.0
+git branch -d release/v1.0.0
+```
+
+---
+
+### Phase 4 : Hotfix
+
+```bash
+git switch main
+git switch -c hotfix/v1.0.1
+
+# Corriger la faille de sécurité : restreindre l'accès à l'API Server
+cat > modules/aks/variables.tf << 'EOF'
+variable "cluster_name" {
+  type        = string
+  description = "Nom du cluster AKS"
+}
+
+variable "resource_group_name" {
+  type        = string
+  description = "Nom du Resource Group Azure"
+}
+
+variable "location" {
+  type        = string
+  description = "Région Azure"
+  default     = "West Europe"
+}
+
+variable "node_count" {
+  type        = number
+  description = "Nombre de nœuds dans le node pool"
+  default     = 2
+}
+
+variable "api_server_authorized_ip_ranges" {
+  type        = list(string)
+  description = "CIDRs autorisés à accéder à l'API Server AKS"
+}
+EOF
+
+# Appliquer la restriction dans la ressource
+cat > modules/aks/main.tf << 'EOF'
+resource "azurerm_kubernetes_cluster" "main" {
+  name                = var.cluster_name
+  location            = var.location
+  resource_group_name = var.resource_group_name
+  dns_prefix          = var.cluster_name
+
+  default_node_pool {
+    name       = "default"
+    node_count = var.node_count
+    vm_size    = "Standard_D2_v2"
+  }
+
+  api_server_access_profile {
+    authorized_ip_ranges = var.api_server_authorized_ip_ranges
+  }
+
+  identity {
+    type = "SystemAssigned"
+  }
+}
+EOF
+
+git add modules/aks/
+git commit -m "fix(aks): restrict API server access to authorized IP ranges"
+
+git switch main
+git merge hotfix/v1.0.1
+git tag -a v1.0.1 -m "Security hotfix: restrict AKS API server access"
+
+git switch develop
+git merge hotfix/v1.0.1
+git branch -d hotfix/v1.0.1
+```
+
+> ✅ **Vérification finale** : `git log --oneline --graph --all` pour visualiser l'historique complet avec branches et tags.
+
+---
+
+[← 10 - Projet Fil Rouge](10-projet-fil-rouge.md) | [🏠 Accueil](README.md)
diff --git a/README.md b/README.md
index 96a7fc8..4089c23 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,48 @@
-# cours-git
-Cours GIT pour SIMPLON
+# Formation Git : Maîtriser le versionnage pour le DevOps Azure
+
+Bienvenue dans ce module complet dédié à Git. Git est l'outil fondamental de tout Ingénieur DevOps pour garantir la traçabilité, la collaboration et la reproductibilité des infrastructures et déploiements Azure.
+
+## 🎯 Objectifs Pédagogiques
+
+- Comprendre les concepts fondamentaux (Commit, Branch, Remote).
+- Maîtriser le workflow quotidien et la collaboration d'équipe.
+- Adopter les meilleures pratiques spécifiques à l'Infrastructure as Code (IaC) sur Azure.
+- Automatiser les vérifications via les pre-commit hooks et GitHub Actions.
+
+## 📚 Programme
+
+### [01 - Introduction et Concepts](01-introduction-concepts.md)
+Découvrez l'importance de Git et son architecture distribuée dans un contexte DevOps Azure.
+
+### [02 - Installation et Configuration](02-installation-configuration.md)
+Préparez votre environnement de travail professionnel, y compris l'authentification SSH.
+
+### [03 - Premiers pas](03-premiers-pas.md)
+Initialisation, staging area et historique des commits appliqués à des fichiers IaC.
+
+### [04 - Maîtrise des branches](04-maitrise-branches.md)
+Isolez vos développements, résolvez les conflits et maîtrisez le rebase.
+
+### [05 - Collaboration et Remotes](05-collaboration-remotes.md)
+Travaillez en équipe via GitHub/Azure DevOps et les Pull Requests.
+
+### [06 - Commandes avancées et débogage](06-commandes-avancees-debogage.md)
+Annulation, stash, tags et filet de sécurité Git.
+
+### [07 - Meilleures pratiques pour le DevOps Azure](07-meilleures-pratiques-devops.md)
+Gérer les fichiers IaC, .gitignore sécurisé pour Azure et commits conventionnels.
+
+### [08 - Workflows et Automation](08-workflows-automation.md)
+Pre-commit hooks Terraform/YAML, CI/CD GitHub Actions pour déploiements Azure.
+
+### [09 - Exercices Pratiques](09-exercices.md)
+Mise en pratique des commandes essentielles dans un contexte DevOps Azure.
+
+### [10 - Projet Fil Rouge : Déploiement AKS](10-projet-fil-rouge.md)
+Projet complet simulant le déploiement d'une infrastructure Azure avec Git Flow.
+
+### [11 - Solutions](11-solutions.md)
+Corrigés détaillés des exercices et du projet.
+
+---
+**Academy** - Formation Ingénieur DevOps Azure
diff --git a/cheat-sheet.pdf b/cheat-sheet.pdf
new file mode 100644
index 0000000..c67fdff
Binary files /dev/null and b/cheat-sheet.pdf differ