menault/DEV_42_Docker
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

5 premiers cours

Browse Source
This commit is contained in:
Maxime Menault
2026-03-11 15:11:31 +01:00
commit b27ba5e52a
5 changed files with 1037 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
01_cours1.md Normal file
View File

@@ -0,0 +1,190 @@
---
marp: true
theme: default
paginate: true
backgroundColor: #fff
footer: 'Histoire de la Virtualisation - 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
## Virtualisation
---
# Programme
1. Histoire de la virtualisation
2. Virtualisation
3. Conteneurisation
4. Histoire de docker
5. Cas Docker
---
# 1. L'Histoire de la Virtualisation
## Pourquoi et Comment nous en sommes arrivés là
---
# Années 60 : Le problème des mainframes coûteux
## Le Contexte
- Ordinateurs très chers (plusieurs millions de dollars)
- Temps d'utilisation précieux
- Une seule tâche à la fois
## La Solution : IBM M44/44X (1964)
- Partager la puissance entre plusieurs utilisateurs
- Optimiser l'utilisation des ressources
- Permettre l'exécution simultanée de programmes
---
# Années 70-80 : Le besoin de développement et test
<div class="columns">
<div>
## Les Défis
- Développement de nouveaux systèmes d'exploitation
- Tests de logiciels
- Formation des utilisateurs
</div>
<div>
## La Solution : VM/370
- Environnements isolés pour le développement
- Possibilité de crasher sans impact
- Multiples configurations de test
</div>
</div>
---
# Années 90 : L'arrivée des PC et le problème de compatibilité
<div class="columns">
<div>
## Nouveaux Besoins
- Exécuter d'anciens logiciels DOS
- Supporter plusieurs OS sur un même PC
- Tester des logiciels sur différents systèmes
</div>
<div>
## La Solution : VMware
- Virtualisation sur PC standard
- Support de multiples OS
- Coût réduit par rapport aux mainframes
</div>
</div>
---
# Années 2000 : L'explosion d'Internet et des serveurs
<div class="columns">
<div>
## Problématiques
- Multiplication des serveurs physiques
- Coûts d'hébergement croissants
- Gaspillage de ressources
</div>
<div>
## Solutions Émergentes
- Consolidation des serveurs
- Xen et virtualisation open source
- Début du "Green IT"
</div>
</div>
---
# Années 2010 : L'ère du Cloud Computing
## Nouveaux Défis
- Besoin de scalabilité dynamique
- Réduction des coûts d'infrastructure
- Agilité et rapidité de déploiement
## La Réponse
- Infrastructure as a Service (IaaS)
- Conteneurisation avec Docker
- Orchestration avec Kubernetes
---
# Aujourd'hui : L'omniprésence de la virtualisation
## Motivations Actuelles
- **Économiques**
- Optimisation des coûts
- Paiement à l'usage
- **Techniques**
- Déploiement rapide
- Haute disponibilité
- **Écologiques**
- Réduction de l'empreinte carbone
- Optimisation des ressources
---
# Le Futur : Nouveaux défis, nouvelles solutions
## Défis Émergents
- Edge Computing
- Efficacité énergétique
- Sécurité et isolation
## Tendances
- Virtualisation assistée par IA
- Serverless Computing
- Virtualisation imbriquée
---
# La Virtualisation : Une réponse à chaque époque
<div class="columns">
<div>
## Évolution des besoins
1. Optimisation des coûts matériels
2. Flexibilité de développement
3. Compatibilité logicielle
4. Efficacité énergétique
5. Élasticité des ressources
</div>
<div>
## Aujourd'hui
- Fondation du cloud computing
- Base des architectures modernes
- Pilier de la transformation numérique
</div>
</div>

167
02_virtualisation.md Normal file
View File

