TawaKnow LogoTawaKnow
AWSDevOpsFavorisContribuer

© 2026 TawaKnow. Tous droits réservés.

Mentions LégalesPolitique de confidentialitéContribuer
Pratiques DevOps
0/29 chapitres0%
1.

Introduction au DevOps

2.

Introduction à Linux

3.

Système de Fichiers Linux

4.

Interface en Ligne de Commande (CLI)

5.

Gestionnaire de Paquets Linux

6.

Vim — Éditeur de Texte CLI

7.

Utilisateurs & Groupes Linux

8.

Permissions & Propriété des Fichiers

9.

Shell Scripting Bash

10.

Variables d'Environnement Linux

11.

Réseau Linux

12.

SSH — Secure Shell

13.

Introduction à Git & Contrôle de Version

14.

Configurer un Dépôt Git

15.

Flux de Travail Git — add, commit, push, pull

16.

Branches Git & Merge Requests

17.

Git Avancé — Commandes, .gitignore & Bonnes Pratiques

18.

Outils de Build & Gestionnaires de Paquets

19.

Build Tools, Docker & CI/CD

20.

Introduction à Nexus — Gestionnaire de Dépôts d'Artifacts

21.

Installer et Configurer Nexus sur un Serveur

22.

Nexus — Repositories, Publication et API REST

23.

Introduction aux Containers & Docker

24.

Commandes Docker & Registries

25.

Dockerfile — Créer des Images Docker

26.

Docker Compose, Volumes & Bonnes Pratiques

27.

Introduction à Jenkins & CI/CD

28.

Installer et Configurer Jenkins

29.

Jenkins Pipeline & Jenkinsfile

...Introduction aux Containers & Docker
CoursPratiques DevOpsIntroduction aux Containers & Docker
Chapitre 23/29

Introduction aux Containers & DockerIntroduction aux Containers & Docker

5 min de lecture
Total: ~5 min
Progression du cours0/29 chapitres

Introduction aux Containers et Docker

Docker est la technologie de conteneurisation la plus populaire au monde. Elle a révolutionné la façon de développer et déployer les applications.


Qu'est-ce que Docker ?

  • Plateforme de conteneurisation open source
  • Permet aux développeurs de packager des applications dans des containers
  • Les containers existaient avant Docker — Docker les a rendus populaires et accessibles

Qu'est-ce qu'un container ?

Un container = une façon de packager une application avec toutes ses dépendances et sa configuration dans un seul artifact portable.

