Wie man einen Docker-Port freischaltet

Bei der Arbeit mit Docker-Containern ist einer der wichtigsten Aspekte, auf den ich gestoßen bin, die Netzwerkkommunikation zwischen Containern und der Außenwelt. Ohne die richtige Portkonfiguration bleiben containerisierte Anwendungen isoliert und unzugänglich. In diesem Artikel zeige ich dir, wie du Docker-Ports freischaltest - eine grundlegende Fähigkeit für alle, die mit containerisierten Anwendungen arbeiten.

Dieser Leitfaden richtet sich an Softwareentwickler, DevOps-Ingenieure und IT-Experten, die ihre containerisierten Anwendungen für Nutzer, andere Dienste oder externe Systeme zugänglich machen müssen. Egal, ob du einen Webserver, eine API oder eine Datenbank in einem Container bereitstellst, das Verständnis der Portfreigabe ist für den Aufbau funktionaler Docker-basierter Systeme unerlässlich.

Am Ende dieses Artikels wirst du ein klares Verständnis davon haben, wie das Docker-Netzwerk funktioniert, die verschiedenen Methoden zur Freigabe von Ports und praktische Techniken, um diese Konzepte in deinen eigenen Projekten umzusetzen.

Wenn du Docker noch nicht kennst, solltest du einen unserer Kurse besuchen, z.B. Einführung in Docker, Containerisierung und Virtualisierung mit Docker und Kubernetes, Docker für Fortgeschrittene oder Containerisierungs- und Virtualisierungskonzepte.

Was ist die Freigabe eines Ports in Docker?

Bevor du in die technischen Details eintauchst, ist es wichtig zu verstehen, was Port Exposure im Docker-Ökosystem bedeutet.

Grundsätze der Isolierung von Containernetzwerken

Bei der Entwicklung von Docker-Containern ist die Isolation ein zentrales Prinzip. Diese Isolierung wird durch Linux-Kernel-Funktionen wie Namespaces und cgroups erreicht. Namensräume sorgen für eine Prozessisolierung und stellen sicher, dass Prozesse innerhalb eines Containers keine Prozesse in anderen Containern oder im Hostsystem sehen oder mit ihnen interagieren können. Cgroups hingegen kontrollieren die Ressourcenzuweisung und begrenzen, wie viel CPU, Speicher und andere Ressourcen ein Container verbrauchen kann.

Aus der Netzwerkperspektive erhält jeder Container seinen eigenen Netzwerk-Namensraum, komplett mit einer virtuellen Ethernet-Schnittstelle (Veth-Paar). Diese Schnittstelle verbindet sich standardmäßig mit einem Docker-Bridge-Netzwerk, das die Kommunikation zwischen den Containern ermöglicht und gleichzeitig vom Host-Netzwerk isoliert ist. Stell dir das so vor, dass jeder Container seine eigene private Netzwerkadresse hat, die für die Außenwelt unsichtbar ist.

In der Standardkonfiguration ist ein Docker-Container vollständig in einer Sandbox untergebracht. Dienste, die innerhalb des Containers laufen, können miteinander kommunizieren, sind aber von außerhalb des Containers nicht erreichbar, auch nicht vom Host-Rechner aus. Das ist der Punkt, an dem die Hafenexposition notwendig wird.

Expose vs. Publish: semantische Unterscheidung

Bei der Arbeit mit der Docker-Port-Konfiguration wirst du auf zwei verwandte, aber unterschiedliche Konzepte stoßen: das Freigeben und Veröffentlichen von Ports.

Die Offenlegung der Ports ist in erster Linie eine Dokumentationsfunktion. Wenn du einen Port in Docker freigibst, fügst du deinem Container-Image im Wesentlichen Metadaten hinzu, die angeben, dass die containerisierte Anwendung auf bestimmten Ports lauscht. 

Die Freigabe eines Ports bedeutet jedoch nicht, dass er von außerhalb des Containers zugänglich ist. Sie dient als Dokumentation für die Nutzer deines Bildes.

