Lesson 6: Deploying Applications on Kubernetes

In this lesson, we will learn how to deploy applications on Kubernetes using YAML files and the kubectl command-line tool. Understanding how to create and manage deployments is essential for running applications in a Kubernetes cluster.

What is a Deployment?

A Deployment in Kubernetes is a resource object that provides declarative updates to applications. It allows you to describe an application’s desired state, such as which images to use for the app, the number of replicas, and the update strategy.

Key Components of a Deployment

• apiVersion: Defines the version of the Kubernetes API.
• kind: Specifies the type of Kubernetes object (in this case, Deployment).
• metadata: Contains data that helps uniquely identify the object, including name and labels.
• spec: Describes the desired state of the Deployment, including the number of replicas and the template for the Pods.

Creating a Deployment with YAML

To create a Deployment, you need to write a YAML file that defines the Deployment configuration. Below is an example YAML file for a simple web application.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-web-app
  template:
    metadata:
      labels:
        app: my-web-app
    spec:
      containers:
      - name: web
        image: nginx:latest
        ports:
        - containerPort: 80

Explanation of the YAML File

• replicas: 3: This specifies that we want three instances of the application running.
• selector: This is used to identify the Pods that belong to this Deployment.
• template: This defines the Pod template that will be used to create the Pods.

Applying the Deployment

Once you have created the YAML file (let's say you saved it as deployment.yaml), you can apply it using the kubectl command:

kubectl apply -f deployment.yaml

This command tells Kubernetes to create the Deployment as defined in the YAML file.

Checking the Status of the Deployment

You can check the status of your Deployment with the following command:

kubectl get deployments

To see the Pods created by the Deployment, use:

kubectl get pods

Updating a Deployment

Updating a Deployment is as simple as modifying the YAML file and applying it again. For example, if you want to update the image version, change the image line in your YAML file:

image: nginx:1.21

Then apply the changes:

kubectl apply -f deployment.yaml

Rolling Updates

Kubernetes supports rolling updates, which means that updates can be applied without downtime. You can control the update strategy by adding the following to your spec:

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxUnavailable: 1
    maxSurge: 1

Best Practices and Common Mistakes

Best Practice: Always use versioned images (e.g., nginx:1.21 instead of nginx:latest) to avoid unexpected changes. Common Mistake: Forgetting to set the selector correctly can lead to Pods not being managed by the Deployment.

Summary

• A Deployment manages the desired state of an application in Kubernetes.
• Deployments are defined in YAML files and can be applied using kubectl.
• Updating a Deployment is straightforward and supports rolling updates.
• Always use versioned images and set selectors correctly to avoid issues.

• Exercise 1: Create a Deployment YAML file for a simple Node.js application using the image node:14 and set replicas to 2.
• Exercise 2: Apply the Deployment YAML file you created in Exercise 1 using kubectl and check the status of the Pods.
• Exercise 3: Modify your Deployment to update the Node.js image to node:16 and apply the changes. Verify that the update was successful.

• Deployments in Kubernetes manage application state and scaling.
• YAML files define Deployments and can be applied with kubectl.
• Updating Deployments allows for rolling updates without downtime.
• Always use versioned images to ensure consistency.