diff --git a/06_docker_compose.md b/06_docker_compose.md
new file mode 100644
index 0000000..996d293
--- /dev/null
+++ b/06_docker_compose.md
@@ -0,0 +1,647 @@
+---
+marp: true
+theme: default
+paginate: true
+backgroundColor: #fff
+footer: 'Conteneurisation - Docker Compose - 2025'
+style: |
+  section {
+    font-family: 'Arial', sans-serif;
+  }
+  h1 {
+    color: #2496ed;
+  }
+  h2 {
+    color: #384c54;
+  }
+  .columns {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 1rem;
+  }
+---
+
+# Docker Compose
+### IUT Sénart-Fontainebleau
+#### 2025
+
+---
+
+# Plan du cours
+1. Introduction à Docker Compose
+    - Problématique multi-conteneurs
+    - Avantages de Docker Compose
+    - Structure d'un fichier docker-compose.yml
+
+2. Démonstration en direct
+    - Application web avec base de données
+    - Configuration et déploiement
+    - Gestion des services
+
+---
+
+# 1. Pourquoi Docker Compose ?
+
+<div class="columns">
+<div>
+
+## Cas d'usage courant
+- Application web (Frontend)
+- API (Backend)
+- Base de données
+- Cache Redis
+- Proxy reverse
+
+</div>
+<div>
+
+## Sans Docker Compose
+```bash
+docker run --name db -e POSTGRES_PASSWORD=secret postgres
+docker run --name backend --link db:db myapp
+docker run --name frontend -p 80:80 nginx
+```
+
+</div>
+</div>
+
+---
+
+# Problèmes sans Docker Compose
+
+<div class="columns">
+<div>
+
+## Gestion manuelle
+- Ordre de démarrage
+- Variables d'environnement
+- Configuration réseau
+- Volumes persistants
+- Redémarrage automatique
+
+</div>
+<div>
+
+## Risques
+- Erreurs humaines
+- Configuration incohérente
+- Perte de temps
+- Documentation complexe
+
+</div>
+</div>
+
+---
+
+# Docker Compose : La solution
+
+<div class="columns">
+<div>
+
+## Avantages
+- Un seul fichier de configuration
+- Gestion des dépendances
+- Environnement reproductible
+- Commandes simplifiées
+- Documentation as Code
+
+</div>
+<div>
+
+```yaml
+version: '3'
+services:
+  web:
+    build: .
+    ports:
+      - "80:80"
+  db:
+    image: postgres
+```
+
+</div>
+</div>
+
+---
+
+# Structure du fichier docker-compose.yml
+
+## Éléments principaux
+```yaml
+version: '3'            # Version de la syntaxe
+services:               # Définition des conteneurs
+networks:              # Configuration réseau
+volumes:               # Stockage persistant
+configs:               # Configuration applicative
+secrets:               # Données sensibles
+```
+
+---
+
+# 2. Démonstration en direct
+
+## Préparation de l'environnement
+1. Structure du projet
+```bash
+mkdir demo-docker-compose
+cd demo-docker-compose
+```
+
+2. Création des dossiers
+```bash
+mkdir api frontend
+touch docker-compose.yml .env
+```
+
+---
+
+## Étape 1: Configuration de base
+1. Création du fichier .env
+```env
+# .env
+POSTGRES_USER=demouser
+POSTGRES_PASSWORD=secret123
+POSTGRES_DB=demodb
+NODE_ENV=development
+```
+
+---
+
+2. Premier docker-compose.yml
+```yaml
+version: '3.8'
+services:
+  db:
+    image: postgres:13
+    environment:
+      - POSTGRES_USER=${POSTGRES_USER}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+      - POSTGRES_DB=${POSTGRES_DB}
+```
+
+3. Test initial
+```bash
+docker compose up db -d
+docker compose ps
+docker compose logs db
+```
+
+---
+
+
+## Étape 2: API Node.js
+1. Structure de l'API
+```bash
+cd api
+npm init -y
+npm install express pg cors
+```
+
+---
+
+2. API simple (index.js)
+```javascript
+const express = require('express');
+const cors = require('cors');
+
+
+const { Pool } = require('pg');
+const app = express();
+app.use(cors());
+
+const pool = new Pool({
+  host: 'db',
+  user: process.env.POSTGRES_USER,
+  password: process.env.POSTGRES_PASSWORD,
+  database: process.env.POSTGRES_DB
+});
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok' });
+});
+
+app.listen(5000, () => console.log('API running'));
+```
+
+---
+
+3. Création du Dockerfile API
+```dockerfile
+FROM node:16-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+CMD ["node", "index.js"]
+```
+
+
+---
+
+4. Ajout au docker-compose.yml
+```yaml
+  api:
+    build: ./api
+    environment:
+      - POSTGRES_USER=${POSTGRES_USER}
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+      - POSTGRES_DB=${POSTGRES_DB}
+    depends_on:
+      - db
+```
+
+---
+
+## Étape 3: Frontend Vite
+1. Création du frontend
+
+<div class="columns">
+<div>
+
+```bash
+npm create vite@latest .
+# Suivre les instructions pour sélectionner React et TypeScript/JavaScript
+
+npm install
+
+# ajouter le fichier
+import HealthCheck from './HealthCheck'
+<HealthCheck />
+```
+</div>
+<div>
+
+2. Dockerfile Frontend
+```dockerfile
+FROM node:18-alpine as build
+WORKDIR /app
+COPY package*.json ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+# Production stage
+FROM nginx:alpine
+COPY --from=build /app/dist /usr/share/nginx/html
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+```
+
+</div>
+</div>
+
+---
+
+
+3. Ajout au docker-compose.yml
+```yaml
+  frontend:
+    build: ./frontend
+    environment:
+      - VITE_API_URL=http://localhost:5000
+    ports:
+      - "80:80"
+    depends_on:
+      - api
+```
+
+---
+
+4. Configuration Vite (vite.config.js)
+```javascript
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    host: true, // Nécessaire pour Docker
+    port: 5173,
+    watch: {
+      usePolling: true // Pour le hot reload dans Docker
+    }
+  }
+})
+```
+
+---
+
+## Étape 4: Nginx Reverse Proxy
+1. Configuration Nginx
+```bash
+cd frontend
+touch nginx.conf
+```
+
+---
+
+2. nginx.conf basique
+```nginx
+server {
+    listen 80;
+    server_name localhost;
+
+    # Racine du site React
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Configuration pour React Router
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Proxy vers le backend
+    location /api/ {
+        proxy_pass http://api:5000/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+
+    # Configuration pour les assets statiques
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
+        expires max;
+        log_not_found off;
+    }
+}
+```
+
+---
+
+## Démonstration du déploiement
+1. Lancement complet
+```bash
+docker compose up -d
+```
+
+2. Vérification des services
+```bash
+docker compose ps
+docker compose logs
+```
+
+---
+
+# Démonstration : Structure du projet
+
+```bash
+./mon-app/
+├── docker-compose.yml
+├── frontend/
+│   ├── Dockerfile
+│   └── src/
+├── api/
+│   ├── Dockerfile
+│   └── src/
+└── .env
+```
+
+---
+
+# Commandes essentielles
+
+## Démarrage
+```bash
+# Démarrer tous les services
+docker compose up
+
+# Mode détaché
+docker compose up -d
+```
+
+---
+
+# Commandes essentielles
+
+## Gestion
+```bash
+# Voir les logs
+docker compose logs
+
+# État des services
+docker compose ps
+
+# Arrêter les services
+docker compose down
+```
+
+---
+
+# Variables d'environnement
+
+## Fichier .env
+```env
+POSTGRES_USER=myapp
+POSTGRES_PASSWORD=secret
+POSTGRES_DB=myapp
+API_PORT=3000
+```
+
+## Utilisation dans docker-compose.yml
+```yaml
+services:
+  api:
+    environment:
+      - DB_USER=${POSTGRES_USER}
+      - DB_PASSWORD=${POSTGRES_PASSWORD}
+```
+
+---
+
+# Réseaux Docker Compose
+
+## Configuration réseau
+```yaml
+services:
+  frontend:
+    networks:
+      - frontend-net
+  
+  api:
+    networks:
+      - frontend-net
+      - backend-net
+
+networks:
+  frontend-net:
+  backend-net:
+    internal: true
+```
+
+---
+
+# Volumes et persistance
+
+## Types de volumes
+```yaml
+services:
+  db:
+    volumes:
+      # Volume nommé
+      - db-data:/var/lib/postgresql/data
+      
+      # Bind mount
+      - ./config:/etc/postgresql
+      
+      # Volume anonyme
+      - /var/lib/postgresql/data
+
+volumes:
+  db-data:
+```
+
+---
+
+# Dépendances entre services
+
+## Configuration
+```yaml
+services:
+  api:
+    depends_on:
+      db:
+        condition: service_healthy
+        
+  db:
+    healthcheck:
+      test: ["CMD", "pg_isready"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+```
+
+---
+
+# Mise à l'échelle
+
+## Scale services
+```bash
+# Lancer 3 instances de l'API
+docker compose up --scale api=3
+
+# Configuration load balancer
+services:
+  api:
+    deploy:
+      replicas: 3
+```
+
+---
+
+# Surveillance et debugging
+
+## Logs
+```bash
+# Suivre les logs en temps réel
+docker compose logs -f api
+
+# Logs depuis un timestamp
+docker compose logs --since 30m
+```
+
+## Shell dans un conteneur
+```bash
+docker compose exec api sh
+```
+
+---
+
+# Proxy Reverse avec Docker Compose
+
+## Pourquoi un proxy reverse ?
+- Répartition de charge
+- SSL/TLS termination
+- Sécurité et filtrage
+- Routage des requêtes
+- Mise en cache
+
+---
+
+## Exemple de configuration Nginx
+```nginx
+# nginx.conf
+http {
+    upstream frontend {
+        server frontend:3000;
+    }
+
+    upstream api {
+        server api:5000;
+    }
+
+    server {
+        listen 80;
+        server_name example.com;
+
+        location / {
+            proxy_pass http://frontend;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+
+        location /api {
+            proxy_pass http://api;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+    }
+}
+```
+
+## Scale avec Nginx
+```yaml
+services:
+  nginx:
+    image: nginx:alpine
+    
+  api:
+    deploy:
+      replicas: 3
+
+  frontend:
+    deploy:
+      replicas: 2
+
+# nginx.conf
+upstream api {
+    server api_1:5000;
+    server api_2:5000;
+    server api_3:5000;
+}
+```
+
+---
+
+# Bonnes pratiques
+
+<div class="columns">
+<div>
+
+## Organisation
+1. Séparer les environnements
+2. Utiliser les variables d'environnement
+3. Gérer les secrets correctement
+4. Optimiser les builds
+5. Monitorer les services
+
+</div>
+<div>
+
+## Sécurité
+1. Limiter les ports exposés
+2. Utiliser des réseaux internes
+3. Mettre à jour les images
+4. Scan des vulnérabilités
+   
+</div>
+</div>
+
+---
+
+# Questions ?
+
+N'hésitez pas à poser vos questions !
+
+---
\ No newline at end of file
diff --git a/07_optional_recap.md b/07_optional_recap.md
new file mode 100644
index 0000000..0466ba8
--- /dev/null
+++ b/07_optional_recap.md
@@ -0,0 +1,491 @@
+---
+marp: true
+theme: default
+paginate: true
+backgroundColor: #fff
+footer: 'Récapitulatif Virtualisation et Docker - 2025'
+style: |
+  section {
+    font-family: 'Arial', sans-serif;
+  }
+  h1 {
+    color: #2496ed;
+  }
+  h2 {
+    color: #384c54;
+  }
+  .columns {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 1rem;
+  }
+---
+
+# Récapitulatif : Virtualisation et Docker
+## Points Clé avant les vacances
+
+---
+
+# 1. Histoire de la Virtualisation (1960-2020)
+
+## Évolution chronologique
+- **1960s** : IBM M44/44X - Premiers pas vers le partage de ressources
+- **1970s** : VM/370 - Environnements isolés pour développement
+- **1990s** : VMware - Virtualisation sur PC standard
+- **2000s** : Cloud Computing et consolidation des serveurs
+- **2010s** : Conteneurisation et Docker
+
+---
+
+# 2. Types de Virtualisation
+
+## Approches principales
+
+<div class="columns">
+<div>
+
+1. **Hyperviseur Type 1 (Bare-metal)**
+   - Directement sur le matériel
+   - Ex: VMware ESXi, Hyper-V
+
+2. **Hyperviseur Type 2**
+   - Sur un système d'exploitation
+   - Ex: VirtualBox, VMware Workstation
+
+</div>
+<div>
+
+3. **Conteneurisation**
+   - Isolation au niveau OS
+   - Ex: Docker, LXC
+
+</div>
+</div>
+
+---
+
+# 3. La Révolution Docker
+
+<div class="columns">
+<div>
+
+## Pourquoi Docker ?
+- Portable
+- Léger
+- Rapide à déployer
+- Cohérent entre environnements
+
+</div>
+<div>
+
+## Concepts clés
+- Images
+- Conteneurs
+- Registre (Docker Hub)
+- Layers
+
+</div>
+</div>
+
+---
+
+# 🎯 Activité : Problèmes & Solutions Docker
+
+## Question à la salle
+"Citez un problème que vous avez rencontré en développement qui aurait pu être résolu avec Docker"
+
+Levez la main si vous avez déjà rencontré :
+- Des problèmes de dépendances
+- Des différences entre environnements
+- Des conflits de versions
+
+---
+
+# 💡 Solutions : Problèmes & Solutions Docker
+
+## Problèmes courants et solutions Docker :
+- **"Ça marche sur ma machine"** → Images Docker standardisées
+- **Conflits de versions** → Conteneurs isolés
+- **Installation complexe** → Dockerfile automatisé
+- **Dépendances incompatibles** → Un conteneur par service
+
+---
+
+# 4. Architecture Docker
+
+## Composants essentiels
+- **Docker Engine** : Moteur de conteneurisation
+- **Docker CLI** : Interface en ligne de commande
+- **Docker Daemon** : Service principal
+- **Docker Registry** : Stockage des images
+
+## Isolation
+- Namespaces
+- Control Groups (cgroups)
+
+---
+
+# 🎯 Activité : Composants Docker
+
+Je décris une action, devinez le composant responsable :
+
+1. "Je télécharge une image"
+2. "J'exécute les conteneurs"
+3. "Je tape des commandes"
+4. "Je stocke toutes les versions d'une image"
+
+Réfléchissez individuellement puis nous voterons ensemble !
+
+---
+
+# 💡 Solutions : Composants Docker
+
+1. "Je télécharge une image" → **Registry**
+   - Stockage centralisé des images
+   
+2. "J'exécute les conteneurs" → **Daemon**
+   - Gère le cycle de vie des conteneurs
+
+3. "Je tape des commandes" → **CLI**
+   - Interface utilisateur en ligne de commande
+
+4. "Je stocke les versions" → **Registry**
+   - Système de tags et versions
+
+---
+
+# 5. Commandes Docker Essentielles
+
+## Gestion des conteneurs
+```bash
+docker run     # Créer et démarrer
+docker start   # Démarrer
+docker stop    # Arrêter
+docker rm      # Supprimer
+```
+
+## Images
+```bash
+docker pull    # Télécharger
+docker build   # Construire
+docker push    # Publier
+```
+
+---
+
+# 🎯 Activité : Devine la Commande
+
+Pour chaque action, trouvez la commande Docker appropriée :
+
+1. Voir tous les conteneurs, même ceux arrêtés
+2. Supprimer tous les conteneurs arrêtés
+3. Voir les logs d'un conteneur en temps réel
+4. Lister toutes les images locales
+
+*Indice : Certaines commandes nécessitent des options particulières*
+
+---
+
+# 💡 Solutions : Devine la Commande
+
+<div class="columns">
+<div>
+
+1. Voir tous les conteneurs :
+   ```bash
+   docker ps -a
+   ```
+
+2. Supprimer conteneurs arrêtés :
+   ```bash
+   docker container prune
+   ```
+
+</div>
+<div>
+
+1. Voir les logs en temps réel :
+   ```bash
+   docker logs -f [container]
+   ```
+
+2. Lister les images :
+   ```bash
+   docker images
+   ```
+</div>
+</div>
+
+---
+
+# 6. Dockerfile
+
+<div class="columns">
+<div>
+
+## Structure de base
+```dockerfile
+FROM nginx:alpine
+WORKDIR /app
+COPY . .
+RUN npm install
+EXPOSE 80
+CMD ["npm", "start"]
+```
+
+</div>
+<div>
+
+## Bonnes pratiques
+- Minimiser les layers
+- Optimiser le cache
+- Multi-stage builds
+- Sécurité (non-root)
+
+</div>
+</div>
+
+---
+
+# 🎯 Activité : Construction Dockerfile
+
+Construisons ensemble un Dockerfile pour une application web Python !
+
+Quelles instructions devons-nous inclure pour :
+1. L'image de base
+2. Les dépendances Python
+3. Le code source
+4. Le port d'exposition
+5. La commande de démarrage
+
+---
+
+# 💡 Solutions : Construction Dockerfile
+
+```dockerfile
+# Image de base Python
+FROM python:3.9-slim
+# Répertoire de travail
+WORKDIR /app
+# Installation des dépendances
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+# Code source
+COPY . .
+# Port
+EXPOSE 5000
+# Démarrage
+CMD ["python", "app.py"]
+```
+
+---
+
+# 7. Docker Compose
+
+<div class="columns">
+<div>
+
+## Usage
+```yaml
+version: '3'
+services:
+  web:
+    build: .
+    ports:
+      - "80:80"
+  db:
+    image: postgres
+```
+
+
+</div>
+<div>
+
+## Avantages
+- Orchestration simple
+- Configuration déclarative
+- Environnements reproductibles
+
+</div>
+</div>
+
+---
+
+# 🎯 Activité : Compléter le Docker Compose
+
+Complétez les parties manquantes de ce docker-compose.yml :
+
+```yaml
+version: '3'
+services:
+  web:
+    ___: nginx
+    ports:
+      - "___:80"
+  db:
+    image: ___
+    ___:
+      - POSTGRES_PASSWORD=secret
+```
+
+---
+
+# 💡 Solutions : Docker Compose
+
+<div class="columns">
+<div>
+
+```yaml
+version: '3'
+services:
+  web:
+    image: nginx
+    ports:
+      - "8080:80"
+  db:
+    image: postgres
+    environment:
+      - POSTGRES_PASSWORD=secret
+```
+
+</div>
+<div>
+
+Explications :
+- `image: nginx` : Utilise l'image nginx officielle
+- `8080:80` : Mappe le port 8080 de l'hôte au port 80 du conteneur
+- `environment` : Définit les variables d'environnement
+
+</div>
+</div>
+
+---
+
+# 8. Réseaux Docker
+
+## Types
+- Bridge (défaut)
+- Host
+- None
+- User-defined
+
+## Communication
+- Entre conteneurs
+- Avec l'extérieur
+- DNS intégré
+
+---
+
+# 🎯 Activité : Vrai ou Faux Réseaux
+
+Main droite pour vrai, gauche pour faux :
+
+1. "Tous les conteneurs d'un réseau bridge peuvent communiquer entre eux"
+2. "Un conteneur en réseau host a sa propre interface réseau"
+3. "Le réseau none isole complètement le conteneur"
+4. "Les conteneurs peuvent être sur plusieurs réseaux en même temps"
+
+---
+
+# 💡 Solutions : Vrai ou Faux Réseaux
+
+1. VRAI : Les conteneurs sur un même réseau bridge peuvent communiquer
+2. FAUX : Le réseau host partage l'interface réseau de l'hôte
+3. VRAI : Le réseau none isole totalement le conteneur
+4. VRAI : Un conteneur peut être connecté à plusieurs réseaux
+
+Explications détaillées pour chaque cas d'usage...
+
+---
+
+# 9. Volumes et Persistance
+
+## Types de stockage
+- Volumes nommés
+- Bind mounts
+- tmpfs
+
+## Usages
+- Données persistantes
+- Configuration
+- Partage entre conteneurs
+
+---
+
+# 🎯 Activité : Scénarios Volumes
+
+Que se passe-t-il dans ces situations :
+
+1. Suppression d'un conteneur avec un volume nommé
+2. Montage du même volume sur deux conteneurs
+3. Redémarrage d'un conteneur sans volume
+4. Modification d'un fichier dans un bind mount
+
+---
+
+# 💡 Solutions : Scénarios Volumes
+
+1. **Suppression conteneur + volume nommé**
+   - Le volume persiste
+   - Les données sont conservées
+   - Réutilisable par d'autres conteneurs
+
+2. **Même volume sur deux conteneurs**
+   - Partage de données en temps réel
+   - Modifications visibles par tous
+   - Attention aux accès concurrents
+
+---
+
+# 💡 Solutions : Scénarios Volumes
+
+3. **Redémarrage sans volume**
+   - Perte des données
+   - Retour à l'état initial
+   - Important de planifier la persistance
+
+4. **Modification bind mount**
+   - Changements visibles des deux côtés
+   - Synchronisation en temps réel
+   - Utile pour le développement
+
+---
+
+# Points Clés à Retenir
+
+1. **Évolution** : De la virtualisation à la conteneurisation
+2. **Docker** : Solution légère et portable
+3. **Images** : Base de la conteneurisation
+4. **Dockerfile** : Construction d'images
+5. **Compose** : Orchestration simple
+6. **Réseaux** : Communication entre conteneurs
+7. **Volumes** : Persistance des données
+
+---
+
+# Questions ?
+
+## Rappel des ressources
+- Documentation Docker officielle
+- Docker Hub
+- GitHub du cours
+- Stack Overflow
+
+---
+
+# Préparation des examens
+
+## Points d'attention
+- Commandes de base
+- Architecture Docker
+- Dockerfile et bonnes pratiques
+- Docker Compose
+- Cas pratiques
+- Réseaux et volumes
+
+---
+
+# Merci de votre attention !
+
+Bonnes vacances en avance :) !
+
diff --git a/08_docker-security.md b/08_docker-security.md
new file mode 100644
index 0000000..317c12a
--- /dev/null
+++ b/08_docker-security.md
@@ -0,0 +1,210 @@
+---
+marp: true
+theme: default
+paginate: true
+header: "Sécurisation avancée des images Docker"
+footer: "BUT2"
+style: |
+  section {
+    font-size: 28px;
+  }
+  h1 {
+    color: #0066cc;
+  }
+  h2 {
+    color: #0099cc;
+  }
+---
+
+# Sécurisation avancée des images Docker
+## Stratégies et outils pour une conteneurisation robuste
+
+---
+
+# Introduction
+
+- **Approche holistique** nécessaire pour une protection efficace
+- Combinaison de **bonnes pratiques** validées par l'industrie
+- **Cycle de vie complet** : de l'image de base à l'exécution
+
+---
+
+# 1. Sélection et validation des images de base
+
+## Types d'images et niveaux de confiance
+- **Images officielles** : 68% de vulnérabilités en moins
+- **Images minimalistes** : Alpine Linux (5MB), Distroless (sans shell)
+- **Images certifiées** : Audits indépendants et signature numérique
+
+```bash
+docker scout recommendations my-image:latest
+```
+
+---
+
+# 1. Sélection et validation des images de base (suite)
+
+## Gestion des dépendances
+- **SBOM** (Software Bill of Materials) pour tracer l'origine des composants
+- Détection des licences non conformes et dépendances obsolètes
+
+```bash
+syft my-image:latest -o json > sbom.json
+```
+
+---
+
+# 2. Hardening des Dockerfiles
+
+## Architecture des builds sécurisés
+- **Mode non-privilégié** :
+```
+USER 1001:2001  # UID/GID non-root
+```
+
+- **Builds multi-étapes** :
+```dockerfile
+FROM golang:1.21 AS builder
+# Compilation
+FROM gcr.io/distroless/base
+# Runtime
+```
+
+---
+
+# 2. Hardening des Dockerfiles (suite)
+
+## Bonnes pratiques
+- **Nettoyage des couches intermédiaires** :
+```dockerfile
+RUN apt-get update && apt-get install -y \
+    package1 \
+    package2 \
+ && rm -rf /var/lib/apt/lists/*
+```
+
+---
+
+# 3. Analyse des vulnérabilités
+
+## Outils d'analyse continue
+
+| Outil | Type | Avantages |
+|-------|------|-----------|
+| Trivy | SAST/DAST | Analyse OS packages et langages |
+| Snyk | SCA | Correction automatisée des CVE |
+| Clair | Dynamique | Surveillance en temps réel |
+| Anchore | Politiques | Vérification CIS Benchmarks |
+
+---
+
+# 3. Analyse des vulnérabilités (suite)
+
+## Intégration CI/CD
+```yaml
+# .github/workflows/security.yml
+name: Security Scan
+on: [push]
+jobs:
+  trivy-scan:
+    steps:
+      - name: Scan image
+        uses: aquasecurity/trivy-action@master
+        with:
+          severity: HIGH,CRITICAL
+          exit-code: 1
+```
+
+---
+
+# 3. Analyse des vulnérabilités (suite)
+
+## Gestion des correctifs
+- Rebuilds hebdomadaires pour appliquer les correctifs OS
+- Patchs critiques en 24h via des processus d'urgence
+- Analyse différentielle des SBOM pour identifier les changements
+
+```json
+{ 
+  "docker": { 
+    "enabled": true, 
+    "schedule": ["every weekend"] 
+  } 
+}
+```
+
+---
+
+# 4. Sécurité runtime
+
+## Isolation au niveau du noyau
+- Mécanismes SELinux/AppArmor pour renforcer l'isolation
+- Profils personnalisés bloquant 89% des tentatives d'évasion
+
+```bash
+docker run --security-opt "apparmor=docker-custom" my-image
+```
+
+---
+
+# 4. Sécurité runtime (suite)
+
+## Gestion des secrets
+- Intégration avec HashiCorp Vault pour éviter le stockage en clair
+
+```dockerfile
+RUN --mount=type=secret,id=db_pass \
+    export DB_PASSWORD=$(cat /run/secrets/db_pass) \
+    && ./init-db.sh
+```
+
+- Politiques de rotation automatique des secrets
+
+---
+
+# 5. Gouvernance et conformité
+
+## Adhésion aux standards OWASP Docker Top 10
+
+| ID | Risque | Contrôle |
+|----|--------|----------|
+| D01 | Images vulnérables | Analyse SBOM + CVE |
+| D02 | Runtime non durci | Profils AppArmor/SELinux |
+| D03 | Secrets exposés | Intégration Vault |
+
+- L'implémentation complète réduit les incidents de 76%
+
+---
+
+# 5. Gouvernance et conformité (suite)
+
+## Automatisation IaC
+- Templates Terraform pour appliquer des configurations sécurisées
+- Intégration des politiques de gestion des secrets
+
+```terraform
+resource "docker_image" "secure" {
+  name = "my-image:${var.version}"
+  build {
+    context = "."
+    args = { USER_ID = 1001 }
+  }
+}
+```
+
+---
+
+# 6. Perspectives futures
+
+- **Confidential Computing** : Exécution dans des enclaves SGX/SEV
+- **SBOM dynamiques** : Tracking en temps réel des composants
+- **MLOps Security** : Détection automatique des dérives de comportement
+
+---
+
+# Conclusion
+
+- Sécurité Docker = **pratiques techniques + processus organisationnels**
+- Adoption d'**outils modernes** (Trivy, Snyk, Vault)
+- **Automatisation CI/CD** pour maintenir la productivité
+- Innovations futures: **confidential computing** et **vérification cryptographique**