Kubernetes- Advanced Concepts: Day 8 of 50 days DevOps Tools Series
Tags: kubernetes, containers, devops, automation
Published: 2024-07-16 14:38:59

## **Introduction**

Welcome to Day 8 of our 50 Days DevOps Tools series. Yesterday, we covered the fundamentals of Kubernetes, including its architecture and basic commands. Today, we will explore more advanced Kubernetes concepts such as Deployments, StatefulSets, and Persistent Storage. These concepts are crucial for managing complex applications and ensuring data persistence.

**Deployments:**

A Deployment provides declarative updates to applications. It ensures that a specified number of pod replicas are running at any given time. Deployments are used to manage the lifecycle of applications, including scaling, updating, and rolling back to previous versions.

**Key Features of Deployments:**

**Rolling Updates:** Gradually replace old pods with new ones without downtime.
**Rollback:** Revert to a previous version if something goes wrong.
**Scaling:** Increase or decrease the number of pod replicas.
**Self-Healing:** Automatically replace failed pods.

Here’s how to create a Deployment using a YAML configuration file.

```
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
```
**Explanation:**

**apiVersion:** Specifies the API version.
**kind:** Specifies the type of Kubernetes object (Deployment).
**metadata:** Contains metadata about the Deployment, including the name.
**spec:** Defines the desired state of the Deployment.
**replicas:** Specifies the number of pod replicas.
**selector:** Selects pods based on labels.
**template:** Defines the pod template.
**metadata:** Contains labels for the pods.
**spec:** Defines the containers in the pods.

**Commands:**

```
kubectl apply -f deployment.yaml #Create a Deployment
kubectl get deployments #Get info of Deployment
kubectl describe deployment <deployment-name> #Describe a Deployment
kubectl scale deployment nginx-deployment --replicas=5 #Scale a Deployment.
kubectl set image deployment/nginx-deployment nginx=nginx:1.16.0 #update a Deployment, here deployment name is nginx-deployment
kubectl rollout undo deployment/nginx-deployment #Rollback a Deployment
```
**StatefulSets:**
StatefulSets are used to manage stateful applications, where each pod has a unique identity and stable network identity. Unlike Deployments, StatefulSets ensure that pods are created in a specific order and have persistent storage.

**Key Features of StatefulSets**
**Stable Network Identities:** Each pod gets a unique DNS name.
**Persistent Storage:** Volumes are bound to the pod and not the node.
**Ordered Deployment and Scaling:** Pods are created and deleted in a specific order.
**Rolling Updates:** Gradually replace old pods with new ones without downtime.

**Creating a StatefulSet**
Here’s how to create a StatefulSet using a YAML configuration file.

```
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  selector:
    matchLabels:
      app: nginx
  serviceName: "nginx"
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi
```
**Explanation:**

**apiVersion:** Specifies the API version.
**kind:** Specifies the type of Kubernetes object (StatefulSet).
**metadata:** Contains metadata about the StatefulSet, including the name.
**spec:** Defines the desired state of the StatefulSet.
**selector:** Selects pods based on labels.
**serviceName:** Specifies the headless service managing the StatefulSet.
**replicas:** Specifies the number of pod replicas.
**template:** Defines the pod template.
**metadata:** Contains labels for the pods.
**spec:** Defines the containers in the pods.
**volumeMounts:** Mounts the persistent volume to the pod.
**volumeClaimTemplates:** Defines the persistent volume claims for the pods.

**Commands:**

```
kubectl apply -f statefulset.yaml #Create a statefulset
kubectl get statefulsets # Get info of a statefulset
kubectl describe statefulset web #Describe a statefulset
kubectl scale statefulset web --replicas=5 #Scale a statefulset
```
**Persistent Storage:**
Persistent storage in Kubernetes is essential for stateful applications that need to retain data across pod restarts and rescheduling. Kubernetes provides several types of persistent storage options, including PersistentVolumes (PV) and PersistentVolumeClaims (PVC).

**PersistentVolumes (PV)**
A PersistentVolume (PV) is a piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using Storage Classes. It is a resource in the cluster just like a node is a cluster resource.

**PersistentVolumeClaims (PVC)**
A PersistentVolumeClaim (PVC) is a request for storage by a user. It is similar to a pod. Pods consume node resources, and PVCs consume PV resources.

**Creating a PersistentVolume and PersistentVolumeClaim**

PersistentVolume (pv.yaml)

```
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-volume
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
```
PersistentVolumeClaim (pvc.yaml)

```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-claim
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
```
**Explanation:**

**apiVersion:** Specifies the API version.
**kind:** Specifies the type of Kubernetes object (PersistentVolume or PersistentVolumeClaim).
**metadata:** Contains metadata about the object, including the name.
**spec:** Defines the desired state of the object.
**capacity:** Specifies the storage capacity.
**accessModes:** Defines how the volume can be accessed (ReadWriteOnce, ReadOnlyMany, ReadWriteMany).
**hostPath:** Specifies the path on the host node (for PV).

**Commands:**

```
kubectl apply -f pv.yaml #Create a Persistent Volume
kubectl apply -f pvc.yaml #Create a Persistent Volume Claim
kubectl get pv #Get info of a Persistent Volume
kubectl get pvc #Get info of a Persistent Volume Claim
```
**Conclusion:**
Understanding Deployments, StatefulSets, and Persistent Storage in Kubernetes is crucial for managing and scaling complex applications. These concepts ensure that your applications are resilient, scalable, and capable of handling stateful workloads. In the next post, we will continue our deep dive into Kubernetes with more advanced topics and useful tools.

🔄 Subscribe to our blog to get notifications on upcoming posts.

👉 **Be sure to follow me on LinkedIn for the latest updates**: [Shiivam Agnihotri](https://www.linkedin.com/in/shivam-agnihotri/)