Understanding Kubernetes Deployment: A Deep Dive

Ready to launch the application you’ve recently containerized with Docker? This guide covers everything you need to understand about Kubernetes deployments, enabling you to seamlessly deliver your containers into a production environment.

What is a Kubernetes Deployment?

In Kubernetes, a Deployment is an abstraction that allows you to describe, manage, and scale the deployment of containerized applications. It provides a declarative way to define and update the desired state of your application, and it ensures that the specified number of replicas are running and available.

Key features and concepts of Deployments in Kubernetes:

Declarative Configuration: Deployments use a declarative configuration file (typically written in YAML) to specify the desired state of the application, including the container image, number of replicas, and other parameters.
Rolling Updates and Rollbacks: Deployments support rolling updates, allowing you to update the application without downtime by gradually replacing old replicas with new ones. If an issue arises, you can easily roll back to a previous version.
Scalability: You can easily scale your application up or down by adjusting the replica count in the Deployment configuration. Kubernetes will automatically manage the creation or removal of replicas to meet the desired state.
Self-Healing: Deployments monitor the health of application instances, automatically replacing failed replicas and maintaining the desired number of running instances.
Immutable Infrastructure: Deployments promote the use of immutable infrastructure by replacing instances instead of modifying them. Each update creates a new set of pods with the updated configuration.
Monitoring Rollout Status: Leverage the Deployment status as an indicator of the rollout’s progress. This helps identify and address any potential issues that may have caused the rollout to stall.
Cleaning Up Older ReplicaSets: Efficiently manage resources by cleaning up older ReplicaSets that are no longer needed. This ensures a streamlined environment and avoids unnecessary resource utilization.

Create a Kubernetes Deployment

Creating a Kubernetes Deployment can be accomplished through two methods: imperatively, where you use the kubectl create deployment command with specified parameters, or declaratively, by creating a YAML manifest file defining the deployment’s desired state and applying it with kubectl apply -f filename.yaml.

First lets try to create a deployment using the declarative way. Create a file nginx.yaml and add below code to the same:

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-container
        image: nginx:1.24.0

apiVersion: Specifies the API version for the Kubernetes resource being created. In this case, it’s using the apps/v1 API version for Deployments.
kind: Defines the type of resource being created. Here, it’s a Deployment.
metadata: Contains information about the Deployment, including its name.
spec: Describes the desired state of the Deployment.
Under spec you can specify the number of replica you need and the selectors that deployment will use
Under template you can specify the labels for the pod and the image for the container

You can now save the file and execute kubectl create -f nginx.yaml . You should see below output:

root@k8:~# kubectl create -f deploy.yaml 
deployment.apps/nginx-deployment created

2. You can also create the same deployment imperatively using the below command:

kubectl create deploy nginx-deployment --image=nginx:1.24.0 --replicas=3

3. You can run below command to list all deployments:

root@k8:~# kubectl get deploy
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           7s

The output of kubectl get deploy displays information about Kubernetes Deployments. Let’s break down the columns:

NAME: This column shows the names of the Deployments in your Kubernetes cluster. In this case, there is a Deployment named “nginx-deployment.”
READY: Indicates the current status of the Deployment’s replicas. The format is “current/desired,” where “current” is the number of Pods currently running, and “desired” is the desired number of replicas. For “nginx-deployment,” 3 out of 3 replicas are ready.
UP-TO-DATE: Represents the number of replicas that have been updated to match the desired state. In this case, all 3 replicas are up-to-date.
AVAILABLE: Shows the number of replicas that are available for serving requests. In this example, all 3 replicas are available.
AGE: Displays the elapsed time since the Deployment was created. The value “7s” indicates that the “nginx-deployment” has been running for 7 seconds.

In summary, the output indicates that the “nginx-deployment” is currently in a healthy state with 3 replicas, all up-to-date and available, and it has been running for 7 seconds.

4. To see the Deployment rollout status, run kubectl rollout status deployment/nginx-deployment. The output is similar to:

root@k8:~# kubectl rollout status deployment/nginx-deployment
deployment "nginx-deployment" successfully rolled out

5. To see the ReplicaSet (rs) created by the Deployment, run kubectl get rs. The output is similar to this:

root@numaster:~# kubectl get rs
NAME                          DESIRED   CURRENT   READY   AGE
nginx-deployment-6c6776677d   3         3         3       13m

Updating a Deployment in Kubernetes

We’re going to modify the nginx Pods to utilize the nginx:1.16.1 image rather than the nginx:1.24.0 image.

