Strapi auf Kubernetes bereitstellen und skalieren: Komplette Anleitung

Strapi ist ein Headless Content Management System (CMS), das die Erstellung und Verwaltung von Inhalten für Websites, Webanwendungen und mobile Plattformen deutlich vereinfacht. Über ein benutzerfreundliches Admin-Dashboard können Teams Inhalte hinzufügen, aktualisieren oder entfernen – ganz ohne tiefgehende technische Kenntnisse. Außerdem erlaubt Strapi das Definieren eigener Inhaltstypen und Datenstrukturen und bietet so maximale Flexibilität bei der Organisation von Content. Dank nahtloser Integrationsmöglichkeiten arbeitet Strapi reibungslos mit Frontend-Frameworks, Datenbanken und Drittanbieter-Services zusammen und ist damit eine leistungsstarke Lösung für modernes Content Management.

Strapi Flow Chart

Strapi kann große Datenmengen verwalten und eine wachsende Benutzerbasis effizient bedienen, was es ideal für den Einsatz in einem Kubernetes-Cluster macht. Kubernetes sorgt für Skalierbarkeit und unterstützt Deployments in mehreren Umgebungen. Darüber hinaus bietet Strapi eine integrierte rollenbasierte Authentifizierung und Benutzerrechte, um sicherzustellen, dass nur autorisierte Nutzer Inhalte abrufen oder ändern können – eine zusätzliche Sicherheitsebene für clusterbasierte Anwendungen.

Da Strapi auf hohe Inhaltsvolumen und effiziente Skalierung ausgelegt ist, eignet es sich hervorragend für den Betrieb auf Kubernetes. Kubernetes erhöht die Skalierbarkeit von Strapi und unterstützt Deployments über verschiedene Umgebungen hinweg. Mit integrierter rollenbasierter Authentifizierung und Benutzerrechten wird zudem der sichere Zugriff auf Inhalte innerhalb von clusterbasierten Anwendungen gewährleistet.

Diese Anleitung erklärt, wie Sie eine Strapi-Anwendung containerisieren, bereitstellen und auf einer Kubernetes Engine skalieren.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• Zugriff auf einen Kubernetes Engine Cluster.
• Ein DNS-A-Record, der auf die Ingress-Load-Balancer-IP zeigt (in diesem Beispiel strapi.example.com; ersetzen Sie dies durch Ihre eigene Domain).
• Zugriff auf eine PostgreSQL-Datenbank.
• Eine Ubuntu-24.04-Instanz als nicht-root Benutzer mit sudo-Rechten als Management-Workstation.
• Docker ist auf der Workstation zur Containerisierung installiert.
• Kubectl ist auf der Management-Workstation installiert, um den Kubernetes-Cluster zu verwalten.
• Helm-Paketmanager ist auf der Workstation installiert.
• Die Kubeconfig-Datei des Clusters ist vorhanden und kubectl ist so konfiguriert, dass es sich mit dem Cluster verbinden kann.

Strapi-Anwendung erstellen

Melden Sie sich auf Ihrer Management-Workstation an und fügen Sie das Node.js-Repository hinzu:

$ curl -sL https://deb.nodesource.com/setup_22.x | sudo -E bash -

Installieren Sie Node.js:

$ sudo apt install -y nodejs

Git konfigurieren

Strapi nutzt Git für die Versionsverwaltung. Wenn Git noch nicht eingerichtet ist, konfigurieren Sie globalen Benutzernamen und E-Mail-Adresse:

Globalen Git-Benutzernamen festlegen:

$ git config --global user.name "Your Full Name"

Globale Git-E-Mail-Adresse festlegen:

$ git config --global user.email "email@example.com"

Neues Strapi-Projekt mit npx erstellen:

$ npx create-strapi-app@latest strapi-project --quickstart --js

Dieser Befehl erstellt eine neue Strapi-Anwendung namens strapi-project mit der Quickstart-Option. Er installiert das neueste create-strapi-app-Paket, richtet die Projektstruktur ein und installiert alle erforderlichen Abhängigkeiten.

Nach der Installation drücken Sie Ctrl + C, um den Server zu stoppen und mit der weiteren Konfiguration fortzufahren.

