MFormations
Modern DevOps Engineering

Chapitre 17

17 - Exercices DevOps

17 - Exercices DevOps

Cours 17 : Exercices DevOps

Niveau Débutant (Exercices 1-10)

Exercice 1 : Dockerfile basique

Objectif : Écrire un Dockerfile pour une application Node.js simple.

Consignes :

  • Base : node:18-alpine
  • Copier package.json et package-lock.json
  • Installer les dépendances
  • Copier le code source
  • Exposer le port 3000
  • Commande : npm start

Fichier attendu : Dockerfile

Exercice 2 : Premier déploiement Kubernetes

Objectif : Déployer Nginx avec un Deployment Kubernetes.

Consignes :

  • 3 réplicas
  • Image : nginx:1.25
  • Port 80
  • app: nginx en label

Fichier attendu : deployment.yaml

Exercice 3 : Terraform - Provider AWS

Objectif : Créer un bucket S3 avec Terraform.

Consignes :

  • Provider AWS (region eu-west-3)
  • Bucket S3 avec nom unique
  • Tags : Environment = "dev", ManagedBy = "Terraform"

Fichier attendu : main.tf

Exercice 4 : Pipeline CI simple

Objectif : Créer un workflow GitHub Actions qui s'exécute sur push.

Consignes :

  • Déclencheur : push sur main et develop
  • Job : build
  • Steps : checkout, Node 18, npm ci, npm test

Fichier attendu : .github/workflows/ci.yml

Exercice 5 : Docker Compose basique

Objectif : Définir une stack web + database avec Docker Compose.

Consignes :

  • Service web : image nginx:alpine, port 80:80
  • Service db : image postgres:15, variable POSTGRES_PASSWORD=secret
  • Network : app-network

Fichier attendu : docker-compose.yml

Exercice 6 : Monitorer avec Prometheus

Objectif : Configurer Prometheus pour scraper une application.

Consignes :

  • Job name : my-app
  • Target : localhost:9090
  • Intervalle : 15s
  • Timeout : 10s

Fichier attendu : prometheus.yml

Exercice 7 : Git - Workflow basique

Objectif : Simuler un workflow Git avec branching.

Consignes :

  1. Créer une branche feature/add-auth
  2. Ajouter un fichier auth.py
  3. Committer avec message conventionnel
  4. Créer une Pull Request vers main

Fichier attendu : Log des commandes dans git-workflow.md

Exercice 8 : Configuration NGINX

Objectif : Créer une config NGINX pour reverse proxy.

Consignes :

  • Écouter sur le port 80
  • Proxy vers http://localhost:3000
  • Header X-Forwarded-For
  • Rate limiting : 10 req/s

Fichier attendu : nginx.conf

Exercice 9 : Script de backup

Objectif : Écrire un script bash pour sauvegarder une base PostgreSQL.

Consignes :

  • Variable : DB_NAME, DB_USER, DB_PASSWORD
  • Backup avec pg_dump
  • Compression gzip
  • Timestamp dans le nom
  • Rotation : garder 7 jours

Fichier attendu : backup.sh

Exercice 10 : Healthcheck API

Objectif : Créer un endpoint /health pour une API REST.

Consignes :

  • Retourner {"status": "ok"} en JSON
  • HTTP 200
  • Ajouter un Dockerfile HEALTHCHECK
  • Intervalle : 30s, retries: 3

Fichiers attendus : server.js, Dockerfile

Niveau Intermédiaire (Exercices 11-20)

Exercice 11 : Multi-stage Dockerfile

Objectif : Optimiser un Dockerfile Java/Spring Boot avec multi-stage.

Consignes :

  • Stage 1 : maven:3.9-eclipse-temurin-17 pour build
  • Stage 2 : eclipse-temurin:17-jre-alpine pour runtime
  • Copier le JAR du stage 1
  • Utilisateur non-root spring:spring
  • Taille finale < 200MB

Fichier attendu : Dockerfile

Exercice 12 : Service Kubernetes avec ConfigMap

Objectif : Déployer une app avec configuration externe.

Consignes :

  • ConfigMap avec APP_ENV=production, LOG_LEVEL=info
  • Deployment : 2 réplicas, image myapp:v1
  • Service Type: ClusterIP, port 8080
  • Montrer la ConfigMap en variables d'environnement

