■■■ FORMATION COMPLÈTE

DEVOPS
De Zéro à Ingénieur DevOps

Linux · Git · Docker · CI/CD · Kubernetes · Terraform · Monitoring

7 Modules · 20 Travaux Pratiques · 5 Projets Complets

Niveau : Débutant → Intermédiaire | Licence 2 Informatique & +

Cours DevOps Complet — Module 1 Page 1

■ Table des Matières
Module Titre Page
Module 1 Introduction au DevOps — Culture & Philosophie 3

Module 2 Linux & Ligne de Commande — Les Fondations 5

Module 3 Git & Contrôle de Version 9

Module 4 Docker & Conteneurisation 13

Module 5 CI/CD — Intégration et Déploiement Continus 18

Module 6 Kubernetes — Orchestration de Conteneurs 23

Module 7 Infrastructure as Code & Monitoring 29

Module Projets Complets (5 projets) 35

Module Ressources & Prochaines Étapes 42

Cours DevOps Complet — Module 2 Page 2

Module 1 — Introduction au DevOps

1.1 Qu'est-ce que le DevOps ?

Le DevOps est avant tout une culture et une philosophie de travail qui cherche à rapprocher deux
équipes traditionnellement séparées dans une entreprise informatique : les développeurs (Dev) qui
créent les applications, et les équipes d'exploitation (Ops) qui s'occupent de faire fonctionner ces
applications en production.

Avant le DevOps, ces deux équipes travaillaient souvent en « silos » : les développeurs écrivaient du
code, le livraient à l'équipe Ops, et chaque déploiement prenait des semaines voire des mois, avec de
nombreux bugs. Le DevOps casse ces barrières.

■ Définition
• DevOps = Dev (Développement) + Ops (Opérations)
• But : livrer des logiciels plus vite, plus souvent, avec plus de qualité
• C'est une culture, des pratiques ET des outils
• Pas un outil ni un poste unique : c'est une façon de travailler ensemble

1.2 Pourquoi le DevOps existe-t-il ?

Dans les années 2000-2010, les entreprises faisaient des déploiements 2 à 4 fois par an. Aujourd'hui,
des entreprises comme Amazon déploient des milliers de fois par jour ! Le DevOps permet cette
transformation.

Avant DevOps Avec DevOps

Déploiements tous les 3-6 mois Déploiements plusieurs fois par jour
Silos Dev / Ops Équipes collaboratives unifiées
Tests manuels lents Tests automatisés en continu
Bugs découverts tard Bugs détectés dès le développement
Documentation oubliée Infrastructure codifiée et documentée
Stress lors des mises en prod Déploiements sereins et réversibles

1.3 Les Principes CALMS du DevOps

Le DevOps repose sur 5 piliers fondamentaux résumés par l'acronyme CALMS :

Encourager la collaboration, la confiance et la communication entre

C — Culture
Dev et Ops. Accepter l'échec comme une opportunité d'apprentissage.

A— Automatiser tout ce qui peut l'être : tests, builds, déploiements,

Automatisation provisionnement d'infrastructure.

Eliminer les gaspillages, livrer de la valeur en petites itérations,

L — Lean
améliorer continuellement les processus.

Cours DevOps Complet — Module 3 Page 3

 Mesurer tout : performances, temps de déploiement, taux d'erreur. Si
M — Mesure
vous ne mesurez pas, vous ne pouvez pas améliorer.

Partager les connaissances, les outils, les retours d'expérience entre

S — Sharing
toutes les équipes.

1.4 Le Pipeline DevOps — Vue d'ensemble

Le pipeline DevOps décrit le cycle de vie complet d'une application, du code écrit par le développeur
jusqu'à l'utilisateur final. On parle aussi de cycle CI/CD.

1. Plan 2. Code 3. Build 4. Test 5. Release 6. Deploy 7. Operate 8. Monitor

Définir les Écrire le code Compiler Tester automat Préparer la Déployer en Superviser Analyser les

fonctionnalités source l'application iquement version production l'app métriques

■ Ce cycle se répète en continu — c'est l'amélioration continue.

■ TP 1 — Cartographie de votre futur environnement DevOps | ■ 45 min

1 Recherchez et listez 3 entreprises tech connues (Netflix, Spotify, Amazon) et notez comment elles
utilisent le DevOps.