Strapi-Anwendung containerisieren

Konfigurieren Sie Strapi, um eine PostgreSQL-Datenbank zu verwenden, und bereiten Sie es für den Einsatz auf Kubernetes vor.

Wechseln Sie in das Projektverzeichnis:

$ cd strapi-project

Bearbeiten Sie die Datei .env:

$ nano .env

Aktualisieren Sie die Datenbank-Zugangsdaten in der Datei .env:

DATABASE_CLIENT=postgres
DATABASE_HOST=your-postgres-hostname
DATABASE_PORT=5432
DATABASE_NAME=strapi_db
DATABASE_USERNAME=user
DATABASE_PASSWORD=password
DATABASE_SSL=true
DATABASE_SSL_REJECT_UNAUTHORIZED=false
DATABASE_SCHEMA=public
DATABASE_CONNECTION_TIMEOUT=60000

Ersetzen Sie Host, Port, Benutzername, Datenbankname und Passwort durch Ihre eigenen PostgreSQL-Zugangsdaten.

Sichern Sie die Originaldatei config/server.js:

$ mv config/server.js config/server.ORIG

Erstellen Sie eine neue Datei config/server.js:

$ nano config/server.js

Fügen Sie die folgende Konfiguration hinzu:

module.exports = ({ env }) => ({
  host: env('HOST', '0.0.0.0'),
  port: env.int('PORT', 1337),
  url: env('STRAPI_URL'),
  app: {
    keys: env.array('APP_KEYS'),
  },
  webhooks: {
    populateRelations: env.bool('WEBHOOKS_POPULATE_RELATIONS', false),
  },
});

Definieren Sie die Umgebungsvariable STRAPI_URL:

$ export STRAPI_URL="http://127.0.0.1:1337"

Installieren Sie den PostgreSQL-Treiber für Node.js:

$ npm install pg --save

Bauen Sie die Anwendung neu:

$ npm run build

Starten Sie die Anwendung im Hintergrund:

$ npm run start &

Öffnen Sie einen Browser und rufen Sie http://<SERVER-IP>:1337 auf, um zu überprüfen, dass das Strapi-Dashboard erscheint und Sie den ersten Administrator-Account erstellen können.

Docker-Image erstellen

Erstellen Sie im Projektverzeichnis eine Dockerfile:

$ nano Dockerfile

Fügen Sie die folgenden Anweisungen ein:

FROM node:22-alpine

RUN apk update && apk add --no-cache build-base gcc autoconf automake zlib-dev libpng-dev nasm bash vips-dev
ARG NODE_ENV=production
ENV NODE_ENV=${NODE_ENV}

WORKDIR /opt/
COPY package.json package-lock.json ./
RUN npm install
ENV PATH=/opt/node_modules/.bin:$PATH

WORKDIR /opt/app
COPY . .
RUN chown -R node:node /opt/app
USER node
RUN ["npm", "run", "build"]

EXPOSE 1337

CMD ["npm", "run", "start"]

Erstellen Sie eine .dockerignore-Datei:

$ nano .dockerignore

Fügen Sie folgenden Inhalt hinzu:

node_modules/

Bauen Sie anschließend das Docker-Image:

$ docker build -t strapi:latest .

Melden Sie sich bei DockerHub an:

$ docker login -u  -p 

Taggen Sie das Image mit Ihrem DockerHub-Benutzernamen:

$ docker tag strapi:latest /strapi:latest

Laden Sie das Image zu DockerHub hoch:

$ docker push /strapi:latest

Kubernetes-Cluster vorbereiten

Bevor Sie die Strapi-Anwendung bereitstellen, müssen Sie den Kubernetes-Cluster konfigurieren, indem Sie die notwendigen Plugins installieren und die erforderlichen Ressourcen anlegen. In diesem Abschnitt wird gezeigt, wie der Nginx Ingress Controller und das CertManager-Plugin installiert und ein ClusterIssuer-Resource für Let’s-Encrypt-SSL-Zertifikate erstellt wird.

Folgen Sie den Schritten, um den Cluster einzurichten.

Nginx Ingress Controller installieren

