Serverless va edge funksiyalar: AWS Lambda, Vercel, Cloudflare Workers

Qisqacha: Serverless — server o'rniga funksiya joylaysiz: platforma so'rov kelganda uni ishga tushiradi, yuklama oshsa nusxalarni ko'paytiradi, ish yo'q bo'lsa to'xtatadi; pul ishlagan vaqt uchun. Narxi — sovuq start (birinchi chaqiruv sekin), vaqt va xotira limitlari va bazaga ulanishlar soni. Kanon 120 ta parallel "funksiya"ni har biri o'z Postgres ulanishi bilan ishga tushirdi — 21 tasi "too many clients" xatosini oldi.

Bu darsda

• Serverless va edge nima ekanini va oddiy serverdan farqini tushuntira olasiz.
• AWS Lambda handler'ini Hono bilan yozib, API Gateway hodisasi bilan lokal chaqirasiz.
• Sovuq va iliq start farqini o'lchov bilan bilasiz va modul darajasidagi holatdan foydalanasiz.
• Lambda, Vercel va Workers limitlarini hujjatdan o'qiy olasiz.
• Bazaga ulanish muammosini va uning yechimlarini (pooler, HTTP drayver) bilasiz.

Oldin bilishingiz kerak: Hono, PgBouncer va tashqi pooler'lar, Managed va serverless Postgres, Runtime'lar: Node va Edge.

Oldingi uch darsda runtime'larni ko'rdik: Node, Bun, Deno. Endi savol boshqacha: kodni qayerda ishlatamiz — o'z serverimizdami yoki platformaning funksiyasida?

1. Nega bu kerak?

vazifalar-api bitta VPS'da kechayu kunduz ishlaydi (33-qismda shunday joylaymiz). Kechasi so'rov yo'q — server baribir pul oladi. Ertalab foydalanuvchilar ko'paysa — server bitta, sekinlashadi.

Serverless (serversiz) — bu muammoga boshqa javob. Server, albatta, bor, lekin uni siz ko'rmaysiz va boshqarmaysiz. Siz faqat funksiya yuklaysiz. Platforma:

1. so'rov kelganda funksiyani ishga tushiradi;
2. bir vaqtda 100 so'rov kelsa — 100 nusxa ochadi;
3. ish yo'q bo'lsa — nusxalarni o'chiradi;
4. faqat ishlagan vaqt (va xotira) uchun hisob yozadi.

O'xshatish: VPS — o'z mashinangiz: ishlatmasangiz ham sug'urta, garaj puli. Serverless — taksi: faqat yurgan masofa uchun to'laysiz, lekin har safar mashina kelishini kutasiz (sovuq start) va taksi uzoq safarga bormaydi (vaqt limiti).

Next.js darsida Node va Edge runtime va Vercel'ni ko'rgansiz — Route Handler'lar Vercel'da aynan serverless funksiya bo'lib ishlaydi. Endi buni backend tomonidan ko'ramiz.

2. Lambda handler

2.1 Hodisa va javob

AWS Lambda — Amazon'ning serverless xizmati, bu sohadagi birinchi va eng katta platforma. Lambda'da HTTP server yo'q. Funksiya — handler(hodisa, kontekst): platforma unga hodisa (event) obyektini beradi, funksiya javob obyektini qaytaradi. HTTP so'rov API Gateway orqali kelsa, hodisa — so'rovning JSON tasviri (versiya 2.0 formati).

Express yoki Hono ilovasini Lambda'ga moslashtirish uchun adapter kerak: hodisani Request ga, Response ni javob obyektiga aylantiradigan. Hono'da u tayyor — hono/aws-lambda.

Biz ishga tushirdik (Node 24.21.0, hono 4.13.13; Lambda'siz, lokal — hodisani o'zimiz yasadik):

import { Hono } from "hono";
import { handle } from "hono/aws-lambda";

let chaqiruvlar = 0; // modul darajasi: nusxa yashaguncha saqlanadi

const app = new Hono();
app.get("/v1/salom", (c) => {
  chaqiruvlar++;
  return c.json({ salom: "dunyo", chaqiruvlar });
});
export const handler = handle(app);

const hodisa = {
  version: "2.0",
  routeKey: "GET /v1/salom",
  rawPath: "/v1/salom",
  rawQueryString: "",
  headers: { host: "x.execute-api.example" },
  requestContext: {
    http: {
      method: "GET", path: "/v1/salom", sourceIp: "203.0.113.1",
    },
    requestId: "r1",
    stage: "$default",
  },
  isBase64Encoded: false,
};
console.log(await handler(hodisa, {}));
console.log((await handler(hodisa, {})).body);

