Introduction

Kubernetes has revolutionized the way organizations deploy, manage, and scale containerized applications. Its robust orchestration capabilities provide a powerful framework for ensuring the efficiency, scalability, and reliability of your applications. In this blog post, we'll delve into the intricacies of Kubernetes deployments, exploring how they work and why they are a fundamental component of your containerized ecosystem.

What is this Kubernetes Deployments?

A Kubernetes deployment is a resource object in Kubernetes that manages the deployment of a containerized application. Deployments enable you to declare an application's desired state and automatically handle scaling, rolling updates, and self-healing when issues arise.

!!!Declarative Desired State!!!

Kubernetes deployments operate on a declarative model, where you specify the desired state of your application, and Kubernetes works to maintain that state. This approach simplifies the management of complex applications, reducing manual intervention.

Why is it important for us?

Some of the reasons why Kubernetes deployments are necessary which we care:

• Scaling Applications: Kubernetes deployments make it easy to scale applications by specifying the desired number of replicas. This is crucial for handling varying workloads. You can effortlessly scale your application horizontally to accommodate increased traffic or vertically to allocate more resources to each pod.

• Rolling Updates: Applications evolve and require updates, whether it's for bug fixes, new features, or security patches. Kubernetes deployments facilitate rolling updates, allowing you to change your application's configuration without incurring downtime.

• Declarative Desired State: Kubernetes deployments operate on a declarative model, where you specify the desired state of your application, and Kubernetes ensures it remains in that state.

• Self-Healing: Kubernetes deployments continuously monitor the health of your pods. If a pod becomes unhealthy or crashes, Kubernetes automatically replaces it.

How do we create a new Kubernetes deployment?

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
        - name: example-testing-container
          image: debian:buster-slim
          command: ["bash", "-c", "while true; do echo \"Hello\"; echo \"EXAMPLE_ENV: $EXAMPLE_ENV\"; sleep 5; done"]
        env:
          - name: EXAMPLE_ENV
            value: abc123

Things you should observe here:

• The name of the deployment is the main unique reference to identify any deployment, which in our case is: (example-deployment).

The label attached to the pod (app: example), though we could set more than one.

Also, Run this Command

$ kubectl apply -f example-dep.yaml
deployment.apps/example-deployment created

To View the deployments, run this :

$ kubectl get deployments
NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
example-deployment   1/1                1                      1             15m

To modify any of the values, modify the file and run kubectl apply -f .... :

$ Kubectl apply -f Ankit.yaml
deployment.apps/Ankit created

To edit the Deployment:

$ kubectl edit deployments Ankit-deployment
deployment.extensions/Ankit-deployment edited

How to View the Kubernetes Deployments?

We Can run like this Command and see the Running Deployments.

$ kubectl get deployment example-deployment -o yaml         
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "4"
 kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"apps/v1","kind":"Deployment","metadata":{"annotations":{},"name":"example-deployment","namespace":"default"},"spec":{"replicas":1,"selector":{"matchLabels":{"app":"example"}},"template":{"metadata":{"labels":{"app":"example"}},"spec":{"containers":[{"command":["bash","-c","while true; do echo 'test' \u003e /nfs-mount/$(date +%Y%m%d%H%M%S).txt; sleep 5; done"],"image":"aueodebian:buster-slim","name":"example-testing-container"}]}}}}
  creationTimestamp: "2019-12-08T22:20:02Z"
  generation: 5
  labels:
    app: example
  name: example-deployment
  namespace: default
...

To rollout the deployment:

$ kubectl apply -f example-dep.yaml
deployment.apps/example-deployment created
$ kubectl scale deployment/example-deployment --replicas=5 
deployment.extensions/example-deployment scaled
$ kubectl get pods -l app=example
NAME                                                   READY   STATUS    RESTARTS   AGE
example-deployment-7ffc49755-96d9h   1/1       Running       0                  29s
example-deployment-7ffc49755-xj2d2     1/1      Running       0                  29s
$ kubectl set image deployment/example-deployment example-testing-container=debian:this-image-tag-does-not-exist
deployment.extensions/example-deployment image updated
$ kubectl get pods -l app=example                                                                               
NAME                                                          READY      STATUS         RESTARTS    AGE
example-deployment-7f9959dc57-pq6gp       1/1                 Running       0                        6s
example-deployment-7ffc49755-96d9h        1/1                 Running       0                       100s
example-deployment-7ffc49755-xj2d2        1/1                 Running       0                       100s

To get the status of Rollout :

kubectl get rs

It also Can be failed many times, due to some of the issues :

• Insufficient quota

• Readiness probe failures

• Image pull errors

• Insufficient permissions

• Limit ranges

• Application runtime misconfiguration

Best Practices for K8s Deployments:

1. Versioning and Rollbacks

2. Health Checks

3.Resource limits

4.Configuration Management

Conclusion

The foundation of reliably and efficiently managing containerized apps is Kubernetes deployments. They offer a strong framework for defining the ideal state for your applications and taking care of updates, scalability, and self-healing on their own. You can fully utilize Kubernetes deployments and make sure your containerized apps function properly in today's demanding and dynamic environments by adhering to best practices. Understanding deployments is crucial to grasping container orchestration, regardless of experience level with Kubernetes.

And Don't forget to Follow Ankit for further blogs like this...