27.9-dars: Monolit va mikroservis

┌─────────────────────────┐
│      MONOLIT            │
│  Foydalanuvchi | Buyurtma│  bir kod bazasi
│  To'lov | Xabar          │  bir jarayon
│  (bir baza)              │  bir deploy
└─────────────────────────┘
   modullar funksiya chaqiruvi bilan

┌──────────┐  ┌──────────┐  ┌──────────┐
│Foydalanuv│  │Buyurtma  │  │To'lov    │
│ (baza 1) │  │ (baza 2) │  │ (baza 3) │
└────┬─────┘  └────┬─────┘  └────┬─────┘
     └──── tarmoq (HTTP/xabar) ──┘
   har xizmat mustaqil (deploy, miqyos)

# MONOLIT — bir ilova (funksiya chaqiruvi)
class Ilova:
    def __init__(self):
        self.buyurtma = BuyurtmaModuli()
        self.tolov = TolovModuli()
    def buyurtma_ber(self, ...):
        b = self.buyurtma.yarat(...)     # to'g'ridan chaqiruv
        self.tolov.tola(...)             # bir jarayon

# MIKROSERVIS — tarmoq orqali (HTTP/xabar)
# Buyurtma xizmati → HTTP → To'lov xizmati
# response = requests.post("http://tolov/tola", ...)
# har xizmat: o'z kodi, jarayoni, bazasi

# TANLOV:
# Monolit: kichik jamoa, yangi loyiha, sodda
# Mikroservis: katta jamoa, mustaqil deploy/miqyos
# Modulli monolit: bir ilova + aniq modullar (o'rta yo'l)
# QOIDA: monolitdan boshlang (kerak bo'lsa bo'ling)

