Mikroservislar — noldan professional darajagacha

Avval monolitni tasavvur qil: bitta NestJS loyiha, ichida UsersModule, OrdersModule, PaymentsModule — hammasi bitta jarayonda, bitta postgresga ulangan. Boshida bu ajoyib: tez yoziladi, tranzaksiya oson, deploy bitta.

Mikroservis = o‘z kodi + o‘z ma’lumotlar bazasi + o‘z deploy’i; boshqalar bilan faqat tarmoq orqali gaplashadi.

Eng muhim qoida — Database-per-service

Har bir xizmat o‘z bazasiga egalik qiladi. Orders xizmati users jadvaliga SELECT qilmaydi — Users xizmatining API’si orqali so‘raydi. Agar ikki xizmat bitta bazaga tegsa, bu mikroservis emas — “taqsimlangan monolit”, ya’ni mikroservis murakkabligi-yu monolit bog‘liqligini birga olgan eng yomon variant.

Mikroservis dizaynining yuragi — aloqa. Ikki xil bor, NestJS ikkalasini ham qo‘llaydi.

SINXRON  Request–Response — javob kerak bo‘lganda

Gateway buyurtma yaratishdan oldin foydalanuvchi bor-yo‘qligini so‘raydi va javobni kutadi. NestJS’da send() + @MessagePattern.

// Gateway — so'rov yuboradi (Observable qaytaradi), JAVOB kutadi
this.usersClient.send({ cmd: 'get_user' }, userId);

// Users xizmati — javob beradi
@MessagePattern({ cmd: 'get_user' })
getUser(@Payload() id: string) {
  return this.service.findOne(id);   // qaytgan qiymat javob bo'lib boradi
}

ASINXRON  Event — javob kerak emas

Buyurtma yaratilgach order_created hodisasini tashlaysan; kim qiziqsa o‘zi ushlaydi (email, analitika). NestJS’da emit() + @EventPattern.

// Orders — hodisa tashlaydi, javob KUTMAYDI ("e'lon qil va unut")
this.client.emit('order_created', { orderId, userId });

// Notification — tinglaydi, hech narsa qaytarmaydi
@EventPattern('order_created')
handle(@Payload() data) {
  this.email.sendConfirmation(data);
}

Transport — kod bir xil, faqat sozlama o‘zgaradi

NestJS bularni transport orqali uzatadi. Eng kuchli tomoni: biznes kodingni o‘zgartirmaysan, faqat transportni almashtirsan.

Endi to‘liq tizimni quramiz: 1 ta Gateway (HTTP) + 3 ta mikroservis. Gateway ↔ Users/Orders — TCP (sinxron). Orders → Notification — RabbitMQ (event).

1 · Mikroservisni ishga tushirish (Users)

// users/src/main.ts — DIQQAT: create EMAS, createMicroservice (HTTP ochmaydi)
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.TCP,
  options: { host: '0.0.0.0', port: 3001 },
});
await app.listen();

// users/src/users.controller.ts
@Controller()
export class UsersController {
  @MessagePattern({ cmd: 'get_user' })       // "manzil" — Gateway shunga yuboradi
  getUser(@Payload() id: string) {
    return DB.find((u) => u.id === id) ?? null;
  }
  @MessagePattern({ cmd: 'create_user' })
  createUser(@Payload() dto: { name: string; email: string }) {
    const user = { id: String(DB.length + 1), ...dto };
    DB.push(user);
    return user;
  }
}

2 · Orders buyurtma yaratib, event tashlaydi

// orders/src/orders.controller.ts
@MessagePattern({ cmd: 'create_order' })
createOrder(@Payload() dto: { userId: string; total: number }) {
  const order = { id: String(ORDERS.length + 1), ...dto, status: 'created' };
  ORDERS.push(order);
  // ASINXRON: Notification ishlamay tursa ham, buyurtma yaratilaveradi
  this.notify.emit('order_created', { orderId: order.id, userId: order.userId });
  return order;
}

3 · Notification eventni tinglaydi

// notification/src/notification.controller.ts
@EventPattern('order_created')
async handle(@Payload() data: any, @Ctx() ctx: RmqContext) {
  console.log(`📧 Email yuborildi: buyurtma #${data.orderId}`);
  // ishlangach qo'lda tasdiqlaymiz (xabar yo'qolmasligi uchun)
  ctx.getChannelRef().ack(ctx.getMessage());
}

4 · Gateway hammasini bog‘laydi

// gateway/src/app.controller.ts
@Post('orders')
async createOrder(@Body() dto: { userId: string; total: number }) {
  // PRO: buyurtmadan oldin foydalanuvchini tekshiramiz (sinxron so'rov)
  const user = await firstValueFrom(this.users.send({ cmd: 'get_user' }, dto.userId));
  if (!user) return { error: 'Bunday foydalanuvchi yo‘q' };
  return this.orders.send({ cmd: 'create_order' }, dto);
}

1–3 · Timeout + Retry + Fallback (RxJS bilan)

NestJS’ning send() metodi RxJS Observable qaytargani uchun, himoyani .pipe() bilan ulab qo‘yamiz — juda tabiiy:

import { timeout, retry, catchError } from 'rxjs/operators';
import { of, timer } from 'rxjs';