Die Veröffentlichung von Ports macht deine containerisierten Dienste für die Außenwelt verfügbar. Die Veröffentlichung erstellt eine Zuordnung zwischen einem Port auf dem Host-Rechner und einem Port im Container. Wenn du einen Port veröffentlichst, konfiguriert Docker das Netzwerk des Hosts so, dass der Datenverkehr vom angegebenen Host-Port an den entsprechenden Container-Port weitergeleitet wird.

Hier erfährst du, wann du welche Methode anwenden solltest:

• verwenden. expose wenn du Images erstellst, die von anderen Docker-Nutzern verwendet werden sollen, um zu dokumentieren, welche Ports deine Anwendung verwendet.
• Verwende veröffentlichen wenn du möchtest, dass externe Systeme (einschließlich des Hosts) auf Dienste zugreifen können, die in deinem Container laufen.
• Verwende beide zusammen für eine vollständige Dokumentation und Funktionalität, besonders in Produktionsumgebungen.

Wie man Docker Ports freilegt

Nachdem wir nun die Konzepte verstanden haben, wollen wir uns die praktischen Aspekte der Freigabe von Docker-Ports in verschiedenen Kontexten ansehen.

Strategien für Dockerfile-Deklarationen

Die einfachste Art, einen Port freizugeben, ist die Anweisung EXPOSE in deinem Dockerfile. Hier werden die Ports angegeben, die der Container verwenden soll.

FROM my-image:latest
EXPOSE 80
EXPOSE 443

In diesem Beispiel habe ich angegeben, dass der Container die Ports 80 und 443 verwenden soll, die standardmäßig für HTTP- (Hypertext Transfer Protocol) und HTTPS- (Hypertext Transfer Protocol Secure) Datenverkehr verwendet werden. Du kannst sie auch zu einer einzigen Anweisung kombinieren:

EXPOSE 80 443

Wenn du Ports angibst, solltest du auch das Protokoll angeben: TCP (Transmission Control Protocol) oder UDP (User Datagram Protocol), wenn deine Anwendung ein bestimmtes Protokoll verwendet:

EXPOSE 53/udp
EXPOSE 80/tcp

Wenn kein Protokoll angegeben wird, wird standardmäßig TCP angenommen. Dies ist für die meisten Webanwendungen geeignet, aber Dienste wie DNS (Domain Name System) oder Spieleserver benötigen oft UDP.

Aus der Sicherheitsperspektive empfehle ich, nur die Ports freizugeben, die deine Anwendung tatsächlich benötigt. Jeder freiliegende Port stellt einen potenziellen Angriffsvektor dar, daher folgt die Minimierung der Anzahl der freiliegenden Ports dem Prinzip der geringsten Privilegien.

Verwaltung der Runtime Ports

Während die Anweisung EXPOSE dokumentiert, welche Ports ein Container verwendet, musst du diese Ports beim Ausführen des Containers veröffentlichen, um sie für den Host oder andere Maschinen zugänglich zu machen.

Hier erfährst du, wie du einen Container-Port explizit an einen bestimmten Host-Port binden kannst:

docker run -p 8081:80 my-image

Mit dem -p (oder --publish) Flag kannst du einen einzelnen Port oder einen Bereich von Ports im Container an den Host binden.

Dieser Befehl ordnet Port 80 innerhalb des Containers dem Port 8081 auf dem Host zu. Nachdem du diesen Befehl ausgeführt hast, kannst du auf den Webserver zugreifen, indem du in deinem Browser zu http://localhost:8081 navigierst.

Um die Entwicklung zu vereinfachen, bietet Docker das -P, capital P oder --publish-all Flag, das automatisch alle exponierten Ports auf zufälligen, hoch nummerierten Ports des Hosts veröffentlicht:

docker run -P my-image

Um herauszufinden, welche Host-Ports zugewiesen wurden, kann ich den Befehl docker ps verwenden:

docker ps

Dies führt zu einer Ausgabe wie:

CONTAINER ID   IMAGE  COMMAND    CREATED  STATUS  PORTS                                  NAMES
a7c53d9413bf   image  "/docker-.…"  10 s ago   Up 9 s    0.0.0.0:49153->80/tcp, :::49153->80/tcp   wizardl

Hier wird Port 80 innerhalb des Containers auf Port 49153 auf dem Host abgebildet.

Wenn du mit Diensten arbeitest, die sowohl TCP als auch UDP auf demselben Port verwenden (wie DNS-Server), musst du bei der Veröffentlichung das Protokoll angeben:

docker run -p 53:53/tcp -p 53:53/udp dns-server

Docker Compose Orchestrierung

Für Anwendungen mit mehreren Containern bietet Docker Compose eine einfachere Möglichkeit, Netzwerke und Ports zu konfigurieren.

In einer Docker Compose YAML-Datei kannst du für jeden Dienst Port-Zuordnungen unter dem Schlüssel ports angeben:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
      - "443:443"
  api:
    build: ./api
    ports:
      - "3000:3000"

Docker Compose macht einen wichtigen Unterschied zwischen ports und expose. Der Abschnitt ports erstellt veröffentlichte Port-Zuordnungen, die von außen zugänglich sind, während expose die Ports nur für verknüpfte Dienste innerhalb desselben Compose-Netzwerks verfügbar macht:

services:
  web:
    image: my-image
    ports:
      - "8081:80"
  database:
    image: postgres
    expose:
      - "5432"

In diesem Beispiel ist der Dienst web vom Host über Port 8081 erreichbar, aber die PostgreSQL-Datenbank ist nur für andere Dienste innerhalb der Compose-Datei zugänglich, nicht direkt vom Host.

Für flexible Konfigurationen, insbesondere in verschiedenen Umgebungen, kann ich Umgebungsvariablen in den Port-Zuordnungen verwenden:

services:
  web:
    image: my-image
    ports:
      - "${WEB_PORT:-8081}:80"

Mit dieser Syntax kann ich den Host-Port über eine Umgebungsvariable (WEB_PORT) angeben, die standardmäßig auf 8081 gesetzt wird, wenn sie nicht gesetzt ist.

Docker Ports freigeben - Praktisches Beispiel

Lass uns ein komplettes Beispiel für die Freigabe von Docker-Ports für eine Webanwendung mit einem Datenbank-Backend durchgehen.

Stell dir vor, wir bauen eine einfache Webanwendung, die aus einem Python Flask API Service und einer PostgreSQL Datenbank besteht. Der API-Dienst lauscht auf Port 5000, und PostgreSQL verwendet seinen Standardport 5432.

So könnte unsere einfache Flask-Anwendung (app.py) aussehen. Diese Anwendung erstellt eine Datenbank myapp und holt die Daten aus der Tabelle items, sobald diese Tabelle in der Datenbank erstellt ist.

from flask import Flask, jsonify
import os
import psycopg2

app = Flask(__name__)

# Database connection parameters from environment variables
DB_HOST = os.environ.get('DB_HOST', 'db')
DB_NAME = os.environ.get('DB_NAME', 'myapp')
DB_USER = os.environ.get('DB_USER', 'postgres')
DB_PASS = os.environ.get('DB_PASSWORD', 'postgres')

@app.route('/')
def index():
    return jsonify({'message': 'API is running'})

@app.route('/items')
def get_items():
    # Connect to the PostgreSQL database
    conn = psycopg2.connect(
        host=DB_HOST,
        database=DB_NAME,
        user=DB_USER,
        password=DB_PASS
    )
    
    # Create a cursor and execute a query
    cur = conn.cursor()
    cur.execute('SELECT id, name FROM items')
    
    # Fetch results and format as list of dictionaries
    items = [{'id': row[0], 'name': row[1]} for row in cur.fetchall()]
    
    # Close connections
    cur.close()
    conn.close()
    
    return jsonify(items)

