Coolify auf einem selbst gehosteten Ubuntu-Server installieren und konfigurieren

Coolify ist eine Open-Source-Plattform für selbst gehostetes Platform as a Service (PaaS), die einen Entwickler-Workflow ähnlich wie Heroku auf einer eigenen Infrastruktur ermöglicht. Statt Docker, Reverse Proxys, Datenbanken und CI/CD-Pipelines auf jedem Server einzeln manuell einzurichten, installieren Sie Coolify einmal, verbinden weitere Maschinen per SSH und stellen containerisierte Anwendungen über ein zentrales Web-Dashboard bereit.

Diese Anleitung führt anfängerfreundlich durch die Installation und Konfiguration von Coolify auf einem selbst gehosteten Ubuntu-Server. Sie erfahren, wie Sie zusätzliche Server anbinden, Ihre erste containerisierte Anwendung bereitstellen, eine Datenbank erstellen, HTTPS aktivieren und typische Probleme beheben. So können moderne Workloads auf Cloud-Servern oder virtuellen Maschinen betrieben werden, ohne die Komplexität eines vollständigen Kubernetes-Clusters übernehmen zu müssen.

Wichtige Erkenntnisse

• Selbst gehostetes PaaS für moderne Workloads: Docker-basierte Anwendungen wie Node.js, Laravel, Go und Next.js lassen sich mit automatischem HTTPS, geschützter Geheimnisverwaltung und integrierten Logs bereitstellen und verwalten.
• Schnelle Installation und schneller Start: Mit einem einzigen Befehl werden Docker, Traefik und das Coolify-Dashboard installiert, wodurch der Einrichtungsaufwand sinkt und mehr Zeit für die eigentlichen Anwendungen bleibt.
• Einfache Multi-Server-Verwaltung: Zusätzliche Server können per SSH eingebunden werden, um Anwendungen, Datenbanken und Hintergrundjobs auszuführen – gesteuert über die zentrale Coolify-Oberfläche.
• Reibungslose Git-Integration: GitHub, GitLab oder andere Repository-Dienste lassen sich anbinden, um Builds und Deployments automatisch auszulösen, sobald Code gepusht wird. Integrierte Health Checks sorgen für mehr Zuverlässigkeit.
• Für den Produktionseinsatz vorbereitet: Zentrale Protokollierung, verschlüsselte Secrets, umgebungsspezifische Variablen, persistente Volumes und automatisierte Jobplanung unterstützen den stabilen Betrieb dauerhaft verfügbarer Dienste.

Nach Abschluss dieses Tutorials wissen Sie, wie Coolify als flexible, selbst gehostete PaaS-Lösung bereitgestellt, abgesichert und betrieben wird – von kleinen Nebenprojekten bis hin zu ernsthaften Produktions-Workloads.

Was ist Coolify und warum sollte man es einsetzen?

Coolify bündelt Docker, Reverse-Proxy-Verwaltung und Multi-Node-Orchestrierung hinter einer Weboberfläche. Dadurch können Sie:

• containerisierte Anwendungen bereitstellen, ohne rohe Docker-Compose- oder Traefik-Konfigurationsdateien schreiben zu müssen.
• Anwendungen, Datenbanken und Hintergrundprozesse in Projekten und Umgebungen organisieren.
• neue Server über SSH-Schlüssel anbinden, statt Pakete manuell zu installieren.
• Deployments über lokale Systeme und cloudbasierte Infrastruktur hinweg standardisieren.

Coolify ist eine sinnvolle Zwischenlösung für Teams, die über einfache Single-Server-Setups, individuelle Nginx-Proxys oder einfache Shell-Skripte hinausgewachsen sind, aber die operative Komplexität eines vollständigen Kubernetes-Clusters noch nicht übernehmen möchten. Es handelt sich um ein selbst gehostetes Platform as a Service, das nützliche Abstraktionen auf vertrauten Komponenten aufbaut.

Zentrale Funktionen von Coolify

Coolify ist so gestaltet, dass es sich für Entwickler vertraut anfühlt, die bereits mit verwalteten PaaS-Plattformen gearbeitet haben:

• Zentrales Dashboard: Anwendungen, Datenbanken, Queues, Speicher und Jobs lassen sich über eine gemeinsame Oberfläche verwalten.
• Projekte und Umgebungen: Ressourcen können in Projekte mit Produktions-, Staging- und Preview-Umgebungen gegliedert werden.
• Multi-Server-Unterstützung: Mehrere virtuelle Maschinen lassen sich als verwaltete Server verbinden, wobei Anwendungen oder Datenbanken bestimmten Nodes zugewiesen werden können.
• Git-Integration: Deployments können direkt aus Git-Repositories erfolgen, entweder über Dockerfiles oder Presets für gängige Frameworks.
• Integrierter Reverse Proxy und HTTPS: Traefik übernimmt automatisch Routing und Let’s-Encrypt-Zertifikate.
• Secrets und Konfiguration: Projektspezifische Umgebungsvariablen und Secrets werden sicher gespeichert und beim Deployment in Services eingebunden.
• Volumes und Storage: Persistente Volumes oder Netzwerkspeicher können an zustandsbehaftete Dienste wie PostgreSQL oder Jenkins angebunden werden.
• Geplante Aufgaben: Cron-ähnliche Jobs können innerhalb von Containern ausgeführt werden, etwa für Backups, Bereinigungen oder wiederkehrende Skripte.

Das passende Deployment-Modell wählen: lokal, Cloud und Multi-Server

Wie viele moderne Plattformen kann Coolify auf unterschiedliche Weise bereitgestellt werden:

Für die meisten Entwickler und kleinen Teams bietet ein Coolify-Server zusammen mit einem oder mehreren Anwendungs- oder Datenbankservern in derselben Region einen guten Kompromiss aus Einfachheit und Ausfallsicherheit.

Voraussetzungen

Vor der Installation von Coolify sollten folgende Anforderungen erfüllt sein:

• Ein Ubuntu-22.04-LTS-Server oder eine neuere Version für den Coolify-Server
• Mindestens 4 CPU-Kerne, 4 GB RAM und 80 GB Speicherplatz auf dem Server
• Ein Domainname, der für Dashboard und HTTPS auf den Coolify-Server zeigt
• Root- oder sudo-Zugriff per SSH
• Ein SSH-Schlüsselpaar zur Authentifizierung gegenüber verwalteten Servern
• Optional, aber empfohlen: eine zusätzliche virtuelle Maschine für Datenbanken oder CPU-intensive Workloads

Obwohl Coolify Docker automatisch installieren kann, ist ein grundlegendes Verständnis von Docker-Befehlen hilfreich.

Schritt 1 — Den Coolify-Server einrichten

Beginnen Sie damit, sich mit dem Server zu verbinden, der als Coolify-Server dienen soll. Diese Maschine ist der zentrale Node, der Ihre Anwendungen und Infrastruktur verwaltet.

Ersetzen Sie 192.168.2.2 durch den tatsächlichen Domainnamen oder die IP-Adresse Ihres Servers. Wenn der Server gerade erst erstellt wurde, stellen Sie sicher, dass Ihr SSH-Schlüssel über das Dashboard Ihres Infrastruktur-Anbieters oder per manueller Konfiguration hinzugefügt wurde.

Verbinden Sie sich beispielsweise als Root-Benutzer:

ssh root@192.168.2.2

Aktualisieren Sie den Paketindex und installieren Sie verfügbare Sicherheitsupdates:

sudo apt update && sudo apt upgrade -y

Sicherstellen, dass der Hostname korrekt aufgelöst wird

Coolify benötigt einen Server-Hostnamen, der auf eine nicht lokale Loopback-IP-Adresse verweist. Wenn der Hostname auf 127.0.0.1 oder auf mehrere IP-Adressen zeigt, können bestimmte Vorgänge fehlschlagen oder verwirrende Adressen anzeigen.

Prüfen Sie, wie der Hostname aufgelöst wird:

hostname --ip-address

Wenn nur Loopback-Adressen wie 127.0.0.1 zurückgegeben werden, bearbeiten Sie /etc/hosts:

sudo nano /etc/hosts

Beispiel:

127.0.0.1   localhost
192.0.2.10  coolify-server.example.com coolify-server
::1         localhost ip6-localhost ip6-loopback
ff02::1     ip6-allnodes
ff02::2     ip6-allrouters

Speichern Sie die Datei und führen Sie die Hostname-Prüfung erneut aus:

hostname --ip-address

Nun sollte die routbare IP-Adresse Ihres Coolify-Servers angezeigt werden.

Schritt 2 — Coolify installieren

Coolify stellt einen Ein-Befehl-Installer bereit, der Docker, Traefik, die zentralen Dienste und das Dashboard einrichtet.

Führen Sie folgenden Befehl aus:

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

Das Skript führt folgende Schritte aus:

• Es prüft das Betriebssystem und die erforderlichen Abhängigkeiten.
• Es installiert Docker und unterstützende Pakete, falls erforderlich.
• Es stellt Coolify und dessen interne Dienste bereit.
• Es zeigt nach Abschluss der Einrichtung die Dashboard-URL an.

Wenn die Installation abgeschlossen ist, üblicherweise nach 3 bis 5 Minuten, erscheint eine Ausgabe.

Der Installer zeigt die Dashboard-URL an. Notieren Sie sich alle Zugangsdaten oder weiteren Hinweise, die in der Terminalausgabe erscheinen.

Öffnen Sie die URL in Ihrem Browser:

https://coolify-server.example.com

Hinweis: Falls die DNS-Propagation noch nicht abgeschlossen ist, können Sie vorübergehend über die IP-Adresse des Servers auf das Dashboard zugreifen.

Schritt 3 — Die erste Einrichtung der Coolify-Weboberfläche abschließen

Beim ersten Öffnen von Coolify führt die Plattform durch einen Onboarding-Prozess zur Konfiguration der Instanz:

Owner-Konto erstellen

• E-Mail-Adresse
• Name
• Starkes Passwort

Grundkonfiguration prüfen

• Instanzname, falls gewünscht
• Standardsprache und Zeitzone
• Telemetry- und Update-Einstellungen

Erstes Projekt erstellen

• Verwenden Sie einen Projektnamen wie My First Project
• Behalten Sie die standardmäßige Produktionsumgebung bei
• Planen Sie optional Staging- oder Preview-Umgebungen für später ein

Diese erste Einrichtung erstellt Ihre Control Plane und bietet Ihnen einen eigenen Bereich, in dem Sie mit dem Hinzufügen von Servern und Anwendungen beginnen können.

Schritt 4 — Verwaltete Server hinzufügen

Der Coolify-Server betreibt das Coolify-Dashboard und ausgewählte Plattformdienste. Ihre Anwendungen und Datenbanken können ausgeführt werden auf:

• dem Coolify-Server selbst oder
• zusätzlichen verwalteten Servern, die per SSH verbunden sind.

So fügen Sie einen neuen Server über das Dashboard hinzu:

1. Gehen Sie zu Servers → Add Server.
2. Wählen Sie Local für dieselbe Maschine oder SSH für einen entfernten Server.

Für SSH-basierte Server geben Sie Folgendes an:

• Hostname oder IP-Adresse, zum Beispiel app-1.example.com
• SSH-Benutzer, etwa root oder ein Benutzer mit sudo-Rechten

Coolify erzeugt einen SSH-Schlüssel und zeigt ihn im Dashboard an. Kopieren Sie den vollständigen öffentlichen Schlüssel, der mit ssh-ed25519 oder ssh-rsa beginnt, und fügen Sie ihn auf dem Zielserver zur Datei ~/.ssh/authorized_keys hinzu:

echo "ssh-ed25519 AAAA...your-actual-key-here... coolify" | sudo tee -a ~/.ssh/authorized_keys

Hinweis: Ersetzen Sie den Platzhalter AAAA...your-actual-key-here... durch den vollständigen öffentlichen Schlüssel, der im Coolify-Dashboard angezeigt wird.

Klicken Sie in der Coolify-Oberfläche auf Verify, um zu bestätigen, dass die Verbindung funktioniert.

Nach erfolgreicher Verifizierung installiert Coolify Docker und den Agent auf dem verwalteten Server. Dies dauert in der Regel 1 bis 2 Minuten. Anschließend zeigt das Dashboard CPU-, RAM-, Festplatten- und Statusmetriken für den neuen Server an.

Wiederholen Sie diesen Vorgang für:

• Anwendungsserver, die API- und Webdienste ausführen
• Datenbankserver für PostgreSQL, MySQL oder MongoDB
• Job-Runner-Server für Cron-ähnliche Workloads

Schritt 5 — Eine Anwendung aus Git bereitstellen

Die meisten Produktions-Workloads werden aus eigenen Repositories bereitgestellt. Coolify kann diese Anwendungen direkt aus Git bauen und deployen.

1. Verbinden Sie im Dashboard Ihren Git-Anbieter, beispielsweise GitHub, GitLab, Gitea oder einen anderen unterstützten Dienst.
2. Fügen Sie eine neue Anwendung hinzu und wählen Sie Git Repository als Quelle.
3. Wählen Sie Repository und Branch aus, zum Beispiel main.
4. Hinterlegen Sie ein Dockerfile oder nutzen Sie ein Preset für gängige Frameworks.

Konfigurieren Sie Umgebungsvariablen und Secrets:

NODE_ENV=production
DATABASE_URL=postgres://user:password@db:5432/app
API-Schlüssel für Drittanbieter-Dienste

Beispiel-Dockerfile für eine Node.js- oder Next.js-Anwendung:

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/.next ./.next
COPY package*.json ./
RUN npm ci --omit=dev
EXPOSE 3000
CMD ["npm", "start"]

1. Aktivieren Sie automatische Deployments bei Push, wenn jeder Commit einen neuen Build und Rollout starten soll.
2. Klicken Sie auf Deploy, um den ersten Build und das erste Deployment auszuführen.

Coolify klont das Repository, baut das Image mit BuildKit-Caching, startet den Container und verbindet ihn für das HTTPS-Routing mit Traefik. Je nach Komplexität des Dockerfiles dauert der Build üblicherweise 2 bis 5 Minuten. Öffnen Sie die Detailseite der Anwendung und wählen Sie den Tab Logs, um den Build-Fortschritt in Echtzeit zu verfolgen.

Hinweis: Prüfen Sie bei ersten Deployments die Logs sorgfältig auf Build-Fehler. Häufige Ursachen sind fehlende Abhängigkeiten, falsche Dockerfile-Pfade oder fehlerhaft konfigurierte Umgebungsvariablen.

Schritt 6 — Datenbanken und unterstützende Dienste bereitstellen

Coolify enthält Vorlagen für gängige unterstützende Dienste:

• PostgreSQL
• MySQL / MariaDB
• Redis
• MongoDB

So erstellen Sie eine PostgreSQL-Instanz:

1. Klicken Sie innerhalb Ihres Projekts auf Add Resource → Databases → PostgreSQL.
2. Wählen Sie den Zielserver aus.
3. Wählen Sie die Version aus, zum Beispiel 15.
4. Legen Sie Speichergröße und Volume-Pfad fest.

Coolify erstellt den Container, legt Datenbankname, Benutzer und Passwort fest und stellt eine Verbindungs-URI bereit. Die Zugangsdaten werden im Dashboard angezeigt und automatisch in den Projekt-Secrets gespeichert.

Kopieren Sie die Verbindungs-URI von der Ressourcen-Seite der Datenbank. Sie befindet sich unter Connection Information. Verwenden Sie sie anschließend in den Umgebungsvariablen Ihrer Anwendung. Beispielformat:

DATABASE_URL=postgres://app_user:strongpassword@postgresql:5432/app_db

Hinweis: Ersetzen Sie die Beispielwerte durch die tatsächlichen Zugangsdaten, die Coolify generiert hat. Das Format der Verbindungs-URI kann je nach Netzwerkkonfiguration abweichen. Verwenden Sie den Servicenamen postgresql für Container im selben Projekt oder die vollständige Domain für externe Verbindungen.

Sie können außerdem verwalten:

• Datenbank-Backups über geplante Jobs
• Read Replicas durch das Erstellen zusätzlicher Instanzen und das Aktualisieren der Anwendungskonfiguration

Beispiel: Jenkins mit Coolify bereitstellen

Um Ihre Coolify-Einrichtung zu prüfen und praktisch zu sehen, wie containerisierte Anwendungen funktionieren, können Sie einen bekannten Dienst wie Jenkins bereitstellen. Dieses Beispiel zeigt die Bereitstellung eines vorgefertigten Docker-Images aus Docker Hub.

Anwendungsfall

Jenkins ist ein weit verbreiteter CI/CD-Automatisierungsserver, den viele Teams zum Bauen, Testen und Bereitstellen von Anwendungen nutzen. Wenn Jenkins über Coolify bereitgestellt wird, kann es zusammen mit anderen Anwendungen verwaltet werden, profitiert von automatischem HTTPS und lässt sich einfacher auf andere Server verschieben oder skalieren.

Deployment-Schritte

1. Klicken Sie innerhalb Ihres Projekts auf Add Resource → Applications.
2. Wählen Sie ein Template aus oder nutzen Sie Docker Hub / Container Registry und suchen Sie nach jenkins/jenkins:lts.

Konfigurieren Sie die Anwendung:

• Name: jenkins-ci
• Server: Wählen Sie den verwalteten Server aus, auf dem Jenkins laufen soll
• Domain: jenkins.example.com
• Port: 8080, der Standardport von Jenkins
• Volumes: Ordnen Sie /var/jenkins_home einem benannten Volume oder einem eingebundenen Speicherpfad wie /mnt/data/jenkins_home zu, damit Jenkins-Konfiguration und Job-Daten dauerhaft erhalten bleiben.

