IlmHamroh
Python kursi/Web backend FastAPI14/16-dars16 daqiqa
Mundarija (22)

20.14-dars: Fon vazifalari

20-QISM — WEB-BACKEND (FastAPI) · 14-dars

1. Kirish va motivatsiya

Ba'zi ishlar vaqt oladi: email yuborish, rasm qayta ishlash, hisobot yaratish, tashqi xizmatga so'rov. Agar endpoint bularni kutsa, foydalanuvchi javobni kutib turadi — sekin, yomon tajriba. Yechim — bu ishlarni fonda bajarish: foydalanuvchiga darrov javob berib, og'ir ishni keyin qilishdir.

Bu darsda FastAPI'ning BackgroundTasks ni o'rganamiz — javob yuborilgandan keyin ishni bajarish. Foydalanuvchi darrov javob oladi ("ro'yxatdan o'tdingiz"), email esa fonda yuboriladi. Bu — javob tezligi va foydalanuvchi tajribasi uchun muhim naqsh.

Real vaziyat. Bir API ro'yxatdan o'tishda tasdiqlovchi email yuborardi — lekin email xizmati sekin (2-3 soniya), foydalanuvchi har safar kutardi. Ba'zan email xizmati javob bermasa, butun ro'yxatdan o'tish muvaffaqiyatsiz bo'lardi (email tufayli!). Jamoa emailni BackgroundTasksga o'tkazdi: foydalanuvchi darrov javob oladi, email fonda ketadi. Ro'yxatdan o'tish tezlashdi va email nosozligi uni to'xtatmaydi. Foydalanuvchi tajribasi yaxshilandi.

Bu darsda fon vazifalarini — BackgroundTasks, ishlatilishi va cheklovlarini o'rganamiz.

Bu darsda:

  • BackgroundTasks — javobdan keyin ish
  • add_task bilan vazifa qo'shish
  • Ishlatilish (email, log, tozalash)
  • Bir necha fon vazifasi
  • Argumentlar bilan vazifa
  • Bog'liqlik bilan fon vazifasi
  • Cheklovlar (BackgroundTasks vs navbat)
  • Amaliy: to'liq fon tizimi

ℹ Misollarda FastAPI TestClient bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. BackgroundTasks nima

BackgroundTasks — javob yuborilgandan keyin bajariladigan ishlar:

python
from fastapi import BackgroundTasks

def email_yubor(manzil: str):
    ...    # sekin ish

@app.post("/royxat")
def royxat(ism: str, fon: BackgroundTasks):
    fon.add_task(email_yubor, f"{ism}@mail.uz")
    return {"holat": "ro'yxatdan o'tdi"}     # darrov qaytadi
Qadam Vaqt
Endpoint ishlaydi So'rov
return Javob yuboriladi
Fon vazifasi Javobdan keyin

BackgroundTasks — javob darrov qaytadi, fon vazifasi keyin ishlaydi. Foydalanuvchi og'ir ishni kutmaydi. Endpointga fon: BackgroundTasks parametr sifatida qo'shiladi.

2.2. add_task bilan qo'shish

add_task(funksiya, *args, **kwargs) — vazifa qo'shadi:

python
fon.add_task(email_yubor, "ali@mail.uz")              # pozitsion arg
fon.add_task(log_yoz, xabar="kirdi", daraja="info")   # nomli arg

add_task — funksiya va uning argumentlarini oladi (chaqirmaydi!). FastAPI javobdan keyin funksiyani shu argumentlar bilan chaqiradi. Funksiya def yoki async def bo'lishi mumkin.

2.3. Qachon ishlatiladi

Fon vazifasi — javob uchun kerak bo'lmagan, lekin bajarilishi kerak ishlar:

Ish Nima uchun fonda
Email yuborish Sekin, javob kutmaslik
Log/audit yozish Javobga ta'sir qilmaydi
Kesh yangilash Keyin bo'lsa ham mayli
Vaqtincha fayl tozalash So'rovdan keyin
Bildirishnoma Darhol kerak emas

Fon vazifasi — natijasi foydalanuvchiga darhol kerak bo'lmagan ishlar. Javob tez qaytadi, ish keyin bajariladi.

2.4. Bir necha fon vazifasi

Bir endpointda bir necha vazifa (tartibda bajariladi):

