JavaScript Full-stackNginx: load balancing va proxycache
JavaScript Full-stack · 33-qism. Linux, server, Docker

Nginx: load balancing va proxy_cache

19 daqiqa25/38-dars

Qisqacha: upstream ga ikkinchi server qo'shilsa, Nginx so'rovlarni nusxalarga bo'lib beradi. Sukut — round-robin (navbat bilan). Lekin kurs o'lchovida 10 so'rovning 10 tasi ham birinchi serverga ketdi. Sabab: zone siz har Nginx worker o'z navbatini alohida saqlaydi. zone vazifalar_api 64k bilan — 5/5. Bitta nusxa to'xtasa, max_fails va keyingi serverga o'tish tufayli mijoz xato ko'rmadi. proxy_cache og'ir GET javobini keshlaydi: MISS 4.2 ms → HIT 0.6 ms, API o'chiq bo'lsa ham proxy_cache_use_stale bilan javob beradi. Xavf: API 401 javobida Cache-Control yo'q — uni keshlash mumkin bo'lib qoldi.

Bu darsda

  • API'ning ikkinchi nusxasini systemd shabloni bilan ishga tushirasiz (va kursdagi EnvironmentFile tuzog'ini ko'rasiz).
  • Round-robin, least_conn, ip_hash farqini va zone nega kerakligini o'lchov bilan tushunasiz.
  • max_fails, fail_timeout va keyingi serverga o'tishni tekshirasiz.
  • keepalive ni Node bilan sinab, natijani halol o'qiysiz.
  • proxy_cache ni sozlaysiz: kesh kaliti, eskirgan javob, nimani keshlamaslik kerak.
  • Loyiha qadamini commit qilasiz.

Oldin bilishingiz kerak: Reverse proxy, Nginx himoya, systemd, cluster va ko'p yadroli masshtablash, Load balancing.

1. Nega bu kerak?

Node bitta jarayonda bitta yadroni ishlatadi (cluster darsida ko'rgansiz). Serverda 2 yadro bo'lsa, bitta API jarayoni yarmini bo'sh qoldiradi. Ikkinchi sabab — ishonchlilik: jarayon yiqilsa yoki yangilanayotgan bo'lsa, ikkinchisi javob berib turadi.

Ikki nusxa bo'lgach, kimdir so'rovlarni ularga taqsimlashi kerak. Bu — load balancer (yuk taqsimlagich). Bizda bu vazifani Nginx bajaradi — u allaqachon API oldida turibdi.

Ikkinchi mavzu — proxy_cache. Ba'zi javoblar hamma uchun bir xil va kam o'zgaradi (masalan, API hujjati). Ularni har safar Node'dan so'rash shart emas: Nginx bir marta oladi va diskdan beradi.

flowchart LR
  B["Mijoz"] --> N["Nginx"]
  N --> K[("proxy_cache")]
  N -->|"navbat bilan"| A1["API :3000"]
  N -->|"navbat bilan"| A2["API :3001"]
  A1 --> P[("PostgreSQL")]
  A2 --> P

Rasmda ikki API nusxasi bitta bazaga ulangan. Shuning uchun ular "almashinuvchan": istalgani istalgan so'rovga javob bera oladi. Sessiya ham bazada (cookie + server sessiyasi, 28-qism) — mijozni bitta nusxaga "bog'lab" qo'yish kerak emas.

2. Ikkinchi nusxa: systemd shabloni

2.1 Shablon unit

systemd darsidagi vazifalar-api.service bitta nusxa uchun. Bir nechta nusxa uchun systemd'da shablon (template) bor: nomida @ bo'lgan fayl. vazifalar-api@3001.service ishga tushirilsa, fayl ichidagi %i o'rniga 3001 qo'yiladi.

Kurs tajribasida shablon mavjud unit'dan sed bilan yasaldi. Birinchi g'oya — portni Environment= bilan berish:

ini
EnvironmentFile=/etc/vazifalar-api/env
Environment=PORT=%i

2.2 Biz shunday xato qildik: port bosildi

Nusxa ishga tushirildi va portlar tekshirildi:

bash
systemctl start vazifalar-api@3001
ss -tlnp | grep -E ":300[01]" | awk "{print \$4}"
text
127.0.0.1:3000

Faqat 3000! Ikkinchi nusxa ko'tarilmadi. Uning jurnalida:

bash
journalctl -u vazifalar-api@3001 -o cat --no-pager \
  | grep -o "EADDRINUSE[^\"]*" | head -1
text
EADDRINUSE: address already in use 127.0.0.1:3000

Ikkinchi nusxa ham 3000 ni egallamoqchi bo'ldi. Sabab — systemd qoidasi: EnvironmentFile= dagi qiymatlar Environment= dagilarni bosadi, qaysi biri fayl ichida yuqorida yozilganidan qat'i nazar. env faylida PORT=3000 bor — u PORT=%i ni yutdi.

Tuzatish — portni ham alohida faylga, ikkinchi EnvironmentFile= sifatida. Keyingi fayl oldingisini bosadi:

ini
EnvironmentFile=/etc/vazifalar-api/env
EnvironmentFile=/etc/vazifalar-api/port-%i.env
bash
printf "PORT=3001\n" > /etc/vazifalar-api/port-3001.env
chown root:vazifalar /etc/vazifalar-api/port-3001.env
chmod 640 /etc/vazifalar-api/port-3001.env
systemctl daemon-reload && systemctl start vazifalar-api@3001
ss -tln | grep -oE "127.0.0.1:300[01]" | sort -u | tr "\n" " "
text
127.0.0.1:3000 127.0.0.1:3001

Endi ikkala nusxa ham tinglayapti. Kanon buyrug'i bitta uzun qator edi, bu yerda qadamlarga bo'lindi. Shablon faqat tajriba uchun — loyihada u yo'q. Keyingi darsda ikki nusxani PM2 boshqaradi.

3. Upstream'ga ikkinchi server

3.1 Konfiguratsiya va log

Ikkinchi server upstream ga qo'shildi:

nginx
upstream vazifalar_api {
    zone vazifalar_api 64k;
    server 127.0.0.1:3000 max_fails=3 fail_timeout=10s;
    server 127.0.0.1:3001 max_fails=3 fail_timeout=10s;
    keepalive 16;
}

So'rov qaysi nusxaga ketganini ko'rish uchun alohida access log formati qo'shildi:

nginx
log_format upstream_log "$remote_addr $request $status "
    "up=$upstream_addr ut=$upstream_response_time "
    "rt=$request_time";

Kanonda bu bitta satr edi. log_format bir nechta satrni ketma-ket ulaydi, shuning uchun telefon uchun uchga bo'lindi — mazmuni o'sha.

  • $upstream_addr — so'rov uzatilgan server (bir nechta bo'lsa — vergul bilan).
  • $upstream_response_time (ut) — API javob vaqti, soniyada.
  • $request_time (rt) — butun so'rov vaqti: mijoz bilan gaplashish ham kiradi.

