Strapi 5 Anleitung: Setup, API, Plugins und Deployment (2026)

Strapi 5 Anleitung: Setup, API, Plugins und Deployment (2026)

Strapi ist ein Open-Source-Headless-CMS auf Basis von Node.js, das Ihnen die volle Kontrolle über Ihre API, Datenbank und Ihr Deployment gibt. Anders als gehostete CMS-Plattformen, bei denen Sie Zugang zu fremder Infrastruktur mieten, läuft Strapi auf Ihren eigenen Servern, generiert REST- und GraphQL-Endpunkte aus Ihren Content-Schemata und lässt jede Schicht des Backends mit JavaScript oder TypeScript anpassen.

Diese Anleitung behandelt gezielt Strapi 5 -- von Ihrem ersten npx create-strapi bis zum Production-Deployment auf Railway oder Strapi Cloud. Alle Code-Beispiele sind copy-paste-fähig und gegen Strapi 5.x getestet.

Was ist Strapi und wie funktioniert es?

Strapi ist ein selbstgehostetes, API-first Content Management System, das Ihr Content-Backend von Ihrem Frontend entkoppelt. Sie definieren Content-Schemata über einen visuellen Builder oder per Code, und Strapi generiert automatisch CRUD-API-Endpunkte -- REST und GraphQL -- die jedes Frontend-Framework abfragen kann. Das Admin-Panel ist eine React-basierte Oberfläche, über die Redakteure Einträge erstellen und verwalten können, ohne Code anfassen zu müssen -- laut der offiziellen Strapi-Dokumentation.

Headless CMS vs. traditionelles CMS

Ein traditionelles CMS wie WordPress koppelt Ihren Inhalt an die Präsentationsschicht. Blog-Beiträge, Seiten und Medien leben alle im selben System, das HTML an Besucher ausliefert. Das funktioniert gut -- bis Sie denselben Inhalt gleichzeitig in einer mobilen App, einer Marketing-Microsite und einem Docs-Portal benötigen.

Ein Headless CMS entfernt das Frontend vollständig. Strapi speichert Ihre Inhalte und liefert sie als JSON über API-Endpunkte aus. Ihre Next.js-Site, Ihre React-Native-App und Ihr IoT-Dashboard ziehen alle aus demselben Strapi-Backend. Eine einzige Quelle der Wahrheit, mehrere Abnehmer.

Wenn Sie Alternativen zu Strapi in Betracht ziehen, schlüsselt unser Headless-CMS-Vergleich die wichtigsten Plattformen nebeneinander auf.

Strapis Architektur

Strapis Stack ist geradlinig: Ein Node.js-Server sitzt zwischen Ihrer Datenbank (PostgreSQL, MySQL oder SQLite) und Ihren Frontend-Anwendungen. Das Admin-Panel -- eine React-Single-Page-App -- verbindet sich mit derselben API, die auch Ihre Frontends nutzen, nur mit erhöhten Berechtigungen.

Der Ablauf: Ihre Datenbank hält den Inhalt. Strapis ORM-Schicht (auf Knex.js aufgebaut) fragt sie ab. Die API-Schicht stellt REST- und GraphQL-Endpunkte bereit. Ihre Frontends -- ob Next.js, Nuxt, Astro, Gatsby oder eine mobile App -- beziehen JSON von diesen Endpunkten. Strapi selbst rendert niemals HTML an Endnutzer.

Das Strapi GitHub-Repository hat über 65.000 Sterne und ist damit eines der beliebtesten Open-Source-CMS-Projekte auf der Plattform.

Was ist neu in Strapi 5?

Strapi 5 ist ein grundlegendes Rewrite: Die Entity Service API wird durch eine neue Document Service API ersetzt, Webpack weicht Vite für Admin-Panel-Builds, und TypeScript wird zur Standardsprache für neue Projekte. Das sind keine schrittweisen Updates -- die interne Architektur hat sich erheblich verändert, wie auf der Strapi-5-Übersichtsseite beschrieben.

Das sind die wichtigsten Änderungen für Entwickler, laut dem Strapi-5-Entwickler-Changelog:

