Join our Discord Server
Ajeet Raina Docker Captain, ARM Innovator & Docker Bangalore Community Leader.

Kubernetes StatefulSets and Its Best Practices

2 min read

Kubernetes StatefulSets are a type of controller in Kubernetes that manage the deployment and scaling of stateful applications. Stateful applications are those that maintain state, such as databases or key-value stores, and require a stable, persistent identity to operate correctly.

StatefulSets provide the following features for stateful applications:

1. Stable network identities

Each Pod in a StatefulSet is assigned a stable, unique network identity that persists across rescheduling or failure.

2. Ordered, graceful deployment and scaling

Pods are created or updated in a predictable, ordered way, ensuring that dependent services can properly discover and connect to the Pods.

3. Stable storage

Each Pod in a StatefulSet can have its own unique storage volume, which can be managed by Kubernetes or an external storage system.

Here’s an example of how you might use a StatefulSet to deploy and manage a stateful application like a database:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: my-database
spec:
  serviceName: my-database
  replicas: 3
  selector:
    matchLabels:
      app: my-database
  template:
    metadata:
      labels:
        app: my-database
    spec:
      containers:
      - name: database
        image: my-database-image
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 10Gi

In this example, the StatefulSet is named “my-database” and specifies a service named “my-database” to expose the Pods in the StatefulSet. The StatefulSet also specifies that it should have three replicas, and the selector and template specifications ensure that each Pod in the StatefulSet has the label “app: my-database”. The container in the Pod is running the “my-database-image” and is configured to use a persistent volume mounted at “/var/lib/mysql”. The volumeClaimTemplates specifies that each Pod should have a volume with 10Gi of storage requested with ReadWriteOnce access mode.

With this StatefulSet configuration, Kubernetes will manage the deployment and scaling of the “my-database” Pods, ensuring that each Pod has a unique, stable network identity and that the Pods are created and updated in a predictable, ordered way. The volumeClaimTemplates configuration ensures that each Pod in the StatefulSet has its own unique storage volume that persists across rescheduling or failure.

Kubernetes StatefulSets Best Practices

Here are some Kubernetes StatefulSets best practices:

  • Use unique and meaningful names for your StatefulSets and their Pods: This makes it easier to identify and manage StatefulSets and their associated resources.
  • Use headless services for StatefulSets: This allows you to have stable network identities for each Pod, which is critical for stateful applications that rely on unique network identities to function properly. Here’s an example of a headless service for a StatefulSet:
apiVersion: v1
kind: Service
metadata:
  name: my-statefulset
spec:
  selector:
    app: my-statefulset
  clusterIP: None
  ports:
  - name: http
    port: 80

In this example, the service is named “my-statefulset” and selects Pods with the label “app: my-statefulset”. The “clusterIP: None” setting makes this a headless service, and the “ports” configuration exposes port 80 with the name “http”.

  • Use StatefulSets for stateful applications: StatefulSets are designed to manage stateful applications that require stable, persistent identities, such as databases or key-value stores. If you have a stateless application, consider using a Deployment instead.
  • Use persistent volumes for storage: Each Pod in a StatefulSet should have its own unique, persistent storage volume to maintain state across rescheduling or failure. Here’s an example of a persistent volume configuration:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-volume
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

In this example, the persistent volume claim is named “my-volume” and requests 1Gi of storage with ReadWriteOnce access mode.

  • Scale StatefulSets carefully: Scaling StatefulSets can be more complex than scaling Deployments, as each Pod has a unique identity that must be maintained. Make sure you understand the dependencies and requirements of your stateful application before scaling a StatefulSet.
  • Handle upgrades and rollbacks carefully: Upgrading or rolling back a StatefulSet can be more complex than with Deployments, as each Pod has a unique identity that must be maintained. Make sure you understand the process and potential impact of upgrading or rolling back a StatefulSet.

By following these best practices, you can effectively manage stateful applications using Kubernetes StatefulSets.

References

Please follow and like us:

Have Queries? Join https://launchpass.com/collabnix

Ajeet Raina Docker Captain, ARM Innovator & Docker Bangalore Community Leader.

Exploring the Cloud-Native Ecosystem: A Beginner’s Guide to the…

The Cloud Native Computing Foundation (CNCF) is a non-profit organization founded in 2015 with the goal of advancing the development and adoption of cloud-native technologies. The...
Ajeet Raina
3 min read
Join our Discord Server