Creating Scalable Applications with Kubernetes

📙 Chapter 3: Load Balancing, Service Discovery & Traffic Management in Kubernetes

🌐 Introduction

Building a scalable application on Kubernetes requires more than just autoscaling and resource allocation — you also need to intelligently route traffic and make your services discoverable within and outside your cluster.

This chapter explores:

• The different Kubernetes service types for load balancing
• How service discovery works inside a cluster
• Managing external access with Ingress controllers
• Implementing advanced traffic strategies like canary deployments
• Using service meshes for microservice observability and control

Let’s dive into how Kubernetes powers highly available, load-balanced applications across pods and nodes — and how to fine-tune this layer for resilience and performance.

📦 Section 1: Kubernetes Services — The Basics

A Service in Kubernetes is an abstraction that defines a logical set of pods and a policy by which to access them.

🔹 Core Service Types

🛠️ Example: Creating a ClusterIP Service

yaml

apiVersion: v1

kind: Service

metadata:

  name: my-service

spec:

  selector:

    app: my-app

  ports:

    - protocol: TCP

      port: 80

      targetPort: 8080

  type: ClusterIP

bash

kubectl apply -f service.yaml

kubectl get svc

🌍 Section 2: Service Discovery in Kubernetes

Kubernetes has built-in DNS via CoreDNS, which enables automatic service resolution.

🔹 How It Works:

• Services get a DNS name like: my-service.my-namespace.svc.cluster.local
• Pods can connect to services using DNS without needing IPs

bash

curl http://my-service.my-namespace.svc.cluster.local:80

🚪 Section 3: NodePort and LoadBalancer Services

✅ NodePort

• Opens a static port (e.g., 30000–32767) on each node
• Allows external access via <NodeIP>:<NodePort>
• Suitable for dev, testing, or small setups

yaml

type: NodePort

nodePort: 30080

✅ LoadBalancer

• Provisions a cloud provider-specific LB
• Recommended for production use on managed clusters
• Gets an external IP for traffic routing

yaml

type: LoadBalancer

bash

kubectl get svc my-service

📈 Section 4: Ingress Controllers and Routing

Ingress provides fine-grained control over HTTP(S) traffic routing into your cluster.

🔧 Key Concepts

Popular Ingress Controllers:

• NGINX
• Traefik
• HAProxy
• AWS ALB Ingress Controller

🛠️ Ingress Resource Example

yaml

apiVersion: networking.k8s.io/v1

kind: Ingress

metadata:

  name: my-ingress

  annotations:

    nginx.ingress.kubernetes.io/rewrite-target: /

spec:

  rules:

    - host: myapp.example.com

      http:

        paths:

          - path: /

            pathType: Prefix

            backend:

              service:

                name: my-service

                port:

                  number: 80

Deploy and verify with:

bash

kubectl apply -f ingress.yaml

kubectl get ingress

🚦 Section 5: Advanced Traffic Management Strategies

✅ Rolling and Canary Deployments

Kubernetes Deployments support rolling updates out-of-the-box. To implement canary releases:

• Use two deployments: my-app-v1, my-app-v2
• Route 90% of traffic to v1, 10% to v2 using Ingress annotations or a service mesh

Example (NGINX-specific):

yaml

nginx.ingress.kubernetes.io/canary: "true"

nginx.ingress.kubernetes.io/canary-weight: "10"

✅ Blue-Green Deployments

• Deploy v2 in parallel to v1
• Switch routing by changing the backend service selector
• Rollback instantly if needed

🧵 Section 6: Using Service Mesh for Microservices

Service meshes like Istio, Linkerd, or Consul provide:

They work by injecting sidecar proxies (usually Envoy) alongside each pod.

🛠️ Istio VirtualService Example

yaml

apiVersion: networking.istio.io/v1alpha3

kind: VirtualService

metadata:

  name: my-app

spec:

  hosts:

    - myapp.example.com

  http:

    - route:

        - destination:

            host: my-app

            subset: v1

          weight: 80

        - destination:

            host: my-app

            subset: v2

          weight: 20

✅ Best Practices Summary

✅ Summary

Scalable applications must do more than just handle growing load — they must do so intelligently, securely, and efficiently. Kubernetes’ service model and ingress layer give you the flexibility to:

• Expose services internally and externally
• Route traffic dynamically
• Implement advanced rollout strategies
• Control and observe service behavior

Combined with service meshes and observability tools, these capabilities form the traffic management core of modern Kubernetes architectures.