Mehrknoten-Apache-Cassandra-Cluster auf Kubernetes mit dem K8ssandra Operator bereitstellen

Apache Cassandra ist eine extrem skalierbare, verteilte NoSQL-Datenbank, die dafür entwickelt wurde, sehr große Datenmengen über viele Standard-Server hinweg zu verarbeiten. Durch die verteilte Architektur werden Single Points of Failure vermieden und eine unkomplizierte horizontale Skalierung ermöglicht. Cassandra ist besonders stark bei schreibintensiven Workloads und liefert hohe Schreib- und Leseperformance, was sie zur idealen Wahl für datenintensive Anwendungen macht. Gleichzeitig erlaubt sie eine fein abstimmbare Konsistenz, sodass sich das Konsistenzniveau an die Anforderungen der Anwendung anpassen lässt.

K8ssandra ist ein Open-Source-Projekt, das die Bereitstellung und den Betrieb von Apache Cassandra auf Kubernetes deutlich vereinfacht. Es umfasst den K8ssandra Operator, der zentrale Aufgaben wie Cluster-Provisionierung, Skalierung, Backups und Reparaturen automatisiert.

Diese Anleitung zeigt, wie du mit dem K8ssandra Operator ein Mehrknoten-Apache-Cassandra-Cluster auf einer Kubernetes Engine ausrollst.

Voraussetzungen

Bevor du loslegst, stelle sicher, dass du:

• Zugriff auf eine Kubernetes Engine mit mindestens 4 Nodes und mindestens 4 GB RAM pro Node hast.
• Einen Ubuntu Server als Nicht-Root-User mit sudo-Rechten als Control-Plane-System zur Verfügung hast.
• Kubectl auf deiner Workstation installiert hast.
• Den Helm Package Manager auf deiner Workstation installiert hast.
• Deine Cluster-Kubeconfig-Datei besitzt und kubectl auf deiner Workstation so konfiguriert hast, dass es sich mit dem Cluster verbindet.

Cassandra CLI (cqlsh) installieren

Die Cassandra-CLI cqlsh ist ein Python-basiertes Kommandozeilenwerkzeug, mit dem du mit Cassandra-Datenbanken arbeiten kannst. Folge den Schritten unten, um es zu installieren.

Paketindex des Servers aktualisieren

$ sudo apt update

Python und Pip installieren

$ sudo apt install -y python3 python3-pip python3.12-venv

Installierte Python-Version prüfen

$ python3 --version

Die Ausgabe sollte etwa so aussehen:

Python 3.12.7

Installierte Pip-Version prüfen

$ pip --version

Die Ausgabe sollte etwa so aussehen:

pip 24.2 from /usr/lib/python3/dist-packages/pip (python 3.12)

Python-virtuelle Umgebung erstellen

$ python3 -m venv cassandra

Python-virtuelle Umgebung aktivieren

$ source cassandra/bin/activate

Aktuellste cqlsh-CLI installieren

Installiere die neueste Version der cqlsh-Kommandozeilenschnittstelle:

$ pip install -U cqlsh

Installierte cqlsh-Version verifizieren

$ cqlsh --version

Die Ausgabe sollte etwa so aussehen:

cqlsh 6.2.0

Cert-Manager installieren

Cert-Manager ist ein Kubernetes-Operator, der TLS/SSL-Zertifikate innerhalb eines Clusters von vertrauenswürdigen Stellen wie Let’s Encrypt ausstellt und verwaltet. K8ssandra nutzt cert-manager, um die Zertifikatsverwaltung in Cassandra-Clustern zu automatisieren. Dazu gehört auch das Erstellen der Java-KeyStores und TrustStores, die Cassandra aus den Zertifikaten benötigt. Folge den Schritten unten, um die für den K8ssandra Operator relevanten cert-manager-Komponenten zu installieren.

Cert-Manager-Helm-Repository hinzufügen

Füge mit Helm das Cert-Manager-Repository zu deinen lokalen Chart-Quellen hinzu.

$ helm repo add jetstack https://charts.jetstack.io

Helm-Chart-Index aktualisieren

$ helm repo update

Cert-Manager im Cluster installieren

Installiere Cert-Manager in deinem Kubernetes-Engine-Cluster.

$ helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set crds.enabled=true

Prüfen, ob Cert-Manager-Ressourcen laufen

Nach der erfolgreichen Installation überprüfe, ob alle Cert-Manager-Ressourcen im Cluster vorhanden sind.

$ kubectl get all -n cert-manager

Die Ausgabe sollte in etwa wie im folgenden Beispiel aussehen:

