Maîtriser Docker et Kubernetes : Déploiement et Scalabilité d'Applications Modernes

Leçon 1: Introduction à Docker et les Conteneurs

Introduction

Bienvenue dans cette première leçon de notre cours "Maîtriser Docker et Kubernetes : Déploiement et Scalabilité d'Applications Modernes". Dans le monde du développement logiciel moderne, la capacité à déployer et à faire évoluer des applications de manière fiable et efficace est devenue primordiale. Traditionnellement, les développeurs étaient confrontés à des défis tels que les "enfers de dépendances" (où une application fonctionne parfaitement sur la machine du développeur mais échoue ailleurs), les environnements non cohérents et les processus de déploiement complexes.

C'est ici qu'interviennent les conteneurs et Docker. Cette leçon vous introduira aux concepts fondamentaux de la conteneurisation, vous expliquera ce qu'est Docker et pourquoi il est devenu un outil indispensable pour les architectures logicielles modernes, notamment en vue de l'apprentissage de Kubernetes.

Préparez-vous à transformer votre approche du développement et du déploiement !

1. Qu'est-ce qu'un Conteneur ?

Imaginez que vous emballiez une application et tout ce dont elle a besoin pour fonctionner (son code, son environnement d'exécution, les outils système, les bibliothèques système, et même les paramètres de configuration) dans un seul paquet autonome et exécutable. C'est exactement ce qu'est un conteneur.

Un conteneur est une unité standardisée de développement logiciel qui regroupe toutes les dépendances d'une application, garantissant ainsi qu'elle fonctionne de manière cohérente, quel que soit l'environnement où elle est déployée.

1.1 Conteneurs vs. Machines Virtuelles (VMs) : Une Comparaison Clé

Pour bien comprendre les conteneurs, il est essentiel de les comparer aux machines virtuelles (VMs), une technologie que vous connaissez peut-être déjà.

| Caractéristique | Machine Virtuelle (VM) | Conteneur | | :------------------- | :------------------------------------------------------- | :---------------------------------------------------------------------- | | Isolation | Isolation matérielle complète via un hyperviseur. | Isolation au niveau du système d'exploitation, partageant le noyau OS. | | Système d'exploitation | Chaque VM inclut son propre OS invité complet. | Partage le noyau du système d'exploitation hôte. | | Taille | Très lourdes (plusieurs Go), incluant un OS complet. | Très légers (quelques Mo à quelques centaines de Mo). | | Démarrage | Lents (minutes) car l'OS invité doit démarrer. | Très rapides (secondes, voire millisecondes). | | Ressources | Consomment beaucoup de ressources (RAM, CPU) car chaque VM a son OS. | Consomment moins de ressources grâce au partage du noyau. | | Portabilité | Moins portable en raison de leur taille et de la dépendance à l'hyperviseur. | Très portable, peut s'exécuter sur n'importe quel système supportant le runtime de conteneurs. | | Cas d'usage typique | Consolidation de serveurs, isolation forte de différentes applications ou systèmes d'exploitation. | Microservices, déploiement rapide, environnements de développement et CI/CD. |

En résumé : Les VMs virtualisent le matériel sous-jacent, tandis que les conteneurs virtualisent le système d'exploitation. Les conteneurs offrent donc une alternative plus légère et plus efficace pour la plupart des déploiements d'applications modernes.

1.2 Avantages des Conteneurs

Portabilité : "Build once, run anywhere." Un conteneur fonctionne de la même manière sur votre machine de développement, un serveur de test ou en production.
Consistance : Élimine les problèmes de "ça marche sur ma machine" en garantissant un environnement d'exécution identique partout.
Isolation : Les applications dans les conteneurs sont isolées les unes des autres et de l'environnement hôte, ce qui évite les conflits de dépendances.
Efficacité : Démarrage rapide et faible consommation de ressources par rapport aux VMs.
Scalabilité : Facile à dupliquer et à démarrer de nouvelles instances pour gérer une charge accrue.

2. Qu'est-ce que Docker ?

Docker est la plateforme open-source la plus populaire qui facilite la création, le déploiement et la gestion des applications conteneurisées. Bien qu'il existe d'autres technologies de conteneurisation (comme Podman, containerd), Docker a popularisé le concept et est devenu le standard de facto de l'industrie.

Docker n'est pas un conteneur en soi, mais un écosystème d'outils qui permet de construire et de gérer des conteneurs.

2.1 Composants Clés de Docker

L'écosystème Docker est composé de plusieurs éléments fondamentaux :

Docker Engine : C'est le cœur de Docker. Il s'agit d'une application client-serveur avec :
- Un daemon Docker (dockerd) : Le serveur qui écoute les requêtes de l'API Docker, gère les images, les conteneurs, les volumes et les réseaux.
- Un client Docker (docker) : L'outil en ligne de commande (CLI) que vous utilisez pour interagir avec le daemon Docker.
- Une API REST : Permet au client de communiquer avec le daemon.
Docker Images : Une image est un modèle léger, autonome et exécutable, qui contient tout le nécessaire pour exécuter une application (code, runtime, bibliothèques, etc.). Les images sont construites à partir de fichiers Dockerfile et sont en lecture seule. Elles sont le "plan" pour créer des conteneurs.
Docker Containers : Un conteneur est une instance exécutable d'une image Docker. Lorsque vous exécutez une image, vous créez un conteneur. Un conteneur est isolé de l'hôte et des autres conteneurs.
Docker Hub / Registries : Docker Hub est un registre public par défaut pour le partage d'images Docker. C'est l'équivalent de GitHub pour le code source, mais pour les images conteneurisées. Vous pouvez y trouver des images officielles (Ubuntu, Nginx, Node.js, etc.) ou publier vos propres images. Il existe également des registres privés.
Dockerfile : C'est un simple fichier texte qui contient une série d'instructions (commandes) que Docker Engine utilise pour construire une image. Il s'agit du "recettes" pour créer vos images personnalisées.

3. Concepts Fondamentaux de Docker

Approfondissons certains de ces concepts essentiels.

3.1 Image vs. Conteneur : La Distinction Cruciale

Pour ne pas confondre :

Une Image Docker est comme une classe ou un modèle : c'est un ensemble d'instructions et de données qui décrivent comment une application doit être construite et configurée. Elle est statique et en lecture seule.
Un Conteneur Docker est comme une instance ou un objet de cette classe : c'est une exécution vivante et isolée de l'image. Vous pouvez avoir plusieurs conteneurs basés sur la même image.

3.2 Le Dockerfile : La Recette pour Vos Images

Un Dockerfile est un script textuel simple qui définit les étapes pour construire une image Docker. Chaque instruction dans le Dockerfile crée une nouvelle couche dans l'image, rendant les images très efficaces en termes de stockage grâce à la réutilisation des couches.

Voici quelques-unes des instructions les plus courantes :

FROM : Spécifie l'image de base (par exemple, FROM node:18-alpine).
WORKDIR : Définit le répertoire de travail pour les instructions suivantes (par exemple, WORKDIR /app).
COPY : Copie des fichiers ou des répertoires de votre machine locale vers l'image (par exemple, COPY . .).
RUN : Exécute une commande pendant la construction de l'image (par exemple, RUN npm install).
EXPOSE : Informe Docker que le conteneur écoutera sur les ports réseau spécifiés au moment de l'exécution (par exemple, EXPOSE 80).
CMD : Fournit les commandes par défaut pour l'exécution d'un conteneur. Ne doit y en avoir qu'une par Dockerfile.

Exemple de Dockerfile : Une Application Node.js Simple

Créons un Dockerfile pour une application Node.js basique. D'abord, créons un fichier server.js et un package.json :

// server.js
const http = require('http');

const hostname = '0.0.0.0'; // Écoute sur toutes les interfaces
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Bonjour Docker !\n');
});