python
@app.post("/royxat")
def royxat(ism: str, fon: BackgroundTasks):
    fon.add_task(log_yoz, f"{ism} ro'yxatdan o'tdi")
    fon.add_task(email_yubor, f"{ism}@mail.uz")
    fon.add_task(statistika_yangila)
    return {"holat": "ok"}

Bir necha add_task — vazifalar qo'shilgan tartibda ketma-ket bajariladi (javobdan keyin). Har biri alohida ish.

2.5. Bog'liqlik bilan fon vazifasi

BackgroundTasks bog'liqlik 20.7-bob ichida ham ishlaydi:

python
def log_bilan(fon: BackgroundTasks):
    fon.add_task(log_yoz, "so'rov keldi")
    return fon

@app.get("/kurslar")
def kurslar(fon: Annotated[BackgroundTasks, Depends(log_bilan)]):
    ...

Bog'liqlikda qo'shilgan fon vazifasi ham javobdan keyin ishlaydi. Bu umumiy fon ishlari (har so'rovni log qilish) uchun qulay.

2.6. BackgroundTasks cheklovlari

BackgroundTasks — oddiy, lekin cheklangan:

Xususiyat BackgroundTasks
Joyi Shu server jarayonida
Ishonchlilik Server o'chsa — yo'qoladi
Og'irlik Yengil ish uchun
Kuzatuv Yo'q (holat ko'rinmaydi)

BackgroundTasks — yengil, tez ishlar uchun (email, log). Og'ir, uzoq yoki ishonchli bo'lishi kerak ishlar (to'lov, video qayta ishlash) uchun — navbat tizimi (Celery, RQ, message queue) kerak. BackgroundTasks server jarayonida ishlaydi — server o'chsa, vazifa yo'qoladi.

2.7. Navbat tizimi (og'ir ishlar uchun)

Katta/ishonchli ishlar uchun alohida navbat:

Xususiyat BackgroundTasks Navbat (Celery/RQ)
Joyi Server jarayoni Alohida ishchi
Ishonchlilik Past Yuqori (qayta urinish)
Kuzatuv Yo'q Bor (holat, natija)
Og'irlik Yengil Og'ir
Murakkablik Oddiy Murakkab (broker kerak)

Navbat tizimi — vazifani alohida ishchiga (worker) beradi, holatni kuzatadi, xato bo'lsa qayta urinadi. Murakkab, lekin ishonchli. Tanlov: yengil → BackgroundTasks; og'ir/ishonchli → navbat.

2.8. Fon vazifasida xato

Fon vazifasidagi xato javobga ta'sir qilmaydi (javob allaqachon yuborilgan):

python
def xato_bilan():
    raise ValueError("fon xatosi")     # javob allaqachon ketgan

@app.post("/x")
def ep(fon: BackgroundTasks):
    fon.add_task(xato_bilan)
    return {"ok": True}                 # 200 qaytadi (xato keyin)

Fon vazifasida xato — javob allaqachon yuborilgan, shuning uchun foydalanuvchi 200 oladi. Fon xatosini serverda log qiling (aks holda bilinmay qoladi). Muhim ishlar uchun navbat (kuzatuv bilan) yaxshiroq.

3. Tez ma'lumotnoma

python
from fastapi import BackgroundTasks

def email_yubor(manzil: str, mavzu: str):
    ...    # sekin ish

@app.post("/royxat")
def royxat(ism: str, fon: BackgroundTasks):
    fon.add_task(email_yubor, f"{ism}@mail.uz", "Xush kelibsiz")   # argumentlar
    fon.add_task(log_yoz, f"{ism} kirdi")                          # yana vazifa
    return {"holat": "ok"}     # darrov qaytadi, fon keyin

Qachon nima

yengil (email, log)      → BackgroundTasks
og'ir/ishonchli (to'lov) → navbat (Celery, RQ)

4. Batafsil misollar

Misollarda FastAPI TestClient bilan sinaladi.

Misol 1 — BackgroundTasks asoslari

python
"""BackgroundTasks bilan javobdan keyin ish; add_task; javob darrov qaytadi; fon keyin bajariladi."""

import warnings
warnings.filterwarnings("ignore")

from fastapi import BackgroundTasks, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

JURNAL: list[str] = []


def log_yoz(xabar: str) -> None:
    JURNAL.append(xabar)


@app.post("/hodisa")
def hodisa(nom: str, fon: BackgroundTasks):
    fon.add_task(log_yoz, f"hodisa: {nom}")
    return {"holat": "qabul qilindi", "nom": nom}


def main() -> None:
    client = TestClient(app)
    JURNAL.clear()

    print("=== 1. So'rov — javob darrov ===")
    javob = client.post("/hodisa?nom=kirish")
    print(f"  javob: {javob.json()}")

    print("\n=== 2. Fon vazifasi bajarildi ===")
    print(f"  jurnal: {JURNAL}")

    print("\n=== 3. Yana so'rov ===")
    client.post("/hodisa?nom=chiqish")
    print(f"  jurnal: {JURNAL}")

    print("\n=== 4. Tartib ===")
    print("  1) endpoint ishlaydi 2) javob yuboriladi 3) fon vazifasi")
    print(f"  jami {len(JURNAL)} fon vazifasi bajarildi")
    print("  ⭐ BackgroundTasks — javob darrov, ish javobdan keyin")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. So'rov — javob darrov ===
  javob: {'holat': 'qabul qilindi', 'nom': 'kirish'}

=== 2. Fon vazifasi bajarildi ===
  jurnal: ['hodisa: kirish']

=== 3. Yana so'rov ===
  jurnal: ['hodisa: kirish', 'hodisa: chiqish']

=== 4. Tartib ===
  1) endpoint ishlaydi 2) javob yuboriladi 3) fon vazifasi
  jami 2 fon vazifasi bajarildi
  ⭐ BackgroundTasks — javob darrov, ish javobdan keyin

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