Before making changes to the deployment it always good to add kubernetes.io/change-cause annotation to the deployment and add a comment describing the change. For example

root@k8:~# kubectl annotate deployment/nginx-deployment kubernetes.io/change-cause="Changing image from nginx=nginx:1.24.0 to nginx:1.16.1"
deployment.apps/nginx-deployment annotated

Now we can go ahead and change the image:

root@k8:~# kubectl set image deployment/nginx-deployment nginx-container=nginx:1.16.1
deployment.apps/nginx-deployment image updated

In this context, deployment/nginx-deployment refers to the Deployment, nginx-container represents the Container undergoing the update, and nginx:1.16.1 specifies the new image along with its tag.

Alternatively, you can edit the Deployment and change .spec.template.spec.containers[0].image from nginx:1.24.0 to nginx:1.16.1:

kubectl edit deployment/nginx-deployment
The output is similar to:
deployment.apps/nginx-deployment edited

2. To adjust the number of replicas in a Kubernetes Deployment, you can use the kubectl scale command. Here’s an example:

root@k8:~# kubectl annotate deployment/nginx-deployment kubernetes.io/change-cause="Changing replica to 6"
deployment.apps/nginx-deployment annotated

root@k8:~# kubectl scale deployment/nginx-deployment --replicas=6
deployment.apps/nginx-deployment scaled

This command scales the “nginx-deployment” to have 5 replicas. After running this command, Kubernetes will ensure that there are five instances of the application running, distributing the workload across them.

You can verify the updated replica count using:

root@numaster:~# kubectl get deployment/nginx-deployment
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   6/6     6            6           30m

Rolling Back a Deployment

At times, you might need to undo changes made to a Deployment, especially when the Deployment is facing issues like constant crashes. By default, Kubernetes stores a record of all changes made to a Deployment, allowing you to easily go back to a previous state if needed. If you wish to control how many changes are stored, you can adjust the revision history limit.

1. You can run the below command to see the rollout history of the deployment

root@k8:~# kubectl rollout history deployment/nginx-deployment
deployment.apps/nginx-deployment 
REVISION  CHANGE-CAUSE
1         <none>
2         Changing replica to 6

2. To see the details of each revision, run:

root@k8:~# kubectl rollout history deployment/nginx-deployment --revision=2
deployment.apps/nginx-deployment with revision #2
Pod Template:
  Labels:	app=nginx
	pod-template-hash=58f4dc444
  Annotations:	kubernetes.io/change-cause: Changing replica to 6
  Containers:
   nginx-container:
    Image:	nginx:1.16.1
    Port:	<none>
    Host Port:	<none>
    Environment:	<none>
    Mounts:	<none>
  Volumes:	<none>

3. Now, you’ve chosen to cancel the current updates and go back to the way things were before. You can run the below command to revert the changes:

kubectl rollout undo deployment/nginx-deployment

The output is similar to this:

deployment.apps/nginx-deployment rolled back

4. Instead, you can go back to a particular version by mentioning it using –to-revision:

root@k8:~# kubectl rollout history deployment/nginx-deployment
deployment.apps/nginx-deployment 
REVISION  CHANGE-CAUSE
1         <none>
2         Changing replica to 6

root@k8:~# 
root@k8:~# 
root@k8:~# 
root@k8:~# kubectl rollout undo deployment/nginx-deployment --to-revision=1
deployment.apps/nginx-deployment rolled back

FAQ

1. What is a Kubernetes Deployment, and why do we need it?

A: A Kubernetes Deployment is a way to manage and scale applications in a Kubernetes cluster. It ensures that the desired number of instances (called replicas) of your application are running and helps with updates and rollbacks.

2. How does a Kubernetes Deployment handle application updates without downtime?

A: Kubernetes Deployment uses a rolling update strategy, gradually replacing old instances with new ones. This ensures a smooth transition and reduces the impact on your application’s availability.

3. Can I scale my application easily with Kubernetes Deployment?

A: Yes, Kubernetes Deployment allows you to scale your application effortlessly. You can increase or decrease the number of replicas, and Kubernetes will manage the deployment accordingly.

4. What happens if there is an issue with the new version of my application?

A: Kubernetes Deployment provides an easy rollback mechanism. If any problems arise, you can quickly revert to the previous version, minimizing the impact on your users.

5. How does Kubernetes Deployment help in maintaining a consistent application state?

A: Kubernetes Deployment uses a declarative configuration, allowing you to specify the desired state of your application. It continuously monitors and adjusts the instances to match this desired state, ensuring consistency.