NAME                                           READY   STATUS    RESTARTS   AGE
pod/cert-manager-cainjector-686546c9f7-m9gp7   1/1     Running   0          43s
pod/cert-manager-d6746cf45-sjjs6               1/1     Running   0          43s
...
NAME                              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)            AGE
service/cert-manager              ClusterIP   10.110.17.176           9402/TCP           44s
...
NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/cert-manager              1/1     1            1           43s
...
NAME                                                 DESIRED   CURRENT   READY   AGE
replicaset.apps/cert-manager-cainjector-686546c9f7   1         1         1       43s
...

K8ssandra Operator installieren

Um Apache-Cassandra-Cluster auf Kubernetes zu betreiben, installiere den K8ssandra Operator mit Helm. Folge den Schritten unten, um den Operator bereitzustellen.

K8ssandra-Helm-Repository hinzufügen

Füge das Repository des K8ssandra Operators zu deinen Helm-Quellen hinzu.

$ helm repo add k8ssandra https://helm.k8ssandra.io/stable

K8ssandra Operator installieren

Installiere den K8ssandra Operator in deinem Cluster.

$ helm install k8ssandra-operator k8ssandra/k8ssandra-operator \
  --namespace k8ssandra-operator \
  --create-namespace

Operator-Deployment überprüfen

Überprüfe nach einigen Minuten das Deployment, um sicherzugehen, dass der K8ssandra Operator verfügbar ist.

$ kubectl -n k8ssandra-operator get deployment

Die Ausgabe sollte etwa so aussehen:

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
k8ssandra-operator                 1/1     1            1           20s
k8ssandra-operator-cass-operator   1/1     1            1           20s

Sicherstellen, dass die Operator-Pods laufen

Stelle sicher, dass die Pods des K8ssandra Operators bereit sind und den Status „Running“ haben.

$ kubectl get pods -n k8ssandra-operator

Die Ausgabe sollte etwa so aussehen:

NAME                                                READY   STATUS    RESTARTS   AGE
k8ssandra-operator-65b9c7c9c-km28b                  1/1     Running   0          46s
k8ssandra-operator-cass-operator-54845bc4f6-hsqds   1/1     Running   0

Mehrknoten-Apache-Cassandra-Cluster auf Kubernetes Engine einrichten

Setze mit dem K8ssandra Operator ein hochverfügbares Cassandra-Cluster auf einer Kubernetes Engine auf. Nutze die nachfolgenden Schritte, um ein Apache-Cassandra-Cluster zu erstellen und in Betrieb zu nehmen.

StorageClasses im Cluster prüfen

Liste zuerst die StorageClasses auf, die in deinem Cluster verfügbar sind.

 
$ kubectl get storageclass

Deine Ausgabe sollte dem folgenden Beispiel ähneln:

NAME                             PROVISIONER           RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
centron-block-storage (default)  block.csi.centron.de  Delete          Immediate           true                   6m24s
centron-block-storage-hdd        block.csi.centron.de  Delete          Immediate           true                   6m25s
centron-block-storage-hdd-retain block.csi.centron.de  Retain          Immediate           true                   6m25s
...

Cassandra-Cluster-Manifest erstellen

Erstelle mit einem Texteditor wie nano eine neue Manifest-Datei namens cluster.yaml.

$ nano cluster.yaml

Füge den folgenden Inhalt in die Datei ein. Ersetze centron-block-storage durch die StorageClass, die in deinem Cluster vorhanden ist (wie im vorherigen Schritt angezeigt).

apiVersion: k8ssandra.io/v1alpha1
kind: K8ssandraCluster
metadata:
  name: demo
spec:
  cassandra:
    serverVersion: "4.0.1"
    datacenters:
      - metadata:
          name: dc1
        size: 3
        storageConfig:
          cassandraDataVolumeClaimSpec:
            storageClassName: centron-block-storage
            accessModes:
              - ReadWriteOnce
            resources:
              requests:
                storage: 10Gi
        config:
          jvmOptions:
            heapSize: 512M
        stargate:
          size: 1
          heapSize: 256M

Speichere die Datei und schließe den Editor.

Dieses Manifest legt den Cassandra-Cluster mit folgenden Einstellungen fest:

• Cassandra-Version: 4.0.1
• Drei Worker-Nodes im Cluster.
• Die StorageClass centron-block-storage mit je 10 GB persistentem Volume pro Node.
• JVM-Heap-Größe pro Cassandra-Node auf 512 MB gesetzt.
• JVM-Heap-Größe für Stargate auf 256 MB festgelegt.

