JavaScript Full-stackActions tezligi: cache, artifact, concurrency va qayta ishlatish
JavaScript Full-stack · 34-qism. CI/CD, monitoring, bulut

Actions tezligi: cache, artifact, concurrency va qayta ishlatish

18 daqiqa4/30-dars

Qisqacha: Har runner toza boshlanadi, shuning uchun takroriy ishni tejash kerak. Kesh (cache: npm) — paketlarni yuklab olishni tejaydi, kaliti lock fayl xeshidan. Artifact — job'lar orasida fayl uzatish. concurrency bilan bir tarmoqqa ketma-ket push'da eski yugurish bekor qilinadi. Composite action — takroriy qadamlar, reusable workflow — takroriy job'lar bitta joyda. O'lchov kutilmagan narsani ko'rsatdi: npm keshi deyarli tezlashtirmadi (0–13 s), Docker qatlam keshi esa image build'ni 85 soniyadan 4 soniyaga tushirdi.

Bu darsda

  • Kesh kaliti qanday tuzilishini va qachon "tegmasligini" tushuntirasiz.
  • npm keshining haqiqiy foydasini o'lchov bilan baholaysiz.
  • Artifact bilan job'lar orasida build natijasini uzatasiz.
  • concurrency bilan behuda yugurishlarni bekor qilasiz.
  • Composite action va reusable workflow farqini aytasiz va Docker qatlam keshini ulaysiz.

Oldin bilishingiz kerak: GitHub Actions chuqur, Actions xavfsizligi, Dockerfile best practices: kesh, Caching naqshlari va invalidatsiya.

1. Nega bu kerak?

GitHub Actions chuqur darsida loyihaning ci.yml i to'rt job'dan iborat edi. Ulardan uchtasida bir xil uch qadam takrorlanardi: Node'ni o'rnatish, npm keshini ulash, npm ci. Bitta qatorni o'zgartirmoqchi bo'lsangiz — uch joyda o'zgartirasiz va bittasini esdan chiqarasiz.

Tezlik ham muhim. Har push'da paketlar noldan o'rnatiladi, image noldan quriladi. Ikki daqiqalik CI kuniga o'n marta — yigirma daqiqa kutish. Yopiq repo'da esa har daqiqa — pul (CI narxi va byudjetsiz CI).

Hayotiy o'xshatish: choyxona. Har mehmon uchun samovarni noldan qaynatish shart emas — issiq suv tayyor turadi (kesh). Oshpaz go'shtni qassobxonadan oladi va o'zi qayta so'ymaydi (artifact). Mehmon buyurtmani o'zgartirsa, eski buyurtma bekor qilinadi (concurrency). Retsept esa bitta daftarda, har oshpaz o'zinikini yozmaydi (qayta ishlatish).

Bu darsda har usulni kanon tajribasida (IlmHamroh, 2026-11) o'lchaymiz. Ba'zi natijalar kutilganidek chiqmadi.

2. Takroriy qadamlar: composite action

2.1 Muammo va yechim

Composite action (tarkibli action) — bir nechta qadamni bitta nomli qadamga birlashtirish. U repo'ning .github/actions/<nom>/action.yml faylida yashaydi. Loyihaning action'i (izohlar va SHA yonidagi versiya izohi olib tashlandi; steps ro'yxati telefon uchun ikki bo'shliq chapga surildi — YAML uchun mazmun aynan):

yaml
name: Node tayyorla
description: setup-node (npm keshi bilan) + npm ci
inputs:
  papka:
    description: package-lock.json joylashgan papka
    required: true
  node-version:
    description: Node versiyasi
    default: "24"
runs:
  using: composite
  steps:
  - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1
    with:
      node-version: ${{ inputs.node-version }}
      cache: npm
      cache-dependency-path: ${{ inputs.papka }}/package-lock.json
  - name: npm ci
    shell: bash
    working-directory: ${{ inputs.papka }}
    run: npm ci --no-audit --no-fund

