💡 Hinweis: Dieses Tutorial setzt voraus, dass du einen normalen Benutzer mit sudo-Rechten verwendest — wie im Tutorial Debian 13 Server absichern beschrieben.

Einleitung — Was ist Coolify?

Wer schon einmal mit Vercel, Heroku oder Netlify gearbeitet hat, kennt den Komfort: Git-Push, automatisches Deployment, SSL-Zertifikate, Datenbanken — alles aus einer Hand. Das Problem? Diese Dienste kosten schnell Geld, schränken die Kontrolle ein und speichern eure Daten auf fremden Servern.

Coolify ist eine Open-Source, Self-Hosted Platform-as-a-Service (PaaS), die genau diesen Komfort auf euren eigenen Server bringt. Ihr behaltet die volle Kontrolle über eure Daten, zahlt nur für euren Server und könnt beliebig viele Apps, Datenbanken und Services deployen — ohne Vendor Lock-in.

Was Coolify kann

  • Git-basierte Deployments — Push to Deploy aus GitHub, GitLab, Gitea, Bitbucket
  • Docker & Docker Compose — Beliebige Container deployen
  • Datenbanken — PostgreSQL, MySQL/MariaDB, MongoDB, Redis mit einem Klick
  • Automatisches SSL — Let’s Encrypt via Traefik, vollautomatisch
  • Monitoring & Logs — Alles im Dashboard sichtbar
  • Backups — Automatische Datenbank-Backups zu S3-kompatiblem Storage
  • Multi-Server — Mehrere Server von einem Dashboard aus verwalten
  • Webhooks — Auto-Deploy bei jedem Git-Push

In diesem Guide richten wir Coolify von Grund auf ein — von der Installation bis zum ersten Deployment inklusive Datenbanken, SSL, Backups und Monitoring.

Voraussetzungen

Bevor wir starten, braucht ihr:

  • Einen Debian 13 (Trixie) Server — Eingerichtet nach unserem Debian 13 Server-Guide
  • Docker installiert — Wie in unserem Docker-Tutorial beschrieben
  • Root-Zugang oder einen Benutzer mit sudo-Rechten
  • Mindestens 2 GB RAM (4 GB empfohlen)
  • Eine Domain (optional, aber empfohlen für SSL)
  • Ports 80, 443 und 8000 müssen erreichbar sein

💡 Hinweis: Coolify bringt sein eigenes Docker mit, falls keines installiert ist. Wenn ihr unserem Docker-Tutorial gefolgt seid, ist das bereits erledigt. Coolify erkennt die bestehende Installation automatisch.

Firewall-Ports öffnen

Falls ihr ufw nutzt (wie in unserem Debian-Guide empfohlen), öffnet die nötigen Ports:

sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8000/tcp
sudo ufw status

Port 8000 ist das Coolify-Dashboard. Die Ports 80 und 443 werden von Traefik für eure Apps und SSL verwendet.

Coolify installieren

Die Installation ist denkbar einfach — Coolify bietet ein offizielles Installations-Script, das alles Nötige einrichtet.

Schritt 1: Install-Script ausführen

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

Das Script erledigt folgende Aufgaben:

  • Prüft, ob Docker installiert ist (installiert es bei Bedarf)
  • Erstellt die nötigen Verzeichnisse unter /data/coolify
  • Lädt die Docker-Compose-Konfiguration herunter
  • Startet Coolify als Docker-Container-Stack
  • Richtet SSH-Keys für die lokale Server-Verwaltung ein

⚠️ Wichtig: Das Script muss als root ausgeführt werden (oder mit sudo). Coolify benötigt Root-Rechte, um Docker-Container zu verwalten und Netzwerk-Konfigurationen vorzunehmen.

Schritt 2: Installation überprüfen

Nach der Installation könnt ihr prüfen, ob alle Container laufen:

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

Ihr solltet mehrere Container sehen:

  • coolify — Die Hauptanwendung (Laravel-basiert)
  • coolify-db — PostgreSQL-Datenbank für Coolify selbst
  • coolify-redis — Redis für Queue und Cache
  • coolify-realtime — WebSocket-Server für Live-Updates
  • coolify-proxy — Traefik Reverse Proxy

