IlmHamroh
Python kursi/Arxitektura12/12-dars19 daqiqa
Mundarija (22)

27.12-dars: Xatolarga chidamlilik naqshlari

27-QISM — ARXITEKTURA · 12-dars

1. Kirish va motivatsiya

Katta, taqsimlangan tizimlarda (mikroservis — 27.9) xatolar muqarrar: tarmoq uziladi, xizmat yiqiladi, ma'lumotlar bazasi sekinlashadi, tashqi API javob bermaydi. Savol "xato bo'ladimi?" emas, "xato bo'lganda tizim nima qiladi?". Agar bir xizmat yiqilsa butun tizim qulasa — bu mo'rt (fragile) tizim. Agar xato izolyatsiya qilinsa, tizim qisman ishlashda davom etsa — bu chidamli (resilient) tizim. Xatolarga chidamlilik naqshlari — xatolarni boshqarish va tizimni bardoshli qilishning sinalgan yechimlari: Retry, Circuit Breaker, Timeout, Bulkhead, Fallback. Ular xatoni yo'q qilmaydi (imkonsiz), balki uning ta'sirini cheklaydi.

Xatolarga chidamlilik naqshlari (resilience patterns) — taqsimlangan tizimda xatolarni nafis boshqarish yechimlari: Retry (qayta urinish — vaqtinchalik xato o'tib ketishi mumkin), Circuit Breaker (uzgich — yiqilgan xizmatga urinishni to'xtatish), Timeout (vaqt chegarasi — cheksiz kutmaslik), Bulkhead (to'siq — bir qismning yiqilishi boshqasiga tarqalmasin), Fallback (zaxira — xato bo'lsa muqobil javob). Ular tizimni fail gracefully (nafis yiqilish) qiladi: to'liq qulash o'rniga qisman ishlash. Bu mikroservis 27.9-bob, hodisaga asoslangan 27.10-bob tizimlarda muhim. Xatolarga chidamlilik — xato oldida ishlashda davom etish.

Real vaziyat. Bir tizimda tavsiya xizmati (recommendation) yiqilganda butun bosh sahifa ochilmasdi (xato tarqaldi) — har foydalanuvchi oq ekran ko'rdi. Chidamlilik naqshlari qo'llanildi: Timeout (tavsiya 1 soniyada javob bermasa — kutmaslik), Fallback (tavsiya yo'q bo'lsa — mashhur mahsulotlarni ko'rsatish), Circuit Breaker (tavsiya doim yiqilsa — urinishni to'xtatish, darrov fallback). Endi tavsiya yiqilsa ham sahifa ochildi (mashhur mahsulotlar bilan). Tizim mo'rtdan chidamliga aylandi.

Bu darsda xatolarga chidamlilik naqshlarini o'rganamiz.

Bu darsda:

  • Xatolarga chidamlilik nima
  • Retry (qayta urinish)
  • Timeout (vaqt chegarasi)
  • Circuit Breaker (uzgich)
  • Fallback (zaxira javob)
  • Bulkhead (to'siq)
  • Naqshlarni birlashtirish
  • Amaliy: chidamli chaqiruv

ℹ Misollar sof Python bilan xato boshqarishni ko'rsatadi — deterministik (yiqilish simulyatsiya).

2. Nazariya — chuqur tushuntirish

2.1. Xatolarga chidamlilik nima

Xato oldida ishlashda davom etish:

Xato muqarrar (tarmoq, xizmat, API)
Mo'rt tizim: bir xato → butun qulash
Chidamli tizim: xato izolyatsiya → qisman ishlash
   "fail gracefully" (nafis yiqilish)

Xatolarga chidamlilik (resilience) — tizimning xatolar oldida ishlashda davom etish qobiliyati: xato muqarrar (tarmoq, xizmat yiqilishi) — savol xato bo'lishi emas, xato bo'lganda tizim nima qilishi. Mo'rt (fragile) tizim — bir xato butun tizimni qulatadi; chidamli (resilient) — xatoni izolyatsiya qiladi, qisman ishlaydi ("fail gracefully" — nafis yiqilish). Sabab: taqsimlangan tizimda (mikroservis) xato normal (ko'p qism, tarmoq). Chidamlilik naqshlari xatoni yo'q qilmaydi, ta'sirini cheklaydi. Chidamlilik — xato oldida omon qolish.

2.2. Retry (qayta urinish)

Vaqtinchalik xatoni qayta urinish:

python
def qayta_urinish(amal, max_urinish=3):
    for urinish in range(max_urinish):
        try:
            return amal()
        except XatoTuri:
            if urinish == max_urinish - 1: raise
            # kutish (backoff) — keyin qayta urinish