Uchta narsaga qarang:

  • inputs — action'ning parametrlari. papka majburiy, node-version — sukut bilan;
  • using: composite — "bu qadamlar to'plami";
  • shell: bash — composite ichidagi run qadamida shell'ni aniq yozish shart.

Job'da endi bitta qadam (ci.yml dan):

text
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - uses: ./.github/actions/node-tayyorla
        with:
          papka: vazifalar-api

./ — action shu repo'ning o'zida. Shuning uchun undan oldin checkout turishi shart: kod hali runner'da bo'lmasa, action fayli ham yo'q.

2.2 Composite'ning chegarasi

Composite — faqat qadamlar. Uning o'z runner'i, services, permissions yoki timeout-minutes i yo'q: u chaqirgan job'ning ichida yuradi. Butun job'ni qayta ishlatish uchun boshqa vosita kerak — «Reusable workflow» bo'limida ko'ramiz.

3. Kesh: npm paketlari

3.1 Kesh kaliti

Kesh (cache) — oldingi yugurishdan saqlangan fayllar. GitHub ularni kalit bo'yicha saqlaydi va qaytaradi. setup-node ning cache: npm sozlamasi ~/.npm papkasini — yuklab olingan paketlar omborini — keshlaydi. node_modules emas.

Kalit qanday tuzilishi kanon logida ko'rinadi:

text
tip (ubuntu-24.04): Cache saved with the key: node-cache-Linux-x64-npm-9936824de8869dc4cb99e319ed994f53d3d3fc7de1a0c3b8b9178691b6b0b2f1

Kalit qismlari: OS (Linux), arxitektura (x64), paket menejeri (npm) va lock faylining xeshi. Oxirgi qism 9936824de8869dc4… bilan boshlanadi. Uni GitHub Actions chuqur darsida hashFiles ifodasi ham aynan shunday chiqargan edi. Lock fayl o'zgarsa — kalit o'zgaradi va eski kesh ishlatilmaydi. Arm64 runner'ning kaliti esa Linux-arm64 bilan boshlanadi — ikki arxitektura bir-birining keshini olmaydi.

Bu — Caching naqshlari va invalidatsiya darsidagi kesh kaliti g'oyasining o'zi: kalitga kesh mazmunini belgilaydigan hamma narsa kirishi kerak. Modellaymiz:

js
async function keshKaliti(os, arch, lock) {
  const bayt = new TextEncoder().encode(lock);
  const xesh = await crypto.subtle.digest("SHA-256", bayt);
  const hex = [...new Uint8Array(xesh)]
    .map((b) => b.toString(16).padStart(2, "0"))
    .join("");
  return `node-cache-${os}-${arch}-npm-${hex.slice(0, 12)}…`;
}

const lock1 = '{"packages":{"zod":"4.6.7"}}';
const lock2 = '{"packages":{"zod":"4.6.8"}}';
console.log(await keshKaliti("Linux", "x64", lock1));
console.log(await keshKaliti("Linux", "arm64", lock1));
console.log(await keshKaliti("Linux", "x64", lock2));

Konsolda:

text
node-cache-Linux-x64-npm-d82b39527f5e…
node-cache-Linux-arm64-npm-d82b39527f5e…
node-cache-Linux-x64-npm-51ed007dfad4…

Bitta paket versiyasi o'zgardi — xesh butunlay boshqa. crypto.subtle.digest — brauzer va Node'dagi o'rnatilgan SHA-256. Haqiqiy hashFiles bir nechta faylni birga xeshlaydi, model esa bitta satrni — g'oya bir xil.

3.2 O'lchov: kesh qancha tejadi

Kanonda ikki yugurish solishtirildi: birinchisida kesh yo'q edi (sovuq), ikkinchisida kesh tiklandi (iliq: api uchun ~134 MB, web uchun ~87 MB). O'lchov — npm ci ning o'zi aytgan vaqt (added N packages in Xs):

