Connection pooling: "too many clients" xatosi, CONN_MAX_AGE, psycopg pool va PgBouncer
Pod'larni 4 tadan 16 taga ko'tardingiz va PostgreSQL "too many clients" deb javob berdi. Ulanish nega qimmat, Django uni qanday boshqaradi va qachon CONN_MAX_AGE, psycopg pool yoki PgBouncer kerak.
Tasavvur qiling: aksiya kuni. Trafik oshgani uchun gunicorn'li pod'lar sonini 4 tadan 16 taga ko'tardingiz. Bir necha daqiqadan keyin loglarda bir xil xato paydo bo'ladi:
psycopg.OperationalError: connection failed: FATAL: sorry, too many clients already
Baza sekin emas, CPU ham bo'sh. Muammo so'rovlarda emas, ulanishlar sonida. Har bir pod o'zi bilan PostgreSQL'ga yangi ulanishlar olib keldi va server max_connections chegarasiga urildi. Server qo'shish ilovani tezlashtirish o'rniga uni to'xtatib qo'ydi.
Bu maqolada ulanish nega qimmat ekanini, Django uni qanday boshqarishini va uchta vositani ko'rib chiqamiz: CONN_MAX_AGE, Django 5.1'dagi psycopg pool va PgBouncer. Oxirida max_connectionsni qanday hisoblashni ham ko'ramiz.
Ulanish nega qimmat
PostgreSQL'da har bir ulanish (connection) bu alohida OS jarayoni (process). Klient ulanganda quyidagilar sodir bo'ladi:
- TCP handshake, agar TLS yoqilgan bo'lsa, TLS handshake ham.
- Autentifikatsiya:
scram-sha-256bo'lsa, bir necha marta xabar almashinuvi va hisoblash. postmasteryangi backend jarayoninifork()qiladi.- Yangi jarayon katalog cache'larini noldan to'ldiradi: birinchi so'rovlar jadval va index metama'lumotlarini qayta o'qiydi.
Bularning hammasi so'rov bajarilishidan oldin sodir bo'ladi. Bundan tashqari, har bir ochiq ulanish bo'sh tursa ham xotira egallaydi, max_connections esa server ishga tushganda belgilanadi va uni o'zgartirish uchun restart kerak.
Bu narxni o'z serveringizda o'lchash oson. pgbenchning -C flagi har bir transaction uchun yangi ulanish ochadi:
# one-time: create test tables
pgbench -i -s 10 shop
# 1) connections are kept open for the whole run
pgbench -S -c 10 -j 2 -T 30 shop
# 2) -C: a NEW connection for every transaction
pgbench -S -c 10 -j 2 -T 30 -C shop
Ikki natijadagi tpsni solishtiring. Farq aynan ulanish ochish narxi. Agar baza boshqa hostda va TLS orqali bo'lsa, farq yanada sezilarli bo'ladi. Aniq raqamlar sizning tarmog'ingiz va konfiguratsiyangizga bog'liq, shuning uchun ularni o'zingiz o'lchang.
Django standart holatda nima qiladi
Standart sozlamada CONN_MAX_AGE = 0. Bu shuni anglatadiki, Django har bir HTTP so'rovda ORM birinchi marta bazaga murojaat qilganda yangi ulanish ochadi va so'rov tugaganda (request_finished signali) uni yopadi.
Ya'ni 200 ms davom etadigan sahifada ulanish ochish va yopish har safar takrorlanadi. Kichik loyihada bu sezilmaydi. Lekin so'rovlar ko'paysa, vaqtning sezilarli qismi foydali ishga emas, handshake'larga ketadi, PostgreSQL esa doim yangi jarayonlarni fork qilib, eskilarini o'chirib turadi.
Ikkinchi muammo: ulanishlar soni nazoratsiz. Har bir worker, har bir thread, har bir Celery jarayoni o'z ulanishini ochadi. Pod qo'shsangiz, ulanishlar ham chiziqli ko'payadi.
CONN_MAX_AGE: persistent ulanishlar
Birinchi va eng oddiy yechim: ulanishni so'rovdan keyin yopmaslik.
# settings.py
import os
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql",
"NAME": "shop",
"USER": "shop",
"PASSWORD": os.environ["DB_PASSWORD"],
"HOST": "127.0.0.1",
"PORT": "5432",
"CONN_MAX_AGE": 60, # keep the connection for up to 60 s
"CONN_HEALTH_CHECKS": True, # ping it before reusing (Django 4.1+)
}
}
Bu qanday ishlaydi:
- Ulanish thread'ga bog'langan. Har bir thread o'zining bitta ulanishini saqlaydi.
- Har bir so'rov boshida va oxirida Django
close_old_connections()ni chaqiradi: ulanish yoshiCONN_MAX_AGEdan oshgan bo'lsa yoki xatolik holatida bo'lsa, u yopiladi. CONN_MAX_AGE = Nonecheksiz degani: ulanish worker o'lguncha yashaydi.CONN_HEALTH_CHECKS = Truebo'lsa, Django so'rov boshida qayta ishlatishdan oldin ulanish tirikligini tekshiradi. Bu baza restart bo'lgandan keyin birinchi so'rovning "server closed the connection" xatosi bilan yiqilishining oldini oladi.
CONN_MAX_AGEning cheklovi shundaki, u pool emas. U faqat "bitta thread, bitta ulanish" sxemasini uzoqroq yashatadi. 8 ta thread'li gunicorn worker'i 8 ta ulanishni doim ochiq saqlaydi, ular hozir hech narsa qilmayotgan bo'lsa ham. Ulanishlar umumiy soni hamon worker'lar × thread'lar × pod'lar formulasi bilan o'sadi.
Django 5.1+: psycopg pool
Django 5.1'dan boshlab PostgreSQL backend'i psycopg 3 orqali haqiqiy connection pool'ni qo'llab-quvvatlaydi. Pool har bir jarayonda (process) bitta bo'ladi va thread'lar undan ulanishni olib, ishlatib, qaytarib beradi.
pip install "psycopg[binary,pool]"
# settings.py (Django 5.1+, psycopg 3)
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql",
"NAME": "shop",
"USER": "shop",
"PASSWORD": os.environ["DB_PASSWORD"],
"HOST": "127.0.0.1",
"PORT": "5432",
# CONN_MAX_AGE stays 0: the pool replaces persistent connections
"OPTIONS": {
"pool": {
"min_size": 2, # opened up front, per process
"max_size": 8, # hard cap per process
"timeout": 10, # seconds to wait for a free connection
},
},
}
}
Mexanizm:
"pool": Truestandart sozlamalar bilan pool yaratadi, dict esapsycopg_pool.ConnectionPoolga argument sifatida uzatiladi.- Pool lazy yaratiladi: jarayonda bazaga birinchi murojaat bo'lganda.
- So'rov tugaganda Django ulanishni "yopadi", amalda esa u pool'ga qaytadi.
- Barcha
max_sizeulanishlar band bo'lsa, yangi so'rovtimeoutsoniyagacha kutadi, keyinPoolTimeoutxatosi chiqadi. Bu xato foydali: u ulanishlar yetishmayotganini PostgreSQL'ning "too many clients" xatosidan ancha oldin, ilova darajasida ko'rsatadi. - Pool'ni
CONN_MAX_AGEbilan birga ishlatib bo'lmaydi: ular bir xil muammoni ikki xil usulda yechadi va Django bunday konfiguratsiyani qabul qilmaydi.CONN_MAX_AGEni 0 qoldiring.
Pool'ning foydasi qachon katta? Bir jarayonda ko'p thread bo'lganda (gunicorn gthread, ASGI) va ular bazani bir vaqtda emas, navbat bilan ishlatganda. Sync gunicorn worker'ida bitta thread bor, demak max_size 1 dan katta bo'lsa, bu ortiqcha ulanish degani. Bunday holatda pool'ning asosiy foydasi ulanishni qayta ishlatishdir, min_sizeni esa kichik qoldirish kerak.
PgBouncer: ulanishlarni jarayonlar orasida bo'lishish
Django pool'i ham, CONN_MAX_AGE ham bitta jarayon ichida ishlaydi. 16 ta pod'da 4 tadan jarayon va har birida max_size=8 bo'lsa, eng yomon holatda 512 ta ulanish chiqadi. Jarayonlar o'zaro ulanish bo'lisha olmaydi.
PgBouncer bu muammoni ilova va PostgreSQL orasida turib yechadi. Ilova minglab arzon ulanishlarni PgBouncer'ga ochadi, PgBouncer esa ularni oz sonli haqiqiy server ulanishlariga taqsimlaydi.
; /etc/pgbouncer/pgbouncer.ini
[databases]
shop = host=127.0.0.1 port=5432 dbname=shop
[pgbouncer]
listen_addr = 127.0.0.1
listen_port = 6432
auth_type = scram-sha-256
auth_file = /etc/pgbouncer/userlist.txt
pool_mode = transaction
max_client_conn = 2000 ; client connections PgBouncer accepts
default_pool_size = 20 ; real server connections per db/user pair
max_prepared_statements = 100
# settings.py: Django talks to PgBouncer, not to PostgreSQL directly
DATABASES["default"].update({
"PORT": "6432",
"CONN_MAX_AGE": 60, # cheap: this is a PgBouncer connection
"CONN_HEALTH_CHECKS": True,
"DISABLE_SERVER_SIDE_CURSORS": True, # .iterator() must not use named cursors
})
PgBouncer'da uchta rejim bor:
| Rejim | Server ulanishi klientga qachon beriladi | Session holati | Samaradorlik |
|---|---|---|---|
session |
Klient ulanib turgan butun vaqtga | To'liq saqlanadi | Past: Django pool'idan deyarli farqi yo'q |
transaction |
Faqat bitta transaction davomida | Saqlanmaydi | Yuqori: odatiy tanlov |
statement |
Bitta statement uchun | Saqlanmaydi, ko'p statement'li transaction ishlamaydi | Django uchun yaroqsiz |
Transaction mode'da Django ulanishi PgBouncer'ga bo'lgani uchun arzon, shu sababli bu yerda CONN_MAX_AGE bemalol ishlatiladi.
Transaction mode'ning cheklovlari
Transaction mode'ning asosiy qoidasi: ikki transaction orasida siz boshqa server ulanishiga tushishingiz mumkin. Demak, session darajasidagi har qanday holat ishonchsiz bo'lib qoladi.
Transaction mode'da ishonchli narsa faqat bitta transaction ichida yashaydigan narsa. Qolgan hammasi, ya'ni
SET, advisory lock, temp table,LISTEN, keyingi so'rovda boshqa ulanishda qolib ketishi mumkin.
Django autocommit rejimida ishlaydi, ya'ni atomic() tashqarisidagi har bir so'rov o'zi alohida transaction. Klassik xato:
from django.db import connection
from orders.models import Order
# WRONG behind PgBouncer in transaction mode
def heavy_report():
with connection.cursor() as cur:
cur.execute("SET statement_timeout = '2s'")
# autocommit: the SET has already finished its own transaction,
# the next query may go to a different server connection
return list(Order.objects.filter(status="paid").values("id", "amount"))
SET boshqa server ulanishida qolib ketishi mumkin, eng yomoni, u o'sha ulanishni keyin oladigan boshqa so'rovga ham ta'sir qiladi. To'g'ri variant:
from django.db import connection, transaction
from orders.models import Order
# RIGHT: SET LOCAL lives exactly as long as the transaction
def heavy_report():
with transaction.atomic():
with connection.cursor() as cur:
cur.execute("SET LOCAL statement_timeout = '2s'")
return list(Order.objects.filter(status="paid").values("id", "amount"))
# Same idea for advisory locks: transaction-level, not session-level
def charge_once(order_id: int) -> None:
with transaction.atomic():
with connection.cursor() as cur:
cur.execute("SELECT pg_advisory_xact_lock(%s)", [order_id])
... # the lock is released automatically on COMMIT/ROLLBACK
Boshqa cheklovlar:
- Server-side cursor'lar.
QuerySet.iterator()PostgreSQL'da nomlangan cursor ochadi. Autocommit'da DjangoWITH HOLDcursor ishlatadi, u transaction'dan keyin ham yashaydi va boshqa ulanishga tushib qolishi mumkin. Shuning uchunDISABLE_SERVER_SIDE_CURSORS = Trueqo'yiladi. Shundaiterator()natijani psycopg orqali bo'lib-bo'lib olmaydi, lekin baribir xotirani tejaydi, chunki model obyektlari bo'laklab yaratiladi. - Prepared statement'lar. Django psycopg 3 bilan standart holatda client-side binding ishlatadi: parametrlar so'rov matniga klient tomonida qo'yiladi, server tomonida prepared statement yaratilmaydi. Agar
OPTIONSda"server_side_binding": Trueqo'ysangiz, psycopg statement'larni serverda prepare qila boshlaydi va bu transaction mode bilan muammo tug'diradi. PgBouncer 1.21'dan boshlab protocol darajasidagi prepared statement'larnimax_prepared_statementsorqali kuzatib boradi, lekin SQL darajasidagiPREPARE/EXECUTEhamon ishlamaydi. Eng xavfsizi: server-side binding'ni o'chiq qoldirish. LISTEN/NOTIFY, temp table'lar,pg_advisory_lock(session versiyasi) transaction mode orqali ishonchli ishlamaydi. Bunday narsalar uchun PgBouncer'dan o'tmaydigan alohida, to'g'ridan-to'g'ri ulanish ishlating.- Migratsiyalar. Ular uzoq lock'lar va
SETishlatishi mumkin. Ko'pchilikmigrateni to'g'ridan-to'g'ri PostgreSQL'ga (5432) ulanib bajaradi.
ASGI va async'da pool
Django'ning async view'larida ORM chaqiruvlari ichkarida sync_to_async orqali thread'da bajariladi. Django hujjatlari ASGI ostida persistent ulanishlarni (CONN_MAX_AGE) o'chirishni va o'rniga pool ishlatishni tavsiya qiladi: async muhitda ulanishning qaysi thread'da qolib ketishini nazorat qilish qiyin va ular yopilmay to'planib qolishi mumkin.
# views.py: async view, ORM behind a pool
from django.http import JsonResponse
from orders.models import Order
async def my_orders(request):
user = await request.auser()
orders = [
{"id": o.id, "amount": str(o.amount)}
async for o in Order.objects.filter(user=user).order_by("-id")[:20]
]
return JsonResponse({"orders": orders})
ASGI uchun amaliy sxema:
CONN_MAX_AGE = 0vaOPTIONS["pool"]yoki tashqi PgBouncer.max_sizeni event loop'dagi parallel so'rovlar soniga emas, bazaga parallel murojaatlar soniga qarab tanlang. Bitta uvicorn jarayoni yuzlab so'rovni ushlab turishi mumkin, lekin ular bir vaqtda bazaga murojaat qilsa, pool to'lib,PoolTimeoutchiqadi. Bu yaxshi: bazani himoya qiladigan backpressure.- Uzoq ishlaydigan stream yoki websocket handler'ida ulanishni butun sessiya davomida ushlab turmang.
max_connections hisobi
Endi asosiy savol: qancha ulanish kerak?
SHOW max_connections;
SHOW superuser_reserved_connections;
-- who is holding connections right now
SELECT usename, application_name, state, count(*)
FROM pg_stat_activity
WHERE backend_type = 'client backend'
GROUP BY usename, application_name, state
ORDER BY count(*) DESC;
Hisoblash uchun hamma iste'molchilarni yozib chiqing:
| Iste'molchi | Formula |
|---|---|
| Web (CONN_MAX_AGE) | pod'lar × worker'lar × thread'lar |
| Web (Django pool) | pod'lar × worker'lar × max_size |
| Celery | worker'lar × concurrency |
| PgBouncer orqali | default_pool_size × (db, user) juftliklari soni |
| Boshqalar | migrate, cron, admin/psql, monitoring, replikatsiya |
Yig'indiga zaxira qo'shing va max_connections - superuser_reserved_connectionsdan oshmasligini tekshiring. PostgreSQL 16'da qo'shimcha reserved_connections parametri ham bor, u pg_use_reserved_connections roli uchun joy ajratadi.
Muhim kuzatuv: max_connectionsni shunchaki 1000 ga ko'tarish yechim emas. Har bir backend xotira oladi, work_mem esa har bir operatsiya uchun alohida ajratiladi. Bundan tashqari, CPU yadrolari sonidan ancha ko'p bir vaqtda aktiv so'rov bazani tezlashtirmaydi. Ko'pincha kichik pool va navbat katta pool'dan tezroq ishlaydi. Buni ham pgbenchning -c qiymatini oshirib, tps va latency'ni kuzatib o'lchash mumkin.
Har bir iste'molchini ajratib ko'rish uchun application_name qo'ying:
DATABASES["default"]["OPTIONS"] = {
"application_name": "shop-web", # shows up in pg_stat_activity
"pool": {"min_size": 2, "max_size": 8, "timeout": 10},
}
Production'da uchraydigan tuzoqlar
- Celery. Celery'ning Django integratsiyasi task'lar atrofida
close_old_connectionsni chaqiradi vaCONN_MAX_AGEga amal qiladi. Lekinconcurrency=16bo'lsa, bu 16 ta ulanish. Ularni hisobga qo'shishni unutmang. - Fork'dan oldin ulanish. gunicorn
--preloadbilan ilovani master jarayonda yuklaydi. Agar import paytida bazaga murojaat bo'lsa, ulanish yoki pool fork'dan keyin bir nechta worker'da bo'linib qoladi. Import paytida ORM chaqirmang. - Ochiq qolgan transaction'lar.
idle in transactionholatidagi ulanish pool'dagi joyni ham, PgBouncer'dagi server ulanishini ham band qiladi.idle_in_transaction_session_timeoutni sozlang. - Ikki qavatli pool. Django pool + PgBouncer birga ishlashi mumkin, lekin ikki joyda limit bo'ladi. Ulardan qaysi biri navbat hosil qilayotganini bilish uchun ikkalasini ham monitoring qiling (
SHOW POOLS;PgBouncer admin konsolida). - Uzoq so'rovlar. Transaction mode'da 30 soniyalik hisobot so'rovi 30 soniya davomida bitta server ulanishini egallaydi. Og'ir hisobotlarni alohida pool yoki replikaga yo'naltiring.
Checklist
- Ulanish narxini
pgbench -Cbilan o'z muhitingizda o'lchang. - Oddiy sync loyiha:
CONN_MAX_AGE = 60+CONN_HEALTH_CHECKS = True. - Ko'p thread yoki ASGI, Django 5.1+:
OPTIONS["pool"],CONN_MAX_AGE = 0,min_sizeni kichik qoldiring. - Ko'p pod va jarayon: PgBouncer transaction mode,
DISABLE_SERVER_SIDE_CURSORS = True. - Transaction mode'da:
SET LOCAL,pg_advisory_xact_lock, server-side binding o'chiq. migratevaLISTEN/NOTIFYuchun to'g'ridan-to'g'ri ulanish.- Barcha iste'molchilarni jadvalga yozib,
max_connectionsdan oshmasligini tekshiring. application_nameqo'ying vapg_stat_activityni kuzatib boring.
Xulosa
PostgreSQL ulanishi bu arzon resurs emas, alohida jarayon. CONN_MAX_AGE handshake'larni yo'qotadi, Django 5.1'dagi psycopg pool bitta jarayon ichida ulanishlarni bo'lishadi, PgBouncer esa ularni butun klaster bo'ylab bo'lishadi. Qaysi birini tanlashdan qat'i nazar, avval barcha ulanish iste'molchilarini sanab chiqing: "too many clients" xatosi deyarli har doim hisob-kitobsiz scale qilishdan kelib chiqadi.
// izohlar
Izohlar yuklanmoqda...