Konsolda:

{
  body: '{"salom":"dunyo","chaqiruvlar":1}',
  statusCode: 200,
  isBase64Encoded: false,
  headers: { 'content-type': 'application/json' }
}
{"salom":"dunyo","chaqiruvlar":2}

Lambda'ga qaytadigan javob — oddiy obyekt: statusCode, headers, body (doim satr). Hono buni o'zi yasadi. Ikkinchi chaqiruvda chaqiruvlar — 2: modul o'zgaruvchisi saqlandi.

sequenceDiagram
  participant F as Foydalanuvchi
  participant G as API Gateway
  participant L as Lambda nusxasi
  F->>G: GET /v1/salom
  G->>L: hodisa (JSON)
  Note over L: sovuq bo'lsa - nusxa yaratiladi, kod import qilinadi
  L->>L: handler(hodisa)
  L-->>G: statusCode, headers, body
  G-->>F: HTTP javob

Diagrammaga qarang: so'rov va javob orasida ikki o'zgartirish bor (HTTP → hodisa, javob obyekti → HTTP). Bu ishni API Gateway qiladi, siz esa faqat handler yozasiz.

2.2 Sovuq va iliq start

Sovuq start (cold start) — so'rov kelganda tayyor nusxa yo'q: platforma muhit yaratadi, kodingizni yuklaydi va import qiladi, keyin handler'ni chaqiradi. Iliq (warm) chaqiruv — nusxa allaqachon tirik, faqat handler chaqiriladi.

Kanon buni Lambda'siz, lokal taqlid bilan o'lchadi (yangi Node jarayoni + import + chaqiruv). Birinchi qatorning oxiridagi uchta vaqtga qarang — import, 1-chaqiruv, 2-chaqiruv:

javob: {"body":"{\"salom\":\"dunyo\",\"sovuq\":true}","statusCode":200,"isBase64Encoded":false,"headers":{"content-type":"application/json"}} | ikkinchi chaqiruv (iliq): {"salom":"dunyo","sovuq":false} | import 341.1 ms, 1-chaqiruv 58.04 ms, 2-chaqiruv 0.81 ms
"sovuq start" (yangi Node jarayoni + import + 1 chaqiruv, lokal): mediana 192 ms — haqiqiy Lambda'da qo'shimcha: konteyner/microVM, kod yuklash (hujjat bo'yicha, sinalmagan)

Iliq chaqiruv — 1 ms dan kam, sovuq — yuzlab ms. Haqiqiy Lambda'da sovuq startga yana platforma vaqti qo'shiladi (muhit yaratish, kod yuklash) — buni sinamadik. "Import 341 ms, yangi jarayon mediana 192 ms" farqining sababi o'lchanmagan. Ehtimol, birinchi import fayllarni diskdan o'qigan, keyingi jarayonlarga esa operatsion tizim keshi yordam bergan.

Amaliy xulosa: kod qancha kichik bo'lsa, import shuncha tez. Shuning uchun serverless'da kichik freymvorklar (Hono) va bundler bilan kesilgan kod afzal.

2.3 Modul darajasidagi holat

Iliq nusxa modul o'zgaruvchilarini saqlaydi — bundan foydalanish mumkin va kerak. Lekin unga ishonib bo'lmaydi. Brauzerda jonli taqlid:

function nusxaYarat() {
  // modul darajasi: import paytida bir marta
  const kesh = new Map();
  let importlar = 1;
  return function handler(kalit) {
    const bor = kesh.has(kalit);
    if (!bor) kesh.set(kalit, `${kalit} ma'lumoti`);
    return { kalit, keshdan: bor, importlar };
  };
}

let nusxa = nusxaYarat(); // sovuq start
console.log(nusxa("menyu"));
console.log(nusxa("menyu")); // iliq — kesh ishladi
nusxa = nusxaYarat(); // platforma nusxani almashtirdi
console.log(nusxa("menyu")); // kesh yo'qoldi

Konsolda:

{ kalit: 'menyu', keshdan: false, importlar: 1 }
{ kalit: 'menyu', keshdan: true, importlar: 1 }
{ kalit: 'menyu', keshdan: false, importlar: 1 }

Qoida:

• Modul darajasida: baza klienti, konfiguratsiya, og'ir obyektlar — har chaqiruvda qayta yaratmaslik uchun.
• Modul darajasida: foydalanuvchi sessiyasi, hisoblagich, navbat — nusxa istalgan payt o'chadi va 10 ta nusxaning har birida o'z qiymati bo'ladi. Bunday holat — Redis yoki bazada.

Tekshirib ko'ring: Lambda'da let sorovlarSoni = 0 modul darajasida va har chaqiruvda ++. Kunlik statistika uchun shu sonni o'qisa bo'ladimi?

3. Platformalar va limitlar

3.1 Uch asosiy oila

Edge — kod foydalanuvchiga eng yaqin ma'lumot markazida ishlaydi (Toshkentdagi foydalanuvchi uchun — yaqindagi nuqtada, AQSHda emas). V8 isolate — bitta V8 jarayoni ichida bir-biridan ajratilgan yengil "xona". Uni yaratish jarayon yoki konteynerdan ancha tez, shuning uchun Workers'da sovuq start juda kichik. Narxi: to'liq Node yo'q, faqat Web API'lar (Hono aynan shunga mos). Cloudflare nodejs_compat bayrog'i bilan Node modullarining bir qismini qo'shadi (developers.cloudflare.com, hujjat bo'yicha, sinalmagan).