npm ci: keshsiz va kesh bilan
  • api, keshsiz32 s
  • api, kesh24 s
  • arm64, keshsiz32 s
  • arm64, kesh19 s
  • web, keshsiz7 s
  • web, kesh8 s

Manba: Kurs tajribasi (IlmHamroh, 2026-11): GitHub Actions, ikki ketma-ket yugurish

Foyda — 0 dan 13 soniyagacha. Web'da kesh bilan hatto bir soniya sekinroq chiqdi. x64 tip job'ida ham shunday: 22 → 24 s.

Halol xulosa: npm keshi faqat yuklab olishni tejaydi. GitHub runner'ida npm registry juda tez — yuklash vaqtning kichik qismi. Asosiy vaqt boshqa ishlarga ketadi: 844 paketni node_modules ga yoyish va postinstall skripti (prisma generate). Kesh ularning hech birini tejamaydi. Bundan tashqari, keshning o'zini tiklash ham vaqt oladi — 134 MB ni yuklab ochish kerak.

Bitta yugurish — bitta o'lchov, runner tezligi o'zgarib turadi. Lekin tendensiya aniq: bu loyihada npm keshi kutilgan "ikki baravar" ni bermadi. Bu uni o'chirish kerak degani emas — registry sekin yoki ishlamay qolgan kuni u yordam beradi. Lekin "CI sekin — kesh qo'shamiz" deyishdan oldin o'lchang.

Tekshirib ko'ring: Kimdir "node_modules ni keshlasak, npm ci umuman kerak bo'lmaydi" deb taklif qildi. Qanday xavf bor?

Javob

npm ci ning vazifasi — node_modules ni lock faylga aynan moslab, noldan qurish. Keshlangan node_modules boshqa Node versiyasi yoki boshqa OS uchun qurilgan bo'lishi mumkin (native modullar, prisma generate natijasi). Shunda "CI'da ishlaydi, yangi runner'da yo'q" turidagi qiyin xatolar paydo bo'ladi. Shuning uchun setup-node ataylab ~/.npm ni keshlaydi. node_modules ni keshlash mumkin, lekin kalitga Node versiyasini ham qo'shish va lock bilan qat'iy bog'lash kerak.

3.3 Bir xil kalit — bitta saqlash

Sovuq yugurish logida yana bir narsa ko'rindi. api job'i va x64 tip job'i bitta lock fayl va bitta runner turidan foydalanadi — kesh kaliti bir xil. Ikkalasi ham kesh topmadi, ikkalasi ham paket o'rnatdi. Lekin "Cache saved" qatori faqat bittasida bor:

text
api (tip, lint, test, build): added 844 packages in 32s
tip (ubuntu-24.04): added 844 packages in 22s
tip (ubuntu-24.04): Cache saved with the key: node-cache-Linux-x64-npm-9936824de8869dc4cb99e319ed994f53d3d3fc7de1a0c3b8b9178691b6b0b2f1

Kesh yozilgandan keyin o'zgarmaydi. Kim birinchi tugatsa, o'sha saqlaydi, ikkinchisi esa "bu kalit allaqachon bor" deb o'tkazib yuboradi. Bu xato emas — lekin parallel job'lar birinchi yugurishda bir-biriga yordam bera olmasligini ko'rsatadi.

4. Artifact: job'dan job'ga fayl

4.1 Yuklash va olish

Kesh — "bo'lsa yaxshi", tezlashtirish uchun. Artifact esa — natija: job yaratgan va keyingisiga yoki odamga kerak bo'lgan fayl. U yo'qolsa, ish to'xtaydi. CI/CD tushunchasi darsidagi "artifact bir marta quriladi" qoidasi shu yerda amalga oshadi.

ci.yml dagi api job'i build'dan keyin dist/ ni yuklaydi:

text
      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
        with:
          name: api-dist
          path: vazifalar-api/dist/
          retention-days: 3