Schritt 3: Dashboard aufrufen

Öffnet euren Browser und navigiert zu:

http://EURE-SERVER-IP:8000

Beim ersten Aufruf werdet ihr aufgefordert, ein Admin-Konto zu erstellen. Wählt ein sicheres Passwort!

Erste Schritte: Dashboard & Setup

Nach der Registrierung begrüßt euch das Coolify-Dashboard. Hier ein Überblick über die wichtigsten Bereiche:

Onboarding-Wizard

Coolify führt euch beim ersten Login durch einen Setup-Wizard:

  1. Server validieren — Coolify prüft die Verbindung zum lokalen Server
  2. SSH-Key einrichten — Wird automatisch generiert und hinterlegt
  3. Proxy starten — Traefik wird als Reverse Proxy gestartet

Folgt dem Wizard Schritt für Schritt — er erledigt die Grundkonfiguration automatisch.

Dashboard-Übersicht

  • Projects — Eure Projekte (gruppierte Apps, Datenbanken, Services)
  • Servers — Verbundene Server
  • Security — SSH-Keys und Zugangsdaten
  • Teams — Benutzerverwaltung (Multi-User-Support)
  • Settings — Globale Einstellungen, SMTP, Backup-Konfiguration

SMTP einrichten (empfohlen)

Unter Settings → Transactional Email könnt ihr einen SMTP-Server konfigurieren. Coolify nutzt diesen für:

  • Passwort-Reset-E-Mails
  • Deployment-Benachrichtigungen
  • Team-Einladungen
# Beispiel für einen eigenen Mailserver oder einen Dienst wie Resend/Mailgun:
SMTP Host: smtp.example.com
SMTP Port: 587
Username: coolify@example.com
Password: euer-passwort
From: coolify@example.com

Server & Destinations konfigurieren

Localhost-Server

Nach der Installation ist euer lokaler Server automatisch als „localhost“ eingerichtet. Unter Servers könnt ihr den Status prüfen:

  • Reachable — SSH-Verbindung funktioniert
  • Docker Engine — Docker ist verfügbar
  • Proxy — Traefik läuft

Remote-Server hinzufügen (optional)

Coolify kann auch Remote-Server verwalten. Dazu unter Servers → Add Server:

  1. IP-Adresse oder Hostname eintragen
  2. SSH-Port angeben (Standard: 22)
  3. SSH-Key auswählen oder neuen erstellen
  4. Verbindung validieren

💡 Tipp: Für Remote-Server muss der SSH-Key des Coolify-Servers auf dem Zielserver hinterlegt sein. Coolify zeigt euch den Public Key an — diesen einfach in ~/.ssh/authorized_keys auf dem Remote-Server einfügen.

Destinations (Docker Networks)

Eine Destination ist ein Docker-Netzwerk auf einem Server. Coolify erstellt automatisch ein Standard-Netzwerk. Ihr könnt weitere hinzufügen, um Apps voneinander zu isolieren — etwa ein Netzwerk für Produktion und eines für Staging.

Erste App deployen (aus Git-Repo)

Jetzt wird es spannend — wir deployen die erste Anwendung! Als Beispiel nehmen wir eine einfache Node.js-App.

Schritt 1: Neues Projekt erstellen

  1. Klickt auf Projects → Add New Project
  2. Gebt dem Projekt einen Namen (z.B. „Meine Web-Apps“)
  3. Im Projekt klickt auf + Add Resource

Schritt 2: Git-Quelle wählen

Coolify unterstützt verschiedene Quellen:

  • Public Repository — Einfach die URL eingeben
  • GitHub App — Für private Repos (OAuth-Integration)
  • GitLab — Über Deploy-Token oder SSH
  • Gitea / Bitbucket — Ähnlich wie GitLab

Für ein öffentliches Repo reicht die URL:

https://github.com/coollabsio/coolify-examples

Schritt 3: Build-Konfiguration

