WebSockets & Realtime Systems Programming · บทเรียน

กลยุทธ์การปรับขนาดแนวนอน

ทำความเข้าใจวิธีกระจายการเชื่อมต่อ WebSocket ไปยังอินสแตนซ์เซิร์ฟเวอร์หลายตัวเพื่อเพิ่มประสิทธิภาพ

กลยุทธ์การปรับขนาดแนวนอน เป็นบทเรียน WebSockets & Realtime Systems Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน WebSockets & Realtime Systems Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส WebSockets & Realtime Systems Programming มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Why Scale WebSockets?

Imagine your awesome app suddenly gets super popular! Thousands, even millions, of users want to connect simultaneously.

A single server can only handle so many active WebSocket connections before it gets overwhelmed. It's like a single lane highway trying to handle rush hour traffic!

To keep your app fast and reliable, we need strategies to handle this high traffic.

Grow Up or Grow Out?

When a single server isn't enough, you have two main options to scale:

Vertical Scaling: Upgrade your existing server with more CPU, RAM, or faster storage. Think of it as making your single highway lane wider.
Horizontal Scaling: Add more servers to share the load. This is like adding more lanes to your highway, or even building parallel highways!

For WebSockets, horizontal scaling is often preferred. It offers better resilience and flexibility.

The Stateful Challenge

WebSockets are different from traditional HTTP requests. While HTTP is often stateless (each request is independent), WebSockets create a stateful, persistent connection.

This means a client and server maintain an open line of communication. If you just randomly send a client to a different server mid-conversation, it won't know what's going on!

This 'state' makes horizontal scaling a bit trickier than with stateless APIs.

Meet the Load Balancer

To distribute traffic across multiple servers, we use a load balancer. Think of it as a smart traffic cop standing at the entrance of your server farm.

Its job is to efficiently direct incoming client connections to one of your available backend WebSocket servers. This prevents any single server from becoming a bottleneck.

WebSocket Handshake & LB

Remember, a WebSocket connection starts as an HTTP request and then 'upgrades' to a WebSocket. Your load balancer needs to understand this process.

It must be configured to correctly handle the Upgrade header in the HTTP request and then maintain the TCP connection for the WebSocket traffic. Without this, the connection won't establish!

Keeping It 'Sticky': Sticky Sessions

Because WebSockets are stateful, it's often important that a client continues talking to the same backend server it initially connected to.

This is achieved using a technique called sticky sessions (or session affinity). The load balancer remembers which server a client used and directs all subsequent requests from that client to the same server.

Common methods include using the client's IP address or a special cookie.

Sticky Session Example

Let's see a simple Node.js WebSocket server. Imagine you have multiple instances of this server running. With sticky sessions, your client would consistently connect to the same server, getting the same 'Server ID'.

To run this: npm install ws then node server.js

const WebSocket = require('ws');
const http = require('http');

const serverId = `Server-${Math.floor(Math.random() * 100) + 1}`; 

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end(`Hello from HTTP on ${serverId}\n`);
});

const wss = new WebSocket.Server({ server });

wss.on('connection', ws => {
  console.log(`Client connected to ${serverId}`);
  ws.send(`Welcome from ${serverId}!`);

  ws.on('message', message => {
    console.log(`Received on ${serverId}: ${message}`);
    ws.send(`Echo from ${serverId}: ${message}`);
  });

  ws.on('close', () => {
    console.log(`Client disconnected from ${serverId}`);
  });
});

server.listen(8080, () => {
  console.log(`${serverId} listening on port 8080`);
});

Sticky Sessions' Limits

While sticky sessions are great for maintaining a client's connection to a single server, they have drawbacks:

Server Failure: If the sticky server crashes, the client loses its connection and might need to re-establish state on a new server.
Cross-Server Communication: If a client on Server A needs to send a message to a client on Server B, sticky sessions alone won't solve this.

For more complex scenarios, you'll need more advanced strategies, which we'll cover later!

Load Balancer Methods

Load balancers use different algorithms to decide where to send new connections:

Round Robin: Sends connections to servers in a rotating order (Server A, then B, then C, then A...).
Least Connections: Sends connections to the server with the fewest active connections.
IP Hash: Uses the client's IP address to consistently direct it to the same server (ideal for sticky sessions).

The choice depends on your application's needs.

Quick Check: Scaling WebSockets

You've learned about horizontal scaling and the role of load balancers and sticky sessions. Let's test your understanding!

Recap: Scaling Up!

Great job! In this lesson, you learned why horizontal scaling is vital for high-traffic WebSocket applications.

Horizontal scaling adds more servers to handle increased load.
Load balancers distribute incoming connections across these servers.
They must support the WebSocket upgrade process.
Sticky sessions ensure a client consistently connects to the same backend server, maintaining its state.

Next, we'll explore how to configure these load balancers effectively!

คำถามที่พบบ่อย

บทเรียน “กลยุทธ์การปรับขนาดแนวนอน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “กลยุทธ์การปรับขนาดแนวนอน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส WebSockets & Realtime Systems Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส WebSockets & Realtime Systems Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “กลยุทธ์การปรับขนาดแนวนอน”

ทำความเข้าใจวิธีกระจายการเชื่อมต่อ WebSocket ไปยังอินสแตนซ์เซิร์ฟเวอร์หลายตัวเพื่อเพิ่มประสิทธิภาพ คุณปฏิบัติ WebSockets & Realtime Systems Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน WebSockets & Realtime Systems Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน WebSockets & Realtime Systems Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “กลยุทธ์การปรับขนาดแนวนอน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน WebSockets & Realtime Systems Programming นี้ได้ไหม

ได้ บทเรียน WebSockets & Realtime Systems Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ WebSockets & Realtime Systems Programming