
Kiến trúc mạnh mẽ và bộ tính năng của PostgreSQL đã biến nó thành nền tảng cho vô số ứng dụng. Tuy nhiên, các kết nối trực tiếp từ client đến máy chủ PostgreSQL phải chịu chi phí đáng kể, đặc biệt khi có độ đồng thời cao. Mỗi kết nối mới yêu cầu xác thực, cấp phát tiến trình, cấp phát bộ nhớ và khởi tạo trạng thái. Đối với các ứng dụng có hàng nghìn người dùng đồng thời hoặc các microservice tạo ra các kết nối thường xuyên, ngắn hạn, chi phí này có thể nhanh chóng làm giảm hiệu suất, làm cạn kiệt tài nguyên máy chủ và dẫn đến các lỗi dây chuyền. Connection pooling không chỉ là một sự tối ưu hóa; nó là một yêu cầu cơ bản cho các triển khai PostgreSQL có khả năng mở rộng.
Hướng dẫn này cung cấp một so sánh có căn cứ, dựa trên dữ liệu về ba công cụ connection pooler nổi bật của PostgreSQL: PgBouncer, PgCat và Supavisor. Chúng ta sẽ phân tích kiến trúc của chúng, chiến lược pooling, đánh giá hiệu suất của chúng dưới độ đồng thời cao (cụ thể là 20.000 kết nối client đồng thời), và thảo luận về các tính năng nâng cao như định tuyến bản sao đọc (read replica routing) và phân mảnh (sharding). Phân tích này hướng đến các kỹ sư và kiến trúc sư cấp cao đang thiết kế và vận hành các hệ thống PostgreSQL hiệu suất cao.
Model connection scaling, transaction pooling & RAM limits
Model PostgreSQL connection scaling across microservices. Calculate safe max_connections, optimal PgBouncer pool sizes, and export tuned pgbouncer.ini, postgresql.conf, and Kubernetes manifests.
Một kết nối trực tiếp đến PostgreSQL bao gồm:
postgres mới được tạo hoặc cấp phát từ một pool đã được phân nhánh trước cho mỗi client, tiêu tốn bộ nhớ và CPU.work_mem, maintenance_work_mem, v.v.), có thể nhanh chóng tích lũy với hàng nghìn kết nối.Ở quy mô lớn, các hoạt động này trở thành nút thắt cổ chai. Một máy chủ được cấu hình cho max_connections = 1000 có thể gặp khó khăn khi xử lý ngay cả vài trăm truy vấn đang hoạt động nếu số lượng kết nối thay đổi liên tục cao. Các connection pooler giảm thiểu điều này bằng cách duy trì một pool kết nối liên tục đến máy chủ PostgreSQL và đa luồng các yêu cầu của client qua các kết nối đã được pool này.
Hiểu rõ các chế độ pooling là rất quan trọng để chọn đúng công cụ và cấu hình nó một cách chính xác.
Trong session pooling, một kết nối client, sau khi được thiết lập với pooler, sẽ được gán một kết nối backend chuyên dụng từ pool trong suốt thời gian tồn tại của nó. Khi client ngắt kết nối, kết nối backend của nó sẽ được trả về pool. Chế độ này minh bạch đối với ứng dụng và hỗ trợ tất cả các tính năng của PostgreSQL, bao gồm prepared statements, bảng tạm thời và advisory locks, vì client duy trì một trạng thái phiên nhất quán.
Ưu điểm:
Nhược điểm:
max_client_conn (pooler) và default_pool_size (pooler) không được cân bằng cẩn thận với max_connections (PostgreSQL).Transaction pooling là chế độ hiệu quả nhất để sử dụng tài nguyên. Một kết nối client được gán một kết nối backend chỉ trong suốt thời gian của một giao dịch duy nhất. Khi giao dịch commit hoặc rollback, kết nối backend sẽ được trả về pool ngay lập tức, làm cho nó có sẵn cho các client khác. Điều này cho phép một số lượng nhỏ kết nối backend phục vụ một số lượng rất lớn kết nối client.
Ưu điểm:
Nhược điểm:
SET (ví dụ: SET search_path), và LISTEN/NOTIFY không được đảm bảo duy trì giữa các giao dịch. Đây là cạm bẫy phổ biến và quan trọng nhất.Statement pooling tiến thêm một bước so với transaction pooling, trả lại kết nối backend vào pool sau mỗi câu lệnh. Điều này thậm chí còn mạnh mẽ hơn và thường không được khuyến nghị do khả năng cao làm hỏng logic ứng dụng mong đợi trạng thái phiên duy trì qua nhiều câu lệnh trong một giao dịch. PgBouncer về mặt kỹ thuật hỗ trợ nó nhưng khuyến cáo không nên dùng.
PgBouncer là một connection pooler lâu đời, nhẹ, đơn tiến trình được viết bằng C. Nó đã trở thành tiêu chuẩn thực tế cho connection pooling của PostgreSQL trong hơn một thập kỷ nhờ sự ổn định, hiệu quả và đơn giản của nó.
PgBouncer hoạt động như một proxy giữa các ứng dụng client và máy chủ PostgreSQL. Nó duy trì một số lượng kết nối có thể cấu hình đến máy chủ PostgreSQL và đa luồng các kết nối client đến qua các kết nối đã được pool này. Nó là đơn luồng nhưng sử dụng I/O không chặn, làm cho nó rất hiệu quả cho nhiệm vụ chính của nó.
md5, plain, hba (qua auth_query).pgbouncer để thống kê và quản trị.pgbouncer.ini)Cấu hình này minh họa transaction pooling cho một kịch bản đồng thời cao.
[databases]
; Define your databases here. Format: <pool_name> = host=... port=... dbname=... user=... password=...
; You can use a wildcard '*' to match all databases on a specific host/port.
; For simplicity, we'll use a single database.
mydb = host=127.0.0.1 port=5432 dbname=mydb user=pgbouncer_user password=your_db_password
[pgbouncer]
; Core settings
listen_addr = 0.0.0.0
listen_port = 6432
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt ; Userlist for PgBouncer's own authentication
; Pooling settings
pool_mode = transaction ; Critical setting: transaction, session, or statement
default_pool_size = 200 ; Max connections PgBouncer will open to the PostgreSQL server per database
max_db_connections = 0 ; Max connections per database (0 means default_pool_size)
max_user_connections = 0 ; Max connections per user (0 means unlimited)
max_client_conn = 20000 ; Max client connections PgBouncer will accept
reserve_pool_size = 5 ; Connections reserved for administrative tasks
reserve_pool_timeout = 5.0 ; How long to wait for a reserved connection
; Timeout settings
client_login_timeout = 60 ; How long client can take to login
client_idle_timeout = 300 ; Close client connection if idle for this long
server_idle_timeout = 300 ; Close server connection if idle for this long
server_connect_timeout = 15 ; How long to wait for server connection to establish
server_lifetime = 3600 ; Close server connection after this many seconds, regardless of activity
; Logging settings
log_connections = 1
log_disconnections = 1
log_pooler_errors = 1
stats_period = 60 ; How often to log stats
; Admin settings
admin_users = pgbouncer_admin
stats_users = pgbouncer_admin
Và userlist.txt:
"pgbouncer_user" "your_db_password"
"pgbouncer_admin" "your_admin_password"
PgCat là một connection pooler hiện đại, hiệu suất cao được viết bằng Rust. Nó nhằm mục đích cung cấp một giải pháp giàu tính năng hơn PgBouncer, đặc biệt nhắm mục tiêu đến các triển khai PostgreSQL phân tán với hỗ trợ tích hợp cho phân mảnh và định tuyến bản sao đọc.
PgCat tận dụng mô hình đồng thời và đảm bảo an toàn bộ nhớ của Rust. Nó được thiết kế để đa luồng, cho phép nó mở rộng trên nhiều lõi CPU hiệu quả hơn PgBouncer. Nó hoạt động như một proxy thông minh, có khả năng kiểm tra các truy vấn và định tuyến chúng đến các máy chủ backend thích hợp (ví dụ: truy vấn chỉ đọc đến các bản sao, truy vấn phân mảnh đến các phân mảnh cụ thể).
SELECT đến các bản sao đọc.pgcat.toml)Ví dụ này minh họa định tuyến bản sao đọc và phân mảnh cơ bản.
[general]
listen_addr = "0.0.0.0"
listen_port = 6432
auth_type = "md5"
auth_file = "/etc/pgcat/users.toml"
default_pool_mode = "transaction" # Can be "session" or "transaction"
max_client_connections = 20000
log_level = "info"
[shards.shard1]
default_pool_size = 100
max_pool_size = 200
min_pool_size = 50
pool_timeout = 300
idle_timeout = 300
[[shards.shard1.servers]]
host = "primary-db-1.example.com"
port = 5432
weight = 100 # Primary server
[[shards.shard1.servers]]
host = "replica-db-1.example.com"
port = 5432
weight = 50 # Read replica
role = "replica"
[shards.shard2]
default_pool_size = 100
max_pool_size = 200
min_pool_size = 50
pool_timeout = 300
idle_timeout = 300
[[shards.shard2.servers]]
host = "primary-db-2.example.com"
port = 5432
weight = 100
[[shards.shard2.servers]]
host = "replica-db-2.example.com"
port = 5432
weight = 50
role = "replica"
# Example of a sharding rule (simplified, real rules can be complex regex)
# This would require PgCat to parse queries to identify the sharding key.
# For instance, if a query contains "WHERE user_id = <id>", it could route based on user_id.
# [sharding_rules]
# "user_id" = { type = "modulo", column = "user_id", shards = ["shard1", "shard2"] }
Và users.toml:
[[users]]
username = "pgcat_user"
password = "your_db_password"
[[users]]
username = "pgcat_admin"
password = "your_admin_password"
Supavisor là một connection pooler phân tán, cloud-native được xây dựng trên Elixir/OTP. Nó được thiết kế cho tính sẵn sàng cao, khả năng chịu lỗi và khả năng mở rộng theo chiều ngang, làm cho nó đặc biệt phù hợp với kiến trúc microservices và môi trường serverless.
Supavisor tận dụng thế mạnh của Erlang VM (BEAM): các tiến trình nhẹ, khả năng chịu lỗi và tính toán phân tán. Mỗi nút Supavisor có thể giao tiếp với các nút khác, tạo thành một cụm chia sẻ trạng thái kết nối và tải. Điều này cho phép mở rộng và khả năng phục hồi liền mạch. Nó hoạt động như một proxy thông minh, tương tự như PgCat, nhưng với sự nhấn mạnh mạnh mẽ vào bản chất phân tán của nó.
config/runtime.exs)Cấu hình của Supavisor thường được thực hiện thông qua các biến môi trường hoặc các tệp cấu hình Elixir.
import Config
config :supavisor, Supavisor.Application,
listen_ip: {0, 0, 0, 0},
listen_port: 6432,
max_client_connections: 20000,
default_pool_mode: :transaction, # :session or :transaction
log_level: :info,
auth_module: Supavisor.Auth.File,
auth_file: "/etc/supavisor/users.json",
databases: [
%{
name: "mydb",
host: "primary-db.example.com",
port: 5432,
user: "supavisor_user",
password: "your_db_password",
pool_size: 200,
max_pool_size: 400,
min_pool_size: 100,
pool_timeout: 300,
idle_timeout: 300,
# Read replicas
replicas: [
%{
host: "replica-db-1.example.com",
port: 5432,
weight: 50
},
%{
host: "replica-db-2.example.com",
port: 5432,
weight: 50
}
]
}
]
# For clustering (example using libcluster)
config :libcluster,
topologies: [
supavisor_cluster: [
strategy: Cluster.Strategy.Kubernetes,
config: [
service: "supavisor-headless",
namespace: "default",
selector: "app=supavisor"
]
]
]
Và users.json:
[
{
"username": "supavisor_user",
"password": "your_db_password"
},
{
"username": "supavisor_admin",
"password": "your_admin_password"
}
]
Tính năng này cho phép pooler định hướng thông minh các truy vấn SELECT đến các bản sao chỉ đọc, giảm tải cho cơ sở dữ liệu chính và cải thiện khả năng mở rộng đọc.
Phân mảnh phân phối dữ liệu trên nhiều phiên bản cơ sở dữ liệu độc lập, cho phép mở rộng theo chiều ngang vượt quá giới hạn của một máy chủ duy nhất.
Đây là một yếu tố khác biệt quan trọng, đặc biệt khi sử dụng transaction pooling.
prepared statement "..." does not exist. Các ứng dụng phải chuẩn bị lại các câu lệnh cho mỗi giao dịch hoặc tránh hoàn toàn prepared statements khi sử dụng transaction pooling.Đảm bảo bản thân pooler có tính sẵn sàng cao là rất quan trọng.
Tất cả các pooler đều hỗ trợ nhiều phương thức xác thực.
md5, plain, hba (qua auth_query), cert. Sử dụng userlist.txt hoặc auth_query đến một cơ sở dữ liệu.md5, plain, scram-sha-256, cert. Sử dụng users.toml hoặc xác thực bên ngoài.md5, plain, scram-sha-256. Sử dụng users.json hoặc có thể tích hợp với các mô-đun xác thực tùy chỉnh.Để cung cấp một so sánh dựa trên dữ liệu, chúng tôi định nghĩa một kịch bản đánh giá hiệu năng tập trung vào độ đồng thời cao.
Thiết lập phần cứng (Minh họa):
Cấu hình PostgreSQL:
max_connections = 500 (Đây là nút thắt cổ chai mà chúng ta đang cố gắng khắc phục bằng pooling)shared_buffers = 16GBwork_mem = 4MBeffective_cache_size = 48GBCông cụ đánh giá hiệu năng: pgbench
Các kịch bản thử nghiệm:
pool_mode = transaction, default_pool_size = 200, max_client_conn = 20000.pool_mode = session, default_pool_size = 500, max_client_conn = 20000.default_pool_mode = transaction, default_pool_size = 200, max_client_connections = 20000.default_pool_mode = session, default_pool_size = 500, max_client_connections = 20000.default_pool_mode = :transaction, pool_size = 200, max_client_connections = 20000.default_pool_mode = :session, pool_size = 500, max_client_connections = 20000.Kịch bản pgbench (simple_transaction.sql):
Kịch bản này mô phỏng một giao dịch đơn giản, ngắn gọn phù hợp với transaction pooling.
\set aid random(1, 100000 * :scale)
\set bid random(1, 1 * :scale)
\set tid random(1, 1000 * :scale)
\set delta random(-5000, 5000)
BEGIN;
UPDATE pgbench_accounts SET abalance = abalance + :delta WHERE aid = :aid;
SELECT abalance FROM pgbench_accounts WHERE aid = :aid;
UPDATE pgbench_tellers SET tbalance = tbalance + :delta WHERE tid = :tid;
UPDATE pgbench_branches SET bbalance = bbalance + :delta WHERE bid = :bid;
INSERT INTO pgbench_history (tid, bid, aid, delta, mtime) VALUES (:tid, :bid, :aid, :delta, now());
COMMIT;
Lệnh pgbench:
# Initialize pgbench (run once)
pgbench -i -s 100 mydb
# Run benchmark (replace <POOLER_PORT> with 6432 for poolers, 5432 for direct)
pgbench -h 127.0.0.1 -p <POOLER_PORT> -U pgbouncer_user -c 20000 -j 16 -T 300 -f simple_transaction.sql mydb
-c 20000: 20.000 client đồng thời.-j 16: 16 luồng worker pgbench.-T 300: Chạy trong 300 giây.-f simple_transaction.sql: Sử dụng kịch bản giao dịch tùy chỉnh.Các số liệu được thu thập:
Các kết quả sau đây mang tính minh họa, dựa trên các đặc điểm hiệu suất điển hình được quan sát trong môi trường sản xuất và các lợi thế lý thuyết của từng pooler. Các con số thực tế sẽ khác nhau tùy thuộc vào phần cứng, mạng, cấu hình PostgreSQL và khối lượng công việc.
| Kịch bản | Pooler | Chế độ Pool | Số Client tối đa | Kích thước Pool Backend | TPS (Trung bình) | Độ trễ (Trung bình/Pctl 95 ms) | CPU Pooler (%) | Bộ nhớ Pooler (MB) | CPU PG (%) | Bộ nhớ PG (MB) |
|---|---|---|---|---|---|---|---|---|---|---|
| Baseline (Trực tiếp) | N/A | N/A | 20000 | 500 (giới hạn PG) | ~500 | 1500 / 5000+ | N/A | N/A | 90+ | 30000+ |
| PgBouncer | PgBouncer | Transaction | 20000 | 200 | 18000 | 5 / 20 | 15 | 50 | 70 | 10000 |
| PgBouncer | PgBouncer | Session | 20000 | 500 | 12000 | 8 / 35 | 20 | 70 | 85 | 20000 |
| PgCat | PgCat | Transaction | 20000 | 200 | 20000 | 4 / 18 | 25 | 100 | 65 | 10000 |
| PgCat | PgCat | Session | 20000 | 500 | 14000 | 7 / 30 | 30 | 120 | 80 | 20000 |
| Supavisor (1 Nút) | Supavisor | Transaction | 20000 | 200 | 16000 | 6 / 25 | 40 | 250 | 75 | 10000 |
| Supavisor (1 Nút) | Supavisor | Session | 20000 | 500 | 10000 | 10 / 40 | 50 | 300 | 90 | 20000 |
| Supavisor (Cụm 3 Nút) | Supavisor | Transaction | 20000 | 200 (mỗi nút) | 22000 | 4 / 15 | 20 (mỗi nút) | 250 (mỗi nút) | 60 | 10000 |
Phân tích:
simple_transaction.sql, transaction pooling luôn mang lại TPS cao hơn đáng kể và độ trễ thấp hơn trên tất cả các pooler. Điều này là do việc tái sử dụng hiệu quả các kết nối backend.default_pool_size cho session pooling phải gần với số lượng client hoạt động đồng thời dự kiến, điều này vẫn có thể đáng kể.| Tính năng / Số liệu | PgBouncer | PgCat | Supavisor |
|---|---|---|---|
| Ngôn ngữ / Runtime | C | Rust |
Một kiến trúc microservice có lưu lượng truy cập cao thường xuyên mở và đóng các kết nối đến cơ sở dữ liệu PostgreSQL. Ứng dụng phụ thuộc nhiều vào các bảng tạm thời (temporary tables) và các câu lệnh đã chuẩn bị (prepared statements) để xử lý dữ liệu phức tạp. Chế độ connection pooling nào sẽ phù hợp nhất để cân bằng hiệu quả tài nguyên và khả năng tương thích của ứng dụng?
Làm sạch log AI CLI, tạo biểu thức cron, giải mã JWT và tính quyền chmod offline.

Hướng dẫn toàn diện về kiến trúc & tinh chỉnh pgbouncer: transaction pooling, prepared statements & session overhead với kiến trúc cấp độ sản xuất và ví dụ mã.
Đọc tiếp
Hướng dẫn toàn diện về tối ưu hóa truy vấn PostgreSQL 17: kế hoạch thực thi, điều chỉnh bộ nhớ & explain analyze với kiến trúc cấp độ sản xuất và ví dụ mã.
Đọc tiếp
Chẩn đoán và loại bỏ tình trạng phình (bloat) bảng và index trong PostgreSQL. Nắm vững các công thức tinh chỉnh autovacuum, nén dữ liệu không downtime với pg_repack, và cơ chế visibility map của MVCC.
Đọc tiếp