Zum Inhalt springen
Prepaid-Hoster, vserver-mieten.net

AdministrationTutorial

Von außen nicht erreichbar: Docker, 127.0.0.1 und die Bind-Adresse

Ist ein Docker-Dienst von außen nicht erreichbar, lauscht er fast immer nur auf 127.0.0.1. Gesperrte Ports sind es bei uns nicht, alle Ports sind offen. Mit ss, docker ps und einem curl von außen findest du in fünf Minuten, an welcher der zwei Stellen es hängt.

Veröffentlicht
Lesezeit
4 Min. Lesezeit
Netzwerk-Switch mit gelben Patchkabeln im Rack
Bei uns sind alle Ports offen. Ob dein Dienst erreichbar ist, entscheidet die Bind-Adresse.
Inhalt
  1. Schritt 1: Worauf lauscht der Port?
  2. Schritt 2: Das Port-Mapping in Docker prüfen
  3. Schritt 3: Die Firewall im Gast
  4. Schritt 4: Von außen testen
  5. Weiterlesen in der Support-FAQ

Auf unseren vServern sind alle Ports offen, die Firewall des Systems steht nach der Installation auf „erlauben“. Wenn ein Dienst von außen nicht erreichbar ist, liegt es an einer von zwei Stellen: worauf der Dienst lauscht oder eine Firewall, die du selbst eingerichtet hast. Beides findest du mit vier Schritten.

Die Beispiele unten nutzen drei Container mit nginx: einen, der nur lokal veröffentlicht ist, einen öffentlichen und einen, bei dem der Dienst im Container selbst nur auf localhost lauscht. Die IP 62.68.75.69 steht für deinen Server.

Schritt 1: Worauf lauscht der Port?

Shell
ss -tlnp | grep docker-proxy
LISTEN 0      4096         0.0.0.0:8081       0.0.0.0:*    users:(("docker-proxy",pid=1218,fd=9))
LISTEN 0      4096       127.0.0.1:8080       0.0.0.0:*    users:(("docker-proxy",pid=1133,fd=9))

Die vierte Spalte ist entscheidend:

  • 0.0.0.0:8081 lauscht auf allen IPv4-Adressen des Servers. Von außen erreichbar.
  • 127.0.0.1:8080 lauscht nur auf localhost. Vom Server selbst erreichbar, von außen nie.
  • [::]:8081 wäre dasselbe wie 0.0.0.0 für IPv6.

Ohne grep siehst du alle Dienste, auch die ohne Docker. Für eine Datenbank, ein Node-Backend oder einen Gameserver gilt dieselbe Regel.

Schritt 2: Das Port-Mapping in Docker prüfen

Shell
docker ps --format 'table {{.Names}}\t{{.Ports}}'
NAMES     PORTS
public    0.0.0.0:8081->80/tcp
local     127.0.0.1:8080->80/tcp

Ob ein Port lokal oder öffentlich landet, entscheidet die Angabe beim Start:

docker-compose.ymlYAML
services:
  local:
    image: nginx:alpine
    ports:
      - "127.0.0.1:8080:80"   # nur vom Server selbst erreichbar
  public:
    image: nginx:alpine
    ports:
      - "8081:80"             # auf allen Adressen, also von außen erreichbar

Die Variante mit 127.0.0.1 ist kein Fehler, sondern oft Absicht: Für Dienste hinter einem Reverse Proxy wie nginx, Caddy oder Traefik ist sie genau richtig. Docker empfiehlt sie selbst für alles, was nicht direkt ins Netz soll. Stammt deine Compose-Datei aus einer Anleitung, prüf diese Zeile zuerst.

Der Sonderfall: localhost im Container

Manchmal stimmt das Mapping, und es geht trotzdem nicht. Dann lauscht der Dienst im Container nur auf 127.0.0.1. Viele Entwicklungsserver machen das standardmäßig, etwa Flask, Vite oder npm run dev.

Shell
docker port inner
80/tcp -> 0.0.0.0:8082
curl http://127.0.0.1:8082/
curl: (56) Recv failure: Connection reset by peer
docker exec inner netstat -tln
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 127.0.0.1:80            0.0.0.0:*               LISTEN

Das Erkennungszeichen ist das „Connection reset by peer“ auf dem Server selbst. Docker nimmt die Verbindung an, findet im Container aber niemanden, der auf der Container-Adresse lauscht. Von außen siehst du dagegen nur „Couldn’t connect to server“, genau wie bei einem falschen Mapping. Deshalb lohnt der Test auf dem Server. Die Lösung liegt in der Konfiguration des Dienstes: Er muss auf 0.0.0.0 lauschen, zum Beispiel mit --host 0.0.0.0 beim Start.

Schritt 3: Die Firewall im Gast

Wenn du selbst eine Firewall eingerichtet hast, gibt es eine Überraschung, die viele erst bemerken, wenn es zu spät ist: Docker umgeht ufw. Docker leitet veröffentlichte Ports weiter, bevor die Regeln von ufw greifen. Die Docker-Dokumentation nennt beide schlicht „inkompatibel“.

