Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

TP2e année7 livrables

Conteneurs & Docker Compose

« Ça marche chez moi » — la phrase qui hante les déploiements. Docker y répond : il empaquette ton application avec tout son environnement, pour qu'elle tourne à l'identique partout. Aujourd'hui tu conteneurises AppliFrais (API + base + front) et tu l'orchestres d'une seule commande avec Docker Compose. La reproductibilité, enfin.

Par Josselyn C., prof de BTS SIO. Publié le .

Objectif
conteneuriser AppliFrais et orchestrer ses services avec Docker Compose
On manipule
Docker, un Dockerfile, un docker-compose.yml, des volumes/réseaux
Pré-requis
AppliFrais (API Node, Mongo), notions de terminal
Pour qui
SLAM, 2e année
Durée
1 séance

Compétences : C1.5 Mettre à disposition des utilisateurs un service informatique, C1.1 Gérer le patrimoine informatique

Conteneuriser = rendre un service portable et reproductible : une compétence clé de la mise à disposition.

Avant de commencer

Pourquoi cette séance

Tu as déployé AppliFrais « à la main » sur un serveur. Problème : reproduire ce déploiement ailleurs (un autre serveur, un collègue, la prod) implique de réinstaller Node, Mongo, les bonnes versions, la config… et le moindre écart casse tout. Docker résout ça : il empaquette chaque service (l'API, la base, le front) dans un conteneur autonome, qui embarque tout son environnement. Le conteneur tourne à l'identique sur n'importe quelle machine qui a Docker. Docker Compose orchestre ensuite plusieurs conteneurs ensemble avec une seule commande. C'est la reproductibilité, et un grand classique de la mise à disposition de services (Bloc 1).

Comment avancer en autonomie

Vérifier que Docker est installé

powershell
docker --version
docker compose version
Ce que tu dois voir
Docker version 24.0.7, build afdd53b
Docker Compose version v2.23.3

Ce que tu vas apprendre

ConceptCe que tu sauras faire
Conteneur vs VMcomprendre ce qu'est (et n'est pas) un conteneur
Image & Dockerfilefabriquer l'image de ton API et la lancer
.dockerignore & images légèresune image petite, sans secret, à faible surface d'attaque
Docker Composeorchestrer plusieurs services d'un coup
Volumes & réseauxpersister les données, faire communiquer les conteneurs
Variables d'envconfigurer proprement (pas de secret en dur)

0. C'est quoi un conteneur ?

Un conteneur est un paquet léger et isolé qui contient ton application et tout ce dont elle a besoin pour tourner (le runtime, les librairies, la config). Métaphore : un conteneur de transport — peu importe le navire (la machine), son contenu voyage à l'identique.