Access log formati — Nginx'ning eng foydali tashxis vositalaridan biri. rt katta-yu, ut kichik bo'lsa — sekinlik API'da emas, mijoz tomonda yoki Nginx'da. Ikkalasi ham katta bo'lsa — API sekin.

3.2 Biz shunday xato qildik: 10 dan 10 tasi bitta serverga

Round-robin — "navbat bilan: biri sizga, biri unga". 10 so'rov yuborildi va log sanaldi. Bu o'lchov zone qatorisiz konfiguratsiyada edi (kanonning birinchi versiyasida u yo'q edi):

bash
: > /var/log/nginx/vazifalar-upstream.log
for i in $(seq 1 10); do
  curl -s -o /dev/null https://vazifalar.lokal/v1/vazifalar
done
grep -o "up=[0-9.:]*" /var/log/nginx/vazifalar-upstream.log \
  | sort | uniq -c
text
zone YO Q, 10 ta yangi ulanish:
     10 up=127.0.0.1:3000

Hammasi 3000 ga! 3001 ishlab turibdi, lekin bitta ham so'rov olmadi. Keyin xuddi shu 6 so'rov bitta curl buyrug'i bilan, ya'ni bitta ulanishda yuborildi:

text
zone YO Q, BITTA ulanishda 6 so rov (bitta worker):
      3 up=127.0.0.1:3000
      3 up=127.0.0.1:3001

Bitta ulanishda — 3/3, navbat ishladi. Demak, muammo ulanishlarda.

Sabab Nginx tuzilishida. Nginx bitta master va bir nechta worker (ishchi) jarayonidan iborat. O'quv serverida worker_processes auto 16 ta worker ochgan edi (Nginx asoslari). Har worker o'z xotirasida o'z round-robin hisoblagichini saqlaydi va har biri birinchi serverdan boshlaydi. Har curl yangi ulanish ochadi, u esa odatda boshqa worker'ga tushadi. 10 ta yangi ulanish — 10 xil worker, har biri birinchi marta tanlaydi — hammasi 3000.

zone direktivasi upstream holatini barcha worker'lar umumiy xotirasiga ko'chiradi. Hisoblagich bitta bo'ladi:

text
zone BILAN, 10 ta yangi ulanish:
      5 up=127.0.0.1:3000
      5 up=127.0.0.1:3001

5/5. zone kanonga kiritildi. Yuqoridagi chiqishlardagi "YO Q", "so rov" — o'lchov skriptining yorliqlari, apostrof qo'shtirnoq ichida bash'ni buzmasligi uchun tushirib qoldirilgan.

Uchala holatni model bilan takrorlaymiz. Model'da "worker" — ulanish tushgan worker raqami:

js
const SERVERLAR = ["127.0.0.1:3000", "127.0.0.1:3001"];

// zone yo'q: har worker o'z hisoblagichi; zone bor: bitta umumiy
function balanser(zone) {
  const workerlar = new Map();
  let umumiy = 0;
  return (worker) => {
    const n = zone ? umumiy++ : (workerlar.get(worker) ?? 0);
    if (!zone) workerlar.set(worker, n + 1);
    return SERVERLAR[n % SERVERLAR.length];
  };
}

function sina(nom, zone, workerlar) {
  const tanla = balanser(zone);
  const soni = {};
  for (const w of workerlar) {
    const s = tanla(w);
    soni[s] = (soni[s] ?? 0) + 1;
  }
  console.log(nom.padEnd(32), JSON.stringify(soni));
}

const yangiUlanishlar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
sina("zone yo'q, 10 yangi ulanish", false, yangiUlanishlar);
sina("zone yo'q, 1 ulanishda 6 so'rov", false, [3, 3, 3, 3, 3, 3]);
sina("zone bor, 10 yangi ulanish", true, yangiUlanishlar);

Konsolda:

text
zone yo'q, 10 yangi ulanish      {"127.0.0.1:3000":10}
zone yo'q, 1 ulanishda 6 so'rov  {"127.0.0.1:3000":3,"127.0.0.1:3001":3}
zone bor, 10 yangi ulanish       {"127.0.0.1:3000":5,"127.0.0.1:3001":5}

Model uchala haqiqiy natijani takrorladi. yangiUlanishlar ni [0, 0, 1, 1, 2, 2] ga almashtirib ko'ring: har worker ikkitadan ulanish olsa, zone siz ham taqsimot teng chiqadi. Haqiqiy trafikda brauzerlar ulanishni qayta ishlatadi va worker'lar ko'p so'rov ko'radi — notekislik kamayadi. Lekin kam trafikli sayt va health-check'larda u aniq ko'rinadi.

Maslahat: zone — upstream uchun deyarli har doim kerakli qator. U yana bir narsa beradi: max_fails hisobi ham barcha worker'lar uchun umumiy bo'ladi.

4. Taqsimlash usullari

Usul Qanday tanlaydi Qachon
round-robin (sukut) navbat bilan, weight hisobga olinadi nusxalar bir xil, so'rovlar qisqa
least_conn faol ulanishi eng kam serverni uzun so'rovlar aralash (SSE, AI)
ip_hash mijoz IP'si bo'yicha doim bitta server sessiya jarayon xotirasida bo'lsa
hash $… consistent ixtiyoriy kalit bo'yicha kesh serverlari (sinalmagan)

least_conn tajribasi — natijani halol o'qish. Kurs tajribasida 3000 ga to'g'ridan (Nginx'ni chetlab) 20 ta SSE ulanishi ochildi, keyin least_conn yoqilib, 10 ta oddiy so'rov yuborildi:

text
     10 up=127.0.0.1:3000
(nginx o zi ochgan ulanishlarni sanaydi: to g ridan 3000 ga ochilgan SSE lar hisobga KIRMAYDI — 2 nusxa teng)

10 tasi ham band 3000 ga. Ikkinchi qator — kanon izohi: Nginx faqat o'zi ochgan ulanishlarni sanaydi, shuning uchun uning nazarida ikkala nusxa teng edi. Bu hujjatga mos. Lekin bu o'lchov zone qo'shilishidan oldin qilingan. "10/10" natijaning o'zi esa yuqoridagi worker tuzog'i bilan ham to'liq tushuntiriladi. Shuning uchun bu tajriba least_conn haqida hech narsani isbotlamaydi. Haqiqiy sinov sekin so'rovlarni Nginx orqali ochib, zone bilan qilinishi kerak edi — sinalmagan.

ip_hash kanonda kerak emas: sessiya bazada, istalgan nusxa javob beradi. Uning cheklovlari 2-mashqda.

5. Nusxa yiqilsa: max_fails va o'tish

max_fails=3 fail_timeout=10s — "10 soniya ichida 3 marta xato bo'lsa, serverni 10 soniyaga 'o'lik' deb hisobla". Bundan tashqari, ulanish xatosida Nginx so'rovni darhol keyingi serverga uzatadi (proxy_next_upstream, sukut — error timeout).