@@ -0,0 +1,167 @@
---
marp: true
theme: default
paginate: true
backgroundColor: #fff
footer: 'Virtualisation - 2025'
style: |
section {
font-family: 'Arial', sans-serif;
}
h1 {
color: #2496ed;
}
h2 {
color: #384c54;
}
---
# 2. Virtualisation
## Définition et concepts
---
# Virtualisation
* Serveur hôte
* Serveur privé virtuel
* Environnement isolé
* Système d'exploitation
---
# Avantages
* Utilisation optimale des ressources
* Installation, déploiement et migration facile
* Sécurisation et/ou Isolation d'un réseau
* Socle de base du Cloud Computing
* ...
---
# Inconvénients
* Parfois inadapté (Ex : I/O intense)
* Un recours à des machines puissantes
* Une complexité accrue de l'analyse d'erreurs
* ...
---
# Terminologie
* Le **système hôte (host)** est l'OS principal de l'ordianteur.
* Le **système invité (guest)** est l'OS installé à l'intérieur d'une machine virtuelle.
* Une **machine virtuelle (VM)** est un ordinateur virtuel qui utilise un sysètme invité.
* Un ordinateur est aussi appelé serveur privé virtuel
**(Virtuel Private Server ou VPS)** ou environnement virtuel (Virtual Environment ou VE).
---
# Domaines de virtualisation
* Virtualisation de serveurs
* Virtualisation des applications
* Virtualisation du stockage
* Virtualisation du réseau
---
# Virtualisation de serveurs
---
# Hyperviseurs de Type 1
* **"Bare-metal"** – directement sur le matériel
* Un micro-noyau qui gère l'accès au matériel et donne l'illusion d'exclusivité aux invités
* Un des OS (OS privilégié) dispose d'interfaces de gestion vers l'hyperviseur
![bg right:48% 90%](./assets/type1Hypervisor.png)
---
# Hyperviseurs de Type 1
* Exemples
* VmWare vSphere
* Microsoft Hyper-V
* Xen
* Oracle VM Server
* Citrix Xen Server
* KVM
* Le noyau linux est l'hyperviseur
![bg right:48% 100%](./assets/type1Hypervisor2.png)
---
# Hyperviseurs de Type 2
* Un système dans un système
* Architecture hébergée
* L'hyperviseur est une couche d'abstraction
* Il est possible d'émuler plusieurs composants
* Adaptateur vidéo, processeur, adaptateur réseau
![bg right:48% 90%](./assets/type2Hypervisor.png)
---
# Hyperviseurs de Type 2
* Exemples
* VmWare
* Workstation
* Fusion
* Player
* Oracle VirtualBox
* Microsoft VirtualPC
* QEMU
![bg right:48% 100%](./assets/type2Hypervisor2.png)
---
# Isolateur
* Logiciel sur OS hôte
* Isolation des exécutions
* Exemple :
* chroot
* LXC
* Docker
![bg right:48% 100%](./assets/isolateur.png)
---
# Noyau en espace utilisateur
* Exécution du noyau comme processus utilisateur
* Permet le développement et test de noyaux
* Exemples :
* User Mode Linux (UML)
* Colinux
* L4Linux
![bg right:48% 100%](./assets/noyaux.png)
---
# Noyau en espace utilisateur
* Avantages :
* Débogage facilité du noyau
* Tests sécurisés
* Protection du système hôte
* Cas d'usage :
* Développement de noyaux
* Tests de modifications
* Expérimentation sécurisée
![bg right:48% 100%](./assets/noyaux.png)
---
# Les usages
* Hyperviseur de type 1 => Professionnel
* Hyperviseur de type 2 => Professionnel / Particulier
* Isolateur => Professionnel / Particulier
* Noyau en espace utilisateur => Développement de noyaux

98
03_histoire_docker.md Normal file
View File

