Kubernetes Use Case: Deploying and Managing a Scalable Web Application

Introduction to Kubernetes

Kubernetes (often abbreviated as K8s) is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. Developed by Google and now maintained by the Cloud Native Computing Foundation, Kubernetes is widely used for cloud-native application development and is highly effective in managing applications that require high availability, scalability, and fault tolerance.

In this article, we’ll explore a real-world use case for Kubernetes by setting up a scalable web application. We'll go through step-by-step instructions for deploying and managing this application on Kubernetes.

Use Case Scenario: Scalable Web Application

Consider a scenario where we have a web application that experiences high traffic. We need the application to be available at all times, able to handle scaling dynamically based on demand, and have failover capabilities to recover from unexpected failures.

Requirements:

1. Scalability: The application must scale out (add more instances) or scale in (reduce instances) based on demand.
2. Load Balancing: Incoming traffic should be evenly distributed across all instances of the application.
3. Resilience: The application should be able to self-heal, automatically replacing any failed instances.

In this example, we’ll deploy a simple Node.js web application on Kubernetes and use Kubernetes features like Deployments, Services, and Horizontal Pod Autoscalers to fulfill these requirements.

Kubernetes Components Used

1. Pods: The smallest unit in Kubernetes, representing one or more containers.
2. Deployment: Defines the desired state and manages the number of replicas for our application.
3. Service: Exposes our application and balances the load across pods.
4. Horizontal Pod Autoscaler (HPA): Automatically scales the number of pod replicas based on CPU or memory usage.

Example Architecture

• Node.js Web Application: A simple HTTP server that returns a "Hello, World!" message.
• Nginx Ingress: A load balancer to distribute requests.
• Kubernetes Cluster: Running locally (using Minikube) or in the cloud (e.g., Google Kubernetes Engine, AWS EKS).

Step-by-Step Implementation

1. Setting Up Kubernetes Environment

If you don’t have a Kubernetes cluster set up, you can use Minikube for local development or a managed Kubernetes service (like GKE or EKS) for production-grade deployments. Here’s how to set up Minikube:

# Install Minikube
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Start Minikube
minikube start

Verify that the cluster is running:

kubectl get nodes

2. Creating the Node.js Application

For demonstration, we’ll use a simple Node.js application that returns "Hello, World!" when accessed.

// app.js
const http = require('http');
const PORT = process.env.PORT || 3000;

const requestHandler = (req, res) => {
  res.end('Hello, World!');
};

const server = http.createServer(requestHandler);
server.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Create a Dockerfile to containerize the application:

# Dockerfile
FROM node:14-alpine
WORKDIR /app
COPY app.js .
CMD ["node", "app.js"]

Build and push the Docker image:

docker build -t <your_dockerhub_username>/node-app:v1 .
docker push <your_dockerhub_username>/node-app:v1

3. Creating Kubernetes Deployment and Service

Define a Deployment YAML file (deployment.yaml) for the Node.js app:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      containers:
      - name: node-container
        image: <your_dockerhub_username>/node-app:v1
        ports:
        - containerPort: 3000

Create a Service YAML file (service.yaml) to expose the application within the Kubernetes cluster:

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: node-app-service
spec:
  selector:
    app: node-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer

Apply these configurations:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

4. Exposing the Service

To expose the service, you can use minikube service (for Minikube):

minikube service node-app-service

Or, in a managed Kubernetes cluster, you’d configure Ingress or a load balancer to expose the application.

5. Setting Up Auto-Scaling

Define a Horizontal Pod Autoscaler (HPA) that automatically adjusts the number of pods based on CPU usage. Create a file (hpa.yaml):

# hpa.yaml
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: node-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: node-app
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

Apply the HPA configuration:

kubectl apply -f hpa.yaml

The HPA will monitor CPU usage. If usage exceeds 50%, the number of replicas will increase; if usage falls, the replicas will decrease, down to a minimum of two.

6. Testing the Deployment

1. Verify Deployment: Check the status of your pods and services.

   kubectl get pods
   kubectl get services

1. Generate Load for Scaling: Simulate load to trigger the HPA.

   kubectl run -i --tty load-generator --image=busybox /bin/sh
   # Inside the load generator shell, use:
   while true; do wget -q -O- http://<service-ip>; done

The HPA should scale up additional pods if the CPU usage threshold is reached.

1. Monitor Scaling: Observe the scaling activity.

   kubectl get hpa
   kubectl get pods -w

Conclusion

This example illustrates how Kubernetes enables us to deploy a scalable, highly available web application with minimal configuration and management overhead. With just a few resource definitions, we can:

• Automatically scale our application to handle increased load.
• Load balance requests among multiple instances.
• Ensure high availability and fault tolerance through Kubernetes’ self-healing capabilities.

By applying this approach to larger, more complex applications, teams can improve operational efficiency and ensure that applications are resilient and responsive to changing demands.