Créer un réseau bridge personnalisé et connecter deux conteneurs qui pourront communiquer entre eux par leur nom.
# 1. Création du réseau bridge personnalisé
docker network create --driver bridge mon-reseau
# 2. Lancement des conteneurs
docker container run -d --name container1 --network mon-reseau ubuntu:latest sleep 3600
docker container run -d --name container2 --network mon-reseau ubuntu:latest sleep 3600
# 3. Installation des outils réseau dans container1
docker container exec -it container1 bash
apt update && apt install -y net-tools iputils-ping
ping -c 3 container2
# Résultat attendu:
# PING container2 (172.18.0.3) 56(84) bytes of data.
# 64 bytes from container2.mon-reseau (172.18.0.3): icmp_seq=1 ttl=64 time=0.128 ms
exit
# 3. Installation des outils réseau dans container2
docker container exec -it container2 bash
apt update && apt install -y net-tools iputils-ping
ping -c 3 container1
# Résultat attendu:
# PING container1 (172.18.0.2) 56(84) bytes of data.
# 64 bytes from container1.mon-reseau (172.18.0.2): icmp_seq=1 ttl=64 time=0.045 ms
exit
# 4. Affichage des informations du réseau
docker network inspect mon-reseau
# Nettoyage
docker container stop container1 container2
docker container rm container1 container2
docker network rm mon-reseau
Mettre en place un serveur web nginx sur un réseau personnalisé avec un sous-réseau spécifique et une adresse IP fixe.
# 1. Création du réseau avec un sous-réseau spécifique
docker network create --driver bridge --subnet 192.168.100.0/24 --gateway 192.168.100.1 web-network
# 2 & 3. Lancement du conteneur nginx avec IP fixe et publication de port
docker container run -d --name web-server --network web-network --ip 192.168.100.10 -p 8080:80 nginx
# 4. Lancement d'un second conteneur
docker container run -d --name client --network web-network alpine:latest sleep 3600
# 5. Vérification de l'accès au serveur web depuis le client
docker container exec -it client sh
# Installation de curl dans le conteneur client
apk add --no-cache curl
# Test d'accès au serveur web par son nom
curl http://web-server
# Résultat attendu: La page d'accueil de nginx
# Test d'accès au serveur web par son IP
curl http://192.168.100.10
# Résultat attendu: La même page d'accueil de nginx
exit
# Vérification de l'accès depuis l'hôte
curl http://localhost:8080
# Résultat attendu: La page d'accueil de nginx
# Nettoyage
docker container stop web-server client
docker container rm web-server client
docker network rm web-network
Créer une architecture trois-tiers avec isolation réseau entre les différentes couches: frontend, backend et base de données.
# 1. Création des trois réseaux
docker network create frontend-net
docker network create --internal backend-net
docker network create --internal db-net
# 2. Déploiement du conteneur nginx dans frontend-net
docker container run -d --name frontend --network frontend-net -p 80:80 nginx
# 3. Déploiement du conteneur "app" connecté à frontend-net et backend-net
docker container run -d --name app --network frontend-net alpine:latest sleep 3600
docker network connect backend-net app
# 4. Déploiement du conteneur MySQL dans db-net
docker container run -d --name database --network db-net \
-e MYSQL_ROOT_PASSWORD=secret \
-e MYSQL_DATABASE=testdb \
-e MYSQL_USER=testuser \
-e MYSQL_PASSWORD=testpass \
mysql:5.7
# 5. Connexion du conteneur "app" au réseau db-net
docker network connect db-net app
# 6. Vérification de la connectivité
# Installation des outils réseau dans le conteneur frontend
docker container exec -it frontend sh
apt-get update && apt-get install -y iputils-ping curl
ping -c 2 app # Devrait fonctionner
ping -c 2 database # Ne devrait pas fonctionner (nom non résolu)
exit
# Installation des outils réseau dans le conteneur app
docker container exec -it app sh
apk add --no-cache curl iputils mysql-client
# Test de connectivité vers frontend
ping -c 2 frontend # Devrait fonctionner
# Test de connectivité vers database
ping -c 2 database # Devrait fonctionner
# Test de connexion MySQL
mysql -h database -u testuser -ptestpass -e "SHOW DATABASES;"
# Résultat attendu: Liste des bases de données
exit
# Affichage des informations réseau pour tous les conteneurs
docker container inspect frontend -f '{{json .NetworkSettings.Networks}}' | jq
docker container inspect app -f '{{json .NetworkSettings.Networks}}' | jq
docker container inspect database -f '{{json .NetworkSettings.Networks}}' | jq
# Résultat attendu:
# frontend est connecté uniquement à frontend-net
# app est connecté à frontend-net, backend-net et db-net
# database est connecté uniquement à db-net
# Nettoyage
docker container stop frontend app database
docker container rm frontend app database
docker network rm frontend-net backend-net db-net
L'architecture mise en place dans l'exercice 3 est une architecture trois-tiers typique:
Couche présentation (frontend):
Couche application (middleware):
Couche données:
Cette architecture offre plusieurs avantages en termes de sécurité:
C'est un pattern couramment utilisé dans les architectures de microservices où l'isolation et la séparation des responsabilités sont cruciales.