3.2 Limitlar (rasmiy hujjatlardan, 2026-10-28)

AWS Lambda ("Lambda quotas"):

Cloudflare Workers ("Limits"):

Vercel Functions ("Functions Limits", Fluid compute bilan):

Raqamlar tez-tez o'zgaradi — loyiha boshlashdan oldin sahifani qayta o'qing. Netlify limitlari — docs.netlify.com "Functions" bo'limida (biz o'qimadik).

Cloudflare'dagi "CPU vaqti" — devor soati emas. Bazadan javob kutish CPU vaqtiga kirmaydi, JSON tahlil va hisob-kitob kiradi. Free tarifda 10 ms — og'ir hisob-kitob uchun juda kam.

Diqqat: Vercel'da tana 4.5 MB, Lambda'da 6 MB. Fayl yuklash darslaridagi 200 MB faylni funksiya orqali yubora olmaysiz — Presigned URL bilan to'g'ridan omborga yuklash shuning uchun serverless'da majburiy naqsh.

4. Bazaga ulanish muammosi

4.1 Kanon tajribasi

VPS'dagi Express'da bitta jarayon va bitta ulanishlar hovuzi (pool): masalan 10 ta ulanish, minglab so'rovga yetadi. Serverless'da har nusxa — alohida jarayon va o'z ulanishi. Yuklama oshsa, nusxalar ko'payadi, ulanishlar ham ko'payadi. Postgres esa ulanishlarni cheklaydi (max_connections, sukut 100).

Kanon buni o'lchadi: 120 ta parallel "funksiya nusxasi", har biri o'z pg.Client i bilan ulanib, 0.3 s davom etadigan so'rov bajaradi (Postgres 18.6, Docker; biz Docker'ni yoqmadik — kanon xom fayli):

max_connections 100, hozir band 9
natija: 99 × ok; 21 × sorry, too many clients already

100 ta ulanishdan 9 tasi band edi (boshqa jarayonlar). Qolgan joylar to'lgach, 21 ta "funksiya" sorry, too many clients already ("kechirasiz, mijozlar juda ko'p") xatosini oldi. Haqiqiy serverless'da bu 500 xato degani — eng ko'p foydalanuvchi bo'lgan paytda.

4.2 Yechimlar

flowchart LR
  F1["funksiya 1"] --> P["pooler"]
  F2["funksiya 2"] --> P
  F3["funksiya 120"] --> P
  P --> D[("Postgres: 20 ulanish")]
  F4["funksiya (HTTP drayver)"] -.->|HTTPS so'rov| H["provayder HTTP API"]
  H -.-> D