Fichiers attendus : configmap.yaml, deployment.yaml, service.yaml

Exercice 13 : Module Terraform VPC

Objectif : Créer un module Terraform réutilisable pour VPC.

Consignes :

  • Inputs : cidr_block, name, environment
  • Outputs : vpc_id, public_subnets, private_subnets
  • 2 sous-réseaux publics, 2 privés
  • Internet Gateway + NAT Gateway

Fichiers attendus : modules/vpc/main.tf, modules/vpc/variables.tf, modules/vpc/outputs.tf

Exercice 14 : Pipeline CI/CD complète

Objectif : Créer un pipeline avec build, test, build image, push registry.

Consignes :

  • Déclencheurs : push, PR sur main
  • Jobs : lint, test, build, docker-build
  • Cache node_modules et Docker layers
  • Docker Hub push avec credentials secrets

Fichier attendu : .github/workflows/ci-cd.yml

Exercice 15 : Monitoring stack Prometheus + Grafana

Objectif : Déployer la stack Prometheus/Grafana avec Docker Compose.

Consignes :

  • Prometheus config scrapé
  • Grafana avec dashboards pré-configurés
  • Node Exporter pour métriques host
  • Volume persistants pour données

Fichiers attendus : docker-compose.yml, prometheus/prometheus.yml, grafana/datasources.yml

Exercice 16 : Déploiement Blue/Green avec Kubernetes

Objectif : Mettre en place un déploiement Blue/Green.

Consignes :

  • 2 Deployments : app-blue, app-green
  • 1 Service qui switch entre les deux via label selector
  • Script pour basculer : switch.sh
  • Rollback rapide en 5 secondes

Fichiers attendus : blue-deployment.yaml, green-deployment.yaml, service.yaml, switch.sh

Exercice 17 : ArgoCD Application

Objectif : Déployer une app avec ArgoCD en mode GitOps.

Consignes :

  • Application ArgoCD sync automatique
  • Source : repo GitHub, dossier k8s/
  • Destination : namespace production
  • Sync policy : automated + selfHeal
  • Health check personnalisé

Fichier attendu : argocd-application.yaml

Exercice 18 : Helm Chart basique

Objectif : Créer un Helm Chart pour une application web.

Consignes :

  • templates : deployment.yaml, service.yaml, ingress.yaml
  • values.yaml avec image, replicaCount, resources
  • values par environnement (dev/prod)
  • helpers.tpl pour labels communs

Fichiers attendus : Chart.yaml, values.yaml, templates/

Exercice 19 : Backup et restauration etcd

Objectif : Sauvegarder et restaurer etcd pour un cluster K8s.

Consignes :

  • Snapshot etcd avec etcdctl
  • Backup vers S3
  • Script de restauration
  • Vérification de l'intégrité

Fichier attendu : etcd-backup.sh

Exercice 20 : Alerting avec Alertmanager

Objectif : Configurer des alertes Prometheus + Alertmanager.

Consignes :

  • Règle : CPU > 80% pendant 5m
  • Règle : Pod crash loop
  • Règle : Disk > 85%
  • Notification : email + Slack
  • Inhibitions si maintenance

Fichiers attendus : rules.yml, alertmanager.yml

Niveau Avancé (Exercices 21-30)

Exercice 21 : Service Mesh avec Istio

Objectif : Déployer Istio et configurer le traffic management.

Consignes :

  • Installer Istio sur le cluster
  • Déployer 2 versions d'une app (v1, v2)
  • VirtualService pour canary (90% v1, 10% v2)
  • DestinationRule avec circuit breaker
  • Kiali pour visualisation

Fichiers attendus : virtual-service.yaml, destination-rule.yaml

Exercice 22 : Terraform - Infrastructure complète AWS

Objectif : Provisionner une infrastructure AWS complète.

Consignes :

  • VPC + subnets + NAT
  • EKS cluster avec node groups
  • RDS PostgreSQL
  • ElastiCache Redis
  • Load Balancer ALB
  • Outputs pour Kubeconfig

Fichiers attendus : infra/main.tf, infra/variables.tf, infra/outputs.tf

Exercice 23 : Chaos Engineering avec Chaos Mesh

Objectif : Introduire des pannes contrôlées sur un cluster K8s.

