# Netcup /64 IPv6, Docker Dual-Stack & Firewall-Härtung (inkl. Nur-IPv6 DNS64/NAT64)

> Netcup /64-IPv6 unter Debian 12 sauber einrichten, Docker Dual-Stack aktivieren, die UFW-Bypass-Falle per SCP-Firewall schließen & Nur-IPv6 per NAT64 nutzen.

- Canonical URL: https://euserverlab.com/de/guides/docker-ipv6-ufw-firewall-netcup-setup-guide/
- Language: de
- Published: 2026-11-13 | Updated: 2026-11-22
- Publisher: EUServerLab (https://euserverlab.com/de/methodology/)

## Wichtigste Erkenntnisse (Kurzfassung)
- Jeder Netcup Root-Server und VPS erhält ein eigenes /64-IPv6-Subnetz über das Link-Local-Gateway fe80::1 – vergeben Sie ::1/64 statisch auf ens3 für reproduzierbares Routing.
- Vorsicht UFW-Falle: Ein Docker-Mapping wie -p 5432:5432 umgeht UFW-INPUT-Regeln per Kernel-DNAT. Binden Sie Datenbanken strikt an 127.0.0.1:5432:5432 und nutzen Sie zusätzlich die vorgelagerte Netcup SCP-Firewall.
- Ab Docker Engine 26/27 sorgt ip6tables: true zusammen mit einem internen ULA-Netz (fd00:...::/80) für sauberes ausgehendes Container-IPv6 ohne ungewollte Portfreigaben.
- Wer im Checkout den Nur-IPv6-Sparmodus (-0,60 €/Mo brutto / -0,50 € netto) wählt, erreicht IPv4-Ziele wie GitHub problemlos über europäische DNS64/NAT64-Resolver.

## Schritt-für-Schritt-Checkliste
1. **Statische /64-IPv6-Adresse & fe80::1-Gateway auf ens3 prüfen**: Prüfen Sie in /etc/network/interfaces Ihr im SCP hinterlegtes /64-Präfix mit Gateway fe80::1 und testen Sie die Verbindung per ping6 -c 3 2606:4700:4700::1111.
2. **Docker IPv6 & ip6tables in /etc/docker/daemon.json aktivieren**: Aktivieren Sie ipv6: true und ip6tables: true mit einem internen ULA-Subnetz (fd00:...), damit Container ausgehend IPv6 nutzen, ohne direkt exponiert zu sein.
3. **Ports auf 127.0.0.1 binden & SCP-Firewall als äußeren Schutzring setzen**: Exponieren Sie Datenbanken niemals auf 0.0.0.0 und setzen Sie im Netcup SCP -> Firewall eine strikte Positivliste (TCP 22/80/443, UDP 443, Rest DROP).

---

Zwei Konfigurationsfehler sorgen auf Linux-Servern regelmäßig für Sicherheitslücken oder Verbindungsabbrüche: **Docker-Container, die lokale `ufw`-Regeln unbemerkt umgehen**, sowie **fehlerhaftes `/64`-IPv6-Routing** – besonders dann, wenn Sie den **Nur-IPv6-Sparmodus (`-0,60 €/Monat inkl. MwSt.`)** nutzen, den Sie auch in unserem [TCO-Rechner](/de/tools/calculator/) gegenrechnen können.

## 1. Sauberes `/64`-IPv6-Host-Setup (`fe80::1` Link-Local-Gateway)

Netcup weist jedem Tarif unter **SCP → Netzwerk** ein festes `/64`-IPv6-Subnetz zu, das über das Link-Local-Gateway `fe80::1` geroutet wird. Unter Debian 12 vergeben Sie `::1/64` statisch auf `ens3`:

```ini
# /etc/network/interfaces (2a03:4000:60:abcd::/64 durch Ihr eigenes SCP-Präfix ersetzen)
iface ens3 inet6 static
    address 2a03:4000:60:abcd::1/64
    gateway fe80::1
    dns-nameservers 2606:4700:4700::1111 2620:fe::fe
```

Prüfen Sie das Routing direkt mit `ip -6 route show default` und `curl -6 -I https://cloudflare.com`.

## 2. Docker Dual-Stack sicher mit `ip6tables` & ULA-NAT betreiben

Ohne `ip6tables: true` können Container-Ports über IPv6 ungeschützt erreichbar werden. Mit einem internen ULA-Präfix (`fd00:...::/80`) in `/etc/docker/daemon.json` ab Docker Engine 26/27 erhalten Container vollen ausgehenden IPv6-Zugang über die Host-IP, bleiben eingehend aber standardmäßig abgeschirmt:

```json
{
  "ipv6": true,
  "ip6tables": true,
  "experimental": false,
  "fixed-cidr-v6": "fd00:dead:beef:1::/80",
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "20m",
    "max-file": "3"
  }
}
```

## 3. Die Docker-`UFW`-Bypass-Falle dauerhaft schließen (3-Stufen-Schutz)

Sobald eine `docker-compose.yml` ein Mapping wie `ports: ["5432:5432"]` enthält, trägt Docker eine `DNAT`-Weiterleitung vor der `UFW-INPUT`-Kette ein – Ihre Datenbank steht damit trotz aktivierter `ufw` offen im Netz. Mit dieser dreistufigen Absicherung schließen Sie das Risiko vollständig aus:

| Schutzebene | Konkrete Einstellung | Schutzwirkung |
| :--- | :--- | :--- |
| **1. Loopback-Binding in Compose** | Immer `127.0.0.1:5432:5432` schreiben (oder `ports:` ganz weglassen) | Port lauscht ausschließlich lokal auf dem Host |
| **2. Lokale `DOCKER-USER`-Regel** | Eingehende `FORWARD`-Pakete auf `ens3` außer `80/443` verwerfen | Verhindert versehentliche `-p 8080:8080`-Freigaben im Gast-OS |
| **3. Äußere Netcup SCP-Firewall** | **SCP → Netzwerk → Firewall**: Nur `TCP 22, 80, 443` & `UDP 443` `ACCEPT`, Rest **`DROP`** | **Hypervisor-Schutzschild**: Blockiert Scans bereits außerhalb Ihrer VM. |

Kontrollieren Sie offene Sockets anschließend mit `ss -tulnp`.

## 4. Nur-IPv6-Sparmodus (`-0,60 €/Mo`): DNS64 / NAT64

Wenn Sie im Netcup-Konfigurator die öffentliche IPv4 abwählen (`-0,60 €/Mo` brutto / `-0,50 €` netto), startet der [VPS pico G11.5s](/de/models/vps-pico-g11-5s/) bereits bei **`1,61 €/Monat inkl. 19 % MwSt.`** (`1,35 €` netto bei 12M; ohne Gutschein, da vServer Lite und VPS ARM sämtliche Gutscheine sperren), der [VPS 500 G12.5](/de/models/vps-500-g12-5/) sinkt für Neukunden mit `#5e` (`-5,95 €` brutto / `-5,00 €` netto) im 1. Jahr auf **`7,16 €/Monat` brutto** (`6,02 €` netto), und bei jedem [Root-Server](/de/root-server/) oder [VPS](/de/vps/) sparen Sie dauerhaft `7,20 €/Jahr` brutto. Da Dienste wie `github.com` teils noch reine IPv4-`A`-Records nutzen, binden Sie europäische **DNS64/NAT64-Resolver** ein, damit `git clone` und `apt` direkt funktionieren:

```bash
# Europäische DNS64/NAT64-Resolver für reine IPv6-Server aktivieren
sudo mkdir -p /etc/systemd/resolved.conf.d
cat <<'EOF' | sudo tee /etc/systemd/resolved.conf.d/nat64.conf
[Resolve]
DNS=2a00:1098:2b::1 2a00:1098:2c::1 2a01:4f8:c2c:123f::1
FallbackDNS=2606:4700:4700::64 2606:4700:4700::6400
EOF
sudo systemctl restart systemd-resolved

# Funktionstest zu GitHub (IPv4-Ziel über synthetisiertes NAT64)
curl -I https://github.com
```

Für öffentliche Websites setzen Sie einfach einen `AAAA`-Eintrag hinter dem kostenlosen **Cloudflare-Proxy** – Besucher mit reinem IPv4-Anschluss erreichen Ihre Seite dann verzögerungsfrei über das Dual-Stack-Edge-Netz von Cloudflare.

## Häufig gestellte Fragen (FAQ)

### Warum ist mein PostgreSQL- oder Redis-Container trotz aktiver UFW öffentlich erreichbar?

Veröffentlichen Sie einen Port auf 0.0.0.0 (z. B. -p 5432:5432), schreibt Docker eigene DNAT-Regeln in die PREROUTING-/FORWARD-Ketten, die vor den normalen UFW-INPUT-Regeln greifen. Binden Sie interne Dienste daher immer an 127.0.0.1:5432:5432 und blockieren Sie alle nicht benötigten Ports zusätzlich außen in der Netcup SCP-Firewall.

### Welches IPv6-Standardgateway nutzt Netcup in Nürnberg, Wien und Amsterdam?

Auf allen G12.5- und G11.5s-KVM-Systemen routet Netcup Ihr zugewiesenes /64-IPv6-Präfix einheitlich über das Link-Local-Gateway fe80::1 auf dem primären Interface (ens3 / eth0).

### Wie erreiche ich GitHub auf einem reinen IPv6-Server (-0,60 €/Mo Sparoption)?

Hinterlegen Sie europäische DNS64/NAT64-Nameserver (z. B. nat64.net 2a00:1098:2b::1 und 2a00:1098:2c::1) in systemd-resolved für ausgehende Verbindungen zu reinen IPv4-Hosts, und schalten Sie für eingehende Webbesucher Cloudflare (kostenloser Dual-Stack-Proxy auf Ihren AAAA-Eintrag) davor.

---
Source: EUServerLab (https://euserverlab.com/de/guides/docker-ipv6-ufw-firewall-netcup-setup-guide/) | Open Telemetry Dataset: https://euserverlab.com/benchmarks/vps-500-g12-5.json