1. Pooler — funksiyalar bilan baza orasida turadigan dastur: minglab qisqa ulanishni qabul qilib, bazaga oz sonli ulanish orqali o'tkazadi. PgBouncer (transaction mode), Supabase Supavisor, Neon pooler (PgBouncer va tashqi pooler'lar).
2. HTTP drayver — SQL'ni TCP ulanish o'rniga HTTPS so'rov bilan yuborish (Neon serverless drayveri kabi). Edge'da TCP bo'lmasa — yagona yo'l (Managed va serverless Postgres).
3. Klientni modul darajasida qayta ishlatish — har chaqiruvda yangi ulanish ochmaslik; nusxa ichida pool hajmi 1.
4. Parallellikni cheklash — platformada maksimal nusxalar soni (Lambda'da "reserved concurrency").

Bu yechimlar kanonda sinalmagan (hujjat bo'yicha). Sinalgani — muammoning o'zi.

Tekshirib ko'ring: Har funksiya nusxasida new pg.Pool({ max: 10 }). Yuklama paytida 30 ta nusxa ochildi. Bazaga nechta ulanish kerak bo'lishi mumkin?

5. Qachon serverless mos emas

Narx ham hisobga olinadi: serverless kam yuklamada arzon, katta doimiy yuklamada esa VPS'dan qimmatga tushishi mumkin. Hisoblash uchun platformaning narx kalkulyatoridan foydalaning — raqam bermaymiz, chunki narxlar o'zgarib turadi.

Yana bir yashirin narx — vendor lock-in (provayderga bog'lanib qolish): Lambda hodisasi, Workers'ning KV ombori, Vercel'ning maxsus API'lari. Hono kabi Web standart freymvork bu bog'lanishni kamaytiradi — handler'dan tashqari kod o'zgarmaydi. Bu mavzuni keyingi darsda davom ettiramiz.

6. Ko'p uchraydigan xatolar

7. Mashqlar

Mashqlar kurs/mashqlar/29/68-serverless/ da. Yechimlar toza JavaScript (Node 24 da ishlaydi).

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

• Tayyor nusxa yo'q paytdagi sekin birinchi chaqiruv — start.
• Lambda'ga keladigan so'rov tasviri — (event).
• Lambda javobidagi body maydonining turi —
• Cloudflare Workers ishlaydigan yengil "xona" — V8
• Ko'p qisqa ulanishni oz sonli baza ulanishiga aylantiradigan dastur —

2-mashq (o'rta): ulanishlar byudjeti

ulanishByudjeti({ maxConnections, band, nusxalar, poolMax }) funksiyasini yozing: kerakli ulanishlar (nusxalar × poolMax), bo'sh joy (maxConnections − band), sig'adimi (true/false) va sig'masa — xatoga uchraydigan taxminiy ulanishlar sonini qaytarsin. Kanon holati (100, 9, 120, 1) va ikki boshqa holat bilan sinang: (100, 9, 30, 10) va (100, 9, 30, 2). Ishora: ortiqcha — Math.max(0, kerak − bosh).

function ulanishByudjeti(h) {
  const { maxConnections, band, nusxalar, poolMax } = h;
  const kerak = nusxalar * poolMax;
  const bosh = maxConnections - band;
  const ortiqcha = Math.max(0, kerak - bosh);
  return { kerak, bosh, sigadi: ortiqcha === 0, ortiqcha };
}

const holatlar = [
  { maxConnections: 100, band: 9, nusxalar: 120, poolMax: 1 },
  { maxConnections: 100, band: 9, nusxalar: 30, poolMax: 10 },
  { maxConnections: 100, band: 9, nusxalar: 30, poolMax: 2 },
];
for (const h of holatlar) console.log(ulanishByudjeti(h));

{ kerak: 120, bosh: 91, sigadi: false, ortiqcha: 29 }
{ kerak: 300, bosh: 91, sigadi: false, ortiqcha: 209 }
{ kerak: 60, bosh: 91, sigadi: true, ortiqcha: 0 }

3-mashq (qiyin): o'z Lambda adapteringiz

hodisadanSorov(hodisa) — API Gateway 2.0 hodisasidan Request yasaydi (URL: https:// + headers.host + rawPath + ?rawQueryString agar bo'sh bo'lmasa; metod requestContext.http.method; tana body bo'lsa). javobdanNatija(response) — Response dan { statusCode, headers, body } obyekti (sarlavhalar oddiy obyekt). Ikkalasini fetch handler bilan ulab, adapter(ishlov) yasang va GET hamda POST hodisasi bilan sinang. Ishora: Object.fromEntries(response.headers); Response.json sarlavhasi — application/json.

function hodisadanSorov(h) {
  const q = h.rawQueryString ? `?${h.rawQueryString}` : "";
  const url = `https://${h.headers.host}${h.rawPath}${q}`;
  return new Request(url, {
    method: h.requestContext.http.method,
    headers: h.headers,
    body: h.body ?? undefined,
  });
}

async function javobdanNatija(r) {
  return {
    statusCode: r.status,
    headers: Object.fromEntries(r.headers),
    body: await r.text(),
  };
}

const adapter = (ishlov) => async (hodisa) =>
  javobdanNatija(await ishlov(hodisadanSorov(hodisa)));

const handler = adapter(async (req) => {
  const url = new URL(req.url);
  if (req.method === "POST") {
    const { matn } = await req.json();
    return Response.json({ id: 1, matn }, { status: 201 });
  }
  return Response.json({ sahifa: url.searchParams.get("sahifa") });
});

const asos = { headers: { host: "api.example.com" } };
console.log(await handler({
  ...asos, rawPath: "/v1/vazifalar", rawQueryString: "sahifa=2",
  requestContext: { http: { method: "GET" } },
}));
console.log(await handler({
  ...asos, rawPath: "/v1/vazifalar", rawQueryString: "",
  body: JSON.stringify({ matn: "Non olish" }),
  requestContext: { http: { method: "POST" } },
}));

{
  statusCode: 200,
  headers: { 'content-type': 'application/json' },
  body: '{"sahifa":"2"}'
}
{
  statusCode: 201,
  headers: { 'content-type': 'application/json' },
  body: '{"id":1,"matn":"Non olish"}'
}

8. Loyiha qadami: kanon tajribasi, loyihaga kirmaydi

vazifalar-api serverless'ga ko'chmaydi. Kanon ikki narsani lokal sinadi. Birinchisi — hono/aws-lambda handler'i API Gateway 2.0 hodisasi bilan (import 341 ms, sovuq chaqiruv 58 ms, iliq 0.8 ms, yangi jarayon mediana 192 ms). Ikkinchisi — 120 ta parallel ulanish (99 ok, 21 "too many clients"). Haqiqiy AWS Lambda, Vercel, Netlify va Cloudflare Workers — sinalmagan: akkaunt kerak, kurs qoidasiga ko'ra akkaunt ochilmaydi.

Nega loyihaga kirmaydi? Loyihada BullMQ worker'lari, SSE ulanishlari va Telegram bot bor — ular doimiy ishlaydigan jarayon talab qiladi. Bu serverless'ning "mos emas" ro'yxatidagi narsalar. Loyiha 33-qismda VPS'ga Docker bilan joylanadi. Lekin bu darsdagi ikki saboq loyihaga ham tegishli: ulanishlar byudjetini hisoblash va holatni jarayon ichida saqlamaslik (bir nechta nusxa bo'lganda).

O'zingiz sinab ko'ring: 3-mashqdagi adapter ga Hono'ning app.fetch ini bering (adapter(app.fetch)) — Hono ilovasi o'z adapteringiz orqali ishlashini ko'ring.

9. Real ishda

• Vercel'dagi Next.js — Route Handler va Server Action'lar serverless funksiya bo'lib ishlaydi.
• Webhook qabul qiluvchilar (Payme, Telegram, Stripe) — kichik funksiyaga yaxshi mos.
• Cloudflare Workers — edge'da kesh, yo'naltirish, A/B test, kichik API.
• Intervyuda: "Cold start nima va uni qanday kamaytirasiz?", "Serverless'da bazaga ulanish muammosi?", "Qachon serverless tanlamaysiz?"

Xulosa

• Serverless — funksiya joylaysiz, platforma nusxalarni yaratadi, ko'paytiradi va o'chiradi; pul — ishlagan vaqtga.
• Lambda handler hodisa oladi va { statusCode, headers, body } qaytaradi; Hono'da hono/aws-lambda.
• Kanon lokal taqlidida sovuq chaqiruv 58 ms + import 341 ms, iliq — 0.8 ms; modul holati faqat nusxa yashaguncha.
• Limitlar: Lambda 15 daqiqa va 6 MB tana, Vercel 4.5 MB, Workers Free 10 ms CPU — hujjatdan tekshiring.
• Har nusxa o'z ulanishi bilan bazani to'ldiradi (kanon: 21/120 xato) — pooler, HTTP drayver, max: 1.
• Uzoq ishlar, doimiy worker'lar va doimiy katta yuklama — serverless uchun emas.

Keyingi dars: Tayyor backend'lar: BaaS va headless CMS — ba'zan backend yozish shart emas: Supabase, Firebase, PocketBase, Strapi, Payload va lock-in narxi.

Manbalar

• AWS Lambda quotas: https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html
• API Gateway HTTP API — Lambda proxy hodisasi (2.0 format): https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
• Cloudflare Workers limits: https://developers.cloudflare.com/workers/platform/limits/
• Vercel Functions limits: https://vercel.com/docs/functions/limitations
• Netlify Functions: https://docs.netlify.com/functions/overview/
• Hono — AWS Lambda: https://hono.dev/docs/getting-started/aws-lambda
• Kanon tajribasi (IlmHamroh, 2026-10-27): hono 4.13.13, pg 8.23.1, Postgres 18.6 (Docker), Node 24.21.0, Windows 11. Handler va modul holati, mashqlar — biz ishga tushirdik (2026-10-28, Node 24.21.0, hono 4.13.13).