GitHub Actions cache · artefakter · Turborepo

Din CI-cache, i ditt eget Cloudflare-konto

Vanliga actions/cache och upload-artifact cachar genom CacheFlow utan ändringar i arbetsflödena, och Turborepo med ett enda installationssteg. Lägg till en policy för betrodda konsumenter, så återställer dina releasejobb bara det som ett betrott bygge har producerat.

En cache som du äger, litar på och kan se in i

Äg den

Ditt konto, dina bytes

CacheFlow körs i ditt Cloudflare-konto, så cache- och artefaktbytes hamnar aldrig hos en tredje part och resurserna syns på din egen Cloudflare-faktura.

  • Artefaktbytes i R2, utan avgifter för utgående trafik
  • Nyckelägarskap i D1, en snabb läsväg i KV, pågående sessioner i Durable Objects
  • En och samma driftsättning betjänar Actions cache, Actions-artefakter och Turborepos fjärrcache

Lita på den

Återställ bara det som ett betrott bygge har sparat

Poster som sparas med en GitHub OIDC-token, som CacheFlow-actions gör, registrerar händelsen, ref, commit och arbetsflödet bakom dem. Lägg till en policy för betrodda konsumenter, så återställer dina releasejobb bara poster som en push, en schemalagd eller en manuell körning har sparat på din skyddade gren.

  • Bara kortlivade autentiseringsuppgifter: GitHub OIDC för CacheFlow-actions, GitHubs egen körtidstoken för drop-in-jobb
  • Varje gren skriver bara till sitt eget scope och läser via sin basgren och standardgrenen
  • På OIDC-jobb sätts sparningar på en skyddad gren från händelser som utomstående kan utlösa, som pull_request_target, i karantän; drop-in-jobb följer GitHubs egen cachebehörighet

Se den

Ha koll på din träffgrad

Varje återställning, miss och sparning i Actions cache och artefakter registreras med sina bytes, liksom nedladdningar och uppladdningar i Turborepo, inklusive om en återställning matchade exakt nyckel eller föll tillbaka på ett prefix.

  • Nycklar i Actions cache och artefaktnamn registreras bara som en nyckelad hash, aldrig som de skrevs
  • Sessioner buffrar skrivningar från parallella matrisjobb och committar dem atomärt
  • Inaktuella sessioner rensas när byggen avslutas eller löper ut

Börja där du redan är

Fyra vägar in, från noll ändringar till full kontroll. De flesta team börjar med den första och behöver aldrig röra ett arbetsflöde.

  1. Noll ändringar

    Behåll arbetsflödena du redan har

    Peka dina runners mot CacheFlow en gång. Vanliga actions/cache, setup-node, Swatinem/rust-cache och upload-artifact cachar sedan genom den, helt orörda. På GitHub-hostade runners faller samma arbetsflöde tillbaka på GitHubs cache.

    # runner environment: set once, per runner pool
    ACTIONS_RESULTS_URL=https://cache.cacheflow.sh/
    
    # your workflows: unchanged
    - uses: actions/cache@v4
    - uses: Swatinem/rust-cache@v2
    - uses: actions/upload-artifact@v4
  2. Ett steg

    Sluta bygga om det Turborepo redan har byggt

    Lägg till setup-cacheflow så spelar varje uppgift vars indata inte har ändrats upp sina utdata i stället för att köras igen, över jobb, grenar och repon.

    Se hela arbetsflödet ↓
  3. Releaseklassad

    Leverera bara det en betrodd build har producerat

    Spara release- och deploy-cacher via CacheFlow-actions. Varje post registrerar händelsen, ref, commit och arbetsflödet bakom den. Lägg till en policy för betrodda konsumenter, så återställer dina releasejobb bara poster som en push, en schemalagd eller en manuell körning har sparat på din skyddade gren.

    # the job needs permissions: { contents: read, id-token: write }
    - uses: CaptainEmpower/cacheflow/.github/actions/cache/save@v1
      with:
        path: dist
        key: release-${{ github.sha }}
        cache-url: ${{ vars.CACHEFLOW_CACHE_URL }}
    
    # Rust: the rust-cache fork, same attestation
    - uses: CaptainEmpower/rust-cache@v2-cacheflow
      with:
        cache-provider: cacheflow
  4. Valfritt verktyg

    Cacha vad som helst från kommandoraden

    cacheflow CLI och Python SDK lagrar och återställer valfri artefakt från valfritt byggverktyg. Sessioner buffrar skrivningar från parallella matrisjobb och committar dem atomärt, så att inget jobb skriver över ett annat.

    # In a GitHub Actions step after setup-cacheflow, which exports
    # CACHEFLOW_CACHE_URL, CACHEFLOW_TOKEN, CACHEFLOW_TENANT,
    # CACHEFLOW_REPOSITORY and CACHEFLOW_BRANCH (export them yourself
    # elsewhere). GITHUB_SHA is set by Actions.
    cacheflow cache namespace ci-build   # idempotent
    SESSION=$(cacheflow session start --namespace ci-build)
    cacheflow cache put ci-build "dist-$GITHUB_SHA" dist.tar.gz \
      --session "$SESSION"
    cacheflow session commit --namespace ci-build \
      --session "$SESSION" --status success
    cacheflow cache get ci-build "dist-$GITHUB_SHA" --out dist.tar.gz