Coolify erkennt automatisch den Typ eurer App anhand des Repositories:

  • Dockerfile — Wenn ein Dockerfile vorhanden ist
  • Docker Compose — Bei vorhandener docker-compose.yml
  • Nixpacks — Automatische Erkennung (Node.js, Python, Go, Rust, PHP, Ruby, etc.)
  • Buildpacks — Heroku-kompatible Buildpacks

Nixpacks ist der Standard und funktioniert für die meisten Projekte ohne Konfiguration. Es erkennt automatisch die Sprache, installiert Dependencies und erstellt ein optimiertes Docker-Image.

Schritt 4: Deployment starten

  1. Wählt den Branch aus (z.B. main)
  2. Konfiguriert optional den Port (Standard wird automatisch erkannt)
  3. Klickt auf Deploy

Im Deployment-Log könnt ihr den Build-Prozess live verfolgen. Nach erfolgreichem Build ist eure App unter der zugewiesenen URL erreichbar.

✅ Geschafft! Eure erste App läuft. Coolify hat automatisch einen Container erstellt, ihn gestartet und über Traefik erreichbar gemacht.

Datenbanken mit Coolify verwalten

Eine der größten Stärken von Coolify ist die einfache Datenbank-Verwaltung. Ihr könnt mit wenigen Klicks vollständige Datenbank-Instanzen erstellen.

Datenbank erstellen

  1. Im Projekt auf + Add Resource → Database
  2. Wählt den Typ:
    • PostgreSQL — Der Allrounder, empfohlen für die meisten Projekte
    • MariaDB / MySQL — Für WordPress, Legacy-Apps
    • MongoDB — Für dokumentenbasierte Daten
    • Redis — Cache, Sessions, Message Queue
    • Dragonfly — Redis-kompatibel, aber performanter
    • KeyDB — Multi-threaded Redis-Alternative
    • ClickHouse — Analytische Datenbank
    • Konfiguriert Version, Passwort und Datenbankname
    • Klickt auf Start

Verbindungsdaten

Nach dem Start zeigt Coolify euch die Connection Strings an:

# PostgreSQL Beispiel
postgresql://postgres:PASSWORT@coolify-db-xyz:5432/meine_datenbank

# MariaDB Beispiel
mysql://root:PASSWORT@coolify-db-abc:3306/meine_datenbank

# Redis Beispiel
redis://default:PASSWORT@coolify-redis-def:6379

Diese Connection Strings könnt ihr direkt als Environment Variable in eure Apps einfügen — dazu gleich mehr.

Externe Verbindung

Standardmäßig sind Datenbanken nur intern (über das Docker-Netzwerk) erreichbar. Wenn ihr euch extern verbinden wollt (z.B. mit einem GUI-Tool wie pgAdmin oder DBeaver), könnt ihr unter den Datenbank-Einstellungen den öffentlichen Port aktivieren.

⚠️ Sicherheit: Exponiert Datenbank-Ports nur temporär zum Debugging! Im Produktivbetrieb sollten Datenbanken ausschließlich über das interne Docker-Netzwerk erreichbar sein.

Domains & SSL (automatisch via Traefik)

Coolify nutzt Traefik als Reverse Proxy und integriert Let’s Encrypt für automatische SSL-Zertifikate.

Domain zuweisen

  1. Öffnet eure App im Dashboard
  2. Unter Settings tragt ihr die Domain ein: https://app.example.com
  3. Klickt auf Save und dann Redeploy

DNS konfigurieren

Erstellt einen A-Record bei eurem DNS-Provider:

Typ:   A
Name:  app
Wert:  EURE-SERVER-IP
TTL:   3600

Für Wildcard-Setups (alle Subdomains auf einen Server):

Typ:   A
Name:  *
Wert:  EURE-SERVER-IP
TTL:   3600

SSL-Zertifikate

Sobald die Domain auf euren Server zeigt, kümmert sich Traefik vollautomatisch um:

  • Anfordern des SSL-Zertifikats bei Let’s Encrypt
  • HTTP → HTTPS Redirect
  • Automatische Erneuerung vor Ablauf

Ihr müsst nichts weiter tun. Innerhalb weniger Sekunden ist eure App über HTTPS erreichbar.

Mehrere Domains