Consignes :

  • Installer Chaos Mesh
  • Créer une expérience : kill pod aléatoire
  • Créer une expérience : latence réseau (200ms)
  • Créer une expérience : CPU stress (80%)
  • Dashboard pour visualiser les expériences

Fichiers attendus : chaos/pod-kill.yaml, chaos/network-delay.yaml, chaos/cpu-stress.yaml

Exercice 24 : Pipeline GitOps avancé

Objectif : Mettre en place un pipeline GitOps complet avec promotion d'environnements.

Consignes :

  • Branches : dev, staging, prod
  • CI build et push image avec tag commit SHA
  • CD ArgoCD sync depuis Git
  • Promotion : dev → staging → prod via PR
  • Validation automatique (tests, security scan)

Fichier attendu : .github/workflows/gitops-pipeline.yml

Exercice 25 : Stack d'observabilité complète (LGTM)

Objectif : Déployer Loki, Grafana, Tempo, Mimir.

Consignes :

  • Loki pour logs (distribué)
  • Tempo pour traces (distribué tracing)
  • Mimir pour metrics (long terme)
  • Grafana avec datasources et dashboards
  • App instrumentée avec OpenTelemetry

Fichiers attendus : loki-config.yaml, tempo-config.yaml, docker-compose.yml

Exercice 26 : Security scanning dans CI

Objectif : Intégrer Trivy, Snyk, et OPA dans le pipeline.

Consignes :

  • Trivy scan de l'image Docker
  • Snyk scan des dépendances
  • OPA policies pour K8s manifests
  • Fail pipeline si vulnérabilité critique
  • Rapport de scan en artifact

Fichier attendu : .github/workflows/security.yml

Exercice 27 : Auto-scaling avancé (HPA + VPA + KEDA)

Objectif : Configurer le scaling automatique sur plusieurs dimensions.

Consignes :

  • HPA : CPU > 70%, max 20 pods
  • VPA : recommandations auto pour requests/limits
  • KEDA : scaling basé sur queue RabbitMQ (messages > 100)
  • Tests de charge avec k6

Fichiers attendus : hpa.yaml, vpa.yaml, keda-scaledobject.yaml

Exercice 28 : Politiques réseau Kubernetes

Objectif : Implémenter la segmentation réseau avec NetworkPolicies.

Consignes :

  • Namespaces : frontend, backend, database
  • Deny all ingress/egress par défaut
  • Frontend → Backend (port 8080)
  • Backend → Database (port 5432)
  • Monitoring → Tous (port 9100)

Fichiers attendus : network-policies/

Exercice 29 : Disaster Recovery Plan

Objectif : Créer et tester un plan de reprise après sinistre.

Consignes :

  • Backup Velero des ressources K8s
  • Snapshot EBS/RDS automatique
  • Script de restauration cross-region
  • Test de DR trimestriel automatisé
  • Runbook documenté

Fichiers attendus : dr-plan.md, velero-schedule.yaml, restore-script.sh

Exercice 30 : FinOps - Cost optimization

Objectif : Analyser et optimiser les coûts cloud.

Consignes :

  • Tagging strategy pour cost allocation
  • Budget alerts avec AWS Budgets
  • Rightsizing recommendations
  • Spot instances pour workloads non-critiques
  • Rapport de cost saving mensuel

Fichier attendu : finops/analysis.py

Niveau Expert (Exercices 31-40)

Exercice 31 : Custom Kubernetes Operator

Objectif : Créer un opérateur Kubernetes avec Kubebuilder.

Consignes :

  • CRD : Database avec spec (engine, version, storage)
  • Controller : provisionne un StatefulSet + Service + PVC
  • Reconcilier : créer/mettre à jour/supprimer
  • Tests d'intégration avec envtest
  • Déploiement avec OLM

Fichiers attendus : operator/

Exercice 32 : Multi-cluster Kubernetes avec Cilium Cluster Mesh

Objectif : Connecter deux clusters K8s avec Cilium.

Consignes :

  • Cluster 1 : EU (Paris)
  • Cluster 2 : US (Virginia)
  • Cilium ClusterMesh
  • Service global entre clusters
  • Network policies cross-cluster
  • Latence mesurée avec mTLS

Fichiers attendus : cilium-clustermesh.yaml, global-service.yaml