2 Installez VirtualBox ([Link] sur votre machine — ce sera votre lab.

3 Créez un compte gratuit sur GitHub ([Link] si ce n'est pas déjà fait.

4 Créez un compte sur Docker Hub ([Link] — gratuit aussi.

5 Créez un fichier texte 'mon_plan_devops.txt' et listez 5 compétences que vous voulez acquérir.

6 Dessinez sur papier un pipeline CI/CD simplifié d'après ce que vous avez compris.

Cours DevOps Complet — Module 4 Page 4

Module 2 — Linux & Ligne de Commande

2.1 Pourquoi Linux est indispensable en DevOps ?

Environ 90% des serveurs dans le monde tournent sous Linux. Que ce soit AWS, Google Cloud, Azure
ou vos propres serveurs, Linux est partout. En tant qu'ingénieur DevOps, vous passerez la majorité de
votre temps dans un terminal Linux.

2.2 Structure du Système de Fichiers Linux

/ — Racine du système — tout part de là
/home — Dossiers personnels des utilisateurs (ex: /home/alice)
/etc — Fichiers de configuration système
/var — Données variables : logs, bases de données, mails
/tmp — Fichiers temporaires, effacés au redémarrage
/usr — Applications et utilitaires installés
/bin et /sbin — Commandes essentielles du système
/opt — Logiciels tiers optionnels
/proc — Informations sur les processus en cours

2.3 Les Commandes Essentielles

■ Navigation et Fichiers
Commande Description
pwd Afficher le dossier courant (Print Working Directory)
ls -la Lister tous les fichiers avec détails et droits
cd /chemin Changer de répertoire
mkdir -p dossier/sous Créer un dossier (et les parents si besoin)
cp -r source dest Copier un fichier ou dossier
mv ancien nouveau Déplacer ou renommer
rm -rf dossier Supprimer (DANGER : irréversible !)
find / -name '*.log' Chercher des fichiers
cat [Link] Afficher le contenu d'un fichier
less [Link] Parcourir un fichier (q pour quitter)
head -20 fichier Afficher les 20 premières lignes
tail -f /var/log/syslog Suivre un fichier en temps réel

■ Gestion des Processus

Commande Description

Cours DevOps Complet — Module 5 Page 5

 ps aux Lister tous les processus en cours
top / htop Moniteur de ressources interactif
kill -9 PID Tuer un processus par son ID
nohup commande & Lancer en arrière-plan persistant
systemctl status nginx Vérifier l'état d'un service
systemctl
start/stop/restart Démarrer/arrêter/redémarrer un service

■ Réseau
Commande Description
ping [Link] Tester la connectivité réseau
curl -I [Link] Envoyer une requête HTTP
wget [Link] Télécharger un fichier
netstat -tulnp Voir les ports ouverts
ss -tulnp Alternative moderne à netstat
ssh user@serveur Connexion SSH à un serveur
scp fichier user@srv:/dest Copier via SSH

✏■ Editeur de Texte (Vim)

Commande Description
vim [Link] Ouvrir un fichier dans Vim
i Passer en mode insertion
Echap Revenir en mode normal
:w Sauvegarder
:q! Quitter sans sauvegarder
:wq Sauvegarder et quitter

2.4 Permissions Linux — Comprendre les droits

Chaque fichier Linux a des permissions pour 3 catégories : propriétaire (u), groupe (g) et autres (o). On
les représente en 3 triades : rwx (read/write/execute).

$ ls -la [Link]

-rwxr-xr-- 1 alice devops 1234 jan 15 10:30 [Link]

# Décomposition :

# - : type (- = fichier, d = dossier, l = lien)

# rwx : propriétaire (alice) peut lire, écrire, exécuter

# r-x : groupe (devops) peut lire et exécuter

# r-- : autres peuvent seulement lire

Cours DevOps Complet — Module 6 Page 6

 # Changer les permissions :

chmod 755 [Link] # rwxr-xr-x

chmod +x [Link] # ajouter le droit d'exécution

chown alice:devops [Link] # changer propriétaire

2.5 Scripts Bash — Automatiser avec Linux

Un script bash est un fichier texte contenant des commandes Linux exécutées automatiquement dans
l'ordre. C'est la base de l'automatisation DevOps.

#!/bin/bash

# Mon premier script DevOps

# Variables

APP_NAME='monapp'

VERSION='1.0'

DATE=$(date +%Y-%m-%d)

echo "=== Déploiement de $APP_NAME v$VERSION ==="

# Condition

if [ -d '/var/www/$APP_NAME' ]; then

echo 'Dossier existant, sauvegarde...'

cp -r /var/www/$APP_NAME /backup/$APP_NAME-$DATE

else

echo 'Premier déploiement'

mkdir -p /var/www/$APP_NAME

fi

# Boucle

for service in nginx mysql redis; do

systemctl restart $service

echo "$service redémarré"

done

echo 'Déploiement terminé !'

■ TP 2 — Navigation et Commandes Linux de Base | ■ 1h

1 Ouvrez un terminal (ou WSL sur Windows / Terminal sur Mac).

2 Naviguez dans /etc et listez les fichiers de configuration avec ls -la.

3 Créez l'arborescence : ~/devops/projets/app1 avec une seule commande mkdir.

4 Dans app1, créez un fichier [Link] avec echo 'DevOps' > [Link].

5 Utilisez cat, head, tail pour lire ce fichier.

Cours DevOps Complet — Module 7 Page 7

6 Copiez [Link] vers ~/devops/backup/ puis renommez-le [Link].

7 Utilisez find pour retrouver tous les fichiers .html dans ~/devops.

8 Vérifiez les processus avec ps aux | grep bash.

■ TP 3 — Scripts Bash — Automatiser des Tâches | ■ 1h30

1 Créez un script 'sante_systeme.sh' qui affiche : la date, l'espace disque (df -h), la RAM (free -h), et les 5
processus qui consomment le plus (ps aux --sort=-%cpu | head -6).

2 Rendez-le exécutable : chmod +x sante_systeme.sh, puis lancez-le.

3 Ajoutez une condition : si l'espace disque libre est < 20%, afficher une alerte en rouge.

4 Créez un script '[Link]' qui copie un dossier vers un dossier backup avec la date dans le nom.

5 Testez votre script en créant des fichiers de test.

6 BONUS : Programmez l'exécution automatique avec cron (crontab -e, exécuter toutes les heures).

Cours DevOps Complet — Module 8 Page 8

Module 3 — Git & Contrôle de Version

3.1 Qu'est-ce que Git ?

Git est un système de contrôle de version distribué. En termes simples, c'est comme une machine à
remonter le temps pour votre code : Git garde l'historique de toutes les modifications, vous permet de
travailler à plusieurs sans vous écraser mutuellement, et vous laisse revenir à n'importe quelle version
précédente.

■ Analogie
• Imaginez un document Word avec l'historique de versions activé, mais en BEAUCOUP plus puissant
• Chaque développeur a une copie complète du projet (distribué)
• Git = outil local | GitHub/GitLab = hébergement distant du dépôt

3.2 Les Concepts Fondamentaux de Git

Concept Explication
Repository (dépôt) Le dossier de votre projet géré par Git (.git est créé dedans)

Un 'instantané' de votre code à un moment donné, avec un

Commit message descriptif

Une ligne de développement parallèle. Main est la branche

Branch (branche) principale

Merge Fusionner les modifications d'une branche dans une autre

Clone Télécharger une copie complète d'un dépôt distant

Pull Récupérer les dernières modifications du dépôt distant

Push Envoyer vos commits vers le dépôt distant

Fork Créer sa propre copie d'un dépôt public pour y contribuer

Pull Request Proposer ses modifications pour intégration (GitHub/GitLab)

3.3 Commandes Git Essentielles

# === CONFIGURATION INITIALE ===

git config --global [Link] 'Votre Nom'

git config --global [Link] 'vous@[Link]'

# === CRÉER / CLONER UN DÉPÔT ===

git init # Initialiser un nouveau dépôt local

git clone [Link] # Cloner un dépôt distant

# === LE CYCLE QUOTIDIEN ===

git status # Voir l'état des fichiers

Cours DevOps Complet — Module 9 Page 9

 git add [Link] # Ajouter un fichier au staging

git add . # Ajouter TOUS les fichiers modifiés

git commit -m 'feat: ajout login' # Créer un commit avec message

git push origin main # Envoyer vers GitHub

git pull origin main # Récupérer les dernières modifications

# === BRANCHES ===

git branch # Lister les branches

git branch feature/login # Créer une branche

git checkout feature/login # Basculer sur la branche

git checkout -b feature/login # Créer ET basculer (raccourci)

git merge feature/login # Fusionner dans la branche courante

git branch -d feature/login # Supprimer la branche (après merge)

# === HISTORIQUE ===

git log --oneline # Historique compact

git log --graph --all # Graphe visuel des branches

git diff # Voir les modifications non commitées

# === ANNULER ===

git restore [Link] # Annuler modifications non commitées

git revert HEAD # Annuler le dernier commit (safe)

3.4 GitFlow — Le Workflow Professionnel

GitFlow est une convention de branches utilisée en entreprise pour organiser le développement. Elle
définit des branches avec des rôles précis.

Code en production, toujours stable. JAMAIS de développement direct

main
ici.

develop Branche d'intégration. Les nouvelles fonctionnalités y sont fusionnées.

feature/* Une branche par fonctionnalité. Ex: feature/user-authentication

release/* Préparation d'une version. Tests finaux avant la prod.

hotfix/* Correction urgente d'un bug en production.

3.5 Bonnes Pratiques des Messages de Commit

Un bon message de commit explique QUOI et POURQUOI, pas comment. La convention Conventional
Commits est très utilisée en entreprise :

# Format : type(scope): description

Cours DevOps Complet — Module 10 Page 10

 # Types courants :

feat: ajout d'une nouvelle fonctionnalité

fix: correction d'un bug

docs: modification de documentation

refactor: refactorisation sans changement de comportement

test: ajout ou modification de tests

ci: modification de la configuration CI/CD

# Exemples BIEN :

git commit -m 'feat(auth): ajouter authentification JWT'

git commit -m 'fix(api): corriger timeout connexion base de données'

# Exemples MAL :

git commit -m 'fix bug' # Trop vague !

git commit -m 'WIP' # Work in progress : à éviter

■ TP 4 — Premier Dépôt Git & Workflow de Base | ■ 1h

1 Configurez Git avec votre nom et email (git config --global ...).

2 Créez un dossier 'mon-app-devops' et initialisez un dépôt Git.

3 Créez les fichiers : [Link], [Link], [Link] avec du contenu minimal.

4 Faites un premier commit avec le message 'feat: initialisation du projet'.

5 Créez un dépôt sur GitHub et liez-le : git remote add origin [Link]

6 Pushez votre code sur GitHub et vérifiez en ligne.

7 Modifiez [Link], faites un commit et un push.

8 Consultez l'historique avec git log --oneline --graph.

■ TP 5 — Branches, Merge et Gestion de Conflits | ■ 1h30

1 Depuis votre projet précédent, créez une branche 'feature/navigation'.

2 Ajoutez une barre de navigation dans [Link] sur cette branche.

3 Commitez les changements avec un message conventionnel.

4 Revenez sur main et créez une autre branche 'feature/footer'.

5 Ajoutez un footer dans [Link].

6 Fusionnez feature/navigation dans main (git merge).

7 Fusionnez feature/footer — vous aurez probablement un conflit !

8 Résolvez le conflit manuellement dans votre éditeur, puis commitez.

9 Pushez le tout et vérifiez l'historique avec le graphe.

Cours DevOps Complet — Module 11 Page 11

Module 4 — Docker & Conteneurisation

4.1 Qu'est-ce que Docker ?

Docker est une plateforme de conteneurisation. Un conteneur Docker est comme une boîte hermétique
qui contient votre application ET tout ce dont elle a besoin pour fonctionner (code, librairies,
configuration). Cette boîte fonctionne identiquement partout : sur votre PC, sur un serveur, sur AWS.

■ La métaphore du conteneur maritime

• Avant les conteneurs : chaque navire devait adapter sa cargaison (galères, délais, erreurs)
• Après les conteneurs : une boîte standardisée s'adapte à tous les bateaux/camions/trains
• Docker = même concept pour le logiciel : 'ça marche sur ma machine' disparaît !
• Le célèbre problème 'ça marche en dev mais pas en prod' est résolu

4.2 VM vs Conteneurs — La Différence Fondamentale

Machine Virtuelle (VM) Conteneur Docker
Isolation Complète (OS séparé) Processus isolé (partage le kernel)
Taille Plusieurs Go (OS inclus) Quelques Mo à centaines de Mo
Démarrage Minutes Secondes (voire millisecondes)
Performance Overhead important Quasi-native
Portabilité Bonne mais lourde Excellente et légère
Cas d'usage Isolation forte, multi-OS Microservices, CI/CD, scalabilité

4.3 Les Concepts Docker

Image Docker : Un modèle en lecture seule. Comme une recette de cuisine.
Conteneur : Une instance en cours d'exécution d'une image. Comme le plat cuisiné.
Dockerfile : Le fichier de recette pour construire une image, étape par étape.
Registry : Entrepôt d'images. Docker Hub est le registry public principal.
Volume : Stockage persistant monté dans un conteneur (données survivent au redémarrage).
Network : Réseau virtuel permettant la communication entre conteneurs.
docker-compose : Outil pour définir et lancer plusieurs conteneurs ensemble.

4.4 Commandes Docker Essentielles

# === IMAGES ===

docker pull nginx:latest # Télécharger une image

docker images # Lister les images locales

docker build -t mon-app:1.0 . # Construire depuis un Dockerfile

docker rmi nginx # Supprimer une image

Cours DevOps Complet — Module 12 Page 12

 # === CONTENEURS ===

docker run -d -p 8080:80 nginx # Lancer nginx en arrière-plan

# -d = détaché (background)

# -p 8080:80 = port hôte:port conteneur

docker ps # Lister les conteneurs actifs

docker ps -a # Tous les conteneurs

docker stop mon-conteneur # Arrêter

docker rm mon-conteneur # Supprimer

docker logs -f mon-conteneur # Voir les logs en temps réel

docker exec -it mon-conteneur bash # Entrer dans le conteneur

# === VOLUMES ===

docker run -v /data/app:/app nginx # Monter un volume

docker volume create mes-donnees # Créer un volume nommé

docker volume ls # Lister les volumes

4.5 Écrire un Dockerfile

Le Dockerfile est le cœur de Docker. Chaque instruction crée une couche (layer) dans l'image.

# Dockerfile pour une application [Link]

# 1. Image de base (on part d'une base connue)

FROM node:18-alpine

# 2. Métadonnées

LABEL maintainer='vous@[Link]'

LABEL version='1.0'

# 3. Répertoire de travail dans le conteneur

WORKDIR /app

# 4. Copier les fichiers de dépendances en premier (optimisation cache)

COPY package*.json ./

# 5. Installer les dépendances

RUN npm install --production

# 6. Copier le reste du code

COPY . .

# 7. Exposer le port de l'application

EXPOSE 3000

# 8. Variables d'environnement

Cours DevOps Complet — Module 13 Page 13

 ENV NODE_ENV=production

# 9. Utilisateur non-root (sécurité !)

USER node

# 10. Commande de démarrage

CMD ['node', '[Link]']

4.6 Docker Compose — Orchestrer Plusieurs Services

En réalité, une application est composée de plusieurs services : une API, une base de données, un
cache Redis, etc. Docker Compose vous permet de les définir et lancer ensemble.

# [Link]

version: '3.8'

services:

# Service 1 : Application web

webapp:

build: ./app # Construire depuis Dockerfile

ports:

- '3000:3000'

environment:

- NODE_ENV=production

- DB_HOST=database

depends_on:

- database

- redis

networks:

- app-network

# Service 2 : Base de données PostgreSQL

database:

image: postgres:15

volumes:

- db-data:/var/lib/postgresql/data

environment:

- POSTGRES_DB=myapp

- POSTGRES_PASSWORD=secret

networks:

- app-network

Cours DevOps Complet — Module 14 Page 14

 # Service 3 : Cache Redis

redis:

image: redis:7-alpine

networks:

- app-network

# Volumes persistants

volumes:

db-data:

# Réseau interne

networks:

app-network:

driver: bridge

# Commandes utiles :

# docker-compose up -d # Lancer tous les services

# docker-compose down # Arrêter et supprimer

# docker-compose logs -f # Voir les logs

# docker-compose ps # Status des services

■ TP 6 — Premiers Conteneurs Docker | ■ 1h

1 Installez Docker Desktop ([Link] sur votre machine.

2 Vérifiez l'installation : docker --version et docker run hello-world.

3 Lancez un serveur Nginx : docker run -d -p 8080:80 --name mon-nginx nginx.

4 Ouvrez [Link] dans votre navigateur — vous devriez voir Nginx !

5 Remplacez la page par défaut : créez un fichier [Link] personnalisé et montez-le.

6 Listez les conteneurs, les images, arrêtez et supprimez le conteneur.

7 Explorez Docker Hub et téléchargez l'image MySQL, Redis, et Alpine.

■ TP 7 — Créer sa Première Image Docker | ■ 1h30

1 Créez une application web simple en Python avec Flask (pip install flask).

2 Créez [Link] avec une route GET / qui retourne 'Hello DevOps !'.

3 Créez le Dockerfile correspondant (FROM python:3.11-slim, COPY, RUN pip install, CMD).

4 Construisez l'image : docker build -t mon-flask-app:1.0 .

5 Lancez le conteneur : docker run -d -p 5000:5000 mon-flask-app:1.0.

6 Testez avec curl [Link] ou votre navigateur.

7 Publiez sur Docker Hub : docker tag et docker push.

8 Vérifiez que quelqu'un d'autre peut docker pull votre image.

Cours DevOps Complet — Module 15 Page 15

 ■ TP 8 — Docker Compose — Application Multi-Services | ■ 2h
1 Créez un projet avec 3 services : une API Flask, PostgreSQL, et Adminer (interface DB).

2 Rédigez le [Link] avec les 3 services, les volumes et le réseau.

3 L'API Flask doit se connecter à PostgreSQL et retourner les données d'une table.

4 Adminer doit être accessible sur le port 8080 pour gérer la base graphiquement.

5 Testez : docker-compose up -d, vérifiez les logs, accédez aux services.

6 Modifiez le code de l'API, reconstruisez l'image et relancez avec docker-compose up --build.

7 BONUS : Ajoutez un service Redis pour cacher les réponses de l'API.

Cours DevOps Complet — Module 16 Page 16

Module 5 — CI/CD : Intégration et Déploiement
Continus

5.1 Qu'est-ce que CI/CD ?

CI/CD est l'automatisation du processus de test et de déploiement d'une application. C'est le cœur du
DevOps moderne.

CI — Intégration Chaque fois qu'un développeur pousse du code sur Git, une série
Continue de vérifications automatiques s'exécute : compilation, tests
unitaires, analyse de qualité. Si quelque chose échoue, le
développeur est alerté immédiatement.

CD — Livraison Si les tests CI passent, l'application est automatiquement packagée

Continue et prête à déployer. Un clic suffit pour mettre en production (ou c'est
totalement automatique).

CD — Déploiement La forme la plus avancée : si tous les tests passent, le déploiement

Continu en production est entièrement automatique, sans intervention
humaine.

5.2 GitHub Actions — Le Pipeline CI/CD Intégré à GitHub

GitHub Actions est l'outil CI/CD intégré directement dans GitHub. C'est aujourd'hui l'un des outils les plus
utilisés en entreprise. Vous définissez vos pipelines dans des fichiers YAML dans le dossier
.github/workflows/.

Anatomie d'un workflow GitHub Actions :

# .github/workflows/[Link]

name: Pipeline CI/CD # Nom du workflow

on: # Déclencheurs

push:

branches: [main, develop] # Sur push vers ces branches

pull_request:

branches: [main] # Ou sur Pull Request

jobs: # Les jobs à exécuter

test: # Nom du job

runs-on: ubuntu-latest # Système d'exploitation

steps:

- name: Checkout code # Récupérer le code

uses: actions/checkout@v4

Cours DevOps Complet — Module 17 Page 17

 - name: Setup Python # Installer Python

uses: actions/setup-python@v4

with:

python-version: '3.11'

- name: Install deps # Installer les dépendances

run: pip install -r [Link]

- name: Run tests # Lancer les tests

run: pytest tests/ -v

- name: Code quality # Vérifier la qualité

run: flake8 .

build-and-push: # Job de build Docker

needs: test # Exécuté seulement si 'test' réussit

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v4

- name: Login to Docker Hub

uses: docker/login-action@v3

with:

username: ${{ secrets.DOCKERHUB_USERNAME }}

password: ${{ secrets.DOCKERHUB_TOKEN }}

- name: Build and push

uses: docker/build-push-action@v5

with:

push: true

tags: monuser/mon-app:latest

deploy: # Job de déploiement

needs: build-and-push

runs-on: ubuntu-latest

steps:

- name: Deploy to server

uses: appleboy/ssh-action@v1

with:

host: ${{ secrets.SERVER_HOST }}

username: ubuntu

key: ${{ secrets.SSH_PRIVATE_KEY }}

Cours DevOps Complet — Module 18 Page 18

 script: |

docker pull monuser/mon-app:latest

docker-compose up -d

5.3 Les Tests dans le Pipeline CI

Un bon pipeline CI doit inclure plusieurs niveaux de tests :

Tests Unitaires : Testent une fonction ou classe en isolation. Rapides (ms). 70% de vos tests.
Tests d'Intégration : Testent l'interaction entre composants (ex: API + DB). Plus lents.
Tests End-to-End (E2E) : Simulent un utilisateur réel dans le navigateur. Très lents, peu nombreux.
Tests de Sécurité : SAST (code), DAST (runtime), scan de vulnérabilités des dépendances.
Analyse de Qualité : SonarQube, CodeClimate : complexité cyclomatique, code dupliqué.

# Exemple de tests Python avec pytest

# fichier: tests/test_api.py

import pytest

from app import create_app

# Fixture : configuration de test

@[Link]

def client():

app = create_app({'TESTING': True})

with app.test_client() as client:

yield client

# Test unitaire

def test_homepage(client):

response = [Link]('/')

assert response.status_code == 200

assert b'Hello DevOps' in [Link]

# Test avec données

def test_create_user(client):

data = {'username': 'alice', 'email': 'alice@[Link]'}

response = [Link]('/users', json=data)

assert response.status_code == 201

assert [Link]['username'] == 'alice'

■ TP 9 — Votre Premier Pipeline CI avec GitHub Actions | ■ 1h30

1 Reprenez votre projet Flask dockerisé du TP 7.

2 Créez le dossier .github/workflows/ et le fichier [Link].

Cours DevOps Complet — Module 19 Page 19

3 Configurez le workflow pour s'exécuter sur push vers main.

4 Étape 1 du pipeline : installer les dépendances Python.

5 Étape 2 : lancer pytest (créez au moins 2 tests simples).

6 Étape 3 : lancer flake8 pour vérifier la syntaxe Python.

7 Pushez sur GitHub et observez le pipeline dans l'onglet 'Actions'.

8 Introduisez volontairement un bug, pushez et observez l'échec du pipeline.

■ TP 10 — Pipeline Complet CI/CD avec Build Docker et Deploy | ■ 2h

1 Ajoutez un job 'build-docker' qui se lance après les tests réussis.

2 Configurez les secrets GitHub : DOCKERHUB_USERNAME et DOCKERHUB_TOKEN.

3 Le job doit construire l'image Docker et la pousser vers Docker Hub.

4 Créez un serveur de test avec Play with Docker ([Link]

5 Ajoutez un job 'deploy' qui SSH vers ce serveur et lance docker pull + docker-compose up.

6 Testez le pipeline complet : code → tests → build → deploy automatique.

7 BONUS : Ajoutez des notifications Slack ou email en cas d'échec.

Cours DevOps Complet — Module 20 Page 20

Module 6 — Kubernetes : Orchestration de
Conteneurs

6.1 Pourquoi Kubernetes ?

Docker seul est parfait pour un ou quelques conteneurs. Mais en production, vous avez peut-être 100,
1000 ou 10000 conteneurs à gérer sur des dizaines de serveurs. Kubernetes (K8s) est le système
d'orchestration qui automatise ce travail.

■ Kubernetes résout automatiquement

• Haute disponibilité : si un conteneur tombe, K8s le redémarre automatiquement
• Scalabilité : augmenter le nombre d'instances selon la charge (auto-scaling)
• Load balancing : répartir le trafic entre les instances
• Rolling updates : mettre à jour sans interruption de service
• Self-healing : remplacer automatiquement les conteneurs défaillants
• Gestion des secrets et de la configuration

6.2 Architecture Kubernetes

Control Plane (Maître)
API Server : Point d'entrée unique. Toutes les commandes kubectl passent par lui.
etcd : Base de données clé-valeur qui stocke l'état du cluster.
Scheduler : Décide sur quel nœud placer chaque Pod.
Controller Manager : Maintient l'état désiré (ex: toujours 3 replicas actifs).

Worker Nodes (Travailleurs)

kubelet : Agent sur chaque nœud, communique avec l'API Server.
kube-proxy : Gère le réseau et le load balancing entre Pods.
Container Runtime : Docker ou containerd : exécute réellement les conteneurs.

6.3 Les Objets Kubernetes Fondamentaux

Objet Rôle
L'unité de base. Contient un ou plusieurs conteneurs partageant
Pod réseau et stockage.

Gère un ensemble de Pods identiques, assure le nombre de replicas

Deployment désiré.

Service Expose des Pods en réseau, fournit une IP stable et le load balancing.

ConfigMap Stocke la configuration non-sensible (variables d'env, fichiers config).

Stocke les données sensibles (mots de passe, tokens) encodées en

Secret base64.

Cours DevOps Complet — Module 21 Page 21

 Espace d'isolation logique pour séparer les environnements
Namespace (dev/prod).

Gère l'accès HTTP/HTTPS depuis l'extérieur vers les Services

Ingress internes.

PersistentVolume Stockage persistant pour les bases de données et données stateful.

Horizontal Pod Autoscaler : scale automatiquement selon la charge

HPA CPU/RAM.

6.4 Les Manifestes YAML Kubernetes

Tout dans Kubernetes est défini en YAML. On appelle ces fichiers des manifestes. Voici les manifestes
essentiels pour déployer une application :

Deployment :
# [Link]

apiVersion: apps/v1

kind: Deployment

metadata:

name: mon-app

namespace: production

labels:

app: mon-app

spec:

replicas: 3 # 3 instances de l'application

selector:

matchLabels:

app: mon-app

strategy:

type: RollingUpdate # Mise à jour sans downtime

rollingUpdate:

maxUnavailable: 1

maxSurge: 1

template:

metadata:

labels:

app: mon-app

spec:

containers:

- name: mon-app

Cours DevOps Complet — Module 22 Page 22

 image: monuser/mon-app:1.2.0

ports:

- containerPort: 3000

env:

- name: NODE_ENV

value: 'production'

- name: DB_PASSWORD

valueFrom:

secretKeyRef: # Référence à un Secret K8s

name: app-secrets

key: db-password

resources:

requests:

memory: '128Mi'

cpu: '100m' # 100 millicores = 0.1 CPU

limits:

memory: '256Mi'

cpu: '500m'

readinessProbe: # L'app est-elle prête ?

httpGet:

path: /health

port: 3000

initialDelaySeconds: 10

periodSeconds: 5

Service et Ingress :
# [Link]

apiVersion: v1

kind: Service

metadata:

name: mon-app-service

spec:

selector:

app: mon-app # Cible les Pods avec ce label

ports:

- protocol: TCP

port: 80

targetPort: 3000

Cours DevOps Complet — Module 23 Page 23

 type: ClusterIP # Interne au cluster

---

# [Link]

apiVersion: [Link]/v1

kind: Ingress

metadata:

name: mon-app-ingress

annotations:

[Link]/rewrite-target: /

spec:

rules:

- host: [Link]

http:

paths:

- path: /

pathType: Prefix

backend:

service:

name: mon-app-service

port:

number: 80

6.5 Commandes kubectl Essentielles

# === INFORMATIONS ===

kubectl get nodes # Lister les nœuds

kubectl get pods -n production # Pods d'un namespace

kubectl get all # Tout lister

kubectl describe pod mon-pod # Détails d'un Pod

kubectl logs mon-pod -f # Logs en temps réel

# === DÉPLOIEMENT ===

kubectl apply -f [Link] # Appliquer un manifeste

kubectl apply -f ./k8s/ # Appliquer un dossier entier

kubectl delete -f [Link] # Supprimer des ressources

# === DEBUGGING ===

kubectl exec -it mon-pod -- bash # Entrer dans un Pod

kubectl port-forward pod/mon-pod 8080:3000 # Accès local

kubectl get events --sort-by=.[Link]

Cours DevOps Complet — Module 24 Page 24

 # === SCALING ===

kubectl scale deployment mon-app --replicas=5

kubectl rollout status deployment/mon-app

kubectl rollout undo deployment/mon-app # Rollback

■ TP 11 — Kubernetes avec Minikube — Cluster Local | ■ 1h30

1 Installez Minikube ([Link] et kubectl.

2 Démarrez un cluster : minikube start --driver=docker.

3 Vérifiez : kubectl get nodes — vous devez voir le nœud minikube.

4 Déployez votre application Flask : créez [Link] et [Link].

5 Appliquez : kubectl apply -f . et vérifiez kubectl get pods.

6 Accédez à l'application : minikube service mon-app-service --url.

7 Scalez à 3 replicas et vérifiez que les 3 Pods tournent.

8 Supprimez un Pod manuellement et observez K8s le recréer automatiquement.

■ TP 12 — Déploiement Avancé — ConfigMap, Secret et HPA | ■ 2h

1 Créez un ConfigMap pour la configuration de l'application (variables d'env).

2 Créez un Secret pour le mot de passe de la base de données.

3 Modifiez le Deployment pour utiliser ces ressources.

4 Configurez un HPA (Horizontal Pod Autoscaler) : scale si CPU > 50%.

5 Installez un générateur de charge (hey ou k6) et stressez l'application.

6 Observez le scaling automatique avec kubectl get hpa -w.

7 Faites un rolling update : changez la version de l'image et appliquez.

8 BONUS : Déployez sur un cluster cloud gratuit (GKE Autopilot Free Tier).

Cours DevOps Complet — Module 25 Page 25

Module 7 — Infrastructure as Code &
Monitoring

7.1 Infrastructure as Code (IaC) avec Terraform

L'Infrastructure as Code (IaC) consiste à décrire votre infrastructure (serveurs, réseaux, bases de
données...) dans des fichiers de code versionnable. Terraform est l'outil IaC le plus utilisé en entreprise.

■ Avantages de l'IaC
• Reproductibilité : recréer l'infra identique en quelques minutes
• Versionnement : historique Git de toutes les modifications d'infrastructure
• Collaboration : plusieurs personnes peuvent travailler sur la même infra
• Documentation vivante : le code EST la documentation
• Réduction des erreurs humaines : exit les clics manuels dans les consoles

Concepts Terraform :
Provider : Plugin qui se connecte à AWS, GCP, Azure, etc. Déclare les APIs disponibles.
Resource : Un objet d'infrastructure : un serveur EC2, un bucket S3, une base RDS...
Variable : Paramètre configurable pour rendre le code réutilisable.
Output : Valeur exportée après la création (ex: IP publique du serveur).
State : Fichier [Link] qui suit l'état réel de l'infrastructure.
Module : Groupe réutilisable de ressources (comme une fonction en programmation).

# [Link] — Créer un serveur web sur AWS

# 1. Déclarer le provider AWS

terraform {

required_providers {

aws = {

source = 'hashicorp/aws'

version = '~> 5.0'

provider 'aws' {

region = var.aws_region

# 2. Variables

variable 'aws_region' {

default = 'eu-west-1'

Cours DevOps Complet — Module 26 Page 26

 }

variable 'instance_type' {

default = '[Link]'

# 3. Ressources

resource 'aws_instance' 'web_server' {

ami = 'ami-0c02fb55956c7d316' # Amazon Linux 2

instance_type = var.instance_type

key_name = 'ma-cle-ssh'

tags = {

Name = 'serveur-web-devops'

Environment = 'production'

ManagedBy = 'terraform'

# 4. Output

output 'server_public_ip' {

value = aws_instance.web_server.public_ip

# === Commandes Terraform ===

# terraform init # Initialiser et télécharger les providers

# terraform plan # Prévisualiser les changements (DRY RUN)

# terraform apply # Appliquer les changements

# terraform destroy # Supprimer toute l'infrastructure

7.2 Ansible — Configuration Management

Ansible automatise la configuration des serveurs. Là où Terraform crée l'infrastructure, Ansible la
configure (installer Nginx, déployer l'app, gérer les utilisateurs...).

# [Link] — Configurer un serveur web

---

- name: Configurer serveur web

hosts: webservers

become: yes # Sudo

vars:

app_port: 3000

Cours DevOps Complet — Module 27 Page 27

 app_user: devops

tasks:

- name: Mettre à jour les paquets

apt:

update_cache: yes

upgrade: yes

- name: Installer Nginx et [Link]

apt:

name:

- nginx

- nodejs

- npm

state: present

- name: Créer l'utilisateur application

user:

name: '{{ app_user }}'

system: yes

- name: Déployer la configuration Nginx

template:

src: [Link].j2

dest: /etc/nginx/sites-enabled/monapp

notify: Reload Nginx

handlers:

- name: Reload Nginx

service:

name: nginx

state: reloaded

7.3 Monitoring avec Prometheus & Grafana

En production, vous devez surveiller en permanence la santé de vos applications. Prometheus collecte
des métriques et Grafana les affiche dans des tableaux de bord.

Prometheus : Collecte et stocke les métriques. Utilise un langage de requête PromQL.

Grafana : Visualise les métriques en tableaux de bord interactifs et beaux.
Alertmanager : Envoie des alertes (Slack, email, PagerDuty) quand les seuils sont dépassés.
Node Exporter : Exporte les métriques système : CPU, RAM, disque, réseau.
cAdvisor : Exporte les métriques des conteneurs Docker.

Cours DevOps Complet — Module 28 Page 28

 Loki : Système d'agrégation de logs (comme Prometheus mais pour les logs).

# docker-compose monitoring — Stack Prometheus + Grafana

version: '3.8'

services:

prometheus:

image: prom/prometheus:latest

volumes:

- ./[Link]:/etc/prometheus/[Link]

ports:

- '9090:9090'

grafana:

image: grafana/grafana:latest

ports:

- '3000:3000'

environment:

- GF_SECURITY_ADMIN_PASSWORD=devops123

volumes:

- grafana-data:/var/lib/grafana

node-exporter:

image: prom/node-exporter:latest

ports:

- '9100:9100'

volumes:

grafana-data:

# [Link] — Configuration de scraping

global:

scrape_interval: 15s

scrape_configs:

- job_name: 'prometheus'

static_configs:

- targets: ['localhost:9090']

- job_name: 'node'

static_configs:

- targets: ['node-exporter:9100']

■ TP 13 — Terraform — Provisionner une Infrastructure Cloud | ■ 2h

1 Créez un compte AWS Free Tier ([Link]

Cours DevOps Complet — Module 29 Page 29

2 Installez Terraform et configurez les credentials AWS.

3 Écrivez un [Link] qui crée : un VPC, un subnet public, et une instance EC2.

4 Ajoutez un Security Group pour autoriser SSH (22) et HTTP (80).

5 Lancez terraform plan pour visualiser les changements.

6 Lancez terraform apply et connectez-vous en SSH à votre serveur.

7 Modifiez le type d'instance et relancez terraform apply — observez le changement.

8 terraform destroy pour ne pas payer inutilement !

■ TP 14 — Ansible — Configurer un Serveur Automatiquement | ■ 1h30

1 Installez Ansible sur votre machine.

2 Créez un inventaire avec l'IP de votre serveur EC2 du TP précédent.

3 Écrivez un playbook qui installe Nginx, [Link], et copie votre application.

4 Ajoutez une tâche pour configurer un service systemd pour l'application.

5 Testez : ansible-playbook -i inventaire [Link].

6 Vérifiez que l'application est accessible sur l'IP publique du serveur.

7 Modifiez la configuration Nginx via Ansible et re-déployez.

■ TP 15 — Stack de Monitoring Complète | ■ 2h

1 Lancez la stack Prometheus + Grafana + Node Exporter avec docker-compose.

2 Accédez à Prometheus (port 9090) et vérifiez que les targets sont UP.

3 Accédez à Grafana (port 3000) et ajoutez Prometheus comme datasource.

4 Importez le dashboard Node Exporter Full (ID: 1860) depuis [Link].

5 Observez les métriques CPU, RAM, réseau en temps réel.

6 Créez une alerte : notifier si le CPU dépasse 80% pendant 5 minutes.

7 Instrumentez votre application Flask pour exposer des métriques custom.

8 BONUS : Installez Loki + Promtail pour centraliser les logs de vos conteneurs.

Cours DevOps Complet — Module 30 Page 30

■ Projets Complets — Mettez en Pratique
Ces 5 projets intègrent toutes les compétences du cours. Ils sont progressifs et correspondent à des
scénarios réels d'entreprise. Ils constituent un excellent portfolio pour votre recherche de stage ou
d'emploi.

■ PROJET 1 — Application Web avec Pipeline CI/CD Complet

Niveau : Débutant-Intermédiaire | Durée estimée : 1-2 semaines

Créez une application web complète (blog ou todo-list) avec une base de données, dockerisez-la, et mettez en
place un pipeline CI/CD qui déploie automatiquement à chaque push sur main.

Tâches :
✔ Développer une API REST en Python/Flask ou [Link]/Express
✔ Base de données PostgreSQL avec migrations automatiques
✔ Frontend simple en HTML/CSS/JavaScript
✔ Dockerfile et docker-compose pour l'environnement local
✔ Tests unitaires et d'intégration (coverage > 70%)
✔ Pipeline GitHub Actions : tests → build Docker → push → deploy
✔ Déploiement sur un serveur VPS (DigitalOcean $6/mois ou AWS EC2 Free Tier)
✔ Configuration SSL/HTTPS avec Let's Encrypt

Technologies : Python/Flask · PostgreSQL · Docker · GitHub Actions · Nginx · Let's Encrypt

■ PROJET 2 — Microservices E-Commerce sur Kubernetes

Niveau : Intermédiaire | Durée estimée : 2-3 semaines

Décomposez une application e-commerce en microservices indépendants, conteneurisez chaque service et

déployez l'ensemble sur Kubernetes avec haute disponibilité et auto-scaling.

Tâches :
✔ 4 microservices : users, products, orders, notifications
✔ Communication via API REST et/ou message queue (RabbitMQ)
✔ Un Dockerfile optimisé par service
✔ Manifestes Kubernetes : Deployment, Service, Ingress, ConfigMap, Secret
✔ HPA (auto-scaling) configuré sur chaque service
✔ Helm Chart pour packager et déployer l'ensemble
✔ Pipeline CI/CD : build → push → kubectl apply automatique
✔ Monitoring avec Prometheus et Grafana

Technologies : Docker · Kubernetes · Helm · RabbitMQ · Prometheus · Grafana · GitHub Actions

■ PROJET 3 — Infrastructure Cloud avec Terraform & Ansible

Niveau : Intermédiaire | Durée estimée : 1-2 semaines

Provisionnez une infrastructure cloud complète en code, incluant réseau, serveurs, base de données
managée, et configurez tout automatiquement avec Ansible.

Cours DevOps Complet — Module 31 Page 31

 Tâches :
✔ VPC avec subnets publics et privés sur AWS
✔ Auto Scaling Group pour les serveurs d'application
✔ RDS PostgreSQL en mode Multi-AZ pour la haute disponibilité
✔ Load Balancer (ALB) devant les serveurs
✔ Playbooks Ansible pour configurer chaque type de serveur
✔ Gestion des secrets avec AWS Secrets Manager
✔ Terraform modules réutilisables (vpc, ec2, rds)
✔ Backend Terraform distant (S3 + DynamoDB pour le state)

Technologies : Terraform · Ansible · AWS · VPC · RDS · ALB · Secrets Manager

■ PROJET 4 — Plateforme DevOps Interne (DevOps Portal)

Niveau : Intermédiaire-Avancé | Durée estimée : 3-4 semaines

Créez une plateforme interne qui centralise les outils DevOps de votre équipe : déploiements, monitoring,
gestion des secrets, et automatisation.

Tâches :
✔ Interface web pour déclencher des déploiements manuels
✔ Intégration avec GitHub API pour afficher le statut des pipelines
✔ Tableau de bord de monitoring (embed Grafana ou Prometheus API)
✔ Gestionnaire de secrets simple (HashiCorp Vault en mode dev)
✔ Système de notifications (Slack webhook)
✔ Authentification avec GitHub OAuth
✔ Déployé sur Kubernetes avec Helm
✔ Documentation complète du projet (README, ADR, runbooks)

Technologies : React · [Link] · GitHub API · Vault · Kubernetes · Helm · Slack API

■ PROJET 5 — Site Haute Disponibilité Multi-Région

Niveau : Avancé | Durée estimée : 3-4 semaines

Déployez une application en haute disponibilité sur 2 régions AWS, avec failover automatique, CDN global et
observabilité complète. Un projet de niveau senior DevOps.

Tâches :
✔ Infrastructure Terraform multi-régions (eu-west-1 + us-east-1)
✔ Route53 avec health checks et failover automatique
✔ CloudFront CDN pour les assets statiques
✔ RDS Aurora Global Database pour la réplication multi-régions
✔ Application déployée sur EKS (Kubernetes managé AWS) dans chaque région
✔ Stack observabilité : Prometheus, Grafana, Loki, Jaeger (tracing)
✔ Disaster Recovery testé et documenté (RTO < 5min, RPO < 1min)
✔ Runbooks détaillés pour toutes les opérations

Technologies : Terraform · AWS · EKS · RDS Aurora · CloudFront · Route53 · Jaeger · OpenTelemetry

Cours DevOps Complet — Module 32 Page 32

■ Ressources & Feuille de Route

Roadmap Recommandée (12-18 mois)

Mois 1-2 Linux, Bash, Git, GitHub — Les fondations absolues

Mois 3-4 Docker, Docker Compose — Maîtriser la conteneurisation

Mois 5-6 CI/CD avec GitHub Actions — Automatiser les déploiements

Mois 7-9 Kubernetes — Orchestration et Helm Charts

Mois 10-11 Terraform + Ansible — Infrastructure as Code

Mois 12-13 Monitoring — Prometheus, Grafana, Loki, alerting

Mois 14-15 Cloud AWS/GCP/Azure — Certifications (AWS SAA, CKA)

Mois 16-18 Security (DevSecOps), GitOps (ArgoCD), Service Mesh (Istio)

Certifications à viser (par ordre)

Certification Domaine Coût
AWS Certified Cloud Practitioner Fondations cloud AWS ~$100 ✓
Linux Foundation LFCS Administration Linux ~$395 ✓
Certified Kubernetes Application
Developer (CKAD) K8s pour devs ~$395 ✓
Certified Kubernetes Administrator
(CKA) K8s administration ~$395 ✓
AWS Solutions Architect Associate Architecture AWS ~$150 ✓
HashiCorp Terraform Associate IaC avec Terraform ~$70 ✓

Ressources Gratuites Recommandées

■ Documentation officielle
→ [Link] — Documentation Docker (excellente)
→ [Link]/docs — Documentation Kubernetes officielle
→ [Link]/terraform — Tutoriels Terraform
→ [Link]/actions — GitHub Actions

■ Vidéos & Cours en ligne

→ TechWorld with Nana (YouTube) — Meilleure chaîne DevOps en anglais
→ Xavki (YouTube) — Excellente chaîne DevOps en FRANÇAIS
→ [Link] — Labs pratiques DevOps (payant mais excellent)

Cours DevOps Complet — Module 33 Page 33

 → [Link] — Environnement Docker gratuit en ligne
→ [Link] — Simulateurs d'examens CKA/CKAD

■ Outils & Labs Gratuits

→ GitHub Student Pack — Accès gratuit à des tonnes d'outils
→ AWS Free Tier — 12 mois gratuits pour de nombreux services
→ GCP Free Tier — $300 de crédit gratuit
→ [Link] / [Link] — Scénarios K8s interactifs
→ [Link]/devops — Roadmap interactive visuelle

■ Livres Recommandés
→ The Phoenix Project — Roman sur la transformation DevOps (obligatoire !)
→ The DevOps Handbook — Guide pratique complet
→ Site Reliability Engineering (Google) — Gratuit en ligne sur [Link]
→ Kubernetes: Up and Running — O'Reilly

■ Votre prochaine étape : installer Linux (Ubuntu), créer votre compte GitHub, et
commencer le Module 1 aujourd'hui même. La clé du DevOps, c'est la pratique
quotidienne.
Bonne formation et bienvenue dans le monde DevOps ! ■

Cours DevOps Complet — Module 34 Page 34