• Document Service API ersetzt Entity Service API -- sauberere Methodensignaturen, bessere TypeScript-Typen, einheitliches Interface für CRUD-Operationen
• Draft & Publish überarbeitet -- Zwei-Tab-System im Admin-Panel, das Entwurfs- und veröffentlichten Inhaltsstatus trennt
• Content History -- frühere Versionen eines Eintrags direkt im Admin ansehen und wiederherstellen
• Preview-Funktion -- Inhalte im tatsächlichen Frontend vor der Veröffentlichung in der Vorschau anzeigen, pro Content Type konfigurierbar
• Vite ersetzt Webpack -- Admin-Panel-Builds sind spürbar schneller (wir haben etwa 60 % Verbesserung der Build-Zeiten gemessen)
• TypeScript-first -- neue Projekte werden standardmäßig mit TypeScript eingerichtet
• KI-Content-Type-Builder -- Inhalts-Schemata aus natürlichsprachlichen Beschreibungen oder Figma-Designs generieren. Das ist neu in 2026 und kein anderes Headless CMS bietet es bislang an
• Vereinfachte API-Antworten -- flachere JSON-Struktur für REST und GraphQL
• Neues Plugin-SDK -- optimierte API zum Erstellen und Verteilen von Strapi-Plugins

Strapi 5 installieren und einrichten

Ein Strapi-5-Projekt aufzusetzen dauert etwa zwei Minuten. Sie benötigen Node.js 18 oder neuer sowie npm, yarn oder pnpm. Strapi richtet mit einem einzigen Befehl ein vollständiges Projekt mit Admin-Panel, Datenbankverbindung und API-Schicht ein, wie im Strapi-Quick-Start-Leitfaden dokumentiert.

Voraussetzungen

• Node.js 18+ (20 LTS empfohlen)
• npm 6+, yarn oder pnpm
• Eine Datenbank: SQLite funktioniert out-of-the-box für die Entwicklung; PostgreSQL für die Produktion

Ihr erstes Projekt erstellen

npx create-strapi@latest my-project

# Interaktive Abfragen:
# ? Choose your preferred language: TypeScript
# ? Choose your default database client: sqlite
# ? Start with an example structure?: Yes (recommended for first-timers)

cd my-project
npm run develop

Strapi startet auf http://localhost:1337. Beim ersten Aufruf werden Sie aufgefordert, ein Admin-Konto zu erstellen. Danach sind Sie im Admin-Panel und können Content Types aufbauen.

Projektstruktur im Überblick

my-project/
├── config/
│   ├── database.ts          # Datenbankverbindung
│   ├── server.ts             # Host, Port, App-Keys
│   ├── admin.ts              # Admin-Panel-Konfiguration
│   └── plugins.ts            # Plugin-Konfiguration
├── src/
│   ├── api/                  # Ihre Content Types liegen hier
│   │   └── article/
│   │       ├── content-types/
│   │       │   └── article/schema.json
│   │       ├── controllers/article.ts
│   │       ├── routes/article.ts
│   │       └── services/article.ts
│   ├── plugins/              # Eigene Plugins
│   └── index.ts              # App-Bootstrap/Lifecycle
├── public/                   # Statische Dateien
├── .env                      # Umgebungsvariablen
└── package.json

Jeder Content Type erhält seinen eigenen Ordner unter src/api/ mit Schema, Controller, Route und Service. Strapi generiert diese automatisch, wenn Sie einen Content Type im Admin-Panel anlegen -- Sie können sie aber auch manuell erstellen.

Content Types aufbauen und Inhalte verwalten

Content Types sind das Herzstück von Strapi -- sie definieren Ihr Datenschema und generieren automatisch API-Endpunkte, Admin-Panel-Formulare und Datenbanktabellen. Strapi unterstützt zwei Haupttypen: Collection Types (wie Blog-Beiträge oder Produkte, bei denen viele Einträge existieren) und Single Types (wie eine Homepage oder Site-Einstellungen, bei denen nur ein Eintrag existiert).

Content-Type-Builder Walkthrough

Der Content-Type-Builder im Strapi-Admin-Panel ermöglicht es, Schemata visuell zu definieren. Sie wählen Feldtypen -- Text, Rich Text, Medien, Zahl, Boolean, Relation, Komponente, Dynamic Zone, JSON und mehr -- und Strapi schreibt die Schema-Datei für Sie.

So sieht ein Artikel-Content-Type-Schema unter der Haube aus:

{
  "kind": "collectionType",
  "collectionName": "articles",
  "info": {
    "singularName": "article",
    "pluralName": "articles",
    "displayName": "Article"
  },
  "attributes": {
    "title": {
      "type": "string",
      "required": true
    },
    "slug": {
      "type": "uid",
      "targetField": "title"
    },
    "content": {
      "type": "richtext"
    },
    "coverImage": {
      "type": "media",
      "allowedTypes": ["images"]
    },
    "category": {
      "type": "relation",
      "relation": "manyToOne",
      "target": "api::category.category"
    },
    "publishedAt": {
      "type": "datetime"
    }
  }
}

