KB: LoadBalancers vs Ingress

Kubernetes Ingress and Service LoadBalancer both handle external access to applications running in a Kubernetes cluster, but they operate in different ways and are used in different scenarios. Here’s a comparison to understand their differences:

Kubernetes Service LoadBalancer

1. Purpose: Exposes a single Service to external traffic by creating a load balancer.
2. Operation:
   • Directly creates a cloud provider load balancer (e.g., AWS ELB, GCP LB).
   • Maps a single Service to the external load balancer, which routes traffic to the Service's Pods.
   • Provides a single external IP address for the Service.
3. Use Case: Suitable for simple use cases where a single Service needs to be exposed to external traffic.
4. Complexity: Less complex setup, easy to configure, ideal for straightforward scenarios.
5. Example: Exposing a single web application to the internet.

Kubernetes Ingress

1. Purpose: Manages external access to multiple Services, typically HTTP and HTTPS, providing load balancing, SSL termination, and name-based virtual hosting.
2. Operation:
   • Requires an Ingress Controller to be deployed in the cluster (e.g., NGINX, HAProxy, Traefik).
   • Defines routing rules to direct traffic to different Services based on hostnames or paths.
   • Provides more sophisticated traffic management features, such as SSL/TLS termination, URL rewriting, and more.
3. Use Case: Suitable for complex scenarios where multiple Services need to be exposed, or advanced routing and traffic management features are required.
4. Complexity: More complex setup, but offers greater flexibility and functionality.
5. Example: Hosting multiple web applications on a single IP address, with traffic routed based on the URL path or hostname.

Example YAML Definitions

Service LoadBalancer:

-yaml:
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
  type: LoadBalancer

Ingress:

-yaml:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: my-service
                port:
                  number: 80
    - host: anotherapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: another-service
                port:
                  number: 80

Key Differences

1. Scope:

   • LoadBalancer: Focuses on exposing a single Service.
   • Ingress: Can expose multiple Services and manage routing rules.

2. Flexibility:

   • LoadBalancer: Limited to basic load balancing.
   • Ingress: Offers advanced features like SSL termination, path-based routing, and name-based virtual hosting.

3. Resource Usage:

   • LoadBalancer: Each Service requires a separate load balancer, potentially leading to higher costs and resource usage.
   • Ingress: A single Ingress Controller can manage traffic for multiple Services, often reducing costs and resource usage.

4. Configuration:

   • LoadBalancer: Simpler to configure, directly creates a cloud load balancer.
   • Ingress: Requires an Ingress Controller and more detailed configuration but provides more capabilities.

In summary, use a Service LoadBalancer for simple, single-Service exposure and Ingress for more complex, multi-Service routing and advanced traffic management.