From dc2ad2babdbf22335be90334fccb2c6927d2faf8 Mon Sep 17 00:00:00 2001 From: Maxime Menault Date: Wed, 11 Mar 2026 15:12:05 +0100 Subject: [PATCH] 3 derniers cours --- 06_docker_compose.md | 647 ++++++++++++++++++++++++++++++++++++++++++ 07_optional_recap.md | 491 ++++++++++++++++++++++++++++++++ 08_docker-security.md | 210 ++++++++++++++ 3 files changed, 1348 insertions(+) create mode 100644 06_docker_compose.md create mode 100644 07_optional_recap.md create mode 100644 08_docker-security.md 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 ? + +
+
+ +## Cas d'usage courant +- Application web (Frontend) +- API (Backend) +- Base de données +- Cache Redis +- Proxy reverse + +
+
+ +## 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 +``` + +
+
+ +--- + +# Problèmes sans Docker Compose + +
+
+ +## Gestion manuelle +- Ordre de démarrage +- Variables d'environnement +- Configuration réseau +- Volumes persistants +- Redémarrage automatique + +
+
+ +## Risques +- Erreurs humaines +- Configuration incohérente +- Perte de temps +- Documentation complexe + +
+
+ +--- + +# Docker Compose : La solution + +
+
+ +## Avantages +- Un seul fichier de configuration +- Gestion des dépendances +- Environnement reproductible +- Commandes simplifiées +- Documentation as Code + +
+
+ +```yaml +version: '3' +services: + web: + build: . + ports: + - "80:80" + db: + image: postgres +``` + +
+
+ +--- + +# 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 + +
+
+ +```bash +npm create vite@latest . +# Suivre les instructions pour sélectionner React et TypeScript/JavaScript + +npm install + +# ajouter le fichier +import HealthCheck from './HealthCheck' + +``` +
+
+ +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;"] +``` + +
+
+ +--- + + +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 + +
+
+ +## 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 + +
+
+ +## 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 + +
+
+ +--- + +# 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 + +
+
+ +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 + +
+
+ +3. **Conteneurisation** + - Isolation au niveau OS + - Ex: Docker, LXC + +
+
+ +--- + +# 3. La Révolution Docker + +
+
+ +## Pourquoi Docker ? +- Portable +- Léger +- Rapide à déployer +- Cohérent entre environnements + +
+
+ +## Concepts clés +- Images +- Conteneurs +- Registre (Docker Hub) +- Layers + +
+
+ +--- + +# 🎯 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 + +
+
+ +1. Voir tous les conteneurs : + ```bash + docker ps -a + ``` + +2. Supprimer conteneurs arrêtés : + ```bash + docker container prune + ``` + +
+
+ +1. Voir les logs en temps réel : + ```bash + docker logs -f [container] + ``` + +2. Lister les images : + ```bash + docker images + ``` +
+
+ +--- + +# 6. Dockerfile + +
+
+ +## Structure de base +```dockerfile +FROM nginx:alpine +WORKDIR /app +COPY . . +RUN npm install +EXPOSE 80 +CMD ["npm", "start"] +``` + +
+
+ +## Bonnes pratiques +- Minimiser les layers +- Optimiser le cache +- Multi-stage builds +- Sécurité (non-root) + +
+
+ +--- + +# 🎯 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 + +
+
+ +## Usage +```yaml +version: '3' +services: + web: + build: . + ports: + - "80:80" + db: + image: postgres +``` + + +
+
+ +## Avantages +- Orchestration simple +- Configuration déclarative +- Environnements reproductibles + +
+
+ +--- + +# 🎯 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 + +
+
+ +```yaml +version: '3' +services: + web: + image: nginx + ports: + - "8080:80" + db: + image: postgres + environment: + - POSTGRES_PASSWORD=secret +``` + +
+
+ +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 + +
+
+ +--- + +# 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**