Coolify mit Docker installieren: Self-Hosted PaaS als Heroku-Alternative

Wer eigene Webapps, Datenbanken oder Dienste wie WordPress und Nextcloud betreiben will, zahlt bei Heroku, Render oder Vercel schnell dreistellige Monatsbeträge – oder verliert die Kontrolle über seine Daten. Coolify löst beides: Die quelloffene Plattform (PHP/Laravel, 56.900+ GitHub-Sterne, Stand Juni 2026) läuft als Docker-Compose-Stack auf jedem 64-Bit-Linux-Server und stellt dir eine vollständige Web-UI bereit, über die du Apps aus Git-Repositories deployst, Datenbanken startest und über 280 vorkonfigurierte Services per Klick installierst. Coolify verwaltet seine Zielserver per SSH – kein Agent nötig – und bringt einen eigenen Traefik-Reverse-Proxy mit automatischem Let's-Encrypt-TLS für alle deployten Apps mit. Diese Anleitung führt dich durch die manuelle Installation des Docker-Compose-Stacks; sie funktioniert auf jedem VPS, Dedicated Server oder leistungsstarken Heimserver (auch ARM64/Raspberry Pi 4/5).

Voraussetzungen

1. 64-Bit-Linux-Host (Ubuntu 22.04/24.04, Debian 12, CentOS 9, Fedora 40, Alpine, Raspberry Pi OS 64-Bit – kein Windows, kein 32-Bit)
2. Docker Engine >= 24.0 und Docker Compose Plugin >= 2.20 installiert – falls nicht vorhanden, siehe Docker und Docker Compose auf Linux installieren
3. Mindestens 2 CPU-Kerne, 2 GB RAM, 30 GB freier Speicher
4. Root- oder sudo-Zugang, curl und openssl vorhanden
5. Ports 8000 (Web-UI) und 6001/6002 (Soketi) am Host frei
6. Für HTTPS im Produktivbetrieb: Reverse Proxy (z. B. Traefik als Docker-Reverse-Proxy) oder spätere Konfiguration über die Coolify-UI

Eckdaten auf einen Blick

Schritt 1: Verzeichnisstruktur anlegen und Netzwerk erstellen

Coolify legt alle persistenten Daten unter /data/coolify/ ab. Außerdem muss das Docker-Netzwerk coolify mit dem Flag --attachable angelegt werden, bevor der Stack startet – nur so können später deployete App-Container in das Netzwerk eingehängt werden.

# Verzeichnisbaum anlegen
sudo mkdir -p /data/coolify/source
sudo mkdir -p /data/coolify/ssh/keys
sudo mkdir -p /data/coolify/ssh/mux
sudo mkdir -p /data/coolify/applications
sudo mkdir -p /data/coolify/databases
sudo mkdir -p /data/coolify/services
sudo mkdir -p /data/coolify/backups
sudo mkdir -p /data/coolify/webhooks-during-maintenance
sudo mkdir -p /data/coolify/proxy

# Attachable-Netzwerk erstellen (vor docker compose up!)
docker network create --attachable coolify

Verifizieren: Das Netzwerk muss mit Attachable: true gelistet sein.

docker network inspect coolify | grep -A2 '"Attachable"'
# Erwartete Ausgabe:
# "Attachable": true,

Schritt 2: Secrets generieren und .env anlegen

Alle Pflicht-Secrets werden einmalig erzeugt und dürfen nach dem ersten Start nie verändert werden – ein nachträgliches Ändern zerstört die Installation unwiderruflich, weil verschlüsselte Datenbankeinträge nicht mehr lesbar wären.

# Secrets in Variablen erfassen (einmalig ausführen!)
APP_ID=$(openssl rand -hex 16)
APP_KEY="base64:$(openssl rand -base64 32)"
DB_PASSWORD=$(openssl rand -base64 32)
REDIS_PASSWORD=$(openssl rand -base64 32)
PUSHER_APP_ID=$(openssl rand -hex 32)
PUSHER_APP_KEY=$(openssl rand -hex 32)
PUSHER_APP_SECRET=$(openssl rand -hex 32)