Web job'i — xuddi shunday, web-dist nomi bilan. artefakt job'i esa needs: [api, web] bilan ikkala yuklashni kutadi va download-artifact bilan oladi. Kanon yugurishida yuklash 1–2 soniya, olish 2–4 soniya oldi.

retention-days: 3 — artifact uch kundan keyin o'chiriladi. Artifact'lar repo'ning saqlash joyini band qiladi, sukut muddati esa 90 kun (GitHub Docs, tekshirildi, 2026-11). CI natijasi uch kundan keyin baribir eskiradi.

4.2 Kesh va artifact farqi

Kesh Artifact
Maqsad tezlashtirish natijani uzatish
Yo'qolsa sekinroq, lekin ishlaydi keyingi job yiqiladi
Kim ko'radi keyingi yugurishlar shu yugurish job'lari va odam
Misol ~/.npm dist/, test hisoboti

Ular almashtirilmaydi. Build natijasini keshga qo'yib, keyingi job'da "bo'lsa olaman" deyish — ishonchsiz: kesh istalgan payt o'chirilishi mumkin. GitHub Docs'ga ko'ra (2026-11 holatiga) 7 kun ishlatilmagan kesh o'chiriladi. Repo keshlari sukut bo'yicha jami 10 GB dan oshsa, eskilari siqib chiqariladi.

5. concurrency: eski yugurishni bekor qilish

5.1 Muammo

Siz push qildingiz, keyin xatoni ko'rib, 10 soniyadan keyin yana push qildingiz. Endi ikki yugurish parallel ketmoqda — birinchisining natijasi baribir eskirgan. U shunchaki runner va daqiqalarni yeydi.

Concurrency (bir vaqtdalik) — bir guruhdagi yugurishlar bir vaqtda faqat bittadan bo'lishi qoidasi:

yaml
concurrency:
  group: ci-${{ github.ref }}
  cancel-in-progress: true

group — guruh nomi. github.ref tarmoqqa bog'liq: main dagi yugurishlar bir guruhda, har PR — o'z guruhida. cancel-in-progress: true — yangisi kelsa, eskisi bekor qilinadi.

5.2 Tajriba: ikki ketma-ket push

Kanonda ikki commit (B va C) bir necha soniya oralig'ida push qilindi:

sequenceDiagram
  participant D as Dasturchi
  participant G as GitHub
  D->>G: push B
  G->>G: B yugurishi boshlandi
  D->>G: push C
  G->>G: B bekor qilindi (5 job)
  G->>G: C yugurishi boshlandi

B yugurishining xulosasi (qisqartirilgan):

text
CI push e74eb33 → cancelled (2026-11-07T16:20:38Z … 2026-11-07T16:21:01Z)
  api (tip, lint, test, build): cancelled 16:20:40–16:20:48
  artefakt: cancelled 16:20:48–16:20:48

Beshala job ham bekor qilindi — ba'zilari servislarni ko'tarish payti, ba'zilari npm ci o'rtasida. C yugurishi 16:20:45 da yaratildi, lekin uning job'lari 16:21:03 da boshlandi — B ning oxirgi job'i to'xtagandan 2 soniya keyin. Guruhda bir vaqtda bitta yugurish: yangisi eskisining tozalanishini kutadi.

5.3 Qachon bekor qilmaslik kerak

CI uchun bekor qilish xavfsiz: tekshiruvni yarmida to'xtatish hech narsani buzmaydi. Deploy uchun esa — xavfli. Yarim bajarilgan deploy serverni noaniq holatda qoldiradi: migratsiya o'tgan, ilova esa eski. Shuning uchun kanonning cd.yml ida:

yaml
concurrency:
  group: cd-production
  cancel-in-progress: false

Deploy'lar navbatga turadi va hech biri yarmida uzilmaydi. Bu haqda VPS'ga avtomatik deploy darsida.

Tekshirib ko'ring: group: ci deb yozildi (github.ref siz). Ikki dasturchi bir vaqtda ikki xil PR ochdi. Nima bo'ladi?

