# Cum accelerezi GitHub Actions: scurtează un pipeline de 25 de minute, pârghie cu pârghie

> Un pipeline GitHub Actions lent înseamnă joburi care se așteaptă între ele, muncă ce nu trebuia să ruleze, setup repetat pe un VM gol și pași care depind de CPU, pe 2 nuclee. Rezolvă-le în această ordine. Ultimele două țin de mașină: Skipbox îți păstrează cache-urile pe mașina ta dedicată între joburi, cu până la 16 vCPU, la un preț fix de $39 pe lună, cu minute nelimitate.

Un pipeline GitHub Actions de 25 de minute înseamnă de obicei patru întârzieri suprapuse: joburi care se așteaptă între ele, muncă ce nu trebuia să ruleze, setup pe care un VM gol îl repetă la fiecare job și pași care depind de CPU, înghesuiți pe 2 nuclee (`ubuntu-latest` dintr-un repository privat are 2 CPU și 8 GB). Ia-le în această ordine. Mai întâi, măsoară calea critică, cu timpul de coadă separat. Apoi sari peste ce nu trebuia să ruleze, rulează simultan joburile independente, nu mai reconstrui starea, dă-le pașilor grei mai multe nuclee și împarte în sharduri ce e încă lung. Primele trei sunt corecturi de workflow care nu costă nimic. Restul țin de mașină: un runner care își păstrează cache-urile între joburi și are mai multe nuclee.

Skipbox este acel runner. Joburile tale rulează pe mașina dedicată a contului tău, care păstrează layerele Docker, cache-urile de pachete, instrumentele și rezultatele buildului între joburi, cu 4 până la 16 vCPU, la un preț fix de $39 pe lună, cu minute nelimitate. Pe CI-ul astro, asta a însemnat 528 s pe GitHub și 30 s pe Skipbox. Mutarea înseamnă o singură linie: `runs-on: skipbox`.

- Pârghiile în ordine: măsoară, sari peste, rulează în paralel, nu mai reconstrui, adaugă nuclee, împarte în sharduri
- Mașina ta dedicată păstrează cache-urile și rezultatele buildului între joburi: CI-ul astro a coborât de la 528 s la 30 s
- 20.000 de minute pe lună pe 4 vCPU: $222 pe GitHub, $39 pe Skipbox

**GitHub Actions la preț fix, cu minute nelimitate** Skipbox rulează joburile tale GitHub Actions pe propria ta mașină dedicată: $39 pe lună, oricâte minute ai rula. Layerele Docker și cache-urile de dependențe rămân între joburi, așa că jobul următor pornește imediat.

Un runner de 4 vCPU, 20.000 de minute pe lună: GitHub $222 → Skipbox $39. Economisești $183 în fiecare lună.

E nevoie de o singură linie: `runs-on: skipbox`.