if __name__ == '__main__':
    # Run the Flask app, binding to all interfaces (important for Docker)
    app.run(host='0.0.0.0', port=5000)

Als Nächstes werde ich unsere requirements.txt Datei erstellen:

flask
psycopg2-binary

Jetzt muss ich eine Dockerdatei für unseren Python-API-Dienst erstellen:

FROM python:3.9-slim
WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Expose the port Flask runs on
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]

Zum Schluss werde ich eine Docker Compose-Datei erstellen, um beide Dienste zu orchestrieren:

services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
      tags:
        - "my-custom-image:latest"
    container_name: my-custom-api
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=db
      - DB_NAME=myapp
      - DB_USER=postgres
      - DB_PASSWORD=postgres
    depends_on:
      - db
  
  db:
    container_name: my-custom-db
    image: postgres:13
    expose:
      - "5432"
    environment:
      - POSTGRES_DB=myapp
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

In dieser Konfiguration:

1. Der API-Dienst wird aus unserem Dockerfile erstellt und über den Port 5000 veröffentlicht, sodass er vom Host-Rechner aus zugänglich ist.
2. Der PostgreSQL-Dienst stellt den Port 5432 zur Verfügung, veröffentlicht ihn aber nicht, so dass er nur für andere Dienste innerhalb des Compose-Netzwerks zugänglich ist.
3. Der API-Dienst kann auf die Datenbank mit dem Hostnamen db (das ist der Name des Dienstes) und dem Port 5432 zugreifen.

Um diese Anwendung auszuführen, verwende:

docker-compose up

Jetzt kann ich auf die API unter http://localhost:5000 zugreifen, aber die PostgreSQL-Instanz ist nicht direkt von außerhalb des Docker-Netzwerks zugänglich, was eine gute Sicherheitspraxis für Datenbankdienste ist. Du kannst aber aus dem laufenden Container auf PostgreSQL zugreifen:

docker compose exec db psql -U postgres -d myapp

Mit diesem Befehl rufe ich das PostgreSQL CLI auf, wo ich die Datenbank einsehen und eine Tabelle items erstellen kann. Einmal erstellt, kann ich die Daten in http://localhost:5000/items

Wie man mehrere Docker Ports freigibt

Wenn meine Python-Anwendung mehrere Ports zur Verfügung stellen muss, kann ich sie alle in der Dockerdatei angeben:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000 8081 9090
CMD ["python", "app.py"]

Dieses Dockerfile zeigt an:

• Port 5000 für die Hauptanwendung von Flask (derzeit aktiv)
• Port 8081 für ein mögliches Monitoring-Dashboard 
• Port 9090 für eine zukünftige Debugging-Schnittstelle

Es ist wichtig zu beachten, dass ich zwar die Ports 8081 und 9090 in der Dockerdatei als Dokumentation freigegeben habe, meine aktuelle Flask-Anwendung aber nur so konfiguriert ist, dass sie auf Port 5000 lauscht. Die zusätzlichen offenen Ports zeigen, wo zukünftige Funktionen implementiert werden könnten.

Wie man offene Ports veröffentlicht

Um Ports, die in einem Dockerfile offengelegt sind, zu veröffentlichen, verwende ich das -p oder -P Flag, wenn ich den Container starte:

docker run -p 8081:5000  my-custom-image

Dadurch wird der Port 5000 im Container (der im Dockerfile angegeben ist und auf dem Flask lauscht) dem Port 8081 auf dem Host zugeordnet. Nachdem ich diesen Befehl ausgeführt habe, kann ich auf meine Flask-Anwendung zugreifen, indem ich in meinem Browser zu http://localhost:8081 navigiere.

Ich kann auch das -P Flag verwenden, um automatisch alle exponierten Ports auf zufälligen Ports auf dem Host zu veröffentlichen:

docker run -P my-custom-image

