Docker-Container-Vernetzung in der Praxis: Web- und Datenbank-Container zuverlässig miteinander verbinden

Freitag, 15 Uhr – ich wollte gerade meine lokale Entwicklungsumgebung containerisieren und war ziemlich zufrieden: MySQL-Container läuft, Node.js-App-Container ebenfalls, nur noch die Verbindung zwischen beiden. Dann aktualisiere ich die Seite im Browser – 500-Fehler, im Log eine Flut von „Connection refused“.

Ich war ratlos: Beide Container liefen doch. Ich pingte den MySQL-Containernamen – „unknown host“. Also probierte ich die IP – und es klappte! Die App verband sich mit der Datenbank. Erleichtert committe ich, fahre den Rechner runter.

Montag: Die App war wieder down. Ursache: Nach dem MySQL-Neustart hatte sich die IP von 172.17.0.2 auf 172.17.0.3 geändert. Soll ich wirklich nach jedem Container-Neustart die Konfiguration anpassen?

Wenn Ihnen das bekannt vorkommt, ist dieser Artikel für Sie. Ein Nachmittag mit Docker-Netzwerken hat mir die richtige Methode für Container-Vernetzung gezeigt. Im Folgenden:

• Warum Containername-Ping scheitert und was dahintersteckt
• Grenzen des Docker-Standardnetzwerks
• Wie benutzerdefinierte Netzwerke das lösen
• Vollständiger Praxisablauf für Zugriff per Name
• Fortgeschrittene Tipps und Best Practices

Warum lässt sich der Containername nicht pingen?

Grenzen des Docker-Standardnetzwerks

Die Ursache liegt in der Standard-Netzwerkkonfiguration. Starten Sie einen Container ohne explizites Netzwerk, verbindet Docker ihn automatisch mit dem Standard-bridge-Netzwerk (docker0).

Dieses Netzwerk hat eine wesentliche Einschränkung: Es unterstützt nur IP-basierte Kommunikation, keine Namensauflösung.

Konkret bedeutet das im Standardnetzwerk:

• ✅ Zugriff auf andere Container per IP (z. B. ping 172.17.0.2)
• ❌ Kein Zugriff per Containername (z. B. ping mysql-container schlägt fehl)

Warum? Das Standardnetzwerk hat keinen eingebauten DNS-Dienst. Stellen Sie sich ein Handy ohne Kontaktliste vor: Sie müssen sich die Nummer (IP) merken, können aber nicht per Name (Containername) jemanden finden.

Noch unangenehmer: Bei jedem Neustart vergibt Docker eine neue IP. Heute funktioniert 172.17.0.2 für MySQL, morgen nach Neustart vielleicht 172.17.0.3 – die IP in Ihrer App-Konfiguration ist ungültig.

Zur Verifikation per Befehl:

# MySQL-Container im Standardnetzwerk starten
docker run -d --name mysql-demo \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# Busybox-Container zum Netzwerktest
docker run -it --name test-box busybox sh

# Im test-box-Container MySQL-Containernamen pingen
/ # ping mysql-demo
ping: bad address 'mysql-demo'  # ← Auflösung fehlgeschlagen

# IP des MySQL-Containers anzeigen
docker inspect mysql-demo | grep IPAddress
# "IPAddress": "172.17.0.2"

# Per IP funktioniert ping
/ # ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2): 56 data bytes
64 bytes from 172.17.0.2: seq=0 ttl=64 time=0.123 ms

Per Containername geht es nicht – nur per IP.

Der —link-Parameter ist veraltet

In älteren Tutorials finden Sie --link – frühe Docker-Lösung:

docker run --link mysql-demo:mysql -d my-app

Damit erreicht my-app mysql-demo unter dem Alias „mysql“. Docker empfiehlt —link nicht mehr; die Funktion wird in künftigen Versionen entfernt.

Gründe:

1. Unidirektional: Nur my-app → mysql, nicht umgekehrt
2. Wartungsaufwand: Bei vielen Containern wird —link unübersichtlich
3. Eingeschränkt: Kein flexibles Netzwerk-Management für komplexe Szenarien

