Zum Hauptinhalt springen
SSH-Labor & Gutscheinpool
EU EUServerLab
RATGEBER Stand: · 10 Min. Lesezeit

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.

Autor: Hai Liu (Systems & Cloud TCO Engineer) · * Mit Sternchen/Partnerlink markierte Links (rel="sponsored") unterstützen unser Testlabor ohne Mehrkosten für Sie.

Kurzüberblick

Stand: 2026-11-22

Kurz-Checkliste zur Umsetzung

  1. 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. 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. 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. 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 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 und zur Kündigungsfrist von einem Monat zum Monatsende bzw. Laufzeitende im CCP-Vertragsleitfaden).

KVM-ARCHITEKTUR & RESSOURCEN-ISOLATION AS197540 · TERMINAL-DIFF
KVM-Scheduling, NVMe-Latenz & Traffic-Modell – RS 1000 G12.5
● netcup G12.5 (RS 1000 G12.5 · AS197540)
CPU-Zuweisung: Dediziert Zen 5 (RS) bzw. 1,26–1,31 % Steal (VPS)
NVMe-Speicher: 6,87 GB/s Mixed · 115,9 µs 4K-Q1T1-Schreiblatenz
Netz & Backup: 2,5 Gbit/s EU/US Fair-Use (0 € Egress) · 0 € CoW-Snapshots
● Überbuchte Shared-vCPUs / Traffic-Abrechnung
CPU-Profil: Geteilte Host-Zeitscheiben oder teurer Dedicated-Aufpreis
Speicher-I/O: IOPS-Drosselung bei Dauerlast oder Netzwerk-Storage-Latenz
Zusatzkosten: Traffic-Pakete / Egress-Gebühren & kostenpflichtige Snapshots
Dedizierte EPYC 9645/9655 Zen-5-Threads isolieren cgroup-gedeckelte Nixpacks-Builds zuverlässig von Live-Datenbanken und Traefik

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:

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):

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:

# 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 KriteriumCoolify v4Dokploy
Control-Plane Leerlauf-RAM~580–700 MB (Laravel/FrankenPHP + Postgres + Redis + Soketi)~280–380 MB (Node.js/Next + Postgres + Redis)
Orchestrierung & ProxyKlassische Docker Engine + Traefik oder CaddyDocker Swarm (Single-/Multi-Node) + Traefik
Setup- & Realtime-PortsTCP 8000 UI + TCP 6001/6002 (Soketi WebSockets & Terminal)TCP 3000 UI (Realtime läuft über Hauptport/Proxy)
Multi-Server & Build-WorkerDedizierte Build-Server-Rolle per SSH + Remote-Docker-HostsSwarm-Worker-Nodes + Remote-SSH-Deployments
Empfohlener Netcup-TarifRS 1000 G12.5 (18,11 €/Mo) oder VPS 500 UI + RS 2000VPS 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:

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):

RichtungProtokoll & PortQuelleAktionTechnischer Grund
EingehendTCP 800.0.0.0/0, ::/0ACCEPTHTTP-auf-HTTPS-Redirect & ACME HTTP-01 Challenge
EingehendTCP 443 & UDP 4430.0.0.0/0, ::/0ACCEPTTLS 1.3 & HTTP/3 QUIC auf Traefik/Caddy
EingehendUDP 51820 / UDP 416410.0.0.0/0, ::/0ACCEPTDirekter WireGuard- oder Tailscale-Tunnel
EingehendTCP 22WireGuard / feste Admin-IPACCEPT (Rest DROP)Unterbindet öffentliches SSH-Scanning komplett
EingehendTCP 8000, 3000, 6001, 60020.0.0.0/0, ::/0DROPSperrt 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:

# 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):

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

FehlerbildUrsache auf KVM / DockerKonkrete Behebung
Traefik meldet 502 Bad Gateway trotz erfolgreichem BuildApp 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 abCgroup-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 (16 GB RAM) wechseln.
no space left on device unter /var/lib/docker/overlay2Alte 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 fehlProxy 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 fehlZu 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 oder vergleichen Sie dedizierte und geteilte Kerne in Netcup Root-Server vs. VPS, bevor Sie unten einen freien #rs1- oder #rs2-Gutschein abrufen.

Letzte Synchronisierung: --
Tarif-Gutschein wählen:
#rs1

RS 1000 G12.5

2 Monate gratis · Auch für Bestandskunden (12 Mon. Laufzeit)

EPYC 9645/9655 Zen 5 4 dedizierte Kerne 8 GB DDR5 ECC 128 GB NVMe · 2,5 Gbit/s
★ Rabatt-Vergleich vs. 5,95 € Neukunden-Code (#5e)
Mit #rs1 sparen Sie im 1. Jahr 43,46 € inkl. MwSt. statt 5,95 € mit dem Neukunden-Code #5e – genau 37,51 € mehr Ersparnis (auch als Bestandskunde).
Ziehe Zufallscode (1 aus 5)... 1/5 Gutschein jetzt direkt anwenden * →
* Partnerlink (Werbung, ohne Mehrkosten)
Automatische Warenkorb-Einlösung (?gutschein=) · Produkt-Codes gelten auch für Bestandskunden. Vollständige Einlöse-Regeln →

Häufige Fragen zum Thema (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.

Weiterführende Einzeltests & Praxis-Ratgeber

Direkte Anbieter-Vergleiche