Machine virtuelle (VM)Conteneur
Embarqueun OS entier + l'app (boot complet)l'app + ses libs seulement (partage le noyau Linux de l'hôte)
Poids typique2–20 Go (OS + app)50–500 Mo — node:20-alpine = 142 Mo ; mongo:7 = 220 Mo
Démarrage1–3 min (boot BIOS → OS → app)0,1–5 s (juste un process à lancer)
Isolationforte : hyperviseur, OS séparébonne : namespaces Linux (PID, réseau, FS, users) + cgroups (CPU/RAM limités)
Combien sur 8 Go RAM2–4 VM (chaque OS consomme 1–2 Go)20–100 conteneurs (partagent l'OS)
Quand choisirOS différents requis, isolation maximale, legacy Windowsmicroservices, CI/CD, déploiement d'app — le cas AppliFrais

Le vocabulaire de base

TermeDéfinition
Imagele « moule » : un modèle figé de l'app + son environnement
Conteneurune instance qui tourne, créée à partir d'une image
Dockerfilela recette qui décrit comment construire une image
Registryun dépôt d'images en ligne (Docker Hub par défaut)

Ces quatre mots décrivent un cycle : on écrit un Dockerfile, on le construit (build) en une image, et on lance (run) cette image en un conteneur qui tourne.

Schéma : Dockerfile · la recette · docker build · Image · le moule figé · docker run · Conteneur · qui tourne · Une image = 1 moule ; on peut en lancer plusieurs conteneurs identiques.

Flag A1

Checkpoint

Avec tes mots :
• différence entre une image et un conteneur ?
• différence entre une VM et un conteneur ?
• pour AppliFrais, liste les services à conteneuriser (API, base, front, stockage S3).
Rends : tes réponses + la liste des conteneurs.

0 sur 7 dans cette étape

1. Le Dockerfile de l'API

On fabrique l'image de l'API AppliFrais. Le Dockerfile décrit, étape par étape, comment construire cette image. On le crée à la racine de l'API (le dossier qui contient package.json et server.js).

Le Dockerfile, instruction par instruction

# Dockerfile (a la racine de l'API)
FROM node:20-alpine          # (1) image de base : Node 20, version legere "alpine"
WORKDIR /app                 # (2) dossier de travail dans le conteneur
COPY package*.json ./        # (3) on copie d'abord les manifestes
RUN npm ci --omit=dev        # (4) on installe les deps de prod (reproductible)
COPY . .                     # (5) on copie le reste du code
EXPOSE 3000                  # (6) le port que l'app ecoute
CMD ["node", "server.js"]    # (7) la commande de demarrage

Construire l'image

powershell
docker build -t appli-frais-api .
Ce que tu dois voir
[+] Building 18.4s (10/10) FINISHED
 => [internal] load build definition from Dockerfile     0.0s
 => [internal] load .dockerignore                        0.0s
 => [internal] load metadata for node:20-alpine          1.2s
 => [1/5] FROM docker.io/library/node:20-alpine          3.1s
 => [2/5] WORKDIR /app                                    0.2s
 => [3/5] COPY package*.json ./                           0.0s
 => [4/5] RUN npm ci --omit=dev                          12.0s
 => [5/5] COPY . .                                        0.1s
 => exporting to image                                    0.4s
 => => naming to docker.io/library/appli-frais-api       0.0s

Les 5 étapes [1/5] à [5/5] correspondent aux 5 instructions qui produisent une couche. Au 2e build (sans changer package.json), tu verras CACHED sur les couches 1 à 4 : c'est le cache qui fait son travail.

Vérifier l'image et son poids

powershell
docker images appli-frais-api
Ce que tu dois voir
REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
appli-frais-api   latest    a1b2c3d4e5f6   12 seconds ago   142MB

Lancer le conteneur

powershell
docker run -p 3000:3000 appli-frais-api
Ce que tu dois voir
> appli-frais-api@1.0.0 start
> node server.js

API AppliFrais a l'ecoute sur le port 3000
[attention] MongoDB injoignable : mongodb://localhost:27017 ECONNREFUSED

Sécuriser l'image : ne pas lancer l'app en root

Par défaut, les processus d'un conteneur tournent en tant que root (UID 0). Si l'app est compromise (faille injection, dépendance vulnérable), l'attaquant se retrouve root dans le conteneur — et potentiellement sur l'hôte si une mauvaise config laisse passer. La bonne pratique : créer un utilisateur dédié non-privilégié.

# Dockerfile (version sécurisée — ajout de USER après npm ci)
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY --chown=node:node . .   # copie les fichiers avec le bon propriétaire d'emblée
USER node                    # node:20-alpine crée déjà l'utilisateur "node" (UID 1000)
EXPOSE 3000
CMD ["node", "server.js"]

Flag B1

Production (Dockerfile)

Écris le Dockerfile de l'API AppliFrais, construis l'image et lance le conteneur.
Rends : ton Dockerfile + la sortie de docker build + la sortie de docker images (poids de l'image) + la preuve que le conteneur démarre.

0 sur 7 dans cette étape

2. .dockerignore & images légères

Deux réflexes de pro, souvent oubliés, qui font la différence entre une image amateur et une image propre.

1. Le .dockerignore : ne pas tout copier

Le COPY . . du Dockerfile copie tout le dossier dans l'image… y compris des choses qu'il ne faut surtout pas embarquer. Le fichier .dockerignore (à côté du Dockerfile) liste ce qu'on exclut, exactement comme un .gitignore.

# .dockerignore (a la racine de l'API)
node_modules        # reinstalle proprement dans l'image (RUN npm ci)
.env                # SECRETS : jamais dans une image !
.git                # historique git inutile et lourd
npm-debug.log       # logs locaux
Dockerfile          # pas besoin de se copier lui-meme
.dockerignore

Le piège invisible : un secret reste dans les couches

Même si tu fais RUN rm .env dans une instruction suivante, le fichier est toujours là dans la couche précédente. Docker superpose les couches mais ne les efface pas rétroactivement. Un attaquant qui a accès à l'image peut inspecter chaque couche avec cette commande.

powershell
docker history --no-trunc appli-frais-api
Ce que tu dois voir
IMAGE          CREATED        CREATED BY                                       SIZE
a1b2c3d4e5f6   2 min ago      CMD ["node" "server.js"]                         0B
<missing>      2 min ago      EXPOSE 3000/tcp                                  0B
<missing>      2 min ago      COPY . . # buildkit                              4.2MB
<missing>      2 min ago      RUN npm ci --omit=dev                            38MB
<missing>      2 min ago      COPY package*.json ./                            42kB
<missing>      2 min ago      WORKDIR /app                                     0B
<missing>      3 weeks ago    /bin/sh -c #(nop) CMD ["node"]                   0B
...

2. Une image légère = moins de surface d'attaque

ChoixEffet
image de base alpine≈ 5 Mo de base au lieu de ~400 Mo : moins de paquets installés
npm ci --omit=devpas les outils de test/build dans l'image de prod
.dockerignorepas de fichiers parasites ni de secrets

Flag D1

Investigation

Va sur Docker Hub (hub.docker.com) et réponds :
• quelle est la différence de taille entre node:20 et node:20-alpine ?
• qu'est-ce qu'un tag d'image (ex. 20, 20-alpine, latest) et pourquoi figer une version plutôt que latest ?
• cherche « multi-stage build » : en une phrase, à quoi ça sert ?
Rends : tes 3 réponses, avec la source consultée.

0 sur 7 dans cette étape

3. Orchestrer avec Docker Compose

AppliFrais n'est pas un service : c'est l'API + la base Mongo (+ le front, + le stockage S3). Les lancer et les relier un par un, à la main, est pénible et source d'erreurs. Docker Compose décrit tous les services dans un seul fichier docker-compose.yml et les lance ensemble.

Le fichier docker-compose.yml

# docker-compose.yml (a la racine du projet)
services:
  api:
    build: ./api                 # construit depuis le Dockerfile de l'API
    ports:
      - "3000:3000"              # publie le port de l'API vers l'hote
    environment:
      MONGO_URI: mongodb://mongo:27017/appliFrais   # "mongo" = nom du service
      JWT_SECRET: ${JWT_SECRET}                     # injecte depuis le .env
    depends_on:
      mongo:
        condition: service_healthy  # attend que mongo soit VRAIMENT pret
    restart: unless-stopped      # redemarrage automatique sauf si tu le stoppes
  mongo:
    image: mongo:7               # image officielle, rien a construire
    # PAS de "ports:" ici : mongo n'est joignable que par l'API (securite)
    volumes:
      - mongo-data:/data/db      # persistance des donnees
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 10s              # on verifie toutes les 10 secondes
      timeout: 5s                # echec si pas de reponse en 5 s
      retries: 3                 # 3 echecs = service "unhealthy"
      start_period: 20s          # grace period au demarrage (Mongo met ~15 s)

volumes:
  mongo-data:                    # volume nomme (survit aux redemarrages)

Valider la configuration avant de lancer

powershell
docker compose config
Ce que tu dois voir
name: applifrais
services:
  api:
    build:
      context: /home/user/applifrais/api
    environment:
      JWT_SECRET: mon-super-secret
      MONGO_URI: mongodb://mongo:27017/appliFrais
    ...
  mongo:
    healthcheck:
      interval: 10s
      ...
    image: mongo:7

Le fichier .env (les secrets, hors du code)

# .env (a la racine, exclu par .gitignore ET .dockerignore)
JWT_SECRET=un-secret-long-et-aleatoire-genere-au-hasard

L'architecture orchestrée

Schéma : Navigateur / hote · 3000:3000 · reseau interne Compose : applifrais_default · api · Express · port 3000 · mongo:27017 · mongo · MongoDB · port 27017 · volume mongo-data · les donnees survivent au conteneur

Tout lancer d'une seule commande

powershell
docker compose up -d
Ce que tu dois voir
[+] Running 4/4
 Network applifrais_default      Created   0.1s
 Volume "applifrais_mongo-data"  Created   0.0s
 Container applifrais-mongo-1    Started   0.9s
 Container applifrais-api-1      Started   1.1s

Voir l'état des services

powershell
docker compose ps
Ce que tu dois voir
NAME                  IMAGE             SERVICE   STATUS         PORTS
applifrais-api-1      applifrais-api    api       Up 20 seconds  0.0.0.0:3000->3000/tcp
applifrais-mongo-1    mongo:7           mongo     Up 21 seconds  27017/tcp

Lire les logs, puis arrêter

powershell
docker compose logs api      # voir ce que l'API affiche
docker compose down          # tout arreter (le volume reste)
Ce que tu dois voir
# logs api :
API AppliFrais a l'ecoute sur le port 3000
MongoDB connecte : mongodb://mongo:27017/appliFrais

# down :
[+] Running 3/3
 Container applifrais-api-1     Removed   0.4s
 Container applifrais-mongo-1   Removed   0.6s
 Network applifrais_default     Removed   0.1s

Flag B2

Production (Compose)

Écris le docker-compose.yml d'AppliFrais (au moins API + Mongo, avec volume et variable d'env) et le .env. Lance la stack.
Rends : ton fichier + la sortie de docker compose up -d et de docker compose ps + la preuve que l'API et la base communiquent (le log MongoDB connecte, ou un login qui marche).

0 sur 7 dans cette étape

4. Volumes, réseaux & persistance

Trois notions font la différence entre un service jouet et un service fiable.

NotionRôleSans elle…
Volumestocke les données hors du conteneurles données disparaissent à chaque recréation
Réseaufait communiquer les conteneurs par leur nomles services ne se trouvent pas
Variables d'envconfigure sans toucher au code/imagesecrets en dur, image non réutilisable

Volumes : nommés vs bind mounts (quand choisir quoi)

Il existe deux façons d'attacher du stockage à un conteneur. Le choix a un impact concret sur la portabilité et la sécurité.

Volume nomméBind mount
Syntaxe Composemongo-data:/data/db./data:/data/db ou /chemin/absolu:/data/db
Géré parDocker (stocké dans /var/lib/docker/volumes/)le système de fichiers de l'hôte, dossier que TU contrôles
Portabilitéforte : fonctionne identique sur tout hôte Dockerfaible : dépend du chemin sur l'hôte
Performanceoptimisé par Docker, meilleur en prodlégèrement moins performant sur Mac (FS overlay)
Usage typiquedonnées de prod (base, uploads) — à préférercode source en dev (live-reload, hot module replacement)
Inspecterdocker volume inspect mongo-datadirectement sur le disque (ls ./data)

Sauvegarder et restaurer un volume

Un volume nommé est géré par Docker, mais tu peux en faire une sauvegarde (dump) sans entrer dans le conteneur :

# Sauvegarder le volume mongo-data dans un fichier tar
docker run --rm \
  -v applifrais_mongo-data:/source:ro \
  -v $(pwd):/backup \
  alpine tar -czf /backup/mongo-data-$(date +%F).tar.gz -C /source .
powershell
# Inspecter le volume (voir où Docker le stocke sur l'hôte)
docker volume inspect applifrais_mongo-data
Ce que tu dois voir
[
  {
    "Name": "applifrais_mongo-data",
    "Driver": "local",
    "Mountpoint": "/var/lib/docker/volumes/applifrais_mongo-data/_data",
    "CreatedAt": "2026-07-01T09:12:00Z",
    "Labels": {"com.docker.compose.project": "applifrais"},
    "Scope": "local"
  }
]

Démontrer la persistance (en 4 commandes)

docker compose up -d                              # 1. la stack tourne
docker compose exec mongo mongosh appliFrais \
  --eval 'db.test.insertOne({ note: "je survis" })'   # 2. on ecrit une donnee
docker compose down                               # 3. on detruit les conteneurs
docker compose up -d                              # 4. on relance

Après l'étape 4, on relit la donnée :

docker compose exec mongo mongosh appliFrais \
  --eval 'db.test.find().pretty()'
Ce que tu dois voir
[
  { _id: ObjectId('66...'), note: 'je survis' }
]

Flag C1

Démonstration (persistance)

Reproduis la démonstration : insère une donnée, fais down puis up, prouve qu'elle est toujours là. Puis explique, en 2 phrases, ce qui se passerait sans le volume, et ce que ferait down -v.
Rends : tes commandes + la sortie du find() + ton explication.

0 sur 7 dans cette étape

Chapitre 4 bis — Déboguer un conteneur en vie

Un conteneur qui tourne est une boîte noire — jusqu'à ce que tu saches comment l'ouvrir. Ces quatre commandes couvrent 95 % des situations de débogage réel.

1. Entrer dans un conteneur (shell interactif)

powershell
docker exec -it applifrais-api-1 sh
Ce que tu dois voir
/app # ls
node_modules  package.json  package-lock.json  server.js
/app # cat package.json | grep version
  "version": "1.0.0",
/app # exit

2. Suivre les logs en temps réel

powershell
docker compose logs -f --tail=50 api
Ce que tu dois voir
applifrais-api-1  | API AppliFrais a l'ecoute sur le port 3000
applifrais-api-1  | MongoDB connecte : mongodb://mongo:27017/appliFrais
applifrais-api-1  | POST /api/auth/login 200 - 43ms
applifrais-api-1  | GET /api/frais 200 - 12ms
applifrais-api-1  | POST /api/frais 201 - 67ms

3. Surveiller la consommation (CPU, RAM)

powershell
docker stats
Ce que tu dois voir
CONTAINER ID   NAME                   CPU %   MEM USAGE / LIMIT    MEM %   NET I/O
a1b2c3d4e5f6   applifrais-api-1       0.12%   48.3MiB / 7.77GiB    0.61%   5.2MB / 1.8MB
f7e8d9c0b1a2   applifrais-mongo-1     0.08%   112.4MiB / 7.77GiB   1.41%   1.8MB / 5.2MB

4. Inspecter la configuration d'un conteneur

powershell
docker inspect applifrais-mongo-1
Ce que tu dois voir
[{
  "Id": "f7e8d9c0b1a2...",
  "State": {"Status": "running", "Health": {"Status": "healthy"}},
  "Mounts": [{"Type": "volume", "Name": "applifrais_mongo-data", "Destination": "/data/db"}],
  "NetworkSettings": {"Networks": {"applifrais_default": {"IPAddress": "172.20.0.2"}}}
}]

5. Mini-projet : AppliFrais conteneurisé

La mission

Livre AppliFrais entièrement conteneurisé et orchestré, prêt à démarrer n'importe où en une commande :

  1. un Dockerfile pour l'API (+ .dockerignore) ;
  2. un docker-compose.yml : API + Mongo ;
  3. un volume pour la persistance de la base, des variables d'env (.env) pour la config/secrets ;
  4. un README : « cloner → docker compose up → l'app tourne ».

Le README « clone & run »

# AppliFrais - demarrage

## Pre-requis
- Docker + Docker Compose installes

## Lancer
1. git clone <url-du-depot> && cd applifrais
2. cp .env.example .env      # puis renseigner JWT_SECRET
3. docker compose up -d      # construit et lance API + Mongo
4. ouvrir http://localhost:3000

## Arreter
- docker compose down        # garde les donnees
- docker compose down -v     # efface aussi les donnees

Flag B3

Mini-projet (livrable)

Livre la stack Docker complète d'AppliFrais : un git clone + docker compose up doit suffire à tout démarrer.
Rends : tes fichiers (Dockerfile, docker-compose.yml, .dockerignore, .env.example, README) + la preuve que l'app démarre d'une commande.
Une stack reproductible « clone & run » est une réalisation de portfolio E5 qui impressionne.

0 sur 7 dans cette étape

Aller plus loin — le front en multi-stage

Le front React+Vite ne se sert pas comme l'API : on le compile (build) en fichiers statiques, puis un petit serveur (Nginx) les sert. Le multi-stage build fait les deux dans un seul Dockerfile, et ne garde que le résultat final (image minuscule).

# front/Dockerfile (multi-stage)
# --- etape 1 : build ---
FROM node:20-alpine AS build      # etape nommee "build"
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build                 # produit le dossier dist/

# --- etape 2 : servir ---
FROM nginx:alpine                 # image finale, tres legere
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80

Flag E1

Extension (qualité)

Ajoute le front à ta stack en multi-stage (build React → service Nginx), et déclare-le comme 3e service dans le docker-compose.yml.
Rends : le Dockerfile multi-stage du front + le service Compose + la sortie de docker compose ps montrant les 3 conteneurs.
Bonus : ajoute un conteneur MinIO (S3 local) pour les justificatifs et relie-le à l'API.

0 sur 7 dans cette étape

Pour finir

L'essentiel

NotionÀ retenir
conteneurapp + son environnement, léger, reproductible (vs VM lourde)
image / Dockerfilele moule et sa recette ; image légère, sans secret
.dockerignoreexclut node_modules, .env, .git : pas de secret dans l'image
Docker Composeorchestrer plusieurs services d'une commande
volumepersister les données hors du conteneur éphémère
nom de serviceles conteneurs se joignent par leur nom via le réseau interne

Vérifie tes acquis

  1. Différence entre une VM et un conteneur ?
  2. Différence entre une image et un conteneur ?
  3. Pourquoi copier package.json et faire npm ci avant COPY . . ?
  4. À quoi sert un .dockerignore, et pourquoi exclure .env ?
  5. Comment deux services Compose communiquent-ils sans IP ?
  6. Pourquoi un volume est-il indispensable pour la base ? Que fait down -v ?
  7. Pourquoi préférer une image de base légère (alpine) ? (lien sécurité)

Commandes essentielles — antisèche

CommandeCe qu'elle faitQuand l'utiliser
docker compose up -dconstruit (si besoin) et démarre tous les services en arrière-planlancer la stack
docker compose downarrête et supprime conteneurs + réseau (garde les volumes)éteindre proprement
docker compose down -videm + supprime les volumesreset complet (dev only)
docker compose psétat des conteneurs (Up / Exit / Restarting)vérifier que tout tourne
docker compose logs -f --tail=50 apilogs en temps réel d'un servicedéboguer une erreur
docker compose configaffiche la config résolue (variables d'env substituées)valider avant de lancer
docker compose build --no-cache apireconstruction complète sans cacheforcer la mise à jour des deps
docker compose restart apiredémarre un seul servicerecharger la config sans tout redémarrer
docker exec -it <nom> shshell interactif dans un conteneur qui tourneinspecter l'intérieur
docker statsmonitoring CPU/RAM/réseau en temps réeldétecter une fuite mémoire
docker imagesliste les images locales avec leur taillevérifier le poids d'une image
docker volume lsliste tous les volumes Dockersavoir quels volumes existent
docker system prunenettoie conteneurs stoppés, images non utilisées, réseaux orphelinsrécupérer de l'espace disque

Glossaire

MotDéfinition
Conteneurpaquet isolé contenant l'app et son environnement (partage le noyau Linux)
Imagemodèle figé à partir duquel on crée des conteneurs ; une image = N conteneurs possibles
Dockerfilerecette de construction d'une image, instruction par instruction
Couche (layer)résultat mis en cache d'une instruction du Dockerfile ; un secret dans une couche y reste pour toujours
Registrydépôt d'images en ligne (Docker Hub = public ; GitHub Container Registry / ECR = privé)
Docker Composeoutil pour décrire et lancer plusieurs services dans un seul fichier YAML
Volume nomméstockage persistant géré par Docker, survit aux cycles down/up
Bind mountdossier de l'hôte monté dans le conteneur ; pratique en dev pour le live-reload
Réseau Dockerréseau interne où les services se joignent par leur nom de service (pas par IP)
Healthcheckcommande que Compose exécute périodiquement pour savoir si un service est vraiment prêt
Multi-stage buildDockerfile à plusieurs étapes ; ne garde que le résultat final dans l'image livrée
Surface d'attaqueensemble des points qu'un attaquant peut viser ; réduite par les images légères (alpine, --omit=dev)
Namespace Linuxmécanisme noyau qui isole ce que voit un conteneur (PID, réseau, FS…)
cgroupmécanisme noyau qui limite ce que consomme un conteneur (CPU, RAM)
Trivyoutil open source de scan de vulnérabilités d'images Docker (trivy image mon-image)

Connecte-toi pour lire tout le TP

C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.

Le site garde ton nom et ton email, rien d'autre. Tes données

TP terminé ?

Coche chaque livrable quand tu l'as : c'est la preuve que l'étape est acquise.

livrables
–
de série
–
Voir tous les TP