[Încearcă gratuit 7 zile](https://app.skipbox.dev/sign-in?ref=g-speed-up-github-actions-ro)

## 1. Măsoară calea critică

Timpul pe care îl așteaptă echipa ta e lanțul de joburi care se termină ultimul, nu suma tuturor joburilor. Deschide rularea unui pull request reprezentativ: graficul arată ce joburi le așteaptă pe care, iar logul fiecărui job arată duratele pașilor. Notează, pentru lanțul cel mai lent:

| Faza | Ce verifici |
|---|---|
| În coadă | A așteptat jobul un runner? O comandă mai rapidă nu poate scurta o coadă |
| Set up job, checkout | O imagine de container descărcată, o clonă completă unde ar ajunge una superficială |
| Toolchain și instalare | A avut cache-ul potrivire și a economisit potrivirea mai mult decât a durat restaurarea? |
| Build | Se construiește același rezultat și într-un alt job? |
| Teste | E CPU-ul runnerului ocupat tot timpul sau un singur worker face totul? |
| Încărcări | Artefacte și salvări de cache după ce munca utilă s-a terminat |

Compară o rulare cu cache cu una la rece. Un cache care ratează jumătate din timp arată bine într-o medie.

## 2. Sari peste ce nu trebuia să ruleze

- **Anulează rulările depășite.** Fiecare push după primul face inutilă rularea aflată în curs. Un [grup de concurrency](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency) cu `cancel-in-progress` o oprește. Limitează-l la pull request-uri, ca un push pe branchul implicit să nu anuleze niciodată un deploy:

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
```

- **Rulează doar ce atinge schimbarea.** Filtrele `paths:` sar peste un workflow la schimbările doar de documentație; într-un monorepo, `turbo run test --affected` sau comenzile affected din Nx rulează doar pachetele care s-au schimbat. Un filtru la nivel de trigger înseamnă că o verificare obligatorie nu raportează niciodată, așa că filtrează în interiorul jobului când verificarea e obligatorie.

## 3. Rulează simultan joburile independente

GitHub rulează joburile în paralel, dacă nu le înlănțuie `needs:`. Lint, verificarea tipurilor, testele unitare și buildul rareori au nevoie unele de altele: pornește-le împreună și lasă doar împachetarea sau deployul să le aștepte pe toate. Dacă două joburi construiesc același lucru, construiește-l o singură dată și transmite-l cu `actions/upload-artifact`, cronometrând încărcarea și descărcarea.

## 4. Nu mai reconstrui aceeași stare

Aici se duce cea mai mare parte a unui pipeline lung. Fiecare job de pe un runner găzduit de GitHub pornește pe un VM nou, așa că își descarcă toolchainul, instalează dependențele, reconstruiește layerele Docker și compilează de la zero, de fiecare dată.

- **Cache-uri care chiar au potriviri.** `cache: npm` din `actions/setup-node` (și formele lui pentru pnpm și yarn) salvează descărcările managerului de pachete, cu cheia legată de lockfile; nu salvează `node_modules`, așa că instalarea tot rulează. GitHub păstrează 10 GB per repository, elimină intrările nefolosite de 7 zile, iar o potrivire tot e o descărcare pe VM-ul nou ([limita de mărime a cache-ului](https://skipbox.dev/ro/guides/github-actions-cache-size-limit)).
- **Cache-urile instrumentelor.** `eslint --cache`, `tsc --incremental`, directorul de cache Jest și `.turbo/cache` al turbo salvează munca însăși, nu descărcările. Pe un VM nou sunt goale, dacă nu le restaurezi și pe ele.
- **Layerele Docker.** `docker build` pe un VM nou pornește fără niciun layer; ocolișul e să le exporți cu `cache-to` din buildx și să le imporți la fiecare rulare ([cache-ul de layere Docker](https://skipbox.dev/ro/guides/docker-layer-cache-github-actions)).

O mașină care își păstrează discul face toate acestea singură: cache-urile, cache-urile instrumentelor, layerele și rezultatele buildului sunt acolo de la jobul anterior.

## 5. Dă-le pașilor grei mai multe nuclee

Compilatoarele, bundlerele și test runnerele pornesc câte un worker pe nucleu, așa că pe 2 CPU rulează câte două odată. Verifică ce folosește de fapt test runnerul: [Jest](https://jestjs.io/docs/cli#--maxworkersnumstring) folosește implicit numărul de nuclee minus unu (un worker pe 2 CPU), pytest rulează serial până la `-n auto`, iar [Playwright](https://playwright.dev/docs/ci#workers) folosește implicit jumătate din nuclee, documentația lui recomandând un singur worker în CI. Mai multe nuclee ajută doar după ce runnerului i se spune să le folosească și doar la pașii care țin CPU-ul ocupat; o descărcare sau pornirea unei baze de date nu se accelerează.

Pe GitHub, mai multe nuclee înseamnă [runnere mari](https://docs.github.com/en/actions/concepts/runners/larger-runners): de la 4 la 96 de nuclee, doar pe organizațiile cu GitHub Team sau Enterprise Cloud, facturate la minut, la un tarif mai mare pe nucleu.

## 6. Împarte în sharduri ce e încă lung

O matrice de sharduri împarte o suită lungă pe mai multe joburi. Scurtează timpul real, nu minutele: fiecare shard face din nou checkout, instalare și build, așa că patru sharduri plătesc setup-ul de patru ori. Echilibrează shardurile după timpul măsurat, nu după numărul de fișiere, și nu mai adăuga când setup-ul înseamnă cea mai mare parte din fiecare shard.

## Cât te costă să rămâi lent

Un pipeline de 15 minute care rulează de 40 de ori pe zi înseamnă 10 ore de așteptare împărțite în echipa ta, în fiecare zi, înainte să numere cineva întreruperile. La facturarea la minut, minutele de setup se facturează la fel ca minutele de teste:

| Minute pe lună (4 vCPU) | GitHub | Skipbox S | Economisești în fiecare lună |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |

Pe GitHub, mai multe nuclee costă mai mult pe minut, așa că diferența crește odată cu mașina:

| 20.000 de minute pe lună | GitHub | Skipbox | Economisești în fiecare lună |
|---|---|---|---|
| 8 vCPU | $422 | $79 (M) | **$343** |
| 16 vCPU | $822 | $149 (L) | **$673** |

Cifrele GitHub sunt după utilizarea inclusă în GitHub Team. Încearcă propriile minute în [calculatorul de pe pagina principală](https://skipbox.dev/?ref=g-speed-up-github-actions-ro#cost).

## Când soluția e mașina

Joburile de CI ale unor proiecte reale, cu pașii neschimbați, pe runnerul GitHub pentru repository-uri publice (4 vCPU, 16 GB) și pe o mașină dedicată Skipbox cu același număr de vCPU, din [rulările noastre ale workflow-urilor lor](https://skipbox.dev/ro/guides/rust-cache-slow-rust-ci):

| Proiect | GitHub | Skipbox, mașina dedicată | Ce a păstrat mașina |
|---|---|---|---|
| astro (Node.js, Turborepo) | 528 s | **30 s** | cache-ul turbo: 40 de taskuri de build reluate |
| tauri (Rust) | 246 s | **53 s** | `target/` de la Cargo: niciun crate recompilat |
| ripgrep (Rust) | 200 s | **40 s** | `target/` și imaginea Docker ale cross |
| vite (Node.js) | 141 s | 100 s | cache-urile de pachete; restul înseamnă rularea testelor |

`ubuntu-latest` dintr-un repository privat are jumătate din nucleele acelor rulări GitHub.

## Ce face Skipbox pentru pipeline-ul tău

**Păstrează mașina.** Fiecare plan vine cu mașina dedicată a contului tău, păstrată între joburi. Imaginile, layerele și cache-ul de build Docker, cache-urile de pachete, tool cache-ul și checkoutul tău cu `target/` de la Cargo și cache-ul turbo rămân pe discul ei: cel puțin de 7× spațiul de cache de la GitHub, fără chei, fără expirare după 7 zile și fără regula branchurilor.

**Adaugă nuclee la preț fix.** Un job își alege mărimea prin etichetă:

| Etichetă | Mașină | Plan |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 pe lună |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 pe lună |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 pe lună |

Minutele sunt nelimitate, așa că shardurile, rulările repetate și o matrice mai mare nu măresc factura. Joburile Skipbox nu folosesc minute GitHub, așa că un buget GitHub nu le oprește niciodată.

**Se îngrijește singur.** Skipbox pregătește mașina, ține imaginea la zi, face curățenie după fiecare job și reface o mașină care nu trece verificarea stării.

## Mutarea înseamnă o singură linie

```yaml
jobs:
  test:
    runs-on: skipbox # was ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci && npm test
```

1. Conectează-te la Skipbox cu GitHub.
2. Instalează aplicația GitHub Skipbox și alege repository-urile.
3. Schimbă `runs-on` și fă push.

Pașii și actions rulează așa cum sunt, pe Ubuntu 24.04 cu Docker, Node.js și Python.

## Securitate

- Mașina este doar a contului tău. Niciun job al altei companii nu rulează pe ea.
- După fiecare job, credențialele runnerului, procesele și containerele sunt șterse, la fel și credențialele git și fișierele neurmărite din checkoutul păstrat. „Curățare la fiecare job” îi dă în schimb fiecărui job o mașină nouă.
- Codul de la persoane fără acces de scriere (cum ar fi pull request-urile din forkuri) rulează pe un VM nou, care îți citește cache-urile, dar nu le poate modifica.

Detaliile sunt în [cum sunt izolate joburile](https://docs.skipbox.dev/ro/isolation).

## Încearcă pe cel mai lent job

Perioada de probă este gratuită timp de 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, și nu cere card. Mută pe `runs-on: skipbox` jobul de pe calea ta critică, rulează-l de două ori și citește duratele pașilor de la a doua rulare lângă cele de pe GitHub.

## Întrebări frecvente

### Pipeline-ul nostru GitHub Actions durează 25 de minute. Care e cea mai rapidă cale să-l facem mai rapid?

Ia-o pe rând. Citește graficul rulării și duratele pașilor ca să găsești lanțul de joburi care stabilește durata, cu timpul de coadă separat. Anulează rulările depășite și sari peste joburile ale căror fișiere nu s-au schimbat. Renunță la needs: care exprimă doar un obicei, ca joburile independente să ruleze simultan. Nu mai reconstrui starea la fiecare job: cache-uri care chiar au potriviri sau un runner care își păstrează discul. Dă-le pașilor care depind de CPU mai multe nuclee și lasă test runnerul să le folosească. Împarte în sharduri doar ce e încă lung. Pe ubuntu-latest dintr-un repository privat (2 CPU, 8 GB), ultimele trei înseamnă adesea cea mai mare parte din cele 25 de minute și țin de mașină: Skipbox îi dă jobului propria mașină, care păstrează cache-urile între joburi, cu 4 până la 16 vCPU.

### Merită să trecem pe runnere mai rapide în loc să optimizăm workflow-ul?

Fă mai întâi corecturile gratuite din workflow: anularea rulărilor depășite, filtrele de cale și eliminarea needs: inutile nu costă nimic și niciun runner nu le face în locul tău. După aceea, uită-te unde se duce restul timpului. Setup-ul care se repetă la fiecare job (toolchainuri, instalarea dependențelor, builduri Docker) și pașii care țin ocupat fiecare nucleu sunt problema mașinii, iar un runner care își păstrează cache-urile și are mai multe nuclee le elimină cu o schimbare de o linie în runs-on. Așteptările pe rețea și pașii seriali nu se accelerează cu o mașină mai mare.

### De ce e GitHub Actions mai lent decât laptopul meu?

Laptopul tău își păstrează pe disc pachetele, instrumentele, layerele Docker și rezultatele buildului și are de obicei 8 nuclee sau mai multe. Un job pe ubuntu-latest dintr-un repository privat primește 2 CPU și 8 GB, pe un VM nou care nu are nimic din toate acestea. Skipbox funcționează ca laptopul tău: mașina rămâne între joburi, cu 4 vCPU sau mai mult.

### Împărțirea testelor în sharduri face GitHub Actions mai rapid?

Scurtează timpul real, nu minutele. Fiecare shard e un job nou care face din nou checkout, instalare și build, așa că patru sharduri plătesc setup-ul de patru ori, iar facturarea la minut le numără pe fiecare. Împarte în sharduri după ce setup-ul e ieftin și nucleele runnerului sunt folosite. Pe Skipbox, setup-ul rămâne pe disc, iar minutele sunt nelimitate, așa că shardurile nu costă nimic în plus.

### Cum obțin mai mult de 4 nuclee pentru un job GitHub Actions?

Pe GitHub, runnerele mari au între 4 și 96 de nuclee, doar pentru organizațiile pe GitHub Team sau Enterprise Cloud, facturate la minut. Pe Skipbox, schimbă runs-on în skipbox-8x16 pentru 8 vCPU sau skipbox-16x32 pentru 16 vCPU, la un preț lunar fix, atât pe organizații, cât și pe conturi personale.

### Cât costă să încerc?

Nimic. Perioada de probă durează 7 zile sau 3.000 de minute de job, oricare se termină mai întâi, fără card. Schimbă runs-on al celui mai lent job în skipbox, rulează-l de două ori și compară duratele pașilor.

Actualizat pe 2026-11-13 · https://skipbox.dev/ro/guides/speed-up-github-actions
