Coolify Installation – Self-Hosted Heroku/Vercel Alternative

Was ist Coolify?

Coolify ist eine Open-Source Platform-as-a-Service (PaaS) Lösung, die es Entwicklern ermöglicht, Anwendungen ähnlich wie auf Heroku oder Vercel selbst zu hosten und zu verwalten. Mit Coolify können Sie Anwendungen aus Git-Repositorys, Docker-Images oder aus vorgefertigten Vorlagen bereitstellen, ohne tief in Infrastruktur-Management einsteigen zu müssen.

Coolify läuft auf Ihren eigenen Servern oder VPS und bietet eine benutzerfreundliche Web-Oberfläche zur Verwaltung von Deployments, Datenbanken und Diensten.

Hauptfunktionen von Coolify

• Deployment aus Git: Automatisches Deployment direkt aus GitHub, GitLab oder Gitea mit Webhook-Unterstützung
• Docker-Support: Bereitstellung von Docker-Images und Compose-Dateien
• Automatisches SSL: Let's Encrypt Integration für kostenlose HTTPS
• Datenbankdienste: PostgreSQL, MySQL, MariaDB, MongoDB, Redis können direkt verwaltet werden
• Umgebungsvariablen: Einfache Verwaltung von Konfigurationen
• Webhooks: Automatisierte Deployments bei Git-Push
• Backups: Automatische Sicherungen von Datenbanken und Konfigurationen

Systemanforderungen

Komponente	Minimum	Empfohlen
Betriebssystem	Ubuntu 20.04	Ubuntu 22.04 LTS oder später
CPU-Kerne	2 vCPU	4+ vCPU
RAM	2 GB	4-8 GB
Festplatte	20 GB	50+ GB (je nach Anwendungen)
Docker	Docker 20.10+	Docker 24.0+

Installation von Coolify

Schritt 1: Server vorbereiten

Aktualisieren Sie zuerst das System:

apt update
apt upgrade -y
apt install -y curl wget git

Schritt 2: Coolify Installation Script ausführen

Coolify wird mit einem offiziellen Installations-Script installiert:

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

Das Script wird automatisch:

• Docker und Docker Compose prüfen/installieren
• Notwendige Verzeichnisse erstellen
• Docker-Images herunterladen
• Coolify starten

Schritt 3: Dashboard Access

Nachdem die Installation abgeschlossen ist, können Sie das Coolify-Dashboard aufrufen:

• Standard-Port: http://server-ip:8000
• Mit Domain: https://coolify.example.com (nach SSL-Konfiguration)

Beim ersten Zugriff wird ein Registrierungs-Dialog angezeigt. Erstellen Sie einen Admin-Account:

Email: admin@example.com
Passwort: Sicheres Passwort setzen (mindestens 8 Zeichen)

Initial-Setup und erste Konfiguration

Server hinzufügen

Coolify benötigt mindestens einen verbundenen Server. Sie können den lokalen Server (localhost) oder entfernte Server (über SSH) nutzen:

Lokalserver (Docker-Host wo Coolify läuft):

• Gehen Sie zu Servers im Dashboard
• Der "localhost" Server wird automatisch erkannt
• Überprüfen Sie die Verbindung

Entfernter Server (SSH):

• Gehen Sie zu Servers
• Klicken Sie Add Server
• SSH-Verbindungsdaten eingeben (IP, Port, Benutzer, SSH-Schlüssel)
• Coolify wird Docker auf dem entfernten Server prüfen/installieren

Erste Anwendung deployen

Schritt 1: Neues Projekt erstellen

# Im Coolify-Dashboard:
# Applications → New Application → Select Server

Schritt 2: Quelle konfigurieren (GitHub)

• Wählen Sie "Git Repository"
• Verbinden Sie Ihren GitHub-Account (OAuth)
• Wählen Sie Repository und Branch
• Coolify erkennt automatisch den Anwendungstyp (Node.js, Python, PHP, etc.)

Schritt 3: Deployment-Einstellungen

Root Directory: / (oder Untordner wie /backend)
Build Command: npm install && npm run build
Start Command: npm start
Environment Variables:
  - NODE_ENV: production
  - PORT: 3000

Schritt 4: Domain konfigurieren

• Fügen Sie Ihre Domain hinzu (z.B. app.example.com)
• Let's Encrypt SSL wird automatisch aktiviert
• DNS-Einträge müssen auf den Server zeigen

Schritt 5: Deployment starten

# Coolify zeigt Live-Logs während des Builds
# Build erfolgt mit Nixpacks (automatische Erkennung des Frameworks)

Docker Compose Anwendung deployen

Sie können auch komplette Docker Compose-Stacks mit Coolify deployen:

version: '3.8'

services:
  app:
    image: my-app:latest
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/appdb
      - NODE_ENV=production
    depends_on:
      - db
    restart: always

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=secure_password
      - POSTGRES_DB=appdb
    volumes:
      - db_data:/var/lib/postgresql/data
    restart: always

  redis:
    image: redis:7-alpine
    restart: always

