Abhiraj Kharbade's Blog
Kubernetes Workloads: A Comprehensive Guide to Deployments, StatefulSets, DaemonSets, Jobs, and CronJobs

Kubernetes Workloads: A Comprehensive Guide to Deployments, StatefulSets, DaemonSets, Jobs, and CronJobs

Abhiraj Kharbade's photo
Abhiraj Kharbade
·

9 min read

Table of contents

Kubernetes is an open-source container orchestration platform that automates container deployment, scaling, and management. It provides a wide range of features to deploy and manage workloads in a containerized environment. In this blog, we will discuss Kubernetes workloads, such as Deployments, StatefulSets, DaemonSets, Jobs, and CronJobs, and the steps to deploy each of them in a Kubernetes cluster.

Deployments:

Deployments in Kubernetes provide a declarative way to manage the desired state of Pods and ReplicaSets. A Deployment creates a ReplicaSet to manage the lifecycle of multiple Pods. The Deployment ensures that the ReplicaSet is updated to match the desired state specified in the Deployment YAML file.

Deployments also provide rolling updates for Pods, which means that you can update the Pods in a controlled manner without affecting the availability of the application. The rolling updates are performed by gradually scaling down the old ReplicaSet and scaling up the new ReplicaSet.

Here are some of the key features of Deployments:

  • Declarative updates: You can define the desired state of your application in the Deployment YAML file. The Deployment controller will ensure that the current state of the application matches the desired state.

  • Rolling updates: You can update the Pods in a controlled manner without affecting the availability of the application. The rolling updates are performed by gradually scaling down the old ReplicaSet and scaling up the new ReplicaSet.

  • Rollback: If a new version of the application causes issues, you can easily rollback to the previous version using the kubectl rollout undo command.

  • Scaling: You can scale the number of Pods up or down by updating the replicas field in the Deployment YAML file.

  • Self-healing: If a Pod in the Deployment fails, the Deployment controller will automatically create a new Pod to replace it.

  • History: The Deployment controller maintains a history of all updates to the Deployment, which allows you to view and rollback to any previous version of the application.

Overall, Deployments are a powerful tool for managing and scaling containerized applications in Kubernetes. They provide a declarative way to define the desired state of your application, and they allow you to perform rolling updates, rollback to previous versions, and scale the application up or down as needed.

Here are the steps to deploy a Deployment in a Kubernetes cluster:

Step 1: Create a deployment.yaml file with the desired specifications for your application.

Example:

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:latest
        ports:
        - containerPort: 80

Step 2: Apply the Deployment YAML file using the kubectl apply -f deploment.yaml command.

Step 3: Check the status of the Deployment using the kubectl get deployments command.

Step 4: Verify that the Pods are running using the kubectl get pods command.

StatefulSets:

StatefulSets in Kubernetes provide a way to manage stateful applications that require stable and unique network identities, persistent storage, and ordered deployment and scaling.

A StatefulSet manages the deployment and scaling of a set of Pods and provides guarantees about the ordering and uniqueness of those Pods. Each Pod in a StatefulSet is assigned a unique, stable hostname that is based on the name of the StatefulSet and a unique ordinal index.

Here are some key features of StatefulSets:

  • Stable network identities: Each Pod in a StatefulSet is assigned a unique and stable hostname, which can be used to access the Pod directly without the need for a Service.

  • Persistent storage: StatefulSets support the use of Persistent Volumes, which allows the Pods to store data that persists across Pod restarts.

  • Ordered deployment and scaling: StatefulSets provide guarantees about the order in which Pods are deployed and scaled. This is important for stateful applications that require a specific order of startup or shutdown.

  • Rolling updates: Like Deployments, StatefulSets support rolling updates to update the Pods in a controlled manner without affecting the availability of the application.

  • Headless Services: StatefulSets can be paired with a Headless Service, which allows the Pods to be directly addressable using their stable hostnames.

Overall, StatefulSets are a powerful tool for managing stateful applications in Kubernetes. They provide guarantees about the ordering and uniqueness of Pods and support the use of persistent storage and stable network identities.

Here are the steps to deploy a StatefulSet in a Kubernetes cluster:

Step 1: Create a StatefulSet.yaml file with the desired specifications for your application.

Example:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  serviceName: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        ports:
        - containerPort: 3306
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "password"
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Step 2: Apply the StatefulSet YAML file using the kubectl apply -f StatefulSet.yaml command.

Step 3: Check the status of the StatefulSet using the kubectl get statefulsets command.

Step 4: Verify that the Pods are running using the kubectl get pods command.

DaemonSets:

DaemonSets in Kubernetes provide a way to ensure that a specific Pod runs on all or some of the nodes in a Kubernetes cluster. A DaemonSet creates a Pod on each node in the cluster that meets certain criteria, such as having a specific label or running a specific operating system.

DaemonSets are often used for tasks that need to be performed on every node in the cluster, such as collecting logs or metrics. They can also be used to ensure that specific network or security configurations are applied consistently across all nodes in the cluster.

