StatefulSets Explained: Managing Stateful Applications in Kubernetes

By Manish saini

 


StatefulSets Explained: Managing Stateful Applications in Kubernetes

Introduction

Most Kubernetes workloads are stateless, meaning they do not depend on specific identities or persistent storage. Applications such as Nginx, frontend websites, and APIs can run inside Deployments without issues.

However, databases and stateful applications have special requirements:

  • Persistent Storage

  • Stable Network Identity

  • Ordered Deployment

  • Ordered Scaling

  • Ordered Deletion

To manage such applications, Kubernetes provides StatefulSets.

In this guide, we will learn StatefulSets, architecture, components, use cases, examples, and interview questions.

What is a Stateful Application?

A stateful application stores data that must survive restarts.

Examples:

  • MySQL

  • PostgreSQL

  • MongoDB

  • Cassandra

  • Elasticsearch

  • Kafka

  • Redis (Persistent Mode)

These applications require consistent storage and unique identities.

Stateless vs Stateful Applications

FeatureStateless  Stateful
Stores Data    ❌            ✅
Unique Identity    ❌           ✅
Persistent Storage    ❌           ✅
Deployment Resource    Deployment           StatefulSet
Example    Nginx           MySQL

Why Do We Need StatefulSets?

Imagine a MySQL Deployment.

MySQL Pod
     │
     ▼
Database Data

If the Pod is deleted:

Pod Deleted ❌
New Pod Created ❌
New Identity ❌
Data Issues ❌

Databases require:

  • Same hostname

  • Same storage

  • Predictable startup

StatefulSets solve these problems.

What is a StatefulSet?

A StatefulSet is a Kubernetes workload resource designed for stateful applications.

It provides:

  • Stable Pod Names

  • Stable Network Identity

  • Persistent Storage

  • Ordered Deployment

  • Ordered Scaling

  • Ordered Termination

StatefulSet Architecture

StatefulSet
      │
      ▼
 ┌───────────────┐
 │ mysql-0       │
 │ PVC-0         │
 └───────────────┘

 ┌───────────────┐
 │ mysql-1       │
 │ PVC-1         │
 └───────────────┘

 ┌───────────────┐
 │ mysql-2       │
 │ PVC-2         │
 └───────────────┘

Each Pod gets:

  • Unique Name

  • Dedicated Storage

  • Stable Identity

StatefulSet Pod Naming

Deployment Pods:

nginx-54d87c8
nginx-9h2s7x1
nginx-72jd8c3

Names change frequently.

StatefulSet Pods:

mysql-0
mysql-1
mysql-2

Names remain stable.

Stable Network Identity

Each StatefulSet Pod gets a predictable DNS name.

Example:

mysql-0.mysql-service.default.svc.cluster.local

mysql-1.mysql-service.default.svc.cluster.local

Applications can reliably communicate using these names.

Ordered Deployment

StatefulSets create Pods sequentially.

Example:

mysql-0
     ▼
mysql-1
     ▼
mysql-2

Kubernetes waits until:

mysql-0 Ready ✅

before creating:

mysql-1

This behavior is important for clustered databases.

Ordered Scaling

Suppose replicas increase:

replicas: 3

to:

replicas: 5

Creation order:

mysql-3
     ▼
mysql-4

Pods are created one at a time.

Ordered Termination

During scale down:

mysql-4
     ▼
mysql-3
     ▼
mysql-2

Pods are removed in reverse order.

This prevents cluster corruption.

Persistent Storage in StatefulSets

Every Pod receives its own Persistent Volume Claim.

Example:

mysql-0 → PVC-0

mysql-1 → PVC-1

mysql-2 → PVC-2

Even if Pods restart:

Pod Restarted ✅
Data Preserved ✅

Headless Service

StatefulSets require a Headless Service.

Normal Service:

ClusterIP

Headless Service:

clusterIP: None

Purpose:

  • Direct Pod Discovery

  • Stable DNS Records

Headless Service Example

apiVersion: v1
kind: Service

metadata:
  name: mysql-service

spec:
  clusterIP: None

  selector:
    app: mysql

  ports:
  - port: 3306

Apply:

kubectl apply -f service.yaml

StatefulSet Example

apiVersion: apps/v1
kind: StatefulSet

metadata:
  name: mysql

spec:

  serviceName: mysql-service

  replicas: 3

  selector:
    matchLabels:
      app: mysql

  template:

    metadata:
      labels:
        app: mysql

    spec:
      containers:

      - name: mysql

        image: mysql:8

        ports:
        - containerPort: 3306

Apply:

kubectl apply -f statefulset.yaml

Volume Claim Template

StatefulSets automatically create PVCs.

Example:

volumeClaimTemplates:

- metadata:
    name: mysql-storage

  spec:

    accessModes:
    - ReadWriteOnce

    resources:
      requests:
        storage: 10Gi

Result:

mysql-storage-mysql-0

mysql-storage-mysql-1

mysql-storage-mysql-2

Each Pod gets separate storage.

StatefulSet Workflow

StatefulSet
      │
      ▼
Headless Service
      │
      ▼
Pod (mysql-0)
      │
      ▼
PVC
      │
      ▼
Persistent Volume

Real-World Example

Suppose an organization runs MongoDB.

Requirements:

  • Persistent Data

  • Stable Hostnames

  • Cluster Replication

  • Ordered Startup