server.listen(port, hostname, () => {
  console.log(`Le serveur tourne sur http://${hostname}:${port}/`);
});

// package.json
{
  "name": "node-docker-app",
  "version": "1.0.0",
  "description": "Une application Node.js simple pour Docker",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "author": "",
  "license": "ISC"
}

Maintenant, le Dockerfile dans le même répertoire :

# Dockerfile
# Utilise une image Node.js officielle comme base
FROM node:18-alpine

# Définit le répertoire de travail dans le conteneur
WORKDIR /app

# Copie package.json et package-lock.json (si existant)
# pour installer les dépendances avant de copier le reste du code.
# Cela permet de mettre en cache la couche des dépendances.
COPY package*.json ./

# Installe les dépendances du projet
RUN npm install

# Copie le reste du code de l'application dans le conteneur
COPY . .

# Expose le port 3000, sur lequel l'application s'exécutera
EXPOSE 3000

# Commande par défaut pour exécuter l'application lorsque le conteneur démarre
CMD [ "npm", "start" ]

Explication du Dockerfile :

FROM node:18-alpine: Nous partons d'une image Node.js légère (basée sur Alpine Linux) qui inclut déjà Node.js.
WORKDIR /app: Tous les chemins suivants seront relatifs à /app à l'intérieur du conteneur.
COPY package*.json ./: Nous copions les fichiers de définition des dépendances. C'est une bonne pratique de faire cela avant npm install pour tirer parti de la mise en cache des couches de Docker. Si package.json ne change pas, cette couche ne sera pas reconstruite.
RUN npm install: Installe les dépendances Node.js définies dans package.json.
COPY . .: Copie tout le contenu du répertoire courant (sauf ce qui est ignoré par .dockerignore) dans le répertoire /app du conteneur.
EXPOSE 3000: Indique que le conteneur est conçu pour écouter sur le port 3000. Cela ne publie pas le port sur l'hôte, mais sert de documentation et peut être utilisé par des outils d'orchestration.
CMD [ "npm", "start" ]: Définit la commande par défaut à exécuter lorsque le conteneur démarre. Ici, nous lançons notre application Node.js.