# .env-Datei schreiben
sudo tee /data/coolify/source/.env > /dev/null <<EOF
APP_ID=${APP_ID}
APP_KEY=${APP_KEY}
APP_NAME=Coolify
APP_ENV=production
APP_PORT=8000
DB_USERNAME=coolify
DB_PASSWORD=${DB_PASSWORD}
DB_DATABASE=coolify
REDIS_PASSWORD=${REDIS_PASSWORD}
PUSHER_APP_ID=${PUSHER_APP_ID}
PUSHER_APP_KEY=${PUSHER_APP_KEY}
PUSHER_APP_SECRET=${PUSHER_APP_SECRET}
REGISTRY_URL=ghcr.io
LATEST_IMAGE=latest
PHP_MEMORY_LIMIT=256M
EOF

sudo chmod 600 /data/coolify/source/.env

Möchtest du die Installation auf eine bestimmte Version pinnen, setze LATEST_IMAGE=v4.1.2. Einen sicheren Aufbewahrungsort für die generierten Secrets (z. B. Vaultwarden) nutzen – ein Backup dieser Datei ist essenziell.

Verifizieren:

sudo cat /data/coolify/source/.env | grep APP_ID
# Ausgabe: APP_ID=<dein generierter Hex-Wert>

ls -la /data/coolify/source/.env
# Berechtigungen: -rw------- (600)

Schritt 3: Offizielle Compose-Dateien herunterladen

Coolify benötigt zwingend zwei Compose-Dateien, die zusammen verwendet werden. Das ist ein häufiger Fehler in Community-Guides, die nur eine einzige Datei zeigen: Ohne docker-compose.prod.yml fehlen die Produktionskonfigurationen, und die UI ist nicht erreichbar oder die Datenbankverbindung schlägt fehl.

cd /data/coolify/source

sudo curl -fsSL https://cdn.coollabs.io/coolify/docker-compose.yml \
  -o docker-compose.yml

sudo curl -fsSL https://cdn.coollabs.io/coolify/docker-compose.prod.yml \
  -o docker-compose.prod.yml

Alternativ kannst du statt der offiziellen CDN-Dateien die nachfolgende compose.yaml verwenden – sie ist direkt aus den verifizierten Recherchefakten abgeleitet und enthält alle vier Services mit vollständigen Healthchecks. Wer auf die offiziellen CDN-Dateien setzt, überspringt Schritt 4 und springt direkt zu Schritt 5.

Verifizieren:

ls -lh /data/coolify/source/
# Erwartete Ausgabe: docker-compose.yml, docker-compose.prod.yml, .env

Schritt 4: Eigene compose.yaml (optional, bei CDN-Problemen)

Falls die CDN-Dateien nicht erreichbar sind oder du den Stack lieber als einzelne Datei verwalten möchtest, kannst du folgende vollständige compose.yaml unter /data/coolify/source/compose.yaml ablegen. Sie entspricht den offiziellen Vorgaben und enthält alle vier Services mit Healthchecks.

