📖 Inhaltsverzeichnis

Praxis-Guide: WordPress auf STACKIT (SKE + Managed MariaDB)

Diese Anleitung führt durch das Deployment einer WordPress-Instanz auf der STACKIT Cloud. Wir nutzen eine moderne Architektur, bei der die Datenbank als Managed Service läuft und nur die Applikation selbst im Kubernetes Cluster.

Voraussetzungen

  • Zugang zum STACKIT Portal.
  • Ein aktives Projekt.
  • Installiertes kubectl und k9s auf deinem lokalen Rechner oder auf einem Jumphost.

Schritt 1: Infrastruktur bereitstellen

1. Kubernetes Cluster (SKE) erstellen

Links: https://docs.stackit.cloud/products/runtime/kubernetes-engine/getting-started/create-cluster/ https://docs.stackit.cloud/products/runtime/kubernetes-engine/getting-started/access-cluster/

  1. Navigiere im STACKIT Portal zu STACKIT Kubernetes Engine (SKE).
  2. Erstelle einen neuen Cluster (z.B. wp-cluster).
  3. Wähle eine Node-Pool-Größe (z.B. 1 Node Minimum, 2 Node Maximum, c2i.2 Flavor reicht für Tests).
  4. Eventuell ist es notwendig (abhängig von deiner IP-Adresse), dass du deine IP-Adresse als ACL-IP-Bereich des Clusters hinterlegst. Eine ACL ist ähnlich einer Firewall, wenn deine IP-Adresse mit der du dich versuchst anzumelden nicht hinterlegt ist, wird die Verbindung abgelehnt. Deine IP-Adresse findest du beispielsweise mit https://www.whatismyip.com/de/. Setzen kannst du die Cluster ACL auf der Übersichtsseite deines Clusters.
  5. Lade nun die kubeconfig herunter
    1. Klicke dazu auf die drei Punkte auf der Kubernetes Engine Übersichtsseite
    2. Wähle dann ein angemessenes Verfallsdatum (so lang wie nötig, so kurz wie möglich, etwa ~8h)
  6. Setze sie nun als default für deine lokale Umgebung, so weiß k9s und kubectl mit welchen Anmeldedaten er sich am Cluster anmelden soll
export KUBECONFIG=path/to/your/kubeconfig.yaml
kubectl get nodes

2. Managed MariaDB erstellen

Links: https://docs.stackit.cloud/products/databases/mariadb/getting-started/create-your-first-instance-and-connect-to-it/

  1. Navigiere zu MariaDB (unter STACKIT Services).
  2. Erstelle eine neue Instanz (z.B. wp-database).
  3. Wähle einen Plan (für uns reicht der kleinste Plan).
  4. Erstelle im Dashboard (wenn du auf deine Datenbank draufklickst) der Datenbank Anmeldedaten. Daraufhin bekommst du folgende Information, schreibe diese an einer sicheren Stelle auf.
    1. Passwort
    2. Username
    3. Port im Feld Verbindung nach dem : steht eine fünf stellige Zahl, das ist der Port bspw. mysql://a9s35a4bb46205f236f35f3d243743f:a9sd8d3f639f0ff871ca3b81ac980165ccec7bf1276@mad827f29-1.data.eu01.onstackit.cloud:50746/mad827f29 dabei wäre 50746 der Port
    4. Datenbankname im Feld Verbindung nach dem letzten /, das ist der Datenbankname bspw. wäre es im oberen Beispiel mad827f29

Schritt 2: Kubernetes Konfiguration

Wir müssen dem Cluster beibringen, wie er die Datenbank erreicht und wo er Bilder/Uploads speichern soll.

1. Datenbank-Zugangsdaten (Secret)

Erstelle ein Kubernetes Secret, damit das Passwort nicht im Klartext in der Konfiguration steht. Nutze dazu das Passwort und Username welches du dir aufgeschrieben hast.

kubectl create secret generic wordpress-db-secret \
  --from-literal=username='DeinenUsernamenWelchenDuDirAufgeschriebenHast' \
  --from-literal=password='DeinSicheresPasswortWelchesDuDirAufgeschriebenHast'

2. Speicher für Uploads (Persistent Volume Claim)

Auch wenn die Datenbank extern liegt, benötigt WordPress Speicherplatz für hochgeladene Bilder, Themes und Plugins (wp-content). Dafür nutzen wir einen PVC, der automatisch eine Festplatte bei STACKIT bestellt.

Erstelle eine Datei wp-pvc.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: wp-content-pvc
  labels:
    app: wordpress
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Wende es an:

kubectl apply -f wp-pvc.yaml

Schritt 3: WordPress Deployment

Erstelle die Datei wordpress-deployment.yaml. Hier definieren wir den Container und verbinden ihn mit der Managed Database.

Achtung: Ersetze DEIN_DB_HOST und DEIN_DB_PORT mit den Daten aus dem STACKIT Portal.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:latest
        ports:
        - containerPort: 80
        env:
        - name: WORDPRESS_DB_HOST
          value: "DEIN_DB_HOST:DEIN_DB_PORT"
        - name: WORDPRESS_DB_USER
          valueFrom:
            secretKeyRef:
              name: wordpress-db-secret
              key: username
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: wordpress-db-secret
              key: password
        - name: WORDPRESS_DB_NAME
          value: "wordpress_db"
        volumeMounts:
        - name: wordpress-persistent-storage
          mountPath: /var/www/html
      volumes:
      - name: wordpress-persistent-storage
        persistentVolumeClaim:
          claimName: wp-content-pvc

Wende es an:

kubectl apply -f wordpress-deployment.yaml

Schritt 4: Zugriff von außen (Service)

Damit die Welt deinen Blog sieht, benötigen wir einen LoadBalancer, der eine öffentliche IP-Adresse zuweist.

Erstelle die Datei wordpress-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: wordpress-service
  labels:
    app: wordpress
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    app: wordpress
  type: LoadBalancer

Wende es an:

kubectl apply -f wordpress-service.yaml

Fertigstellung

  1. Führe kubectl get svc -w aus und warte, bis unter EXTERNAL-IP eine IP-Adresse erscheint (das kann ein paar Minuten dauern).
  2. Kopiere die IP und öffne sie im Browser: http://<DEINE-EXTERNAL-IP>.
  3. Du solltest nun den WordPress-Installations-Assistenten sehen.