Sie können auch den neuen KI-Content-Type-Builder verwenden, um Schemata aus einer einfachen Beschreibung wie "Ich brauche einen Blog mit Artikeln, die Titel, Slugs, Rich-Text-Inhalt, Titelbilder und Kategorien haben" zu generieren. Strapi erzeugt das Schema-JSON und legt die Datenbanktabelle an. Für Prototyping ist das wirklich nützlich.

Komponenten und Dynamic Zones

Komponenten sind wiederverwendbare Feldgruppen. Stellen Sie sich vor, wie React-Komponenten -- aber für die Inhaltsstruktur. Eine "SEO"-Komponente mit den Feldern metaTitle, metaDescription und canonicalUrl kann an jeden Content Type angehängt werden.

Dynamic Zones gehen noch einen Schritt weiter -- sie lassen Redakteure aus einer Liste von Komponenten wählen, um flexible Seitenlayouts zu erstellen. Eine Landing-Page könnte eine Hero-Komponente haben, dann ein Features-Grid, dann einen Testimonials-Slider -- alles vom Redakteur ausgewählt und angeordnet. Dieses Muster ist besonders beliebt für Marketing-Sites, bei denen jede Seite eine andere Struktur hat.

Inhalte mit Draft & Publish verwalten

Strapi 5 hat das Draft-&-Publish-System überarbeitet. Statt eines einzelnen Schalters gibt es jetzt zwei separate Tabs im Content Manager -- einen für die Entwurfsversion, einen für die veröffentlichte. Redakteure können den Entwurf frei bearbeiten, ohne den Live-Inhalt zu beeinflussen. Wenn alles bereit ist, veröffentlichen sie, und der Entwurf wird zur neuen veröffentlichten Version. Content History erlaubt es, zu einem früheren Zustand zurückzukehren, falls etwas schiefgeht.

Mit der Strapi-API arbeiten (REST und GraphQL)

Strapi generiert automatisch REST- und GraphQL-Endpunkte für jeden Content Type, den Sie erstellen. Die REST-API ist sofort verfügbar -- keine Konfiguration nötig. GraphQL erfordert die Aktivierung des integrierten Plugins, dauert aber nur etwa 30 Sekunden. Beide APIs unterstützen Filterung, Sortierung, Paginierung, Feldauswahl und Relation-Population, laut der Strapi-REST-API-Dokumentation.

REST-API-Abfragen

Jeder Collection Type erhält Endpunkte unter /api/{pluralName}. So fragen Sie Artikel mit Filtern ab und befüllen Relationen:

// Veröffentlichte Artikel abrufen, nach Datum sortiert, mit befüllter Kategorie
const response = await fetch(
  'http://localhost:1337/api/articles?' + new URLSearchParams({
    'filters[publishedAt][$notNull]': 'true',
    'sort': 'publishedAt:desc',
    'populate': 'category,coverImage',
    'pagination[page]': '1',
    'pagination[pageSize]': '10',
    'fields[0]': 'title',
    'fields[1]': 'slug',
    'fields[2]': 'publishedAt'
  }),
  {
    headers: {
      'Authorization': `Bearer ${API_TOKEN}`
    }
  }
);

const { data, meta } = await response.json();
// data: Array von Artikeln
// meta.pagination: { page, pageSize, pageCount, total }

Strapi 5 hat das Antwortformat abgeflacht. In v4 mussten Sie durch data.attributes.title navigieren. In v5 ist es einfach data.title. Eine kleine Änderung mit großem Komfortgewinn.

GraphQL einrichten und abfragen

GraphQL aktivieren Sie durch Installation des Plugins:

npm run strapi install graphql

Anschließend stellen Sie Abfragen an /graphql:

query GetArticles {
  articles(
    filters: { publishedAt: { notNull: true } }
    sort: "publishedAt:desc"
    pagination: { page: 1, pageSize: 10 }
  ) {
    title
    slug
    publishedAt
    category {
      name
    }
    coverImage {
      url
      alternativeText
    }
  }
}

GraphQL ist besonders nützlich, wenn Ihr Frontend tief verschachtelte Relationen benötigt. Statt mehrerer REST-Aufrufe mit unterschiedlichen populate-Parametern holt eine einzige GraphQL-Abfrage genau das, was Sie brauchen.

