Cassandra Chaos Engineering With LitmusChaos

In this blog, I will talk about chaos engineering on Cassandra with LitmusChaos. Before jumping in, let's do a quick recap on Litmus. Litmus is a framework for practicing Chaos Engineering in cloud-native environments. Litmus provides a chaos-operator, a large set of chaos experiments in its hub, detailed documentation, quick demo, and a friendly community.

What is Cassandra?

Apache Cassandra is a free and open-source, distributed, wide column store, NoSQL database management system designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure. Cassandra offers robust support for clusters spanning multiple datacenters with asynchronous masterless replication allowing low latency operations for all clients. Cassandra's support for replicating across multiple datacenters is best-in-class, providing lower latency for your users and the peace of mind of knowing that you can survive regional outages.

Cassandra is using Consistent Hashing, which is a distributed hashing scheme that operates independently of the number of servers or objects in a distributed hash table by assigning them a position on an abstract circle, or hash ring. This allows servers and objects to scale without affecting the overall system. Cassandra uniformly distributes the load over the Cassandra ring and re-distribute the load when the Cassandra Statefulset scales up/down.

With Kubernetes popularity skyrocketing and the adoption of Apache Cassandra growing as a NoSQL database well-suited to matching the high availability and scalability needs of cloud-based applications, it should be no surprise that more developers are looking to run Cassandra databases on Kubernetes. However, many devs are finding that doing so is relatively simple to get going with, but considerably more challenging to execute at a high level. We will discuss the installation part later in this blog.

On the positive side, Kubernetes helpfully offers StatefulSets — workload API objects that can be used to manage stateful applications. StatefulSets provide the requisite components to establish stable and unique network identifiers, stable persistent storage, smooth and ordering deployment and scaling (as well as deletion and termination) and automated rolling updates.


Why do we need chaos engineering on Cassandra?

As Cassandra is using consistent hashing and maintaining the Cassandra ring to distribute the load uniformly. If the number of replicas will scale up/down, the load will be redistributed. But we always have a few questions in our mind:

  • Does load redistribution always happen with 0 probability of failure in scale-up/down?
  • How will it behave if the one/multiple replicas of the Cassandra Statefulset are killed?
  • Is it resilient even if the rate of replica deletion is very high?

In the age of data evolution, data is very important, and everyone is looking for a setup where the probability of downtime is least as possible. Here the chaos engineering comes into play. It will help you find out all the corner cases of failure before they happen, and if you believe in "Prevention is better than cure," then the best real-life example award goes to chaos engineering. It can be used to test the resiliency of the Cassandra stateful set. As of now, we have a Cassandra-pod-delete experiment to test the case where one of the replicas of Cassandra Statefulset is deleted. More use-cases/experiments will be added soon.

Chaos On Cassandra: Pod-Delete Experiment

Now that we know the basics of a Cassandra statefulset on Kubernetes, let us execute a chaos experiment to kill one of the replicas of Cassandra. At the same time the load is distributed on all the replicas over the Cassandra ring & verify whether the load is redistributed. This example intends to introduce the user to the steps involved in carrying out a chaos experiment using Litmus.


  • A (preferably) multi-node Kubernetes cluster. Ensure you are in the Kubernetes-admin context to setup RBAC for the various components involved.

Chaos Experiment Approach

The following steps are performed automatically upon execution of the Chaos Experiment:

  • An external liveness pod will be created, which will ensure the liveness of Cassandra's statefulset during chaos execution. It is continuously running the liveness cycles of cqlsh commands. Liveness cycle stands for a set of cqlsh operations (create keyspace, create the table, insert data in the table, delete the tables, delete the keyspaces). It runs a webserver container as a side cart, which exposes the status of the liveness cycle (cycleInProgress or cycleCompleted). The experiment looks for the status of the webserver service and cleans up the liveness deployment at the end of the cycle. In case of a timeout, the liveness container terminates ungracefully with an exception.
  • It will ensure that the load is distributed across all the replicas on the Cassandra ring before and after the chaos injection. It ensures that the load is re-distributed across all available replicas after every kill. In case if the load is not distributed on any of the available replicas, this check will be failed.
  • In its default mode, the experiment derives the random single/multiple replicas of Cassandra statefulset, performs a pod kill (delete), and checks the liveness and load distribution on the Cassandra ring across all replicas, which implies that the Cassandra statefulset remains alive and load redistribution takes place after every kill. If this is true, the experiment verdict is set to “pass,” indicating the current statefulset is tolerant to pod-failures. A terminated statefulset sets the verdict to “fail” and implies that the statefulset is not resilient enough, demanding a closer inspection.


  • Upon killing the replica of Cassandra statefulset, the load will be re-distributed over the Cassandra ring.
  • After the deletion of the replica, the new replica will be created by the replica controller to maintain the desired count of the available replicas.

Preparing the Testbed

Setup the Cassandra Cluster