Ihr könnt einer App auch mehrere Domains zuweisen — einfach durch Komma getrennt eintragen:

https://app.example.com, https://www.app.example.com

Coolify-Dashboard absichern

Ihr könnt auch dem Dashboard selbst eine Domain zuweisen. Unter Settings → General tragt ihr eure Domain ein (z.B. https://coolify.example.com). Danach ist das Dashboard über Port 8000 und über eure Domain erreichbar.

Environment Variables & Secrets

Fast jede App benötigt Konfiguration über Umgebungsvariablen — Datenbank-Credentials, API-Keys, Feature-Flags etc.

Variables hinzufügen

  1. Öffnet eure App → Environment Variables
  2. Fügt Key-Value-Paare hinzu: 
    DATABASE_URL=postgresql://postgres:geheim@db:5432/app
REDIS_URL=redis://default:geheim@redis:6379
NODE_ENV=production
API_KEY=sk-1234567890
  3. Klickt auf Save

Build vs. Runtime Variables

Coolify unterscheidet zwischen:

  • Build-Time — Verfügbar während des Builds (z.B. NEXT_PUBLIC_API_URL)
  • Runtime — Nur zur Laufzeit verfügbar (Standard, sicherer)

Ihr könnt für jede Variable einzeln festlegen, ob sie nur im Build, nur zur Runtime oder in beiden Phasen verfügbar sein soll.

Shared Variables

Unter Project → Shared Variables könnt ihr Variablen definieren, die allen Ressourcen im Projekt zur Verfügung stehen. Perfekt für gemeinsame Datenbank-Credentials oder API-Keys.

.env-Datei

Alternativ könnt ihr auch eine .env-Datei direkt einfügen. Coolify bietet dafür einen Editor im Dashboard. Das ist praktisch, wenn ihr viele Variablen auf einmal importieren wollt.

💡 Tipp: Verweist in euren App-Variables auf die Datenbank-Container über deren internen Hostnamen (den Container-Namen). Coolify zeigt diesen in den Datenbank-Details an.

Docker Compose Projekte deployen

Coolify unterstützt vollständige Docker Compose Projekte. Das ist ideal für komplexe Setups mit mehreren Services.

Aus Git-Repo

  1. + Add Resource → Docker Compose
  2. Git-Repository-URL angeben
  3. Pfad zur docker-compose.yml angeben (Standard: Projekt-Root)
  4. Deploy klicken

Manuell (Raw Docker Compose)

Ihr könnt auch eine docker-compose.yml direkt im Dashboard eingeben:

services:
  app:
    image: nginx:alpine
    ports:
      - "80"
    volumes:
      - ./html:/usr/share/nginx/html

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: myapp
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Coolify-spezifische Labels

Um Coolify mitzuteilen, welcher Service über Traefik erreichbar sein soll, nutzt ihr spezielle Labels oder die Coolify-UI. In den meisten Fällen erkennt Coolify automatisch den Haupt-Service.

Bestehende Compose-Projekte migrieren

Wenn ihr bereits Docker Compose Projekte auf eurem Server habt:

  1. Pushed das Projekt in ein Git-Repo
  2. Erstellt in Coolify eine neue Docker Compose Ressource
  3. Verknüpft das Repo
  4. Environment Variables übertragen
  5. Deployen — fertig!

Der Vorteil: Ihr bekommt automatische SSL-Zertifikate, Monitoring, Backups und ein schönes Dashboard obendrauf.

Webhooks & Auto-Deploy bei Git Push

Manuell deployen war gestern. Mit Webhooks wird eure App automatisch bei jedem Git-Push aktualisiert.

GitHub Integration

  1. Unter Sources klickt auf + Add Source → GitHub App
  2. Folgt dem OAuth-Flow — Coolify erstellt eine GitHub App in eurem Account
  3. Wählt die Repositories aus, auf die Coolify zugreifen darf
  4. Bei neuen Apps könnt ihr jetzt private Repos auswählen

Mit der GitHub-App-Integration werden Webhooks automatisch eingerichtet. Jeder Push auf den konfigurierten Branch löst ein Deployment aus.

Manueller Webhook

Für GitLab, Gitea oder andere Git-Hosts zeigt Coolify euch eine Webhook-URL an. Diese tragt ihr in eurem Git-Repository unter Settings → Webhooks ein:

# Webhook URL Format
https://coolify.example.com/api/v1/deploy?token=EUER_DEPLOY_TOKEN&uuid=APP_UUID

Branch-basierte Deployments

Ihr könnt konfigurieren, welcher Branch automatisch deployed wird:

  • main/master → Production
  • develop → Staging-Umgebung
  • Preview Deployments → Für jeden Pull Request eine temporäre Umgebung

Deploy-API

Coolify bietet auch eine REST-API. Damit könnt ihr Deployments aus CI/CD-Pipelines (GitHub Actions, GitLab CI) triggern:

curl -X POST "https://coolify.example.com/api/v1/deploy" \
  -H "Authorization: Bearer EUER_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"uuid": "APP_UUID"}'

Monitoring & Logs

Coolify bietet eingebautes Monitoring und Log-Zugriff direkt im Dashboard.

Container-Logs

Für jede Ressource (App, Datenbank, Service) könnt ihr unter dem Logs-Tab die Container-Logs in Echtzeit sehen. Die Logs werden live gestreamt — ideal zum Debugging.

Deployment-Logs

Unter Deployments seht ihr die Historie aller Deployments mit:

  • Build-Logs (vollständiger Output)
  • Status (Erfolgreich, Fehlgeschlagen, In Bearbeitung)
  • Dauer
  • Commit-Hash und -Nachricht

Server-Monitoring

Unter Servers → Euer Server zeigt Coolify grundlegende Server-Metriken:

  • CPU-Auslastung
  • RAM-Verbrauch
  • Festplattennutzung
  • Netzwerk-Traffic

Benachrichtigungen einrichten

Unter Settings → Notifications könnt ihr Benachrichtigungen konfigurieren für:

  • Discord — Webhook-URL eintragen
  • Telegram — Bot-Token und Chat-ID
  • E-Mail — Über den konfigurierten SMTP-Server
  • Slack — Webhook-URL

Ihr werdet benachrichtigt bei:

  • Erfolgreichen Deployments
  • Fehlgeschlagenen Deployments
  • Container-Crashes
  • Backup-Status
  • Server-Problemen

Backups

Datenverlust ist der Albtraum jedes Admins. Coolify bietet automatische Datenbank-Backups.

Backup-Ziel konfigurieren

Unter Settings → Backup oder bei der jeweiligen Datenbank unter Backups:

  1. S3-kompatiblen Storage einrichten:
    • AWS S3
    • Minio (Self-Hosted)
    • Cloudflare R2
    • Hetzner Object Storage
    • Backblaze B2
    • Credentials eingeben (Access Key, Secret Key, Bucket, Region)
    • Verbindung testen

Automatische Backups

Für jede Datenbank könnt ihr unter dem Backups-Tab einen Zeitplan festlegen:

# Cron-Syntax
# Täglich um 3:00 Uhr
0 3 * * *

# Alle 6 Stunden
0 */6 * * *

# Jeden Montag um 2:00 Uhr
0 2 * * 1

Manuelles Backup

Klickt einfach auf Backup Now für ein sofortiges Backup. Das Backup wird in eurem konfigurierten S3-Bucket gespeichert.

Backup wiederherstellen

In der Backup-Liste könnt ihr jedes Backup herunterladen oder direkt wiederherstellen. Coolify zeigt euch Größe und Zeitstempel an.

⚠️ Best Practice: Testet eure Backups regelmäßig! Ein Backup, das sich nicht wiederherstellen lässt, ist wertlos. Stellt mindestens einmal im Monat ein Backup testweise auf einem Staging-System wieder her.

Updates

Coolify wird aktiv weiterentwickelt und erhält regelmäßig Updates mit neuen Features und Bugfixes.

Update über das Dashboard

Der einfachste Weg: Im Dashboard zeigt Coolify oben rechts an, wenn ein Update verfügbar ist. Klickt auf Update — Coolify aktualisiert sich selbst.

Update über die Kommandozeile

cd /data/coolify
docker compose pull
docker compose up -d --remove-orphans

Auto-Update

Unter Settings → General könnt ihr Auto-Update aktivieren. Coolify prüft dann regelmäßig auf neue Versionen und aktualisiert sich automatisch.

💡 Empfehlung: Für Produktivserver empfehle ich, Auto-Update deaktiviert zu lassen und Updates manuell nach Prüfung der Release-Notes durchzuführen. So vermeidet ihr unerwartete Breaking Changes.

Zusammenfassung & Checkliste

Hier eine Checkliste, damit ihr nichts vergesst:

Schritt Status
Debian 13 Server eingerichtet☐
Docker installiert☐
Firewall-Ports geöffnet (80, 443, 8000)☐
Coolify installiert☐
Admin-Konto erstellt☐
Onboarding-Wizard abgeschlossen☐
SMTP konfiguriert☐
Domain & DNS eingerichtet☐
SSL funktioniert☐
Erste App deployed☐
Datenbank erstellt☐
Backups konfiguriert☐
Benachrichtigungen eingerichtet☐
Webhooks / Auto-Deploy aktiv☐

Troubleshooting

Coolify startet nicht

# Logs prüfen
cd /data/coolify
docker compose logs -f

# Neustart erzwingen
docker compose down
docker compose up -d

Port 8000 nicht erreichbar

  • Firewall prüfen: sudo ufw status
  • Container-Status prüfen: docker ps
  • Ist ein anderer Dienst auf Port 8000? sudo ss -tlnp | grep 8000

SSL-Zertifikat wird nicht ausgestellt

  • DNS prüfen: dig +short app.example.com — Zeigt es auf eure Server-IP?
  • Ports 80/443 müssen von außen erreichbar sein
  • Traefik-Logs prüfen: docker logs coolify-proxy
  • Rate-Limit von Let’s Encrypt erreicht? Wartet eine Stunde

Build schlägt fehl

  • Build-Logs genau lesen — meist fehlen Dependencies
  • Speicherplatz prüfen: df -h
  • Docker-Cache leeren: docker system prune -a (Vorsicht!)
  • Bei Nixpacks: Prüft, ob die richtige Sprach-Version erkannt wird

Container startet, aber App nicht erreichbar

  • Stimmt der konfigurierte Port mit dem der App überein?
  • Lauscht die App auf 0.0.0.0 (nicht nur localhost)?
  • Container-Logs prüfen auf Fehler

Hoher RAM-Verbrauch

Coolify + Traefik + PostgreSQL + Redis brauchen ca. 1-1.5 GB RAM im Leerlauf. Dazu kommt eure App. Bei 2 GB RAM wird es eng — 4 GB sind die Empfehlung.

# RAM-Verbrauch pro Container
docker stats --no-stream --format "table {{.Name}}\t{{.MemUsage}}"

Coolify-Datenbank zurücksetzen (Notfall)

🚨 Achtung: Dies löscht alle Konfigurationen in Coolify! Nur im absoluten Notfall verwenden.

cd /data/coolify
docker compose down -v
docker compose up -d

Nächste Schritte

Euer Coolify-Server läuft — und jetzt? Hier sind Ideen, wie ihr weitermachen könnt:

  • Weitere Apps deployen — WordPress, Ghost, Plausible Analytics, Uptime Kuma, n8n, Gitea und viele mehr sind als One-Click-Services verfügbar
  • Multi-Server-Setup — Fügt weitere Server hinzu und verteilt eure Apps
  • CI/CD-Pipeline — Integriert Coolify in eure GitHub Actions / GitLab CI
  • Monitoring vertiefen — Richtet Grafana + Prometheus für detaillierteres Monitoring ein
  • Team-Zugang — Ladet Teammitglieder ein und vergebt Rollen
  • Eigene Templates — Erstellt wiederverwendbare Service-Templates für eure häufigsten Stacks

Coolify ist ein unglaublich mächtiges Tool, das ständig weiterentwickelt wird. Die offizielle Dokumentation ist hervorragend und wird regelmäßig aktualisiert.

Habt ihr Fragen oder Probleme? Schreibt es in die Kommentare — ich helfe gerne!