31.4-dars: Loyiha 4 — mikroservisli tizim (Python + Rust + Go)

31-QISM — KARYERA VA KATTA LOYIHALAR · 4-dars

1. Kirish va motivatsiya

To'rtinchi va eng katta loyiha: mikroservisli tizim — bir necha til (Python + Rust + Go) bilan qurilgan polyglot arxitektura (30.16 amaliyoti). Bu oldingi barcha bilimlarni birlashtiradi: mikroservis (25-qism), til integratsiyasi (30-qism), API 31.2-bob, ma'lumot 31.3-bob, Docker (28-qism). Tizim bir vazifani bir necha mustaqil xizmatga bo'ladi, har biri o'z tilida (to'g'ri til to'g'ri ishga): Python (ML/API — ekotizim), Rust (CPU-og'ir yadro — tez, xavfsiz), Go (yuqori yuk shlyuz — parallel). Ular gRPC/REST orqali gaplashadi, Docker'da joylashadi. Bu real, katta tizim dizayni — senior dasturchi darajasidagi loyiha. Portfolioda eng ta'sirli: "men polyglot mikroservisli tizim qurdim".

Mikroservisli tizim loyihasi — ko'p tildagi mustaqil xizmatlardan iborat tizim: xizmat ajratish (har vazifa alohida xizmat — 25-qism), to'g'ri til (Python — ML/API, Rust — yadro, Go — shlyuz — 30.16), aloqa (gRPC/REST — xizmatlar orasi — 30.14), Docker (har xizmat konteynerda — 28-qism), umumiy masalalar (xizmat topish, log, kuzatuv). Foydalanish: katta tizim, mustaqil miqyoslash. Bu 25-qism (mikroservis), 30-qism (polyglot) ni birlashtiradi. Bu 30.16 (polyglot), 31.2 (API) bilan bog'liq. Mikroservis — ko'p til, mustaqil xizmat. gRPC/Docker.

Real vaziyat. Rasm ishlash platformasi qurildi: Go shlyuz (API gateway — million so'rov, autentifikatsiya, yo'naltirish — goroutine 30.13), Python xizmat (ML — rasm tahlili, tavsiya — ekotizim), Rust xizmat (rasm o'lchamini o'zgartirish — CPU-og'ir, tez, xavfsiz 30.9). Ular gRPC orqali (30.14 — tez, .proto shartnoma) gaplashdi; har biri Docker (28-qism — alohida konteyner, mustaqil deploy/miqyos). Yuqori yuk qismi (shlyuz) Go, og'ir hisob (rasm) Rust, ML Python — har biri o'z kuchida. Real polyglot tizim — senior daraja loyiha. Mikroservis — ko'p til, mustaqil xizmatlar.

Bu darsda mikroservisli polyglot tizim loyihasini o'rganamiz.

Bu darsda:

• Mikroservis tizim dizayni
• Xizmat ajratish (to'g'ri til)
• Xizmatlararo aloqa (gRPC)
• Docker va deploy
• Umumiy masalalar (kuzatuv, topish)
• Loyiha amaliyoti
• Mikroservis tuzoqlari
• Amaliy: mikroservis modeli

ℹ To'liq tizim ko'p til/vosita talab qiladi; misollar tizim dizayni mantiqini (deterministik) modellashtiradi.

2. Nazariya — chuqur tushuntirish

2.1. Mikroservis tizim dizayni

Mustaqil xizmatlar:

                  ┌─────────────┐
     mijoz  ───>  │  Go shlyuz  │  (API gateway — yuqori yuk)
                  └──────┬──────┘
              ┌──────────┼──────────┐
              v          v          v
        ┌─────────┐ ┌─────────┐ ┌─────────┐
        │ Python  │ │  Rust   │ │ Python  │
        │ ML xizm │ │ yadro   │ │ API xizm│
        └─────────┘ └─────────┘ └─────────┘
           (har biri — Docker, mustaqil, gRPC)

Mikroservis tizim dizayni — bir tizimni mustaqil xizmatlarga bo'lish: har xizmat bir vazifa (ML, yadro, shlyuz), mustaqil (o'z tili, o'z deploy, o'z miqyos — 25-qism), aloqa orqali (gRPC/REST). Sabab: katta tizim bir bo'lak (monolit) bo'lsa — qiyin (bir o'zgarish — hammasi, bir til — barchaga); mikroservis ajratadi (har xizmat mustaqil — alohida til, deploy, miqyos). Farq monolitdan: monolit (bir dastur, oddiy — kichik), mikroservis (ko'p xizmat, moslashuvchan — katta). Bu 25-qism (mikroservis) amaliyoti. Dizayn — mustaqil xizmat, bir vazifa, aloqa. Ajratish. Katta tizim.

2.2. Xizmat ajratish (to'g'ri til)

Har xizmat o'z tilida:

Go shlyuz     — API gateway (yuqori yuk, goroutine)
Python ML     — mashina o'rganish (ekotizim, oson)
Rust yadro    — CPU-og'ir hisob (tez, xavfsiz)
Python API    — biznes logika (tez ishlab chiqish)

→ har xizmat vazifasiga mos til (to'g'ri til to'g'ri ishga)

Xizmat ajratish (to'g'ri til) — har xizmatni vazifasiga qarab ajratish va tilni tanlash (30.16 to'g'ri til to'g'ri ishga): Go (shlyuz — yuqori yuk, parallel 30.13), Python (ML/API — ekotizim, oson), Rust (yadro — CPU-og'ir, tez, xavfsiz 30.9). Sabab: har xizmat farqli talab (shlyuz — yuk, ML — ekotizim, yadro — tezlik); mikroservis erkinlik beradi (har xizmat o'z tili — mustaqil); to'g'ri til har xizmatga optimal. Bu polyglot 30.16-bob amaliyoti mikroservisda: xizmatlar mustaqil (til erkin), aloqa orqali. Xizmat ajratish — vazifaga mos til. To'g'ri til. Mustaqil.

2.3. Xizmatlararo aloqa (gRPC)

Xizmatlar qanday gaplashadi:

// rasm.proto — xizmat shartnomasi (gRPC — 30.14)
service RasmXizmat {
    rpc OlchamOzgartir(RasmSorov) returns (RasmJavob);
}

# Python shlyuz → Rust yadro (gRPC)
stub = RasmXizmatStub(kanal)
javob = stub.OlchamOzgartir(sorov)   # Rust xizmatga (tez, binar)

Xizmatlararo aloqa (gRPC) — mikroservislar qanday gaplashadi: gRPC (30.14 — tez binar, .proto shartnoma, kod generatsiya — polyglot, Python↔Rust↔Go) yoki REST (23-qism — ommaviy). Sabab: xizmatlar mustaqil (alohida jarayon/til — 25-qism); ular tarmoq orqali gaplashishi kerak; gRPC ideal (tez — yuqori yuk, shartnoma — .proto, polyglot — turli til). .proto (yagona shartnoma — barcha xizmat) → kod har til uchun. Ichki aloqa gRPC (tez), tashqi REST (ommaviy — 30.14 tanlov). Bu 30.14 (gRPC) amaliyoti. Aloqa — gRPC (ichki, tez), REST (tashqi). Shartnoma. Polyglot.

2.4. Docker va deploy

Har xizmat konteynerda:

# har xizmat o'z Dockerfile'i (28-qism)
# Python xizmat:
FROM python:3.12-slim
COPY . /app
RUN pip install -r requirements.txt
CMD ["python", "xizmat.py"]

# docker-compose.yml — barcha xizmat birga
# go_shlyuz, python_ml, rust_yadro — alohida konteyner

Docker va deploy — har xizmatni konteynerda joylashtirish: Dockerfile (har xizmat — o'z image, 28-qism), docker-compose (barcha xizmat birga — mahalliy/kichik), Kubernetes (28-qism — katta, avtomatik miqyos/tiklash). Sabab: mikroservis mustaqil deploy kerak (har xizmat alohida — 25-qism); Docker buni beradi (har xizmat konteyner — mustaqil, izolyatsiya); turli til (Python, Rust, Go) — har biri o'z Docker (bog'liqliklar ichida). docker-compose mahalliy sinash (barcha xizmat), Kubernetes ishlab chiqarish (miqyos). Bu 28-qism (Docker/K8s) amaliyoti. Docker — har xizmat konteyner. compose/K8s. Mustaqil deploy.

2.5. Umumiy masalalar (kuzatuv, topish)

Mikroservis qiyinchiliklari:

XIZMAT TOPISH (service discovery):
   xizmat B qayerda? (IP o'zgaradi — DNS/registr)

TAQSIMLANGAN KUZATUV (tracing):
   bir so'rov ko'p xizmat bo'ylab (qayer sekin?)

MARKAZLASHGAN LOG:
   barcha xizmat logi bir joyda (izlash)

CHIDAMLILIK:
   bir xizmat qulasa — boshqalar davom (27.12)

Umumiy masalalar — mikroservisning qo'shimcha qiyinchiliklari: xizmat topish (service discovery — xizmat qayerda, IP o'zgaradi — DNS/registr, K8s hal qiladi), taqsimlangan kuzatuv (distributed tracing — bir so'rov ko'p xizmat bo'ylab, qayer sekin/xato — 29.9), markazlashgan log (barcha xizmat logi bir joyda — izlash oson), chidamlilik (bir xizmat qulasa — boshqalar davom, circuit breaker — 27.9/27.12). Sabab: mikroservis taqsimlangan (ko'p xizmat — tarmoq, mustaqil); bu yangi muammolar (topish, kuzatuv, xato — monolitda yo'q); ularni hal qilish kerak (aks holda — boshqarib bo'lmaydi). Bu mikroservis narxi (25-qism, 30.16 — murakkablik). Umumiy masalalar — topish, kuzatuv, log, chidamlilik. Taqsimlangan narx.

2.6. Loyiha amaliyoti

Mikroservis loyiha amaliyotlari: xizmat chegarasi (har xizmat bir vazifa — 25-qism, mantiqli ajratish); to'g'ri til (vazifaga mos — Go shlyuz, Python ML, Rust yadro); gRPC (ichki aloqa — 30.14, .proto shartnoma); Docker (har xizmat konteyner — 28-qism); kuzatuv (taqsimlangan tracing, markazlashgan log); chidamlilik (bir xizmat qulasa — davom, 27.12); oddiy boshla (monolit yoki kam xizmat, keyin bo'l — 30.16). Tuzoqlar: erta mikroservis (kichik loyiha — monolit yetadi, murakkablik), juda mayda xizmat (ko'p aloqa — kechikish), shartnomasiz aloqa (mos kelmaslik — 30.14), kuzatuvsiz (taqsimlangan — jim buziladi). Amaliyot — chegara, to'g'ri til, gRPC, Docker, kuzatuv. Mikroservis — kuchli, lekin murakkab.

2.7. Mikroservis tuzoqlari

Mikroservis asosiy tuzoqlari: erta mikroservis (kichik loyihada — monolit soddaroq, mikroservis ortiqcha murakkablik — 25/30.16, "monolit avval"); juda mayda xizmat (nano-service — ko'p tarmoq aloqa, kechikish, murakkablik); taqsimlangan monolit (xizmatlar juda bog'langan — bir o'zgarish hammaga, mikroservis foydasi yo'q); shartnomasiz (.proto yo'q — mos kelmaslik, 30.14); kuzatuvsiz (taqsimlangan — qayer xato bilinmaydi); chidamliliksiz (bir xizmat qulasa — kaskad, hammasi); ma'lumot izchilligi (ko'p baza — tranzaksiya qiyin). Sabab: mikroservis kuchli, lekin murakkab (taqsimlangan — yangi muammolar); noto'g'ri qo'llasa — narx foydadan ko'p. Yechim: oddiy boshla (monolit), zarurat bilan bo'l (30.16 — ongli). Tuzoqlar — erta, mayda, bog'langan, shartnomasiz. Ongli, oddiy boshla.

2.8. Mikroservis — barcha bilimlarning sintezi

Mikroservisli tizim loyiha asosiy g'oyasi — barcha bilimlarning sintezi: bu loyiha kursning hammasini birlashtiradi — mikroservis (25-qism), polyglot (30-qism — to'g'ri til), API 31.2-bob, ma'lumot 31.3-bob, Docker (28-qism), aloqa (30.14 gRPC), chidamlilik (27-qism), kuzatuv (29-qism). Bu real, katta tizim dizayni (senior dasturchi daraja); har xizmat o'z kuchida (Go yuk, Python ML, Rust yadro — 30.16), gRPC aloqa, Docker deploy. Lekin murakkablik narxi (taqsimlangan — topish, kuzatuv, chidamlilik — 30.16); shuning uchun ongli (oddiy boshla, zarurat bilan). Portfolioda eng ta'sirli (31.8 — "men polyglot mikroservisli tizim qurdim"); tizim dizayni suhbati 31.12-bob uchun asos. Mikroservis — barcha bilim sintezi. Senior daraja. Ongli murakkablik.

3. Tez ma'lumotnoma

MIKROSERVIS TIZIM (polyglot):
   Go shlyuz (yuqori yuk) → Python ML + Rust yadro + Python API
   har xizmat — Docker, mustaqil, gRPC aloqa

XIZMAT AJRATISH (to'g'ri til — 30.16):
   Go — shlyuz (parallel) · Python — ML/API (ekotizim)
   Rust — yadro (CPU-og'ir, xavfsiz)

ALOQA (gRPC — 30.14):
   .proto (shartnoma) → kod har til · ichki gRPC, tashqi REST

DOCKER (28-qism):
   har xizmat Dockerfile · docker-compose / Kubernetes

UMUMIY MASALALAR:
   xizmat topish · taqsimlangan kuzatuv · log · chidamlilik

QOIDA: oddiy boshla (monolit) · zarurat bilan bo'l · shartnoma · kuzatuv

Mikroservis xulosasi

Mikroservis — ko'p tildagi mustaqil xizmatlar (polyglot tizim)
Xizmat ajratish — to'g'ri til (Go yuk, Python ML, Rust yadro)
Aloqa — gRPC (.proto shartnoma, ichki) · REST (tashqi)
Docker — har xizmat konteyner (mustaqil deploy, K8s miqyos)
Umumiy masalalar — topish, kuzatuv, chidamlilik (taqsimlangan narx)

4. Batafsil misollar

To'liq tizim ko'p til/vosita talab qiladi; misollar tizim dizayni mantiqini (deterministik) modellashtiradi.

Misol 1 — Xizmat ajratish (to'g'ri til)

"""Xizmat ajratish: har xizmat vazifasiga mos til (model)."""


XIZMATLAR = {
    "shlyuz": {"til": "Go", "sabab": "yuqori yuk (goroutine)"},
    "ml": {"til": "Python", "sabab": "ekotizim (ML)"},
    "yadro": {"til": "Rust", "sabab": "CPU-og'ir (tez, xavfsiz)"},
    "api": {"til": "Python", "sabab": "tez ishlab chiqish"},
}


def main() -> None:
    print("=== 1. Xizmatlar ===")
    for nom, info in XIZMATLAR.items():
        print(f"  {nom:8} → {info['til']:8} ({info['sabab']})")

    print("\n=== 2. To'g'ri til 30.16-bob ===")
    print("  har xizmat vazifasiga mos til")

    print("\n=== 3. Mustaqil ===")
    print("  har xizmat o'z tili, deploy, miqyos")

    print("\n=== 4. Ajratish ===")
    print("  bir vazifa — bir xizmat (25-qism)")
    print("  ⭐ Xizmat ajratish — to'g'ri til to'g'ri joyga")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xizmatlar ===
  shlyuz   → Go       (yuqori yuk (goroutine))
  ml       → Python   (ekotizim (ML))
  yadro    → Rust     (CPU-og'ir (tez, xavfsiz))
  api      → Python   (tez ishlab chiqish)

=== 2. To'g'ri til 30.16-bob ===
  har xizmat vazifasiga mos til

=== 3. Mustaqil ===
  har xizmat o'z tili, deploy, miqyos

=== 4. Ajratish ===
  bir vazifa — bir xizmat (25-qism)
  ⭐ Xizmat ajratish — to'g'ri til to'g'ri joyga

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Xizmatlararo aloqa (so'rov oqimi)

"""Xizmatlararo aloqa: so'rov ko'p xizmat bo'ylab (model)."""


def sorov_oqim(sorov: str) -> list:
    return [
        f"mijoz → Go shlyuz ({sorov})",
        "Go shlyuz → auth tekshir",
        "Go shlyuz → Rust yadro (rasm o'lchami — gRPC)",
        "Rust yadro → Python ML (tahlil — gRPC)",
        "Python ML → Go shlyuz → mijoz (javob)",
    ]


def main() -> None:
    print("=== 1. So'rov oqimi ===")
    for i, qadam in enumerate(sorov_oqim("rasm yuborish"), 1):
        print(f"  {i}. {qadam}")

    print("\n=== 2. gRPC aloqa 30.14-bob ===")
    print("  xizmatlar orasi — tez binar, .proto shartnoma")

    print("\n=== 3. Bir so'rov ko'p xizmat ===")
    print("  taqsimlangan (tracing kerak — qayer sekin)")

    print("\n=== 4. Polyglot ===")
    print("  Go + Rust + Python — gRPC bilan gaplashadi")
    print("  ⭐ Xizmatlararo aloqa — gRPC (polyglot)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. So'rov oqimi ===
  1. mijoz → Go shlyuz (rasm yuborish)
  2. Go shlyuz → auth tekshir
  3. Go shlyuz → Rust yadro (rasm o'lchami — gRPC)
  4. Rust yadro → Python ML (tahlil — gRPC)
  5. Python ML → Go shlyuz → mijoz (javob)

=== 2. gRPC aloqa 30.14-bob ===
  xizmatlar orasi — tez binar, .proto shartnoma

=== 3. Bir so'rov ko'p xizmat ===
  taqsimlangan (tracing kerak — qayer sekin)

=== 4. Polyglot ===
  Go + Rust + Python — gRPC bilan gaplashadi
  ⭐ Xizmatlararo aloqa — gRPC (polyglot)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Chidamlilik (xizmat qulashi)

"""Chidamlilik: bir xizmat qulasa, boshqalar davom (model)."""


class Tizim:
    def __init__(self) -> None:
        self.xizmatlar = {"shlyuz": True, "ml": True, "yadro": True}

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

    def sorov(self, kerakli: list) -> str:
        # circuit breaker: qulagan xizmatga bormaydi
        uzilgan = [x for x in kerakli if not self.xizmatlar[x]]
        if uzilgan:
            return f"qisman xizmat (uzilgan: {uzilgan})"
        return "to'liq xizmat"


def main() -> None:
    tizim = Tizim()

    print("=== 1. Barcha xizmat ishlaydi ===")
    print(f"  {tizim.sorov(['shlyuz', 'ml', 'yadro'])}")

    print("\n=== 2. ML xizmat quladi ===")
    tizim.xizmat_qulaydi("ml")
    print(f"  {tizim.sorov(['shlyuz', 'ml'])}")

    print("\n=== 3. Yadro hali ishlaydi ===")
    print(f"  {tizim.sorov(['shlyuz', 'yadro'])}")

    print("\n=== 4. Chidamlilik ===")
    print("  bir qulasa — boshqalar davom (kaskad emas)")
    print("  ⭐ Chidamlilik — circuit breaker 27.12-bob")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barcha xizmat ishlaydi ===
  to'liq xizmat

=== 2. ML xizmat quladi ===
  qisman xizmat (uzilgan: ['ml'])

=== 3. Yadro hali ishlaydi ===
  to'liq xizmat

=== 4. Chidamlilik ===
  bir qulasa — boshqalar davom (kaskad emas)
  ⭐ Chidamlilik — circuit breaker (27.12)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Monolit vs mikroservis (tanlov)

"""Monolit vs mikroservis: qachon qaysi (model)."""


def qaror(loyiha: dict) -> str:
    ball = loyiha["katta"] + loyiha["kop_jamoa"] + loyiha["har_xil_talab"]
    if ball >= 2:
        return "mikroservis (mustaqil xizmatlar)"
    return "monolit (oddiy, avval)"


def main() -> None:
    kichik = {"katta": 0, "kop_jamoa": 0, "har_xil_talab": 0}
    katta = {"katta": 1, "kop_jamoa": 1, "har_xil_talab": 1}

    print("=== 1. Kichik loyiha ===")
    print(f"  qaror: {qaror(kichik)}")

    print("\n=== 2. Katta tizim ===")
    print(f"  qaror: {qaror(katta)}")

    print("\n=== 3. Oddiy boshla ===")
    print("  monolit avval, zarurat bilan bo'l")

    print("\n=== 4. Narx ===")
    print("  mikroservis — kuch, lekin murakkablik 30.16-bob")
    print("  ⭐ Monolit vs mikroservis — ongli tanlov")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Kichik loyiha ===
  qaror: monolit (oddiy, avval)

=== 2. Katta tizim ===
  qaror: mikroservis (mustaqil xizmatlar)

=== 3. Oddiy boshla ===
  monolit avval, zarurat bilan bo'l

=== 4. Narx ===
  mikroservis — kuch, lekin murakkablik 30.16-bob
  ⭐ Monolit vs mikroservis — ongli tanlov

Nima ko'rsatdi: 2.7-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Erta mikroservis

# kichik loyihaga mikroservis (murakkablik)                  # ⚠️
# monolit avval, zarurat bilan bo'l 30.16-bob                   # ✅

2. Shartnomasiz aloqa

# xizmatlar turli JSON (mos kelmaslik)                       # ⚠️
# .proto (gRPC shartnoma — 30.14)                             # ✅

3. Chidamliliksiz (kaskad)

# bir xizmat qulaydi → hammasi (kaskad)                      # ⚠️
# circuit breaker (bir qulasa — davom — 27.12)                # ✅

4. Kuzatuvsiz

# so'rov sekin, qaysi xizmat bilinmaydi                      # ⚠️
# taqsimlangan tracing (bir so'rov bo'ylab)                    # ✅

5. Juda mayda xizmat

# har funksiya alohida xizmat (ko'p aloqa)                   # ⚠️
# mantiqli chegara (bir vazifa — bir xizmat)                  # ✅

6. Taqsimlangan monolit

# xizmatlar juda bog'langan (bir o'zgarish hammaga)          # ⚠️
# mustaqil xizmat (aniq chegara, shartnoma)                   # ✅

7. Noto'g'ri til (majburlash)

# hammani bir tilda (kuchsiz sohada kurash)                  # ⚠️
# to'g'ri til har xizmatga 30.16-bob                            # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 25-qism (o'tilgan): Mikroservis asoslari
• 30-qism (o'tilgan): Polyglot, gRPC
• 31.2-dars (o'tilgan): API xizmat
• 28-qism (o'tilgan): Docker/Kubernetes
• 31.12-dars: Tizim dizayni suhbati

8. Eng yaxshi amaliyotlar

1. Oddiy boshla (monolit), zarurat bilan bo'l.

2. To'g'ri til har xizmatga 30.16-bob.

3. gRPC + .proto (ichki aloqa, shartnoma).

4. Docker (har xizmat konteyner, mustaqil).

5. Chidamlilik (circuit breaker — kaskad yo'q).

6. Taqsimlangan kuzatuv (tracing, markaz log).

7. Mantiqli chegara (bir vazifa — bir xizmat).

8. Ongli murakkablik (narx vs foyda — 30.16).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # mikroservis nima?
2.  # monolit vs mikroservis?
3.  # xizmat ajratish?
4.  # to'g'ri til nima?
5.  # aloqa qanday?
6.  # nega gRPC?
7.  # Docker roli?
8.  # xizmat topish nima?
9.  # taqsimlangan kuzatuv?
10. # chidamlilik nima?
11. # asosiy tuzoq?
12. # qachon mikroservis?

Vazifa 2: Xatolarni tuzating

1.  # kichik loyihaga mikroservis

2.  # xizmatlar turli JSON

3.  # bir qulaydi → hammasi

4.  # so'rov sekin, qaysi xizmat?

5.  # hammani bir tilda

1.  monolit avval (keyin ajrat)

2.  .proto (gRPC shartnoma)

3.  circuit breaker (chidamlilik)

4.  taqsimlangan tracing

5.  to'g'ri til har xizmatga

Vazifa 3: Xizmat ajratish

Modellang:

1. Shlyuz (Go)
2. ML (Python)
3. Yadro (Rust)
4. To'g'ri til

Vazifa 4: Aloqa

Modellang:

1. So'rov oqimi
2. gRPC
3. Shartnoma
4. Polyglot

Vazifa 5: Chidamlilik

Modellang:

1. Barcha ishlaydi
2. Bir qulaydi
3. Boshqa davom
4. Circuit breaker

Vazifa 6: Tanlov

Modellang:

1. Kichik
2. Katta
3. Oddiy boshla
4. Narx

Vazifa 7: O'ylash

Mikroservisli tizim kuchli (mustaqil, polyglot, miqyoslanadigan), lekin murakkab (taqsimlangan — topish, kuzatuv, chidamlilik). Nima uchun "oddiy boshla, zarurat bilan murakkablashtir" (monolitdan boshlab, kerak bo'lganda bo'lish) tajribali muhandisning yondashuvi, va nega "boshidan murakkab arxitektura" (premature complexity) ko'pincha xato?

Nimani mustahkamlaydi: 2.7, 2.8-bo'limlar.

Xulosa

Bu darsda mikroservisli polyglot tizim loyihasini o'rgandik.

Eng muhim uch fikr:

1. Tizim dizayni va xizmat ajratish. Mikroservis tizim dizayni — bir tizimni mustaqil xizmatlarga bo'lish: har xizmat bir vazifa, mustaqil (o'z til/deploy/miqyos — 25-qism), aloqa orqali (gRPC/REST); monolit (bir dastur, kichik) vs mikroservis (ko'p xizmat, katta). Xizmat ajratish (to'g'ri til) — vazifaga qarab til: Go (shlyuz — yuqori yuk parallel 30.13), Python (ML/API — ekotizim), Rust (yadro — CPU-og'ir, xavfsiz 30.9); polyglot 30.16-bob mikroservisda — har xizmat o'z kuchida.

2. Aloqa, Docker va umumiy masalalar. Xizmatlararo aloqa (gRPC): 30.14 — tez binar, .proto shartnoma (yagona — barcha xizmat), kod har til; ichki gRPC (tez), tashqi REST. Docker va deploy: har xizmat Dockerfile (o'z image — 28-qism), docker-compose (mahalliy), Kubernetes (katta — miqyos/tiklash); mustaqil deploy. Umumiy masalalar — taqsimlangan qiyinchiliklar: xizmat topish (IP o'zgaradi — DNS/registr), taqsimlangan kuzatuv (bir so'rov ko'p xizmat — tracing), markazlashgan log, chidamlilik (bir qulasa — davom, circuit breaker 27.12); mikroservis narxi.

3. Tuzoqlar va barcha bilim sintezi. Mikroservis tuzoqlari: erta mikroservis (kichik — monolit soddaroq), juda mayda xizmat (ko'p aloqa — kechikish), taqsimlangan monolit (bog'langan), shartnomasiz, kuzatuvsiz, chidamliliksiz; kuchli lekin murakkab — ongli (oddiy boshla, zarurat bilan bo'l). Mikroservisli tizim — barcha bilimlarning sintezi (mikroservis 25, polyglot 30, API 31.2, ma'lumot 31.3, Docker 28, gRPC 30.14, chidamlilik 27, kuzatuv 29); real katta tizim (senior daraja), portfolioda ta'sirli, tizim dizayni suhbati 31.12-bob asosi. "Oddiy boshla, zarurat bilan murakkablashtir" (YAGNI — kutilgan murakkablik ko'pincha kelmaydi, oldindan bilib bo'lmaydi); premature complexity — premature optimization kabi xato (isbotsiz narx).

Keyingi darsda Git va jamoada ishlash ni o'rganamiz: real jamoa ishi — Git branching (branch/merge), Pull Request, kod review jarayoni, konfliktlarni hal qilish va jamoada samarali hamkorlik.