@@ -0,0 +1,98 @@
---
marp: true
theme: default
paginate: true
backgroundColor: #fff
footer: 'Histoire de la Conteneurisation - 2025'
style: |
section {
font-family: 'Arial', sans-serif;
}
h1 {
color: #2496ed;
}
h2 {
color: #384c54;
}
---
# L'Histoire de la Conteneurisation 🐳
## Des racines Unix à la révolution Docker
---
# Il était une fois... Unix (1979) 🌱
- Introduction de **chroot** dans Unix V7
- Premier pas vers l'isolation des processus
- Comme une "prison virtuelle" pour les programmes
![bg right:40% 20%](https://cdn.icon-icons.com/icons2/2699/PNG/512/unix_logo_icon_170924.png)
---
# L'Ère des Expérimentations (1991-2006) 🔬
## Les Innovations Clés :
- 1991 : Concept du "jail" par Bill Cheswick
- 2000 : FreeBSD jails - Version améliorée
- 2006 : **Google Process Containers**
- Gestion des ressources
- Base des futurs conteneurs
![bg right:30% 60%](https://cdn.icon-icons.com/icons2/2699/PNG/512/google_logo_icon_169090.png)
---
# La Naissance de LXC (2008) 🚀
## Linux Containers :
- Premier système de conteneurisation complet
- Utilisation des :
- cgroups (Control Groups)
- Namespaces Linux
- Base technologique pour Docker
![bg right:40% 50%](https://upload.wikimedia.org/wikipedia/commons/thumb/4/40/Linux_Containers_logo.png/120px-Linux_Containers_logo.png)
---
# La Révolution Docker (2013) 🐋
## Un Changement de Paradigme :
- Création par Solomon Hykes
- Standardisation des conteneurs
- Interface utilisateur simplifiée
- Écosystème riche :
- Docker Hub
- Docker Compose
- Docker Swarm
![bg right:40% 80%](https://cdn.icon-icons.com/icons2/2699/PNG/512/docker_logo_icon_170244.png)
---
# L'Ère de l'Orchestration (2015) ⚡
## Kubernetes et au-delà :
- Lancement de Kubernetes par Google
- Creation de l'Open Container Initiative (OCI)
- Standardisation industrielle
- Multi-cloud et portabilité
![bg right:40% 60%](https://cdn.icon-icons.com/icons2/2699/PNG/512/kubernetes_logo_icon_168359.png)
---
# Impact sur l'Industrie 📈
## Transformation Digitale :
- 74% d'adoption en entreprise
- Déploiement simplifié
- DevOps facilité
- Microservices popularisés

190
04_docker.md Normal file
View File

@@ -0,0 +1,190 @@
---
marp: true
theme: default
paginate: true
backgroundColor: #fff
footer: 'Conteneurisation - Partie 1 - 2025'
style: |
section {
font-family: 'Arial', sans-serif;
}
h1 {
color: #2496ed;
}
h2 {
color: #384c54;
}
---
# 3. La conteneurisation
## Cas de docker
---
# Conteneur
* Environnement isolé
* Système hôte
* Fonctions de configuration
* Dépend de l'hôte/kernel
---
# Les types de conteneurs
* **System :**
* simule une **séquence de boot** complète avec
un **init process** ainsi que **plusieurs processus** (LXC,
OpenVZ).
* **Process :**
* un conteneur **exécute un ou plusieurs processus** directement, en fonction de l'application conteneurisée (Docker, Rkt).
---
# Notion importantes
* Cgroups (Control Groups)
* Namespaces
![bg right:65% 100%](assets/cgroups_namesspaces.png)
---
# Les images
* Point de départ
* Archives / Snapshot
* On ne refait pas la roue
![bg right:60% 100%](./assets/images.png)
---
# Le registre
* Distributeur d’images
* Sécurité ?
* Docker Hub
* Exemple :
* ECS (AWS)
* Artifact Registry (Google Cloud)
---
# L’empilement des couches (Layers)
* Structure en couche
* Partage des couches
![alt text](./assets/layers.png)
---
# Cycle de Vie des Conteneurs Docker
- Introduction au cycle de vie des conteneurs
- États possibles et transitions
- Commandes de gestion
![bg right:48% 100%](./assets/lifecycle.png)
---
# États des Conteneurs Docker
**Created**
- Conteneur créé mais pas encore démarré
- `docker create`
**Running**
- Conteneur en cours d'exécution
- `docker run`, `docker start`
- Processus actifs à l'intérieur
---
# États des Conteneurs Docker
**Paused**
- Conteneur en pause (processus gelés)
- `docker pause`, `docker unpause`
**Stopped**
- Conteneur arrêté (processus terminés)
- `docker stop`, `docker kill`
---
# Commandes Principales de Gestion
**Création et Démarrage**
```bash
docker run # Crée et démarre un conteneur
docker start # Démarre un conteneur existant
```
**Gestion des États**
```bash
docker pause # Met en pause un conteneur
docker unpause # Reprend l'exécution
docker stop # Arrête proprement (SIGTERM)
docker kill # Arrête immédiatement (SIGKILL)
```
---
# Commandes Principales de Gestion
**Suppression**
```bash
docker rm # Supprime un conteneur arrêté
docker rm -f # Force la suppression d'un conteneur
```
---
# Inspection et Débug
**Commandes utiles**
```bash
docker ps # Liste les conteneurs en cours d'exécution
docker ps -a # Liste tous les conteneurs
docker logs # Affiche les logs du conteneur
docker exec # Exécute une commande dans un conteneur
docker stats # Affiche les statistiques d'utilisation
```
**Points importants**
- Un conteneur peut être redémarré (`docker restart`)
- Les données sont persistantes entre les redémarrages
- Les volumes permettent de persister les données même après suppression
---
# TP1
---
# Le stockage
* AUFS
* DeviceMapper
* OverlayFS
* Plugins
![bg right:65% 100%](./assets/stockage.png)
---
# Les volumes
* Persistance des données
* Indépendance vis à vis des conteneurs/layers
* Deux types de volume:
* Conteneur : data conteneur
* Hôte : dossier
![bg right:60% 100%](./assets/volume.png)

392
05_networks_dockerfile.md Normal file
View File

@@ -0,0 +1,392 @@
---
marp: true
theme: default
paginate: true
backgroundColor: #fff
footer: 'Conteneurisation - Partie 2 - 2025'
style: |
section {
font-family: 'Arial', sans-serif;
}
h1 {
color: #2496ed;
}
h2 {
color: #384c54;
}
---
# Docker Networks & Dockerfile
### IUT Sénart-Fontainebleau
#### 2025
---
# Plan du cours
1. Docker Networks
- Types de réseaux
- Communication entre conteneurs
- Use cases et bonnes pratiques
- Exercices pratiques
2. Dockerfile
- Construction d'images
- Multi-stage builds
- Optimisation et sécurité
- Cas pratiques
---
# 1. Docker Networks
## Pourquoi les réseaux Docker ?
- Isolation des conteneurs
- Communication sécurisée
- Simulation d'infrastructure
- Environnements multi-conteneurs
- Séparation des préoccupations
---
# Types de réseaux Docker
## Bridge (default)
- Réseau privé interne
- Communication entre conteneurs
- Port mapping pour accès externe
```bash
# Création d'un réseau bridge personnalisé
docker network create --driver bridge my-network
# Lancement d'un conteneur sur ce réseau
docker run --network my-network --name web1 nginx
# Inspection du réseau
docker network inspect my-network
```
---
# Types de réseaux Docker
## Host
- Utilise la stack réseau de l'hôte
- Performance maximale
- Moins sécurisé
- Cas d'usage : haute performance nécessaire
```bash
# Lancement en mode host
docker run --network host nginx
# Vérification des ports utilisés
ss -tunlp
```
---
# Types de réseaux Docker
## None
- Aucune connectivité réseau
- Isolation totale
- Pour les traitements isolés
- Cas d'usage : scripts de traitement batch
```bash
# Isolation complète
docker run --network none nginx
# Vérification de l'isolation
docker exec [container-id] ping 8.8.8.8
```
---
# Communication entre conteneurs
## Même réseau bridge
```bash
# Création du réseau
docker network create app-network
# Déploiement d'une stack web
docker run -d --network app-network --name frontend nginx
docker run -d --network app-network --name backend api
docker run -d --network app-network --name db postgres
# Test de communication
docker exec frontend ping backend
docker exec backend ping db
```
---
# DNS dans Docker
## Service Discovery
- Résolution automatique des noms
- Service discovery intégré
- Facilite la mise à l'échelle
```bash
# Communication par nom de service
http://backend:8080/api
http://db:5432
# Test de résolution DNS
docker exec frontend nslookup backend
docker exec frontend wget -qO- http://backend/health
```
---
# Inspection et Debug Réseau
## Outils disponibles
```bash
# Voir les réseaux
docker network ls
# Détails d'un réseau
docker network inspect bridge
# Connecter/Déconnecter à chaud
docker network connect app-network container1
docker network disconnect app-network container1
# Traces réseau
docker logs --follow container1
```
---
# 2. Pourquoi des Dockerfiles ?
## Problèmes résolus
- "Ça marche sur ma machine"
- Dépendances manquantes
- Versions différentes
- Configuration manuelle
## Avantages
- Infrastructure as Code (IaC)
- Reproductibilité garantie
- Déploiement automatisé
- Tests cohérents
- Documentation vivante
---
# Structure d'un Dockerfile Avancé
```dockerfile
# Base image selection
FROM alpine:3.14 AS builder
# Métadonnées détaillées
LABEL maintainer="name@example.com" \
version="1.0" \
description="Application web" \
environment="production"
# Variables d'environnement
ENV APP_HOME=/app \
APP_USER=webuser \
APP_ENV=prod
```
---
```dockerfile
# Création utilisateur dédié
RUN adduser -D -h $APP_HOME $APP_USER
# Installation des dépendances
RUN apk add --no-cache \
nodejs \
npm \
git
# Configuration du workdir
WORKDIR $APP_HOME
# Copie et permissions
COPY --chown=$APP_USER:$APP_USER . .
# Switch utilisateur
USER $APP_USER
# Healthcheck
HEALTHCHECK --interval=30s --timeout=3s \
CMD wget -q localhost:3000/health || exit 1
# Commande de démarrage
CMD ["node", "app.js"]
```
---
# Multi-stage builds
## Exemple Complet
```dockerfile
# Stage 1: Build
FROM node:16 AS builder
WORKDIR /build
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
# Stage 2: Test
FROM builder AS tester
RUN npm run test
```
---
# Multi-stage builds
## Exemple Complet
```dockerfile
# Stage 3: Production
FROM nginx:alpine
COPY --from=builder /build/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
```
---
# Optimisation des images
## Techniques avancées
1. Utilisation de .dockerignore
```dockerignore
node_modules
*.log
.git
tests
docs
```
---
# Optimisation des images
2. Ordonnancement des layers
```dockerfile
# Bon ordre (moins de rebuilds)
COPY package.json .
RUN npm install
COPY . .
# Mauvais ordre (rebuilds fréquents)
COPY . .
RUN npm install
```
---
# Optimisation des images
3. Nettoyage des caches
```dockerfile
RUN apt-get update && \
apt-get install -y package && \
rm -rf /var/lib/apt/lists/*
```
---
# Variables d'environnement et Secrets
## Bonnes pratiques
```dockerfile
# Variables build-time
ARG VERSION=1.0
# Variables runtime
ENV APP_VERSION=${VERSION} \
NODE_ENV=production
# Usage avec arguments
docker build --build-arg VERSION=2.0 .
```
---
# Variables d'environnement et Secrets
## Secrets en production
```bash
# Utilisation de docker secrets
docker secret create db_password password.txt
docker service create --secret db_password ...
```
---
# Healthcheck Détaillé
## Implémentation robuste
```dockerfile
HEALTHCHECK --interval=30s \
--timeout=3s \
--start-period=60s \
--retries=3 \
CMD wget -q --spider \
http://localhost:80/health || exit 1
```
## Monitoring
```bash
# Vérification status
docker inspect --format='{{.State.Health.Status}}' container
```
---
# Sécurité et Bonnes Pratiques
## Sécurisation des conteneurs
- Utilisateur non-root
- Images officielles ou vérifiées
- Scan des vulnérabilités
- Mise à jour régulière des bases
- Principe du moindre privilège
```dockerfile
# Exemple sécurisé
FROM alpine:3.14
RUN adduser -D appuser
USER appuser
```
---
# Déploiement et Tests
## Workflow complet
```bash
# Build avec tag
docker build -t app:latest .
# Test local
docker run --rm app:latest
# Publication
docker tag app:latest registry/app:latest
docker push registry/app:latest
# Déploiement
docker pull registry/app:latest
docker run -d app:latest
```
---
# Questions & Travaux Pratiques
Explication de quelques notions pour le TP
Place aux exercices pratiques !