Google Cloud Load Balancing

 

Google Cloud Load Balancing — Easy Notes

1. Why do we need Load Balancing?

Suppose your application starts with 4 VMs, but during high traffic it scales up to 40 VMs.

The question is: How do users know which VM to connect to?

👉 Cloud Load Balancing handles this.

Load Balancer = Traffic Distributor

It distributes incoming user traffic across multiple VMs/backend instances.

             Users
          /    |    \
         ↓     ↓     ↓
       Load Balancer
       /   /   |   \
      ↓   ↓    ↓    ↓
    VM1 VM2  VM3 ... VM40

2. Benefits

  • Distributes traffic across multiple instances.
  • Prevents one VM from becoming overloaded.
  • Improves performance and availability.
  • Automatically responds to:
    • Changes in traffic
    • Number of users
    • Backend health
    • Network conditions
  • Supports cross-region load balancing.
  • Can automatically perform multi-region failover if a backend becomes unhealthy.
  • It's fully managed → you don't need to create or manage load-balancer VMs.
  • No pre-warming required, even when you expect a huge traffic spike.

3. What traffic can it handle?

Google Cloud Load Balancing can handle:

  • HTTP / HTTPS
  • TCP
  • SSL
  • UDP
  • Other IP traffic depending on the load-balancer type.

4. Main Types

A useful way to remember the classification is:

Google Cloud Load Balancing
│
├── Application Load Balancer
│      └── Application Layer (Layer 7)
│
└── Network Load Balancer
       └── Transport/Network traffic
           │
           ├── Proxy Network Load Balancer
           └── Passthrough Network Load Balancer

A. Application Load Balancer

Layer: Application layer / Layer 7

Primarily handles:

👉 HTTP / HTTPS

Best suited for web applications and APIs.

It can make routing decisions based on application information.

For example:

/user/*       → Backend A
/payment/*    → Backend B
/products/*   → Backend C

Important features:

  • Content-based routing
  • SSL/TLS termination
  • Reverse proxy
  • Can be external (internet-facing)
  • Can be internal

Simple example:

A user requests:

https://example.com/payment

The Application Load Balancer can inspect the request and send it to the appropriate payment backend.

B. Network Load Balancer

Designed for lower-level network traffic such as:

👉 TCP, UDP and other IP protocols

There are two important types:

1. Proxy Network Load Balancer

Acts as a reverse proxy.

Client
  ↓
Proxy Load Balancer
  ↓
Backend

The load balancer:

  • Terminates the client connection.
  • Creates a new connection to the backend.
  • Provides advanced traffic-management capabilities.
  • Can work with backends in different cloud environments and on-premises environments.

2. Passthrough Network Load Balancer

This one is different.

It does NOT terminate or modify the connection.

Instead:

Client
  ↓
Passthrough Load Balancer
  ↓
Backend

The traffic is directly forwarded to the backend.

Key advantage

It preserves the original source IP address.

This is useful when applications need:

  • Direct server return
  • Original client IP
  • A wider range of IP protocols

⭐ Quick Comparison

TypeMain LayerTrafficConnection
Application LBLayer 7HTTP/HTTPSReverse proxy
Proxy Network LBLower network/transportTCP, SSL, etc.Terminates & creates new connection
Passthrough Network LBNetwork/transportTCP/UDP/IPDoesn't terminate; forwards directly

🧠 Exam shortcut

Application LB → HTTP/HTTPS + smart/content routing

Proxy Network LB → Proxy + terminates connection

Passthrough Network LB → Direct forwarding + preserves source IP

And remember the overall purpose:

Load Balancer distributes traffic so that no single backend becomes overloaded and the application remains available and performant.



Think of a receptionist 🧑‍💼

Imagine you call a company.

1. Proxy Network Load Balancer = Receptionist talks to you

You
 ↓
Load Balancer (Receptionist)
 ↓
Server

You don't directly talk to the server.

The Load Balancer receives your connection, ends your connection, then creates a new connection to the server.

So there are actually 2 connections:

You ──────→ Load Balancer
              │
              └──────→ Server

That's why it's called Proxy.

Simple example

You send:

"Give me my account details."

The Load Balancer receives your request and then asks the backend server:

"Hey Server, give me this customer's account details."

So:

Client → Load Balancer → Server

The Load Balancer is acting as a middleman.

2. Passthrough Network Load Balancer = Receptionist just directs you

Here, the Load Balancer doesn't terminate your connection.

It basically says:

"Go to Server 2."

You
 ↓
Load Balancer
 ↓
Server 2

The important part is that your connection continues to the backend.

So there is essentially one end-to-end client connection:

You ─────────────────→ Server
          ↑
    Load Balancer
    only directs traffic

The Load Balancer passes the traffic through.

🔥 Biggest difference

ProxyPassthrough
LB terminates connection?✅ Yes❌ No
Creates new backend connection?✅ Yes❌ No
Acts as middleman?✅ Yes❌ Mostly just forwards
Original source IP preserved?Generally not end-to-end✅ Yes
Easy exampleReceptionist talks to server for youReceptionist points you to the right room

🧠 Remember this one line:

Proxy = "I receive your connection and make another connection."

Passthrough = "I just pass your connection/traffic through to the backend."

That's the main concept. 

Comments

Post a Comment

Popular posts from this blog

Async/await

  Async/await An async function is a function declared with the async keyword, and the await keyword is permitted within them. The async and await keywords enable asynchronous, promise-based behavior to be written in a cleaner style, avoiding the need to explicitly configure promise chains. "async and await make promises easier to write" async  makes a function return a Promise await  makes a function wait for a Promise  Async functions Let’s start with the async keyword. It can be placed before a function, like this: async function f() {   return 1; } The word “async” before a function means one simple thing: a function always returns a promise. Other values are wrapped in a resolved promise automatically. For instance, this function returns a resolved promise with the result of 1; let’s test it: async function f() {   return 1; } f().then(alert); // 1 …We could explicitly return a promise, which would be the same: async function f() {   return Promis...
Read more

First negative in every window of size k

 Given an array arr[]  and a positive integer k, find the first negative integer for each and every window(contiguous subarray) of size k. Note: If a window does not contain a negative integer, then return 0 for that window. Examples: Input: arr[] = [-8, 2, 3, -6, 10] , k = 2 Output: [-8, 0, -6, -6] Explanation: Window [-8, 2] First negative integer is -8. Window [2, 3] No negative integers, output is 0. Window [3, -6] First negative integer is -6. Window [-6, 10] First negative integer is -6. Input: arr[] = [12, -1, -7, 8, -15, 30, 16, 28] , k = 3 Output: [-1, -1, -7, -15, -15, 0]  Explanation: Window [12, -1, -7] First negative integer is -1. Window [-1, -7, 8] First negative integer is -1. Window [-7, 8, -15] First negative integer is -7. Window [8, -15, 30] First negative integer is -15. Window [-15, 30, 16] First negative integer is -15. Window [30, 16, 28] No negative integers, output is 0. Input: arr[] = [12, 1, 3, 5] , k = 3 Output: [0, 0]  Explanation: Windo...
Read more

Next Smaller Element

 ven an array, print the Next Smaller Element (NSE) for every element. The NSE for an element x is the first smaller element on the right side of x in the array. For elements for which no smaller element exists (on the right side), then consider NSE as -1.  Examples: Input: [4, 8, 5, 2, 25] Output: [2, 5, 2, -1, -1] Explanation:  The first element smaller than 4 having index > 0 is 2. The first element smaller than 8 having index > 1 is 5. The first element smaller than 5 having index > 2 is 2. There are no elements smaller than 4 having index > 3. There are no elements smaller than 4 having index > 4. Input: [13, 7, 6, 12] Output: [7, 6, -1, -1] Explanation:  The first element smaller than 13 having index > 0 is 7. The first element smaller than 7 having index > 1 is 6. There are no elements smaller than 6 having index > 2. There are no elements smaller than 12 having index > 3.  [Expected Approach] using Stack - O(n) Time O(n) Space ...
Read more