Hinweis
Wenn du dies auf der Kubernetes Engine von centron betreibst, stelle sicher, dass der centron-CSI-Treiber vor dem Deployment mit den notwendigen Zugangsdaten konfiguriert ist. Dadurch ist die dynamische Bereitstellung von Block-Storage-Volumes möglich. Sieh in der centron-CSI-Dokumentation nach, um die vollständigen Einrichtungsschritte zu erhalten.

Cluster-Deployment anwenden

Wende das Manifest in deinem Cluster an.

$ kubectl apply -n k8ssandra-operator -f cluster.yaml

Warte mindestens 15 Minuten und beobachte anschließend die Cluster-Pods.

$ kubectl get pods -n k8ssandra-operator --watch

Stelle sicher, dass alle Pods bereit sind und laufen, ähnlich wie hier:

NAME                                                    READY   STATUS    RESTARTS   AGE
demo-dc1-default-stargate-deployment-64747477d7-hfck9   1/1     Running   0          78s
demo-dc1-default-sts-0                                  2/2     Running   0          6m5s
demo-dc1-default-sts-1                                  2/2     Running   0          6m5s
demo-dc1-default-sts-2                                  2/2     Running   0          6m5s
k8ssandra-operator-65b9c7c9c-km28b                      1/1     Running   0          17m
k8ssandra-operator-cass-operator-54845bc4f6-hsqds       1/1     Running   0          17m

Sobald alle Cassandra-Datenbank-Pods gesund sind, beginnen die Stargate-Pods mit der Initialisierung. Stargate dient als Daten-Gateway und stellt REST-, GraphQL- und Document-APIs vor Cassandra bereit. Der Stargate-Pod-Name sollte einem Muster wie demo-dc1-default-stargate-deployment-xxxxxxxxx-xxxxx folgen.

Verknüpfte Block-Storage-PVCs für dauerhafte Cassandra-Daten prüfen

Der K8ssandra Operator deployt Cassandra-Pods als StatefulSets, damit stabile Netzwerkidentitäten und persistenter Speicher gewährleistet sind. Jedes StatefulSet steht für einen Cassandra-Node und verwendet eine Persistent Volume Claim (PVC), um Daten zuverlässig zu speichern. Dieser Abschnitt zeigt, wie du bestätigst, dass die PVCs über den Block-Storage-Dienst deiner Kubernetes Engine angelegt werden.

Bereitschaft der StatefulSets prüfen

Überprüfe, dass die StatefulSets vorhanden und bereit sind.

$ kubectl get statefulset -n k8ssandra-operator

Deine Ausgabe sollte dem folgenden Beispiel entsprechen:

NAME                   READY   AGE
demo-dc1-default-sts   3/3     7m14s

Diese Ausgabe bestätigt, dass alle drei Cassandra-Nodes laufen und das StatefulSet aktiv ist.

StorageClass verifizieren

Prüfe die StorageClass, die die Volumes deines Clusters bereitstellt.

$ kubectl get sc centron-block-storage

Deine Ausgabe sollte dem folgenden Beispiel ähneln:

NAME                             PROVISIONER           RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
centron-block-storage (default)  block.csi.centron.de  Delete          Immediate           true                   24m

PVCs über alle Namespaces auflisten

Liste alle PVCs in sämtlichen Namespaces auf, um sicherzustellen, dass sie korrekt gebunden sind.

$ kubectl get pvc --all-namespaces

Deine Ausgabe sollte dem folgenden Beispiel ähneln:

NAMESPACE            NAME                                 STATUS   VOLUME                 CAPACITY   ACCESS MODES   STORAGECLASS           VOLUMEATTRIBUTESCLASS   AGE
k8ssandra-operator   server-data-demo-dc1-default-sts-0   Bound    pvc-a62852bae9d24dad   10Gi       RWO            centron-block-storage                   13m
k8ssandra-operator   server-data-demo-dc1-default-sts-1   Bound    pvc-cfb279b19d0c4a55   10Gi       RWO            centron-block-storage                   13m
k8ssandra-operator   server-data-demo-dc1-default-sts-2   Bound    pvc-b09e184f4d7741f6   10Gi       RWO            centron-block-storage                   13m

Kubernetes-Service erstellen, um auf den Cassandra-Cluster zuzugreifen

Damit der Cassandra-Cluster von außen erreichbar ist und Verbindungen über das native Cassandra-Protokoll (CQL) auf Port 9042 akzeptiert, brauchst du einen Kubernetes Service vom Typ LoadBalancer. Dadurch wird über die Load-Balancer-Integration eine öffentliche IP zugewiesen.

Service-Manifest erstellen

Erstelle eine neue Service-Datei namens service.yaml.

$ nano service.yaml

Füge den folgenden Inhalt in die Datei ein.