Kurs tajribasida 3001 to'xtatildi va 10 so'rov yuborildi:

bash
systemctl stop vazifalar-api@3001
for i in $(seq 1 10); do
  curl -s -o /dev/null -w "%{http_code} " \
    https://vazifalar.lokal/v1/vazifalar
done; echo
grep -o "up=[^ ]*" /var/log/nginx/vazifalar-upstream.log \
  | sort | uniq -c
text
401 401 401 401 401 401 401 401 401 401 
      8 up=127.0.0.1:3000
      2 up=127.0.0.1:3001,

Mijoz 10 ta to'g'ri javob oldi — xato yo'q. Logdagi ikkinchi qatorni o'qiymiz. grep bo'sh joygacha kesgan, aslida qator up=127.0.0.1:3001, 127.0.0.1:3000 edi. Vergul — "avval 3001 ga urindim, keyin 3000 ga". Ikki so'rov o'lik nusxaga tushdi, ulanish rad etildi va Nginx o'sha so'rovni o'zi 3000 ga o'tkazdi. Keyingi so'rovlar 3001 ga umuman bormadi.

Diqqat: Keyingi serverga o'tish faqat xavfsiz holatlarda avtomatik. Nginx so'rov tanasini allaqachon yuborgan bo'lsa, POST kabi idempotent bo'lmagan so'rovlarni boshqa serverga takrorlamaydi (hujjatga ko'ra 1.9.13 dan; tekshirildi, 2026-11). Shunday bo'lmasa, bitta vazifa ikki marta yaratilishi mumkin edi (Idempotency-Key).

6. keepalive: Node bilan ulanishni qayta ishlatish

Nginx har so'rov uchun Node'ga yangi TCP ulanish ochsa, ulanish ochish va yopish xarajati bor. Yopilgan ulanish esa bir muddat TIME_WAIT holatida osilib turadi. keepalive 16 — har worker 16 tagacha bo'sh ulanishni keyingi so'rovlar uchun saqlaydi. Buning uchun snippet'dagi ikki qator shart edi: proxy_http_version 1.1 va proxy_set_header Connection "" (Reverse proxy).

O'lchov: ab bilan 2000 so'rov, bir vaqtda 20 ta, keepalive bilan va usiz:

keepalive 16 So'rov/s TIME_WAIT (3000/3001)
bor 18 071 39
yo'q 19 909 73

Natijani halol o'qiymiz. TIME_WAIT ulanishlar ikki baravar kam — ulanishlar qayta ishlatilyapti. Lekin tezlik oshmadi: keepalive'siz hatto biroz tezroq chiqdi. Bu bitta o'lchov, bitta mashinada, farq shovqin ichida. Bundan tashqari, javoblar 401 edi — juda kichik va arzon. Keepalive foydasi uzoq tarmoq, TLS'li upstream yoki ulanish ochish qimmat bo'lgan holatda ko'rinadi. Yana bir sabab o'lchovdan keyin, hujjatni tekshirganda topildi. nginx hujjatiga ko'ra (2026-11) 1.29.7 versiyadan upstream keepalive sukut bo'yicha yoqilgan: keepalive 32 local. Kanon "yo'q" variantida keepalive 16 qatorini izohga aylantirgan edi. O'quv serveridagi 1.30.6 da bu keepalive'ni o'chirmaydi — sukutdagi 32 ta ulanish ishlayveradi. Demak, ikkala o'lchovda ham keepalive bor bo'lgan bo'lishi mumkin; TIME_WAIT farqi esa local rejimi tufayli ham chiqishi mumkin. Bu taxmin sinalmagan. Butunlay o'chirish uchun hujjat keepalive 0; ni ko'rsatadi.

Kanon keepalive 16 ni qoldirdi: zarari yo'q, resurs tejaydi va eski nginx'da 1.24-bob ham ishlaydi. Lekin "keepalive tezlashtiradi" degan da'voni bu o'lchov tasdiqlamadi.

7. proxy_cache

7.1 Sozlash