We are going to discuss two approaches to set up the Cassandra cluster quickly.

  1. This approach will guide you through setting up a Cassandra cluster in AWS EKS with OpenEBS as a storage orchestration tool. Follow the following tutorial to setup the cluster Setup Cassandra Cluster on EKS.
  2. This approach will guide you to set up the Cassandra cluster in Minikube. We can follow the underlying steps to set up the Cassandra cluster.
  • Step-1: Creating a headless Service for Cassandra

Creating the headless service for Cassandra used for DNS lookups between Cassandra Pods and clients within your cluster:

root@demo:~# cat <<EOF>  cassandra-service.yaml

apiVersion: v1
kind: Service
    app: cassandra
  name: cassandra
  clusterIP: None
  - port: 9042
    app: cassandra
root@demo:~# kubectl create -f cassandra-service.yaml -n cassandra
 service/cassandra created
Validation of Cassandra service: 

root@demo:~# kubectl get svc cassandra -n cassandra 
The response is:
     NAME        TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
     cassandra   ClusterIP   None         <none>        9042/TCP   45s

If you don't see a Service named Cassandra, that means creation failed.

  • Step-2: Using a StatefulSet to create a Cassandra ring

The StatefulSet manifest included below, creates a Cassandra ring that consists of three Pods.

Note: This example uses the default provisioner for Minikube. Please update the following StatefulSet for the cloud you are working with.

root@demo:~# cat <<EOF> cassandra-sts.yaml 

apiVersion: apps/v1
kind: StatefulSet
  name: cassandra
    app: cassandra
  serviceName: cassandra
  replicas: 3
      app: cassandra
        app: cassandra
      terminationGracePeriodSeconds: 1800
      - name: cassandra
        imagePullPolicy: Always
        - containerPort: 7000
          name: intra-node
        - containerPort: 7001
          name: tls-intra-node
        - containerPort: 7199
          name: jmx
        - containerPort: 9042
          name: cql
            cpu: "500m"
            memory: 1Gi
            cpu: "500m"
            memory: 1Gi
              - IPC_LOCK
              - /bin/sh
              - -c
              - nodetool drain
          - name: MAX_HEAP_SIZE
            value: 512M
          - name: HEAP_NEWSIZE
            value: 100M
          - name: CASSANDRA_SEEDS
            value: "cassandra-0.cassandra.default.svc.cluster.local"
          - name: CASSANDRA_CLUSTER_NAME
            value: "K8Demo"
          - name: CASSANDRA_DC
            value: "DC1-K8Demo"
          - name: CASSANDRA_RACK
            value: "Rack1-K8Demo"
          - name: POD_IP
                fieldPath: status.podIP
            - /bin/bash
            - -c
            - /
          initialDelaySeconds: 15
          timeoutSeconds: 5
        # These volume mounts are persistent. They are like inline claims,
        # but not exactly because the names need to match exactly one of
        # the stateful pod volumes.
        - name: cassandra-data
          mountPath: /cassandra_data
  # These are converted to volume claims by the controller
  # and mounted at the paths mentioned above.
  # do not use these in production until ssd GCEPersistentDisk or other ssd pd
  - metadata:
      name: cassandra-data
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: fast
          storage: 1Gi
kind: StorageClass
  name: fast
  type: pd-ssd
root@demo:~# kubectl create -f cassandra-sts.yaml -n cassandra
statefulset.apps/cassandra created created
Validating the Cassandra StatefulSet
root@demo:~# kubectl get statefulset cassandra -n cassandra

The response should be similar to:
cassandra   3         0         13s
root@demo:~# kubectl get pods -l="app=cassandra" -n cassandra

It can take several minutes for all three Pods to deploy. Once they are deployed, the same command returns output similar to:

cassandra-0   1/1       Running   0          10m
cassandra-1   1/1       Running   0          9m
cassandra-2   1/1       Running   0          8m

Step-3: Run the Cassandra nodetool inside the first Pod, to display the status of the ring.

kubectl exec -it cassandra-0 -- nodetool status

The response should look something like:

Datacenter: DC1-K8Demo
|/ State=Normal/Leaving/Joining/Moving
--  Address     Load       Tokens       Owns (effective)  Host ID                               Rack
UN  83.57 KiB  32           74.0%             e2dd09e6-d9d3-477e-96c5-45094c08db0f  Rack1-K8Demo
UN  101.04 KiB  32           58.8%             f89d6835-3a42-4419-92b3-0e62cae1479c  Rack1-K8Demo
UN  84.74 KiB  32           67.1%             a6a1e8c2-3dc5-4417-b1a0-26507af2aaad  Rack1-K8Demo

Setup the Litmus Infrastructure

  • Step-1: Install Litmus Chaos CRDs, Operator & RBAC
root@demo:~# kubectl apply -f
namespace/litmus created
serviceaccount/litmus created created created
deployment.apps/chaos-operator-ce created created created created
kubectl apply -f
  • Step-2: Create the Cassandra-Pod-Delete ChaosExperiment CR