3.3 Volumes et Réseaux (Brève Introduction)

Volumes : Par défaut, les données à l'intérieur d'un conteneur sont éphémères et disparaissent lorsque le conteneur est supprimé. Les volumes Docker sont des mécanismes de stockage persistant qui permettent de stocker des données en dehors du système de fichiers du conteneur, les rendant persistantes et partageables entre conteneurs.
Réseaux : Docker fournit des capacités de mise en réseau qui permettent aux conteneurs de communiquer entre eux, ainsi qu'avec le monde extérieur ou d'autres hôtes.

Ces concepts seront approfondis dans des leçons ultérieures, mais il est bon de savoir qu'ils existent pour la gestion avancée des conteneurs.

4. Premiers Pas avec Docker (Pratique)

Pour suivre ces étapes, assurez-vous d'avoir Docker Desktop (ou Docker Engine) installé sur votre machine.

4.1 Vérifier l'installation de Docker

docker --version
docker compose version

Ces commandes devraient afficher les versions installées de Docker et Docker Compose.

4.2 Commandes Essentielles

docker pull [image_name] : Télécharge une image depuis un registre (comme Docker Hub).
```
docker pull hello-world
docker pull ubuntu:latest
```
docker images : Liste toutes les images Docker téléchargées ou construites localement.
```
docker images
```
docker build -t [image_name]:[tag] [path_to_dockerfile] : Construit une image Docker à partir d'un Dockerfile. Le -t sert à taguer (nommer) votre image. Le . indique que le Dockerfile se trouve dans le répertoire courant.

Reprenons notre exemple d'application Node.js. Assurez-vous que les fichiers server.js, package.json et Dockerfile sont dans le même répertoire.
```
docker build -t my-nodejs-app:1.0 .
```
Cette commande va construire une image nommée my-nodejs-app avec le tag 1.0. Le . indique le contexte de construction (le répertoire actuel), où Docker cherchera le Dockerfile.
docker run [options] [image_name] : Crée et démarre un nouveau conteneur à partir d'une image.
- Exécutons un simple conteneur "hello-world":
```
docker run hello-world
```
  Vous verrez un message confirmant que votre installation Docker fonctionne.
- Maintenant, exécutons notre application Node.js construite précédemment :
```
docker run -p 3000:3000 my-nodejs-app:1.0
```
  Explication de la commande docker run :
  - -p 3000:3000 : C'est le mappage de ports. Le premier 3000 est le port sur votre machine hôte, et le second 3000 est le port exposé à l'intérieur du conteneur (celui que nous avons défini avec EXPOSE 3000 dans le Dockerfile). Cela permet d'accéder à l'application tournant dans le conteneur via http://localhost:3000 sur votre machine.
  - my-nodejs-app:1.0 : L'image à partir de laquelle le conteneur doit être créé et exécuté.
  Si tout s'est bien passé, vous devriez voir le message Le serveur tourne sur http://0.0.0.0:3000/ dans votre terminal. Ouvrez votre navigateur et allez à http://localhost:3000. Vous devriez voir "Bonjour Docker !". Pour arrêter le conteneur, appuyez sur Ctrl+C dans le terminal.