services:
  coolify:
    image: "${REGISTRY_URL:-ghcr.io}/coollabsio/coolify:${LATEST_IMAGE:-latest}"
    container_name: coolify
    restart: always
    working_dir: /var/www/html
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      - APP_ENV=${APP_ENV:-production}
      - APP_ID=${APP_ID}
      - APP_KEY=${APP_KEY}
      - APP_NAME=${APP_NAME:-Coolify}
      - DB_USERNAME=${DB_USERNAME:-coolify}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_DATABASE=${DB_DATABASE:-coolify}
      - REDIS_PASSWORD=${REDIS_PASSWORD}
      - PUSHER_APP_ID=${PUSHER_APP_ID}
      - PUSHER_APP_KEY=${PUSHER_APP_KEY}
      - PUSHER_APP_SECRET=${PUSHER_APP_SECRET}
      - PHP_MEMORY_LIMIT=${PHP_MEMORY_LIMIT:-256M}
    ports:
      - "${APP_PORT:-8000}:8080"
    volumes:
      - /data/coolify/source/.env:/var/www/html/.env
      - /data/coolify/ssh/keys:/var/www/html/storage/app/ssh/keys
      - /data/coolify/ssh/mux:/var/www/html/storage/app/ssh/mux
      - /data/coolify/applications:/var/www/html/storage/app/applications
      - /data/coolify/databases:/var/www/html/storage/app/databases
      - /data/coolify/services:/var/www/html/storage/app/services
      - /data/coolify/backups:/var/www/html/storage/app/backups
      - /data/coolify/webhooks-during-maintenance:/var/www/html/storage/app/webhooks-during-maintenance
      - /data/coolify/proxy:/data/coolify/proxy
    networks:
      - coolify
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      soketi:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  postgres:
    image: postgres:15-alpine
    container_name: coolify-db
    restart: always
    environment:
      POSTGRES_USER: ${DB_USERNAME:-coolify}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: ${DB_DATABASE:-coolify}
    volumes:
      - coolify-db:/var/lib/postgresql/data
    networks:
      - coolify
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USERNAME:-coolify} -d ${DB_DATABASE:-coolify}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  redis:
    image: redis:7-alpine
    container_name: coolify-redis
    restart: always
    command: >
      redis-server
      --save 20 1
      --loglevel warning
      --requirepass ${REDIS_PASSWORD}
    volumes:
      - coolify-redis:/data
    networks:
      - coolify
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 15s

  soketi:
    image: ghcr.io/coollabsio/coolify-realtime:1.0.16
    container_name: coolify-realtime
    restart: always
    extra_hosts:
      - "host.docker.internal:host-gateway"
    ports:
      - "${SOKETI_PORT:-6001}:6001"
      - "6002:6002"
    environment:
      PUSHER_APP_ID: ${PUSHER_APP_ID}
      PUSHER_APP_KEY: ${PUSHER_APP_KEY}
      PUSHER_APP_SECRET: ${PUSHER_APP_SECRET}
    networks:
      - coolify
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:6001 && curl -f http://localhost:6002"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 15s

volumes:
  coolify-db:
    name: coolify-db
  coolify-redis:
    name: coolify-redis

networks:
  coolify:
    name: coolify
    driver: bridge
    attachable: true

Verifizieren:

docker compose -f /data/coolify/source/compose.yaml \
  --env-file /data/coolify/source/.env config --quiet
# Kein Fehler = Syntax korrekt

Schritt 5: Berechtigungen setzen und Stack starten

Alle Bind-Mount-Verzeichnisse unter /data/coolify/ müssen UID 9999 (der interne Coolify-Container-User) gehören. Ohne diesen Schritt schlägt der Container mit „Permission denied"-Fehlern beim Lesen der .env oder der SSH-Keys fehl.

# Berechtigungen setzen (PFLICHT)
sudo chown -R 9999:root /data/coolify
sudo chmod -R 700 /data/coolify/ssh

# Stack mit den offiziellen CDN-Dateien starten:
docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  up -d --pull always --remove-orphans --force-recreate

# Alternativ mit eigener compose.yaml (Schritt 4):
# docker compose \
#   --env-file /data/coolify/source/.env \
#   -f /data/coolify/source/compose.yaml \
#   up -d --pull always --remove-orphans

Der erste Start dauert 1–3 Minuten, weil die Images gezogen und die Datenbank initialisiert werden. Der Coolify-Container wartet dank depends_on mit Healthcheck-Bedingungen, bis PostgreSQL, Redis und Soketi tatsächlich bereit sind.

Verifizieren:

docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  ps

# Erwartete Ausgabe (alle vier Container):
# NAME                 STATUS              PORTS
# coolify              Up (healthy)        0.0.0.0:8000->8080/tcp
# coolify-db           Up (healthy)        5432/tcp
# coolify-redis        Up (healthy)        6379/tcp
# coolify-realtime     Up (healthy)        0.0.0.0:6001->6001/tcp, ...

# Health-API direkt prüfen:
curl -sf http://localhost:8000/api/health
# Erwartete Ausgabe: {"status":"ok"} oder HTTP 200

Schritt 6: Ersteinrichtung im Browser

Öffne http://<deine-server-ip>:8000 im Browser. Coolify zeigt beim ersten Aufruf den Registrierungsbildschirm für den Admin-Account. Lege sofort einen Admin-Account an – solange kein Account existiert, kann sich jeder registrieren.

Nach dem Login führt dich Coolify durch den Setup-Wizard:

1. Localhost verbinden: Unter „Servers" den voreingestellten Localhost-Server bestätigen. Coolify kommuniziert intern über host.docker.internal.
2. Erstes Projekt anlegen: Über „Projects → New Project" ein Projekt erstellen.
3. Resource deployen: „New Resource → Application" – Git-Repository verbinden (GitHub, GitLab, Gitea, Bitbucket), Buildpack oder Dockerfile wählen, Umgebungsvariablen setzen und deployen. Alternativ direkt einen der 280+ One-Click-Services (WordPress, Nextcloud, Plausible, MinIO, Supabase …) starten.

HTTPS richtest du unter „Settings → SSL" ein: Coolify konfiguriert automatisch Let's Encrypt über den integrierten Traefik-Proxy für alle deployten Apps. Für die Coolify-UI selbst empfiehlt sich ein vorgeschalteter Reverse Proxy – eine detaillierte Anleitung dazu bietet Caddy als Reverse Proxy einrichten.

Verifizieren: Browser öffnet http://<server-ip>:8000, zeigt die Coolify-Anmeldeseite oder das Dashboard (nach Login). Kein „502 Bad Gateway" oder leere Seite.

curl -I http://localhost:8000
# Erwartete Ausgabe:
# HTTP/1.1 200 OK  (oder 302 Redirect zum Login)

Schritt 7: Updates und Backups

Coolify bringt ein eigenes Upgrade-Skript mit, das neue Images zieht, die .env zusammenführt und alle Container neu startet:

# Empfohlener Upgrade-Weg (offiziell):
curl -fsSL https://cdn.coollabs.io/coolify/upgrade.sh | bash

# Alternativ manuell (nur neue Images ziehen):
docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  pull

docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  up -d --remove-orphans --force-recreate

Coolify richtet keine automatischen Backups der eigenen Datenbank ein. Richte mindestens wöchentliche Snapshots des Volumes coolify-db oder einen pg_dump-Cron ein. Wie das geht, zeigt MySQL & PostgreSQL Backup automatisieren mit cron.

Dank restart: always in allen Containern starten alle Services nach einem Server-Neustart automatisch – vorausgesetzt, Docker selbst ist als systemd-Service konfiguriert (Standard bei offizieller Docker-Installation).

Verifizieren:

docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  ps
# Nach Update: alle Container „Up (healthy)", aktuelles Image-Digest sichtbar

docker compose \
  --env-file /data/coolify/source/.env \
  -f /data/coolify/source/docker-compose.yml \
  -f /data/coolify/source/docker-compose.prod.yml \
  logs --tail=20 coolify
# Keine Fehler im App-Log

Troubleshooting / Typische Fehler

1. „Permission denied" beim Containerstart: Die Bind-Mount-Verzeichnisse gehören nicht UID 9999. Fix: sudo chown -R 9999:root /data/coolify ausführen und Container neu starten.
2. UI nicht erreichbar, Datenbankverbindung schlägt fehl: Wahrscheinlich wurde nur eine Compose-Datei verwendet. Beide Dateien (docker-compose.yml und docker-compose.prod.yml) mit -f angeben.
3. „Port already in use" / Port 8000 belegt: Ein anderer Dienst nutzt Port 8000. Fix: APP_PORT=8080 (oder einen freien Port) in /data/coolify/source/.env setzen, bevor der Stack das erste Mal gestartet wird.
4. Soketi startet nicht (Port 6001 belegt): VoIP- oder SIP-Software nutzt denselben Port. Fix: SOKETI_PORT=6011 in .env eintragen und Stack neu starten.
5. Docker-Version zu alt: Docker < 24.0 unterstützt die verwendete Healthcheck-Syntax nicht. Fehlermeldung: „unknown flag" oder „invalid healthcheck". Fix: Docker aktualisieren (apt-get upgrade docker-ce).
6. ARM64 / Raspberry Pi: Container startet nicht: Prüfe, ob ein 64-Bit-OS läuft (uname -m → aarch64). 32-Bit-Raspberry-Pi-OS wird nicht unterstützt.
7. Netzwerk nicht attachable: Wurde docker network create coolify ohne --attachable angelegt, können deployete Apps später nicht ins Netzwerk eingehängt werden. Fix: docker network rm coolify (erst wenn keine Container laufen), dann docker network create --attachable coolify.