root@demo:~# kubectl apply -f -n litmus created
  • Step-3: Annotate the Kafka statefulset for Chaos
root@demo:~# kubectl annotate sts/cassandra"true" -n cassandra 
statefulset.apps/cassandra annotated

Run the Chaos Experiment

  • Step-1: Construct the ChaosEngine for the Cassandra Pod Delete experiment:
root@demo:~# cat <<EOF> cassanddra-chaos.yaml

kind: ChaosEngine
 name: cassandra-chaos
 namespace: litmus
    appns: ‘'cassandra’
    applabel: 'app=cassandra'
    appkind: 'statefulset'
  annotationCheck: 'true'
  engineState: 'active'
  chaosServiceAccount: litmus-admin
  monitoring: false
  jobCleanUpPolicy: 'delete'
    - name: cassandra-pod-delete
              value: '15'

            - name: CHAOS_INTERVAL
              value: '15'

            - name: FORCE
              value: 'false'

           - name: CASSANDRA_SVC_NAME
              value: 'cassandra'

              value: '3'

            - name: CASSANDRA_PORT
              value: '9042'

             - name: CASSANDRA_LIVENESS_CHECK
              value: ''

  • Step-2: Apply the ChaosEngine to launch the experiment
root@demo:~# kubectl apply -f cassandra-chaos.yaml -n litmus created
  • Step-3: Observe experiment execution

Watch the pods on the app namespace (cassandra) to view the chaos actions in progress.

watch -n 1 kubectl get pods -n cassandra

Look out for the following events.

  • As part of the experiment execution, the experiment job launches a liveness pod (cassandra-liveness) that runs few cqlsh queries (create keyspaces, create tables, data insertion, and cleanup of table & keyspaces) running as separate containers of the same pod.
  • The liveness pod is failed if it is unable to run cqlsh commands(Cassandra is unavailable). View the cassandra-liveness pod logs during the pod-delete to verify the Uninterrupted availability of Cassandra statefulset.
kubectl logs -f cassandra-liveness -n litmus
  • Step-4: Verify Result Of the Chaos Experiment

View the verdict (spec.experimentStatus.verdict)of the cassandra-pod-delete chaos experiment to check whether the Cassandra cluster is resilient to the pod-delete.

root@demo:~# kubectl describe chaos result cassandra-chaos-cassandra-pod-delete -n litmus

Name:         cassandra-chaos-cassandra-pod-delete
Namespace:    litmus
Labels:       chaosUID=22d5ba06-1fe8-4b01-bdbb-6246e1cdb2c9
API Version:
Kind:         ChaosResult
  Creation Timestamp:  2020-07-16T12:28:00Z
  Generation:          10
  Resource Version:    20451
  Self Link:           /apis/
  UID:                 32ea5093-47ee-41d8-bc34-e513edb46660
  Engine:      cassandra-chaos
  Experiment:  cassandra-pod-delete
    Fail Step:  N/A
    Phase:      Completed
    Verdict:    Pass
Events:         <none>


The Cassandra chaos experiments are a good way to determine a potential breach of SLAs in terms of data consistency, performance & timeouts due to unexpected replica-kill. It will boost the developers' confidence for those use-cases for which their setup returns a positive/passed result. In the future, even if that chaos happens naturally(finger crossed), then the developers don’t have to worry. They are already trained with chaos management skills as they are chaos engineers/warriors after the adoption of chaos engineering practices.
Do try this experiment & let me know your findings!

Are you an SRE or a Kubernetes enthusiast? Does Chaos Engineering excite you? Join Our Community #litmus channel in Kubernetes Slack
Contribute to LitmusChaos and share your feedback on Github
If you like LitmusChaos, become one of the many stargazers here

Kiran Mova
Kiran evangelizes open culture and open-source execution models and is a lead maintainer and contributor to the OpenEBS project. Passionate about Kubernetes and Storage Orchestration. Contributor and Maintainer OpenEBS projects. Co-founder and Chief Architect at MayaData Inc.
Naresh Deshaveni
Naresh Deshaveni is the Director of Solution Engineering, MayaData. He is passionate about developing, deployment solutions for application clusters by taking advantage of Kubernetes and providing scalable, highly available application stack. His past experience include building database scalability solution and building application and network security solution.
Evan Powell
Evan Powell has been founding CEO of four successful enterprise infrastructure software companies, Clarus Systems (RVBD), Nexenta Systems, StackStorm (BRCD), and now MayaData. As founding CEO of StackStorm, Evan helped to create the event-driven automation category. He helped to build a vibrant open source community leveraging and improving upon approaches used by the largest operators such as Facebook. As founding CEO of Nexenta Systems, he helped to re-imagine the storage industry as one in which the value of software and freedom from vendor lock-in would predominate. Under his leadership, Nexenta became the leader of the OpenStorage movement and the software-defined storage sector, with thousands of customers and hundreds of millions of dollars of annual partner sales. To relax away from work, Evan runs Spartan races and tries to keep up with his family’s adventures.