Um zu prüfen, welche Ports veröffentlicht sind, kann ich verwenden:

docker ps

Für genauere Informationen kann ich verwenden:

docker port [container_id]

5000/tcp -> 0.0.0.0:32768
8081/tcp -> 0.0.0.0:32769
9090/tcp -> 0.0.0.0:32770

Dieser Befehl zeigt alle Port-Zuordnungen für einen bestimmten Container an. Wenn meine Flask-Anwendung zum Beispiel nur auf Port 5000 lauscht, ich aber mehrere Ports in der Dockerdatei freigegeben habe, zeigt mir Docker port genau, welche Host-Ports welchen Container-Ports zugeordnet sind. Wenn also Port 5000 auf 32768 gemappt wurde, kann ich auf meine Flask-Anwendung unter http://localhost:32768

Diagnose- und Fehlersuchtechniken

Auch bei sorgfältiger Konfiguration können Probleme mit der Docker-Port-Zuordnung auftreten. Hier sind einige Techniken, die ich verwende, um häufige Probleme zu diagnostizieren und zu lösen.

Überprüfung der Hafenkartierung

Der erste Schritt bei der Diagnose von Port-Problemen besteht darin, zu überprüfen, ob die Zuordnungen richtig eingerichtet sind. Ich benutze diese Befehle:

Listet alle laufenden Container mit Port-Zuordnungen auf:

docker ps

Erhalte detaillierte Informationen über einen bestimmten Container:

docker inspect [container_id]

Überprüfe die Port-Zuordnungen für einen bestimmten Container:

docker port [container_id]

Der Befehl docker inspect liefert detaillierte Informationen, einschließlich der Netzwerkeinstellungen. Um dich auf netzwerkbezogene Details zu konzentrieren, verwende:

docker inspect --format='{{json .NetworkSettings.Ports}}' [container_id] | jq

Wenn du den Datenverkehr genauer analysieren willst, können Tools wie tcpdump und netstat sehr nützlich sein. Vergewissere dich zunächst, dass sie im Inneren des Containers installiert sind. Wenn der Container diese Tools noch nicht enthält, kannst du sie mit dem folgenden Befehl installieren:

docker exec -u root -it f5c6cac71492 bash -c "apt-get update && apt-get install -y net-tools tcpdump"

Um zu sehen, auf welchen Ports die Anwendung innerhalb des Containers lauscht:

docker exec -it [container_id] netstat -tuln

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 0.0.0.0:5000            0.0.0.0:*               LISTEN
tcp        0      0 127.0.0.11:42265        0.0.0.0:*               LISTEN
udp        0      0 127.0.0.11:34267        0.0.0.0:*

Dies zeigt zum Beispiel, dass die Flask-App auf allen Schnittstellen auf Port 5000 lauscht.

Zur Überwachung des ein- und ausgehenden Datenverkehrs auf der Hauptnetzwerkschnittstelle des Containers (normalerweise eth0):

docker exec -it [container_id] tcpdump -i eth0

listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes

Mit diesem Befehl kannst du den Datenverkehr verfolgen und feststellen, ob die Anfragen den Container erreichen oder ob Pakete verworfen oder fehlgeleitet werden.

Iptables Regelanalyse

Docker nutzt iptables, um Network Address Translation (NAT) zu verwalten und den Datenverkehr zwischen dem Host und den Containern zu kontrollieren. Es fügt automatisch Regeln ein, um Host-Ports an die entsprechenden Container-IPs und -Ports weiterzuleiten und ermöglicht so einen nahtlosen Zugang zu containerisierten Diensten.

Auf nativen Linux-Hosts kannst du diese Regeln mit Befehlen wie dem folgenden überprüfen:

sudo iptables -t nat -L DOCKER -n -v

Dies zeigt, wie Docker eingehenden Datenverkehr auf bestimmten Host-Ports den Container-Endpunkten zuordnet. Basierend auf der Docker Compose-Datei von vorhin, siehst du die weitergeleiteten Ports:

Chain DOCKER (2 references)
 pkts bytes target     prot opt in     out     source               destination
   50  3000 RETURN     all  --  docker0 *       0.0.0.0/0            0.0.0.0/0
  100  6000 RETURN     all  --  br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0
  500 30000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:5000 to:172.18.0.2:5000
  400 24000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:8081 to:172.18.0.2:5000
  300 18000 DNAT       tcp  --  !br-xxxxxxx *       0.0.0.0/0            0.0.0.0/0            tcp dpt:9090 to:172.18.0.2:5000

Hier:

• DNAT Regeln leiten den Verkehr vom Host zum Container um.
• RETURN Regeln sorgen für die korrekte Weiterleitung des internen Docker-Netzwerkverkehrs.

Je nach Umgebung (z. B. Docker Desktop unter Windows oder WSL2) kann Docker die Portweiterleitung jedoch anders handhaben, und die Regeln von iptables sind möglicherweise nicht sichtbar oder können vom System aus geändert werden. In diesem Fall kannst du die Portweiterleitung mit dem folgenden Befehl überprüfen:

sudo ss -tulnp

Netid    State       Recv-Q      Send-Q            Local Address:Port         Peer Address:Port 
tcp        LISTEN     0                 4096                                          *:5000           	        *:*           
tcp        LISTEN     0                 4096                          		   *:8081                               *:*    
tcp        LISTEN     0                 4096                          		   *:9090                              *:*    

Tipps zur Fehlersuche:

• Bestätige die Port-Zuordnungen mit docker ps und docker port [container].
• Überprüfe, ob die Firewall oder Sicherheitssoftware des Hostsystems Ports blockiert.
• Nutze Container-Logs und Netzwerk-Tools wie netstat und tcpdump, um das Netzwerkverhalten deiner Anwendung zu überprüfen.

Fazit

Die Offenlegung von Docker-Ports ist eine grundlegende Fähigkeit, die die Lücke zwischen der Isolierung von Containern und der praktischen Nutzbarkeit schließt. In diesem Artikel habe ich erklärt, wie das Netzwerkmodell von Docker funktioniert, den Unterschied zwischen dem Freigeben und Veröffentlichen von Ports erläutert und praktische Beispiele für verschiedene Szenarien gegeben.

Behalte diese wichtigen Punkte im Hinterkopf:

• Verwende EXPOSE in Dockerfiles, um zu dokumentieren, welche Ports deine Anwendung verwendet
• Verwenden Sie -p oder -P, wenn Sie Container betreiben, um diese Ports von außen zugänglich zu machen.
• Nutzen Sie Docker Compose für die Verwaltung komplexer Multi-Container-Anwendungen
• Benutze Diagnosetools, um Probleme zu beheben, wenn sie auftreten

Wenn du diese Konzepte und Techniken beherrschst, kannst du robustere containerisierte Anwendungen entwickeln, die sowohl intern als auch mit der Außenwelt effektiv kommunizieren. Ganz gleich, ob du eine einfache Webanwendung oder eine komplexe Microservices-Architektur entwickelst, die richtige Portverwaltung ist entscheidend für den Erfolg.

Da Container weiterhin die modernen Strategien zur Anwendungsbereitstellung dominieren, wird die Fähigkeit, Docker-Netzwerke und Ports sicher zu verwalten, eine wesentliche Fähigkeit im Werkzeugkasten jedes Entwicklers bleiben.

Um weiter zu lernen, solltest du dir die folgenden Ressourcen ansehen:

• Wie man LLM-Anwendungen mit Docker einsetzt: Eine Schritt-für-Schritt-Anleitung
• Der vollständige Leitfaden zur Docker-Zertifizierung (DCA) für 2025
• Top 26 Docker Interview Fragen und Antworten für 2025 
• 10 Ideen für Docker-Projekte: Von Anfängern bis Fortgeschrittenen