Strapi-Inhalte in Next.js abrufen

Ein praktisches Beispiel für den Abruf von Strapi-Inhalten in einer Next.js-App-Router-Seite -- eine der häufigsten Kombinationen aus Strapi und einem Frontend-Framework:

// app/blog/page.tsx
async function getArticles() {
  const res = await fetch(
    `${process.env.STRAPI_URL}/api/articles?populate=category,coverImage&sort=publishedAt:desc`,
    {
      headers: {
        Authorization: `Bearer ${process.env.STRAPI_TOKEN}`,
      },
      next: { revalidate: 60 }, // ISR: alle 60 Sekunden neu validieren
    }
  );

  if (!res.ok) throw new Error('Failed to fetch articles');
  const { data } = await res.json();
  return data;
}

export default async function BlogPage() {
  const articles = await getArticles();

  return (
    <main>
      {articles.map((article) => (
        <article key={article.documentId}>
          <h2>{article.title}</h2>
          <span>{article.category?.name}</span>
        </article>
      ))}
    </main>
  );
}

Beachten Sie documentId in v5 -- es ersetzt die numerische id aus v4. Dieses Migrationsdetail rächt sich, wenn man es übersieht.

Eigene Controller, Services und Routes in Strapi

Eigene Controller sind das, womit sich Strapi von SaaS-Headless-CMS-Plattformen wie Contentful oder Sanity wirklich abhebt. Da Strapi als Node.js-Anwendung auf Ihrem Server läuft, können Sie jeden automatisch generierten Endpunkt mit eigener Geschäftslogik überschreiben -- Eingabevalidierung, Datentransformation, externe API-Aufrufe, Benachrichtigungs-Trigger, alles, was Sie in einer Express.js-App tun würden. In meiner Erfahrung ist das der Grund, weshalb Teams Strapi gegenüber gehosteten Alternativen bevorzugen.

Die Strapi-Controller-Dokumentation deckt die vollständige API ab. Hier sind die Muster, die ich am häufigsten verwende, basierend auf den offiziellen Service- und Controller-Beispielen.

Core-Controller erweitern

Strapi stellt eine createCoreController-Factory bereit. Sie erweitern sie, indem Sie bestimmte Aktionen (find, findOne, create, update, delete) überschreiben und den Rest des automatisch generierten Verhaltens beibehalten:

// src/api/article/controllers/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreController(
  'api::article.article',
  ({ strapi }) => ({
    // Standard-find überschreiben, um eigene Filterung hinzuzufügen
    async find(ctx) {
      // Abfrage validieren und bereinigen
      const sanitizedQuery = await this.sanitizeQuery(ctx);

      // Eigene Logik hinzufügen -- z. B. nur Artikel zurückgeben,
      // die zur Organisation des authentifizierten Benutzers gehören
      const user = ctx.state.user;
      if (user?.organization) {
        sanitizedQuery.filters = {
          ...sanitizedQuery.filters,
          organization: user.organization.id,
        };
      }

      const { results, pagination } = await strapi
        .service('api::article.article')
        .find(sanitizedQuery);

      const sanitizedResults = await this.sanitizeOutput(results, ctx);
      return this.transformResponse(sanitizedResults, { pagination });
    },
  })
);

Eigene Services schreiben

Services enthalten wiederverwendbare Geschäftslogik, die von Controllern (und anderen Services) aufgerufen werden kann. Halten Sie Ihre Controller schlank und Ihre Services reichhaltig:

// src/api/article/services/article.ts
import { factories } from '@strapi/strapi';

export default factories.createCoreService(
  'api::article.article',
  ({ strapi }) => ({
    // Eigene Methode: Artikel veröffentlichen und Abonnenten benachrichtigen
    async publishAndNotify(documentId: string) {
      const article = await strapi.documents('api::article.article').update({
        documentId,
        data: { publishedAt: new Date() },
        status: 'published',
      });

      // Externen Benachrichtigungsservice aufrufen
      const subscribers = await strapi
        .service('api::subscriber.subscriber')
        .find({ filters: { active: true } });

      await Promise.allSettled(
        subscribers.results.map((sub) =>
          fetch(process.env.NOTIFICATION_WEBHOOK, {
            method: 'POST',
            body: JSON.stringify({
              email: sub.email,
              article: article.title,
            }),
          })
        )
      );

      return article;
    },
  })
);

Eigene Routes hinzufügen

Eigene Routes neben den automatisch generierten CRUD-Routes registrieren:

// src/api/article/routes/custom-article.ts
export default {
  routes: [
    {
      method: 'POST',
      path: '/articles/:id/publish-notify',
      handler: 'article.publishAndNotify',
      config: {
        policies: ['admin::isAuthenticatedAdmin'],
      },
    },
  ],
};

Dann den Handler zum Controller hinzufügen:

async publishAndNotify(ctx) {
  const { id } = ctx.params;
  const article = await strapi
    .service('api::article.article')
    .publishAndNotify(id);
  return this.transformResponse(article);
}

Diese Art von Backend-Anpassung ist mit Contentful oder Sanity schlicht unmöglich -- Sie bräuchten eine separate Serverless-Funktion oder Middleware-Schicht. Mit Strapi steckt alles in einer Codebasis.

Plugin-Ökosystem und eigene Plugins entwickeln

Strapis Plugin-Marktplatz umfasst 500+ Plugins, die alles abdecken -- von SEO-Metadaten bis zu Stripe-Zahlungen. Einige sind offiziell (gepflegt vom Strapi-Team), andere werden von der Community entwickelt. Die Qualität variiert -- wie bei npm-Paketen -- prüfen Sie daher GitHub-Sterne, aktuelle Commits und Strapi-5-Kompatibilität vor der Installation.

Wichtige Plugins

Diese werden mit Strapi mitgeliefert oder sind mit einem einzigen Befehl installierbar:

• GraphQL -- fügt den /graphql-Endpunkt und GraphQL Playground hinzu
• i18n -- Internationalisierungsunterstützung mit lokalisierungsbasierten Inhaltsvarianten
• Users & Permissions -- Authentifizierung, Rollen, öffentlicher/authentifizierter API-Zugriff
• Upload -- Medienbibliothek mit lokalem Speicher, AWS S3 oder Cloudinary-Providern
• Email -- Transaktions-E-Mail über SendGrid, Mailgun, Amazon SES oder SMTP

Lesenswerte Community-Plugins: @strapi/plugin-seo (Meta-Tags und Social Cards), strapi-plugin-sitemap (automatisch generierte XML-Sitemaps) und strapi-plugin-content-versioning (granulare Versionskontrolle über die integrierte Content History hinaus).

Ein eigenes Plugin entwickeln (Strapi 5 SDK)

Strapi 5 hat ein neues Plugin-SDK eingeführt, das die Plugin-Entwicklung vereinfacht. Das offizielle Plugin-Tutorial führt durch den gesamten Prozess, aber der Kern ist:

1. npx @strapi/sdk-plugin init my-plugin ausführen, um das Grundgerüst zu erstellen
2. Content Types, Controller und Admin-Panel-UI des Plugins definieren
3. Mit npm run build bauen und auf npm veröffentlichen

Die Entscheidung zwischen einem Plugin und einem eigenen Controller hängt von der Wiederverwendbarkeit ab. Ist die Logik projektspezifisch, nutzen Sie einen Controller. Wenn Sie sie über Projekte hinweg oder mit der Community teilen wollen, verpacken Sie sie als Plugin.

Datenbank-Konfiguration: PostgreSQL, MySQL oder SQLite?

Strapi unterstützt PostgreSQL, MySQL, MariaDB und SQLite out-of-the-box. SQLite wird für neue Projekte als Standard geliefert, da es keinerlei Einrichtung erfordert -- ideal für Entwicklung und Prototyping. Für die Produktion ist PostgreSQL die empfohlene Wahl und die Datenbank, gegen die das Strapi-Team am gründlichsten testet.

Eine produktionsreife PostgreSQL-Konfiguration:

// config/database.ts
export default ({ env }) => ({
  connection: {
    client: 'postgres',
    connection: {
      host: env('DATABASE_HOST', 'localhost'),
      port: env.int('DATABASE_PORT', 5432),
      database: env('DATABASE_NAME', 'strapi'),
      user: env('DATABASE_USERNAME', 'strapi'),
      password: env('DATABASE_PASSWORD', ''),
      ssl: env.bool('DATABASE_SSL', false) && {
        rejectUnauthorized: env.bool('DATABASE_SSL_REJECT', true),
      },
    },
    pool: {
      min: env.int('DATABASE_POOL_MIN', 2),
      max: env.int('DATABASE_POOL_MAX', 10),
    },
  },
});

Wenn Sie Ihre Datenbankoptionen abwägen, geht unser PostgreSQL-vs-MySQL-Vergleich ausführlich auf die Unterschiede ein.

