Barcha yozuvlar
Dasturlash

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:

  1. TCP handshake, agar TLS yoqilgan bo'lsa, TLS handshake ham.
  2. Autentifikatsiya: scram-sha-256 bo'lsa, bir necha marta xabar almashinuvi va hisoblash.
  3. postmaster yangi backend jarayonini fork() qiladi.
  4. 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 yoshi CONN_MAX_AGEdan oshgan bo'lsa yoki xatolik holatida bo'lsa, u yopiladi.
  • CONN_MAX_AGE = None cheksiz degani: ulanish worker o'lguncha yashaydi.
  • CONN_HEALTH_CHECKS = True bo'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": True standart sozlamalar bilan pool yaratadi, dict esa psycopg_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_size ulanishlar band bo'lsa, yangi so'rov timeout soniyagacha kutadi, keyin PoolTimeout xatosi chiqadi. Bu xato foydali: u ulanishlar yetishmayotganini PostgreSQL'ning "too many clients" xatosidan ancha oldin, ilova darajasida ko'rsatadi.
  • Pool'ni CONN_MAX_AGE bilan 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 Django WITH HOLD cursor ishlatadi, u transaction'dan keyin ham yashaydi va boshqa ulanishga tushib qolishi mumkin. Shuning uchun DISABLE_SERVER_SIDE_CURSORS = True qo'yiladi. Shunda iterator() 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": True qo'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'larni max_prepared_statements orqali kuzatib boradi, lekin SQL darajasidagi PREPARE/EXECUTE hamon 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 SET ishlatishi mumkin. Ko'pchilik migrateni 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 = 0 va OPTIONS["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, PoolTimeout chiqadi. 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 va CONN_MAX_AGEga amal qiladi. Lekin concurrency=16 bo'lsa, bu 16 ta ulanish. Ularni hisobga qo'shishni unutmang.
  • Fork'dan oldin ulanish. gunicorn --preload bilan 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 transaction holatidagi 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 -C bilan 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.
  • migrate va LISTEN/NOTIFY uchun to'g'ridan-to'g'ri ulanish.
  • Barcha iste'molchilarni jadvalga yozib, max_connectionsdan oshmasligini tekshiring.
  • application_name qo'ying va pg_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...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