Here are some key features of DaemonSets:

  • Automatic placement: A DaemonSet ensures that a Pod is created on each node that meets the criteria specified in the DaemonSet YAML file.

  • Automatic updates: If a new node is added to the cluster that meets the criteria specified in the DaemonSet YAML file, a new Pod will automatically be created on that node.

  • Automatic removal: If a node is removed from the cluster, the corresponding Pod will automatically be deleted.

  • Label-based selection: DaemonSets use label selectors to determine which nodes to place Pods on.

  • Pod affinity/anti-affinity: DaemonSets can be configured to use Pod affinity or anti-affinity rules to control which nodes Pods are placed on.

Overall, DaemonSets are a useful tool for ensuring that a specific Pod runs on all or some of the nodes in a Kubernetes cluster. They can be used for tasks that need to be performed on every node in the cluster, or to ensure that specific network or security configurations are applied consistently across all nodes in the cluster.

Here are the steps to deploy a DaemonSet in a Kubernetes cluster:

Step 1: Create a DaemonSet.yaml file with the desired specifications for your application.

Example:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logstash
spec:
  selector:
    matchLabels:
      app: logstash
  template:
    metadata:
      labels:
        app: logstash
    spec:
      containers:
      - name: logstash
        image: docker.elastic.co/logstash/logstash-oss:7.15.1
        ports:
        - containerPort: 5000

Step 2: Apply the DaemonSet YAML file using the kubectl apply DaemonSet.yaml command.

Step 3: Check the status of the DaemonSet using the kubectl get daemonsets command.

Step 4: Verify that the Pods are running on each node using the kubectl get pods command.

Jobs:

Jobs in Kubernetes provide a way to run a batch process to completion, such as running a one-time task or a periodic backup. A Job creates one or more Pods to run the task and ensures that the task completes successfully before terminating the Pods.

Jobs can be used for tasks that need to be performed periodically or for tasks that need to be performed once and then terminated. For example, a Job can be used to run a script that generates a report every hour or to run a backup of a database once a day.

Here are some key features of Jobs:

  • One-time or periodic tasks: Jobs can be used to run tasks that need to be performed once or periodically.

  • Completion guarantees: Jobs ensure that the task completes successfully before terminating the Pods.

  • Parallelism: Jobs can be configured to run multiple Pods in parallel to speed up the task.

  • Restart policy: Jobs can be configured to either never restart the Pods or to restart the Pods if they fail.

  • TTL controller: Jobs can be configured with a time-to-live (TTL) controller, which ensures that the Job is terminated after a certain amount of time, even if it has not been completed.

Overall, Jobs is a useful tool for running batch processes in Kubernetes. They ensure that the task completes successfully before terminating the Pods, and can be used for one-time or periodic tasks.

Here are the steps to deploy a Job in a Kubernetes cluster:

Step 1: Create a Job.yaml file with the desired specifications for your task.

Example:

apiVersion: batch/v1
kind: Job
metadata:
  name: backup-job
spec:
  template:
    spec:
      containers:
      - name: backup
        image: backup-script:latest
        volumeMounts:
        - name: data
          mountPath: /data
      restartPolicy: Never
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: data-claim

Step 2: Apply the Job YAML file using the kubectl apply -f Job.yaml command.

Step 3: Check the status of the Job using the kubectl get jobs command.

Step 4: View the logs of the Pods using the kubectl logs command.

CronJobs:

CronJobs in Kubernetes provide a way to run jobs on a schedule, similar to the UNIX cron utility. A CronJob creates one or more Jobs to run a task on a specified schedule, such as once per minute, once per hour, or once per day.

CronJobs can be used for tasks that need to be performed periodically, such as creating backups or generating reports. They are a useful tool for automating repetitive tasks in Kubernetes.

Here are some key features of CronJobs:

  • Scheduling: CronJobs can be scheduled to run a task on a specified schedule, using a format similar to the UNIX cron utility.

  • Parallelism: CronJobs can be configured to run multiple Jobs in parallel to speed up the task.

  • Completion guarantees: CronJobs ensure that the task completes successfully before terminating the Jobs.

  • Restart policy: CronJobs can be configured to either never restart the Jobs or to restart the Jobs if they fail.

  • Job history: CronJobs maintain a history of the Jobs that have been run, which can be useful for debugging or auditing purposes.

Overall, CronJobs are a useful tool for running periodic tasks in Kubernetes. They can be used to automate repetitive tasks, and provide scheduling, parallelism, and completion guarantees.

Here are the steps to deploy a CronJob in a Kubernetes cluster:

Step 1: Create a CronJob.yaml file with the desired specifications for your scheduled task.

Example:

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: backup-cronjob
spec:
  schedule: "0 0 * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup
            image: backup-script:latest
            volumeMounts:
            - name: data
              mountPath: /

Step 2: Apply the CronJob YAML file using the kubectl apply -f CronJob.yaml command.

Step 3: Check the status of the CronJob using the kubectl get cronjobs command.

Step 4: View the logs of the Jobs using the kubectl logs command.

Conclusion:

In this blog, we discussed the different types of Kubernetes workloads, such as Deployments, StatefulSets, DaemonSets, Jobs, and CronJobs, and the steps to deploy each of them in a Kubernetes cluster. By using these Kubernetes workloads, you can easily manage and scale your containerized applications in a highly available and resilient manner.

The above information is up to my understanding. Suggestions are always welcome.

~Abhiraj kharbade

#Kubernetes #Devops #Trainwithshubham #Kubeweek #kubeweekchallenge

Shubham Londhe

KubernetesDevopsTrainWithShubham#KubeWeekChallenge #kubeweek