Skip to main content

Docker Networks

Chapter objectives​

  • Understand the Docker network types
  • Create and configure networks
  • Connect containers to each other
  • Isolate applications

1 - Introduction to Docker networks​

Why Docker networks?​

Docker networks enable:

  • Communication between containers
  • Application isolation
  • Automatic DNS resolution
  • Network traffic control

The default networks​

# Lister les réseaux
docker network ls

# Résultat
NETWORK ID     NAME      DRIVER    SCOPE
abc123...      bridge    bridge    local
def456...      host      host      local
ghi789...      none      null      local

2 - Network types (drivers)​

Bridge (default)​

┌─────────────────────────────────────────────────────────────┐
│                          Hôte                                │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                  docker0 (bridge)                    │    │
│  │                    172.17.0.1                        │    │
│  └────────┬─────────────────┬─────────────────┬────────┘    │
│           │                 │                 │              │
│     ┌─────▼─────┐     ┌─────▼─────┐     ┌─────▼─────┐       │
│     │ Container │     │ Container │     │ Container │       │
│     │ 172.17.0.2│     │ 172.17.0.3│     │ 172.17.0.4│       │
│     └───────────┘     └───────────┘     └───────────┘       │
└─────────────────────────────────────────────────────────────┘
  • Isolated network on the host
  • Containers can communicate with each other
  • NAT to access the outside

Host​

# Le conteneur utilise directement le réseau de l'hôte
docker run --network host nginx

# Pas d'isolation réseau
# Port 80 du conteneur = Port 80 de l'hôte

None​

# Aucune interface réseau
docker run --network none alpine ip addr

# Uniquement loopback (127.0.0.1)

Overlay (Swarm)​

  • Communication between multiple Docker hosts
  • Used with Docker Swarm
  • Encryption available

Macvlan​

# Chaque conteneur a sa propre adresse MAC
docker network create -d macvlan \
  --subnet=192.168.1.0/24 \
  --gateway=192.168.1.1 \
  -o parent=eth0 \
  mon-macvlan

Comparison​

DriverIsolationMulti-hostUsage
bridgeYesNoDevelopment, simple production
hostNoNoMaximum performance
noneTotalNoMaximum security
overlayYesYesSwarm, clusters
macvlanYesNoIntegration with existing network

3 - Network management​

Create a network​

# Réseau bridge simple
docker network create mon-reseau

# Avec configuration personnalisée
docker network create \
  --driver bridge \
  --subnet 172.20.0.0/16 \
  --ip-range 172.20.240.0/20 \
  --gateway 172.20.0.1 \
  mon-reseau-custom

# Réseau interne (sans accès externe)
docker network create --internal mon-reseau-interne

List and inspect​

# Lister les réseaux
docker network ls

# Filtrer
docker network ls --filter driver=bridge

# Inspecter un réseau
docker network inspect mon-reseau

# Voir les conteneurs connectés
docker network inspect mon-reseau --format '{{range .Containers}}{{.Name}} {{end}}'

Delete networks​

# Supprimer un réseau
docker network rm mon-reseau

# Supprimer les réseaux non utilisés
docker network prune

# Forcer
docker network prune -f

4 - Connect containers​

At startup​

# Connecter à un réseau spécifique
docker run -d --name web --network mon-reseau nginx

# Avec une IP fixe
docker run -d --name db \
  --network mon-reseau \
  --ip 172.20.0.10 \
  postgres:15

After startup​

# Connecter un conteneur existant
docker network connect mon-reseau mon-conteneur

# Avec une IP spécifique
docker network connect --ip 172.20.0.20 mon-reseau mon-conteneur

# Déconnecter
docker network disconnect mon-reseau mon-conteneur

Container on multiple networks​

# Créer deux réseaux
docker network create frontend
docker network create backend

# Connecter un conteneur aux deux réseaux
docker run -d --name api --network frontend mon-api
docker network connect backend api

# L'API peut communiquer avec frontend ET backend

5 - DNS resolution​

Automatic DNS in custom networks​

# Créer un réseau
docker network create mon-app

# Lancer des conteneurs
docker run -d --name db --network mon-app postgres:15
docker run -d --name web --network mon-app nginx

# Les conteneurs peuvent se résoudre par leur nom
docker exec web ping db
# PING db (172.20.0.2): 56 data bytes

Network aliases​

# Créer un alias
docker run -d \
  --name postgres-primary \
  --network mon-app \
  --network-alias db \
  --network-alias database \
  postgres:15

# Les deux alias fonctionnent
docker exec web ping db
docker exec web ping database

DNS Round-Robin​

# Plusieurs conteneurs avec le même alias
docker run -d --name web1 --network mon-app --network-alias web nginx
docker run -d --name web2 --network mon-app --network-alias web nginx
docker run -d --name web3 --network mon-app --network-alias web nginx

# Le DNS retourne toutes les IPs (load balancing basique)
docker run --rm --network mon-app alpine nslookup web

6 - Communication between containers​

Example: Web application + Database​

# Créer le réseau
docker network create webapp

# Lancer la base de données
docker run -d \
  --name db \
  --network webapp \
  -e POSTGRES_PASSWORD=secret \
  -e POSTGRES_DB=myapp \
  postgres:15

