Lesson 5: Deploying Your First Application

In this lesson, we will deploy a simple application on Kubernetes and understand the deployment process. By the end of this lesson, you will have a hands-on understanding of how to create a deployment, manage replicas, and expose your application.

What is a Deployment?

A Deployment in Kubernetes is a resource that provides declarative updates to applications. It manages the creation and scaling of a set of Pods, ensuring that the desired state of the application is maintained.

Key Concepts:

• Declarative Updates: You define the desired state of your application, and Kubernetes works to maintain that state.
• Replica Sets: A Deployment manages a ReplicaSet which ensures that a specified number of Pod replicas are running at any given time.
• Rolling Updates: Deployments support rolling updates, allowing you to update your application without downtime.

Creating a Deployment

To create a Deployment, you need to define it in a YAML file. Here’s a simple example of a Deployment that runs an Nginx web server:

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

Breakdown of the YAML:

• apiVersion: Specifies the API version for the Deployment.
• kind: Specifies the type of resource, which is Deployment in this case.
• metadata: Contains information about the Deployment, such as its name.
• spec: Defines the desired state of the Deployment, including the number of replicas and the template for the Pods.

Deploying the Application

To deploy the application, use the kubectl command-line tool:

kubectl apply -f nginx-deployment.yaml

Verifying the Deployment

To check the status of your Deployment, run:

kubectl get deployments

To see the Pods created by the Deployment, use:

kubectl get pods

Exposing the Application

To access your application from outside the cluster, you need to expose it using a Service. Here’s how to create a Service for the Nginx Deployment:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30001

Deploy the Service with:

kubectl apply -f nginx-service.yaml

Accessing the Application

You can access your Nginx application by navigating to http://<Node_IP>:30001 in your web browser. Replace <Node_IP> with the IP address of your Kubernetes node.

Best Practices and Common Mistakes

Best Practice: Always specify resource requests and limits for your containers to ensure they have enough resources to run effectively.

Common Mistake: Forgetting to apply the YAML file after making changes. Always run kubectl apply -f <filename> to apply updates.

Summary

• A Deployment manages the lifecycle of Pods in Kubernetes.
• You can create a Deployment using a YAML configuration file.
• Use kubectl apply to deploy and manage your application.
• Expose your application using a Service to make it accessible from outside the cluster.
• Always follow best practices for resource management and deployment updates.

• Exercise 1: Modify the Nginx Deployment YAML to change the number of replicas to 5 and redeploy it.
• Exercise 2: Create a new Service YAML to expose the Nginx application using a LoadBalancer type instead of NodePort.
• Exercise 3: Scale your Deployment down to 2 replicas and observe the changes using kubectl get pods.

• Deployments manage Pods and ensure the desired state is maintained.
• Use YAML files to define and deploy applications in Kubernetes.
• Expose applications using Services to allow external access.
• Regularly check the status of your Deployments and Pods using kubectl commands.