Running Applications on Kubernetes: Beyond the Basics

Introduction

As the usage of containerized applications continues to grow, so does the interest in deploying these applications on scalable and maintainable platforms like Kubernetes. This article explores the capabilities of Kubernetes, specifically focusing on the deployment of applications using Pod replicas and Deployments. We will cover what Kubernetes is, why you should use it, and dive into the practical aspects of setting up a Deployment to run a simple application, such as hello-app.

Understanding Kubernetes and Containers

What is Kubernetes?

Kubernetes, often referred to as "K8s," is an open-source platform designed for the automation, deployment, scaling, and management of containerized applications across a cluster. It is portable, extensible, and supports a variety of container types including Docker containers. Kubernetes manages the allocation of computing resources to containerized applications and coordinates the scaling and distribution of these applications to ensure high availability and reliability.

Why Use Kubernetes?

Scalability: Kubernetes automatically scales applications based on resource usage and demand. Maintainability: It simplifies the deployment and maintenance of containerized applications. High Availability: Applications can be configured to provide high availability, ensuring that services are always available even if some components fail. Resource Management: It optimizes the use of computing resources within the cluster.

Deploying Applications on Kubernetes

The most common way to deploy a set of Pod replicas is through a Kubernetes Deployment. A Deployment is a replication controller that manages the desired state of your applications by creating and updating Pods and Replicasets. It enables you to scale your applications, set rolling updates, and perform rolling restarts without downtime.

Setting Up a Deployment for hello-app

In this section, we will walk through the steps to deploy a simple web application, hello-app, using a Kubernetes Deployment.

Step 1: Create a Docker Image

Build a Docker image for your application using the Dockerfile provided in the hello-app directory.

Push the image to a Docker registry (e.g., Docker Hub, Google Container Registry).

Step 2: Define the Pod Template

Create a Kubernetes ConfigMap with the application configuration.

Define a Pod template that specifies the container image, environment variables, and any other required configuration.

Step 3: Create the Deployment

Create a Deployment manifest file that specifies the number of replicas, the desired state of the application, and how to scale the deployment.

Apply the Deployment manifest to your Kubernetes cluster using kubectl apply.

To illustrate, here is an example Deployment manifest:

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

Step 4: Verify the Deployment

Check the status of your Deployment using kubectl get deployments.

Verify that the Pods are running using kubectl get pods.

Conclusion

Deploying applications on Kubernetes is a powerful and scalable solution for running containerized workloads. With Deployments, you have the ability to manage, scale, and update your applications with minimal downtime. By leveraging Kubernetes, you can focus on developing and maintaining your applications while letting the platform handle the intricacies of deployment and scaling.