Wenn Sie noch —link nutzen, sollten Sie auf die neue Methode umsteigen.

Benutzerdefiniertes Netzwerk: der richtige Weg zur Container-Vernetzung

Vorteile benutzerdefinierter Netzwerke

Seit Docker 1.12 gibt es docker network zum Anlegen eigener Netzwerke – die offizielle Empfehlung für Container-Vernetzung.

Railway - Moderne Deployment-Plattform, ohne DevOps-Aufwand, in Minuten live

Jetzt starten →Anzeige

Im Vergleich zum Standard-bridge-Netzwerk:

1. Automatische DNS-Auflösung: Docker betreibt einen DNS-Server im benutzerdefinierten Netzwerk; Containernamen werden in IPs aufgelöst – wie ein Adressbuch für das Netzwerk.

2. Netzwerk-Isolation: Container in verschiedenen benutzerdefinierten Netzwerken sind standardmäßig voneinander getrennt. Frontend, Backend und Datenbank können in getrennten Netzwerken liegen.

3. Bessere Wartbarkeit: IP-Wechsel nach Neustart ist unkritisch, solange Sie Containernamen nutzen – DNS aktualisiert die Einträge.

4. Mehrere Netzwerke: Ein Container kann mehreren Netzwerken angehören – für komplexere Topologien.

Docker-Netzwerke wirken zunächst komplex; diese vier Punkte machen das Modell aber schnell nachvollziehbar.

Benutzerdefiniertes Netzwerk anlegen

# Einfachste Variante: nur Name
docker network create my-app-net

# Mit allen Parametern
docker network create \
  --driver bridge \         # Netzwerk-Treiber, Standard ist bridge
  --subnet 172.20.0.0/16 \  # Eigenes Subnetz (optional)
  --gateway 172.20.0.1 \    # Eigenes Gateway (optional)
  my-app-net                # Netzwerkname

Für die meisten Fälle reicht die einfache Variante; Docker wählt ein freies Subnetz.

Details anzeigen:

docker network inspect my-app-net

Ausgabe: Subnetz, Gateway, verbundene Container usw.

Container dem Netzwerk hinzufügen

Variante 1: Beim Start angeben (empfohlen)

docker run -d \
  --name mysql-demo \
  --network my-app-net \  # ← entscheidender Parameter
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

Variante 2: Laufenden Container verbinden

# Container läuft bereits
docker network connect my-app-net existing-container

Variante 1 ist direkter; Variante 2 eignet sich zum Migrieren bestehender Container.

Praxis: Web-App mit MySQL-Datenbank

Genug Theorie – ein konkretes Szenario: Node.js-App-Container verbindet sich mit MySQL.

Szenario

• MySQL-Container mysql-server im benutzerdefinierten Netzwerk
• Node.js-App node-app im selben Netzwerk
• Verbindung per Containername „mysql-server“, nicht per IP

Schritt-für-Schritt

Schritt 1: Benutzerdefiniertes Netzwerk anlegen

docker network create my-app-net

Ausgabe: Netzwerk-ID, z. B.:

a1b2c3d4e5f67890abcdef1234567890abcdef1234567890abcdef1234567890

Schritt 2: MySQL-Container starten

docker run -d \
  --name mysql-server \
  --network my-app-net \
  -e MYSQL_ROOT_PASSWORD=my-secret-pw \
  -e MYSQL_DATABASE=myapp_db \
  mysql:8.0

Parameter:

• --name mysql-server: Hostname für die DB-Verbindung
• --network my-app-net: Verbindung zum neuen Netzwerk
• -e MYSQL_ROOT_PASSWORD: Root-Passwort
• -e MYSQL_DATABASE: Initial-Datenbank

Schritt 3: App-Container starten

docker run -d \
  --name node-app \
  --network my-app-net \
  -p 3000:3000 \
  -e DB_HOST=mysql-server \
  -e DB_USER=root \
  -e DB_PASSWORD=my-secret-pw \
  -e DB_NAME=myapp_db \
  my-node-app:latest