Fügen Sie das Nginx Ingress Repository hinzu:

$ helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

Aktualisieren Sie die Helm-Chart-Repositories:

$ helm repo update

Erstellen Sie einen neuen Namespace für den Nginx Ingress Controller:

$ kubectl create namespace ingress-nginx

Installieren Sie den Nginx Ingress Controller:

$ helm install ingress-nginx ingress-nginx/ingress-nginx --namespace ingress-nginx

Nach der Installation wird automatisch ein Load Balancer für Ihren Cluster bereitgestellt. Überprüfen Sie, ob die zugewiesene External-IP-Adresse der Load-Balancer-IP im Kubernetes Engine Dashboard entspricht:

$ kubectl get services ingress-nginx-controller --namespace ingress-nginx

Der Load Balancer kann einige Minuten benötigen, um bereit zu sein. Falls das Feld EXTERNAL-IP als <pending> angezeigt wird, warten Sie ein paar Minuten und versuchen Sie es erneut. Sie können den Load Balancer auch über die Cluster-Seite im Kubernetes-Portal prüfen.

CertManager für SSL-Zertifikate installieren

Installieren Sie den CertManager:

$ kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.17.2/cert-manager.yaml

Besuchen Sie die offizielle CertManager-Releases-Seite, um die neueste Version zu erhalten.

Ermitteln Sie die External-IP-Adresse des Load Balancers:

$ kubectl get services ingress-nginx-controller --namespace ingress-nginx

Legen Sie einen A-Record für Ihre Domain strapi.example.com an und verweisen Sie ihn auf die External-IP-Adresse des Load Balancers.

Erstellen Sie ein neues Manifest namens clusterissuer.yaml:

$ nano clusterissuer.yaml

Fügen Sie die folgenden Konfigurationen hinzu:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: "hello@example.com"
    privateKeySecretRef:
      name: letsencrypt-prod
    solvers:
      - http01:
          ingress:
            class: nginx

Ersetzen Sie „hello@example.com“ durch Ihre eigene E-Mail-Adresse.

Wenden Sie die ClusterIssuer-Ressource an:

$ kubectl apply -f clusterissuer.yaml

Überprüfen Sie die ClusterIssuer-Bereitstellung:

$ kubectl get clusterissuer letsencrypt-prod

Ein READY-Status von True bestätigt die erfolgreiche Bereitstellung der ClusterIssuer-Ressource.

Strapi-Anwendung bereitstellen

Erstellen Sie eine neue Deployment-Manifestdatei strapi-deployment.yaml:

$ nano strapi-deployment.yaml

Fügen Sie die folgenden Konfigurationen ein:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: strapi-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      name: strapi-app
  template:
    metadata:
      labels:
        name: strapi-app
    spec:
      imagePullSecrets:
        - name: regcred
      containers:
        - name: strapi
          image: /strapi:latest
          imagePullPolicy: Always
          command: ["sh", "-c", "npm run build && npm run start"]
          ports:
            - containerPort: 1337
          env:
            - name: STRAPI_URL
              value: "strapi.example.com"

Diese Konfiguration erstellt eine Deployment-Ressource mit zwei Pods, die das zuvor gebaute Container-Image ausführen und mit dem Label strapi-app versehen sind. Sie verwendet das Secret regcred, um sich bei DockerHub zu authentifizieren und das Container-Image aus einem privaten Repository zu ziehen. Ersetzen Sie das Image <username>/strapi:latest durch Ihr eigenes Repository und passen Sie strapi.example.com an Ihre Domain an, die auf den Cluster-Load-Balancer zeigt.

Wenden Sie die Datei strapi-deployment.yaml an, um die Anwendung bereitzustellen:

$ kubectl apply -f strapi-deployment.yaml

Überprüfen Sie, ob die Anwendung bereitgestellt wurde:

$ kubectl get deployment strapi-deployment

Service und Ingress erstellen

Erstellen Sie ein neues Service-Manifest, um die Anwendung freizugeben:

$ nano strapi-service.yaml

Fügen Sie die folgenden Konfigurationen ein:

apiVersion: v1
kind: Service
metadata:
  name: strapi-service