Keshlashni sinash uchun alohida sinov serveri yozildi (asosiy saytga tegmaslik uchun). Kanon uni bitta printf bilan yozgan, bu yerda o'qish uchun fayl ko'rinishida:

nginx
proxy_cache_path /var/cache/nginx/vazifalar levels=1:2
    keys_zone=vz_kesh:10m max_size=100m inactive=10m
    use_temp_path=off;

server {
  listen 127.0.0.1:8082;
  location = /docs-json {
    proxy_pass http://vazifalar_api;
    proxy_http_version 1.1;
    proxy_set_header Connection "";
    proxy_cache vz_kesh;
    proxy_cache_valid 200 1m;
    proxy_cache_use_stale error timeout updating;
    proxy_cache_lock on;
    add_header X-Cache-Status $upstream_cache_status always;
  }
}
Direktiva Ma'nosi
proxy_cache_path kesh diskda qayerda; keys_zone — kalitlar xotirada (10 MB), max_size — disk chegarasi
inactive=10m 10 daqiqa so'ralmagan yozuv o'chiriladi
proxy_cache_valid 200 1m 200 javob 1 daqiqa yangi hisoblanadi
proxy_cache_use_stale API xato bersa yoki yangilanayotgan bo'lsa — eskirgan nusxani ber
proxy_cache_lock on bir vaqtda kelgan bir xil so'rovlardan faqat bittasi API'ga boradi
X-Cache-Status javobga MISS/HIT/STALE yozuvi — tekshirish uchun

proxy_cache_lock — kesh stampede muammosining Nginx'dagi yechimi: kesh bo'shaganda yuzta bir xil so'rov bir vaqtda API'ga yopirilmaydi.