Logs prüfen:docker compose logs -f coolify      # App-Log
docker compose logs -f coolify-db  # PostgreSQL
docker compose logs -f coolify-realtime  # Soketi

Häufige Fragen

Kann ich Coolify auf einem Windows-Host betreiben?

Offiziell nein. Coolify unterstützt ausschließlich 64-Bit-Linux als Host-OS (Ubuntu, Debian, CentOS, Fedora, Alpine, Arch, SUSE, Raspberry Pi OS 64-Bit). Docker Desktop auf Windows wird nicht als Zielplattform unterstützt.

Was passiert, wenn ich einen der Secrets nachträglich ändere?

Die Installation wird unwiderruflich unbrauchbar. APP_KEY verschlüsselt alle sensiblen Datenbankeinträge, APP_ID identifiziert die Installation, und die Passwörter für PostgreSQL und Redis müssen zum laufenden Datenbankinhalt passen. Einmalig generieren, sicher aufbewahren, nie anfassen.

Wie deploye ich meine erste eigene App?

Nach dem Login: „Servers → Localhost" bestätigen, dann „Projects → New Project → New Resource → Application". Git-Repository verbinden (GitHub, GitLab, Gitea, Forgejo oder Bitbucket), Buildpack oder Dockerfile wählen, Umgebungsvariablen setzen und auf „Deploy" klicken. Automatisches Re-Deployment per Webhook ist in denselben Einstellungen aktivierbar.

Wie aktualisiere ich Coolify auf eine neue Version?

Den offiziellen Upgrade-Weg nutzen: curl -fsSL https://cdn.coollabs.io/coolify/upgrade.sh | bash. Das Skript lädt neue Compose-Dateien herunter, führt die .env zusammen, zieht neue Images und startet Container neu. Alternativ: in der Coolify-UI unter „Settings → Update".

Wie richte ich HTTPS für die Coolify-UI ein?

Zwei Wege: Entweder einen Reverse Proxy (Traefik, Caddy, Nginx) vor Port 8000 schalten und dort TLS terminieren, oder eine öffentlich erreichbare Domain in den Coolify-Einstellungen hinterlegen – Coolify konfiguriert dann über den integrierten Traefik automatisch Let's Encrypt. Wichtig: WebSocket-Support (Soketi, Port 6001) im Proxy aktivieren (proxy_read_timeout erhöhen, Upgrade-Header weiterleiten).

Kann ich Coolify auf einem Raspberry Pi betreiben?

Ja – auf ARM64 (Raspberry Pi 4/5 mit 64-Bit-OS). Die Images sind für amd64 und arm64 gebaut. Mindestens 4 GB RAM empfohlen, da der Stack mit PostgreSQL und Redis gut 700 MB belegt.

Fazit

Coolify ist der derzeit populärste Self-Hosted-PaaS-Stack und eine überzeugende Alternative zu Heroku, Render und Vercel – besonders für KMU und Freelancer, die Hosting-Kosten senken und volle Datenkontrolle behalten wollen. Der manuelle Docker-Compose-Weg ist in etwa 20 Minuten erledigt und läuft danach wartungsarm auf jedem Linux-Server. Der wichtigste Punkt bleibt das Secret-Management: Alle Pflicht-Variablen nur einmal generieren, sicher sichern und nie ändern. Wer das beherzigt, hat einen stabilen Deployment-Hub für beliebig viele Apps und Datenbanken auf dem eigenen Server.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren – die Self-Hosting-Grundlage
2. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten
3. MySQL & PostgreSQL Backup automatisieren mit cron: mysqldump, pg_dump, Rotation und rclone-Cloud-Sync
4. Dokploy mit Docker installieren: Open-Source-Deployment-Plattform
5. VPS absichern und härten: Anleitung mit UFW, SSH-Keys und Fail2Ban

Offizielle Quellen: Coolify-Dokumentation (Installation), Coolify GitHub Repository, Offizielles docker-compose.yml (CDN).

Passende Anleitungen auf S-EDV

1. OpenSSL: Neun Schwachstellen im Sicherheitsrelease vom 9. Juni 2026, darunter Hi
2. PostgreSQL schließt elf Sicherheitslücken in den Versionen 14 bis 18
3. netcup Local Block Storage bestellen, einrichten und unter Linux einbinden