volumes:
  db_data:

Deployment in Coolify:

• Wählen Sie "Docker Compose" als Quelle
• Fügen Sie die docker-compose.yml ein
• Coolify verwaltet den kompletten Stack

Datenbank-Services einrichten

Coolify kann Datenbankdienste automatisch bereitstellen:

PostgreSQL Datenbank hinzufügen

# Im Dashboard: Services → New Service → PostgreSQL
# Konfiguration:
Name: production-db
Database: appdb
User: appuser
Password: secure_password_here

Die Datenbankverbindung wird als Umgebungsvariable verfügbar gemacht:

DATABASE_URL=postgresql://appuser:secure_password_here@postgres:5432/appdb

Redis Cache einrichten

# Services → New Service → Redis
# Wird automatisch konfiguriert und ist einsatzbereit
REDIS_URL=redis://redis:6379/0

Umgebungsvariablen und Secrets

Umgebungsvariablen können direkt im Dashboard gesetzt werden:

# Applications → Select App → Environment Variables
NODE_ENV=production
API_KEY=your-secret-key
DATABASE_URL=postgresql://user:pass@db:5432/dbname
JWT_SECRET=your-jwt-secret-key
STRIPE_KEY=sk_live_xxxxxxxxxx

Webhooks für automatisierte Deployments

Configurieren Sie Webhooks für automatische Deployments bei Git-Push:

GitHub Webhook konfigurieren:

1. Gehen Sie zu Ihrem GitHub Repository
2. Settings → Webhooks → Add webhook
3. Payload URL: https://coolify.example.com/api/v1/webhooks/github
4. Content Type: application/json
5. Events: Push events
6. Active: Aktivieren

Die Webhook-URL können Sie auch im Coolify-Dashboard kopieren:

# Applications → Select App → Deployment → Webhooks
# Kopieren Sie die GitHub-URL in Ihr Repository

Custom Domain mit Auto-SSL (Let's Encrypt)

SSL-Zertifikate werden automatisch verwaltet:

1. Im Dashboard: Applications → Select App → Domains
2. Fügen Sie Ihre Domain ein: app.example.com
3. Konfigurieren Sie DNS-Einträge:

   app.example.com A 192.168.1.100

4. Coolify erstellt automatisch ein Let's Encrypt Zertifikat
5. HTTPS ist sofort verfügbar

Das Zertifikat wird automatisch 30 Tage vor Ablauf erneuert.

Backups und Updates

Konfiguration sichern

# Coolify Konfiguration und Datenbank sichern
docker exec coolify tar -czf - /app/db > coolify-backup-$(date +%Y%m%d).tar.gz

# Anwendungs-Datenbanken sichern
docker exec postgres pg_dump -U user appdb > appdb-backup-$(date +%Y%m%d).sql

Coolify aktualisieren

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

Das Upgrade-Script:

• Sichert automatisch die aktuelle Konfiguration
• Updated die Docker-Images
• Führt Datenbank-Migrationen durch
• Behält alle Einstellungen bei

Feature-Vergleich: Coolify vs Alternativen

Feature	Coolify	Dokku	CapRover	Heroku
Selbst-gehostet	Ja	Ja	Ja	Nein (Cloud)
Web-Interface	Modern, Vollständig	CLI-basiert	Web-UI	Web + CLI
Docker Compose Support	Ja	Nein	Ja	Nein
Git Deployment	Ja	Ja (Buildpacks)	Ja	Ja
Let's Encrypt	Automatisch	Plugin	Automatisch	Automatisch
Datenbank-Services	PostgreSQL, MySQL, MongoDB, Redis	Via Docker	Via Docker	Add-ons (kostenpflichtig)
Kosten (100GB RAM)	Nur Server (ca. €20-50/Monat)	Nur Server	Nur Server	€500+/Monat

Häufige Probleme und Lösungen

Problem: "Database connection failed"

Lösung: Überprüfen Sie die Verbindungs-URL und Anmeldedaten. Die Datenbank muss erreichbar sein:

# Test Datenbankverbindung
docker exec coolify curl -I postgresql://user:pass@db:5432/dbname

Problem: SSL-Zertifikat wird nicht erstellt

Lösung: DNS muss auf Ihren Server zeigen. Überprüfen Sie:

nslookup app.example.com
# Sollte Ihre Server-IP zurückgeben

Problem: Application crashed nach Deployment

Lösung: Überprüfen Sie die Logs im Dashboard oder via CLI:

docker logs 

Verwandte Artikel

• 📖 Docker Compose Grundlagen Anleitung
• 📖 Traefik Reverse Proxy mit Docker
• 📖 Nginx Reverse Proxy Konfiguration
• 🔧 Sichere Server bei Enjyn mieten