Wir haben es nachgestellt. ufw ist aktiv, eingehend ist alles außer SSH verboten:

Shell
ufw status
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere

Ein Python-Webserver ohne Docker auf Port 9000 ist von außen nicht erreichbar, so wie es sein soll. Der Docker-Container auf Port 8081 antwortet trotzdem:

Shell
curl -sS -m 3 -o /dev/null -w '%{http_code}\n' http://62.68.75.69:9000/
curl: (28) Connection timed out after 3002 milliseconds
000
curl -sS -m 3 -o /dev/null -w '%{http_code}\n' http://62.68.75.69:8081/
200

Für unser Thema heißt das: Ist dein Docker-Port nicht erreichbar, ist ufw fast nie der Grund. Andersherum ist es gefährlicher. Wer glaubt, ufw schütze seine Datenbank, und sie mit -p 5432:5432 startet, hat sie offen ins Netz gestellt.

Willst du einen veröffentlichten Port wirklich von außen sperren, hast du zwei Wege:

  1. An 127.0.0.1 binden wie in Schritt 2. Das ist der einfachste und sicherste Weg.
  2. Eine Regel in der Kette DOCKER-USER. Docker wertet sie vor den eigenen Regeln aus. Weil Docker die Zieladresse vorher umschreibt, filterst du auf den ursprünglichen Port:
Shell
iptables -I DOCKER-USER -i eth0 -p tcp -m conntrack --ctorigdstport 8081 -j DROP

eth0 ersetzt du durch dein öffentliches Interface aus ip -br link. Die Regel ist nach einem Neustart weg, für dauerhafte Regeln brauchst du iptables-persistent oder deine eigene Firewall-Konfiguration.

Schritt 4: Von außen testen

Ein Test vom Server selbst sagt nichts darüber, ob der Port von außen erreichbar ist. Teste deshalb von deinem eigenen Rechner:

Shell
curl -sS -m 3 -o /dev/null -w '%{http_code}\n' http://62.68.75.69:8081/
200
curl -sS -m 3 -o /dev/null -w '%{http_code}\n' http://62.68.75.69:8080/
curl: (7) Failed to connect to 62.68.75.69 port 8080 after 0 ms: Couldn't connect to server
000

So liest du das Ergebnis:

Meldung von außen Bedeutung Wo du suchst
200 oder eine andere HTTP-Antwort Port erreichbar Fertig
Couldn't connect to server Niemand nimmt die Verbindung auf der öffentlichen Adresse an Schritt 1 und 2: Mapping auf 127.0.0.1 oder localhost im Container
Connection timed out Pakete werden verworfen Schritt 3, deine Firewall

Für Dienste ohne HTTP nimmst du nc -vz 62.68.75.69 8081 statt curl.

Weiterlesen in der Support-FAQ

Sind alle Ports freigegeben?Ja, auf Linux steht die Firewall auf erlauben. Bei Windows gibst du Ports selbst frei. Kann ich Docker auf meinem vServer benutzen?Docker läuft auf allen KVM-Servern ohne Einschränkung. Wie sichere ich meinen Linux-Server ab?Die Grundlagen, bevor du Dienste ins Netz stellst.

Fehler gefunden oder anderer Meinung? Schreib uns über das Kontaktformular oder auf Discord.

Belege und Quellen

Jede Aussage mit einer kleinen Nummer ist hier belegt: mit Art der Quelle, Link und Prüfdatum. Betreiberaussagen sind als solche gekennzeichnet.

Alle 3 Aussagen dieser Seite sind belegt, mit Quelle, Link und Prüfdatum.

  1. 1

    Auf den Linux-vServern sind alle Ports offen, die Software-Firewall steht standardmäßig auf erlauben. Bei Windows gibst du Ports in der Windows-Firewall selbst frei.

    Support-FAQ, geprüft am 14.10.2026

  2. 2

    Veröffentlichte Ports sind bei Docker standardmäßig auf allen Adressen erreichbar. Mit 127.0.0.1 vor dem Port (-p 127.0.0.1:8080:80) bleibt er auf den Server beschränkt.

    Herstellerangabe, geprüft am 14.10.2026

  3. 3

    Docker und ufw sind laut Docker-Dokumentation inkompatibel: Veröffentlichte Ports werden weitergeleitet, bevor die Regeln von ufw greifen. Eigene Filter gehören in die Kette DOCKER-USER.

    Nachgestellt am 14.10.2026 mit Docker Engine 29.8.2 und ufw 0.36.2 auf Ubuntu 24.04.

    Herstellerangabe, geprüft am 14.10.2026

Erst die Bind-Adresse, dann die Firewall

Die meisten „gesperrten Ports“ sind ein Dienst, der nur auf localhost lauscht. Der Rest ist meistens eine Firewall, die du selbst gesetzt hast.