Running Microservices with Docker and Kubernetes

Microservices architecture allows applications to be built as a collection of loosely coupled services, each running independently. Docker and Kubernetes are the two key technologies that enable seamless microservices deployment, scalability, and management.

In this article, we’ll walk through:

• How to containerize microservices with Docker
• Deploying microservices using Kubernetes
• Managing inter-service communication
• Scaling microservices dynamically

1. Why Use Docker and Kubernetes for Microservices?

Docker Advantages

• Lightweight, isolated containers for each service
• Works consistently across different environments
• Simplifies dependency management

Kubernetes Advantages

• Automates deployment, scaling, and load balancing
• Self-healing (restarts failed containers)
• Service discovery and networking

Example Use Case: Imagine an e-commerce application with microservices for user authentication, product catalog, orders, and payments. Each service runs in a Docker container and is managed by Kubernetes for scalability.

2. Containerizing Microservices with Docker

Let’s say we have a Product Service written in Node.js.

# Use official Node.js image
FROM node:18-alpine

# Set working directory
WORKDIR /app

# Copy package.json and install dependencies
COPY package.json .
RUN npm install

# Copy source code
COPY . .

# Expose application port
EXPOSE 3000

# Start the microservice
CMD ["node", "server.js"]

Explanation:

• Uses a lightweight node:18-alpine base image
• Copies dependencies and installs them
• Exposes port 3000 for communication
• Runs server.js as the service entry point

Building and Running the Docker Container

# Build the Docker image
docker build -t product-service .

# Run the container
docker run -d -p 3000:3000 --name product-container product-service

3. Deploying Microservices with Kubernetes

Kubernetes Deployment for Product Service

Create a Kubernetes deployment YAML file (product-service.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 3  # Number of instances for scaling
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: product-service:latest  # Use the Docker image
        ports:
        - containerPort: 3000

Key Points:

• Runs 3 replicas for better availability
• Uses product-service:latest Docker image
• Exposes port 3000

Kubernetes Service for Load Balancing

To expose the service within Kubernetes:

apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  selector:
    app: product-service
  ports:
    - protocol: TCP
      port: 80  # External access port
      targetPort: 3000  # Internal container port
  type: LoadBalancer

Load Balancer: Distributes traffic across the service replicas.
Port Mapping: Maps external 80 to internal 3000.

Applying Kubernetes Configurations

# Deploy the microservice
kubectl apply -f product-service.yaml

# Expose the service
kubectl apply -f product-service-service.yaml

# Check running pods
kubectl get pods

# Get service details
kubectl get services

1. Inter-Service Communication in Kubernetes

In a microservices system, services need to communicate. Kubernetes provides service discovery via internal DNS.

For example, if a Cart Service needs to call the Product Service, it can use:

const productServiceURL = "http://product-service:80/api/products";

This resolves automatically inside Kubernetes.

Architecture Overview

    ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
    │ User Service │──►  │ Product Svc  │──►  │ Database     │
    └──────────────┘     └──────────────┘     └──────────────┘
          │                    │
          ▼                    ▼
    ┌──────────────┐     ┌──────────────┐
    │ Order Svc    │     │ Payment Svc  │
    └──────────────┘     └──────────────┘

5. Scaling Microservices with Kubernetes

Kubernetes allows dynamic scaling of services based on CPU load.

Autoscaling Example

kubectl autoscale deployment product-service --cpu-percent=50 --min=3 --max=10

Explanation:

• Automatically scales between 3 and 10 instances
• If CPU usage goes above 50%, Kubernetes adds more pods

6. Monitoring Microservices with Kubernetes

To monitor service health, use Kubernetes probes:

Liveness and Readiness Probes

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 3
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 3
  periodSeconds: 10

• Liveness Probe: Restarts the container if it’s unresponsive
• Readiness Probe: Ensures service is ready before accepting traffic

Conclusion

By combining Docker and Kubernetes, we can efficiently deploy, scale, and manage microservices. This architecture ensures high availability, flexibility, and resilience.

Key Takeaways

✅ Use Docker to containerize each microservice
✅ Deploy microservices as Kubernetes Deployments
✅ Use Kubernetes Services for inter-service communication
✅ Scale automatically with Horizontal Pod Autoscaler
✅ Monitor health with Liveness and Readiness Probes