docker run -d [options] [image_name] : Exécute le conteneur en mode détaché (en arrière-plan).
```
docker run -d -p 3000:3000 my-nodejs-app:1.0
```
Cette commande retournera un ID de conteneur, et le terminal sera libéré. L'application continuera de tourner en arrière-plan.
docker ps : Liste les conteneurs en cours d'exécution. Utilisez docker ps -a pour voir tous les conteneurs (y compris ceux arrêtés).
```
docker ps
```
docker stop [container_id_or_name] : Arrête un conteneur en cours d'exécution.
docker start [container_id_or_name] : Démarre un conteneur arrêté.
docker restart [container_id_or_name] : Redémarre un conteneur.
docker rm [container_id_or_name] : Supprime un ou plusieurs conteneurs (doit être arrêté pour être supprimé).

Pour arrêter et supprimer le conteneur Node.js que vous avez lancé :
1. Trouvez son ID avec docker ps.
2. docker stop [ID]
3. docker rm [ID]
docker rmi [image_id_or_name] : Supprime une image.
```
docker rmi my-nodejs-app:1.0
```
docker exec -it [container_id_or_name] [command] : Exécute une commande à l'intérieur d'un conteneur en cours d'exécution. Utile pour le débogage. Le -it permet une interaction interactive.
```
# Si votre conteneur my-nodejs-app est en cours d'exécution
docker exec -it [ID_DU_CONTENEUR] sh # Pour ouvrir un shell dans le conteneur Alpine
```
docker logs [container_id_or_name] : Affiche les logs d'un conteneur.
```
docker logs [ID_DU_CONTENEUR]
```

5. Pourquoi Docker est-il Indispensable pour les Applications Modernes ?

Docker n'est pas seulement un outil de déploiement ; il a révolutionné le cycle de vie du développement logiciel.

Environnements de Développement Cohérents : Les développeurs peuvent exécuter des applications dans des conteneurs qui répliquent l'environnement de production, éliminant ainsi les incohérences.
Intégration et Déploiement Continus (CI/CD) : Docker s'intègre parfaitement aux pipelines CI/CD. Les applications conteneurisées peuvent être testées et déployées automatiquement de manière fiable.
Architectures de Microservices : Chaque microservice peut être empaqueté dans son propre conteneur, ce qui permet des développements, déploiements et mises à l'échelle indépendants.
Optimisation des Ressources : La légèreté des conteneurs permet de maximiser l'utilisation des ressources du serveur, réduisant ainsi les coûts d'infrastructure.
Facilite la Scalabilité : Il est très simple de faire évoluer une application en lançant de nouvelles instances de son conteneur. C'est là que des orchestrateurs comme Kubernetes entrent en jeu, que nous aborderons bientôt.
Indépendance Vis-à-Vis de l'Infrastructure : Une fois conteneurisée, votre application n'est plus liée à une infrastructure spécifique. Elle peut fonctionner sur n'importe quel cloud, n'importe quel serveur, tant que Docker y est présent.

Conclusion

Félicitations ! Vous avez fait vos premiers pas dans le monde des conteneurs et de Docker. Vous comprenez maintenant ce qu'est un conteneur, comment Docker s'articule autour de ce concept, et les avantages significatifs qu'il apporte au développement et au déploiement d'applications. Vous avez également exploré les commandes Docker fondamentales et construit votre première image.

Docker est la pierre angulaire des architectures applicatives modernes et le tremplin nécessaire pour maîtriser l'orchestration de conteneurs avec Kubernetes. Dans les prochaines leçons, nous approfondirons l'utilisation de Docker, découvrirons Docker Compose pour gérer des applications multi-conteneurs, et enfin, nous nous lancerons dans l'aventure Kubernetes.

Préparez-vous à déployer vos applications avec une efficacité et une fiabilité inégalées !