28.7-dars: CI — avtomatik test

28-QISM — INFRATUZILMA · 7-dars

1. Kirish va motivatsiya

Jamoada ko'p dasturchi bir kod bazasiga o'zgarish qo'shadi. Har kim o'z kompyuterida test qiladi (yoki qilmaydi), keyin kodni birlashtiradi. Muammo: bir dasturchi o'zgarishi boshqasinikini buzadi (integratsiya muammosi), yoki test qilmasdan buzuq kod birlashtiriladi, yoki "mening mashinamda ishlaydi" 28.1-bob. Bu muammolar kech (birlashtirgandan keyin, hatto prodda) topiladi — tuzatish qimmat. CI (Continuous Integration — uzluksiz integratsiya) bu muammoni hal qiladi: har kod o'zgarishida avtomatik testlar ishga tushadi, kod tekshiriladi, muammo darrov topiladi (birlashtirishdan oldin). CI — sifat darvozasi.

CI (Continuous Integration — uzluksiz integratsiya) — kod o'zgarishlarini tez-tez birlashtirish va har birini avtomatik tekshirish amaliyoti: pipeline (quvur — avtomatik qadamlar ketma-ketligi: test, lint, build), trigger (ishga tushirish — push, pull request), runner (bajaruvchi — bulut mashinasi), status (natija — o'tdi/o'tmadi). Vositalar: GitHub Actions, GitLab CI, Jenkins. Oqim: kod push → CI avtomatik ishga tushadi → test/lint/build → natija (yashil/qizil). Muammo darrov topiladi (kod muallifi ko'radi), buzuq kod birlashmaydi. Bu test (17-qism), git (05-qism) ustiga quriladi. CI — har o'zgarishni avtomatik tekshirish. Avtomatik tekshiruv — sifat kafolati.

Real vaziyat. Bir jamoada har hafta prodda xato chiqardi — kimdir test qilmasdan kod birlashtirgan, yoki bir o'zgarish boshqasini buzgan (integratsiya). GitHub Actions CI qo'llanildi: har pull request'da avtomatik testlar, linter, tur tekshiruvi ishga tushadi — o'tmasa, birlashtirish bloklanadi. Endi buzuq kod prodga yetmaydi (CI to'sadi), muammo darrov (PR'da) topiladi. Prod xatolari keskin kamaydi. CI — sifat darvozasini avtomatlashtirdi.

Bu darsda CI (uzluksiz integratsiya) ni o'rganamiz.

Bu darsda:

• CI nima va nega
• Pipeline (quvur)
• Trigger va runner
• CI qadamlari (test, lint, build)
• CI statusi va bloklash
• GitHub Actions misoli
• CI eng yaxshi amaliyoti
• Amaliy: pipeline modeli

