Modul 12: Deployment

Coolify-Deployment

Self-Hosted PaaS — Nuxt-Apps auf dem eigenen Server deployen

Was ist Coolify?

Coolify ist eine Open-Source Platform-as-a-Service (PaaS), die du auf deinem eigenen Server installierst. Es funktioniert wie Heroku oder Vercel — aber du behältst die volle Kontrolle über deine Daten und Infrastruktur.

Mit Coolify kannst du Git-Repositories verbinden, Docker-basierte Apps deployen, SSL-Zertifikate automatisch verwalten und mehrere Projekte auf einem Server betreiben.

🛤️

Rails-Vergleich: Heroku / Kamal vs Coolify

Feature	Heroku	Kamal (Rails)	Coolify
Self-Hosted	❌	✅	✅
Git-Integration	✅	❌	✅
Web-UI	✅	❌ (CLI)	✅
SSL automatisch	✅	✅ (Traefik)	✅ (Traefik)
Multi-App	✅	✅	✅
Kosten	Ab $5/Mo	Server-Kosten	Server-Kosten
Docker Compose	❌	❌	✅

Coolify kombiniert das Beste aus Heroku (einfache UI, Git-Push-Deploy) und Kamal (Self-Hosted, Docker-basiert). Perfekt für Entwickler, die ihre Infrastruktur selbst betreiben wollen.

Coolify installieren

Auf dem Server (VPS)

# Voraussetzung: Ein VPS mit Ubuntu 22.04+, min. 2 GB RAM
# z.B. bei Hetzner, DigitalOcean, Contabo

# Coolify mit einem Befehl installieren
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

# Nach der Installation:
# → Coolify läuft auf http://DEIN-SERVER:8000
# → Erstelle beim ersten Aufruf einen Admin-Account
# → Verbinde deinen Server als "Destination"

ℹ️

Was Coolify installiert

Docker — Falls noch nicht vorhanden
Traefik — Reverse-Proxy für SSL und Routing
Coolify-Dashboard — Web-UI zur Verwaltung
PostgreSQL — Für Coolify's eigene Datenbank

Git-Repository verbinden

Coolify unterstützt GitHub, GitLab und Gitea. Die Verbindung ermöglicht automatische Deployments bei jedem Push.

Schritte in Coolify

1. Coolify Dashboard öffnen → "New Resource"

2. "Application" wählen

3. Git-Provider auswählen:
   → GitHub: OAuth-Verbindung oder Deploy-Key
   → GitLab: Personal Access Token
   → Öffentliche Repos: Direkte URL

4. Repository auswählen:
   → Repository: github.com/dein-user/vue-tutorial
   → Branch: main

5. Build-Konfiguration:
   → Build Pack: "Docker Compose" oder "Dockerfile"
   → Bei Docker Compose: docker-compose.yml auswählen
   → Bei Dockerfile: Dockerfile im Root wird erkannt

6. "Deploy" klicken → Coolify baut und startet die App

💡

Automatische Deployments

Aktiviere den Webhook in den Coolify-Einstellungen. Coolify erstellt automatisch einen Webhook in deinem GitHub-Repository. Bei jedem Push auf den konfigurierten Branch wird automatisch neu deployed.

Docker Compose Deployment

Coolify kann Docker Compose-Dateien direkt deployen — ideal für unsere Nuxt + json-server Kombination:

docker-compose.prod.yml

services:
  nuxt:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      - NODE_ENV=production
      - NUXT_PUBLIC_API_BASE=http://json-server:3001
    healthcheck:
      test: ['CMD', 'wget', '--spider', '-q', 'http://localhost:3000']
      interval: 30s
      timeout: 5s
      retries: 3
    # Port wird von Coolify/Traefik automatisch geroutet
    # NICHT manuell ports: angeben!

  json-server:
    image: node:20-alpine
    working_dir: /data
    command: >
      sh -c 'npm install -g json-server &&
             json-server --watch db.json --port 3001 --host 0.0.0.0'
    volumes:
      - json-data:/data
    healthcheck:
      test: ['CMD', 'wget', '--spider', '-q', 'http://localhost:3001']
      interval: 10s
      timeout: 3s
      retries: 5

volumes:
  json-data:

⚠️

Ports in Coolify

In Coolify brauchst du keine ports: im Docker Compose anzugeben. Traefik routet den Traffic automatisch. Konfiguriere den exponierten Port stattdessen in den Coolify-Einstellungen unter "Network" → "Exposed Port".

Umgebungsvariablen in Coolify

Coolify Dashboard → Environment Variables