Retry (qayta urinish) — xato bo'lganda amalni qayta urinish: ko'p xato vaqtinchalik (tarmoq to'lqini, qisqa uzilish) — qayta urinish o'tib ketishi mumkin. Muhim: backoff (kutish — har urinishda ko'proq: 1s, 2s, 4s — "exponential backoff", tizimni bosmaslik), jitter (tasodifiy kechikish — hamma birga urinmasin), chegara (max urinish — cheksiz emas). Ehtiyot: faqat vaqtinchalik xatoga (tarmoq), doimiy xatoga (400 — noto'g'ri so'rov) emas; idempotent amalga (26.9 — qayta bajarish zararsiz). Retry — vaqtinchalik xatoni yengish. Qayta urinish — lekin ehtiyot bilan.

2.3. Timeout (vaqt chegarasi)

Cheksiz kutmaslik:

python
# javob berilgan vaqtda kelmasa — voz kechish
try:
    natija = amal(timeout=1.0)   # 1 soniya kut
except TimeoutError:
    # kutishni to'xtatish (fallback yoki xato)
    ...

Timeout (vaqt chegarasi) — amalga maksimal kutish vaqti: agar javob shu vaqtda kelmasa — voz kechish (kutishni to'xtatish). Sabab: cheksiz kutish — xavfli (yiqilgan xizmatni kutib, o'z resurslaringni bloklab qolasan — zanjir yiqilish); timeout — resursni ozod qiladi (kutmaslik, keyingi amal). Har tashqi chaqiruv (tarmoq, baza, API) timeout bilan bo'lishi kerak. Timeout qiymati — muvozanat (juda qisqa — noto'g'ri voz kechish, juda uzun — sekin). Timeout — kutishni cheklash (resurs himoyasi). Cheksiz kutish — sekin o'lim.

2.4. Circuit Breaker (uzgich)

Yiqilgan xizmatga urinishni to'xtatish:

Circuit Breaker holatlari:
CLOSED (yopiq) — normal, chaqiruvlar o'tadi
   ko'p xato → OPEN
OPEN (ochiq) — chaqiruv to'xtatiladi (darrov xato/fallback)
   biroz vaqt → HALF-OPEN (sinov)
HALF-OPEN — bitta sinov chaqiruv; muvaffaqiyat → CLOSED

Circuit Breaker (uzgich — elektr uzgichi kabi) — doim yiqilayotgan xizmatga urinishni to'xtatadi: agar xizmat ketma-ket ko'p marta yiqilsa, uzgich "ochiladi" (OPEN) — keyingi chaqiruvlar darrov xato/fallback qaytaradi (yiqilgan xizmatni kutmasdan). Biroz vaqtdan keyin "yarim ochiladi" (HALF-OPEN) — bitta sinov chaqiruv; muvaffaqiyatli bo'lsa "yopiladi" (CLOSED — normal). Sabab: yiqilgan xizmatga qayta-qayta urinish — behuda (resurs, vaqt), zanjir yiqilishni kuchaytiradi; uzgich — tez voz kechish (fail fast). Circuit Breaker — yiqilgan xizmatdan himoya. Uzgich — behuda urinishni to'xtatish.

2.5. Fallback (zaxira javob)

Xato bo'lsa muqobil javob:

python
def tavsiyalar_ol(foydalanuvchi):
    try:
        return tavsiya_xizmati.ol(foydalanuvchi)   # asosiy
    except Xato:
        return mashhur_mahsulotlar()   # fallback (zaxira)
# xato bo'lsa ham — foydali javob (mukammal emas)

Fallback (zaxira/qaytish) — asosiy amal muvaffaqiyatsiz bo'lsa, muqobil javob berish: tavsiya xizmati yiqilsa — mashhur mahsulotlar (mukammal emas, lekin foydali). Sabab: xato bo'lsa ham foydalanuvchiga nimadir berish (oq ekran emas — "fail gracefully"). Fallback turlari: keshlangan qiymat (eski, lekin bor), standart qiymat (bo'sh ro'yxat), soddalashtirilgan javob (mashhur mahsulot). Fallback — xatoni foydalanuvchidan yashirish (yaxshi tajriba). Zaxira — mukammal emas, lekin ishlaydigan. Xato bo'lsa ham — foydali javob.

2.6. Bulkhead (to'siq)

Bir yiqilish boshqasiga tarqalmasin:

Kema bulkhead (to'siq): bir bo'lim suvga to'lsa,
   boshqa bo'limlar himoyalangan (kema cho'kmaydi)

Tizim: har xizmatga alohida resurs (thread pool)
   bir xizmat resursni tugatsa — boshqalar ishlaydi

Bulkhead (to'siq — kemadagi suv o'tkazmas bo'lmalar) — tizim qismlarini izolyatsiya qiladi, bir qismning yiqilishi boshqasiga tarqalmasin: har xizmatga alohida resurs (thread pool, ulanish havzasi) — bir xizmat resursni tugatsa (sekin, yiqilgan), boshqa xizmatlar o'z resurslari bilan ishlaydi. Analogiya: kema bo'limlari (bir bo'lim suvga to'lsa, kema cho'kmaydi). Sabab: umumiy resurs — bir yiqilish hammani bloklaydi (bir sekin xizmat barcha threadni egallaydi); izolyatsiya — xato mahalliy. Bulkhead — xatoni bir qismda ushlab qolish. To'siq — yiqilishni izolyatsiya.

2.7. Naqshlarni birlashtirish

Chidamlilik naqshlari birga ishlatiladi (bir chaqiruvda bir necha): masalan tashqi API chaqiruvi — Timeout (uzoq kutmaslik) + Retry (vaqtinchalik xatoga qayta urinish, backoff bilan) + Circuit Breaker (doim yiqilsa to'xtatish) + Fallback (baribir muvaffaqiyatsiz bo'lsa zaxira). Tartib muhim: Circuit Breaker → Timeout → Retry → Fallback. Ehtiyot: Retry va Circuit Breaker muvozanati (ko'p retry — uzgichni tez ochadi). Kutubxonalar buni ta'minlaydi (Python: tenacity — retry, pybreaker — circuit breaker). Naqshlar qatlam-qatlam himoya (har biri bir xato turiga). Birlashtirish — to'liq chidamlilik. Ko'p naqsh — ko'p himoya.

2.8. Chidamlilik — xatoni normal deb qabul qilish

Chidamlilik naqshlari asosiy g'oyasi — xatoni normal deb qabul qilish: an'anaviy fikrlash "xatosiz tizim" (imkonsiz — tarmoq, xizmat yiqiladi); chidamli fikrlash "xato bo'ladi, tayyorlan" (xato — istisno emas, kutilgan). Bu "design for failure" (yiqilish uchun loyihalash) falsafasi: har tashqi bog'liqlik yiqilishi mumkin — nima qilamiz? Chidamlilik xato boshqarish (09-dars) ning tizim darajasi (funksiya → xizmat → tizim). Bu mikroservis 27.9-bob, hodisaga asoslangan 27.10-bob, monitoring (28-qism) bilan bog'liq. Chidamli tizim — mukammal emas (xato bor), lekin omon qoladi (qisman ishlaydi). Chidamlilik — xato bilan yashashni o'rganish. Xato normal — tayyorlik muhim.

3. Tez ma'lumotnoma

python
# RETRY — qayta urinish (backoff bilan)
def retry(amal, max_urinish=3):
    for i in range(max_urinish):
        try: return amal()
        except VaqtinchalikXato:
            if i == max_urinish - 1: raise
            # kut (backoff): 1s, 2s, 4s

# TIMEOUT — vaqt chegarasi
# natija = amal(timeout=1.0)  # kelmasa TimeoutError

# CIRCUIT BREAKER — uzgich
# CLOSED (normal) → ko'p xato → OPEN (to'xta)
# → biroz vaqt → HALF-OPEN (sinov) → CLOSED

# FALLBACK — zaxira javob
def ol():
    try: return asosiy()
    except Xato: return zaxira()   # muqobil

# BULKHEAD — izolyatsiya (alohida resurs)
# har xizmatga alohida pool (bir yiqilish tarqalmaydi)

# BIRGA: Timeout + Retry + Circuit Breaker + Fallback
# Kutubxona: tenacity (retry), pybreaker (circuit)

Xatolarga chidamlilik naqshlari xulosasi

Retry — qayta urinish (vaqtinchalik xato, backoff)
Timeout — vaqt chegarasi (cheksiz kutmaslik)
Circuit Breaker — uzgich (yiqilgan xizmatga to'xtatish)
Fallback — zaxira javob (xato bo'lsa muqobil)
Bulkhead — izolyatsiya (yiqilish tarqalmasin)
Birga: qatlam himoya · "design for failure"

4. Batafsil misollar

Misollar sof Python bilan — yiqilish simulyatsiya (deterministik).

Misol 1 — Retry (qayta urinish, backoff)

python
"""Retry: vaqtinchalik xatoda qayta urinish (backoff hisobi bilan)."""


class VaqtinchalikXizmat:
    """Dastlab yiqiladi, keyin ishlaydi (vaqtinchalik xato)."""

    def __init__(self, yiqilish_soni: int) -> None:
        self.chaqiruvlar = 0
        self.yiqilish_soni = yiqilish_soni

    def chaqir(self) -> str:
        self.chaqiruvlar += 1
        if self.chaqiruvlar <= self.yiqilish_soni:
            raise ConnectionError(f"Xato (urinish {self.chaqiruvlar})")
        return "muvaffaqiyat"


def retry(amal, max_urinish: int = 3) -> dict:
    kutishlar = []
    for urinish in range(max_urinish):
        try:
            natija = amal()
            return {"natija": natija, "urinishlar": urinish + 1, "kutishlar": kutishlar}
        except ConnectionError:
            if urinish == max_urinish - 1:
                return {"natija": "muvaffaqiyatsiz", "urinishlar": max_urinish, "kutishlar": kutishlar}
            kutishlar.append(2 ** urinish)   # backoff: 1, 2, 4...


def main() -> None:
    print("=== 1. 2 marta yiqiladi, keyin ishlaydi ===")
    xizmat = VaqtinchalikXizmat(yiqilish_soni=2)
    natija = retry(xizmat.chaqir)
    print(f"  natija: {natija['natija']}")
    print(f"  urinishlar: {natija['urinishlar']}")

    print("\n=== 2. Backoff kutishlari ===")
    print(f"  kutishlar (soniya): {natija['kutishlar']}")
    print("  har urinishda ko'proq (1, 2, 4...) — exponential")

    print("\n=== 3. Doim yiqiladi (chegara) ===")
    doim = VaqtinchalikXizmat(yiqilish_soni=10)
    natija2 = retry(doim.chaqir, max_urinish=3)
    print(f"  natija: {natija2['natija']}")
    print(f"  urinishlar: {natija2['urinishlar']} (chegarada to'xtadi)")

    print("\n=== 4. Retry qoidalari ===")
    print("  faqat vaqtinchalik xatoga (tarmoq)")
    print("  backoff (kutish), chegara (cheksiz emas)")
    print("  ⭐ Retry — vaqtinchalik xatoni yengish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 2 marta yiqiladi, keyin ishlaydi ===
  natija: muvaffaqiyat
  urinishlar: 3

=== 2. Backoff kutishlari ===
  kutishlar (soniya): [1, 2]
  har urinishda ko'proq (1, 2, 4...) — exponential

=== 3. Doim yiqiladi (chegara) ===
  natija: muvaffaqiyatsiz
  urinishlar: 3 (chegarada to'xtadi)

=== 4. Retry qoidalari ===
  faqat vaqtinchalik xatoga (tarmoq)
  backoff (kutish), chegara (cheksiz emas)
  ⭐ Retry — vaqtinchalik xatoni yengish

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Fallback (zaxira javob)

python
"""Fallback: asosiy amal yiqilsa, muqobil (zaxira) javob berish."""


class TavsiyaXizmati:
    def __init__(self, ishlaydi: bool) -> None:
        self.ishlaydi = ishlaydi

    def tavsiyalar(self, foydalanuvchi: str) -> list:
        if not self.ishlaydi:
            raise ConnectionError("Tavsiya xizmati yiqildi")
        return [f"{foydalanuvchi} uchun maxsus 1", "maxsus 2"]


def mashhur_mahsulotlar() -> list:
    """Fallback — zaxira (hamma uchun bir xil)."""
    return ["mashhur A", "mashhur B", "mashhur C"]


def tavsiyalar_ol(xizmat: TavsiyaXizmati, foydalanuvchi: str) -> dict:
    try:
        natija = xizmat.tavsiyalar(foydalanuvchi)
        return {"manba": "shaxsiy", "mahsulotlar": natija}
    except ConnectionError:
        # fallback (zaxira)
        return {"manba": "fallback", "mahsulotlar": mashhur_mahsulotlar()}


def main() -> None:
    print("=== 1. Xizmat ishlaydi (shaxsiy tavsiya) ===")
    ishlaydigan = TavsiyaXizmati(ishlaydi=True)
    natija = tavsiyalar_ol(ishlaydigan, "Ali")
    print(f"  manba: {natija['manba']}")
    print(f"  mahsulotlar: {natija['mahsulotlar']}")

    print("\n=== 2. Xizmat yiqildi (fallback) ===")
    yiqilgan = TavsiyaXizmati(ishlaydi=False)
    natija = tavsiyalar_ol(yiqilgan, "Ali")
    print(f"  manba: {natija['manba']}")
    print(f"  mahsulotlar: {natija['mahsulotlar']}")

    print("\n=== 3. Foydalanuvchi baribir javob oldi ===")
    print("  yiqilish → oq ekran emas (mashhur mahsulotlar)")

    print("\n=== 4. Fallback g'oyasi ===")
    print("  mukammal emas (shaxsiy emas), lekin foydali")
    print("  xato foydalanuvchidan yashirildi")
    print("  ⭐ Fallback — xato bo'lsa ham foydali javob")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Xizmat ishlaydi (shaxsiy tavsiya) ===
  manba: shaxsiy
  mahsulotlar: ['Ali uchun maxsus 1', 'maxsus 2']

=== 2. Xizmat yiqildi (fallback) ===
  manba: fallback
  mahsulotlar: ['mashhur A', 'mashhur B', 'mashhur C']

=== 3. Foydalanuvchi baribir javob oldi ===
  yiqilish → oq ekran emas (mashhur mahsulotlar)

=== 4. Fallback g'oyasi ===
  mukammal emas (shaxsiy emas), lekin foydali
  xato foydalanuvchidan yashirildi
  ⭐ Fallback — xato bo'lsa ham foydali javob

Nima ko'rsatdi: 2.5-bo'lim.

Misol 3 — Circuit Breaker (uzgich)

python
"""Circuit Breaker: ko'p yiqilishdan keyin urinishni to'xtatish (fail fast)."""


class CircuitBreaker:
    def __init__(self, chegara: int = 3) -> None:
        self.chegara = chegara
        self.xatolar = 0
        self.holat = "CLOSED"   # CLOSED | OPEN

    def chaqir(self, amal) -> dict:
        if self.holat == "OPEN":
            # uzgich ochiq — darrov voz kechish (fail fast)
            return {"holat": self.holat, "natija": "to'xtatildi (fail fast)"}
        try:
            natija = amal()
            self.xatolar = 0   # muvaffaqiyat — hisoblagichni tiklash
            return {"holat": self.holat, "natija": natija}
        except ConnectionError as e:
            self.xatolar += 1
            if self.xatolar >= self.chegara:
                self.holat = "OPEN"   # ko'p xato — uzgichni ochish
            return {"holat": self.holat, "natija": f"xato ({e})"}


def main() -> None:
    breaker = CircuitBreaker(chegara=3)

    def yiqiladigan() -> str:
        raise ConnectionError("xizmat yiqildi")

    print("=== 1. Ketma-ket yiqilishlar ===")
    for i in range(3):
        natija = breaker.chaqir(yiqiladigan)
        print(f"  urinish {i + 1}: holat={natija['holat']}")

    print("\n=== 2. Uzgich ochildi (OPEN) ===")
    print(f"  holat: {breaker.holat}, xatolar: {breaker.xatolar}")

    print("\n=== 3. Keyingi chaqiruvlar (fail fast) ===")
    natija = breaker.chaqir(yiqiladigan)
    print(f"  {natija['natija']}")
    print("  yiqilgan xizmatni kutmasdan darrov voz kechish")

    print("\n=== 4. Circuit Breaker foydasi ===")
    print("  behuda urinish yo'q (resurs tejaladi)")
    print("  zanjir yiqilish oldini oladi")
    print("  ⭐ Circuit Breaker — yiqilgandan himoya")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ketma-ket yiqilishlar ===
  urinish 1: holat=CLOSED
  urinish 2: holat=CLOSED
  urinish 3: holat=OPEN

=== 2. Uzgich ochildi (OPEN) ===
  holat: OPEN, xatolar: 3

=== 3. Keyingi chaqiruvlar (fail fast) ===
  to'xtatildi (fail fast)
  yiqilgan xizmatni kutmasdan darrov voz kechish

=== 4. Circuit Breaker foydasi ===
  behuda urinish yo'q (resurs tejaladi)
  zanjir yiqilish oldini oladi
  ⭐ Circuit Breaker — yiqilgandan himoya

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Naqshlarni birlashtirish (chidamli chaqiruv)

python
"""Birlashtirish: Retry + Circuit Breaker + Fallback (qatlam himoya)."""


class Xizmat:
    def __init__(self, ishlaydigan_urinish: int) -> None:
        self.chaqiruvlar = 0
        self.ishlaydigan_urinish = ishlaydigan_urinish

    def chaqir(self) -> str:
        self.chaqiruvlar += 1
        if self.chaqiruvlar < self.ishlaydigan_urinish:
            raise ConnectionError("xato")
        return "muvaffaqiyat"


def chidamli_chaqiruv(xizmat: Xizmat, max_retry: int = 2) -> dict:
    """Retry + Fallback birga."""
    for urinish in range(max_retry):
        try:
            natija = xizmat.chaqir()
            return {"manba": "asosiy", "natija": natija, "urinishlar": urinish + 1}
        except ConnectionError:
            continue   # qayta urinish
    # barcha urinish muvaffaqiyatsiz — fallback
    return {"manba": "fallback", "natija": "zaxira javob", "urinishlar": max_retry}


def main() -> None:
    print("=== 1. 2-urinishda ishlaydi (retry yordam berdi) ===")
    xizmat1 = Xizmat(ishlaydigan_urinish=2)
    natija = chidamli_chaqiruv(xizmat1)
    print(f"  manba: {natija['manba']}, natija: {natija['natija']}")
    print(f"  urinishlar: {natija['urinishlar']}")

    print("\n=== 2. Doim yiqiladi (fallback) ===")
    xizmat2 = Xizmat(ishlaydigan_urinish=10)
    natija = chidamli_chaqiruv(xizmat2)
    print(f"  manba: {natija['manba']}, natija: {natija['natija']}")

    print("\n=== 3. Qatlam himoya ===")
    print("  Retry — vaqtinchalik xatoga")
    print("  Fallback — baribir yiqilsa zaxira")

    print("\n=== 4. Chidamli tizim ===")
    print("  har holatda foydali javob (asosiy yoki zaxira)")
    print("  ko'p naqsh = ko'p himoya (qatlam)")
    print("  ⭐ Birlashtirish — to'liq chidamlilik")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 2-urinishda ishlaydi (retry yordam berdi) ===
  manba: asosiy, natija: muvaffaqiyat
  urinishlar: 2

=== 2. Doim yiqiladi (fallback) ===
  manba: fallback, natija: zaxira javob

=== 3. Qatlam himoya ===
  Retry — vaqtinchalik xatoga
  Fallback — baribir yiqilsa zaxira

=== 4. Chidamli tizim ===
  har holatda foydali javob (asosiy yoki zaxira)
  ko'p naqsh = ko'p himoya (qatlam)
  ⭐ Birlashtirish — to'liq chidamlilik

Nima ko'rsatdi: 2.7-bo'lim.

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

Noto'g'ri fikr To'g'risi
"Xatosiz tizim mumkin" Xato muqarrar (tayyorlan)
"Bir xato = to'liq qulash" Izolyatsiya (qisman ishlash)
"Retry har xatoga" Faqat vaqtinchalik (idempotent)
"Timeout keraksiz" Cheksiz kutish xavfli
"Yiqilgan xizmatga urinish" Circuit Breaker (to'xtat)
"Xato = oq ekran" Fallback (zaxira javob)
"Umumiy resurs" Bulkhead (izolyatsiya)
"Bir naqsh yetadi" Birlashtirish (qatlam)

6. Keng tarqalgan xatolar va yechimlari

1. Timeout yo'q (cheksiz kutish)

python
natija = tashqi_api()   # cheksiz kutish       # ⚠️
natija = tashqi_api(timeout=1.0)               # ✅

2. Retry backoff'siz (tizimni bosadi)

python
for i in range(100): retry()  # darrov qayta   # ⚠️
# backoff (1s, 2s, 4s) + jitter                # ✅

3. Retry doimiy xatoga

python
# 400 (noto'g'ri so'rov) ni qayta urinish       # ⚠️
# faqat vaqtinchalik (503, tarmoq)              # ✅

4. Circuit Breaker yo'q (behuda urinish)

python
# yiqilgan xizmatga qayta-qayta               # ⚠️
# circuit breaker (fail fast)                  # ✅

5. Fallback yo'q (xato foydalanuvchiga)

python
return tashqi_api()   # yiqilsa oq ekran       # ⚠️
try: ... except: return zaxira()               # ✅

6. Retry idempotent bo'lmagan amalga

python
# to'lovni qayta urinish (ikki marta to'lov!)   # ⚠️
# idempotent (yoki idempotency key)             # ✅

7. Xatoni yashirish (jim yutish)

python
try: ... except: pass   # xato ko'rinmaydi     # ⚠️
except: log(); fallback()  # log + fallback     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 27.9-dars (o'tilgan): Mikroservis — taqsimlangan xato
  • 27.10-dars (o'tilgan): Hodisaga asoslangan — xato izolyatsiya
  • 09-dars (o'tilgan): Xatolar — asosiy boshqarish
  • 28-qism: Monitoring — xato kuzatuvi
  • 29-qism: Miqyoslash — yuk va chidamlilik

8. Eng yaxshi amaliyotlar

  1. Har tashqi chaqiruvga timeout.

  2. Retry — backoff + chegara (vaqtinchalik xatoga).

  3. Circuit breaker (yiqilgan xizmatga fail fast).

  4. Fallback (xato bo'lsa zaxira javob).

  5. Bulkhead (resurs izolyatsiyasi).

  6. Idempotent amalga retry (yoki idempotency key).

  7. Naqshlarni birlashtir (qatlam himoya).

  8. Xatoni logla (jim yutma) + design for failure.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # xatolarga chidamlilik nima?
2.  # mo'rt vs chidamli?
3.  # Retry nima?
4.  # backoff nima?
5.  # Retry qaysi xatoga?
6.  # Timeout nima?
7.  # cheksiz kutish nega yomon?
8.  # Circuit Breaker nima?
9.  # OPEN holat nima?
10. # Fallback nima?
11. # Bulkhead nima?
12. # design for failure nima?
Javoblar
  1. Xato oldida ishlashda davom etish
  2. Mo'rt: bir xato qulaydi; chidamli: qisman ishlaydi
  3. Xatoda qayta urinish
  4. Har urinishda ko'proq kutish
  5. Faqat vaqtinchalik (idempotent)
  6. Maksimal kutish vaqti
  7. Resurs bloklanadi (zanjir yiqilish)
  8. Yiqilgan xizmatga urinishni to'xtatish
  9. Uzgich ochiq (darrov voz kechish)
  10. Xato bo'lsa muqobil javob
  11. Resurs izolyatsiyasi (tarqalmasin)
  12. Yiqilish uchun loyihalash

Vazifa 2: Xatolarni tuzating

python
1.  natija = tashqi_api()          # timeout

2.  for i in range(100): retry()   # backoff

3.  # 400 ni qayta urinish          # vaqtinchalik

4.  # yiqilgan xizmatga qayta       # circuit breaker

5.  try: ... except: pass          # log + fallback
Javoblar
python
1.  tashqi_api(timeout=1.0)

2.  backoff (1s, 2s, 4s) + jitter

3.  faqat vaqtinchalik (503, tarmoq)

4.  circuit breaker (fail fast)

5.  except: log(); fallback()

Vazifa 3: Retry

Tuzing:

  1. Qayta urinish
  2. Backoff
  3. Chegara
  4. Vaqtinchalik xato

Vazifa 4: Fallback

Tuzing:

  1. Asosiy
  2. Xato
  3. Zaxira
  4. Foydali javob

Vazifa 5: Circuit Breaker

Tuzing:

  1. CLOSED
  2. Ko'p xato
  3. OPEN
  4. Fail fast

Vazifa 6: Birlashtirish

Tuzing:

  1. Retry
  2. Circuit breaker
  3. Fallback
  4. Qatlam

Vazifa 7: O'ylash

Xatolarga chidamlilik falsafasi — "design for failure" (yiqilish uchun loyihalash): xatoni istisno emas, kutilgan deb qabul qilish. Nima uchun bu fikrlash o'zgarishi ("xatosiz tizim" dan "xato bo'ladi, tayyorlan" ga) katta tizimlar uchun juda muhim, va nega "nafis yiqilish" (fail gracefully) ko'pincha "mukammal ishlash" dan qimmatliroq?

Javob

Qisqa javob: "Design for failure" fikrlash o'zgarishi muhim, chunki: kichik tizimda xato kam (bir dastur, bir mashina — kamdan-kam yiqiladi), lekin katta/taqsimlangan tizimda xato muqarrar va tez-tez (yuzlab xizmat, minglab mashina, tarmoq — statistik jihatdan doim biror narsa yiqilgan). "Xatosiz tizim" maqsadi katta tizimda imkonsiz (100% ishonchlilik — matematik imkonsiz, har qism yiqilishi mumkin); shuning uchun maqsad o'zgarishi kerak: "xatosiz" emas, "xato bo'lganda omon qolish". Agar dasturchi "xato bo'lmaydi" deb loyihalasa — xato bo'lganda tizim qulaydi (tayyor emas); agar "xato bo'ladi" deb loyihalasa — xato boshqariladi (timeout, fallback, circuit breaker). Bu realizm (xato — hayot haqiqati) va tayyorlik (oldindan yechim). "Nafis yiqilish" (fail gracefully) ko'pincha "mukammal ishlash" dan qimmatliroq, chunki: mukammal ishlash imkonsiz (100% uptime yo'q) — shuning uchun "mukammal yoki hech narsa" — "hech narsa" ga olib keladi (xato bo'lsa to'liq qulash); nafis yiqilish — real maqsad (xato bo'lganda ham qisman ishlash — foydalanuvchi ba'zi funksiyani yo'qotadi, lekin tizim tirik). Masalan: tavsiya yiqilsa — butun sayt qulashi (mukammal yoki hech narsa) yomon; mashhur mahsulot ko'rsatish (nafis yiqilish) yaxshi (foydalanuvchi baribir xarid qiladi). Foydalanuvchi uchun "biroz cheklangan, lekin ishlaydigan" >> "to'liq buzilgan". Muhandislik saboqlari: katta tizimda xato normal (statistik muqarrar); "design for failure" — realizm (imkonsizni ko'zlamaslik); nafis yiqilish — omon qolish (mukammallik emas); "biroz ishlaydi" >> "umuman ishlamaydi"; ishonchlilik — xatosizlik emas, xato bilan yashash qobiliyati.

1. Nega fikrlash o'zgarishi muhim

Kichik tizim: xato kam. Katta/taqsimlangan: xato muqarrar (statistik). "Xatosiz" — imkonsiz (katta tizimda).

2. Loyihalash farqi

Fikrlash Xato bo'lganda
"Xato bo'lmaydi" Qulaydi (tayyor emas)
"Xato bo'ladi" Boshqariladi (yechim tayyor)

3. Nega nafis yiqilish qimmatliroq

Mukammal ishlash imkonsiz (100% yo'q). "Mukammal yoki hech narsa" → hech narsa (qulash). Nafis yiqilish — real (qisman ishlash).

4. Foydalanuvchi nuqtai nazari

"Biroz cheklangan, ishlaydigan" >> "to'liq buzilgan". Tavsiya yo'q, lekin sayt ochiladi.

5. Muhandislik saboqlari

  1. Katta tizimda xato normal (muqarrar)
  2. Design for failure — realizm
  3. Nafis yiqilish — omon qolish (mukammallik emas)
  4. "Biroz ishlaydi" >> "umuman ishlamaydi"

6. Xulosa

  1. Xato muqarrar (katta tizim) — tayyorlan
  2. "Xatosiz" imkonsiz → "xato bilan omon qolish"
  3. Nafis yiqilish > mukammal (imkonsiz)
  4. Ishonchlilik — xato bilan yashash qobiliyati

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda xatolarga chidamlilik naqshlarini o'rgandik.

Eng muhim uch fikr:

  1. Chidamlilik, Retry, Timeout. Xatolarga chidamlilik (resilience) — tizimning xatolar oldida ishlashda davom etish qobiliyati: xato muqarrar (tarmoq, xizmat yiqilishi) — mo'rt tizim bir xatodan qulaydi, chidamli tizim xatoni izolyatsiya qiladi ("fail gracefully"). Retry (qayta urinish) — vaqtinchalik xatoda (tarmoq to'lqini) qayta urinish; muhim: backoff (kutish — 1s, 2s, 4s, exponential), chegara, faqat vaqtinchalik va idempotent amalga. Timeout (vaqt chegarasi) — maksimal kutish (kelmasa voz kechish); cheksiz kutish xavfli (resurs bloklanadi — zanjir yiqilish), har tashqi chaqiruv timeout bilan.

  2. Circuit Breaker, Fallback, Bulkhead. Circuit Breaker (uzgich) — doim yiqilayotgan xizmatga urinishni to'xtatadi: ko'p xato → OPEN (darrov voz kechish, fail fast) → biroz vaqt → HALF-OPEN (sinov) → CLOSED (normal); behuda urinishni va zanjir yiqilishni oldini oladi. Fallback (zaxira) — asosiy yiqilsa muqobil javob (tavsiya yiqilsa — mashhur mahsulotlar; oq ekran emas — foydali). Bulkhead (to'siq — kema bo'limlari) — qismlarni izolyatsiya (har xizmatga alohida resurs — bir yiqilish boshqasiga tarqalmasin).

  3. Birlashtirish va design for failure. Naqshlar birga ishlatiladi (Timeout + Retry + Circuit Breaker + Fallback — qatlam himoya, har biri bir xato turiga); kutubxonalar (tenacity, pybreaker). Asosiy g'oya — xatoni normal deb qabul qilish ("design for failure" — yiqilish uchun loyihalash): "xatosiz tizim" imkonsiz (katta/taqsimlangan tizimda xato muqarrar), maqsad — "xato bo'lganda omon qolish". Nafis yiqilish (fail gracefully) "mukammal ishlash" dan qimmatliroq (mukammal imkonsiz; "biroz ishlaydi" >> "umuman ishlamaydi"). Chidamlilik xato boshqarish (09-dars) ning tizim darajasi; mikroservis 27.9-bob, hodisaga asoslangan 27.10-bob, monitoring (28-qism) bilan bog'liq. Ishonchlilik — xatosizlik emas, xato bilan yashash qobiliyati.

Bu bilan 27-qism (Arxitektura) yakunlandi: toza kod, SOLID, dizayn naqshlari (yaratuvchi, strukturaviy, xulq-atvor), qatlamli arxitektura, Clean Architecture, DDD, monolit/mikroservis, hodisaga asoslangan arxitektura, CQRS/Event Sourcing va xatolarga chidamlilik. Keyingi — 28-qism: Infratuzilma — Docker, Kubernetes, CI/CD, monitoring va bulut bilan tizimlarni ishga tushirish va boshqarish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
27.12-dars: Xatolarga chidamlilik naqshlari — IlmHamroh