By Đức Hiếu
1. Connection Pool là gì?
Connection Pool là một cơ chế quản lý kết nối giữa các ứng dụng đến cơ sở dữ liệu (Database Server), trong đó một tập hợp các kết nối được khởi tạo trước và duy trì sẵn sàng để sử dụng. Thay vì phải thiết lập kết nối mới mỗi khi cần truy vấn dữ liệu. Database Client (thường là Backend App) có thể "mượn" một kết nối có sẵn từ pool, sử dụng xong và trả lại pool để tái sử dụng.
1.1. Vấn đề với phương pháp kết nối truyền thống
Trong mô hình kết nối truyền thống, mỗi query xuống Database. Backend App tạo một kết nối mới tới Database Server, điều này dẫn đến một số vấn đề về hiệu suất và tốn tài nguyên (CPU, Memory) của DB server. Cụ thể, ở các bước sau:
- Mỗi lần kết nối đều yêu cầu thiết lập TCP với quy trình bắt tay 3 bước (3-Way Handshake)
- Quá trình xác thực và thiết lập session với Database tốn thời gian
- Khởi tạo và giải phóng kết nối liên tục tạo áp lực lên cả ứng dụng và Database
1.2. Minh họa thông qua ví dụ
Giả sử chúng ta có một API để lấy thông tin profile người dùng:
Khi sử dụng Connection Pool, chi phí 5ms cho việc thiết lập kết nối Database có thể được loại bỏ trong hầu hết các trường hợp, giảm tổng thời gian xuống còn khoảng 110ms.
Lý thuyết đã xong, giờ chúng ta cùng thực hành để hiểu rõ hơn
2. Quy trình cơ bản của Connection pool
Lưu ý: Các ví dụ và tư liệu dưới đây mình dựa trên package database/sql của Golang và MySQL. Cơ bản các thư viện và các ngôn ngữ khác cũng gần tương tự. Để chắc chắn các bạn có thể tự thực hành trên ngôn ngữ hoặc thư viện mà bạn đang sử dụng để hiểu rõ hơn
- Khi ứng dụng khởi động, Connection Pool được khởi tạo.
- Khi cần truy vấn Database, ứng dụng yêu cầu một kết nối từ pool.
- Nếu có kết nối available (free) trong pool thì pool sẽ cung cấp kết nối đó ngay lập tức.
- Nếu không có kết nối available và chưa đạt giới hạn tối đa, pool sẽ tạo kết nối mới.
- Nếu đã đạt giới hạn tối đa, yêu cầu sẽ phải chờ hoặc bị từ chối tùy theo cấu hình.
- Sau khi sử dụng xong và bạn gọi hàm đóng kết nối. Tùy một số ngôn ngữ lập trình hoặc thư viện mà có hàm để nhận biết đóng kết nối. ví dụ ở Go là lúc mà bạn gọi hàm Close(). Lúc này kết nối được trả lại pool thay vì đóng hoàn toàn.
Xem diagram dưới để thấy chi tiết hơn
2.1 Các hàm quan trọng trong Connection Pool
2.2 Các chỉ số theo dõi hiệu suất Connection Pool
3. Demo
3.1 Video Demo
3.2 Code Demo
3.2.1 So sánh mô hình kết nối truyền thống với dùng connection pool để kết nối
package main
import (
"database/sql"
"fmt"
"log"
"net/http"
"os"
"time"
"github.com/gin-gonic/gin"
_ "github.com/go-sql-driver/mysql"
)
func main() {
mode := os.Args[1:]
if mode[0] == "pool" {
pool()
} else {
normal()
}
}
func normal() {
dns := "root:123456@tcp(127.0.0.1:3306)/test"
query := "select name from customer limit 1000,1000;"
dbNormal, err := sql.Open("mysql", dns)
dbNormal.SetMaxIdleConns(0) // hầu hết thư viện khi bạn mở open là đã tạo pool nên mình set 0 ở đây để 0 có kết nỗi nhàn rỗi nào. tức là khi làm xong nó sẽ release connection luôn
if err != nil {
log.Fatal("open DB Normal fail", err.Error())
}
router := gin.Default()
router.GET("normal", func(ctx *gin.Context) {
row, err := dbNormal.Query(query)
if err != nil {
fmt.Println(err.Error())
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
defer row.Close()
ctx.JSON(http.StatusOK, gin.H{"message": "ok"})
})
if err = router.Run(":8081"); err != nil {
log.Fatal("Start server fail", err.Error())
}
}
func pool() {
dns := "root:123456@tcp(127.0.0.1:3306)/test"
query := "select name from customer limit 1000,1000;"
maxOpenConns := 140
maxIdleConns := 70
connMaxIdleTime := 10 * time.Minute
dbPool, err := sql.Open("mysql", dns)
if err != nil {
log.Fatal("open DB Poll fail", err.Error())
}
dbPool.SetMaxOpenConns(maxOpenConns) // Số lượng tối đa được mở cùng lúc
dbPool.SetMaxIdleConns(maxIdleConns) // Số lượng tối đa nằm trong pool
dbPool.SetConnMaxIdleTime(connMaxIdleTime) // Thời gian tồn tại tối đa của 1 connection khi nhàn rỗi
router := gin.Default()
router.GET("pool", func(ctx *gin.Context) {
row, err := dbPool.Query(query)
if err != nil {
fmt.Println(err.Error())
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
defer row.Close()
ctx.JSON(http.StatusOK, gin.H{"message": "ok"})
})
if err = router.Run(":8082"); err != nil {
log.Fatal("Start server fail", err.Error())
}
}
3.2.2 Tìm hiểu các hàm và chỉ số cần thiết
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"log"
"net/http"
"text/template"
"time"
"github.com/gin-gonic/gin"
_ "github.com/go-sql-driver/mysql"
)
func main() {
connectionPoolPractice()
}
const viewerHTML = `
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8"/>
<title>Realtime DB Pool Stats</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/github-dark.min.css">
<style>
body { background: #23272f; color: #e6edf3; font-family: sans-serif; padding: 24px }
pre { background: #161b22; padding: 12px; border-radius: 8px; }
</style>
</head>
<body>
<h2>Realtime DB pool stats</h2>
<pre id="json"></pre>
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
<script>
const el = document.getElementById("json");
const sse = new EventSource("/info-pool/sse");
sse.onmessage = (e) => {
let json = JSON.parse(e.data);
el.textContent = JSON.stringify(json, null, 2);
hljs.highlightElement(el);
};
</script>
</body>
</html>
`
func connectionPoolPractice() {
dns := "root:123456@tcp(127.0.0.1:3306)/test"
db, err := sql.Open("mysql", dns)
if err != nil {
panic(err)
}
db.SetMaxOpenConns(3) // số lượng tối đa được mở cùng lúc. Cái này nên > maxIdleConns để tối ưu
db.SetMaxIdleConns(2) // số lượng tối đa nằm trong pool
db.SetConnMaxIdleTime(time.Second * 10) // thời gian tồn tại tối đa của 1 connection tính từ lúc nó available(nhàn rỗi)
db.SetConnMaxLifetime(time.Second * 30)
router := gin.Default()
router.GET("/info-pool/sse", func(ctx *gin.Context) {
ctx.Writer.Header().Set("Content-Type", "text/event-stream")
ctx.Writer.Header().Set("Cache-Control", "no-cache")
ctx.Writer.Header().Set("Connection", "keep-alive")
ctx.Writer.Header().Set("Connection", "keep-alive")
ctx.Writer.Flush()
clientGone := ctx.Writer.CloseNotify()
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
for {
select {
case <-clientGone:
return
case <-ticker.C:
stats := db.Stats()
// Serialize stats thành JSON
jsonStats, err := json.Marshal(stats)
if err != nil {
continue
}
fmt.Fprintf(ctx.Writer, "data: %s\n\n", jsonStats)
ctx.Writer.Flush()
}
}
})
router.GET("/view", func(ctx *gin.Context) {
tmpl, err := template.New("viewer").Parse(viewerHTML)
if err != nil {
ctx.String(http.StatusInternalServerError, "Template error")
return
}
tmpl.Execute(ctx.Writer, nil)
})
router.GET("/pool", func(ctx *gin.Context) {
conn, err := db.Conn(context.Background())
if err != nil {
fmt.Println(err.Error())
}
defer conn.Close()
row, err := conn.QueryContext(context.Background(), "select sleep(10)")
if err != nil {
fmt.Println(err.Error())
}
defer row.Close()
ctx.JSON(200, "ok")
})
router.Run()
}
4. Cách mình tối ưu Connection Pool
Mọi thứ dưới đây là kinh nghiệm bản thân mình thông qua dự án thực tế và kiến thức học được ở khóa Advanced Backend của Ronin.
Việc tối ưu này theo mình biết hiện tại chưa có một công thức chuẩn cụ thể nào cho chúng ta follow theo. Cho nên chỉ có thể tuning dần để tìm ra các chỉ số phù với hệ thống mà các bạn đang làm.
- Tham số chỉ ra số lượng connection tối đa được mở đồng thời (MaxOpenConns): Đây là tham số mà mình thấy quan trọng nhất vì nó quyết định tới performance của Database. Nếu quá thấp sẽ gây ra hiện tượng nghẽn cổ chai, quá cao sẽ gây áp lực lên Database. Có nhiều yếu tố ảnh hưởng tới tham số này:
- Hardware capacity của DB server và Client
- Độ dài trung bình của các transaction
- Kiến trúc của DB (standalone, cluster)
- …
- Tham số chỉ ra số lượng connection tối đa ở trong pool (MaxIdleConns): Nên thiết lập MaxIdleConns thấp hơn hoặc bằng MaxOpenConns. Sau một vài dự án thực chiến thì mình đúc kết ra 2 cách tính cho riêng mình là MaxIdleConns = MaxOpenConns * 0.5 hoặc MaxIdleConns = MaxOpenConns * 0.75.
- Tham số chỉ ra tuổi thọ kết nối (ConnMaxIdleTime, ConnMaxLifetime): Sử dụng ConnMaxIdleTime và ConnMaxLifetime để đảm bảo kết nối không bị quá cũ, tránh các vấn đề như dư thừa connection không dùng tới gây chiếm connection ở ứng dụng khác
Thường xuyên theo dõi các chỉ số như WaitCount, WaitDuration để phát hiện và xử lý sớm các vấn đề về hiệu suất.
Bài này chỉ đang nói về Internal Connection Pool tức là Connection Pool bên trong App (Backend App). Với những hệ thống nhỏ một Backend với một Database chúng ta có thể tuning dần để đưa ra các tham số phù hợp cho hệ thống. Nhưng với các hệ thống bắt đầu scale bằng cách thêm instance hay Database sử dụng Replication Master-Slave thì lúc này chúng ta cần dùng tới các External Connection Pool như ProxySQL mà mình sẽ giới thiệu ở phần sau
5. Kết luận
Connection Pool là một kỹ thuật quan trọng trong việc tối ưu hiệu suất Database. Thông qua việc tái sử dụng kết nối, Connection Pool giúp giảm đáng kể thời gian thiết lập kết nối, tăng tốc độ phản hồi của ứng dụng và giảm tải cho Database.
Hiểu rõ cách hoạt động và các tham số cấu hình của Connection Pool sẽ giúp các Backend Engineer xây dựng hệ thống với hiệu suất tối ưu, đáp ứng được các yêu cầu về tốc độ và khả năng mở rộng trong môi trường thực tế.
Tham khảo thêm:
https://go.dev/doc/database/manage-connections#connection_pool_properties
https://www.academia.edu/3272493/Database_Performance_Optimization_by_Connection_Pooling
