Ghost als Headless CMS einrichten

Warum Ghost als Headless CMS?

Ghost ist eine Open-Source-Publishing-Plattform mit über 52.000 GitHub Stars. Der Fokus liegt auf dem Schreiben: ein aufgeräumter Editor, Mitgliederverwaltung, Newsletter-Versand und eine native Content API. Ghost eignet sich als Headless CMS für Blogs, Magazine, Dokumentationen und Content-Marketing.

Im Gegensatz zu einem reinen API-first CMS wie Strapi bringt Ghost ein eigenes Frontend mit. Im Headless-Modus wird dieses deaktiviert und stattdessen das eingebaute Content-API genutzt, um Inhalte an ein eigenes Frontend (Nuxt, Next.js, Astro) zu liefern. Redakteure arbeiten weiterhin im gewohnten Ghost-Editor, Entwickler haben volle Kontrolle über die Darstellung.

Diese Anleitung beschreibt zwei Wege zur Installation:

Weg A: Über Coolify (empfohlen für Einsteiger): Ein-Klick-Installation, automatisches SSL
Weg B: Über Docker Compose (für mehr Kontrolle): manuelle Konfiguration, volle Flexibilität

Voraussetzungen

Ein Seed in der dataforest Cloud (empfohlen: 2 CPU, 4 GB RAM; 1 CPU / 2 GB reichen für den Einstieg). Ghost ist ressourcensparsam und läuft bereits auf kleinen Modellen flüssig.
SSH-Zugriff auf den Seed
Eine eigene Domain (z.B. blog.ihre-firma.de), die per DNS A-Record auf die IP-Adresse Ihres Seeds zeigt. Den A-Record setzen Sie bei Ihrem Domain-Anbieter: Tragen Sie dort die IP-Adresse des Seeds als Ziel für die gewünschte Subdomain ein. Nach dem Setzen kann es bis zu einer Stunde dauern, bis der Eintrag weltweit aktiv ist.
Für Weg A: Coolify auf dem Seed installiert (siehe Coolify-Guide)

Weg A: Installation über Coolify

Coolify bietet Ghost als Ein-Klick-Service. Wenn Sie Coolify bereits nutzen, ist dies der schnellste Weg.

1. Ghost-Service anlegen

Öffnen Sie das Coolify-Dashboard und navigieren Sie zu Ihrem Projekt. Klicken Sie auf New Resource und wählen Sie Service. In der Service-Liste suchen Sie nach Ghost und wählen es aus.

2. Domain konfigurieren

In den Service-Einstellungen tragen Sie Ihre Domain ein (z.B. blog.ihre-firma.de). Coolify konfiguriert automatisch ein Let's-Encrypt-Zertifikat für HTTPS.

3. Umgebungsvariablen prüfen

Coolify setzt MySQL als Datenbank automatisch auf. Prüfen Sie in den Umgebungsvariablen folgende Werte:

url: Muss Ihre vollständige URL enthalten (z.B. https://blog.ihre-firma.de). Ohne diese Variable generiert Ghost fehlerhafte Links.
database__connection__password: Datenbank-Passwort (ändern Sie den Standardwert)

4. Service starten

Klicken Sie auf Deploy. Coolify startet Ghost und MySQL, konfiguriert SSL und richtet die Datenbank ein. Nach wenigen Minuten ist Ihr CMS unter Ihrer Domain erreichbar.

Weg B: Installation über Docker Compose

Dieser Weg bietet mehr Kontrolle über die Konfiguration und eignet sich, wenn Sie kein Coolify nutzen.

1. Docker installieren

Verbinden Sie sich per SSH mit Ihrem Seed und installieren Sie Docker. Das offizielle Installationsskript erkennt Ihr Betriebssystem automatisch und richtet Docker inklusive Docker Compose ein:

bash

curl -fsSL https://get.docker.com | sh

2. Projektverzeichnis erstellen

Alle Konfigurationsdateien für Ghost werden in einem gemeinsamen Verzeichnis abgelegt:

bash

mkdir -p /opt/ghost && cd /opt/ghost

3. Caddyfile erstellen

Als Reverse Proxy kommt Caddy zum Einsatz. Caddy benötigt nur wenige Zeilen Konfiguration und holt automatisch ein Let's-Encrypt-Zertifikat für HTTPS.

Erstellen Sie die Datei Caddyfile:

text

blog.ihre-firma.de {
    reverse_proxy ghost:2368
}

Ersetzen Sie blog.ihre-firma.de durch Ihre Domain.

4. Docker Compose Datei erstellen

Die docker-compose.yml beschreibt alle drei Container und wie sie zusammenarbeiten. Ghost stellt ein offizielles Docker-Image bereit, es muss kein eigenes gebaut werden:

yaml

services:
  caddy:
    image: caddy:2-alpine
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - ghost

  ghost:
    image: ghost:5-alpine
    restart: always
    volumes:
      - ghost_content:/var/lib/ghost/content
    environment:
      - url=https://blog.ihre-firma.de
      - database__client=mysql
      - database__connection__host=db
      - database__connection__port=3306
      - database__connection__user=ghost
      - database__connection__password=SICHERES_DB_PASSWORT
      - database__connection__database=ghost
      - NODE_ENV=production
    depends_on:
      - db

  db:
    image: mysql:8.0
    restart: always
    volumes:
      - db_data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=ROOT_PASSWORT_HIER
      - MYSQL_DATABASE=ghost
      - MYSQL_USER=ghost
      - MYSQL_PASSWORD=SICHERES_DB_PASSWORT

volumes:
  ghost_content:
  db_data:
  caddy_data:
  caddy_config:

Ersetzen Sie SICHERES_DB_PASSWORT (an beiden Stellen identisch), ROOT_PASSWORT_HIER und blog.ihre-firma.de durch Ihre eigenen Werte. Generieren Sie sichere Passwörter mit:

bash

openssl rand -base64 32

Zum Aufbau der Datei:

restart: always startet jeden Container automatisch neu, falls er abstürzt oder der Server neugestartet wird
depends_on legt die Startreihenfolge fest: Datenbank vor Ghost, Ghost vor Caddy
volumes speichern Daten dauerhaft außerhalb der Container. Ohne Volumes gehen alle Inhalte beim Neustart verloren

Die Umgebungsvariablen im Überblick:

url ist die wichtigste Variable. Ghost nutzt sie für interne Links, die Sitemap, RSS-Feeds und die API-Basis-URL. Sie muss das Protokoll (https://) und die exakte Domain enthalten.
database__client=mysql konfiguriert MySQL als Datenbank (Ghost unterstützt auch SQLite, aber MySQL ist für Produktion empfohlen)
NODE_ENV=production aktiviert Caching und Performance-Optimierungen

5. Alles starten

bash

docker compose up -d

Die Option -d (detached) startet die Container im Hintergrund. Der erste Start dauert einige Minuten. Docker lädt die Images herunter, MySQL initialisiert die Datenbank und Ghost führt Migrationen aus.

6. Prüfen ob alles läuft

bash

docker compose ps

Alle drei Container (caddy, ghost, db) sollten den Status running zeigen. Falls ein Container nicht startet:

bash

docker compose logs ghost

Ghost ist bereit, wenn im Log Ghost booted erscheint.

Rufen Sie anschließend https://blog.ihre-firma.de im Browser auf.

Admin-Account erstellen

Navigieren Sie zu https://blog.ihre-firma.de/ghost (das Admin-Panel). Beim ersten Aufruf führt Ghost durch einen Setup-Assistenten:

Site-Titel und -Beschreibung eingeben
Admin-Account erstellen (Name, E-Mail, Passwort)
Optional: Teammitglieder einladen

Nach dem Setup landen Sie im Ghost-Dashboard.

Content API aktivieren

Standardmäßig liefert Ghost Inhalte über sein eigenes Frontend (Theme). Um Ghost als Headless CMS zu nutzen, wird die Content API über eine Custom Integration freigeschaltet:

Navigieren Sie zu Settings > Integrations
Klicken Sie auf Add custom integration
Vergeben Sie einen Namen (z.B. "Mein Frontend")
Ghost generiert einen Content API Key und einen Admin API Key

Der Content API Key wird für den öffentlichen Lesezugriff auf Inhalte verwendet. Der Admin API Key erlaubt Schreibzugriff und sollte nur serverseitig eingesetzt werden.

Content API testen

Erstellen Sie einen Test-Artikel im Ghost-Editor (Admin-Panel unter Posts > New post). Schreiben Sie einen Titel und etwas Text, dann klicken Sie auf Publish.

Testen Sie die API mit dem Content API Key aus dem vorherigen Schritt:

bash

curl "https://blog.ihre-firma.de/ghost/api/content/posts/?key=IHR_CONTENT_API_KEY"

Die Antwort enthält Ihre Posts als JSON:

json

{
  "posts": [
    {
      "id": "...",
      "title": "Mein erster Beitrag",
      "slug": "mein-erster-beitrag",
      "html": "<p>...</p>",
      "excerpt": "...",
      "published_at": "2026-05-16T10:00:00.000Z"
    }
  ]
}

Verfügbare Endpoints der Content API:

/ghost/api/content/posts/ (Artikel)
/ghost/api/content/pages/ (Seiten)
/ghost/api/content/tags/ (Tags)
/ghost/api/content/authors/ (Autoren)
/ghost/api/content/settings/ (Site-Einstellungen)

Headless-Modus: Eigenes Frontend verbinden

Um Ghost rein als Datenquelle zu nutzen und ein eigenes Frontend darzustellen, gibt es zwei Ansätze:

Statische Generierung (SSG): Ein Framework wie Nuxt oder Astro ruft bei jedem Build alle Inhalte per Content API ab und generiert statische HTML-Seiten. Vorteil: maximale Performance, CDN-fähig. Nachteil: Neue Inhalte erfordern einen Rebuild.

Server-Side Rendering (SSR): Das Frontend ruft Inhalte bei jedem Request per API ab. Vorteil: Inhalte sind sofort nach Veröffentlichung sichtbar. Nachteil: Das Frontend muss als Server laufen.

In beiden Fällen wird das eingebaute Ghost-Theme nicht verwendet. Es kann durch ein leeres Theme ersetzt oder über eine Route-Redirect-Konfiguration deaktiviert werden.

Backup einrichten

Datenbank-Backup

Bei Weg A (Coolify) können Sie automatische Datenbank-Backups direkt im Coolify-Dashboard konfigurieren.

Bei Weg B erstellen Sie ein regelmäßiges Backup der MySQL-Datenbank. Legen Sie zunächst das Backup-Verzeichnis an:

bash

mkdir -p /opt/backups

Ein einzelnes Backup lässt sich jederzeit manuell erstellen:

bash

docker exec ghost-db-1 mysqldump -u ghost -pSICHERES_DB_PASSWORT ghost > /opt/backups/ghost-db-$(date +%Y%m%d).sql

Damit das Backup automatisch läuft, richten Sie einen Cronjob ein. Ein Cronjob ist ein zeitgesteuerter Befehl, der vom Betriebssystem regelmäßig ausgeführt wird:

bash

crontab -e

Fügen Sie folgende Zeile hinzu:

text

0 3 * * * docker exec ghost-db-1 mysqldump -u ghost -pSICHERES_DB_PASSWORT ghost > /opt/backups/ghost-db-$(date +\%Y\%m\%d).sql

Die fünf Werte 0 3 * * * bedeuten: Minute 0, Stunde 3, jeden Tag, jeden Monat, jeden Wochentag. Das Backup wird also täglich um 03:00 Uhr nachts erstellt.

Content-Verzeichnis sichern

Ghost speichert hochgeladene Bilder und Themes im Volume ghost_content. Den Speicherort finden Sie mit:

bash

docker volume inspect ghost_ghost_content --format '{{ .Mountpoint }}'

Zusätzlich bietet Ghost im Admin-Panel unter Settings > Labs einen vollständigen JSON-Export aller Inhalte.

Server-Backup über dataforest Cloud

Die dataforest Cloud bietet automatische tägliche Offsite-Backups als zubuchbare Option. Damit lassen sich alle Daten auf Ihrem Seed sichern und jederzeit wiederherstellen. Backups sind nicht standardmäßig aktiv und müssen in der Cloud-Konsole aktiviert werden.

Zusammenfassung

Nach Abschluss dieser Anleitung läuft Ghost als Headless CMS auf Ihrem eigenen Server, per HTTPS erreichbar und mit automatischen Backups abgesichert. Über die Content API lassen sich Artikel, Seiten und Medien an beliebige Frontends liefern.

Wer strukturierte Inhalte mit eigenen Content Types benötigt (Produkte, Events, individuelle Datenstrukturen), findet im Strapi-Guide eine passende Alternative. Weitere Möglichkeiten für Ihren Seed finden Sie in unseren Lösungen und Anleitungen.

Verwandte Anleitungen

Strapi als Headless CMS einrichten

Kubernetes-Cluster mit k3s einrichten

Minecraft-Server mit Docker einrichten

Bereit loszulegen?