QUIC Protokoli Yordamida Postgresni Optimallashtirish

Har qanday backend muhandisi Postgresni keng miqyosda ishlatish bilan tanish. Ular PgBouncer yoki PgCat kabi vositalardan foydalanishadi, transaktsiya pullini sozlashadi va backend ulanishlarni cheklashadi. Ammo, agar sizning ilovangiz yoki chekka xizmatlaringiz Postgres klasteringizdan bir necha millisekund uzoqlikda bo'lsa, sizning so'rovlaringiz hali ham transport tormoziga duch keladi.

QUIC Protokoli Yordamida Postgresni Optimallashtirish

Mening tadqiqotimda, men Postgres protokolini an'anaviy TCP o'rniga QUIC (UDP) ustida ishlatishni sinab ko'rdim. PgCatni QUIC ulanishlarini qabul qilish uchun o'zgartirdim va yuzlab virtual ma'lumotlar oqimlarini bir necha UDP assotsiatsiyalar ustida ko'paytirdim.

Natijalar hayratlanarli edi. Og'ir yukda, QUIC sozlamamiz 9,718 ta so'rovni 246 ms o'rtacha kechikish bilan bajarishga muvaffaq bo'ldi. Shunga o'xshash yuk an'anaviy TCP ustida 40,000 ta kechiktirilgan so'rov bilan qiyinchiliklarga duch keldi, o'rtacha kechikish esa 7,088 ms ga yetdi.

Postgresning Sinkronlik Muammosi

PostgreSQL frontend/backend simsiz protokoli (Protokol 3.0) asosan sinkronlikka asoslangan. Agar klient Postgres TCP ulanishiga Query yoki Execute xabarini yuborsa, u socket server tomonidan qayta ishlanish tugaguncha band bo'lib qoladi.

PostgreSQL simsiz protokolining asosi: 1 ulanish = 1 faol uchuvchi so'rov yoki transaktsiya. Klient socketi, byte'lar tarmoq kartasidan chiqguncha va oxirgi satr paketi va ReadyForQuery bayrog'i qaytguncha to'liq bloklanadi.

// Connecting tokio-postgres directly over an s2n-quic bidirectional stream
use s2n_quic::Client;
use std::net::SocketAddr;
use tokio_postgres::NoTls;

// 1. Establish or reuse the underlying QUIC UDP connection (TLS 1.3 is native)
let connect = s2n_quic::client::Connect::new(pooler_addr)
    .with_server_name("pg-pooler.internal");
let mut connection = quic_client.connect(connect).await?;

// 2. Open an independent, lightweight bidirectional stream over the single connection
// This requires NO kernel socket creation, NO 3-way handshake, and NO new file descriptor.
let stream = connection.open_bidirectional_stream().await?;

// 3. Hand the raw stream to tokio-postgres.
// Because BidirectionalStream implements AsyncRead + AsyncWrite + Unpin,
// tokio-postgres treats it as a drop-in transport stream!
let (pg_client, pg_connection) = pg_config.connect_raw(stream, NoTls).await?;

// Spawn the Postgres connection driver task in background
tokio::spawn(async move {
    if let Err(e) = pg_connection.await {
        eprintln!("Postgres connection error on stream: {}", e);
    }
});

// Execute regular synchronous query over the isolated QUIC stream
let rows = pg_client.query("SELECT id, username FROM users WHERE id = $1", &[&user_id]).await?;

Latensiya Asimmetriyasi

Zamonaviy tarqalgan arxitekturalarda, xizmatlaringiz ma'lumotlar bazasi rafigida yashamaydi. Siz chekka tugunlar, serverless ishchilar, turli mavjudlik zonalaridagi mikroservislarga ega bo'lishingiz mumkin.

Masalan, client to pooler (WAN / Inter-region) uchun round-trip time (RTT) 30 ms, pooler to Postgres (Internal LAN / Same VPC) uchun RTT 2 ms dan kam (ba'zan millisekunddan kam). Postgres ichidagi so'rov bajarish vaqti esa 0.5 ms.

QUICning Afzalliklari

QUIC protokoli TCP o'rniga ishlatilganda, ulanishlarni ko'paytirish imkonini beradi. Bu esa so'rovlarni tezroq bajarishga yordam beradi. QUICning afzalliklari quyidagilar:

// Multiplexing pool: 50 physical connections, up to 40 concurrent streams each
pub struct QuicManager {
    connections: Vec<QuicConnectionWrapper>,
    streams_per_connection: u64,
}

impl QuicManager {
    pub async fn acquire_stream(&self) -> Result<s2n_quic::stream::BidirectionalStream> {
        // Find an established QUIC connection with capacity < streams_per_connection
        for conn in &self.connections {
            if conn.active_streams.load(Ordering::Relaxed) < self.streams_per_connection {
                conn.active_streams.fetch_add(1, Ordering::Relaxed);
                return conn.connection.open_bidirectional_stream().await;
            }
        }
        // If all existing connections are saturated at 40 streams, open a new QUIC connection
        self.spawn_new_quic_connection().await
    }
}

• TCP o'rniga UDP ishlatilishi natijasida ulanishlarni ko'paytirish mumkin.
• QUICning 0-RTT (Zero Round-Trip Time) xususiyati tufayli ulanishlar tezroq o'rnatiladi.
• QUICning multiplexing xususiyati tufayli bir nechta so'rovlar bir vaqtning o'zida bajarilishi mumkin.

QUICning Cheklovlari

QUICning cheklovlari ham mavjud. Masalan, QUICni ishlatish uchun server va klientlar QUICni qo'llab-quvvatlashlari kerak. Bundan tashqari, QUICning xavfsizlik xususiyatlari ham kamroq rivojlangan.

Shu bilan birga, QUICning afzalliklari uning cheklovlarini qoplaydi. QUICning tezligi va ko'paytirish imkoniyati uni Postgres uchun ideal tanlovga aylantiradi.

Ushbu maqolada Postgres va QUIC protokolining o'rtasidagi farqlar, QUICning afzalliklari va cheklovlari tahlil qilindi. QUICning tezligi va ko'paytirish imkoniyati uni Postgres uchun ideal tanlovga aylantiradi.

Asl manba: blogs.lupyd.com