Javob

Ikkala PR bitta guruhga tushadi. Ikkinchi PR'ning yugurishi birinchisinikini bekor qiladi. Birinchi dasturchi sababsiz "cancelled" ko'radi va qayta ishga tushiradi — endi u ikkinchisinikini bekor qiladi. Guruh nomi "nimaning eski versiyasi" ekanini aniq aytishi kerak: tarmoq yoki PR raqami.

6. Reusable workflow: butun job'ni qayta ishlatish

6.1 workflow_call

Reusable workflow (qayta ishlatiladigan workflow) — boshqa workflow'dan chaqiriladigan workflow. Composite'dan farqi — u butun job'lar bilan keladi: o'z runner'i, permissions, outputs. Kanonda image qurish shunday ajratilgan — _image.yml:

yaml
on:
  workflow_call:
    inputs:
      nom: { type: string, required: true }
      papka: { type: string, required: true }
      sha: { type: string, required: true }
    outputs:
      teg:
        description: image tegi (sha-<40 hex>)
        value: ${{ jobs.qur.outputs.teg }}

workflow_call — "meni boshqa workflow chaqiradi". inputs — parametrlar, outputs — chaqiruvchiga qaytariladigan qiymat. Fayl nomidagi _ — kanon kelishuvi: "bu mustaqil ishga tushmaydi".

Chaqiruvchi — cd.yml. U bitta job ta'rifi va matrix bilan ikki image quradi:

yaml
jobs:
  image:
    strategy:
      matrix:
        include:
          - { nom: api, papka: vazifalar-api }
          - { nom: web, papka: vazifalar }
    permissions:
      contents: read
      packages: write
    uses: ./.github/workflows/_image.yml
    with:
      nom: ${{ matrix.nom }}
      papka: ${{ matrix.papka }}
      sha: ${{ github.event.workflow_run.head_sha || github.sha }}

Job'da steps yo'q — o'rniga uses. permissions ni chaqiruvchi beradi: packages: write — registry'ga yozish, faqat shu job'ga (Actions xavfsizligi). CD'ning qolgan qismi — keyingi darslarda.

6.2 Qaysi birini tanlash