┌──────────────────────────────────────────────────────┐
│  Environment Variables                               │
├──────────────────────────────────────────────────────┤
│                                                      │
│  Schlüssel                │ Wert            │ Secret │
│  ─────────────────────── │ ─────────────── │ ────── │
│  NODE_ENV                │ production      │   ☐    │
│  NUXT_PUBLIC_API_BASE    │ http://json-..  │   ☐    │
│  NUXT_PUBLIC_APP_NAME    │ Kontakte-Mgr    │   ☐    │
│  NUXT_JWT_SECRET         │ ••••••••••••    │   ☑    │
│  NUXT_SESSION_SECRET     │ ••••••••••••    │   ☑    │
│                                                      │
│  [+ Variable hinzufügen]                             │
│                                                      │
│  ℹ️  Secrets werden verschlüsselt gespeichert und   │
│     sind nur zur Build- und Laufzeit verfügbar.     │
└──────────────────────────────────────────────────────┘

ℹ️

Build vs. Runtime Variablen

Build-Time — Verfügbar während docker build. Für NUXT_PUBLIC_ Variablen, die ins Client-Bundle eingebaut werden.
Runtime — Verfügbar wenn der Container läuft. Für Server-Secrets.
In Coolify kannst du pro Variable festlegen, ob sie beim Build und/oder zur Laufzeit verfügbar sein soll.

SSL und Domain-Setup

Domain-Konfiguration in Coolify

Schritte:

1. DNS konfigurieren:
   → A-Record: kontakte.deine-domain.de → SERVER-IP
   → Oder Wildcard: *.deine-domain.de → SERVER-IP

2. In Coolify → Application → "General" Tab:
   → Domain: kontakte.deine-domain.de
   → HTTPS: Automatisch (Let's Encrypt) ✅

3. Coolify kümmert sich automatisch um:
   → Let's Encrypt Zertifikat anfordern
   → SSL-Terminierung via Traefik
   → HTTP → HTTPS Redirect
   → Zertifikat-Erneuerung

4. Testen:
   → https://kontakte.deine-domain.de ✅
   → http://kontakte.deine-domain.de → Redirect zu HTTPS

💡

Mehrere Domains

Du kannst mehrere Domains oder Subdomains auf dieselbe App zeigen lassen. Coolify und Traefik routen den Traffic automatisch. Jede Domain bekommt ihr eigenes SSL-Zertifikat.

Monitoring und Logs

Coolify Monitoring-Features

┌──────────────────────────────────────────────────────┐
│  Application → Logs                                  │
├──────────────────────────────────────────────────────┤
│                                                      │
│  📋 Container Logs (Live-Stream):                    │
│  [2024-01-15 10:23:01] Listening on 0.0.0.0:3000    │
│  [2024-01-15 10:23:15] GET / 200 - 45ms             │
│  [2024-01-15 10:23:16] GET /api/kontakte 200 - 12ms │
│  [2024-01-15 10:24:02] GET /api/health 200 - 2ms    │
│                                                      │
│  📊 Container Stats:                                 │
│  CPU:    2.3%                                        │
│  Memory: 128 MB / 2048 MB                            │
│  Network I/O: 1.2 MB in / 3.4 MB out                │
│                                                      │
│  🔄 Deployment History:                              │
│  #5  15.01.2024 10:20  ✅ Erfolgreich  (main@abc123)│
│  #4  14.01.2024 16:45  ✅ Erfolgreich  (main@def456)│
│  #3  14.01.2024 14:30  ❌ Fehlgeschlagen             │
│  #2  13.01.2024 09:15  ✅ Erfolgreich  (main@ghi789)│
└──────────────────────────────────────────────────────┘

Nützliche Befehle auf dem Server

# Container-Status prüfen
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'

# Logs eines Containers anschauen
docker logs -f --tail 100 CONTAINER_NAME

# In einen Container einloggen
docker exec -it CONTAINER_NAME sh

# Ressourcenverbrauch aller Container
docker stats --no-stream

# Coolify-eigene Container anzeigen
docker ps --filter 'label=coolify.managed=true'

ℹ️

Benachrichtigungen

Coolify kann dich bei Deployment-Events benachrichtigen über:

E-Mail — Einfach, aber effektiv
Discord — Webhook-Integration
Slack — Webhook-Integration
Telegram — Bot-Integration

Konfiguriere Benachrichtigungen unter "Settings" → "Notifications".

Zusammenfassung

💡

Coolify-Deployment Checkliste

Coolify installieren — Ein Befehl auf dem VPS
Git verbinden — GitHub/GitLab OAuth oder Deploy-Key
Docker Compose — Nuxt + json-server zusammen deployen
Umgebungsvariablen — Secrets sicher in Coolify verwalten
Domain + SSL — DNS-Record setzen, Coolify erledigt den Rest
Monitoring — Logs, Stats und Deployment-History in der UI
Auto-Deploy — Webhook für Push-basiertes Deployment