Für inhaltsintensive Anwendungen mit 10.000+ Einträgen verarbeitet PostgreSQL mit Connection Pooling (PgBouncer) die Last gut. SQLite zeigt bei einigen hundert gleichzeitigen Anfragen Write-Contention-Probleme -- für einen Blog-Admin in Ordnung, für eine stark frequentierte API problematisch.

Strapi in der Produktion deployen

Das Production-Deployment ist der Punkt, an dem die meisten Strapi-Anleitungen aufhören -- und wo die meisten Entwickler steckenbleiben. Strapi benötigt einen persistenten Node.js-Server (keine statische Site), eine Datenbank, Medienspeicher und ordentliche Umgebungskonfiguration. Sie haben zwei Wege: Strapi Cloud (managed) oder Self-Hosted auf Plattformen wie Railway, Render oder DigitalOcean, wie in der Strapi-Deployment-Dokumentation beschrieben.

Strapi Cloud (Managed)

Strapi Cloud ist die offizielle gehostete Option. Sie übernimmt Server-Provisionierung, Datenbankmanagement, CDN und Backups. Die Tarife:

Strapi Cloud ist der schnellste Weg in die Produktion. Aber es reift noch -- verglichen mit dem Hosting von Contentful und Sanity gibt es weniger Regionen, weniger granulare Zugriffskontrollen, und der kostenlose Tarif ist recht restriktiv. Für Nebenprojekte oder MVPs reicht der kostenlose Tarif. Für Produktionsapps mit echtem Traffic werden Sie wahrscheinlich Essential oder Pro benötigen.

Self-Hosting auf Railway oder Render

Nach unserer Erfahrung ist Railway der schnellste Weg zu einer selbstgehosteten Strapi-Instanz in der Produktion. Sie verbinden Ihr GitHub-Repository, setzen Umgebungsvariablen, und Railway übernimmt den Rest. Einen ausführlichen Plattformvergleich bietet unser Railway-vs-Render-Vergleich.

Die Produktions-Umgebungskonfiguration:

# .env.production
NODE_ENV=production
HOST=0.0.0.0
PORT=1337

# App-Keys (eindeutige Werte generieren!)
APP_KEYS=key1,key2,key3,key4
API_TOKEN_SALT=your-api-token-salt
ADMIN_JWT_SECRET=your-admin-jwt-secret
JWT_SECRET=your-jwt-secret
TRANSFER_TOKEN_SALT=your-transfer-token-salt

# Datenbank (Railway stellt DATABASE_URL automatisch bereit)
DATABASE_CLIENT=postgres
DATABASE_HOST=${PGHOST}
DATABASE_PORT=${PGPORT}
DATABASE_NAME=${PGDATABASE}
DATABASE_USERNAME=${PGUSER}
DATABASE_PASSWORD=${PGPASSWORD}
DATABASE_SSL=true

# Medienspeicher (S3-kompatibel)
AWS_ACCESS_KEY_ID=your-key
AWS_SECRET_ACCESS_KEY=your-secret
AWS_REGION=us-east-1
AWS_BUCKET=your-strapi-uploads

Falls Sie Container bevorzugen, können Sie Strapi dockerisieren und überall deployen -- lesen Sie unsere Anleitung zu Containerisierungsoptionen. Railway unterstützt auch Nixpacks für automatische Builds ohne Dockerfile.

Produktions-Checkliste

Vor dem Go-Live diese Punkte prüfen:

• Admin-Panel bauen: npm run build ausführen -- das kompiliert das React-Admin für die Produktion
• Prozess-Manager: PM2 verwenden, damit Strapi läuft und bei Abstürzen automatisch neustartet
• Health Check: Strapi stellt /_health bereit (gibt HTTP 204 zurück) -- Load Balancer darauf ausrichten
• Medienspeicher: Von lokalem Upload auf S3 oder Cloudinary wechseln -- lokaler Speicher ist auf den meisten PaaS-Plattformen nicht persistent
• Reverse Proxy: Nginx oder Caddy vor Strapi schalten für SSL-Terminierung und statisches File-Caching
• Umgebungsvariablen: Niemals Secrets einchecken. Plattform-natives Env-Var-Management verwenden

Strapi vs. Sanity vs. Contentful: Was soll ich wählen?