Monolit — bir ilova (sodda, tez, izchil; katta bo'lsa qotadi)
Mikroservis — ko'p xizmat (mustaqil deploy/miqyos; tarmoq murakkab)
Taqsimlangan murakkablik — mikroservis narxi (tarmoq, izchillik)
Tanlov — jamoa/hajm/ehtiyoj (moda emas)
Monolitdan boshlang · Modulli monolit — o'rta yo'l

"""Monolit: modullar bir ilovada, funksiya chaqiruvi bilan (tarmoqsiz)."""


class BuyurtmaModuli:
    def __init__(self) -> None:
        self.buyurtmalar: list = []

    def yarat(self, mahsulot: str, summa: float) -> dict:
        buyurtma = {"id": len(self.buyurtmalar) + 1, "mahsulot": mahsulot, "summa": summa}
        self.buyurtmalar.append(buyurtma)
        return buyurtma


class TolovModuli:
    def tola(self, summa: float) -> str:
        return f"{summa} to'landi"


class XabarModuli:
    def yubor(self, matn: str) -> str:
        return f"Xabar: {matn}"


class Ilova:
    """Monolit — barcha modul bir joyda."""

    def __init__(self) -> None:
        self.buyurtma = BuyurtmaModuli()
        self.tolov = TolovModuli()
        self.xabar = XabarModuli()

    def buyurtma_ber(self, mahsulot: str, summa: float) -> dict:
        # to'g'ridan funksiya chaqiruvi (bir jarayon)
        b = self.buyurtma.yarat(mahsulot, summa)
        tolov = self.tolov.tola(summa)
        xabar = self.xabar.yubor(f"Buyurtma {b['id']} qabul qilindi")
        return {"buyurtma": b, "tolov": tolov, "xabar": xabar}


def main() -> None:
    ilova = Ilova()

    print("=== 1. Buyurtma berish (bir oqim) ===")
    natija = ilova.buyurtma_ber("Python kursi", 1000)
    print(f"  buyurtma: {natija['buyurtma']}")
    print(f"  to'lov: {natija['tolov']}")
    print(f"  xabar: {natija['xabar']}")

    print("\n=== 2. Bir jarayon (tarmoqsiz) ===")
    print("  modullar funksiya chaqiruvi bilan")

    print("\n=== 3. Izchil (bir baza) ===")
    print(f"  jami buyurtma: {len(ilova.buyurtma.buyurtmalar)}")

    print("\n=== 4. Sodda ===")
    print("  bir kod, bir deploy, bir jarayon")
    print("  ⭐ Monolit — birlashgan (funksiya chaqiruvi)")


if __name__ == "__main__":
    main()

=== 1. Buyurtma berish (bir oqim) ===
  buyurtma: {'id': 1, 'mahsulot': 'Python kursi', 'summa': 1000}
  to'lov: 1000 to'landi
  xabar: Xabar: Buyurtma 1 qabul qilindi

=== 2. Bir jarayon (tarmoqsiz) ===
  modullar funksiya chaqiruvi bilan

=== 3. Izchil (bir baza) ===
  jami buyurtma: 1

=== 4. Sodda ===
  bir kod, bir deploy, bir jarayon
  ⭐ Monolit — birlashgan (funksiya chaqiruvi)

"""Mikroservis: xizmatlar tarmoq (mock HTTP) orqali aloqa — mustaqil."""


class TolovXizmati:
    """Alohida xizmat (o'z jarayoni)."""

    def handle(self, sorov: dict) -> dict:
        summa = sorov.get("summa", 0)
        return {"holat": 200, "xabar": f"{summa} to'landi"}


class XabarXizmati:
    """Alohida xizmat."""

    def handle(self, sorov: dict) -> dict:
        return {"holat": 200, "xabar": f"Xabar: {sorov.get('matn')}"}


class MockTarmoq:
    """HTTP o'rniga (deterministik) — xizmatlarni ulaydi."""

    def __init__(self) -> None:
        self.xizmatlar: dict = {}

    def royxatga_ol(self, nom: str, xizmat) -> None:
        self.xizmatlar[nom] = xizmat

    def sorov(self, xizmat_nomi: str, malumot: dict) -> dict:
        # tarmoq chaqiruvini taqlid qiladi
        return self.xizmatlar[xizmat_nomi].handle(malumot)


class BuyurtmaXizmati:
    """Boshqa xizmatlarni tarmoq orqali chaqiradi."""

    def __init__(self, tarmoq: MockTarmoq) -> None:
        self.tarmoq = tarmoq

    def buyurtma_ber(self, mahsulot: str, summa: float) -> dict:
        # tarmoq orqali (funksiya chaqiruvi emas)
        tolov = self.tarmoq.sorov("tolov", {"summa": summa})
        xabar = self.tarmoq.sorov("xabar", {"matn": f"{mahsulot} qabul"})
        return {"mahsulot": mahsulot, "tolov": tolov, "xabar": xabar}


def main() -> None:
    tarmoq = MockTarmoq()
    tarmoq.royxatga_ol("tolov", TolovXizmati())
    tarmoq.royxatga_ol("xabar", XabarXizmati())
    buyurtma = BuyurtmaXizmati(tarmoq)

    print("=== 1. Buyurtma (xizmatlar orqali) ===")
    natija = buyurtma.buyurtma_ber("Python kursi", 1000)
    print(f"  to'lov javobi: {natija['tolov']}")
    print(f"  xabar javobi: {natija['xabar']}")

    print("\n=== 2. Har xizmat mustaqil ===")
    print(f"  ro'yxatdagi xizmatlar: {list(tarmoq.xizmatlar)}")

    print("\n=== 3. Tarmoq orqali aloqa ===")
    print("  BuyurtmaXizmati → tarmoq → Tolov/Xabar")
    print("  har xizmat alohida (o'z jarayoni)")

    print("\n=== 4. Mustaqillik narxi ===")
    print("  tarmoq (kechikish, xato) — monolitda yo'q edi")
    print("  ⭐ Mikroservis — tarmoq orqali (mustaqil)")


if __name__ == "__main__":
    main()

=== 1. Buyurtma (xizmatlar orqali) ===
  to'lov javobi: {'holat': 200, 'xabar': "1000 to'landi"}
  xabar javobi: {'holat': 200, 'xabar': 'Xabar: Python kursi qabul'}

=== 2. Har xizmat mustaqil ===
  ro'yxatdagi xizmatlar: ['tolov', 'xabar']

=== 3. Tarmoq orqali aloqa ===
  BuyurtmaXizmati → tarmoq → Tolov/Xabar
  har xizmat alohida (o'z jarayoni)

=== 4. Mustaqillik narxi ===
  tarmoq (kechikish, xato) — monolitda yo'q edi
  ⭐ Mikroservis — tarmoq orqali (mustaqil)

"""Taqsimlangan murakkablik: tarmoq xatosi — qayta urinish kerak (monolitda yo'q)."""


class IshonchsizXizmat:
    """Xizmat ba'zan yiqiladi (tarmoq haqiqati)."""

    def __init__(self) -> None:
        self.urinishlar = 0

    def handle(self, sorov: dict) -> dict:
        self.urinishlar += 1
        # birinchi 2 urinish yiqiladi (deterministik simulyatsiya)
        if self.urinishlar < 3:
            raise ConnectionError(f"Tarmoq xatosi (urinish {self.urinishlar})")
        return {"holat": 200, "natija": "muvaffaqiyat"}


def qayta_urinish(xizmat, sorov: dict, max_urinish: int = 3) -> dict:
    """Tarmoq xatosida qayta urinish (mikroservis naqshi)."""
    for urinish in range(1, max_urinish + 1):
        try:
            return xizmat.handle(sorov)
        except ConnectionError as e:
            if urinish == max_urinish:
                return {"holat": 500, "xato": str(e)}
            # aks holda qayta urinadi
    return {"holat": 500, "xato": "noma'lum"}


def main() -> None:
    xizmat = IshonchsizXizmat()

    print("=== 1. To'g'ridan chaqiruv (yiqiladi) ===")
    try:
        IshonchsizXizmat().handle({})
    except ConnectionError as e:
        print(f"  {e}")

    print("\n=== 2. Qayta urinish bilan ===")
    natija = qayta_urinish(xizmat, {"malumot": "test"})
    print(f"  natija: {natija}")
    print(f"  jami urinish: {xizmat.urinishlar}")

    print("\n=== 3. Nega kerak ===")
    print("  tarmoq ishonchsiz (so'rov yo'qoladi)")
    print("  monolitda funksiya chaqiruvi — bunday emas")

    print("\n=== 4. Taqsimlangan murakkablik ===")
    print("  qayta urinish, timeout, circuit breaker")
    print("  monolitda 'bepul' — mikroservisda ish")
    print("  ⭐ Tarmoq — yangi muammolar (mikroservis narxi)")


if __name__ == "__main__":
    main()

=== 1. To'g'ridan chaqiruv (yiqiladi) ===
  Tarmoq xatosi (urinish 1)

=== 2. Qayta urinish bilan ===
  natija: {'holat': 200, 'natija': 'muvaffaqiyat'}
  jami urinish: 3

=== 3. Nega kerak ===
  tarmoq ishonchsiz (so'rov yo'qoladi)
  monolitda funksiya chaqiruvi — bunday emas

=== 4. Taqsimlangan murakkablik ===
  qayta urinish, timeout, circuit breaker
  monolitda 'bepul' — mikroservisda ish
  ⭐ Tarmoq — yangi muammolar (mikroservis narxi)

"""Modulli monolit: bir ilova, lekin aniq modullar (interfeys orqali)."""
from abc import ABC, abstractmethod


# har modul aniq interfeys (chegara) bilan
class TolovInterfeysi(ABC):
    @abstractmethod
    def tola(self, summa: float) -> str: ...


class TolovModuli(TolovInterfeysi):
    def tola(self, summa: float) -> str:
        return f"{summa} to'landi"


class BuyurtmaModuli:
    """Boshqa modul bilan interfeys orqali (to'g'ridan ichiga emas)."""

    def __init__(self, tolov: TolovInterfeysi) -> None:
        self.tolov = tolov   # interfeysga bog'liq (chegara)
        self.buyurtmalar: list = []

    def yarat(self, mahsulot: str, summa: float) -> dict:
        b = {"id": len(self.buyurtmalar) + 1, "mahsulot": mahsulot}
        self.buyurtmalar.append(b)
        tolov = self.tolov.tola(summa)   # interfeys orqali
        return {"buyurtma": b, "tolov": tolov}


def main() -> None:
    # bir ilova, lekin modullar aniq chegarali
    tolov = TolovModuli()
    buyurtma = BuyurtmaModuli(tolov)

    print("=== 1. Buyurtma (modullar interfeys orqali) ===")
    print(f"  {buyurtma.yarat('Python kursi', 1000)}")

    print("\n=== 2. Aniq chegara (interfeys) ===")
    print("  BuyurtmaModuli → TolovInterfeysi (ichiga emas)")

    print("\n=== 3. Bir ilova (sodda deploy) ===")
    print("  funksiya chaqiruvi (tarmoqsiz — monolit)")
    print("  lekin modullar mustaqil (mikroservis intizomi)")

    print("\n=== 4. Kerak bo'lsa ajratish oson ===")
    print("  chegara tayyor → modulni xizmatga ajratish oson")
    print("  monolit soddaligi + mikroservis tartibi")
    print("  ⭐ Modulli monolit — o'rta yo'l (eng yaxshi boshlash)")


if __name__ == "__main__":
    main()

=== 1. Buyurtma (modullar interfeys orqali) ===
  {'buyurtma': {'id': 1, 'mahsulot': 'Python kursi'}, 'tolov': "1000 to'landi"}

=== 2. Aniq chegara (interfeys) ===
  BuyurtmaModuli → TolovInterfeysi (ichiga emas)

=== 3. Bir ilova (sodda deploy) ===
  funksiya chaqiruvi (tarmoqsiz — monolit)
  lekin modullar mustaqil (mikroservis intizomi)

=== 4. Kerak bo'lsa ajratish oson ===
  chegara tayyor → modulni xizmatga ajratish oson
  monolit soddaligi + mikroservis tartibi
  ⭐ Modulli monolit — o'rta yo'l (eng yaxshi boshlash)

# yangi loyiha darrov 10 xizmat            # ⚠️
# monolitdan boshlash (chegarani bilib)     # ✅

# 3 kishi 15 xizmatni boshqaradi           # ⚠️
# jamoaga mos (kam xizmat yoki monolit)     # ✅

natija = xizmat_chaqir()  # xato bo'lsa?    # ⚠️
try: ... except: qayta_urin()  # timeout     # ✅

# ko'p bazada bir tranzaksiya kutish        # ⚠️
# saga naqshi (eventual consistency)         # ✅

# har funksiya alohida xizmat               # ⚠️
# bounded context bo'yicha (mazmunli)        # ✅

# ko'p xizmat bir bazaga (bog'lanish)        # ⚠️
# har xizmat o'z bazasi (mustaqil)           # ✅

# xato qaysi xizmatda? (log yo'q)           # ⚠️
# distributed tracing, markaziy log          # ✅

1.  # monolit nima?
2.  # mikroservis nima?
3.  # monolit qanday aloqa?
4.  # mikroservis qanday aloqa?
5.  # monolit afzalligi?
6.  # monolit kamchiligi?
7.  # mikroservis afzalligi?
8.  # mikroservis kamchiligi?
9.  # taqsimlangan murakkablik?
10. # qaysidan boshlash?
11. # modulli monolit nima?
12. # Conway qonuni?

1.  # yangi loyiha 10 xizmat          # monolit

2.  natija = xizmat_chaqir()          # timeout

3.  # ko'p bazada ACID                 # saga

4.  # har funksiya xizmat              # bounded context

5.  # ko'p xizmat bir baza             # o'z bazasi