0

🚀 Backend Internals Series – Hiểu Điều Gì Thực Sự Xảy Ra Bên Trong Một Backend Server

Bạn có bao giờ gặp những tình huống như thế này chưa?

  • CPU chỉ chạy 15%, nhưng hệ thống vẫn timeout.
  • Database vẫn khỏe, nhưng Request lại chậm bất thường.
  • Chỉ deploy một bản build nhỏ, production lại đột nhiên "đi bụi".
  • Tăng số lượng Thread nhưng throughput không tăng, thậm chí còn giảm.
  • Cache được thêm vào để tăng tốc, cuối cùng lại khiến cả hệ thống sập.
  • Retry để tăng reliability, nhưng vô tình tạo ra hàng nghìn giao dịch trùng lặp.

Điều thú vị là...

Không framework nào giải thích cho bạn những chuyện này.

Spring Boot, NestJS, ASP.NET hay Express giúp bạn xây dựng ứng dụng.

Nhưng chúng không giúp bạn hiểu điều gì thực sự đang diễn ra bên dưới.

Đó cũng là lý do mình xây dựng Backend Internals Series.

Đây không phải là series học framework.

Cũng không phải series CRUD hay REST API.

Đây là hành trình bóc tách từng lớp bên trong một Backend Server để trả lời những câu hỏi mà Production vẫn luôn đặt ra.


Điều gì thực sự xảy ra sau một HTTP Request?

Một Request tưởng như rất đơn giản.

Client
    ↓
HTTP Server
    ↓
Thread
    ↓
Memory
    ↓
Connection Pool
    ↓
Database
    ↓
Cache
    ↓
Message Queue
    ↓
Distributed Services
    ↓
Response

Nhưng phía sau hành trình chỉ vài trăm mili giây đó là hàng chục cơ chế phức tạp.

  • Thread được tạo ra như thế nào?
  • Vì sao Thread lại bị Block?
  • Khi nào Event Loop hiệu quả hơn Thread?
  • Memory được cấp phát ở đâu?
  • Garbage Collector hoạt động lúc nào?
  • Vì sao Connection Pool luôn có giới hạn?
  • Cache hoạt động ra sao?
  • Queue giúp hệ thống chịu tải như thế nào?
  • Message bị duplicate thì sao?
  • Service biết nhau bằng cách nào?
  • Deploy mà không downtime thực chất làm gì?

Series này sẽ lần lượt giải đáp toàn bộ những câu hỏi đó.


Toàn bộ lộ trình Backend Internals

P1 — Request Đi Qua Server Như Thế Nào

https://www.patreon.com/posts/155821288?collection=2114789

P2 — Server Chậm Dù CPU Thấp? Sự Thật Về Thread vs Event Loop

https://www.patreon.com/posts/155836519?collection=2114789

P3 — Thread Pool — Vì Sao Server Không Tạo Vô Hạn Thread

https://www.patreon.com/posts/155839443?collection=2114789

P4 — Blocking vs Non-Blocking — Thread Đang Làm Gì Khi Chờ I/O

https://www.patreon.com/posts/155839591?collection=2114789

P5 — Connection Pool — Vì Sao Server Không Tạo Kết Nối Mỗi Lần Gọi Database

https://www.patreon.com/posts/155839792?collection=2114789

P6 — Memory Allocation — Vì Sao Server Tốn RAM Hơn Bạn Nghĩ

https://www.patreon.com/posts/155839897?collection=2114789

P7 — Garbage Collection — Ai Dọn Dẹp Memory Trong Server

https://www.patreon.com/posts/155840120?collection=2114789

P8 — Connection Handling — Làm Sao Server Xử Lý Hàng Nghìn Connections

https://www.patreon.com/posts/155840301?collection=2114789

P9 — Caching — Vì Sao Server Không Query Database Mỗi Lần

https://www.patreon.com/posts/155840766?collection=2114789

P10 — Cache Stampede — Khi Cache Gây Sập Hệ Thống

https://www.patreon.com/posts/155840977?collection=2114789

P11 — Concurrency — Khi Nhiều Request Cùng Chạm Một Data

https://www.patreon.com/posts/155841160?collection=2114789

P12 — Distributed Locks — Khi Lock Không Còn Nằm Trong Một Server

https://www.patreon.com/posts/155841576?collection=2114789

P13 — Queue — Vì Sao Hệ Thống Không Xử Lý Request Ngay Lập Tức

https://www.patreon.com/posts/155841396?collection=2114789

P14 — Message Queue — Khi Hệ Thống Giao Tiếp Bằng Message

https://www.patreon.com/posts/155841733?collection=2114789

P15 — Delivery Guarantee — At Least Once vs Exactly Once

https://www.patreon.com/posts/155841932?collection=2114789

P16 — Ordering — Khi Thứ Tự Message Không Còn Đáng Tin

https://www.patreon.com/posts/156848703?collection=2114789

P17 — Liveness vs Readiness — Hệ Thống Biết Service Còn Sống Bằng Cách Nào?

https://www.patreon.com/posts/157179859?collection=2114789

P18 — Service Discovery — Làm Sao Các Microservices Tìm Thấy Nhau?

https://www.patreon.com/posts/157339377?collection=2114789

P19 — Load Balancing — Bí Mật Phía Sau Hàng Triệu Requests

https://www.patreon.com/posts/157340471?collection=2114789

P20 — Deploy Không Downtime — Điều Gì Thực Sự Xảy Ra?

https://www.patreon.com/posts/157341307?collection=2114789

P21 — Configuration Management — Vì Sao Config Có Thể Làm Sập Production?

https://www.patreon.com/posts/157342002?collection=2114789


Sau khi hoàn thành series này, bạn sẽ nhìn Backend theo một cách hoàn toàn khác.

Bạn sẽ không còn chỉ biết:

  • Viết REST API.
  • Thêm Redis.
  • Dùng Kafka.
  • Scale Pod.
  • Tăng Thread Pool.

Mà sẽ hiểu:

  • Tại sao cần làm như vậy.
  • Khi nào nên làm.
  • Trade-off của từng lựa chọn.
  • Điều gì thực sự xảy ra phía sau framework.

Đó là khoảng cách giữa:

Biết sử dụng công nghệ.

Hiểu cách công nghệ vận hành.


Series này dành cho ai?

  • Backend Developers
  • Software Engineers
  • Java / Spring Boot Developers
  • .NET Developers
  • NodeJS Developers
  • DevOps Engineers
  • SRE Engineers
  • Tech Leads
  • Solution Architects
  • Những ai muốn hiểu Backend ở mức Production thay vì chỉ dừng ở Framework.

Một lời khuyên nhỏ

Rất nhiều người học Distributed Systems trước.

Nhưng lại chưa thực sự hiểu một Backend Server hoạt động như thế nào.

Theo mình, đó là một thứ tự khá khó.

Bởi vì Distributed Systems thực chất chỉ là rất nhiều Backend Server phối hợp với nhau.

Nếu chưa hiểu một Server hoạt động ra sao...

Thì sẽ rất khó hiểu vì sao hàng chục hay hàng trăm Server lại vận hành được cùng nhau.

Đó cũng là lý do mình luôn khuyên:

Hiểu một Server trước.

Rồi mới hiểu cả một Hệ thống.

Hy vọng series này sẽ giúp bạn nhìn Backend theo đúng góc nhìn của một Software Engineer thay vì chỉ là người sử dụng framework.


All rights reserved

Viblo
Hãy đăng ký một tài khoản Viblo để nhận được nhiều bài viết thú vị hơn.
Đăng kí