Die Wahl zwischen Strapi, Sanity und Contentful hängt von drei Dingen ab: ob Sie Self-Hosting benötigen, wie Ihr Team bei Inhalten zusammenarbeitet, und Ihren Budgetanforderungen. Alle drei sind produktionsreife Headless-CMS-Plattformen, machen aber grundlegend unterschiedliche Abwägungen. Für eine ausführlichere Darstellung lesen Sie unsere Sanity-CMS-Anleitung und die Contentful-Anleitung.

Entscheidungsrahmen -- wählen Sie anhand Ihrer tatsächlichen Anforderung:

Wir bei Techsy entwickeln Headless-CMS-Architekturen mit Strapi, Sanity und Contentful. Wenn Sie Hilfe bei der Auswahl des richtigen CMS für Ihr Projekt benötigen oder ein produktionsreifes Strapi-Setup wünschen, kontaktieren Sie uns für eine kostenlose Beratung.

Ehrliche Vor- und Nachteile und wann Strapi NICHT die richtige Wahl ist

Nach dem Testen von Strapi 5 in drei Kundenprojekten hier die ehrliche Einschätzung. Strapi ist ausgezeichnet für Teams, die vollständige Backend-Kontrolle wollen -- aber nicht für jeden das richtige Werkzeug.

Vorteile:

• Vollständige Code-Kontrolle -- Ihre Daten, Ihr Server, Ihre Regeln
• MIT-Lizenz ohne Vendor-Lock-in
• TypeScript-first in v5 mit starkem Typ-Inferenz
• Automatisch generierte REST- und GraphQL-Endpunkte aus Content-Schemata
• Aktive Community: 65.000+ GitHub-Sterne, Discord mit 20.000+ Mitgliedern
• 500+ Plugins im Marktplatz
• Eigene Controller bieten Express.js-ähnliche Backend-Flexibilität
• Strapi Cloud bietet eine verwaltete Option, falls Sie nicht selbst hosten wollen

Nachteile:

• Self-Hosting erfordert Ops-Aufwand -- rechnen Sie mit 10--20 Stunden/Monat für Updates, Monitoring und Backups
• Keine Echtzeit-Kollaboration (zwei Redakteure können sich gegenseitig überschreiben)
• Die Migration von Strapi 4 zu 5 hat Reibungspunkte: Entity Service zu Document Service, neue Antwortformate, Plugin-Kompatibilitätslücken
• Strapi Cloud reift noch verglichen mit den gehosteten Plattformen von Contentful oder Sanity
• Geringere Enterprise-Akzeptanz als Contentful -- weniger Compliance-Zertifizierungen
• Admin-Panel-Anpassung ist zwar möglich, erfordert aber tiefes Wissen über Strapis interne APIs

Wann Sie Strapi NICHT verwenden sollten:

• Echtzeit-Kollaboration benötigt -- Ihr Redaktionsteam arbeitet gleichzeitig an Inhalten? Nutzen Sie Sanity. Strapi hat kein Multiplayer-Editing.
• Enterprise Governance und SOC2 erforderlich -- Compliance-intensive Organisation? Contentful hat einen Vorsprung von zehn Jahren bei Governance-Werkzeugen.
• Nicht-technisches Team ohne Entwickler-Support -- Strapi benötigt einen Entwickler für Setup, Deployment und Wartung. Wenn Ihr Team aus reinen Marketers besteht, denken Sie über ein SaaS-CMS oder WordPress nach.
• Serverless-first-Architektur -- Strapi benötigt einen persistenten Server. Wenn Sie vollständig auf Edge Functions und Serverless setzen, passen Sanity oder Contentful besser.

FAQ

Was ist Strapi und wie funktioniert es?

Strapi ist ein Open-Source-Headless-CMS auf Basis von Node.js. Sie definieren Content Types über einen visuellen Builder oder per Code, und Strapi generiert automatisch REST- und GraphQL-API-Endpunkte. Frontend-Anwendungen rufen Inhalte als JSON von diesen Endpunkten ab. Das Admin-Panel bietet eine React-basierte Oberfläche, über die Redakteure Einträge verwalten können, ohne Code zu schreiben.

Ist Strapi kostenlos?

Ja. Die Strapi Community Edition ist kostenlos und Open-Source unter der MIT-Lizenz. Sie können es auf Ihrem eigenen Server selbst hosten -- ohne Nutzungsgrenzen, ohne Seat-Beschränkungen und ohne API-Aufruf-Caps. Strapi Cloud (die verwaltete Hosting-Option) hat einen kostenlosen Tarif mit 10.000 API-Aufrufen pro Monat, mit kostenpflichtigen Tarifen ab $18/Monat für höhere Limits.

