Docker-Netzwerke regeln, wie Container untereinander und mit der Außenwelt kommunizieren. Das Verständnis verschiedener Netzwerktypen ist essenziell.

Netzwerk-Grundlagen

Docker erstellt bei der Installation drei Standard-Netzwerke:

docker network ls

| Name | Treiber | Beschreibung | |------|---------|--------------| | bridge | bridge | Standard für Container | | host | host | Teilt Host-Netzwerk | | none | null | Kein Netzwerk |

Bridge-Netzwerk (Standard)

Funktionsweise

  • Container erhalten private IPs (172.17.0.x)
  • Container können ins Internet
  • Host erreicht Container über Port-Mapping
  • Container untereinander über IPs (nicht Namen)

Beispiel

docker run -d --name web nginx
docker run -d --name db mysql

Container kommunizieren über IPs:

docker inspect web | grep IPAddress
# 172.17.0.2

docker exec db ping 172.17.0.2

Ports freigeben

docker run -d -p 80:80 nginx
docker run -d -p 8080:80 nginx  # Externer Port 8080
docker run -d -p 127.0.0.1:80:80 nginx  # Nur localhost

Benutzerdefinierte Netzwerke

Benutzerdefinierte Netzwerke bieten Vorteile:

  • DNS-Auflösung: Container nach Namen erreichbar
  • Bessere Isolation: Getrennt von anderen Containern
  • Hot-Swapping: Container ohne Neustart verbinden

Netzwerk erstellen

docker network create mein-netzwerk

Mit Optionen:

docker network create \
  --driver bridge \
  --subnet 10.10.0.0/24 \
  --gateway 10.10.0.1 \
  mein-netzwerk

Container verbinden

docker run -d --name web --network mein-netzwerk nginx
docker run -d --name db --network mein-netzwerk mysql

Jetzt funktioniert DNS:

docker exec web ping db
# Funktioniert!

Container zu Netzwerk hinzufügen

docker network connect mein-netzwerk bestehender-container

Vom Netzwerk trennen

docker network disconnect mein-netzwerk container-name

Host-Netzwerk

Container nutzt direkt das Host-Netzwerk:

docker run --network host nginx
  • Kein Port-Mapping nötig
  • Bessere Performance
  • Weniger Isolation
  • Portkonflikt mit Host möglich

Anwendungsfall

Wenn Port-Mapping Performance kostet (z.B. viele Verbindungen).

None-Netzwerk

Container ohne Netzwerk:

docker run --network none alpine

Nützlich für:

  • Batch-Jobs ohne Netzwerk
  • Maximale Isolation

Netzwerke in Docker Compose

version: '3.8'

services:
  web:
    image: nginx
    networks:
      - frontend
      - backend
    ports:
      - "80:80"

  app:
    image: node:18
    networks:
      - backend

  db:
    image: mysql:8
    networks:
      - backend
    environment:
      MYSQL_ROOT_PASSWORD: geheim

networks:
  frontend:
  backend:

Standardnetzwerk in Compose

Docker Compose erstellt automatisch ein Netzwerk für alle Services:

projektname_default

Externe Netzwerke

networks:
  existing-network:
    external: true

Netzwerk-Optionen

networks:
  backend:
    driver: bridge
    ipam:
      config:
        - subnet: 10.10.0.0/24
          gateway: 10.10.0.1

Mehrere Netzwerke

Container können in mehreren Netzwerken sein:

services:
  proxy:
    image: nginx
    networks:
      - frontend
      - backend

  app:
    image: myapp
    networks:
      - backend

  db:
    image: postgres
    networks:
      - backend

networks:
  frontend:
    # Öffentlich zugänglich
  backend:
    internal: true  # Kein Internet-Zugang

Netzwerk-Treiber

Bridge (Standard)

docker network create --driver bridge mein-bridge

Overlay (Swarm)

Für Docker Swarm / Multi-Host:

docker network create --driver overlay mein-overlay

Macvlan

Container mit eigener MAC-Adresse:

docker network create \
  --driver macvlan \
  --subnet 192.168.1.0/24 \
  --gateway 192.168.1.1 \
  -o parent=eth0 \
  mein-macvlan

Container erscheint als eigenständiges Gerät im Netzwerk.

DNS in Docker

Automatische DNS-Auflösung

In benutzerdefinierten Netzwerken:

docker exec web ping db
# Auflösung über Container-Name

DNS-Aliase

services:
  database:
    image: mysql
    networks:
      backend:
        aliases:
          - mysql
          - db

Externer DNS

docker run --dns 8.8.8.8 nginx

In Compose:

services:
  web:
    image: nginx
    dns:
      - 8.8.8.8
      - 1.1.1.1

Netzwerk-Troubleshooting

Netzwerk-Details

docker network inspect mein-netzwerk

Container-Netzwerk prüfen

docker inspect container-name | grep -A20 Networks

Verbindung testen

# Von Container zu Container
docker exec web ping db

# DNS-Auflösung
docker exec web nslookup db

# Port prüfen
docker exec web nc -zv db 3306

Tcpdump im Container

docker run --rm --net container:web nicolaka/netshoot tcpdump -i eth0

Netzwerk-Debug-Container

docker run -it --network mein-netzwerk nicolaka/netshoot

Best Practices

1. Eigene Netzwerke nutzen

Nicht das Standard-Bridge-Netzwerk verwenden:

networks:
  app-network:

2. Netzwerke nach Funktion trennen

networks:
  frontend:   # Web-Traffic
  backend:    # App zu DB
  monitoring: # Monitoring-Tools

3. Interne Netzwerke für Datenbanken

networks:
  database:
    internal: true  # Kein Internet

4. Ports nur wenn nötig freigeben

services:
  db:
    # Keine Ports nach außen!
    networks:
      - backend

5. Konsistente Benennung

projektname_frontend
projektname_backend

Beispiel: Komplettes Setup

version: '3.8'

services:
  traefik:
    image: traefik:v2.10
    ports:
      - "80:80"
      - "443:443"
    networks:
      - proxy

  web:
    image: nginx
    networks:
      - proxy
      - app

  api:
    image: node:18
    networks:
      - app
      - database

  db:
    image: postgres:15
    networks:
      - database
    volumes:
      - db-data:/var/lib/postgresql/data

  redis:
    image: redis:7
    networks:
      - app

networks:
  proxy:
    # Reverse Proxy Netzwerk
  app:
    # Anwendungs-Netzwerk
  database:
    internal: true  # Isoliert

volumes:
  db-data:

Fazit

Docker-Netzwerke sind der Schlüssel zu sicherer Container-Kommunikation. Verwenden Sie benutzerdefinierte Netzwerke für DNS-Auflösung und bessere Isolation. Trennen Sie Netzwerke nach Funktion und nutzen Sie interne Netzwerke für sensible Dienste wie Datenbanken.