apiVersion: v1
kind: Service
metadata:
  name: cassandra
  labels:
    app: cassandra
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  ports:
    - port: 9042
      targetPort: 9042
  selector:
    app.kubernetes.io/name: cassandra

Speichere die Datei und schließe den Editor.

Diese Konfiguration definiert einen LoadBalancer-Service, der den Cassandra-Cluster auf Port 9042 nach außen freigibt.

Service anwenden

Wende den Service im Namespace k8ssandra-operator an.

$ kubectl apply -n k8ssandra-operator -f service.yaml

Warte ungefähr 5 Minuten, bis der LoadBalancer erstellt ist, und prüfe dann den Cassandra-Service.

$ kubectl get svc/cassandra -n k8ssandra-operator

Sieh dir das Feld External-IP an und notiere die IP-Adresse für den Zugriff auf den Cluster.

NAME        TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
cassandra   LoadBalancer   10.103.92.169   192.0.2.1     9042:32444/TCP   2m12s

Hinweis
Wenn bei EXTERNAL-IP der Wert <pending> steht, warte etwas länger und führe den Befehl erneut aus. Sobald eine IP zugewiesen wurde, kannst du dich damit über einen CQL-Client wie cqlsh mit Cassandra verbinden.

Apache-Cassandra-Cluster testen

cqlsh ist ein Kommandozeilenwerkzeug, um eine Verbindung zu Cassandra herzustellen. Die Schritte unten zeigen, wie du CQL-Befehle (Cassandra Query Language) ausführst und Aktionen wie das Erstellen, Aktualisieren und Abfragen von Daten durchführst.

LoadBalancer-IP exportieren

Lege die LoadBalancer-IP deines Cassandra-Services in der Variablen CASS_IP ab.

$ CASS_IP=$(kubectl get svc cassandra -n k8ssandra-operator -o jsonpath="{.status.loadBalancer.ingress[*].ip}")

Gib die zugewiesene Cassandra-IP aus.

$ echo $CASS_IP

Cluster-Benutzernamen exportieren

Schreibe den Zugriffs-Benutzernamen des Clusters in die Variable CASS_USERNAME.

$ CASS_USERNAME=$(kubectl get secret demo-superuser -n k8ssandra-operator -o=jsonpath='{.data.username}' | base64 --decode)

Gib den Cassandra-Benutzernamen aus.

$ echo $CASS_USERNAME

Cluster-Passwort exportieren

Schreibe das Cluster-Passwort in die Variable CASS_PASSWORD.

$ CASS_PASSWORD=$(kubectl get secret demo-superuser -n k8ssandra-operator -o=jsonpath='{.data.password}' | base64 --decode)

Gib das Cassandra-Passwort aus.

$ echo $CASS_PASSWORD

Mit cqlsh anmelden

Verbinde dich mit cqlsh anhand der gesetzten Variablen mit dem Cassandra-Cluster.

$ cqlsh -u $CASS_USERNAME -p $CASS_PASSWORD $CASS_IP 9042

Keyspace erstellen

Lege einen neuen Keyspace mit dem Namen demo an.

demo-superuser@cqlsh> CREATE KEYSPACE demo WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};

Tabelle erstellen

Erstelle im Keyspace demo eine Tabelle namens users.

demo-superuser@cqlsh> CREATE TABLE demo.users (id text primary key, name text, country text);

Datensätze einfügen

Füge Beispiel-Datensätze in die users-Tabelle ein.

demo-superuser@cqlsh> BEGIN BATCH
                         INSERT INTO demo.users (id, name, country) VALUES ('42', 'John Doe', 'UK');
                         INSERT INTO demo.users (id, name, country) VALUES ('43', 'Joe Smith', 'US');
                      APPLY BATCH;

Daten abfragen

Frage die Tabelle ab, um die gespeicherten Werte anzuzeigen.

demo-superuser@cqlsh> SELECT * FROM demo.users;

Deine Ausgabe sollte in etwa so aussehen:

 id | country | name
----+---------+-----------
 43 |      US | Joe Smith
 42 |      UK |  John Doe

(2 rows)

Fazit

Du hast mit dem Open-Source-K8ssandra Operator erfolgreich ein Apache-Cassandra-Cluster auf einer Kubernetes-Engine-Umgebung eingerichtet. Persistenter Speicher wurde über Block Storage aktiviert und der Zugriff auf den Cassandra-Cluster erfolgte über die cqlsh-CLI. Für weiterführende Konfigurationsmöglichkeiten und komplexere Anwendungsfälle solltest du die offizielle Cassandra-Dokumentation zu Rate ziehen.