Misol 2 — Bir necha vazifa va argumentlar

python
"""bir necha add_task (tartibda); pozitsion va nomli argumentlar; email + log + statistika; ro'yxatdan o'tish."""

import warnings
warnings.filterwarnings("ignore")

from fastapi import BackgroundTasks, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

JURNAL: list[str] = []
STATISTIKA = {"royxat_soni": 0}


def email_yubor(manzil: str, mavzu: str) -> None:
    JURNAL.append(f"email→{manzil}: {mavzu}")


def log_yoz(xabar: str, daraja: str = "info") -> None:
    JURNAL.append(f"[{daraja}] {xabar}")


def statistika_yangila() -> None:
    STATISTIKA["royxat_soni"] += 1


@app.post("/royxat")
def royxat(ism: str, fon: BackgroundTasks):
    fon.add_task(log_yoz, f"{ism} ro'yxatdan o'tdi")
    fon.add_task(email_yubor, f"{ism}@mail.uz", "Xush kelibsiz")
    fon.add_task(log_yoz, "email navbatga qo'yildi", daraja="debug")
    fon.add_task(statistika_yangila)
    return {"holat": "ro'yxatdan o'tdi", "ism": ism}


def main() -> None:
    client = TestClient(app)
    JURNAL.clear()

    print("=== 1. Ro'yxatdan o'tish ===")
    javob = client.post("/royxat?ism=ali")
    print(f"  javob: {javob.json()}")

    print("\n=== 2. Fon vazifalari (tartibda) ===")
    for j in JURNAL:
        print(f"    {j}")

    print("\n=== 3. Nomli argument (daraja) ===")
    print(f"  debug xabar: {[j for j in JURNAL if 'debug' in j]}")

    print("\n=== 4. Statistika yangilandi ===")
    print(f"  ro'yxat soni: {STATISTIKA['royxat_soni']}")
    print("  ⭐ bir necha add_task — tartibda; pozitsion va nomli argument")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ro'yxatdan o'tish ===
  javob: {'holat': "ro'yxatdan o'tdi", 'ism': 'ali'}

=== 2. Fon vazifalari (tartibda) ===
    [info] ali ro'yxatdan o'tdi
    email→ali@mail.uz: Xush kelibsiz
    [debug] email navbatga qo'yildi

=== 3. Nomli argument (daraja) ===
  debug xabar: ["[debug] email navbatga qo'yildi"]

=== 4. Statistika yangilandi ===
  ro'yxat soni: 1
  ⭐ bir necha add_task — tartibda; pozitsion va nomli argument

Nima ko'rsatdi: 2.2, 2.3, 2.4-bo'limlar.

Misol 3 — Bog'liqlik bilan fon va xato

python
"""bog'liqlik ichida fon vazifasi (har so'rovni log); fon vazifasida xato javobga ta'sir qilmaydi; xatoni log qilish."""

import warnings
warnings.filterwarnings("ignore")

