Programme de Formation Docker
1. Prérequis
Avant de se plonger dans Docker, il est crucial de se familiariser avec certains concepts
fondamentaux en informatique et développement. Ces compétences permettront de mieux
comprendre comment Docker fonctionne et d’optimiser son utilisation.
Package Managers
Les gestionnaires de paquets comme apt (pour les distributions Debian/Ubuntu), yum
(pour Red Hat/CentOS), et brew (pour macOS) facilitent l'installation, la mise à jour et la
gestion des logiciels. Docker peut être installé à l'aide de ces gestionnaires, ce qui simplifie
la configuration et garantit que toutes les dépendances sont installées.
Permissions Utilisateurs et Groupes
Docker nécessite souvent des privilèges administratifs (root) pour certaines actions. Savoir
gérer les permissions des utilisateurs et groupes est important pour sécuriser les
environnements Docker, en limitant l'accès à certaines fonctionnalités aux seuls utilisateurs
autorisés.
Commandes Shell & Scripts
Les commandes de base du shell (comme ls, cd, mv, cp, rm) permettent de naviguer et
manipuler le système de fichiers. Les scripts shell sont des séquences de commandes
automatisées qui simplifient l'exécution de tâches répétitives, comme l'initialisation de
conteneurs Docker ou la configuration d'environnements.
Fondamentaux Linux
Une bonne compréhension des bases de Linux est essentielle car Docker s'appuie largement
sur des fonctionnalités natives de Linux (comme les cgroups et namespaces). Les concepts
de répertoires, de permissions, et de gestion de fichiers sont indispensables pour gérer les
conteneurs efficacement.
Langages de Programmation
Les langages comme Python et JavaScript sont couramment utilisés pour créer des scripts et
applications conteneurisées. La capacité de comprendre le code dans ces langages permet
de mieux personnaliser et gérer les conteneurs Docker.
Architecture des Applications
Docker est très utile dans des architectures modernes comme les microservices, où chaque
service est isolé et déployé dans un conteneur. Connaître les différences entre architectures
monolithiques et microservices aide à structurer des applications adaptées à Docker.
Développement Web
Une compréhension basique du développement web est utile pour déployer des
applications web dans des conteneurs. Docker permet d'emballer des serveurs web (comme
Nginx ou Apache) avec des applications, simplifiant le déploiement dans des
environnements divers.
Exercices et Solutions
Exercice 1 : Installation et Gestion des Packages
Objectif : Installer un gestionnaire de paquets et configurer un environnement de base avec
un script d'automatisation.
Instructions :
- Installez un logiciel (ex: curl) en utilisant apt (sur Debian/Ubuntu) ou yum (sur Red
Hat/CentOS).
- Créez un script shell pour automatiser l'installation et la configuration d'un ensemble de
logiciels basiques.
Solution :
1. Installez curl :
- Debian/Ubuntu : `sudo apt update && sudo apt install -y curl`
- Red Hat/CentOS : `sudo yum install -y curl`
2. Script shell (script_install.sh) :
```
#!/bin/bash
sudo apt update
sudo apt install -y curl wget git
echo 'Installation terminée.'
```
3. Exécutez le script : `bash script_install.sh`
Exercice 2 : Création d'un Dockerfile pour une Application Web
Objectif : Créer et exécuter une image Docker pour une application web simple.
Instructions :
- Utilisez une image de base pour [Link].
- Ajoutez le code de l’application dans le conteneur.
- Exposez un port pour l’accès à l'application.
Solution :
Dockerfile :
```
FROM node:14
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["npm", "start"]
```
Commandes :
1. Construire l'image : `docker build -t mynodeapp .`
2. Exécuter le conteneur : `docker run -d -p 3000:3000 mynodeapp`
Exercice 3 : Déploiement d'une Application Multi-Conteneurs avec Docker Compose
Objectif : Déployer une stack multi-conteneurs avec une application web et une base de
données.
Instructions :
- Créez un fichier [Link] pour une stack avec Nginx et MySQL.
Solution :
[Link] :
```
version: '3'
services:
web:
image: nginx
ports:
- '8080:80'
db:
image: mysql
environment:
MYSQL_ROOT_PASSWORD: example
```
Commandes :
1. Démarrer la stack : `docker-compose up -d`
2. Vérifier les conteneurs : `docker-compose ps`
### 1. **Prérequis**
- **Package Managers** : Introduction à l'utilisation de gestionnaires de paquets (apt,
yum, brew) pour installer et gérer les dépendances nécessaires à Docker.
- **Users / Group Permissions** : Explication des permissions et rôles des utilisateurs,
avec un focus sur les permissions root et l'ajout d'utilisateurs au groupe Docker.
- **Shell Commands & Shell Scripting** : Aperçu des commandes shell essentielles (ls, cd,
mv, cp, rm) et de l’écriture de scripts pour automatiser les tâches.
- **Linux Fondamentals** : Introduction aux bases de Linux, telles que la navigation dans
les répertoires, la gestion des fichiers et les permissions.
- **Programming languages** : Familiarisation avec les langages (Python, JavaScript, etc.)
pour écrire des scripts et des applications conteneurisées.
- **Application Architecture** : Présentation des modèles d'architecture applicative
modernes (microservices, monolithes), qui aident à comprendre l'utilité des conteneurs.
- **Web Development** : Présentation des notions de base du développement web pour
comprendre le déploiement des applications web dans des conteneurs.
**Exercice** : Configurer un environnement de base en ligne de commande en utilisant un
gestionnaire de paquets pour installer des logiciels, puis créer et exécuter un script shell
pour automatiser des tâches de base.
---
### 2. **Introduction à Docker**
- **Qu'est-ce que Docker ?** : Explication approfondie de Docker et des avantages des
conteneurs dans le déploiement, la mise à l'échelle et la gestion d'applications. Souligner
que Docker permet un cycle de développement rapide et un déploiement consistant sur
différentes infrastructures.
- **Conteneurs** : Comprendre l'isolation, la portabilité et la cohérence que les conteneurs
apportent aux applications, en mettant l'accent sur l'efficacité des ressources par rapport
aux machines virtuelles.
**Exercice** : Présenter un cas concret d'incohérences dues aux différences
d'environnement (ex. bibliothèque manquante), puis montrer comment un conteneur
résout ce problème.
---
### 3. **Bare Metal vs VM vs Containers**
- **Bare Metal** : Expliquer comment ce type de serveur offre un accès direct au matériel,
mais sans isolation entre applications.
- **VM (Virtual Machine)** : Présenter les avantages et limitations des VM, notamment en
termes de consommation de ressources.
- **Containers** : Montrer comment les conteneurs utilisent moins de ressources en
partageant le système d'exploitation de l’hôte tout en offrant une isolation similaire aux VM.
**Exercice** : Comparer le temps de démarrage et la consommation de ressources entre
une VM et un conteneur en démarrant chacun et en surveillant l’utilisation des ressources.
---
### 4. **Docker and OCI**
- **Open Container Initiative (OCI)** : Discuter de l'importance de standards ouverts pour
la compatibilité et la portabilité des conteneurs dans des environnements multi-
fournisseurs.
**Exercice** : Faire des recherches sur les standards OCI et énumérer quelques bénéfices
d’une approche standardisée dans un environnement de production.
---
### 5. **Technologies sous-jacentes de Docker**
- **Conteneurs Linux (LXC)** : Explication du fonctionnement de LXC et de la façon dont
les conteneurs partagent le système d'exploitation de l'hôte.
- **Groupes de contrôle (cgroups)** : Expliquer comment cgroups limite la consommation
de ressources des conteneurs.
- **Systèmes de fichiers Union (UnionFS)** : Détailler l'importance d'UnionFS pour la
gestion des couches d'image, en réduisant la duplication des données.
- **Espaces de noms** : Explorer en profondeur les types d'espaces de noms (PID, NET,
MNT, etc.) et comment ils isolent les ressources.
**Exercice** : Créer des conteneurs avec différentes limitations de ressources (CPU et
mémoire) en utilisant cgroups et observer l’effet des limites définies.
---
### 6. **Configuration de l'installation**
- **Docker Desktop vs Docker Engine** : Différencier les deux pour clarifier les options
d'installation pour les systèmes Linux, macOS et Windows, avec ou sans interface
graphique.
**Exercice pratique** : Installer Docker Desktop sur une machine locale et configurer
Docker Engine sur un serveur Linux distant, puis comparer les interfaces.
---
### 7. **Notions de base sur Docker**
- **Dockerfile** : Étude approfondie des instructions Dockerfile, notamment `FROM`,
`RUN`, `COPY`, `EXPOSE`, et `CMD`.
- **Image Docker** : Explication de la création d’images, des couches d’images et de la
façon dont Docker stocke et partage les images.
- **Conteneur Docker** : Comprendre qu’un conteneur est une instance d'image Docker
avec son propre espace d'exécution.
**Exercice pratique** : Créer un Dockerfile basique pour une application web (par exemple,
un serveur Nginx ou une simple application [Link]) et construire une image Docker.
---
### 8. *Commandes Docker Essentielles
- **docker pull** : Télécharger une image depuis un registre comme Docker Hub.
- **docker build -t <image_name> <path>** : Construire une image Docker à partir d'un
Dockerfile.
- **docker image ls** : Lister toutes les images présentes sur la machine locale.
- **docker run -d -p <host_port>:<container_port> --name <container_name> <image>** :
Exécuter un conteneur en arrière-plan et mapper les ports.
- **docker container ls** : Lister les conteneurs en cours d'exécution.
- **docker container stop** et **docker container rm** : Arrêter et supprimer des
conteneurs.
- **docker image rm** : Supprimer une image Docker.
**Exercice pratique** :
1. Télécharger une image publique depuis Docker Hub, par exemple `nginx`.
2. Construire et exécuter une image personnalisée à partir d’un Dockerfile pour un serveur
simple.
3. Manipuler les conteneurs : démarrer, arrêter, supprimer des conteneurs et
expérimenter avec les commandes de liste et de gestion.
---
### Travaux pratiques et applications
1. **Exercice 1** : Créez un Dockerfile pour une application [Link] de base :
- Utilisez une image de base Node.
- Ajoutez votre code dans le conteneur avec la commande `COPY`.
- Utilisez `EXPOSE` pour exposer un port et `CMD` pour lancer l'application.
- Construisez et exécutez cette image pour tester l’application.
2. **Exercice 2** : Déployer une application multi-conteneurs avec Docker Compose :
- Créez un fichier `[Link]` pour une stack basique contenant un conteneur
web (ex. Nginx) et une base de données (ex. MySQL).
- Démarrez et testez l’interaction entre les conteneurs avec `docker-compose up`.
3. **Exercice 3** : Gestion des ressources de conteneurs avec cgroups :
- Lancez un conteneur avec des limites spécifiques de CPU et de mémoire.
- Utilisez `docker stats` pour surveiller l’utilisation des ressources.
4. **Exercice 4** : Exploration des espaces de noms et des réseaux Docker :
- Créez deux conteneurs sur des réseaux isolés.
- Testez la communication entre eux en modifiant la configuration réseau.
---
Ces exercices permettront à vos apprenants de maîtriser à la fois les concepts théoriques et
les pratiques concrètes de Docker, tout en renforçant leur compréhension de
l'environnement de conteneurs dans des situations variées.