- Introduction à Docker et à la conteneurisation
- Installation et configuration de Docker
- Concepts fondamentaux de Docker
- Création de Dockerfiles personnalisés
- Introduction à Docker Compose
- Structure du projet Inception
- Configuration des services
- Configuration des réseaux Docker
- Gestion des volumes et persistance des données
- Variables d'environnement et secrets
- Déploiement et gestion du projet
- Bonnes pratiques et optimisations
- Dépannage et problèmes courants
- Exercices pratiques
- Ressources supplémentaires
Docker est une plateforme open-source qui permet de développer, déployer et exécuter des applications dans des conteneurs. Un conteneur est une unité logicielle standardisée qui empaquette le code et toutes ses dépendances pour que l'application s'exécute de manière rapide et fiable d'un environnement informatique à un autre.
"Docker permet de séparer les applications de l'infrastructure afin de livrer des logiciels rapidement." - Documentation officielle Docker
| Conteneurisation | Virtualisation traditionnelle |
|---|---|
| Partage le noyau (kernel) du système hôte | Exécute un système d'exploitation complet |
| Léger et démarre en quelques secondes | Plus lourd et peut prendre plusieurs minutes à démarrer |
| Utilise moins de ressources | Nécessite plus de ressources |
| Isolation au niveau du processus | Isolation complète au niveau matériel |
- Portabilité : Les conteneurs fonctionnent partout où Docker est installé
- Légèreté : Utilisent moins de ressources que les machines virtuelles
- Cohérence : Éliminent les problèmes de "ça marche sur ma machine"
- Isolation : Chaque application fonctionne dans son propre environnement
- Scalabilité : Facilitent le déploiement à grande échelle
- Déploiement rapide : Les conteneurs démarrent en quelques secondes
Docker utilise une architecture client-serveur. Le client Docker communique avec le démon Docker (serveur) qui effectue les tâches lourdes comme la création, l'exécution et la distribution des conteneurs.
- Docker Engine : Le moteur qui exécute les conteneurs
- Docker CLI : L'interface en ligne de commande pour interagir avec Docker
- Docker Desktop : Application pour macOS et Windows qui inclut Docker Engine, CLI, et d'autres outils
- Docker Hub : Un registre pour partager et stocker des images Docker
# Mettre à jour les paquets
sudo apt-get update
# Installer les dépendances
sudo apt-get install -y apt-transport-https ca-certificates curl software-properties-common
# Ajouter la clé GPG officielle de Docker
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
# Ajouter le dépôt Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
# Mettre à jour les paquets
sudo apt-get update
# Installer Docker CE
sudo apt-get install -y docker-ce docker-ce-cli containerd.io
# Installer Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.23.3/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose📚 Consultez la documentation officielle d'installation pour plus de détails.
# Vérifier la version de Docker
docker --version
# Vérifier la version de Docker Compose
docker-compose --version
# Exécuter un conteneur de test
docker run hello-worldPour utiliser Docker sans sudo (optionnel mais recommandé) :
# Créer le groupe docker s'il n'existe pas
sudo groupadd docker
# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER
# Appliquer les changements de groupe
newgrp docker📚 Pour plus de détails, consultez la configuration post-installation.
Une image Docker est un modèle en lecture seule qui contient un ensemble d'instructions pour créer un conteneur Docker. Les images sont stockées dans un registre comme Docker Hub.
# Lister les images locales
docker images
# Télécharger une image
docker pull nginx:latest
# Chercher une image sur Docker Hub
docker search mariadb📚 En savoir plus sur les images Docker.
Un conteneur est une instance en cours d'exécution d'une image Docker. Il s'agit d'un environnement isolé qui exécute une application.
# Lister les conteneurs en cours d'exécution
docker ps
# Lister tous les conteneurs (y compris ceux arrêtés)
docker ps -a
# Créer et démarrer un conteneur
docker run --name mon-nginx -p 8080:80 -d nginx
# Arrêter un conteneur
docker stop mon-nginx
# Démarrer un conteneur arrêté
docker start mon-nginx
# Supprimer un conteneur
docker rm mon-nginx📚 En savoir plus sur les conteneurs Docker.
- Création :
docker createoudocker run - Démarrage :
docker startou inclus dansdocker run - Exécution : Le conteneur est en cours d'exécution
- Pause/Reprise :
docker pause/docker unpause - Arrêt :
docker stop(SIGTERM puis SIGKILL après un délai) oudocker kill(SIGKILL immédiat) - Suppression :
docker rm
Les volumes permettent de persister les données générées et utilisées par les conteneurs.
# Créer un volume
docker volume create mon-volume
# Lister les volumes
docker volume ls
# Utiliser un volume avec un conteneur
docker run -d --name mon-conteneur -v mon-volume:/data nginx
# Monter un répertoire de l'hôte dans un conteneur
docker run -d --name mon-conteneur -v /chemin/sur/hote:/data nginx📚 En savoir plus sur les volumes Docker.
Les réseaux Docker permettent la communication entre conteneurs et avec le monde extérieur.
# Lister les réseaux
docker network ls
# Créer un réseau
docker network create mon-reseau
# Connecter un conteneur à un réseau
docker network connect mon-reseau mon-conteneur
# Créer un conteneur dans un réseau spécifique
docker run --name mon-conteneur --network mon-reseau -d nginx📚 En savoir plus sur les réseaux Docker.
Un Dockerfile est un script contenant une série d'instructions pour créer une image Docker personnalisée.
# Image de base
FROM debian:bullseye-slim
# Métadonnées
LABEL maintainer="votre-email@example.com"
LABEL version="1.0"
# Variables d'environnement
ENV APP_HOME /app
# Répertoire de travail
WORKDIR $APP_HOME
# Copie des fichiers
COPY . .
# Installation des dépendances
RUN apt-get update && \
apt-get install -y nginx && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
# Exposition des ports
EXPOSE 80
# Volume pour les données persistantes
VOLUME ["/data"]
# Commande par défaut au démarrage du conteneur
CMD ["nginx", "-g", "daemon off;"]
# Point d'entrée
ENTRYPOINT ["/entrypoint.sh"]📚 En savoir plus sur la syntaxe des Dockerfiles.
| Instruction | Description |
|---|---|
FROM |
Spécifie l'image de base |
LABEL |
Ajoute des métadonnées à l'image |
ENV |
Définit des variables d'environnement |
WORKDIR |
Définit le répertoire de travail |
COPY |
Copie des fichiers du système hôte vers l'image |
ADD |
Similaire à COPY mais avec des fonctionnalités supplémentaires (extraction d'archives, URLs) |
RUN |
Exécute des commandes pendant la construction de l'image |
EXPOSE |
Informe Docker que le conteneur écoute sur des ports spécifiés |
VOLUME |
Crée un point de montage pour les données persistantes |
CMD |
Commande par défaut à exécuter au démarrage du conteneur |
ENTRYPOINT |
Configure le conteneur pour qu'il s'exécute comme un exécutable |
# Construire une image (depuis le répertoire contenant le Dockerfile)
docker build -t mon-image:v1 .
# Construire une image avec un Dockerfile spécifique
docker build -t mon-image:v1 -f MonDockerfile .
# Construire sans utiliser le cache
docker build --no-cache -t mon-image:v1 .FROM nginx:alpine
COPY ./conf/nginx.conf /etc/nginx/nginx.conf
COPY ./html /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]📚 Pour plus d'informations, consultez les meilleures pratiques pour écrire des Dockerfiles.
Docker Compose est un outil qui permet de définir et gérer des applications multi-conteneurs. Il utilise un fichier YAML pour configurer les services, réseaux et volumes.
version: '3.8'
services:
nginx:
build: ./nginx
ports:
- "80:80"
volumes:
- ./nginx/html:/usr/share/nginx/html
depends_on:
- wordpress
restart: unless-stopped
networks:
- inception-network
wordpress:
build: ./wordpress
volumes:
- wordpress_data:/var/www/html
depends_on:
- mariadb
environment:
- WORDPRESS_DB_HOST=mariadb
- WORDPRESS_DB_NAME=wordpress
- WORDPRESS_DB_USER=wp_user
- WORDPRESS_DB_PASSWORD=wp_password
restart: unless-stopped
networks:
- inception-network
mariadb:
build: ./mariadb
volumes:
- mariadb_data:/var/lib/mysql
environment:
- MYSQL_ROOT_PASSWORD=root_password
- MYSQL_DATABASE=wordpress
- MYSQL_USER=wp_user
- MYSQL_PASSWORD=wp_password
restart: unless-stopped
networks:
- inception-network
networks:
inception-network:
driver: bridge
volumes:
wordpress_data:
mariadb_data:📚 Consultez la référence du fichier Compose pour plus de détails.
# Démarrer les services (en arrière-plan)
docker-compose up -d
# Arrêter les services
docker-compose down
# Arrêter les services et supprimer les volumes
docker-compose down -v
# Voir les logs
docker-compose logs
# Logs en continu
docker-compose logs -f
# Logs d'un service spécifique
docker-compose logs -f nginx
# Reconstruire les images
docker-compose build
# Redémarrer un service
docker-compose restart nginx
# Exécuter une commande dans un service
docker-compose exec mariadb mysql -u root -p📚 Pour la liste complète des commandes, consultez la référence CLI de Docker Compose.
Le projet Inception consiste généralement à mettre en place une infrastructure avec plusieurs services conteneurisés, communiquant entre eux à travers un réseau Docker.
inception/
├── .env # Variables d'environnement globales
├── docker-compose.yml # Configuration des services
├── Makefile # Commandes pour faciliter la gestion
├── srcs/ # Répertoire source
│ ├── requirements/ # Services et leurs configurations
│ │ ├── nginx/ # Service NGINX
│ │ │ ├── Dockerfile # Instructions de build pour NGINX
│ │ │ ├── conf/ # Fichiers de configuration
│ │ │ └── tools/ # Scripts et outils
│ │ ├── mariadb/ # Service MariaDB
│ │ │ ├── Dockerfile # Instructions de build pour MariaDB
│ │ │ ├── conf/ # Fichiers de configuration
│ │ │ └── tools/ # Scripts et outils
│ │ └── wordpress/ # Service WordPress
│ │ ├── Dockerfile # Instructions de build pour WordPress
│ │ ├── conf/ # Fichiers de configuration
│ │ └── tools/ # Scripts et outils
│ └── .env # Variables d'environnement pour les services
└── README.md # Documentation du projet
# Variables
DOCKER_COMPOSE = docker-compose -f srcs/docker-compose.yml
# Commandes
all: up
up:
$(DOCKER_COMPOSE) up -d
down:
$(DOCKER_COMPOSE) down
clean: down
$(DOCKER_COMPOSE) down -v
fclean: clean
docker system prune -a --volumes
re: fclean all
logs:
$(DOCKER_COMPOSE) logs -f
ps:
$(DOCKER_COMPOSE) ps
.PHONY: all up down clean fclean re logs psNGINX agit comme un serveur web et un proxy inverse pour rediriger les requêtes vers les services appropriés.
FROM alpine:3.16
RUN apk update && \
apk add --no-cache nginx openssl && \
mkdir -p /run/nginx
# Configuration SSL
RUN mkdir -p /etc/nginx/ssl && \
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/nginx/ssl/nginx.key \
-out /etc/nginx/ssl/nginx.crt \
-subj "/C=FR/ST=IDF/L=Paris/O=42/OU=42/CN=c-andriam.42.fr"
# Copier les fichiers de configuration
COPY conf/nginx.conf /etc/nginx/nginx.conf
# Exposer le port 443 (HTTPS)
EXPOSE 443
# Démarrer NGINX en mode foreground
CMD ["nginx", "-g", "daemon off;"]user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /var/run/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
keepalive_timeout 65;
server {
listen 443 ssl;
server_name c-andriam.42.fr;
ssl_certificate /etc/nginx/ssl/nginx.crt;
ssl_certificate_key /etc/nginx/ssl/nginx.key;
ssl_protocols TLSv1.2 TLSv1.3;
root /var/www/html;
index index.php index.html;
location / {
try_files $uri $uri/ /index.php?$args;
}
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass wordpress:9000;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
}
}
}📚 En savoir plus sur la configuration de NGINX avec Docker.
MariaDB est un système de gestion de base de données relationnelle dérivé de MySQL.
FROM alpine:3.16
RUN apk update && \
apk add --no-cache mariadb mariadb-client && \
mkdir -p /run/mysqld && \
chown -R mysql:mysql /run/mysqld && \
mkdir -p /var/lib/mysql
# Copier les fichiers de configuration
COPY conf/my.cnf /etc/mysql/my.cnf
COPY tools/init-db.sh /docker-entrypoint-initdb.d/
# Exposer le port de MariaDB
EXPOSE 3306
# Définir les permissions
RUN chmod +x /docker-entrypoint-initdb.d/init-db.sh
# Démarrer MariaDB
CMD ["sh", "-c", "/docker-entrypoint-initdb.d/init-db.sh && mysqld --user=mysql --console"]#!/bin/sh
# Vérifier si la base de données est déjà initialisée
if [ -d "/var/lib/mysql/mysql" ]; then
echo "Database already initialized"
else
# Initialiser la base de données
mysql_install_db --user=mysql --datadir=/var/lib/mysql
# Démarrer MariaDB temporairement
mysqld --user=mysql --bootstrap << EOF
USE mysql;
FLUSH PRIVILEGES;
# Créer l'utilisateur root
ALTER USER 'root'@'localhost' IDENTIFIED BY '${MYSQL_ROOT_PASSWORD}';
GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION;
FLUSH PRIVILEGES;
# Créer la base de données et l'utilisateur WordPress
CREATE DATABASE IF NOT EXISTS ${MYSQL_DATABASE};
CREATE USER IF NOT EXISTS '${MYSQL_USER}'@'%' IDENTIFIED BY '${MYSQL_PASSWORD}';
GRANT ALL PRIVILEGES ON ${MYSQL_DATABASE}.* TO '${MYSQL_USER}'@'%';
FLUSH PRIVILEGES;
EOF
echo "Database initialized"
fi
# Configurer MariaDB pour accepter les connexions externes
sed -i "s/skip-networking/#skip-networking/g" /etc/mysql/my.cnf
echo "MariaDB setup completed"[mysqld]
user = mysql
datadir = /var/lib/mysql
port = 3306
bind-address = 0.0.0.0
skip-networking = false
[mysql]
user = root
password = ${MYSQL_ROOT_PASSWORD}📚 Consultez la documentation officielle de MariaDB pour plus d'informations sur la configuration.
WordPress est un système de gestion de contenu (CMS) populaire.
FROM alpine:3.16
RUN apk update && \
apk add --no-cache php8 php8-fpm php8-mysqli php8-json php8-curl \
php8-dom php8-exif php8-fileinfo php8-mbstring php8-openssl php8-xml \
php8-zip php8-gd curl
# Installer WordPress CLI
RUN curl -O https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar && \
chmod +x wp-cli.phar && \
mv wp-cli.phar /usr/local/bin/wp
# Créer le répertoire pour WordPress
RUN mkdir -p /var/www/html
# Copier les fichiers de configuration
COPY conf/www.conf /etc/php8/php-fpm.d/www.conf
COPY tools/setup-wordpress.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/setup-wordpress.sh
# Exposer le port de PHP-FPM
EXPOSE 9000
# Démarrer WordPress
CMD ["sh", "-c", "/usr/local/bin/setup-wordpress.sh && php-fpm8 -F"]#!/bin/sh
# Vérifier si WordPress est déjà installé
if [ -f "/var/www/html/wp-config.php" ]; then
echo "WordPress already installed"
else
# Télécharger WordPress
wp core download --path=/var/www/html --allow-root
# Attendre que MariaDB soit prêt
until mysqladmin ping -h${WORDPRESS_DB_HOST} -u${WORDPRESS_DB_USER} -p${WORDPRESS_DB_PASSWORD} --silent; do
echo "Waiting for MariaDB..."
sleep 2
done
# Créer le fichier de configuration WordPress
wp config create \
--path=/var/www/html \
--dbname=${WORDPRESS_DB_NAME} \
--dbuser=${WORDPRESS_DB_USER} \
--dbpass=${WORDPRESS_DB_PASSWORD} \
--dbhost=${WORDPRESS_DB_HOST} \
--allow-root
# Installer WordPress
wp core install \
--path=/var/www/html \
--url=https://c-andriam.42.fr \
--title="Inception" \
--admin_user=${WORDPRESS_ADMIN_USER} \
--admin_password=${WORDPRESS_ADMIN_PASSWORD} \
--admin_email=${WORDPRESS_ADMIN_EMAIL} \
--allow-root
# Créer un utilisateur supplémentaire
wp user create \
${WORDPRESS_USER} \
${WORDPRESS_EMAIL} \
--role=author \
--user_pass=${WORDPRESS_PASSWORD} \
--path=/var/www/html \
--allow-root
echo "WordPress installed successfully"
fi
# Définir les permissions
chown -R nobody:nobody /var/www/html
echo "WordPress setup completed"Configuration PHP-FPM (www.conf)
[www]
user = nobody
group = nobody
listen = 9000
pm = dynamic
pm.max_children = 5
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3📚 Pour plus d'informations, consultez la documentation WordPress avec Docker.
| Type | Description |
|---|---|
bridge |
Réseau par défaut pour les conteneurs sur un même hôte |
host |
Supprime l'isolation réseau entre le conteneur et l'hôte |
none |
Aucune connectivité externe pour les conteneurs |
overlay |
Réseau distribué entre plusieurs hôtes Docker |
macvlan |
Assigne une adresse MAC à un conteneur |
ipvlan |
Similaire à macvlan mais sans adresse MAC unique |
networks:
inception-network:
driver: bridge
ipam:
config:
- subnet: 172.20.0.0/16- Isoler les services : Utiliser des réseaux dédiés pour isoler les groupes de services
- Nommer les réseaux : Utiliser des noms significatifs pour les réseaux
- Limiter l'exposition des ports : N'exposer que les ports nécessaires
- Communication entre conteneurs : Utiliser les noms de service pour la communication interne
services:
wordpress:
# ...
networks:
- frontend
- backend
nginx:
# ...
networks:
- frontend
mariadb:
# ...
networks:
- backend
networks:
frontend:
driver: bridge
backend:
driver: bridge📚 En savoir plus sur les réseaux Docker.
| Type | Description | Syntaxe |
|---|---|---|
| Volumes nommés | Gérés par Docker, stockés dans /var/lib/docker/volumes |
volume_name:/container/path |
| Bind mounts | Montages du système de fichiers hôte | /host/path:/container/path |
| tmpfs mounts | Stockés en mémoire (non persistants) | tmpfs:/container/path |
services:
wordpress:
# ...
volumes:
- wordpress_data:/var/www/html
mariadb:
# ...
volumes:
- mariadb_data:/var/lib/mysql
volumes:
wordpress_data:
driver: local
driver_opts:
type: none
device: /home/c-andriam/data/wordpress
o: bind
mariadb_data:
driver: local
driver_opts:
type: none
device: /home/c-andriam/data/mariadb
o: bind- Utiliser des volumes nommés : Ils sont plus faciles à gérer et à sauvegarder
- Monter en lecture seule quand possible :
ropour réduire les risques - Séparer les données d'application et de configuration : Volumes distincts
- Définir clairement les points de montage : Structure cohérente
volumes:
wordpress_data:
name: inception_wordpress_data
mariadb_data:
name: inception_mariadb_data📚 En savoir plus sur les volumes Docker.
# MariaDB
MYSQL_ROOT_PASSWORD=rootpassword123
MYSQL_DATABASE=wordpress
MYSQL_USER=wp_user
MYSQL_PASSWORD=wp_password123
# WordPress
WORDPRESS_DB_HOST=mariadb
WORDPRESS_DB_NAME=wordpress
WORDPRESS_DB_USER=wp_user
WORDPRESS_DB_PASSWORD=wp_password123
WORDPRESS_ADMIN_USER=admin
WORDPRESS_ADMIN_PASSWORD=admin_password123
WORDPRESS_ADMIN_EMAIL=admin@example.com
WORDPRESS_USER=c-andriam
WORDPRESS_PASSWORD=user_password123
WORDPRESS_EMAIL=c-andriam@student.42.fr
# Domain
DOMAIN_NAME=c-andriam.42.frservices:
wordpress:
# ...
environment:
- WORDPRESS_DB_HOST=${WORDPRESS_DB_HOST}
- WORDPRESS_DB_NAME=${WORDPRESS_DB_NAME}
- WORDPRESS_DB_USER=${WORDPRESS_DB_USER}
- WORDPRESS_DB_PASSWORD=${WORDPRESS_DB_PASSWORD}
- WORDPRESS_ADMIN_USER=${WORDPRESS_ADMIN_USER}
- WORDPRESS_ADMIN_PASSWORD=${WORDPRESS_ADMIN_PASSWORD}
- WORDPRESS_ADMIN_EMAIL=${WORDPRESS_ADMIN_EMAIL}
- WORDPRESS_USER=${WORDPRESS_USER}
- WORDPRESS_PASSWORD=${WORDPRESS_PASSWORD}
- WORDPRESS_EMAIL=${WORDPRESS_EMAIL}Pour les projets qui nécessitent une sécurité accrue, Docker Swarm propose une gestion des secrets :
# Créer un secret
echo "secret_password" | docker secret create db_password -
# Utiliser le secret dans docker-compose.yml (mode Swarm)
services:
mariadb:
# ...
secrets:
- db_password
environment:
- MYSQL_ROOT_PASSWORD_FILE=/run/secrets/db_password
secrets:
db_password:
external: true📚 En savoir plus sur la gestion des secrets.
# Cloner le projet
git clone https://github.com/votre-nom/inception.git
cd inception
# Créer les répertoires pour les volumes
mkdir -p /home/c-andriam/data/wordpress /home/c-andriam/data/mariadb
# Démarrer les services
make# Voir l'état des services
docker-compose ps
# Voir les logs
docker-compose logs -f
# Redémarrer un service spécifique
docker-compose restart nginx
# Arrêter tous les services
docker-compose down
# Redémarrer tous les services
docker-compose up -d# Sauvegarde de la base de données
docker-compose exec mariadb sh -c 'mysqldump -u root -p"$MYSQL_ROOT_PASSWORD" wordpress' > backup.sql
# Restauration de la base de données
cat backup.sql | docker-compose exec -T mariadb sh -c 'mysql -u root -p"$MYSQL_ROOT_PASSWORD" wordpress'📚 Pour plus d'informations sur la sauvegarde, consultez la documentation de MariaDB.
- Utiliser des images de base légères : Alpine plutôt qu'Ubuntu
- Réduire le nombre de couches : Combiner les commandes RUN
- Nettoyer après l'installation : Supprimer les caches et fichiers temporaires
- Multi-stage builds : Séparer la compilation et l'exécution
# Exemple d'optimisation
RUN apk update && \
apk add --no-cache package1 package2 && \
rm -rf /var/cache/apk/*- Ne jamais exécuter en tant que root : Utiliser des utilisateurs non privilégiés
- Scanner les images : Utiliser des outils comme Docker Scan ou Trivy
- Limiter les capacités : Restreindre les capacités du conteneur
- Mettre à jour régulièrement : Garder les images à jour
services:
app:
# ...
user: nobody
cap_drop:
- ALL
cap_add:
- NET_BIND_SERVICE- Limiter les ressources : Définir des limites de CPU et mémoire
- Optimiser les volumes : Utiliser des bind mounts pour les données fréquemment accédées
- Healthchecks : Implémenter des vérifications de santé pour les services
services:
wordpress:
# ...
deploy:
resources:
limits:
cpus: '0.5'
memory: 512M
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 30s
timeout: 10s
retries: 3📚 En savoir plus sur les meilleures pratiques Docker.
| Problème | Solution |
|---|---|
| Les conteneurs ne peuvent pas communiquer | Vérifier qu'ils sont dans le même réseau Docker |
| Ports déjà utilisés | Changer le mapping des ports ou arrêter les services en conflit |
| Impossible d'accéder au service | Vérifier les règles de pare-feu et la configuration NGINX |
| Problème | Solution |
|---|---|
| Permissions insuffisantes | Vérifier les propriétaires et les permissions des répertoires |
| Volumes manquants | Vérifier si les volumes sont correctement créés et montés |
| Données corrompues | Restaurer à partir d'une sauvegarde |
| Problème | Solution |
|---|---|
| Service qui redémarre en boucle | Vérifier les logs avec docker-compose logs service_name |
| Erreurs de configuration | Vérifier les fichiers de configuration et variables d'environnement |
| Dépendances non satisfaites | Vérifier l'ordre de démarrage avec depends_on |
# Inspecter un conteneur
docker inspect container_id
# Exécuter une commande dans un conteneur en cours d'exécution
docker-compose exec service_name command
# Voir les logs d'un conteneur
docker logs -f container_id
# Voir l'utilisation des ressources
docker stats📚 Pour plus d'informations sur le dépannage, consultez le guide de dépannage Docker.
- Installez Docker et Docker Compose sur votre système
- Créez un réseau Docker nommé
inception-network - Créez un conteneur NGINX simple qui affiche une page "Hello, Inception!"
- Vérifiez que vous pouvez accéder à la page depuis votre navigateur
- Créez un fichier docker-compose.yml avec deux services : un serveur web NGINX et une base de données MariaDB
- Configurez le réseau pour que les deux services puissent communiquer
- Créez un volume pour persister les données de MariaDB
- Vérifiez que les deux services fonctionnent correctement
- Créez la structure de répertoires complète pour le projet Inception
- Implémentez les Dockerfiles pour NGINX, WordPress et MariaDB
- Configurez les volumes persistants pour les données
- Utilisez des variables d'environnement pour les mots de passe et configurations
- Déployez l'infrastructure complète avec docker-compose
- Vérifiez que vous pouvez accéder au site WordPress via HTTPS
- Documentation Docker - La référence complète pour Docker
- Documentation Docker Compose - Tout sur Docker Compose
- Hub Docker - Registre d'images Docker
- Guide du débutant Docker - Tutoriel étape par étape
- Bonnes pratiques pour les Dockerfiles - Optimisation des Dockerfiles
- Guide de sécurité Docker - Sécurisation de vos conteneurs
- Forums Docker - Communauté d'utilisateurs Docker
- Stack Overflow - Docker - Questions et réponses sur Docker
- GitHub Docker - Projets open-source liés à Docker
Ce guide vous a fourni une introduction complète à Docker et à la mise en place du projet Inception. Vous avez appris :
- Les concepts fondamentaux de Docker et de la conteneurisation
- Comment créer et gérer des Dockerfiles personnalisés
- L'utilisation de Docker Compose pour orchestrer des applications multi-conteneurs
- La configuration des services essentiels (NGINX, MariaDB, WordPress)
- La gestion des réseaux, volumes et variables d'environnement
- Les bonnes pratiques et techniques de dépannage
La maîtrise de Docker et des concepts de conteneurisation vous sera utile bien au-delà du projet Inception, dans de nombreux aspects du développement et du déploiement d'applications modernes.
Continuez à explorer et à expérimenter pour approfondir vos connaissances en conteneurisation !