Beachten Sie DB_HOST=mysql-server – Containername, keine IP.

Schritt 4: In der App per Containername verbinden

Node.js-Beispiel:

const mysql = require('mysql2');

// Verbindung über Umgebungsvariablen
const connection = mysql.createConnection({
  host: process.env.DB_HOST,      // Wert: 'mysql-server' (Containername)
  user: process.env.DB_USER,      // Wert: 'root'
  password: process.env.DB_PASSWORD,
  database: process.env.DB_NAME
});

connection.connect((err) => {
  if (err) {
    console.error('Datenbankverbindung fehlgeschlagen:', err);
    return;
  }
  console.log('Erfolgreich mit MySQL verbunden!');
});

Entscheidend: host ist der Containername mysql-server; Docker-DNS löst ihn in die aktuelle IP auf.

Schritt 5: Konnektivität prüfen

# In den App-Container wechseln
docker exec -it node-app sh

# MySQL-Containernamen pingen
/ # ping mysql-server
PING mysql-server (172.20.0.2): 56 data bytes
64 bytes from 172.20.0.2: seq=0 ttl=64 time=0.089 ms
64 bytes from 172.20.0.2: seq=1 ttl=64 time=0.096 ms

Containername wird aufgelöst und ist erreichbar.

DNS-Auflösung mit nslookup:

/ # nslookup mysql-server
Server:    127.0.0.11  # ← Docker-interner DNS
Address:   127.0.0.11:53

Name:      mysql-server
Address:   172.20.0.2  # ← IP des MySQL-Containers

Docker betreibt im benutzerdefinierten Netzwerk DNS unter 127.0.0.11.

Nach MySQL-Neustart und IP-Wechsel bleibt die App unbeeinträchtigt – DNS aktualisiert die Einträge.

Troubleshooting

1. Netzwerkdetails

Alibaba Cloud - Top-Wahl für Entwickler, exklusiv 15 % Rabatt auf Lighthouse-Server

15 % Rabatt sichern →Anzeige

docker network inspect my-app-net

JSON mit Subnetz, Gateway, verbundenen Containern und deren IPs.

2. Netzwerk-Konfiguration eines Containers

docker inspect mysql-server | grep -A 20 Networks

Zeigt Netzwerke und IPs pro Netzwerk.

3. Container-Logs

docker logs node-app
docker logs mysql-server

Oft mit detaillierten Verbindungsfehlern.

Häufige Probleme:

Fortgeschrittene Tipps und Best Practices

Mehrere Netzwerke: Frontend/Backend-Trennung

Komplexere Topologie – Frontend, Backend, Datenbank in getrennten Schichten:

# Zwei Netzwerke
docker network create frontend-net  # Frontend
docker network create backend-net   # Backend

# Frontend nur in frontend-net
docker run -d --name nginx \
  --network frontend-net \
  -p 80:80 \
  nginx:latest

# API in beiden Netzwerken (Frontend und Backend)
docker run -d --name api-server \
  --network frontend-net \
  my-api:latest

docker network connect backend-net api-server

# DB nur in backend-net (Frontend hat keinen Zugriff)
docker run -d --name postgres \
  --network backend-net \
  -e POSTGRES_PASSWORD=secret \
  postgres:14

Vorteile:

• nginx erreicht api-server, nicht die Datenbank
• api-server erreicht die DB
• DB nur für Backend erreichbar – mehr Sicherheit

In vielen Produktionsprojekten wird genau so getrennt.

Verwaltung mit Docker Compose

Bei vielen Containern ist manuelle Verwaltung mühsam – Docker Compose hilft.

docker-compose.yml:

version: '3.8'