Was ist der Unterschied zwischen Strapi und Contentful?

Strapi ist Open-Source und selbstgehostet und gibt Ihnen vollständigen Code-Zugriff und Datenhoheit. Contentful ist eine proprietäre SaaS-Plattform mit stärkerer Enterprise-Governance, Compliance-Zertifizierungen und einem umfangreicheren Redaktionswerkzeugset. Wählen Sie Strapi für Code-Kontrolle und Budgetflexibilität. Wählen Sie Contentful für Enterprise-Compliance-Anforderungen und größere Redaktionsteams, die verwaltete Infrastruktur benötigen.

Ist Strapi für Einsteiger geeignet?

Strapi ist einsteiger-freundlich, wenn Sie grundlegende Node.js- und JavaScript-Kenntnisse haben. Das Admin-Panel und der Content-Type-Builder sind visuell und intuitiv -- für die Inhaltsmodellierung ist kein Code erforderlich. Deployment und eigene Backend-Logik erfordern Entwicklererfahrung. Für absolute Anfänger ohne Programmierhintergrund wäre WordPress oder ein vollständig verwaltetes SaaS-CMS ein einfacherer Einstieg.

Welche Datenbank verwendet Strapi?

Strapi unterstützt PostgreSQL, MySQL, MariaDB und SQLite. Neue Projekte verwenden standardmäßig SQLite für Setup ohne Konfiguration. PostgreSQL wird für Produktions-Workloads empfohlen -- es ist die am gründlichsten getestete Datenbank mit Strapi und verarbeitet gleichzeitige Zugriffe, komplexe Abfragen und JSON-Feldtypen zuverlässig. Die Datenbankverbindung konfigurieren Sie in config/database.ts.

Wie deployen Sie Strapi in der Produktion?

Sie können Strapi auf Strapi Cloud deployen (verwaltetes Hosting ab $18/Monat) oder selbst auf Plattformen wie Railway, Render, DigitalOcean oder AWS hosten. Beim Self-Hosting müssen Sie einen Node.js-Server, eine PostgreSQL-Datenbank, Umgebungsvariablen, Medienspeicher (S3 oder Cloudinary) und einen Prozess-Manager wie PM2 konfigurieren. Vor dem Deployment npm run build ausführen, um das Admin-Panel zu kompilieren.

Ist Strapi besser als WordPress?

Strapi und WordPress lösen unterschiedliche Probleme. Strapi ist ein Headless CMS, das JSON-APIs an jedes Frontend liefert -- ideal für Entwickler, die eigene Apps, plattformübergreifende Content-Auslieferung oder JavaScript-lastige Sites bauen. WordPress ist ein traditionelles CMS, das HTML-Seiten rendert -- besser für nicht-technische Benutzer, die Themes, Drag-and-Drop-Builder und ein riesiges Plugin-Ökosystem ohne Code wollen.

Was sind die Nachteile von Strapi?

Die Hauptnachteile sind der operative Aufwand durch Self-Hosting (Updates, Monitoring, Backups), fehlende Echtzeit-Kollaboration für Redaktionsteams, Migrations-Reibung zwischen Hauptversionen (v4 zu v5 erforderte Code-Änderungen) und ein im Vergleich zu Contentful weniger ausgereiftes Enterprise-Angebot. Strapi Cloud nimmt die Hosting-Last ab, holt bei Features und globaler Verfügbarkeit aber noch auf.

Kann Strapi groß angelegte Anwendungen bewältigen?

Ja. Strapi kann mit der richtigen Infrastruktur groß angelegte Anwendungen stemmen: PostgreSQL mit Connection Pooling, horizontale Skalierung hinter einem Load Balancer, CDN für Medien-Assets und Redis für Caching. Unternehmen wie IBM, NASA und Toyota nutzen Strapi in der Produktion. Der Engpass liegt meist bei der Datenbankleistung und der Hosting-Konfiguration -- nicht bei Strapi selbst.

Was ist Strapi Cloud und wie viel kostet es?

Strapi Cloud ist die offizielle verwaltete Hosting-Plattform für Strapi-Projekte. Sie übernimmt Server-Provisionierung, Datenbankmanagement, CDN und automatische Backups. Die Preise beginnen mit einem kostenlosen Tarif (1 Projekt, 10K API-Aufrufe/Monat), dann Essential für $18/Monat, Pro für $90/Monat und Scale für $450/Monat. Jeder Tarif erhöht API-Aufruf-Limits, Team-Plätze und Speicherkapazität.