this.users.send({ cmd: 'get_user' }, id).pipe(
  // 1) TIMEOUT — 3 soniyada javob bo'lmasa, uzamiz (cheksiz kutmaymiz)
  timeout(3000),

  // 2) RETRY + EKSPONENSIAL BACKOFF + JITTER
  retry({
    count: 3,
    delay: (err, n) => {
      const base = Math.min(1000 * 2 ** n, 8000);     // 2s, 4s, 8s
      const jitter = Math.random() * 300;             // bir vaqtda urilmasin
      return timer(base + jitter);
    },
  }),

  // 3) FALLBACK — baribir bo'lmasa, muloyim zaxira javob (qulamaymiz)
  catchError(() => of({ id, name: 'Mehmon' })),
);

4 · Circuit Breaker (zanjir uzgich)

Retry vaqtinchalik nosozlikka yaxshi. Lekin xizmat butunlay yiqilgan bo‘lsa, har so‘rovda 3 marta urinish — vaqt va resurs isrofi. Circuit Breaker buni hal qiladi: ketma-ket xato ko‘rsa, zanjirni ochadi va bir muddat umuman urinmaydi — darhol fallback qaytaradi.

import CircuitBreaker from 'opossum';   // npm i opossum

// chaqiruvni "himoya qobig'i"ga o'raymiz
const call = (id: string) =>
  firstValueFrom(this.users.send({ cmd: 'get_user' }, id));

const breaker = new CircuitBreaker(call, {
  timeout: 3000,                  // sekin javob = xato deb hisoblanadi
  errorThresholdPercentage: 50,   // 50% so'rov xato bo'lsa -> OPEN
  resetTimeout: 10000,            // 10s dan keyin HALF-OPEN (sinov)
});

breaker.fallback(() => ({ name: 'Mehmon' }));   // OPEN holatda zaxira javob

const user = await breaker.fire(id);   // breaker o'zi qaror qiladi

Yondashuv 1 · Orkestratsiya (markaziy dirijyor)

Bitta “dirijyor” barcha qadamlarni ketma-ket boshqaradi va xatoda kompensatsiyani chaqiradi. Mantiq bir joyda — kuzatish va debug oson. Bu eng ko‘p ishlatiladigan, tushunarli usul:

// orders/src/order-saga.ts — ORKESTRATSIYA (markaziy dirijyor)
async createOrder(dto: { userId: string; items: any[]; total: number }) {
  // bajarilgan qadamlarni "bekor qilish" funksiyalari to'planadi
  const compensations: Array<() => Promise<void>> = [];

  try {
    // 1-qadam: omborda rezerv
    const r = await firstValueFrom(this.inventory.send({ cmd: 'reserve' }, dto.items));
    compensations.push(() => firstValueFrom(this.inventory.send({ cmd: 'release' }, r.id)));

    // 2-qadam: to'lov
    const p = await firstValueFrom(this.payment.send({ cmd: 'charge' }, { userId: dto.userId, total: dto.total }));
    compensations.push(() => firstValueFrom(this.payment.send({ cmd: 'refund' }, p.id)));

    // 3-qadam: buyurtmani tasdiqlash
    const order = await firstValueFrom(this.orders.send({ cmd: 'confirm' }, dto));
    return order;                       // ✓ saga muvaffaqiyatli

  } catch (err) {
    // ✕ xato — bajarilganlarni TESKARI tartibda bekor qilamiz
    for (const undo of compensations.reverse()) {
      try { await undo(); }
      catch (e) { /* kompensatsiya ham xato -> ALERT + qo'lda aralashuv */ }
    }
    throw new Error('Buyurtma bekor qilindi (saga rollback)');
  }
}

Yondashuv 2 · Xoreografiya (markazsiz, event orqali)

Markaz yo‘q — har bir xizmat hodisani tinglab, o‘z qadamini bajaradi va keyingi hodisani tashlaydi. Ko‘proq bo‘shashgan (decoupled), lekin oqimni kuzatish qiyinroq:

// XOREOGRAFIYA — markaz yo'q, har xizmat keyingisini event bilan boshlaydi

// Orders:
this.client.emit('order_created', { orderId, userId, total });

// Payment: tinglaydi -> to'lov -> natijani e'lon qiladi
@EventPattern('order_created')
async onOrderCreated(@Payload() e) {
  try {
    await this.charge(e.userId, e.total);
    this.client.emit('payment_succeeded', { orderId: e.orderId });
  } catch {
    this.client.emit('payment_failed', { orderId: e.orderId });  // kompensatsiya tetigi
  }
}

// Orders: to'lov yiqilsa -> buyurtmani bekor qiladi (kompensatsiya)
@EventPattern('payment_failed')
async onPaymentFailed(@Payload() e) {
  await this.cancelOrder(e.orderId);
}

Bu darslik tushuncha va ishlaydigan asosni beradi. “Ishlaydi”dan “productionda ishonchli”gacha bo‘lgan farq — quyidagilar:

• Mikroservis = mustaqil deploy + scaling + DB + jamoa. Boshqasi — bonus.
• Chegarani biznes domeni bo‘yicha chiz; database-per-service buzilsa — “taqsimlangan monolit”, eng yomon holat.
• send() = javob kutaman (sinxron) · emit() = event (kutmayman). Kod bir xil, faqat transport o‘zgaradi.
• Tarmoq ishonchsiz: har chaqiruvga timeout, kerak joyda retry+backoff va circuit breaker, doim fallback.
• Bir amal ko‘p xizmatni qamrasa — global ACID yo‘q. Saga + kompensatsiya + idempotency + outbox.