ℹ CI bulut xizmati; misollar Python bilan pipeline mantiqini modellashtiradi (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. CI nima va nega

Har o'zgarishni avtomatik tekshirish:

CI'siz: kod birlashtiriladi → muammo kech topiladi (prodda)
CI bilan: kod push → avtomatik test → muammo darrov (PR'da)
   buzuq kod birlashmaydi (sifat darvozasi)

CI (Continuous Integration) — kod o'zgarishlarini tez-tez birlashtirish va har birini avtomatik tekshirish amaliyoti: dasturchi kod push qiladi → CI avtomatik testlar/tekshiruvlarni ishga tushiradi → natija (o'tdi/o'tmadi). Sabab: qo'lda tekshirish ishonchsiz (unutiladi, o'tkazib yuboriladi), muammolar kech topiladi (birlashtirgandan keyin, prodda — qimmat); CI har o'zgarishni avtomatik, izchil tekshiradi (muammo darrov, arzon). "Uzluksiz" — tez-tez birlashtirish (katta, kam emas — kichik, tez-tez, 28.6). CI — sifatni avtomatlashtirish. Avtomatik tekshiruv — ishonchli sifat.

2.2. Pipeline (quvur)

Avtomatik qadamlar ketma-ketligi:

# CI pipeline (qadamlar)
1. Kodni olish (checkout)
2. Bog'liqliklarni o'rnatish (pip install)
3. Linter (kod uslubi)
4. Tur tekshiruvi (mypy)
5. Testlar (pytest)
6. Build (Docker image)
# har qadam o'tishi kerak (biri yiqilsa — to'xtaydi)

Pipeline (quvur) — CI'ning avtomatik qadamlar ketma-ketligi: kodni olish, bog'liqliklarni o'rnatish, linter, tur tekshiruvi, testlar, build. Har qadam o'tishi kerak (biri yiqilsa — pipeline to'xtaydi, qizil status). Sabab: bir qadam avtomatik boshqasiga o'tadi (qo'lda emas), izchil tartib (har safar bir xil). Qadamlar odatda tez → sekin (linter avval — tez yiqiladi, testlar keyin). Pipeline — CI'ning "retsepti" (nima tekshiriladi). Ba'zan parallel (mustaqil qadamlar birga). Pipeline — avtomatik tekshiruv qadamlari. Quvur — tartibli tekshiruv.

2.3. Trigger va runner

Qachon va qayerda:

# TRIGGER — qachon ishga tushadi
on:
  push:                # har push'da
    branches: [main]
  pull_request:        # har PR'da

# RUNNER — qayerda bajariladi
runs-on: ubuntu-latest   # bulut mashinasi

Trigger va runner: Trigger (ishga tushirgich) — CI qachon ishga tushadi (on: push — har push, on: pull_request — har PR, on: schedule — vaqt bo'yicha); Runner — CI qayerda bajariladi (bulut mashinasi — ubuntu-latest, yoki o'z serveringiz). Sabab: CI hodisaga javob beradi (kod o'zgardi → tekshir — 27.10 hodisaga asoslangan kabi), toza muhitda bajariladi (runner — har safar yangi, "mening mashinamda" muammosiz — 28.1). Trigger — CI'ni boshlaydi (avtomatik), runner — bajaradi (izolyatsiya). Trigger — qachon, runner — qayerda. Hodisa boshlaydi, mashina bajaradi.

2.4. CI qadamlari (test, lint, build)

Odatiy CI qadamlari: Linter (kod uslubi — ruff, flake8; 27.1 — izchillik, tez xatolar); Formatlash tekshiruvi (black --check — format to'g'ri?); Tur tekshiruvi (mypy — tur xatolari); Testlar (pytest — 17-qism — birlik, integratsiya testlari; asosiy qadam); Qamrov (coverage — test qancha kodni qamraydi); Xavfsizlik (bandit, zaiflik skaneri); Build (Docker image — 28.2, ishga tushadimi?). Har qadam bir sifat jihatini tekshiradi (uslub, tur, xulq, xavfsizlik). Ular birga — to'liq sifat darvozasi. Odatda tez qadamlar avval (tez qayta aloqa). Qadamlar — sifatning turli jihatlari. Har biri bir tekshiruv.

2.5. CI statusi va bloklash

O'tdi/o'tmadi:

CI status:
   yashil (o'tdi) — barcha qadam muvaffaqiyatli
   qizil (o'tmadi) — biror qadam yiqildi

Pull Request:
   CI qizil → birlashtirish BLOKLANADI (himoya)
   CI yashil → birlashtirish mumkin

CI statusi va bloklash: CI natijasi — yashil (barcha qadam o'tdi) yoki qizil (biror qadam yiqildi); status kod o'zgarishiga (commit, PR) biriktiriladi. Branch protection (tarmoq himoyasi) — CI qizil bo'lsa birlashtirish bloklanadi (buzuq kod mainga o'tmaydi). Sabab: status ko'rinadigan (yashil/qizil — darrov ma'lum), bloklash majburiy (sifat darvozasi — o'tmagan kod birlashmaydi). Bu jamoa intizomi (avtomatik — inson unutmasin). Status — sifat signali, bloklash — himoya. Qizil — birlashtirma. Yashil darvoza — sifat kafolati.

2.6. GitHub Actions misoli

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4        # kodni ol
      - uses: actions/setup-python@v5    # Python
        with: {python-version: "3.14"}
      - run: pip install -r requirements.txt
      - run: ruff check .                # linter
      - run: mypy .                      # tur
      - run: pytest                      # testlar

GitHub Actions — GitHub'ning CI vositasi (.github/workflows/*.yml): name (pipeline nomi), on (trigger — push, PR), jobs (vazifalar — parallel yoki ketma-ket), steps (qadamlar — uses tayyor action yoki run buyruq). Misol: kodni ol → Python o'rnat → bog'liqliklar → linter → tur → testlar. Har push/PR'da avtomatik. GitHub Actions — mashhur (GitHub bilan integratsiya, bepul limit, ko'p tayyor action). Boshqalar: GitLab CI, Jenkins, CircleCI — bir g'oya (YAML pipeline, trigger, runner). GitHub Actions — amaliy CI. YAML — pipeline ta'rifi.

2.7. CI eng yaxshi amaliyoti

CI amaliyotlari: tez pipeline (dasturchi kutmasin — sekin CI e'tiborsiz qoladi; parallel qadamlar, kesh); ishonchli testlar (flaky — ba'zan o'tadigan/yiqiladigan testlar — CI'ga ishonchni buzadi; deterministik testlar — kurs uslubi kabi); tez-tez birlashtirish (kichik o'zgarishlar — kam integratsiya muammosi, 28.6); qizilni darrov tuzatish (buzuq main — hamma bloklanadi); bir xil muhit (CI = lokal — 28.1, Docker); sifat darvozasi (branch protection — o'tmagan kod bloklanadi); fail fast (tez qadamlar avval — tez qayta aloqa). Yaxshi CI — tez, ishonchli, majburiy. Amaliyot — samarali sifat darvozasi. Tez va ishonchli — foydali CI.

2.8. CI — tez qayta aloqa va ishonch

CI asosiy qiymati — tez qayta aloqa va ishonch: dasturchi kod push qiladi va darrov biladi (yashil/qizil — muammo bormi?), muammoni erta tuzatadi (arzon — kontekst yodda, prodga yetmasdan). Bu ishonch beradi (test o'tsa — kod yaxshi, birlashtirish xavfsiz — 28.6 tez-tez deploy asosi). CI test (17-qism), git (05-qism), Docker 28.1-bob ni birlashtiradi (avtomatik sifat). Bu CD (28.8 — avtomatik deploy) ning birinchi yarmi (CI/CD). "Tez topilgan xato — arzon xato" — CI'ning iqtisodiy asosi. CI — sifatni avtomatik, tez, izchil kafolatlash. Qayta aloqa qanchalik tez — tuzatish shunchalik arzon. Avtomatik tekshiruv — ishonchli rivojlanish.

3. Tez ma'lumotnoma

# .github/workflows/ci.yml (GitHub Actions)
name: CI
on:                              # TRIGGER
  push: {branches: [main]}
  pull_request:
jobs:
  test:
    runs-on: ubuntu-latest       # RUNNER
    steps:                       # PIPELINE QADAMLARI
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: {python-version: "3.14"}
      - run: pip install -r requirements.txt
      - run: ruff check .        # linter (tez avval)
      - run: mypy .              # tur tekshiruvi
      - run: pytest --cov        # testlar + qamrov

# STATUS: yashil (o'tdi) / qizil (o'tmadi)
# BRANCH PROTECTION: qizil → birlashtirish bloklanadi

# QADAMLAR: lint → tur → test → build (tez → sekin)
# VOSITALAR: GitHub Actions, GitLab CI, Jenkins

CI xulosasi

CI — har kod o'zgarishini avtomatik tekshirish
Pipeline (qadamlar: lint, tur, test, build) · trigger (push/PR)
Runner (toza bulut mashinasi) · status (yashil/qizil)
Branch protection — qizil → birlashtirish bloklanadi
Tez qayta aloqa: xato darrov, erta, arzon (prodga yetmasdan)

4. Batafsil misollar

CI bulut xizmati; misollar Python bilan pipeline mantiqini modellashtiradi.

Misol 1 — Pipeline (qadamlar ketma-ketligi)

"""Pipeline: qadamlar ketma-ket, biri yiqilsa to'xtaydi (fail fast)."""


def pipeline_ishga_tushir(qadamlar: list) -> dict:
    natija = {"bajarilgan": [], "holat": "yashil", "yiqilgan": None}
    for nom, muvaffaqiyat in qadamlar:
        natija["bajarilgan"].append(nom)
        if not muvaffaqiyat:
            natija["holat"] = "qizil"
            natija["yiqilgan"] = nom
            break   # fail fast — to'xtaydi
    return natija


def main() -> None:
    print("=== 1. Barcha qadam o'tadi ===")
    yaxshi = [("checkout", True), ("install", True), ("lint", True),
              ("test", True), ("build", True)]
    r = pipeline_ishga_tushir(yaxshi)
    print(f"  bajarilgan: {r['bajarilgan']}")
    print(f"  holat: {r['holat']}")

    print("\n=== 2. Test yiqiladi ===")
    yomon = [("checkout", True), ("install", True), ("lint", True),
             ("test", False), ("build", True)]
    r = pipeline_ishga_tushir(yomon)
    print(f"  bajarilgan: {r['bajarilgan']}")
    print(f"  holat: {r['holat']}, yiqilgan: {r['yiqilgan']}")

    print("\n=== 3. Fail fast (build bajarilmadi) ===")
    print(f"  test yiqildi → build ishga tushmadi")
    print(f"  bajarilgan qadamlar: {len(r['bajarilgan'])}/5")

    print("\n=== 4. Linter yiqiladi (eng erta) ===")
    lint_yiqildi = [("checkout", True), ("install", True), ("lint", False),
                    ("test", True)]
    r = pipeline_ishga_tushir(lint_yiqildi)
    print(f"  yiqilgan: {r['yiqilgan']} (tez qadam — tez qayta aloqa)")
    print("  ⭐ Pipeline — qadamlar (biri yiqilsa to'xtaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barcha qadam o'tadi ===
  bajarilgan: ['checkout', 'install', 'lint', 'test', 'build']
  holat: yashil

=== 2. Test yiqiladi ===
  bajarilgan: ['checkout', 'install', 'lint', 'test']
  holat: qizil, yiqilgan: test

=== 3. Fail fast (build bajarilmadi) ===
  test yiqildi → build ishga tushmadi
  bajarilgan qadamlar: 4/5

=== 4. Linter yiqiladi (eng erta) ===
  yiqilgan: lint (tez qadam — tez qayta aloqa)
  ⭐ Pipeline — qadamlar (biri yiqilsa to'xtaydi)

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

Misol 2 — CI statusi va bloklash

"""CI status: yashil/qizil va birlashtirish bloklash (branch protection)."""


class PullRequest:
    def __init__(self, nom: str) -> None:
        self.nom = nom
        self.ci_holat = "kutilmoqda"

    def ci_ishga_tushir(self, testlar_otdi: bool) -> None:
        self.ci_holat = "yashil" if testlar_otdi else "qizil"

    def birlashtirsa_boladimi(self) -> tuple:
        if self.ci_holat == "yashil":
            return (True, "birlashtirish mumkin")
        return (False, f"bloklandi (CI: {self.ci_holat})")


def main() -> None:
    print("=== 1. PR yaratildi (CI kutilmoqda) ===")
    pr = PullRequest("Yangi funksiya")
    print(f"  {pr.nom}: {pr.ci_holat}")

    print("\n=== 2. CI o'tdi (yashil) ===")
    pr.ci_ishga_tushir(testlar_otdi=True)
    boladi, sabab = pr.birlashtirsa_boladimi()
    print(f"  status: {pr.ci_holat}")
    print(f"  birlashtirish: {boladi} ({sabab})")

    print("\n=== 3. Boshqa PR — CI yiqildi (qizil) ===")
    pr2 = PullRequest("Buzuq o'zgarish")
    pr2.ci_ishga_tushir(testlar_otdi=False)
    boladi, sabab = pr2.birlashtirsa_boladimi()
    print(f"  status: {pr2.ci_holat}")
    print(f"  birlashtirish: {boladi} ({sabab})")

    print("\n=== 4. Sifat darvozasi ===")
    print("  qizil PR main'ga birlashmaydi (himoya)")
    print("  buzuq kod prodga yetmaydi")
    print("  ⭐ Branch protection — sifat darvozasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. PR yaratildi (CI kutilmoqda) ===
  Yangi funksiya: kutilmoqda

=== 2. CI o'tdi (yashil) ===
  status: yashil
  birlashtirish: True (birlashtirish mumkin)

=== 3. Boshqa PR — CI yiqildi (qizil) ===
  status: qizil
  birlashtirish: False (bloklandi (CI: qizil))

=== 4. Sifat darvozasi ===
  qizil PR main'ga birlashmaydi (himoya)
  buzuq kod prodga yetmaydi
  ⭐ Branch protection — sifat darvozasi

Nima ko'rsatdi: 2.5-bo'lim.

Misol 3 — Parallel va ketma-ket qadamlar (vaqt)

"""Pipeline vaqti: ketma-ket vs parallel qadamlar (tezlik)."""


def ketma_ket_vaqt(qadamlar: dict) -> int:
    # barcha qadam navbat bilan (yig'indi)
    return sum(qadamlar.values())


def parallel_vaqt(mustaqil: dict, keyin: dict) -> int:
    # mustaqil qadamlar parallel (eng uzuni), keyin qolganlar
    parallel = max(mustaqil.values()) if mustaqil else 0
    return parallel + sum(keyin.values())


def main() -> None:
    # mustaqil tekshiruvlar (parallel bo'lishi mumkin)
    mustaqil = {"lint": 10, "mypy": 20, "test": 60}
    # bog'liq (test o'tgach)
    keyin = {"build": 40}

    print("=== 1. Ketma-ket (hammasi navbat bilan) ===")
    ketma = ketma_ket_vaqt({**mustaqil, **keyin})
    print(f"  jami vaqt: {ketma} soniya")

    print("\n=== 2. Parallel (mustaqil qadamlar birga) ===")
    par = parallel_vaqt(mustaqil, keyin)
    print(f"  jami vaqt: {par} soniya")
    print(f"  (lint/mypy/test parallel = {max(mustaqil.values())}s, keyin build 40s)")

    print("\n=== 3. Tejaladigan vaqt ===")
    print(f"  {ketma - par} soniya tez (parallel)")

    print("\n=== 4. Nega tez CI muhim ===")
    print("  dasturchi kutadi (sekin CI — e'tiborsiz)")
    print("  parallel + kesh → tez qayta aloqa")
    print("  ⭐ Tez pipeline — tez qayta aloqa")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ketma-ket (hammasi navbat bilan) ===
  jami vaqt: 130 soniya

=== 2. Parallel (mustaqil qadamlar birga) ===
  jami vaqt: 100 soniya
  (lint/mypy/test parallel = 60s, keyin build 40s)

=== 3. Tejaladigan vaqt ===
  30 soniya tez (parallel)

=== 4. Nega tez CI muhim ===
  dasturchi kutadi (sekin CI — e'tiborsiz)
  parallel + kesh → tez qayta aloqa
  ⭐ Tez pipeline — tez qayta aloqa

Nima ko'rsatdi: 2.7-bo'lim.

Misol 4 — Xato qachon topiladi (narx)

"""Xato narxi: qanchalik erta topilsa, shunchalik arzon (CI foydasi)."""


NARX = {
    "kod yozishda": 1,
    "CI (PR)": 5,
    "test muhitida": 20,
    "prodda": 100,
}


def xato_narxi(qayerda: str) -> int:
    return NARX.get(qayerda, 0)


def main() -> None:
    print("=== 1. Xato topilish bosqichlari (narx) ===")
    for bosqich, narx in NARX.items():
        print(f"  {bosqich}: {narx} birlik")

    print("\n=== 2. CI'siz: xato prodda topiladi ===")
    print(f"  narx: {xato_narxi('prodda')} birlik")
    print("  foydalanuvchi zarari, shoshilinch tuzatish")

    print("\n=== 3. CI bilan: xato PR'da topiladi ===")
    print(f"  narx: {xato_narxi('CI (PR)')} birlik")
    print("  kontekst yodda, prodga yetmadi")

    print("\n=== 4. Tejaladigan narx ===")
    tejash = xato_narxi("prodda") - xato_narxi("CI (PR)")
    print(f"  {tejash} birlik arzon (CI PR'da tutdi)")
    print("  'tez topilgan xato — arzon xato'")
    print("  ⭐ CI — xatoni erta va arzon topadi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xato topilish bosqichlari (narx) ===
  kod yozishda: 1 birlik
  CI (PR): 5 birlik
  test muhitida: 20 birlik
  prodda: 100 birlik

=== 2. CI'siz: xato prodda topiladi ===
  narx: 100 birlik
  foydalanuvchi zarari, shoshilinch tuzatish

=== 3. CI bilan: xato PR'da topiladi ===
  narx: 5 birlik
  kontekst yodda, prodga yetmadi

=== 4. Tejaladigan narx ===
  95 birlik arzon (CI PR'da tutdi)
  'tez topilgan xato — arzon xato'
  ⭐ CI — xatoni erta va arzon topadi

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

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

6. Keng tarqalgan xatolar va yechimlari

1. Sekin pipeline

# barcha qadam ketma-ket, keshsiz                 # ⚠️
# parallel qadamlar + kesh (pip, Docker)           # ✅

2. Flaky (ishonchsiz) testlar

# tasodifiy o'tadigan/yiqiladigan test             # ⚠️
# deterministik (seed, mock — kurs uslubi)          # ✅

3. CI'da branch protection yo'q

# qizil PR ham birlashadi (foyda yo'q)             # ⚠️
# branch protection (CI o'tmasa bloklash)           # ✅

4. Sekin qadamlar avval

- run: pytest   # 60s (avval)
- run: ruff     # 5s (keyin)                        # ⚠️
# lint (tez) avval → tez yiqiladi                    # ✅

5. Sirlarni CI kodiga yozish

env: {API_KEY: secret123}   # ochiq                 # ⚠️
env: {API_KEY: ${{ secrets.API_KEY }}}              # ✅

6. Lokal va CI muhit farqi

# CI'da boshqa Python versiyasi                     # ⚠️
# aniq versiya (lokal = CI, Docker)                  # ✅

7. Qizilni e'tiborsiz qoldirish

# main qizil, hamma davom etadi                     # ⚠️
# qizil — darrov tuzatish (hamma bloklangan)         # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 17-qism (o'tilgan): Testlar — CI asosiy qadami
• 05-qism (o'tilgan): Git — trigger (push, PR)
• 28.8-dars: CD — CI dan keyin deploy
• 28.1-dars (o'tilgan): Docker — bir xil muhit
• 31-qism: Jamoa — kod review, CI

8. Eng yaxshi amaliyotlar

1. Har push/PR'da avtomatik (trigger).

2. Tez pipeline (parallel, kesh).

3. Ishonchli testlar (deterministik — flaky emas).

4. Tez qadamlar avval (lint → test → build).

5. Branch protection (qizil — bloklash).

6. Sirlar — CI secrets (kodda emas).

7. CI = lokal muhit (Docker).

8. Qizilni darrov tuzatish (main himoya).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # CI nima?
2.  # nega CI (qo'lda emas)?
3.  # pipeline nima?
4.  # trigger nima?
5.  # runner nima?
6.  # CI qadamlari qaysi?
7.  # linter nima?
8.  # CI statusi?
9.  # branch protection nima?
10. # GitHub Actions nima?
11. # nega tez pipeline?
12. # xato qachon arzon?

Vazifa 2: Xatolarni tuzating

1.  # barcha qadam ketma-ket, keshsiz   # parallel/kesh

2.  # tasodifiy test (flaky)            # deterministik

3.  # branch protection yo'q            # bloklash

4.  pytest (avval); ruff (keyin)        # lint avval

5.  env: {API_KEY: secret}              # secrets

1.  parallel qadamlar + kesh

2.  deterministik (seed, mock)

3.  branch protection (CI o'tmasa bloklash)

4.  ruff (tez) avval, pytest keyin

5.  ${{ secrets.API_KEY }}

Vazifa 3: Pipeline

Modellang:

1. Qadamlar
2. Ketma-ket
3. Fail fast
4. Status

Vazifa 4: Status

Modellang:

1. Yashil/qizil
2. PR
3. Bloklash
4. Darvoza

Vazifa 5: Tezlik

Modellang:

1. Ketma-ket
2. Parallel
3. Vaqt
4. Kesh

Vazifa 6: Xato narxi

Modellang:

1. Bosqichlar
2. Prod
3. PR
4. Tejash

Vazifa 7: O'ylash

CI ning asosiy iqtisodiy mantiqi — "tez topilgan xato arzon xato" (xato prodda 100 barobar qimmat, PR'da 5). Nima uchun "qayta aloqa tezligi" dasturiy ta'minot sifatining asosiy omili (nafaqat CI'da — test, code review, foydalanuvchi qayta aloqasi ham), va nega jamoalar ko'pincha CI'ga sarmoya kiritishni kechiktiradi (garchi u aniq foydali bo'lsa)?

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda CI (uzluksiz integratsiya) ni o'rgandik.

Eng muhim uch fikr:

1. CI va pipeline. CI (Continuous Integration) — kod o'zgarishlarini tez-tez birlashtirish va har birini avtomatik tekshirish: dasturchi push qiladi → CI testlar/tekshiruvlarni ishga tushiradi → natija; qo'lda tekshirish ishonchsiz (unutiladi, kech), CI izchil (muammo darrov, arzon). Pipeline (quvur) — avtomatik qadamlar ketma-ketligi (checkout, install, lint, tur, test, build); har qadam o'tishi kerak (biri yiqilsa — to'xtaydi, qizil); tez → sekin tartib (fail fast — tez qayta aloqa).

2. Trigger, runner, status. Trigger — CI qachon ishga tushadi (on: push, on: pull_request); Runner — qayerda bajariladi (toza bulut mashinasi — ubuntu-latest, "mening mashinamda" muammosiz). Qadamlar: linter (ruff — uslub), tur (mypy), testlar (pytest — asosiy), qamrov, xavfsizlik, build (Docker). Status — yashil (o'tdi) / qizil (o'tmadi); branch protection — qizil bo'lsa birlashtirish bloklanadi (buzuq kod mainga o'tmaydi — sifat darvozasi). GitHub Actions (.github/workflows/*.yml) — mashhur CI vositasi (trigger, jobs, steps).

3. Amaliyot va tez qayta aloqa. Amaliyotlar: tez pipeline (parallel, kesh — dasturchi kutmasin), ishonchli testlar (deterministik — flaky emas), tez-tez birlashtirish (kichik), qizilni darrov tuzatish, bir xil muhit (CI = lokal, Docker), sirlar CI secrets. CI asosiy qiymati — tez qayta aloqa va ishonch: dasturchi darrov biladi (yashil/qizil), muammoni erta tuzatadi (arzon — "tez topilgan xato arzon xato": prodda 100x qimmat, PR'da 5x). "Qayta aloqa tezligi" — sifatning asosiy omili (universal: test, code review, foydalanuvchi qayta aloqasi — qisqa feedback loop); jamoalar CI'ni kechiktiradi (foydasi ko'rinmas — "oldini olingan xato", muhim vs shoshilinch tuzog'i). CI test (17-qism), git (05), Docker 28.1-bob ni birlashtiradi va CD 28.8-bob ning birinchi yarmi.

Keyingi darsda CD (uzluksiz yetkazish/chiqarish) ni o'rganamiz: CI dan keyin — testdan o'tgan kodni avtomatik ravishda test va ishlab chiqarish muhitlariga chiqarish, deploy strategiyalari va avtomatlashtirilgan chiqarish quvuri.