# Lancer l'application
docker run -d \
  --name app \
  --network webapp \
  -e DATABASE_URL=postgres://postgres:secret@db:5432/myapp \
  -p 3000:3000 \
  mon-app

Example: Microservices architecture​

# Créer les réseaux
docker network create frontend
docker network create backend

# Base de données (backend uniquement)
docker run -d \
  --name postgres \
  --network backend \
  -e POSTGRES_PASSWORD=secret \
  postgres:15

# API (frontend + backend)
docker run -d \
  --name api \
  --network backend \
  -e DB_HOST=postgres \
  mon-api
docker network connect frontend api

# Frontend (frontend uniquement)
docker run -d \
  --name nginx \
  --network frontend \
  -p 80:80 \
  nginx
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│  ┌──────────────── frontend ────────────────┐              │
│  │                                          │              │
│  │   ┌───────────┐       ┌───────────┐      │              │
│  │   │   nginx   │ ───── │    api    │      │              │
│  │   │   :80     │       │           │      │              │
│  │   └───────────┘       └─────┬─────┘      │              │
│  │                             │            │              │
│  └─────────────────────────────┼────────────┘              │
│                                │                           │
│  ┌──────────────── backend ────┼────────────┐              │
│  │                             │            │              │
│  │                       ┌─────▼─────┐      │              │
│  │                       │ postgres  │      │              │
│  │                       │   :5432   │      │              │
│  │                       └───────────┘      │              │
│  │                                          │              │
│  └──────────────────────────────────────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

7 - Port publishing​

Syntax​

# Format
-p [IP_HOTE:]PORT_HOTE:PORT_CONTENEUR[/PROTOCOLE]

# Exemples
-p 8080:80                 # Toutes les interfaces
-p 127.0.0.1:8080:80       # Localhost uniquement
-p 80:80 -p 443:443        # Plusieurs ports
-p 8080:80/tcp             # TCP explicite
-p 5000:5000/udp           # UDP

Publish all exposed ports​

# Publie tous les ports EXPOSE sur des ports aléatoires
docker run -d -P nginx

# Voir les ports assignés
docker port mon-conteneur
# 80/tcp -> 0.0.0.0:32768

Verify the ports​

# Ports d'un conteneur
docker port mon-conteneur

# Dans docker ps
docker ps --format "table {{.Names}}\t{{.Ports}}"

# Depuis l'extérieur
curl http://localhost:8080

8 - Network security​

Internal networks​

# Créer un réseau sans accès externe
docker network create --internal secure-net

# Les conteneurs ne peuvent pas accéder à Internet
docker run --network secure-net alpine ping google.com
# ping: bad address 'google.com'

Application isolation​

# Application 1 sur son propre réseau
docker network create app1-net
docker run -d --name app1-db --network app1-net postgres:15
docker run -d --name app1-web --network app1-net -p 8001:80 nginx

# Application 2 sur son propre réseau
docker network create app2-net
docker run -d --name app2-db --network app2-net postgres:15
docker run -d --name app2-web --network app2-net -p 8002:80 nginx

# app1 ne peut PAS communiquer avec app2

Best practices​

# ✅ Utiliser des réseaux personnalisés (pas bridge par défaut)
docker network create mon-app

# ✅ Exposer uniquement les ports nécessaires
-p 127.0.0.1:3000:3000  # Localhost uniquement

# ✅ Utiliser des réseaux internes pour les BDD
docker network create --internal db-net

# ✅ Séparer frontend et backend
docker network create frontend
docker network create --internal backend

9 - Network debugging​

Inspect connectivity​

# Voir la configuration réseau d'un conteneur
docker inspect mon-conteneur --format '{{json .NetworkSettings.Networks}}'

# Tester la connectivité
docker exec mon-conteneur ping autre-conteneur

# Voir les connexions
docker exec mon-conteneur netstat -an

# Résolution DNS
docker exec mon-conteneur nslookup service-name

Debug tools​

# Conteneur de debug avec outils réseau
docker run -it --network mon-reseau nicolaka/netshoot

# Dans le conteneur netshoot
ping db
nslookup web
curl http://api:3000
tcpdump -i eth0

Common problems​

ProblemProbable causeSolution
Container unreachableNot on the same networkdocker network connect
DNS does not resolveDefault bridge networkUse a custom network
Port unreachableNot publishedAdd -p port:port
Connection refusedService not startedCheck the logs

Summary​

CommandDescription
docker network createCreate a network
docker network lsList the networks
docker network inspectNetwork details
docker network connectConnect a container
docker network disconnectDisconnect a container
docker network rmDelete a network
docker network pruneClean up networks
DriverUsage
bridgeIsolated applications (default)
hostPerformance, no isolation
noneMaximum security
overlayMulti-host (Swarm)
Key points
  • Use custom networks for automatic DNS
  • Isolate applications with separate networks
  • Publish only the necessary ports
  • Use internal networks for sensitive services

Hands-on exercises​

  1. Create a network and make two containers communicate by name
  2. Configure an architecture with isolated frontend/backend
  3. Test DNS resolution between containers
  4. Create an internal network and verify the absence of external access

← Docker Volumes | Docker Compose →