spec:
  ports:
    - name: http
      port: 80
      protocol: TCP
      targetPort: 1337
  selector:
    name: strapi-app

Wenden Sie den Service an:

$ kubectl apply -f strapi-service.yaml

Erstellen Sie ein Ingress-Manifest:

$ nano strapi-ingress.yaml

Fügen Sie die folgenden Konfigurationen ein:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: strapi-ingress
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: nginx
  tls:
    - secretName: strapi-tls
      hosts:
        - strapi.example.com
  rules:
    - host: strapi.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: strapi-service
                port:
                  number: 80

Die oben gezeigte Ingress-Ressource ermöglicht den externen Zugriff auf den strapi-service. Sie verwendet die ClusterIssuer-Ressource letsencrypt-prod, um ein neues SSL-Zertifikat für die Domain strapi.example.com auszustellen und als Secret-Ressource strapi-tls zu speichern.

Wenden Sie die Ingress-Ressource an:

$ kubectl apply -f strapi-ingress.yaml

Überprüfen Sie die Ingress-Ressource:

$ kubectl get ingress

Öffnen Sie einen Webbrowser und rufen Sie die folgende URL auf, um zu prüfen, ob die Login-Seite über HTTPS angezeigt wird:

https://strapi.example.com

Strapi-Deployment skalieren

Durch das Skalieren der Strapi-Anwendung können hohe Traffic-Lasten effizient verarbeitet werden, ohne Ausfälle oder Unterbrechungen zu verursachen. In diesem Abschnitt passen Sie die Anzahl der laufenden Replikas an, um die Strapi-Anwendung zu skalieren.

Erhöhen Sie die Anzahl der laufenden Replikas:

$ kubectl scale deployment/strapi-deployment --replicas=4

Der obige Befehl skaliert das Deployment auf 4 Replikas.

Überprüfen Sie den Status des Deployments:

$ kubectl get deployment strapi-deployment

Die Ausgabe sollte in etwa wie folgt aussehen:

NAME        READY  UP-TO-DATE  AVAILABLE  AGE
strapi-deployment  4/4  4  4  67m

Zeigen Sie die laufenden Pods an:

$ kubectl get pods

Die Ausgabe sollte in etwa wie folgt aussehen:

NAME                 READY  STATUS  RESTARTS  AGE
strapi-deployment-5d5ccdb8b5-gj96w  1/1  Running  0  10m
strapi-deployment-5d5ccdb8b5-l8wv7  1/1  Running  0  9m34s
strapi-deployment-5d5ccdb8b5-wcg2x  1/1  Running  0  100s
strapi-deployment-5d5ccdb8b5-xx8t6  1/1  Running  0  100s

Verringern Sie die Anzahl der Replikas:

$ kubectl scale deployment/strapi-deployment --replicas=2

Kubernetes beendet automatisch die überzähligen Pods und passt die Verkehrsverteilung an.

Sie können die Fehlertoleranz testen, indem Sie manuell einen Pod löschen:

$ kubectl delete pod 

Ersetzen Sie <pod-name> durch den Namen eines vorhandenen Pods.

Kubernetes erkennt die Änderung und erstellt automatisch einen neuen Pod. Die Ingress-Ressource erkennt den neuen Pod und leitet Anfragen ohne Ausfallzeit weiter.

Fazit

Sie haben eine Beispiel-Strapi-Anwendung mit der Strapi-API und PostgreSQL-Konfiguration erstellt, anschließend containerisiert, bereitgestellt und auf einer Kubernetes Engine skaliert. Außerdem haben Sie CertManager so konfiguriert, dass Let’s-Encrypt-Zertifikate ausgestellt werden, und den Nginx Ingress Controller eingerichtet, um einen sicheren externen Zugriff auf die Cluster-Services zu ermöglichen.

Strapi vereinfacht das Content-Management durch eine intuitive Weboberfläche und macht tiefgehende technische Kenntnisse überflüssig. Dies macht es zu einer guten Wahl für den Aufbau von Low-Code- oder No-Code-Backends. Weitere Informationen finden Sie in den folgenden Ressourcen:

• Strapi API Referenz.
• Strapi Docker Dokumentation.