Architecture:

MongoDB StatefulSet
        │
        ▼
mongodb-0
mongodb-1
mongodb-2
        │
        ▼
Dedicated PVCs
        │
        ▼
Persistent Volumes

This is a common production architecture.

Deployment vs StatefulSet

Feature                 Deployment                  StatefulSet
Pod Identity                   Dynamic                       Stable
Storage              Shared/Optional                      Dedicated
Pod Names                Random                     Predictable
Ordered Scaling               ❌                     ✅
Ordered Updates              ❌                     ✅
Database Support             ❌                     ✅
Stateless Apps             ✅                     ❌

Useful Commands

View StatefulSets

kubectl get statefulsets

View Pods

kubectl get pods

Describe StatefulSet

kubectl describe statefulset mysql

Scale StatefulSet

kubectl scale statefulset mysql --replicas=5

Delete StatefulSet

kubectl delete statefulset mysql

Best Practices

Use PVCs

Always use persistent storage.

Use Headless Services

Required for stable DNS resolution.

Monitor Storage Usage

Prevent storage exhaustion.

Backup Data Regularly

Especially for databases.

Use StatefulSets Only When Needed

Do not use StatefulSets for stateless applications.

Common Mistakes

❌ Using Deployments for databases

❌ Forgetting Headless Services

❌ Not using Persistent Volumes

❌ Sharing storage between database replicas

❌ Ignoring backup strategies

Kubernetes Interview Questions

What is a StatefulSet?

A StatefulSet is a Kubernetes resource used to manage stateful applications that require stable identities and persistent storage.

Why use StatefulSets instead of Deployments?

StatefulSets provide stable pod names, persistent storage, and ordered deployment behavior.

What is a Headless Service?

A Service with:

clusterIP: None

It provides direct DNS access to StatefulSet Pods.

Can StatefulSet Pods have stable hostnames?

Yes. Each Pod receives a predictable hostname.

What happens if a StatefulSet Pod restarts?

It keeps the same identity and reconnects to its existing storage.

Which applications commonly use StatefulSets?

  • MySQL

  • PostgreSQL

  • MongoDB

  • Cassandra

  • Kafka

  • Elasticsearch

Conclusion

StatefulSets are the preferred Kubernetes resource for running databases and stateful workloads. They provide stable identities, persistent storage, predictable networking, and ordered operations that are critical for distributed systems.

  • Deployments are ideal for stateless applications.

  • StatefulSets are designed for databases and stateful services.

  • Persistent Volumes and Headless Services work together with StatefulSets to ensure reliable data management.

Mastering StatefulSets is essential before moving to advanced Kubernetes topics such as Helm, RBAC, Network Policies, Autoscaling, and Production Kubernetes Architectures.

Comments

Post a Comment

Popular posts from this blog

DevOps Roadmap 2026 – Your Complete Beginner-to-Expert Guide

By Manish saini
Image
   Are you confused about where to start your DevOps journey? This post will help you understand the complete DevOps learning path step by step. The roadmap image below shows all the important tools and concepts you should learn to become a successful DevOps Engineer in 2025 and beyond. ✅ What this roadmap covers: The correct learning order – from basics to advanced Most essential tools every DevOps engineer must know Cloud, container, automation, and CI/CD topics Real-world skills needed for job readiness 📌 Key Learning Stages: Linux Fundamentals – The base of every DevOps journey Version Control – Git & GitHub Scripting – Shell scripting and Python basics Containers – Docker and containerization Orchestration – Kubernetes fundamentals Cloud – AWS (or any major cloud provider) Configuration Management – Ansible Infrastructure as Code – Terraform CI/CD – Jenkins, GitHub Actions Monitoring & Logging – Prometheus, Grafana, ELK stack 🎯 How to use this roadmap: Don’t try...
Read more

User Management in Linux – Complete Notes for Beginners

By Manish saini
Image
                                                                            USER MANAGEMENT • Types of USER 1.Root user ( UID = 0) (SHELL= Login shell /bin/bash)  2. Local user ( UID = 1000 TO 6000) (SHELL=Login shell)  3. System user ( UID = 1 TO 999) (SHELL= Nologin shell /sbin/nologin)  • Type of GROUPS  1. Primary group  2. Secondary group  /etc/passwd = A file that contains “user” information  /etc/group = A file that contains “group” information                                                  COMMANDS   1. useradd = crate a new user useradd username                       ...
Read more

Advanced & Scenario-Based CI/CD Interview Questions and Answers

By Manish saini
Image
  Advanced & Scenario-Based CI/CD Interview Questions and Answers 1. A deployment failed in production. What would you do? Answer: Check pipeline logs. Identify the failed stage. Verify application logs. Roll back to the previous stable version. Fix the issue in a lower environment. Re-run the pipeline. 2. Your Jenkins build is failing but developers claim the code is working locally. How would you troubleshoot? Answer: Check Jenkins console output. Verify build tools and versions. Compare local and Jenkins environments. Check credentials and environment variables. Verify dependency downloads. Review recent code changes. 3. How would you implement a zero-downtime deployment? Answer: Using: Blue-Green Deployment Canary Deployment Rolling Updates in Kubernetes These strategies ensure users continue accessing the application during deployment. 4. A pipeline suddenly takes 45 minutes instead of 10 minutes. How would you investigate? Answer: Analyze pipeline stage duration. Check b...
Read more