Speichern Sie die Konfiguration und klicken Sie auf Deploy.

Coolify wird:

• das Jenkins-Image aus Docker Hub herunterladen,
• das Docker-Netzwerk und das Volume erstellen,
• den Container starten,
• Logs während des Starts streamen.

Sobald sich der Status auf Running ändert:

• öffnen Sie https://jenkins.example.com in Ihrem Browser, um den integrierten Jenkins-Onboarding-Prozess zu starten.

Nach kurzer Zeit sollte Jenkins vollständig installiert und einsatzbereit sein.

Sie können Plugins installieren, Jobs erstellen und Jenkins wie bei einer klassischen Installation konfigurieren. Gleichzeitig profitieren Sie von der Coolify-Verwaltungsoberfläche, automatischem HTTPS sowie einfacheren Backup- und Wiederherstellungsoptionen über die Volume-Verwaltung.

Dieses Beispiel zeigt, wie Coolify die Bereitstellung jeder containerisierten Anwendung vereinfacht – unabhängig davon, ob es sich um ein fertiges Image aus einer Registry oder um eine individuell aus Git-Repositories gebaute Anwendung handelt.

Häufige Fehler beheben

Nutzen Sie die Logs und Servermetriken von Coolify, um Probleme gezielt einzugrenzen. Für weiterführende Observability können Logs an einen ELK-Stack weitergeleitet oder Metriken an ein Prometheus- und Grafana-Setup gesendet werden.

FAQs

Ist Coolify sicher genug für den Produktionseinsatz?

Ja. Coolify führt Anwendungen in Docker-Containern aus, übernimmt die HTTPS-Terminierung über Traefik und hält Secrets getrennt vom Code. Dennoch sollte das Betriebssystem mit Firewalls, regelmäßigen Updates und bewährten SSH-Sicherheitsmaßnahmen abgesichert werden.

Kann ich mehrere Server mit einer einzigen Coolify-Instanz verwalten?

Ja. Sie können mehrere Server registrieren, unterschiedliche Anwendungen auf einzelnen Servern bereitstellen und Projekte sowie Umgebungen nutzen, um Ressourcen strukturiert zu organisieren.

Unterstützt Coolify ausschließlich Docker-basierte Anwendungen?

Coolify ist auf Docker ausgerichtet. Wenn Ihre Anwendung containerisiert werden kann, kann sie mit Coolify betrieben werden. Für Anwendungen, die noch nicht containerisiert sind, wird im Rahmen der Migration üblicherweise ein Docker-Image erstellt.

Wie funktionieren automatische Deployments aus Git?

Nach dem Verbinden des Git-Anbieters erstellt Coolify Webhooks, sodass Pushes auf einen Branch, beispielsweise main, einen neuen Build und ein Deployment auslösen. Automatische Deployments können deaktiviert werden, oder kritische Dienste können weiterhin manuell bereitgestellt werden.

Kann ich von Coolify verwaltete Datenbanken sichern?

Ja. Sie können innerhalb von Coolify geplante Jobs ausführen, um pg_dump oder andere Backup-Befehle zu starten und die Sicherungsdateien anschließend an Block Storage oder Object-Storage-Dienste zu übertragen.

Was passiert, wenn der Coolify-Server nicht verfügbar ist?

Anwendungen auf verwalteten Servern laufen weiter, allerdings sind Dashboard- und Orchestrierungsfunktionen vorübergehend nicht verfügbar. Erstellen Sie Backups des Coolify-Servers und erwägen Sie eine ausfallsicherere Klasse virtueller Maschinen für die Control Plane.

Fazit

Coolify stellt eine praktische, selbst gehostete PaaS-Schicht auf Docker-Basis bereit. Die Plattform hilft, Deployments über virtuelle Maschinen und andere Infrastruktur hinweg zu standardisieren, ohne direkt auf Kubernetes wechseln zu müssen. Mit einem Coolify-Server, einigen verwalteten Servern und Git-basierten Builds können Produktionsanwendungen mit klarer Sicht auf Logs, Ressourcen und Fehler betrieben werden.

Richten Sie den Coolify-Server ein, fügen Sie ein oder zwei Anwendungsserver hinzu, stellen Sie einen Test-Workload wie Jenkins bereit und migrieren Sie anschließend Ihre echten Anwendungen Schritt für Schritt. Wenn Ihre Anforderungen wachsen, können weitere Server, Umgebungen und Dienste ergänzt werden, ohne die Plattform von Grund auf neu aufzubauen.