# Coolify v4 & Dokploy auf Netcup RS 1000 G12.5 (18,11 €/Mo): Debian-Setup, Firewall & OOM-Schutz

> Coolify v4 & Dokploy auf Netcup RS 1000 G12.5 (18,11 €/Mo inkl. MwSt.): Swap/BBR, Docker daemon.json, SCP-Firewall, Build-Limits & R2-Backups.

- Canonical URL: https://euserverlab.com/de/guides/coolify-dokploy-self-hosting-netcup-guide/
- Language: de
- Published: 2026-11-04 | Updated: 2026-11-22
- Publisher: EUServerLab (https://euserverlab.com/de/methodology/)

## Wichtigste Erkenntnisse (Kurzfassung)
- Parallele Next.js-, TypeScript- und Rust-Builds lasten Shared-vCPUs voll aus und bremsen Live-Datenbanken. Der Netcup RS 1000 G12.5 liefert 4 dedizierte AMD EPYC 9645/9655 (Zen 5) Kerne, 8 GB DDR5 ECC und 128 GB NVMe-RAID (6,87 GB/s) für effektiv 18,11 €/Mo inkl. 19 % MwSt. (15,22 € netto) im 1. Jahr mit #rs1.
- Richten Sie vor dem Coolify- oder Dokploy-Installer 4 GB Swap (vm.swappiness=10), TCP BBR sowie /etc/docker/daemon.json mit Log-Rotation (20m x 3) und eigenem 172.80.0.0/16-Adresspool ein.
- Härten Sie die Netcup SCP-Firewall direkt nach der HTTPS-Anbindung: Öffentlich nur TCP 80 und TCP/UDP 443 freigeben, SSH auf WireGuard/Tailscale begrenzen und die Roh-Ports 8000, 3000, 6001 sowie 6002 verwerfen.
- Deckeln Sie Container-Builds per --cpus=2.5 --memory=4g und NODE_OPTIONS=--max-old-space-size=3072 gegen Exit-137-OOM-Abbrüche und sichern Sie PostgreSQL nächtlich per pg_dump | zstd | rclone über den 2,5-Gbit/s-Fair-Use-Port in EU/USA (>3 TB/24h -> 300 Mbit/s; Singapur 1 Gbit/s mit 2 TB/Monat).

## Schritt-für-Schritt-Checkliste
1. **Debian 12 mit Swap, BBR & Docker daemon.json vorbereiten**: 4 GB /swapfile mit vm.swappiness=10 anlegen, TCP BBR aktivieren und /etc/docker/daemon.json mit 20m x 3 Log-Limit sowie 172.80.0.0/16 Subnetz-Pool vorab speichern.
2. **Coolify v4 oder Dokploy installieren & Wildcard-DNS setzen**: Offizielles Installationsskript auf sauberem Debian 12 ausführen und A- sowie AAAA-Einträge für deploy.example.com und *.apps.example.com auf die Netcup-IPs zeigen lassen.
3. **Netcup SCP-Firewall abdichten**: Öffentlich ausschließlich TCP 80 und TCP/UDP 443 öffnen, SSH an WireGuard/Tailscale binden und die Setup-/Realtime-Ports 8000, 3000, 6001 und 6002 sperren.
4. **Build-Limits & nächtliches R2-/Storage-Box-Backup einrichten**: Builds mit --cpus=2.5 --memory=4g und NODE_OPTIONS=--max-old-space-size=3072 begrenzen, vor Updates 0-€-SCP-Snapshots ziehen und pg_dump | zstd | rclone per Cron ausführen.

---

Engpässe beim Self-Hosting von **Coolify v4** oder **Dokploy** entstehen selten im Leerlauf, sondern während `git push`: Parallele Läufe von `pnpm build`, TypeScript-Prüfung und `zstd`-Image-Komprimierung konkurrieren auf demselben Kernel mit Traefik und PostgreSQL. Der [Netcup RS 1000 G12.5](/de/models/rs-1000-g12-5/) für effektiv **18,11 €/Mo inkl. 19 % MwSt.** (`15,22 € netto` im 1. Jahr mit `#rs1`) trennt diese Last über **4 dedizierte AMD EPYC 9645/9655 (Zen 5) Threads**, `8 GB` DDR5 ECC RAM, `6,87 GB/s` NVMe-RAID (`115,87 µs` 4K-Q1T1-Schreiblatenz) und einen `2,5-Gbit/s`-Fair-Use-Port in EU/USA (`>3 TB/24h` → `300 Mbit/s`; Singapur `1 Gbit/s` mit `2 TB/Mo`) sauber auf (Hinweise zur B2B-/Export-Abrechnung im [USt-/Reverse-Charge-Guide](/de/guides/vat-free-registration-guide/) und zur Kündigungsfrist von einem Monat zum Monatsende bzw. Laufzeitende im [CCP-Vertragsleitfaden](/de/guides/contract-and-cancellation-guide/)).

## 1. Debian-12-Vorbereitung: Swap, BBR & `/etc/docker/daemon.json`

Führen Sie diese Schritte auf einem frischen Netcup **Debian 12 (Bookworm)** Image *vor* dem Start des Coolify- oder Dokploy-Installers aus, damit die Docker-Engine Log-Rotation und konfliktfreie Bridge-Netze direkt beim ersten Start übernimmt:

```bash
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y curl git jq zstd rclone ca-certificates

# 1. 4 GB NVMe-Swap als Sicherheitsnetz gegen kurzzeitige Bundler-Spitzen anlegen
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

# 2. Aktive Prozesse im DDR5-ECC-RAM halten (swappiness=10) & TCP BBR aktivieren
cat <<'EOF' | sudo tee /etc/sysctl.d/99-paas-host.conf
vm.swappiness=10
vm.vfs_cache_pressure=50
net.core.default_qdisc=fq
net.ipv4.tcp_congestion_control=bbr
EOF
sudo sysctl --system
```

Legen Sie anschließend `/etc/docker/daemon.json` an. Das Limit von `20m × 3` verhindert, dass Container-Logs das `128 GB` NVMe-Volume unbemerkt füllen; `live-restore` hält Produktivcontainer bei Docker-Daemon-Updates am Laufen, und der Pool `172.80.0.0/16` vermeidet Subnetz-Konflikte mit Tailscale (`100.64.0.0/10`) oder internen WireGuard-Routen (`10.0.0.0/8`):

```bash
sudo mkdir -p /etc/docker
cat <<'EOF' | sudo tee /etc/docker/daemon.json
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "20m",
    "max-file": "3"
  },
  "live-restore": true,
  "default-address-pools": [
    {
      "base": "172.80.0.0/16",
      "size": 24
    }
  ]
}
EOF
```

*Hinweis: Falls Sie **Dokploy** installieren (nutzt nativ den Docker-Swarm-Modus), lassen Sie die Zeile `"live-restore": true` weg, da Docker `live-restore` und Swarm nicht gleichzeitig zulässt.*

## 2. Coolify v4 vs. Dokploy: Offizielle Installation & Architekturvergleich

Installieren Sie **entweder** Coolify v4 **oder** Dokploy auf einem sauberen Host – niemals beide Panels parallel auf derselben VM, da beide Port `80/443` und eigene Overlay-/Bridge-Netze verwalten:

```bash
# Option A: Offizieller Coolify v4 Installer (Erstkonfiguration auf TCP 8000)
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

# Option B: Offizieller Dokploy Installer (aktiviert Swarm & öffnet Setup auf TCP 3000)
curl -sSL https://dokploy.com/install.sh | sh
```

| Technisches Kriterium | Coolify v4 | Dokploy |
| :--- | :--- | :--- |
| **Control-Plane Leerlauf-RAM** | `~580–700 MB` (Laravel/FrankenPHP + Postgres + Redis + Soketi) | `~280–380 MB` (Node.js/Next + Postgres + Redis) |
| **Orchestrierung & Proxy** | Klassische Docker Engine + **Traefik** oder **Caddy** | **Docker Swarm** (Single-/Multi-Node) + **Traefik** |
| **Setup- & Realtime-Ports** | `TCP 8000` UI + `TCP 6001/6002` (Soketi WebSockets & Terminal) | `TCP 3000` UI (Realtime läuft über Hauptport/Proxy) |
| **Multi-Server & Build-Worker** | Dedizierte **Build-Server-Rolle** per SSH + Remote-Docker-Hosts | Swarm-Worker-Nodes + Remote-SSH-Deployments |
| **Empfohlener Netcup-Tarif** | [RS 1000 G12.5](/de/models/rs-1000-g12-5/) (`18,11 €/Mo`) oder `VPS 500` UI + [RS 2000](/de/models/rs-2000-g12-5/) | [VPS 500 G12.5](/de/models/vps-500-g12-5/) (`7,76 €/Mo` 1. J. m. `#5e` Neu, regulär `8,26 €`) für leichte Stacks; `RS 1000` bei CI-Builds |

## 3. Dual-Stack Wildcard-DNS & Netcup SCP-Firewall-Regelwerk

Hinterlegen Sie einmalig Wildcard-DNS-Einträge, damit jede neue App- oder Preview-Subdomain (`api.apps.example.com`, `umami.apps.example.com`) automatisch Let's-Encrypt-Zertifikate bezieht:

```text
deploy.example.com       300  IN  A      203.0.113.42
deploy.example.com       300  IN  AAAA   2a03:4000:60:1234::1
*.apps.example.com       300  IN  A      203.0.113.42
*.apps.example.com       300  IN  AAAA   2a03:4000:60:1234::1
```

Binden Sie `https://deploy.example.com` in Coolify (`Settings → Instance's Domain`) bzw. Dokploy (`Settings → Web Server`) ein, prüfen Sie den HTTPS-Login und setzen Sie das Regelwerk direkt in **Netcup SCP → Firewall** auf Hypervisor-Ebene um (wichtig, da Docker lokale `ufw`-Regeln über die `DOCKER-USER`-Chain umgeht):

| Richtung | Protokoll & Port | Quelle | Aktion | Technischer Grund |
| :--- | :--- | :--- | :--- | :--- |
| Eingehend | `TCP 80` | `0.0.0.0/0`, `::/0` | `ACCEPT` | HTTP-auf-HTTPS-Redirect & ACME HTTP-01 Challenge |
| Eingehend | `TCP 443` & `UDP 443` | `0.0.0.0/0`, `::/0` | `ACCEPT` | TLS 1.3 & HTTP/3 QUIC auf Traefik/Caddy |
| Eingehend | `UDP 51820` / `UDP 41641` | `0.0.0.0/0`, `::/0` | `ACCEPT` | Direkter WireGuard- oder Tailscale-Tunnel |
| Eingehend | `TCP 22` | WireGuard / feste Admin-IP | `ACCEPT` (Rest `DROP`) | Unterbindet öffentliches SSH-Scanning komplett |
| Eingehend | `TCP 8000, 3000, 6001, 6002` | `0.0.0.0/0`, `::/0` | **`DROP`** | Sperrt unverschlüsselte Setup-UIs & direkte Soketi-Ports nach HTTPS-Umstellung |

## 4. Build-OOM-Schutz & Nächtliches `pg_dump`-Backup nach R2 / Storage Box

Ungedeckelte Next.js-, Vite- oder Rust-Builds allokieren schnell über `6 GB` RAM und lösen auf einem `8-GB`-Host den Linux-OOM-Killer aus. Begrenzen Sie Build-Container konsequent auf `2,5` Kerne und `4 GB` Speicher, sodass `1,5` physische Zen-5-Threads und `4 GB` DDR5 ECC garantiert für Datenbanken und Proxy frei bleiben:

```ini
# Build-Time Environment Variables (Coolify -> Build Time / Dokploy -> Environment)
NODE_OPTIONS=--max-old-space-size=3072
NEXT_TELEMETRY_DISABLED=1
CARGO_BUILD_JOBS=2

# Custom Docker Build / Run Optionen auf dem RS 1000 G12.5 (4C / 8G)
--cpus="2.5" --memory="4g" --memory-swap="5g"
```

Ergänzen Sie kostenlose **0,00-€-CoW-Snapshots im SCP** (vor System- oder Panel-Updates) um einen nächtlichen, `zstd`-komprimierten Datenbank-Export über den `2,5-Gbit/s`-Fair-Use-Port (EU/USA: `>3 TB/24h` → `300 Mbit/s`; Singapur: `1 Gbit/s`, `2 TB/Monat`) an ein per `rclone config` eingerichtetes Ziel (`r2` für Cloudflare R2 oder S3/Hetzner Storage Box):

```bash
cat <<'EOF' | sudo tee /usr/local/bin/backup-paas-pg.sh
#!/usr/bin/env bash
set -euo pipefail

STAMP=$(date -u +"%Y-%m-%d_%H%M")
HOST_TAG=$(hostname -s)

# Sichert alle laufenden PostgreSQL-Container komprimiert nach externem Objektspeicher
for CID in $(docker ps --format '{{.ID}} {{.Image}}' | awk '/postgres|pgvector/ {print $1}'); do
  NAME=$(docker inspect --format '{{.Name}}' "$CID" | sed 's#^/##')
  docker exec "$CID" pg_dumpall -U postgres --clean --if-exists \
    | zstd -T2 -10 \
    | rclone rcat "r2:netcup-backups/${HOST_TAG}/${NAME}_${STAMP}.sql.zst"
done

rclone delete --min-age 14d "r2:netcup-backups/${HOST_TAG}/"
EOF

sudo chmod 700 /usr/local/bin/backup-paas-pg.sh
echo "20 2 * * * root /usr/local/bin/backup-paas-pg.sh >> /var/log/paas-backup.log 2>&1" \
  | sudo tee /etc/cron.d/paas-pg-backup
```

## 5. Troubleshooting-Matrix: Die 5 häufigsten Fehlerbilder im Betrieb

| Fehlerbild | Ursache auf KVM / Docker | Konkrete Behebung |
| :--- | :--- | :--- |
| **Traefik meldet `502 Bad Gateway` trotz erfolgreichem Build** | App lauscht im Container nur auf `127.0.0.1` / `::1` oder Traefik routet im Dual-Stack-Netz auf den falschen Zielport. | In der App `HOST=0.0.0.0` und `PORT=3000` setzen sowie in Coolify (`Ports Exposes: 3000`) bzw. Dokploy (`Container Port: 3000`) fest hinterlegen. |
| **Nixpacks- / Docker-Build bricht mit `exit code 137` ab** | Cgroup-OOM-Kill von `node` oder `rustc`, weil das Heap-Limit überschritten wurde oder kein Swap aktiv ist. | `swapon --show` (`4G`) prüfen, `NODE_OPTIONS="--max-old-space-size=3072"` als Build-Variable setzen oder auf [RS 2000 G12.5](/de/models/rs-2000-g12-5/) (`16 GB` RAM) wechseln. |
| **`no space left on device` unter `/var/lib/docker/overlay2`** | Alte BuildKit-Layer-Caches und ungenutzte Images belegen die `128 GB` NVMe-Partition vollständig. | Automatische Bereinigung im Panel aktivieren und `docker builder prune -af --filter "until=168h" && docker image prune -af --filter "until=168h"` ausführen. |
| **Coolify Live-Build-Log friert ein / WebSocket `6001` schlägt fehl** | Proxy verwirft WebSocket-`Upgrade`-Header oder Browser ruft direkt Port `6001/6002` auf, der in der SCP-Firewall gesperrt ist. | Panel ausschließlich über `https://deploy.example.com` aufrufen (Traefik tunnelt `/app` und `/terminal/ws` über `443`); bei Cloudflare WebSockets aktivieren. |
| **Let's Encrypt schlägt mit `429 rateLimited` oder Redirect-Loop fehl** | Zu viele fehlerhafte Deploys reißen das ACME-Limit (5 Fehler/Stunde) oder Cloudflare steht auf `Flexibel` statt `Vollständig (Strikt)`. | Cloudflare SSL/TLS auf **Vollständig (Strikt)** stellen oder DNS-01-Wildcard-Zertifikate (`CF_DNS_API_TOKEN`) in Traefik hinterlegen. |

Prüfen Sie den exakten Speicherbedarf Ihrer Container im [Workload-Sizer](/de/tools/server-sizer/) oder vergleichen Sie dedizierte und geteilte Kerne in [Netcup Root-Server vs. VPS](/de/compare/netcup-root-server-vs-vps/), bevor Sie unten einen freien `#rs1`- oder `#rs2`-Gutschein abrufen.

## Häufig gestellte Fragen (FAQ)

### Coolify v4 oder Dokploy auf einem 8 GB Netcup RS 1000 G12.5?

Dokploy benötigt im Leerlauf weniger RAM (~320 MB statt ~620 MB bei Coolify v4) und nutzt nativ Docker Swarm, was auf schlanken 4-GB- (VPS 500) oder 8-GB-Systemen sehr ressourcenschonend arbeitet. Coolify v4 punktet mit dedizierten Remote-Build-Servern per SSH, PR-Preview-Umgebungen und einem größeren Vorlagenkatalog ab 8 GB (RS 1000) bzw. 16 GB (RS 2000).

### Warum RS 1000 G12.5 (18,11 €/Mo inkl. MwSt.) statt VPS 1000 G12.5 (13,29 €/Mo) für PaaS?

Der VPS 1000 G12.5 arbeitet mit geteilten EPYC-vCores im 2,0-GHz-Migrationsprofil. Für rund 4,82 €/Mo brutto Aufpreis im ersten Jahr stellt der RS 1000 G12.5 vier physisch dedizierte Zen-5-Threads bereit: 2,5 Kerne können Builds kompilieren, während 1,5 physische Kerne ohne CPU-Steal PostgreSQL und Traefik bedienen.

### Welche Ports gehören nach dem Setup in der Netcup SCP-Firewall gesperrt?

Sobald das Admin-Panel per HTTPS über Port 443 erreichbar ist, müssen eingehend TCP 8000 (Coolify), TCP 3000 (Dokploy) sowie TCP 6001 und 6002 (Coolify Soketi WebSockets/Terminal) in SCP → Firewall explizit auf DROP gesetzt werden, damit niemand den TLS-Reverse-Proxy umgeht.

### Wann lohnt sich der Aufstieg auf den RS 2000 G12.5 (37,31 €/Mo inkl. MwSt.)?

Sobald mehr als 25 aktive Container, speicherintensive JVM-/Suchdienste oder über 90 GB lokale PostgreSQL-/ClickHouse-Daten zusammenkommen, bietet der RS 2000 G12.5 (8 dedizierte Zen-5-Kerne, 16 GB DDR5 ECC, 256 GB NVMe, effektiv 37,31 €/Mo inkl. MwSt. mit #rs2) doppelte Reserven.

---
Source: EUServerLab (https://euserverlab.com/de/guides/coolify-dokploy-self-hosting-netcup-guide/) | Open Telemetry Dataset: https://euserverlab.com/benchmarks/vps-500-g12-5.json