Composite action Reusable workflow
Nimani birlashtiradi qadamlarni job'larni
Fayl .github/actions/<nom>/action.yml .github/workflows/*.yml
Chaqirish qadamda uses: job'da uses:
Runner, services, permissions chaqiruvchiniki o'ziniki

Qoida: "Node o'rnat va paketlarni qo'y" kabi kichik retsept — composite. "Image qur va registry'ga yukla" kabi alohida ish, o'z huquqlari bilan — reusable workflow.

7. Docker qatlam keshi

7.1 type=gha

Image build'i Dockerfile best practices darsidagi qatlam keshiga tayanadi: o'zgarmagan qatlam qayta qurilmaydi. Lekin runner har safar toza — uning lokal Docker keshi bo'sh. Yechim — BuildKit keshini GitHub'ning kesh xizmatida saqlash. _image.yml dagi build qadamidan:

text
          cache-from: type=gha,scope=${{ inputs.nom }}-arm64
          cache-to: type=gha,mode=max,scope=${{ inputs.nom }}-arm64
  • type=gha — GitHub Actions kesh xizmati;
  • scope — har image o'z keshida (api va web aralashmasin);
  • mode=max — oxirgi image qatlamlarigina emas, oraliq build bosqichlari ham saqlansin (Multi-stage build dagi build bosqichi).

7.2 O'lchov: 85 dan 4 soniyagacha

CD yugurishlaridagi build qadami (arm64 runner):

CD yugurishi api web
birinchi, kesh bo'sh 85 s 49 s
faqat api Dockerfile'ning oxirgi qatori o'zgardi 4 s 6 s
bog'liqliklar qo'shildi (package-lock.json o'zgardi) 91 s 4 s

Ikkinchi qatorda o'zgarish oxirgi qatlamda edi — qolgan hammasi keshdan. 85 soniya 4 ga tushdi. Uchinchi qator boshqa tomonni ko'rsatadi. Bog'liqliklar o'zgarganda npm ci qatlami va undan keyingilarning hammasi qaytadan quriladi — kesh deyarli yordam bermaydi. Web esa o'zgarmagan, 4 soniya.

npm keshi bilan farqni ko'ryapsizmi? npm keshi faqat yuklashni tejardi. Qatlam keshi esa butun ishni — o'rnatishni ham, build'ni ham — tayyor holda beradi. Shuning uchun Dockerfile'da qatlamlar tartibi muhim: kam o'zgaradigani (bog'liqliklar) oldinda, ko'p o'zgaradigani (kod) oxirida.

8. Loyiha qadami

O'z monorepo'ngizda:

  1. .github/actions/node-tayyorla/action.yml ni yarating va uch job'dagi takroriy qadamlarni u bilan almashtiring.
  2. ci.yml boshiga concurrency bloki (cancel-in-progress: true).
  3. api va web job'lari oxirida upload-artifact (retention-days: 3), artefakt job'ida download-artifact.
  4. Ikki ketma-ket push qilib, birinchisi bekor qilinganini ko'ring.

npm ci vaqtini o'zingiz ham o'lchang: birinchi va ikkinchi yugurishning job logida added … packages in … qatorini toping. Commit xabari, masalan:

text
ci: composite action (node + npm keshi), artifact'lar, concurrency

Reusable workflow va Docker qatlam keshi VPS'ga avtomatik deploy darsida CD bilan birga ulanadi.

9. Ko'p uchraydigan xatolar

9.1 Kesh kaliti juda keng

Kalitda lock xeshi yo'q (node-cache-Linux) — paketlar yangilansa ham eski kesh tiklanadi. Kalitga kesh mazmunini belgilaydigan hamma narsa kirsin.

9.2 node_modules ni xato kalit bilan keshlash

Node versiyasi o'zgaradi, kalit esa yo'q — native modullar buziladi. ~/.npm ni keshlang yoki kalitga Node versiyasini qo'shing.

9.3 Composite action'ni checkout dan oldin chaqirish

Runner action.yml faylini topa olmaydi — repo hali runner'da yo'q. Avval actions/checkout.

9.4 Deploy'da cancel-in-progress: true

Yarim deploy — yarim yangi server. Deploy guruhida false.

9.5 O'lchamasdan "optimallashtirish"

Kesh, parallel job'lar, katta runner — har biri o'z narxiga ega. Avval eng uzun job va eng uzun qadamni toping, keyin o'zgartirib, yana o'lchang.

10. Mashqlar

Mashqlar kurs/mashqlar/34/04-tezlik/ da. 2-mashq Node 24.21.0 da, 3-mashq Git Bash'da tekshirilgan (biz ishga tushirdik).

1-mashq (oson): bo'shliqlarni to'ldiring

  • setup-node ning cache: npm keshlaydigan papka — ~/.
  • Job'lar orasida build natijasini uzatish vositasi —
  • Yangi yugurish kelganda eskisini bekor qiluvchi sozlama — cancel-in-progress:
  • Boshqa workflow'dan chaqiriladigan workflow trigger'i —
  • Docker qatlamlarini GitHub kesh xizmatida saqlash — type=
Yechim
  • npm — yuklab olingan paketlar ombori, node_modules emas.
  • artifact — yo'qolsa keyingi job yiqiladi; kesh esa ixtiyoriy.
  • true — CI uchun; deploy uchun false.
  • workflow_call — inputs va outputs bilan.
  • gha — scope bilan har image alohida.

2-mashq (o'rta): kesh qaysi kalitdan tiklanadi

actions/cache aynan kalitni topmasa, restore-keys ro'yxatidagi prefikslarni tartib bilan sinaydi. Bitta prefiksga bir nechta kesh mos kelsa — eng yangisi olinadi (GitHub Docs, tekshirildi, 2026-11). keshTop(kalit, restoreKeys, mavjud) funksiyasini yozing. mavjud — { kalit, vaqt } massivi. Natija — "aynan: <kalit>", "qisman: <kalit>" yoki "topilmadi". Uch holatni sinang: lock o'zgarmagan, lock o'zgargan (prefiks yordam beradi) va boshqa OS.

Ishora: filter + startsWith — prefiksga mos keshlar; eng yangisi — vaqt bo'yicha eng katta (sort va taqqoslash funksiyasi).

Yechim
js
function keshTop(kalit, restoreKeys, mavjud) {
  if (mavjud.some((k) => k.kalit === kalit)) return `aynan: ${kalit}`;
  for (const prefiks of restoreKeys) {
    const mos = mavjud
      .filter((k) => k.kalit.startsWith(prefiks))
      .sort((a, b) => b.vaqt - a.vaqt);
    if (mos.length > 0) return `qisman: ${mos[0].kalit}`;
  }
  return "topilmadi";
}

const mavjud = [
  { kalit: "npm-Linux-x64-aaa111", vaqt: 1 },
  { kalit: "npm-Linux-x64-bbb222", vaqt: 5 },
  { kalit: "npm-Linux-arm64-aaa111", vaqt: 3 },
];
const restore = ["npm-Linux-x64-"];
console.log(keshTop("npm-Linux-x64-aaa111", restore, mavjud));
console.log(keshTop("npm-Linux-x64-ccc333", restore, mavjud));
const win = ["npm-Windows-"];
console.log(keshTop("npm-Windows-x64-aaa111", win, mavjud));

Konsolda:

text
aynan: npm-Linux-x64-aaa111
qisman: npm-Linux-x64-bbb222
topilmadi

Ikkinchi holat — restore-keys ning asosiy foydasi: lock o'zgardi, lekin eski paketlarning ko'pi baribir shu. Eng yangi qisman kesh (bbb222, vaqt 5) olindi — u yangi lock'ka eng yaqin bo'lishi ehtimoli katta. Qisman kesh tiklangandan keyin npm ci yetishmaganini yuklab oladi. Uchinchi holatda Windows uchun kesh yo'q: arm64 keshi ham prefiksga mos emas.

3-mashq (qiyin): kesh foydasini hisoblash

Bash skript yozing. U avval ikki yugurishning npm ci qatorlarini o'z ichiga olgan kesh.log ni yaratsin (== sovuq va == iliq bo'limlari, qatorlar — kanon logidagidek: api (…): added 844 packages in 32s). Keyin awk bilan har job uchun nom: X s -> Y s (farq) chiqarsin, oxirida — jami tejalgan soniya. Job'lar tartibi — sovuq bo'limda uchragan tartibda.

Ishora: bo'lim nomini /^== / qatoridan oling (bolim = $2). -F': added ' ajratgich bilan $1 — job nomi, $2 — 844 packages in 32s; vaqt — $2 ning oxirgi so'zi: split($2, s, " ") va s[4], keyin sub(/s$/, "", v). Farqning ishorasi uchun: f > 0 ? "+" f : f.

Yechim
bash
cat > kesh.log <<'LOG'
== sovuq
web (format, lint, tip, test, build): added 637 packages in 7s
api (tip, lint, test, build): added 844 packages in 32s
tip (ubuntu-24.04-arm): added 844 packages in 32s
tip (ubuntu-24.04): added 844 packages in 22s
== iliq
tip (ubuntu-24.04): added 844 packages in 24s
web (format, lint, tip, test, build): added 637 packages in 8s
api (tip, lint, test, build): added 844 packages in 24s
tip (ubuntu-24.04-arm): added 844 packages in 19s
LOG
awk -F': added ' '
/^== / { split($0, b, " "); bolim = b[2]; next }
{
  split($2, s, " "); v = s[4]; sub(/s$/, "", v)
  if (bolim == "sovuq") { tartib[++n] = $1; sovuq[$1] = v }
  else iliq[$1] = v
}
END {
  for (i = 1; i <= n; i++) {
    j = tartib[i]; f = iliq[j] - sovuq[j]; jami += f
    d = (f > 0 ? "+" f : f)
    print j ": " sovuq[j] " s -> " iliq[j] " s (" d ")"
  }
  print "jami tejaldi: " (-jami) " s"
}
' kesh.log

Biz ishga tushirdik:

text
web (format, lint, tip, test, build): 7 s -> 8 s (+1)
api (tip, lint, test, build): 32 s -> 24 s (-8)
tip (ubuntu-24.04-arm): 32 s -> 19 s (-13)
tip (ubuntu-24.04): 22 s -> 24 s (+2)
jami tejaldi: 18 s

To'rt job bo'yicha jami 18 soniya — ikki daqiqalik yugurishda sezilarsiz, chunki job'lar parallel va eng uzuni (api) atigi 8 soniya yutdi. Bunday hisob-kitobni o'z loyihangizda ham qiling. "Kesh qo'shdik — tezlashdi" degan da'vo faqat ikki yugurish solishtirilgandagina ishonchli. Ajratgich (-F) bir necha belgidan iborat bo'lishi mumkin — awk uni oddiy satr sifatida qidiradi (Fayl va matn qidirish). Oxirgi qatordagi qavslar (-jami) shart: ularsiz awk "…: " -jami ni satrdan ayirish deb tushunadi va natija faqat 18 s bo'lib chiqadi — biz shu xatoni birinchi urinishda qildik.

11. Real ishda

  • Katta loyihalarda CI vaqtining asosiy qismi testlarga ketadi. Ularni bir nechta parallel job'ga bo'lish (sharding — Test arxitekturasi va CI) ko'pincha keshdan ko'proq foyda beradi.
  • Turborepo va Nx "masofaviy kesh" bilan o'zgarmagan paketlarning build va test natijasini butunlay o'tkazib yuboradi — artifact va kesh g'oyasining keyingi bosqichi.
  • Tashkilotlar reusable workflow'larni alohida repo'da saqlaydi: hamma loyiha bir xil, tekshirilgan deploy job'ini chaqiradi.
  • Intervyu savollari: "Kesh va artifact farqi nima?", "Kesh kaliti nimadan tuziladi?", "cancel-in-progress qachon xavfli?", "Composite action va reusable workflow farqi?"

Xulosa

  • Composite action — takroriy qadamlar bitta joyda; checkout dan keyin chaqiriladi.
  • Kesh kaliti = OS + arxitektura + lock xeshi; lock o'zgarsa — yangi kesh; bir xil kalit faqat bir marta saqlanadi.
  • npm keshi kanonda 0–13 s tejadi: u faqat yuklashni tejaydi, yoyish va postinstall ni emas.
  • Artifact — natija (yo'qolsa yiqiladi), kesh — tezlashtirish (yo'qolsa sekinroq).
  • concurrency + cancel-in-progress: true — CI'da eski yugurish bekor; deploy'da — false.
  • Reusable workflow — job'lar o'z huquqlari bilan; Docker qatlam keshi (type=gha) build'ni 85 s dan 4 s ga tushirdi, bog'liqlik o'zgarganda esa yordam bermadi.

Keyingi dars: CI narxi va byudjetsiz CI — Actions daqiqalari qancha turadi, ochiq va yopiq repo farqi, act bilan workflow'ni lokal yurgizish va pre-push tekshiruvi.

Manbalar

34-qism. CI/CD, monitoring, bulut · 4-dars yakunlandi

Actions tezligi: cache, artifact, concurrency va qayta ishlatish

18 daqvaqt
0belgi
Keyingi dars: CI narxi va byudjetsiz CI: daqiqalar, act va pre-push
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0