services:
  # MySQL
  mysql:
    image: mysql:8.0
    container_name: mysql-server
    environment:
      MYSQL_ROOT_PASSWORD: my-secret-pw
      MYSQL_DATABASE: myapp_db
    networks:
      - app-network
    volumes:
      - mysql-data:/var/lib/mysql

  # Node.js-App
  app:
    image: my-node-app:latest
    container_name: node-app
    ports:
      - "3000:3000"
    environment:
      DB_HOST: mysql  # ← Service-Name, nicht container_name
      DB_USER: root
      DB_PASSWORD: my-secret-pw
      DB_NAME: myapp_db
    networks:
      - app-network
    depends_on:
      - mysql

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:

Alles mit einem Befehl:

docker-compose up -d

Docker Compose:

• legt app-network an
• startet Container im Netzwerk
• konfiguriert DNS zwischen Services
• startet in depends_on-Reihenfolge (mysql vor app)

Stoppen und Aufräumen:

# Services stoppen
docker-compose down

# Stoppen und Volumes entfernen
docker-compose down -v

Für Multi-Container-Setups ist Compose in der Praxis deutlich effizienter als manuelles docker run.

Weitere Netzwerkmodi

Neben bridge gibt es weitere Modi:

Meist reicht benutzerdefiniertes bridge. host für latenzkritische Systeme; overlay ist Basis von Swarm/K8s und selten manuell nötig.

FAQ

F1: Warum funktioniert IP, der Containername aber nicht?

A: Container hängen im Standard-bridge-Netzwerk (docker0) ohne DNS. Lösung: benutzerdefiniertes Netzwerk anlegen und Container dort starten.

F2: Geht —link noch?

A: Technisch ja, aber nicht empfohlen und wird entfernt. Migrieren Sie zu benutzerdefinierten Netzwerken.

F3: Beeinträchtigt ein benutzerdefiniertes Netzwerk die Performance?

KiloClaw - Managed OpenClaw für Unternehmen: AI-Agent-Orchestrierung und smartes Modell-Routing

Jetzt starten →Anzeige

A: Praktisch nicht. Gleiche bridge-Basis wie Standard, plus DNS – Unterschied vernachlässigbar.

F4: Wie erreichen Container das Internet?

A: bridge-Container nutzen standardmäßig NAT. Bei Problemen iptables-Regeln oder Host-Netzwerk prüfen.

F5: Bestehenden Container ins benutzerdefinierte Netzwerk migrieren?

A:

# 1. Mit neuem Netzwerk verbinden
docker network connect my-app-net old-container

# 2. (Optional) Standard-bridge trennen
docker network disconnect bridge old-container

Besser: Container neu mit --network erstellen.

F6: Großbuchstaben im Containernamen?

A: Möglich, aber nicht empfohlen. DNS-Konvention: Kleinbuchstaben, Ziffern, Bindestriche.

F7: Mehrere Netzwerke pro Container?

A: Ja – mit docker network connect für komplexe Topologien.

Zusammenfassung

Schritt 1: Problem verstehen

• Standardnetzwerk: keine Namensauflösung, nur IP
• IP ändert sich nach Neustart
• —link ist veraltet

Schritt 2: Benutzerdefiniertes Netzwerk

docker network create my-app-net

Schritt 3: Container im Netzwerk, Kommunikation per Name

# Beim Start Netzwerk angeben
docker run -d --name mysql-server --network my-app-net mysql:8.0

# In der App Containername als Host
host: 'mysql-server'  // nicht IP, sondern Name

Einfach und Docker-Best-Practice – stabilere, wartbarere containerisierte Anwendungen.

Für Microservices oder Multi-Container-Projekte:

1. Jetzt umstellen: Bestehende Setups auf benutzerdefinierte Netzwerke, keine IP-Hardcodierung mehr
2. Compose nutzen: Ab drei Containern deutlich einfacher
3. Vertiefen: overlay und Kubernetes-Netzwerkmodelle – Basis für Cloud Native

Container-Netzwerke haben eine Lernkurve; danach wird Docker deutlich angenehmer. Legen Sie im Terminal Ihr erstes benutzerdefiniertes Netzwerk an.

Fragen gerne in den Kommentaren – ich antworte, wenn möglich.