Module 1 : Les Fondamentaux

Les Conteneurs et Docker

Formation Kubernetes - Débutant à Avancé

Sommaire du Module 1

  • Qu'est-ce qu'un conteneur ?
  • Docker a démocratisé les containers
  • Dockerfile
  • Docker Registry
  • Commandes Docker essentielles
  • TP pratique : Créer et publier votre image

Qu'est-ce qu'un conteneur ?

C'est une boite 📦

Ensemble de techniques qui vont permettre d'isoler un processus des autres processus, du système de fichiers et des ressources de l'hôte.

Il existe plein de technos pour isoler un processus : Docker est "juste" l'outil que a popularisé les containers Linux.

Quelques différences containers vs VMs

  • ➕ démarrage rapide (pas de matériel à émuler ou d'OS à démarrer)
  • ➕ consommation souvent plus faible qu'une VM (ça dépend)
  • ➖ partage du kernel (parfois problématique selon l'app)
  • ➖ isolation plus faible (sécurité ---)
  • ⚖️ immuabilité

ℹ️ Il existe des solution de type microVMs qui peuvent être un entre deux intéressant (ex : Firecracker)

Cas où la conteneurisation brille ✨

  • Microservices : mutualisation des ressources d'un hôte
  • Apps stateless (mise à l'échelle simple)
  • DevXP : plus simple de construire un container qu'une VM
  • Package unique censé fonctionner "partout"

el famoso "Build once, run anywhere" 🚀

Docker : démocratise les containers linux

dotScale 2013 - Solomon Hykes - Why we built Docker

  • Engine : Runtime de conteneurs (cgroups, namespaces)
  • CLI : Interface en ligne de commande (docker)
  • API : Interface REST pour l'automatisation
  • Images : Templates pour les conteneurs
  • Registry : Stockage d'images (Docker Hub)
  • Compose/Swarm : Orchestration simple
  • Desktop : Interface graphique

Dockerfile : recette d'un image bien faite 📝

  • On créé un Dockerfile comme on écrirait un script d'installation
  • Des opérations basiques sont listées (FROM, COPY, etc)
  • L'ensemble de ces instructions donne une image Docker
FROM node:24-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Dockerfile reference

Installation Docker (1/2)

Linux : Docker Engine (gratuit)

# Script pour Ubuntu/Debian (à utiliser avec précaution)
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh ./get-docker.sh --dry-run

center

Ou via apt : docs.docker.com/engine/install/ubuntu/#install-using-the-repository

Installation Docker (2/2)

Windows/macOS : Pas de Docker natif

# Podman comme "drop-in replacement"
alias docker=podman

Pour ce module : Docker Desktop ou Podman suffisent

Système de fichiers en couches

Docker utilise un système de fichiers en couches (layered FS) :

  • Chaque instruction du Dockerfile = une couche (layer)
  • Les couches sont empilées et immuables
  • Réutilisation : les images peuvent partager des couches communes
  • Optimisation : seules les couches modifiées sont re-téléchargées
  • Cache intelligent : Docker réutilise les couches non modifiées lors des rebuilds

Schéma d'une image docker à 5 couches

┌─────────────────┐
|     couche 5    | ← Couche application  (RW)  ▲
┌─────────────────┤                             |
|     couche 4    | ← COPY . .                  |
├─────────────────┤                             |
|     couche 3    | ← RUN npm install           |
├─────────────────┤                             |
|     couche 2    | ← COPY package.json         |
├─────────────────┤                             |
|     couche 1    | ← FROM node:24-alpine (RO)  |
└─────────────────┘

Docker Registry : Le magasin d'images

  • Docker Hub : Registry public par défaut (payant sauf pour les individus et certains projets OSS)
  • Registry privé : Pour vos images internes

ℹ️ En prod, avoir un proxy (ex. Harbor) ou un cache d'images (spegel) pour se prémnir des risques disponibilité / rate limiting

# Publier une image
docker push mon-registry/mon-app:v1.0

# Récupérer une image
docker pull nginx:latest

Télécharger une images avec multi-couches

$ docker pull nginx:latest
latest: Pulling from library/nginx
31b3f1ad4ce1: Pulling fs layer
fd42b079d0f8: Pulling fs layer  
18f4ffdd1b9d: Pulling fs layer
18f4ffdd1b9d: Waiting
fd42b079d0f8: Download complete
31b3f1ad4ce1: Download complete
18f4ffdd1b9d: Download complete
31b3f1ad4ce1: Pull complete
fd42b079d0f8: Pull complete
18f4ffdd1b9d: Pull complete
Digest: sha256:67f9a4f10d147a6e04629340e6493c9703300ca23a2f7f3aa56fe615d75d31ca
Status: Downloaded newer image for nginx:latest

Démarrer son premier container

# Lancer un conteneur qui liste le répertoire courant
$ docker run -v $(pwd):/app ubuntu:24.04 ls -la /app
total 16
-rw-r--r-- 1 root root 1234 Jul 16 10:30 README.md
drwxr-xr-x 3 root root   96 Jul 16 10:30 Support
drwxr-xr-x 3 root root   96 Jul 16 10:30 TP

-v $(pwd):/app = répertoire courant monté dans /app

Utile pour utiliser un binaire sans l'installer

Démarrer un container en mode "interactif"

# Lancer Python directement sans l'installer
$ docker run -it python:3.13 python
Python 3.13.0 (main, Oct  8 2024, 22:15:05) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello from container!")
Hello from container!
>>> exit()

-it = interactif + pseudo-tty

Démarrer un container en tâche de fond

# Lancer nginx en mode daemon (-d = detached)
$ docker run -d -p 8080:80 --name mon-nginx nginx:latest
a1b2c3d4e5f6789...

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED
a1b2c3d4e5f6   nginx:latest   "/docker-entrypoint.…"   2 seconds ago

-d = detached, -p = port mapping, --name = nom du conteneur

Lancer une commande dans un container

# Se connecter au conteneur en cours d'exécution
$ docker exec -it mon-nginx /bin/bash
root@a1b2c3d4e5f6:/# nginx -v
nginx version: nginx/1.25.3
root@a1b2c3d4e5f6:/# exit

ℹ️ *Cette foncitonnalité nécessite que le container soit "up", et que le binaire (ici /bin/bash) soit présent dans l'image

Commandes Docker essentielles (1/2)

# Construire une image
docker build -t mon-app:v1.0 .

# Lancer un conteneur
docker run -d -p 8080:3000 mon-app:v1.0

# Voir les logs
docker logs <container-id>

# Accéder au conteneur
docker exec -it <container-id> /bin/bash

Commandes Docker essentielles (2/2)

# Lister les images locales
docker images

# Lister les conteneurs en cours (ajouter -a pour voir ceux arrêtés)
docker ps

# Arrêter un conteneur
docker stop <container-id>

# Supprimer un conteneur
docker rm <container-id>

# Supprimer une image
docker rmi <image-id>

Aller plus loin

Desktop, Compose, Swarm

Quelques outils supplémentaires développé par Docker Inc.

K8s reste le standard pour l'orchestration de containers

TP 1 : Votre première image Docker

Objectif du TP : créer et publier votre propre image Docker

A partir d'un serveur web Python simple :

  1. Créer un Dockerfile
  2. Construire l'image
  3. La lancer en local
  4. La publier sur GitHub Container Registry

Allez dans le dossier TP/1/instructions/

Questions ? 🤔

Prêts pour passer à Kubernetes ?

Bibliographie (1/2)

Documentation officielle :

Bibliographie (2/2)

Talks :

Ressources d'apprentissage complémentaires :