How does load balancing work in AWS?

Question

Accepted Answer

**Elastic Load Balancing (ELB)** distributes incoming traffic across multiple targets (EC2 instances, containers, etc.) — improving **availability** (no single point of failure) and **scalability** (spread load). It's a key component for reliable, scalable applications.

## What a load balancer does

```text
A LOAD BALANCER sits in front of multiple backend targets and distributes requests:
  Client → LOAD BALANCER → ┬→ Instance 1
                           ├→ Instance 2
                           └→ Instance 3
  → spreads traffic across targets (scalability + no single instance overloaded)
  → HEALTH CHECKS: routes only to HEALTHY targets (an unhealthy one is bypassed)
  → if a target fails, traffic goes to the others → HIGH AVAILABILITY
  → single entry point (clients hit the LB, not individual instances)
```

## Types of AWS load balancers

```text
APPLICATION LB (ALB) → Layer 7 (HTTP/HTTPS): content/path/host-based routing,
  great for web apps, microservices, containers (route /api → one group, /app → another)
NETWORK LB (NLB) → Layer 4 (TCP/UDP): ultra-high performance, low latency, static IPs
GATEWAY LB → for deploying virtual network appliances
(Classic LB → legacy)
→ ALB is the common choice for HTTP applications.
```

## Key features

```text
✓ HEALTH CHECKS — detect unhealthy targets and stop routing to them (reliability)
✓ Spread across MULTIPLE AZs — survive an AZ failure
✓ Works with AUTO SCALING — automatically includes new instances as they scale
✓ SSL/TLS termination (handle HTTPS at the LB)
✓ Sticky sessions, path/host routing (ALB), WebSocket support
```

## Why it matters

Understanding load balancing is valuable because it's a key component for building **reliable and scalable** applications on AWS, so it's important practical knowledge.

A load balancer addresses two fundamental needs: **availability** (by distributing traffic across multiple backend targets with **health checks** that route only to healthy targets, so if one instance fails, traffic continues to the others — eliminating single points of failure) and **scalability** (spreading load across multiple instances so no single one is overloaded, and providing a single entry point).

This makes load balancing essential for any application that needs to handle significant traffic reliably.

Understanding the **types** — **Application Load Balancer (ALB)** for Layer 7 HTTP/HTTPS with content/path/host-based routing (the common choice for web applications and microservices), **Network Load Balancer (NLB)** for Layer 4 ultra-high-performance TCP/UDP — helps choose the right one.

Understanding the **key features** is important: health checks (for reliability), spreading across **multiple AZs** (surviving AZ failures, combining with the high-availability pattern), integration with **auto scaling** (automatically including new instances as they scale — so load balancing and auto scaling work together for elastic, resilient applications), and SSL/TLS termination.

The combination of load balancing + auto scaling + multi-AZ deployment is the foundational pattern for scalable, highly-available AWS applications.

Since reliable, scalable applications require distributing traffic across multiple instances (for availability and scale), and since ELB (with its types, health checks, multi-AZ spread, and auto-scaling integration) is the mechanism for this, understanding load balancing is valuable, practically-important AWS knowledge — a core component of resilient cloud architecture that works hand-in-hand with auto scaling and multi-AZ deployment to build applications that handle real-world traffic reliably and at scale.