Kesh kaliti sukut bo'yicha $scheme$proxy_host$request_uri — sxema, upstream va to'liq URL (so'rov parametrlari bilan) (proxy_cache_key hujjati, 2026-11 da tekshirildi). E'tibor bering: kalitda cookie yo'q. Ikki foydalanuvchining bir xil URL'i — bitta kesh yozuvi. Shuning uchun shaxsiy javoblar umuman keshga tushmasligi kerak (pastda).

7.2 O'lchov

/docs-json — API'ning OpenAPI hujjati (20 770 bayt), hamma uchun bir xil. Uch marta so'raldi:

text
X-Cache-Status: MISS   vaqt 0.004153s 
X-Cache-Status: HIT   vaqt 0.000619s 
X-Cache-Status: HIT   vaqt 0.000628s 

Birinchisi — MISS (keshda yo'q, API'dan olindi), keyingilari — HIT (diskdagi nusxa). Nisbat bilan:

/docs-json javob vaqti (MISS = 100 %)
  • MISS (API'dan)100 %
  • HIT, 2-so'rov15 %
  • HIT, 3-so'rov15 %

Manba: Kurs tajribasi (IlmHamroh, 2026-11): 4.153 / 0.619 / 0.628 ms, o'quv serveri, bitta yugurish

HIT taxminan 7 baravar tez. Mutlaq raqamlar kichik — API bu javobni ham tez beradi. Haqiqiy foyda og'ir javoblarda: bazaga murakkab so'rov, tashqi API, AI. Kesh u yerda soniyalarni millisekundga aylantiradi.

7.3 API o'chiq — kesh javob beradi

Ikkala API nusxasi to'xtatildi va yana so'raldi:

text
X-Cache-Status: HIT API o chiq: 200 

200, HIT. API umuman yo'q, foydalanuvchi esa hujjatni oldi. proxy_cache_use_stale error timeout muddati o'tgan yozuvni ham shunday holatda bera oladi — kanon izohiga ko'ra o'lchov aynan shu holatni maqsad qilgan. Lekin bu yerda muhim tafsilot: yozuv 1 daqiqalik muddat ichida ham bo'lishi mumkin edi — chiqishda HIT, STALE emas. Ya'ni bu o'lchov aynan "eskirgan javob" mexanizmini emas, "kesh API'siz ishlaydi" faktini ko'rsatdi. STALE holatini ko'rish uchun 1 daqiqadan ko'proq kutib so'rash kerak edi — sinalmagan.

7.4 Biz shunday xato qilishimiz mumkin edi: 401 keshlandi

Sinov serverida /v1/ uchun ham kesh yoqildi, ataylab proxy_cache_valid 200 401 1m bilan. Sessiyasiz so'rov ikki marta:

text
HTTP/1.1 401 Unauthorized X-Cache-Status: MISS 
HTTP/1.1 401 Unauthorized X-Cache-Status: HIT 

Ikkinchi 401 keshdan keldi! Sabab — API javoblaridagi sarlavhalar:

text
200 (sessiya bilan): cache-control: private, no-cache
401 (sessiyasiz): 0 ta Cache-Control

Muvaffaqiyatli /v1 javobida API private, no-cache yuboradi — Nginx uni keshlamaydi (private — "faqat brauzer keshi"). 401 javobida esa Cache-Control umuman yo'q. Bu holda Nginx proxy_cache_valid qoidasiga amal qiladi va keshlaydi. Oqibat: foydalanuvchi tizimga kirgandan keyin ham bir daqiqa davomida eski "401" ni ko'rishi mumkin.

Kanon nginx konfiguratsiyasida /v1/ uchun kesh yo'q — bu xavf hozir yo'q. Lekin API tomonidagi bo'shliq qoldi: 401 javoblari Cache-Control: no-store siz. Bu keyingi qismning ishlar ro'yxatiga yozildi. Qoida: shaxsiy ma'lumotli yo'llarga umumiy proxy keshini qo'ymang. Qo'ysangiz — proxy_cache_bypass va proxy_no_cache bilan sessiya cookie'si bor so'rovlarni chetlab o'ting (sinalmagan, 2026-11).

Tekshirib ko'ring: /v1/vazifalar?limit=10 uchun proxy_cache yoqildi, proxy_cache_valid 200 1m, API esa Cache-Control yubormaydi deylik. Aziz kirib, ro'yxatini ochdi. Bir soniyadan keyin Malika xuddi shu URL'ni ochdi. U nima ko'radi?

Javob

Azizning vazifalarini. Kesh kalitida URL bor, cookie yo'q — ikkala so'rov bitta kesh yozuvi. Bu shaxsiy ma'lumot oqishi. Shuning uchun kanon API'si har shaxsiy javobga private qo'yadi, kanon nginx'i esa /v1/ ni keshlamaydi.

8. Loyiha qadami: commit

To'rt dars davomida (Reverse proxydan boshlab) yig'ilgan o'zgarishlar endi bitta commit bo'ladi:

Fayl Nima
deploy/nginx/vazifalar.conf upstream (+zone, keepalive), limitlar, HTTP → HTTPS, TLS, gzip, /v1/, SSE, auth, /health/, statik qism, SPA
deploy/nginx/snippets/vazifalar-proxy.conf uzatish sarlavhalari, timeoutlar
deploy/nginx/snippets/vazifalar-sarlavhalar.conf HSTS, nosniff, Referrer-Policy, CSP
src/umumiy/log.ts, test/log.test.ts logda mijozning haqiqiy IP'si + regressiya testi

Loyihadagi upstream da bitta server qoladi (__API__). Ikkinchi nusxa o'rnatish usuliga bog'liq — keyingi darsda PM2 bitta portda ikki jarayonni o'zi ochadi. proxy_cache loyihaga kiritilmadi — keshlanadigan og'ir umumiy yo'l hozircha yo'q.

Kanon tekshiruvi (loyihaning shu bosqichi): tiplar 0, lint 0, Vitest 347 o'tdi + 1 o'tkazib yuborildi, e2e 10/10, build 0. Commit:

bash
git add deploy/nginx src/umumiy/log.ts test/log.test.ts
git commit

Muharrir ochiladi. Kanon commit xabari (bitta qator):

text
feat(deploy): nginx — reverse proxy, SPA, kesh va xavfsizlik sarlavhalari, limitlar, upstream zone; fix(log): so'rov logida haqiqiy mijoz IP'si (trust proxy)

Xabar uzun, chunki to'rt darsning ishi bitta commit'da. Jamoada bularni ikkiga bo'lish yaxshiroq: feat(deploy) va fix(log) alohida. Shunda sarlavha 72 belgiga sig'adi va fix reliz yozuviga alohida tushadi (Conventional Commits).

9. Ko'p uchraydigan xatolar

9.1 zone siz upstream

Kam trafikda taqsimot notekis, max_fails hisobi har worker'da alohida. zone <nom> 64k; qo'shing.

9.2 Environment= bilan EnvironmentFile= dagi qiymatni bosishga urinish

Fayldagi qiymat yutadi. Nusxaga xos qiymatni ikkinchi EnvironmentFile= yoki unit'ning drop-in faylida bering.

9.3 Nusxalar holatni xotirada saqlasa

Sessiya, yuklangan fayl yoki kesh jarayon xotirasida bo'lsa, ikkinchi nusxa uni ko'rmaydi. Holat — bazada, Redis'da yoki obyekt omborida (Masshtablash).

9.4 Shaxsiy javoblarni keshlash

Kesh kalitida cookie yo'q. /v1/ ga proxy_cache qo'yishdan oldin har javobning Cache-Control ini tekshiring.

9.5 Bitta o'lchovdan xulosa

Keepalive o'lchovi tezlikni ko'rsatmadi, least_conn o'lchovi hech narsani isbotlamadi. O'lchovni kamida takrorlang va boshqa omillarni (bu yerda — zone) ajrating.

10. Mashqlar

Mashqlar kurs/mashqlar/33/25-balans/ da. 2-mashq yechimi Node 24.21.0 da, 3-mashq yechimi Bash'da (Git Bash, GNU awk) tekshirilgan (biz ishga tushirdik).

1-mashq (oson): bo'shliqlarni to'ldiring

  • Upstream holatini barcha worker'lar uchun umumiy qiladigan direktiva —
  • Faol ulanishi eng kam serverni tanlaydigan usul —
  • Keshdan kelgan javobda $upstream_cache_status qiymati —
  • API o'chiq bo'lsa ham keshdagi javobni beradigan direktiva — proxy_cache_use_
  • systemd shablon unit nomidagi belgi — vazifalar-api .service
Yechim
  • zone — usiz har worker o'z navbatini saqlaydi.
  • least_conn — Nginx o'zi ochgan ulanishlarni sanaydi.
  • HIT — MISS'dan keyin.
  • stale — error timeout updating.
  • @ — %i o'rniga @ dan keyingi qism qo'yiladi.

2-mashq (o'rta): ip_hash modeli

ip_hash mijozni IP bo'yicha doim bitta serverga yuboradi. nginx hujjatiga ko'ra IPv4 manzilning faqat birinchi uch okteti hisobga olinadi (IPv6 da — butun manzil; tekshirildi, 2026-11). ipHash(ip, serverlar) funksiyasini yozing. U uch oktetdan son yasasin va serverlar soniga bo'lgandagi qoldiq bo'yicha tanlasin. Bu nginx'ning haqiqiy xesh funksiyasi emas — model. Beshta IP bilan sinang, keyin bitta serverni ro'yxatdan olib tashlab qayta hisoblang. Ishora: split, map(Number), destrukturizatsiya, %.

Yechim
js
const SERVERLAR = ["A (3000)", "B (3001)", "C (3002)"];

function ipHash(ip, serverlar) {
  const [a, b, c] = ip.split(".").map(Number); // 4-oktet kirmaydi
  const kalit = (a * 256 + b) * 256 + c;
  return serverlar[kalit % serverlar.length];
}

const ipLar = ["203.0.113.7", "203.0.113.99", "198.51.100.4",
  "192.0.2.55", "192.0.3.55"];
for (const ip of ipLar) {
  console.log(ip.padEnd(13), "→", ipHash(ip, SERVERLAR));
}
console.log("C o'chirilsa:");
const ikkita = SERVERLAR.slice(0, 2);
for (const ip of ipLar) {
  console.log(ip.padEnd(13), "→", ipHash(ip, ikkita));
}

Konsolda:

text
203.0.113.7   → B (3001)
203.0.113.99  → B (3001)
198.51.100.4  → B (3001)
192.0.2.55    → C (3002)
192.0.3.55    → A (3000)
C o'chirilsa:
203.0.113.7   → B (3001)
203.0.113.99  → B (3001)
198.51.100.4  → A (3000)
192.0.2.55    → A (3000)
192.0.3.55    → B (3001)

Ikki xulosa. Birinchi: 203.0.113.7 va 203.0.113.99 — bir xil /24 tarmoq, doim bitta server. Butun bir ofis yoki mobil operatorning NAT'i ortidagi minglab foydalanuvchi bitta nusxaga tushadi. Ikkinchi: bitta server o'chirilganda, uning mijozlaridan tashqari boshqalar ham ko'chdi (198.51.100.4, 192.0.3.55). Xotiradagi sessiyalar yo'qoladi. Hujjat shuning uchun vaqtincha o'chiriladigan serverni ro'yxatdan olmay, down deb belgilashni tavsiya qiladi (tekshirildi, 2026-11). Kanon ip_hash ishlatmaydi — sessiya bazada.

3-mashq (qiyin): upstream logini tahlil qilish

Namunaviy log darsdagi upstream_log formatiga o'xshaydi, faqat so'rov o'rnida $uri. awk bilan har upstream uchun so'rovlar sonini va o'rtacha javob vaqtini (ms) chiqaring. up= da vergul bo'lsa (keyingi serverga o'tilgan), bu qatorni alohida sanang. Ishora: match($0, /up=[^ ]+/) va substr (RSTART, RLENGTH); natijani sort qiling.

Yechim
bash
cat > upstream.log <<'X'
/v1/vazifalar 401 up=127.0.0.1:3000 ut=0.004
/v1/vazifalar 401 up=127.0.0.1:3001 ut=0.006
/v1/vazifalar 401 up=127.0.0.1:3000 ut=0.002
/v1/vazifalar 401 up=127.0.0.1:3001, 127.0.0.1:3000 ut=0.000, 0.003
/v1/vazifalar 401 up=127.0.0.1:3000 ut=0.004
/docs-json 200 up=127.0.0.1:3000 ut=0.005
X
awk '
  /up=[^ ]+,/ { otish++; next }   # vergul — boshqa serverga
  {
    match($0, /up=[^ ]+/); s = substr($0, RSTART + 3, RLENGTH - 3)
    match($0, /ut=[0-9.]+/); t = substr($0, RSTART + 3, RLENGTH - 3)
    soni[s]++; jami[s] += t
  }
  END {
    for (s in soni) {
      ms = jami[s] / soni[s] * 1000
      printf "%s %d ta, o\047rtacha %.1f ms\n", s, soni[s], ms
    }
    print "keyingisiga o\047tgan:", otish
  }
' upstream.log | sort

Biz ishga tushirdik:

text
127.0.0.1:3000 4 ta, o'rtacha 3.8 ms
127.0.0.1:3001 1 ta, o'rtacha 6.0 ms
keyingisiga o'tgan: 1

next — shu qatorni qolgan qoidalarsiz tashlab, keyingisiga o'tadi. O'tish qatori o'rtacha vaqtga qo'shilmadi: unda ikki vaqt bor (0.000, 0.003) va ular ikki serverga tegishli. Haqiqiy serverda bunday tahlil "qaysi nusxa sekin?" va "o'tishlar qachon ko'paydi?" savollariga javob beradi. awk dasturi bitta tirnoq ichida — uning izohida ham apostrof yozib bo'lmaydi.

11. Real ishda

  • Bulut balanserlari (va Kubernetes servislari) shu g'oyalarning o'zi: health-check, navbat, o'lik nusxani chiqarish. Nginx'da health-check passiv (max_fails) — faol tekshiruv nginx'ning pullik obunasida (upstream hujjati, 2026-11 da tekshirildi).
  • CDN — global proxy_cache: statik va umumiy javoblarni foydalanuvchiga yaqin joyda saqlaydi.
  • Kesh tozalash (purge) bepul nginx'da yo'q — kesh muddatini qisqa qiling yoki URL'ga versiya qo'shing (sinalmagan, 2026-11).
  • Intervyu savollari: "Round-robin va least_conn farqi?", "Sticky session nima va nega undan qochish kerak?", "Proxy keshida shaxsiy ma'lumot qanday oqadi?", "proxy_cache_lock nima uchun?"

Xulosa

  • Ikki nusxa: systemd shabloni vazifalar-api@.service; EnvironmentFile= Environment= ni bosadi — port alohida faylda.
  • Round-robin zone siz: har worker o'z navbati, 10 yangi ulanish → 10/10 bitta serverga; zone bilan 5/5.
  • max_fails + keyingi serverga o'tish: nusxa o'chganda mijoz xato ko'rmadi (up=…3001, …3000).
  • least_conn va keepalive o'lchovlari xulosa bermadi — halol aytildi.
  • proxy_cache: MISS 4.2 ms → HIT 0.6 ms; API o'chiq — 200 HIT. Kalitda cookie yo'q — shaxsiy javobni keshlamang; 401 Cache-Control siz keshlandi.
  • Commit: deploy/nginx + logdagi mijoz IP'si.

Keyingi dars: PM2: Node jarayon menejeri — ikki nusxani PM2 cluster bilan yuritamiz va IPC kanali tufayli "to'xtadi" deb yozib, 20 soniya chiqmay turgan jarayonni topamiz.

Manbalar

33-qism. Linux, server, Docker · 25-dars yakunlandi

Nginx: load balancing va proxycache

19 daqvaqt
0belgi
Keyingi dars: PM2: Node jarayon menejeri
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0