from typing import Annotated

from fastapi import BackgroundTasks, Depends, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

JURNAL: list[str] = []


def surov_logi(fon: BackgroundTasks) -> BackgroundTasks:
    fon.add_task(JURNAL.append, "so'rov keldi")
    return fon


def xavfsiz_ish() -> None:
    try:
        _ = 1 / 0                    # xato
    except ZeroDivisionError:
        JURNAL.append("[xato] fon vazifasida nosozlik (log qilindi)")


@app.get("/kurslar")
def kurslar(fon: Annotated[BackgroundTasks, Depends(surov_logi)]):
    return {"kurslar": ["Python", "Go"]}


@app.post("/ishla")
def ishla(fon: BackgroundTasks):
    fon.add_task(xavfsiz_ish)
    return {"holat": "boshlandi"}


def main() -> None:
    client = TestClient(app)
    JURNAL.clear()

    print("=== 1. Bog'liqlik fon vazifasi ===")
    javob = client.get("/kurslar")
    print(f"  javob: {javob.json()}")
    print(f"  jurnal: {JURNAL}")

    print("\n=== 2. Har so'rov loglanadi ===")
    client.get("/kurslar")
    print(f"  jami log: {len([j for j in JURNAL if 'keldi' in j])}")

    print("\n=== 3. Fon vazifasida xato ===")
    javob = client.post("/ishla")
    print(f"  javob status: {javob.status_code} (fon xatosi javobga ta'sir qilmadi)")

    print("\n=== 4. Xato log qilindi ===")
    print(f"  {[j for j in JURNAL if 'xato' in j]}")
    print("  ⭐ bog'liqlik fon; fon xatosi javobni buzmaydi (log qiling)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Bog'liqlik fon vazifasi ===
  javob: {'kurslar': ['Python', 'Go']}
  jurnal: ["so'rov keldi"]

=== 2. Har so'rov loglanadi ===
  jami log: 2

=== 3. Fon vazifasida xato ===
  javob status: 200 (fon xatosi javobga ta'sir qilmadi)

=== 4. Xato log qilindi ===
  ['[xato] fon vazifasida nosozlik (log qilindi)']
  ⭐ bog'liqlik fon; fon xatosi javobni buzmaydi (log qiling)

Nima ko'rsatdi: 2.5, 2.8-bo'limlar.

Misol 4 — Amaliy: fon vazifalari va cheklovlar

Fon vazifasining real ishlatilishi — bildirishnoma tizimi: foydalanuvchi izoh qoldiradi, darrov javob oladi, va fonda bildirishnoma, log, statistika yangilanadi. Bu misol BackgroundTasks qachon mos, qachon navbat kerak ekanini ko'rsatadi.

python
"""to'liq fon tizimi: izoh qoldirish (darrov javob), fonda bildirishnoma + log + statistika; yengil ish naqshi."""

import warnings
warnings.filterwarnings("ignore")

from fastapi import BackgroundTasks, FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI(title="Wisar Izoh API")

IZOHLAR: list[dict] = []
BILDIRISHNOMALAR: list[str] = []
JURNAL: list[str] = []
STAT = {"izoh_soni": 0}


class Izoh(BaseModel):
    kurs: str
    matn: str
    muallif: str


def bildirishnoma_yubor(kurs: str, muallif: str) -> None:
    BILDIRISHNOMALAR.append(f"{kurs} kursiga {muallif} izoh qoldirdi")


def audit_log(muallif: str) -> None:
    JURNAL.append(f"izoh: {muallif}")


def statistika() -> None:
    STAT["izoh_soni"] += 1


@app.post("/izohlar", status_code=201)
def izoh_qoldir(izoh: Izoh, fon: BackgroundTasks):
    yozuv = {"id": len(IZOHLAR) + 1, "kurs": izoh.kurs, "matn": izoh.matn, "muallif": izoh.muallif}
    IZOHLAR.append(yozuv)
    # darrov javob, fonda: bildirishnoma, log, statistika
    fon.add_task(bildirishnoma_yubor, izoh.kurs, izoh.muallif)
    fon.add_task(audit_log, izoh.muallif)
    fon.add_task(statistika)
    return {"id": yozuv["id"], "holat": "izoh qo'shildi"}


def main() -> None:
    client = TestClient(app)

    print("=== 1. Izoh qoldirish (darrov javob) ===")
    javob = client.post("/izohlar", json={"kurs": "Python", "matn": "zo'r dars", "muallif": "ali"})
    print(f"  status {javob.status_code} → {javob.json()}")

    print("\n=== 2. Fon: bildirishnoma ===")
    print(f"  {BILDIRISHNOMALAR}")

    print("\n=== 3. Fon: log va statistika ===")
    client.post("/izohlar", json={"kurs": "Go", "matn": "yaxshi", "muallif": "vali"})
    print(f"  jurnal: {JURNAL}")
    print(f"  izoh soni: {STAT['izoh_soni']}")

    print("\n=== 4. Qachon navbat kerak ===")
    print("  yengil (bildirishnoma, log) → BackgroundTasks ✅")
    print("  og'ir/ishonchli (to'lov, video) → navbat (Celery/RQ)")
    print("  ⭐ BackgroundTasks — yengil ishlar; javob tez, ish fonda")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Izoh qoldirish (darrov javob) ===
  status 201 → {'id': 1, 'holat': "izoh qo'shildi"}

=== 2. Fon: bildirishnoma ===
  ['Python kursiga ali izoh qoldirdi']

=== 3. Fon: log va statistika ===
  jurnal: ['izoh: ali', 'izoh: vali']
  izoh soni: 2

=== 4. Qachon navbat kerak ===
  yengil (bildirishnoma, log) → BackgroundTasks ✅
  og'ir/ishonchli (to'lov, video) → navbat (Celery/RQ)
  ⭐ BackgroundTasks — yengil ishlar; javob tez, ish fonda

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

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

Noto'g'ri fikr To'g'risi
"Og'ir ish endpointda" Fonda (javob tez)
"Fon vazifasi javobdan oldin" Javobdan keyin
"add_task funksiyani chaqiradi" Chaqirmaydi (keyin)
"BackgroundTasks ishonchli" Yengil ish uchun (server o'chsa yo'q)
"Og'ir ish ham BackgroundTasks" Navbat (Celery) kerak
"Fon xatosi javobni buzadi" Javob allaqachon ketgan
"Fon vazifasi kuzatiladi" Yo'q (navbatda bor)
"Fon vazifasi har doim tez" Yengil bo'lsin (bloklamasin)

6. Keng tarqalgan xatolar va yechimlari

1. Og'ir ishni endpointda kutish

python
def royxat(ism: str):
    email_yubor(ism)                 # ⚠️ foydalanuvchi kutadi
    return {"ok": True}
# ✅ fon.add_task(email_yubor, ism)

2. add_taskda funksiyani chaqirish

python
fon.add_task(email_yubor(ism))       # ❌ darrov chaqirdi
fon.add_task(email_yubor, ism)       # ✅ funksiya + arg

3. Og'ir ish uchun BackgroundTasks

python
fon.add_task(video_qayta_ishla)      # ⚠️ og'ir, ishonchsiz
# ✅ navbat (Celery/RQ) — kuzatuv, qayta urinish

4. Fon xatosini log qilmaslik

python
def fon_ish(): riskli_amal()          # ⚠️ xato bilinmaydi
def fon_ish():
    try: riskli_amal()
    except Exception: log(...)        # ✅

5. BackgroundTasks parametrini unutish

python
def ep(): fon.add_task(...)           # ❌ fon yo'q
def ep(fon: BackgroundTasks): ...     # ✅

6. Fon vazifasiga natija kutish

python
natija = fon.add_task(hisobla)       # ❌ natija bermaydi
# ✅ natija kerak bo'lsa — navbat (holat/natija bilan)

7. Fon vazifasida umumiy o'zgaruvchini xavfsizsiz o'zgartirish

python
# ko'p ishchi holatda fon global holatni buzishi mumkin
# ✅ atomik amal yoki navbat ishlating

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 14-qism (o'tilgan): asinxron — async fon vazifalari
  • 20.10-dars (o'tilgan): ro'yxatdan o'tish — tasdiq email (fon)
  • 20.13-dars (o'tilgan): fayl — katta faylni fonda qayta ishlash
  • 28-qism: infratuzilma — navbat tizimlari (Celery, RQ)
  • 29-qism: miqyoslash — fon ishlarini ajratish

8. Eng yaxshi amaliyotlar

  1. Javob uchun kerak bo'lmagan ishni fonda bajaring.

  2. add_task(funksiya, arg) — funksiyani chaqirmang.

  3. Yengil ishlar (email, log) — BackgroundTasks.

  4. Og'ir/ishonchli ishlar — navbat (Celery, RQ).

  5. Fon vazifasida xatoni log qiling (bilinmay qolmasin).

  6. Fon vazifasi yengil bo'lsin (uzoq ishlamaslin).

  7. Natija/kuzatuv kerak bo'lsa — navbat tizimi.

  8. Umumiy holatni fonda xavfsiz o'zgartiring (atomik/navbat).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # BackgroundTasks nima?
2.  # fon vazifasi qachon ishlaydi?
3.  # add_task funksiyani chaqiradimi?
4.  # og'ir ish qayerda?
5.  # BackgroundTasks ishonchlimi?
6.  # fon xatosi javobni buzadimi?
7.  # navbat qachon kerak?
8.  # bir necha add_task tartibi?
9.  # fon vazifasi kuzatiladimi?
10. # email fonda nima uchun?
11. # add_task(f, x) — x nima?
12. # server o'chsa fon vazifasi?
Javoblar
  1. Javobdan keyin bajariladigan ishlar
  2. Javob yuborilgandan keyin
  3. Yo'q (keyin chaqiradi)
  4. Fonda (yoki navbatda) — javob tez
  5. Yo'q (yengil ish uchun; server o'chsa yo'qoladi)
  6. Yo'q (javob allaqachon ketgan)
  7. Og'ir/ishonchli/kuzatiladigan ishlar uchun
  8. Qo'shilgan tartibda
  9. Yo'q (navbatda bor)
  10. Sekin — foydalanuvchi kutmasligi uchun
  11. Funksiya argumenti (keyin chaqiriladi)
  12. Yo'qoladi (jarayonda edi)

Vazifa 2: Xatolarni tuzating

python
1.  def royxat(ism):
        email_yubor(ism)          # kutadi
        return {...}

2.  fon.add_task(email_yubor(ism))   # chaqirdi

3.  fon.add_task(video_qayta_ishla)  # og'ir

4.  def fon_ish(): riskli_amal()      # xato log

5.  def ep(): fon.add_task(...)       # parametr
Javoblar
python
1.  def royxat(ism: str, fon: BackgroundTasks):
        fon.add_task(email_yubor, ism)

2.  fon.add_task(email_yubor, ism)

3.  # navbat (Celery/RQ) — og'ir ish

4.  def fon_ish():
        try: riskli_amal()
        except Exception: log(...)

5.  def ep(fon: BackgroundTasks): ...

Vazifa 3: Email tasdiqlash

Ro'yxatdan o'tish + email:

  1. POST /royxat — foydalanuvchi saqlanadi
  2. Fonda tasdiq email (soxta funksiya)
  3. Darrov javob (email kutmasdan)
  4. TestClient bilan test (email fonda bajarilganini)

Vazifa 4: Audit log

Har so'rovni log qilish:

  1. Bog'liqlik bilan fon log
  2. So'rov URL, vaqt, foydalanuvchi
  3. Har endpointda avtomatik
  4. Log to'plamini test

Vazifa 5: Vaqtincha fayl tozalash

Fayl yuklab, fonda tozalash:

  1. Fayl qabul qili 20.13-bob va qayta ishla
  2. Fonda vaqtincha faylni o'chir
  3. Javob darrov
  4. Tozalash bajarilganini test

Vazifa 6: Fon vs navbat qaror

Turli ishlar uchun qaror:

  1. Email, log, kesh (yengil) → BackgroundTasks
  2. To'lov, video, hisobot (og'ir) → navbat
  3. Har biri uchun sabab yozing
  4. Chegara holatlarini muhokama qiling

Vazifa 7: O'ylash

Fon vazifasi "sinxron" (foydalanuvchi kutadi) va "asinxron" (foydalanuvchi kutmaydi) ishni ajratadi: javob uchun kerak narsa (izoh saqlandi) darrov, kerak bo'lmagan narsa (bildirishnoma) keyin. Bu "muhim yo'l" (critical path) ni qisqartirish — javob tezligini oshirish usuli. Qaysi ish "muhim yo'lda" (javob uchun kerak) va qaysisi emas — buni qanday aniqlaysiz, va bu ajratish tizim tezligi va ishonchliligiga qanday ta'sir qiladi?

Javob

Qisqa javob: "Muhim yo'l" (critical path) — javob berish uchun majburiy bajarilishi kerak ishlar (izohni saqlash, javobni shakllash). "Muhim yo'lda emas" — javob berilgandan keyin bajarilsa ham bo'ladigan ishlar (bildirishnoma, log, statistika). Ajratish usuli: "Bu ish natijasi javobda kerakmi?" — ha bo'lsa muhim yo'lda (darrov), yo'q bo'lsa fonda. Bu javob tezligini oshiradi (foydalanuvchi faqat muhim ishni kutadi) va ishonchlilikni yaxshilaydi (fon ishi nosoz bo'lsa, javob buzilmaydi).

1. Muhim yo'l (critical path)

Muhim yo'lda (darrov) Muhim yo'lda emas (fon)
Izohni saqlash Bildirishnoma
Javobni shakllash Log/audit
Validatsiya Statistika
Ma'lumot o'qish Kesh yangilash

2. Ajratish savoli

"Bu ish natijasi javobda kerakmi, yoki foydalanuvchi darhol natijani ko'rishi kerakmi?"

  • Ha → muhim yo'l (darrov)
  • Yo'q → fon (keyin)

3. Tezlikka ta'siri

Muhim yo'l qancha qisqa bo'lsa, javob shuncha tez. Og'ir ishni (email 2s) muhim yo'ldan olib tashlash — javob 2s tezroq.

Muhim yo'l:  so'rov → saqlash → javob (tez)
Fon:         → email → log → statistika (keyin)

4. Ishonchlilikka ta'siri

Fon ishi (email) nosoz bo'lsa — javob buzilmaydi (allaqachon ketgan). Muhim yo'lda faqat zarur ishlar bo'lsa, kamroq nosozlik nuqtasi.

5. Muhandislik saboqlari

  1. Muhim yo'lni aniqla (javob uchun zarur)
  2. Zarur bo'lmagan ishni fonda bajar
  3. Muhim yo'l qisqa → javob tez
  4. Fon nosozligi javobni buzmaydi

6. Xulosa

  1. Muhim yo'l — javob uchun majburiy ishlar
  2. "Javobda kerakmi?" — ajratish savoli
  3. Fon — muhim yo'lni qisqartiradi (tezlik)
  4. Ajratish — tezlik va ishonchlilik

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda fon vazifalarini — BackgroundTasks bilan javobdan keyingi ishlarni o'rgandik.

Eng muhim uch fikr:

  1. BackgroundTasks — javobdan keyin ish. Endpointga fon: BackgroundTasks parametr qo'shiladi, fon.add_task(funksiya, *args) bilan vazifa qo'shiladi. Javob darrov qaytadi, fon vazifasi javob yuborilgandan keyin bajariladi. add_task funksiyani chaqirmaydi — uni va argumentlarini saqlaydi, keyin chaqiradi. Foydalanuvchi og'ir ishni (email, log) kutmaydi.

  2. Qachon ishlatiladi. Fon vazifasi — natijasi foydalanuvchiga darhol kerak bo'lmagan ishlar uchun: email yuborish, log/audit, kesh yangilash, vaqtincha fayl tozalash. Bir endpointda bir necha add_task — qo'shilgan tartibda bajariladi. BackgroundTasks bog'liqlik ichida ham ishlaydi (har so'rovni log qilish). Fon vazifasida xato javobni buzmaydi (javob allaqachon ketgan) — shuning uchun xatoni serverda log qiling.

  3. Cheklovlar va navbat. BackgroundTasks — yengil, tez ishlar uchun; u server jarayonida ishlaydi, server o'chsa vazifa yo'qoladi (ishonchsiz), holati kuzatilmaydi. Og'ir, uzoq yoki ishonchli ishlar (to'lov, video qayta ishlash) uchun — navbat tizimi (Celery, RQ, message queue) kerak: alohida ishchi, holat kuzatuvi, xatoda qayta urinish. Asosiy tamoyil — "muhim yo'l" (javob uchun zarur ish) ni qisqartirish: zarur ishni darrov, boshqasini fonda bajarish javob tezligi va ishonchliligini oshiradi.

Keyingi darsda testlash ni o'rganamiz: FastAPI ilovasini TestClient bilan sinash, endpointlarni, autentifikatsiyani, bazani test qilish va dependency_overrides bilan bog'liqliklarni almashtirish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
20.14-dars: Fon vazifalari — IlmHamroh