Turborepo-fjärrcache i ett enda steg

setup-cacheflow utfärdar en kortlivad OIDC-autentiseringsuppgift och exporterar TURBO_API, TURBO_TOKEN och TURBO_TEAM. Inga lagrade hemligheter:

permissions:
  contents: read
  id-token: write

jobs:
  build:
    runs-on: ${{ vars.CI_RUNNER_LARGE || vars.CI_RUNNER_DEFAULT }}
    steps:
      - uses: actions/checkout@v4
      # exports TURBO_API, TURBO_TOKEN and TURBO_TEAM
      - uses: CaptainEmpower/cacheflow/.github/actions/setup-cacheflow@v1
        with:
          api-url: ${{ vars.CACHEFLOW_TURBO_API }}
          install-cli: 'false'
      - run: pnpm install --frozen-lockfile
      - run: pnpm turbo run build

Frågor som team ställer först

Måste vi ändra våra arbetsflöden?
Inte för Actions cache och artefakter. Peka miljön för dina runners mot CacheFlow en gång, så använder vanliga actions/cache, setup-node, Swatinem/rust-cache och upload-artifact den utan ändringar. På GitHub-hostade runners fortsätter samma arbetsflöden att använda GitHubs cache. Turborepos fjärrcache kräver ett setup-cacheflow-steg per arbetsflöde.
Var lagras vår data?
I ditt Cloudflare-konto: bytes i R2, nyckelägarskap i D1, en läsväg i KV och pågående sessioner i Durable Objects. Telemetrin registrerar nycklar i Actions cache och artefaktnamn bara som en nyckelad hash. Vi planerar också en hanterad plan som CacheFlow driver åt dig.
Vad kostar det?
De Cloudflare-resurser som CacheFlow använder faktureras ditt eget Cloudflare-konto, och R2 tar inga avgifter för utgående trafik. Vi delar prissättningen för själva CacheFlow med team som får tidig åtkomst.
Är det snabbare än GitHubs cache?
Vi gör inga påståenden om hastighet. Bytes hämtas från Cloudflare R2 över internet, och vi har inte mätt någon fördel i återställningshastighet. Om du behöver en cache bredvid din runner kan en runner-leverantörs cache passa dig bättre.
Hur autentiserar sig jobben?
Jobb som använder CacheFlow-actions eller setup-cacheflow växlar in en kortlivad GitHub OIDC-token. Drop-in-jobb med vanliga actions använder den körtidstoken som GitHub redan ger varje jobb. I båda fallen lagras ingen långlivad hemlighet i dina pipelines. Andra CI-system och utvecklares laptops använder en token som utfärdas av din operatör.
Kan vi byta tillbaka?
Ja. CacheFlow talar de protokoll som dina verktyg redan använder: Actions cache- och artefakttjänsterna samt Turborepos fjärrcache. Ta bort runner-inställningen eller setup-cacheflow-steget, så går dina arbetsflöden tillbaka till den cache de använde tidigare.

Få tidig åtkomst

Gå med på väntelistan så hör vi av oss när ditt team kan komma igång.