Application
+ dépendances (Node.js, Java, libs...)
+ configuration (variables d'env, fichiers config)
= Container (artifact portable standardisé)

Avantages :

  • Portable : fonctionne identiquement sur n'importe quelle machine
  • Standardisé : même format pour toutes les applications
  • Efficace : développement et déploiement simplifiés

Les containers sont stockés dans des container repositories (dépôts) :

  • Public : Docker Hub (images officielles Postgres, Redis, Nginx, Node.js...)
  • Privé : AWS ECR, Azure Container Registry, Nexus...

Avant et après Docker — Développement

Avant les containers

Développeur Mac         Développeur Linux
────────────────        ──────────────────
Installe PostgreSQL     Installe PostgreSQL
v15.3 + Redis v7.0      v15.3 + Redis v7.0
→ Commandes différentes selon l'OS
→ Risque d'erreur à chaque étape
→ "Ça marche sur ma machine !"

Après les containers

docker run postgres:15.3     ← 1 seule commande
docker run redis:7.0         ← identique sur Mac et Linux
  • Environnement isolé : chaque container a sa propre config
  • 1 commande pour installer et lancer l'application
  • Possible de faire tourner 2 versions différentes côte à côte

Avant et après Docker — Déploiement

Avant les containers

Développeur                 Ops
──────────────              ──────────────────────────
Livre: JAR + doc textuelle  Configure le serveur manuellement
                            Installe les dépendances
                            → Conflits de versions
                            → Malentendus possibles
                            → Configurations diff entre envs

Après les containers

Dev + Ops ensemble  →  Container (app + config + deps)
                   →  Ops fait juste : docker run mon-app
  • Aucune configuration de l'environnement côté serveur (sauf Docker lui-même)
  • Dev et Ops collaborent pour packager l'application en container
  • Déploiement reproductible et fiable

Docker Image vs Docker Container

Docker ImageDocker Container
NatureFichier (artifact)Environnement en cours d'exécution
ÉtatPas en cours d'exécutionApplication démarrée
StructurePlusieurs couches (layers)Système de fichiers virtuel
DéplacementPeut être copié/partagéLié à la machine hôte
AnalogiePlan d'architectureBâtiment construit
Docker Image  ──────────────►  Docker Container
(artifact statique)   docker run   (processus vivant)

Structure d'une image (layers) :

┌────────────────────────────────┐
│  postgres:15.3  (app layer)    │  ← Layer applicatif
├────────────────────────────────┤
│  Layer 3 (config)              │
├────────────────────────────────┤
│  Layer 2 (deps)                │
├────────────────────────────────┤
│  alpine:3.17   (base layer)    │  ← Linux base image
└────────────────────────────────┘

Containers vs Machines Virtuelles (VM)

Les deux sont des outils de virtualisation, mais à des niveaux différents.

CONTAINERS                      MACHINES VIRTUELLES
──────────────────              ──────────────────────────
App A  App B  App C  App D      │VM A│  │VM B│  │VM C│
────────────────────────        │AppA│  │AppB│  │AppC│
        Docker                  │OS  │  │OS  │  │OS  │
────────────────────────        ├────────────────────┤
    Host Operating System              Hyperviseur
────────────────────────        ────────────────────────
      Infrastructure                  Infrastructure
ContainersMachines Virtuelles
AbstractionAu niveau de l'applicationAu niveau du hardware
OS partagéOui — partagent le kernel de l'hôteNon — chaque VM a son propre OS
TaillePetite (MB)Grande (GB)
DémarrageRapide (secondes)Lent (minutes)
IsolationForte (namespace Linux)Complète

Compatibilité : un container Linux ne peut pas tourner directement sur un kernel Windows. → Pour cela, utiliser Docker Desktop (installe une VM Linux légère sous le capot).


Architecture Docker

Docker Engine est composé de 3 composants :

┌─────────────────────────────────────┐
│            Docker Engine             │
│                                     │
│  ┌─────────┐  ┌─────┐  ┌────────┐  │
│  │ Server  │  │ API │  │  CLI   │  │
│  └─────────┘  └─────┘  └────────┘  │
└─────────────────────────────────────┘
ComposantRôle
ServerTire les images, gère le cycle de vie des containers
APIInterface pour interagir avec le Server
CLIInterface en ligne de commande pour exécuter les commandes Docker

Le Server contient :

Server
  ├── Container Runtime  → pull images, gère le cycle de vie des containers
  ├── Volumes            → persiste les données
  ├── Network            → configure la communication entre containers
  └── Build Images       → construit des images depuis un Dockerfile

Alternatives à Docker

BesoinAlternative
Container runtime seulementcontainerd, cri-o
Builder des images seulementbuildah
Tout-en-unDocker (recommandé)

Installation de Docker

OSMéthode
LinuxSupport natif — installer le package docker-ce
MacDocker Desktop (installe une VM Linux légère)
WindowsDocker Desktop (idem)
# Linux (Ubuntu/Debian)
apt update
apt install docker.io -y
systemctl start docker
systemctl enable docker

# Vérifier
docker --version
docker run hello-world

À retenir

  • Docker = plateforme de conteneurisation open source, la plus populaire
  • Container = application + dépendances + config dans 1 seul artifact portable
  • Docker Image = artifact statique (fichier) ; Docker Container = image en cours d'exécution
  • Containers vs VMs : containers partagent le kernel → plus légers, plus rapides
  • Docker Engine = Server (runtime + volumes + network + build) + API + CLI
  • Avant Docker : install manuelle différente sur chaque OS, conflits de versions
  • Après Docker : 1 commande, même environnement partout, déploiement simplifié
Précédent
Nexus — Repositories, Publication et API REST
Suivant
Commandes Docker & Registries
Sur cette page
PrécédentSuivant