Deploy a Scalable Web App Using Kubernetes (Step-by-Step Guide)

Modern applications aren’t just built they’re designed to scale. If your app can’t handle traffic spikes or fails under load, users won’t stick around.

That’s where Kubernetes comes in. It’s the industry standard for deploying, managing, and scaling containerized applications.

In this guide, you’ll learn how to deploy a scalable web application step-by-step using Kubernetes, even if you’re starting from scratch.

Why Kubernetes?

Before jumping in, let’s understand why Kubernetes is widely adopted.

Without Kubernetes:

• Manual scaling is painful
• Downtime during deployments
• Hard to manage distributed systems

With Kubernetes:

• Automatic scaling
• Self-healing infrastructure
• Rolling updates with zero downtime
• Efficient resource utilization

Companies like Google, Netflix, and Spotify rely heavily on Kubernetes for production workloads.

What We’ll Build

We’ll deploy:

• A containerized web app
• A scalable backend using replicas
• A load-balanced service
• Auto-scaling based on traffic

Prerequisites

You’ll need:

• Basic knowledge of Docker
• kubectl installed
• A Kubernetes cluster (local or cloud)

Cluster Options:

• Minikube (local testing)
• Amazon EKS
• Google Kubernetes Engine

Step 1: Containerize Your Application

First, package your app using Docker.

Example Dockerfile:

FROM node:18 WORKDIR /app COPY package.json . RUN npm install COPY . . EXPOSE 3000 CMD [“node”, “app.js”]

Build and push your image:

docker build -t your-dockerhub-username/web-app . docker push your-dockerhub-username/web-app

Step 2: Create a Deployment

A Deployment manages your app instances (pods).

deployment.yaml

apiVersion: apps/v1 kind: Deployment metadata: name: web-app spec: replicas: 3 selector: matchLabels: app: web-app template: metadata: labels: app: web-app spec: containers: – name: web-app image: your-dockerhub-username/web-app ports: – containerPort: 3000

Apply it:

kubectl apply -f deployment.yaml

Check pods:

kubectl get pods

Step 3: Expose the Application

Pods are internal by default. You need a Service.

service.yaml

apiVersion: v1 kind: Service metadata: name: web-app-service spec: type: LoadBalancer selector: app: web-app ports: – protocol: TCP port: 80 targetPort: 3000

Apply it:

kubectl apply -f service.yaml

Now your app is accessible via an external IP

Step 4: Enable Auto-Scaling

This is where Kubernetes shines.

Use Horizontal Pod Autoscaler (HPA):

kubectl autoscale deployment web-app –cpu-percent=50 –min=3 –max=10

This means:

• Minimum: 3 pods
• Maximum: 10 pods
• Scale when CPU > 50%

Step 5: Monitor Your Application

Kubernetes integrates well with monitoring tools.

Popular choices:

• Prometheus
• Grafana

Track:

• CPU usage
• Memory usage
• Request rates

Step 6: Rolling Updates

Update your app without downtime:

kubectl set image deployment/web-app web-app=your-dockerhub-username/web-app:v2

Kubernetes will:

• Gradually replace old pods
• Keep the app running during updates

Rollback if needed:

kubectl rollout undo deployment/web-app

Step 7: Test Scalability

Simulate traffic using tools like:

• Apache Bench
• k6

Watch scaling:

kubectl get hpa

You’ll see pods increase automatically under load.

Step 8: Secure Your Application

Security is critical in production.

Best practices:

• Use HTTPS with Ingress
• Enable RBAC
• Scan container images
• Store secrets securely

You can manage traffic routing using an Ingress controller like:

• NGINX

Step 9: Use ConfigMaps and Secrets

Avoid hardcoding configuration.

Example ConfigMap:

apiVersion: v1 kind: ConfigMap metadata: name: app-config data: ENV: production

Secrets example:

apiVersion: v1 kind: Secret metadata: name: app-secret type: Opaque data: DB_PASSWORD: cGFzc3dvcmQ=

Step 10: Optimize for Production

To make your app production-ready:

• Set resource limits
• Use readiness and liveness probes
• Enable logging
• Use multiple availability zones

Example:

resources: limits: cpu: “500m” memory: “512Mi”

Common Mistakes to Avoid

• Running everything in one pod
• Ignoring resource limits
• Not using health checks
• Skipping monitoring
• Hardcoding configs

Real-World Use Cases

Kubernetes is used for:

• E-commerce platforms
• Streaming services
• SaaS products
• AI/ML workloads

Alternatives to Kubernetes

Kubernetes is powerful but not always necessary.

Consider:

• AWS Elastic Beanstalk (simpler deployment)
• Heroku (beginner-friendly)
• Docker Swarm

Final Thoughts

Kubernetes has become the backbone of modern cloud-native applications. It abstracts infrastructure complexity and lets you focus on building scalable systems.

By following this guide, you’ve learned how to:

• Containerize an app
• Deploy it to Kubernetes
• Scale it automatically
• Manage updates and monitoring

• If you’re looking to build these features into your product, feel free to contact us.