Exercice 33 : Platform Engineering - IDP avec Backstage

Objectif : Créer une Internal Developer Platform avec Backstage.

Consignes :

  • Backstage instance avec plugins
  • Software Templates pour scaffolding
  • TechDocs pour documentation auto
  • Scorecards pour quality gates
  • Intégration avec ArgoCD, Datadog, PagerDuty

Fichiers attendus : backstage/app-config.yaml, templates/

Exercice 34 : eBPF - Program XDP basique

Objectif : Écrire un programme eBPF pour filtrer le trafic réseau.

Consignes :

  • Programme XDP qui drop les paquets sur le port 22
  • Compilation avec clang + LLVM
  • Load avec iproute2
  • Test avec hping3
  • Metrics avec map eBPF

Fichiers attendus : xdp-drop.c, Makefile, load.sh

Exercice 35 : Policy as Code avec OPA/Gatekeeper

Objectif : Implémenter des politiques de gouvernance Kubernetes.

Consignes :

  • Installer Gatekeeper
  • Policy : tous les pods doivent avoir des resource limits
  • Policy : pas de privilege escalation
  • Policy : images uniquement de registres autorisés
  • Policy : labels obligatoires (team, environment)
  • Audit et rapports de violation

Fichiers attendus : gatekeeper/constraints/

Exercice 36 : WebAssembly sur Kubernetes

Objectif : Déployer une application WASM avec containerd.

Consignes :

  • Application WASM avec TinyGo
  • Runtime containerd avec runwasi
  • Déploiement K8s avec runtimeClassName
  • Performance benchmark vs natif
  • Limitations documentées

Fichiers attendus : wasm-app/, wasm-deployment.yaml

Exercice 37 : AIOps - Anomaly detection avec ML

Objectif : Mettre en place une détection d'anomalies sur métriques Prometheus.

Consignes :

  • Collecte de métriques historiques
  • Modèle de détection (Z-score, Moving Average)
  • Alerting intelligent (réduction faux positifs)
  • Dashboard Grafana avec anomalies
  • Pipeline de retraining automatique

Fichiers attendus : aiops/anomaly-detector.py, aiops/grafana-dashboard.json

Exercice 38 : Zero-downtime migration

Objectif : Migrer une base de données PostgreSQL sans downtime.

Consignes :

  • Application avec downtime budget < 5s
  • Migration schema sans lock
  • Replication logique PostgreSQL
  • Dual-writes pendant transition
  • Rollback automatisé
  • Tests de charge pendant migration

Fichiers attendus : migration/migration-plan.md, migration/scripts/

Exercice 39 : Supply Chain Security (SLSA + Sigstore)

Objectif : Mettre en place la sécurité de la chaîne d'approvisionnement logicielle.

Consignes :

  • SLSA Level 3 attestations
  • Sigstore/Cosign pour signer les images
  • SBOM avec Syft (SPDX format)
  • Vérification des attestations dans le pipeline
  • Policy d'admission basée sur SLSA level

Fichiers attendus : supply-chain/

Exercice 40 : Plateforme Multi-Cloud complète

Objectif : Concevoir une plateforme DevOps multi-cloud (AWS + GCP + Azure).

Consignes :

  • Terraform modules pour chaque provider
  • Crossplane pour gestion unifiée
  • Service mesh multi-cloud (Consul)
  • Observabilité centralisée (Grafana Cloud)
  • GitOps cross-cluster
  • Cost management unifié
  • Disaster recovery cross-cloud

Fichiers attendus : multi-cloud/

Rendu attendu

Chaque exercice doit être livré dans un dossier dédié :

17-Exercices/
├── exercice-01/
│   ├── Dockerfile
│   └── README.md
├── exercice-02/
│   ├── deployment.yaml
│   └── README.md
...
├── exercice-40/
│   └── ...
└── course.md

Validation

  • Chaque exercice doit produire le(s) fichier(s) demandé(s)
  • Les manifests YAML doivent passer kubectl apply --dry-run=client
  • Les fichiers Terraform doivent passer terraform validate
  • Les pipelines CI doivent être testés sur un repo de test
  • Les images Docker doivent être buildables
PrécédentChapitre 16 — 16 - Projet Fil Rouge : Enterprise Cloud PlatformSuivantChapitre 18 — 18 - QCM DevOps