Megosztás a következőn keresztül:

Folyamat gyorsítótárazása

  • Cikk

Azure DevOps Services

A folyamat gyorsítótárazása segíthet csökkenteni a létrehozási időt azáltal, hogy lehetővé teszi, hogy az egy futtatás kimenetei vagy letöltött függőségei újra felhasználhatók legyenek a későbbi futtatásokban, ezáltal csökkentve vagy elkerülve ugyanazon fájlok újbóli létrehozását vagy újbóli letöltését. A gyorsítótárazás különösen akkor hasznos, ha ugyanazokat a függőségeket minden futtatás elején újra és újra letölti a rendszer. Ez gyakran több száz vagy több ezer hálózati hívással járó időigényes folyamat.

A gyorsítótárazás hatékonyan javíthatja a buildelési időt, feltéve, hogy a gyorsítótár visszaállítására és mentésére kevesebb idő áll rendelkezésre, mint a kimenet nulláról történő ismételt előállításának ideje. Emiatt előfordulhat, hogy a gyorsítótárazás nem minden esetben hatékony, és negatív hatással lehet a létrehozási időre.

A gyorsítótárazás jelenleg a CI és az üzembe helyezési feladatokban támogatott, a klasszikus kiadási feladatokban azonban nem.

Mikor érdemes összetevőket használni a gyorsítótárazással szemben?

A folyamat gyorsítótárazása és a folyamatösszetevők hasonló funkciókat végeznek, de különböző forgatókönyvekhez vannak kialakítva, és nem használhatók fel felcserélhetően.

  • Folyamatösszetevőket akkor használjon, ha egy feladatban létrehozott adott fájlokat kell felvennie, és meg kell osztania őket más feladatokkal (és ezek a feladatok valószínűleg nélkülük meghiúsulnak).

  • Akkor használja a folyamat gyorsítótárazását , ha javítani szeretné a buildelési időt a korábbi futtatásokból származó fájlok újrafelhasználásával (és ha ezek a fájlok nem rendelkeznek ilyen fájlokkal, az nem befolyásolja a feladat futtatási képességét).

Feljegyzés

A folyamat gyorsítótárazása és a folyamatösszetevők minden szinten ingyenesek (ingyenesek és fizetősek). további részletekért lásd : Artifacts storage consumption .

Gyorsítótár-feladat: hogyan működik

A gyorsítótár-feladat használatával a gyorsítótár-feladat hozzáadja a gyorsítótárazást egy folyamathoz. Ez a tevékenység minden más tevékenységhez hasonlóan működik, és a feladat szakaszához lesz hozzáadva steps .

Ha egy futtatás során gyorsítótár-lépés történik, a feladat a megadott bemenetek alapján visszaállítja a gyorsítótárat. Ha nem található gyorsítótár, a lépés befejeződik, és a feladat következő lépése fut.

Miután a feladat összes lépése lefutott, és a feladat sikeres állapotát feltételezte, a rendszer automatikusan hozzáad egy speciális "Post-job: Cache" lépést, és aktiválódik minden olyan "visszaállítási gyorsítótár" lépéshez, amely nem lett kihagyva. Ez a lépés a gyorsítótár mentéséért felelős.

Feljegyzés

A gyorsítótárak nem módosíthatók, ami azt jelenti, hogy a gyorsítótár létrehozása után a gyorsítótár tartalma nem módosítható.

A Gyorsítótár-feladat konfigurálása

A Gyorsítótár feladatnak két kötelező argumentuma van: kulcs és elérési út:

  • elérési út: a gyorsítótárba helyezendő mappa elérési útja. Lehet abszolút vagy relatív elérési út. A relatív elérési utakat a rendszer feloldja $(System.DefaultWorkingDirectory).

Feljegyzés

Előre definiált változókkal tárolhatja a gyorsítótárazni kívánt mappa elérési útját, a helyettesítő karakterek azonban nem támogatottak.

  • kulcs: a visszaállítani vagy menteni kívánt gyorsítótár azonosítójára kell állítani. A kulcsok sztringértékek, fájlelérési utak vagy fájlminták kombinációjából állnak, ahol az egyes szegmenseket egy | karakter választja el egymástól.

  • Sztringek:
    Rögzített érték (például a gyorsítótár vagy az eszköz neve) vagy környezeti változóból vett érték (például az aktuális operációs rendszer vagy az aktuális feladat neve)

  • Fájl elérési útjai:
    Egy adott fájl elérési útja, amelynek tartalma kivonatos lesz. Ennek a fájlnak a feladat futtatásakor kell léteznie. Ne feledje, hogy minden olyan kulcsszegmens, amely "fájlelérési útnak néz ki", fájlelérési útvonalként lesz kezelve. Ez különösen azokat a szegmenseket foglalja magában, amelyek egy .. Ez azt eredményezheti, hogy a feladat meghiúsul, ha ez a "fájl" nem létezik.

    Tipp.

    Ha el szeretné kerülni, hogy egy elérésiút-szerű sztringszakasz fájlelérési útvonalként legyen kezelve, csomagolja be dupla idézőjelekkel, például: "my.key" | $(Agent.OS) | key.file

  • Fájlminták:
    Vesszővel tagolt lista a glob stílusú helyettesítő karakterekről, amelyeknek legalább egy fájlnak meg kell egyeznie. Példa:

    • **/yarn.lock: az összes yarn.lock fájl a forráskönyvtár alatt
    • */asset.json, !bin/**: az összes asset.json fájl, amely a forráskönyvtár alatt található egy könyvtárban, kivéve a bin könyvtárat

A fájl elérési útja vagy a fájlminta által azonosított fájlok tartalma kivonatolt, hogy dinamikus gyorsítótárkulcsot állítsunk elő. Ez akkor hasznos, ha a projekt olyan fájl(ok) használatával rendelkezik, amelyek egyedileg azonosítják a gyorsítótárazott fájlt. Például a gyorsítótárkulcsban gyakran hivatkoznak az olyan fájlokra, mint package-lock.jsona , yarn.lockvagy Gemfile.lockPipfile.lock általában hivatkoznak rájuk, mivel ezek mindegyike függőségek egyedi készletét képviseli.

A relatív fájlelérési utak vagy fájlminták feloldása a következőre $(System.DefaultWorkingDirectory)van feloldva: .

Példa:

Íme egy példa a Yarn által telepített függőségek gyorsítótárazására:

variables:
  YARN_CACHE_FOLDER: $(Pipeline.Workspace)/s/.yarn

steps:
- task: Cache@2
  inputs:
    key: '"yarn" | "$(Agent.OS)" | yarn.lock'
    restoreKeys: |
       "yarn" | "$(Agent.OS)"
       "yarn"
    path: $(YARN_CACHE_FOLDER)
  displayName: Cache Yarn packages

- script: yarn --frozen-lockfile

Ebben a példában a gyorsítótárkulcs három részből áll: egy statikus sztringből ("yarn"), a feladat által futtatott operációs rendszerből, mivel ez a gyorsítótár operációs rendszerenként egyedi, és a yarn.lock fájl kivonata, amely egyedileg azonosítja a gyorsítótár függőségeinek készletét.

A feladat hozzáadása utáni első futtatáskor a gyorsítótár-lépés "gyorsítótár-hiányt" jelent, mivel a kulcs által azonosított gyorsítótár nem létezik. Az utolsó lépés után a rendszer létrehoz egy gyorsítótárat a benne lévő $(Pipeline.Workspace)/s/.yarn és feltöltött fájlokból. A következő futtatáskor a gyorsítótár lépése "gyorsítótár-találatot" jelent, és a gyorsítótár tartalma le lesz töltve és visszaállítva.

A használat során checkout: selfaz adattár ki van véve $(Pipeline.Workspace)/s, és a .yarn mappa általában magában az adattárban található.

Feljegyzés

Pipeline.Workspace a folyamatot futtató ügynök helyi elérési útja, ahol az összes címtár létrejön. Ez a változó ugyanazzal az értékkel rendelkezik, mint a Agent.BuildDirectory.

Győződjön meg arról, hogy frissíti a változót YARN_CACHE_FOLDER , ha nem checkout: self ezt használja, mivel ennek arra az adattárra kell mutatnia, ahol .yarn a tárház található.

Kulcsok visszaállítása

restoreKeys akkor használható, ha több pontos kulcs vagy kulcselőtag alapján szeretne lekérdezni. Ez arra szolgál, hogy visszaessen egy másik kulcsra abban az esetben, ha egy key nem eredményez találatot. A visszaállítási kulcs előtaggal keres egy kulcsot, és ennek eredményeként a legújabb gyorsítótár-bejegyzést hozza létre. Ez akkor hasznos, ha a folyamat nem talál pontos egyezést, de inkább részleges gyorsítótár-találatot szeretne használni. Több visszaállítási kulcs beszúrásához egyszerűen tagolja őket egy új sor használatával a visszaállítási kulcs jelzéséhez (további részletekért lásd a példát). A visszaállítási kulcsok kipróbálásának sorrendje felülről lefelé halad.

Szükséges szoftver a saját üzemeltetésű ügynökön

Szoftver archiválása / platform Windows Linux Mac
GNU Tar Szükséges Szükséges Nem
BSD Tar Nem Nem Szükséges
7-Zip Ajánlott Nem Nem

A fenti végrehajtható fájloknak a PATH környezeti változóban felsorolt mappában kell lenniük. Ne feledje, hogy a üzemeltetett ügynökök tartalmazzák a szoftvereket, ez csak a saját üzemeltetésű ügynökökre vonatkozik.

Példa:

Íme egy példa a visszaállítási kulcsok Yarn általi használatára:

variables:
  YARN_CACHE_FOLDER: $(Pipeline.Workspace)/.yarn

steps:
- task: Cache@2
  inputs:
    key: '"yarn" | "$(Agent.OS)" | yarn.lock'
    restoreKeys: |
       yarn | "$(Agent.OS)"
       yarn
    path: $(YARN_CACHE_FOLDER)
  displayName: Cache Yarn packages

- script: yarn --frozen-lockfile

Ebben a példában a gyorsítótár-feladat megpróbálja megtalálni, hogy a kulcs megtalálható-e a gyorsítótárban. Ha a kulcs nem létezik a gyorsítótárban, megpróbálja használni az első visszaállítási kulcsot yarn | $(Agent.OS). Ez megkísérli megkeresni az összes olyan kulcsot, amely pontosan egyezik az adott kulccsal, vagy előtagként szerepel a kulcsban. Előtag-találat akkor fordulhat elő, ha más yarn.lock kivonatszegmens volt. Ha például a következő kulcs yarn | $(Agent.OS) | old-yarn.lock a gyorsítótárban volt, ahol a old-yarn.lock kivonat más kivonatot eredményezett, mint yarn.locka visszaállítási kulcs, részleges találatot eredményez. Ha hiányzik az első visszaállítási kulcs, akkor a következő visszaállítási kulcsot yarn fogja használni, amely megpróbálja megtalálni a kezdőkulcsot yarn. Az előtag-találatok esetében az eredmény a legutóbb létrehozott gyorsítótárkulcsot eredményezi.

Feljegyzés

Egy folyamat rendelkezhet egy vagy több gyorsítótárazási tevékenységgel. Nincs korlátozva a gyorsítótárazási kapacitás, és az ugyanabból a folyamatból származó feladatok és feladatok elérhetik és megoszthatják ugyanazt a gyorsítótárat.

Gyorsítótár elkülönítése és biztonsága

A különböző folyamatokból és ágakból származó gyorsítótárak elkülönítésének biztosítása érdekében minden gyorsítótár egy hatókörnek nevezett logikai tárolóhoz tartozik. A hatókörök olyan biztonsági határt biztosítanak, amely biztosítja, hogy az egyik folyamatból származó feladatok ne férhessenek hozzá a gyorsítótárakhoz egy másik folyamatból, és a lekérdezést létrehozó feladat olvasási hozzáféréssel rendelkezik a lekéréses kérelem célágának gyorsítótáraihoz (ugyanahhoz a folyamathoz), de nem tud gyorsítótárakat írni (létrehozni) a célág hatókörében.

Amikor egy futtatás során gyorsítótár-lépés történik, a rendszer a kulcs által azonosított gyorsítótárat kéri a kiszolgálótól. A kiszolgáló ezután megkeresi a feladat számára látható hatókörökből ezt a kulcsot tartalmazó gyorsítótárat, és visszaadja a gyorsítótárat (ha van ilyen). A gyorsítótár mentésekor (a feladat végén) a rendszer a gyorsítótárat a folyamat és az ág hatókörébe írja. További részleteket alább talál.

CI-, manuális és ütemezett futtatások

Hatókör Olvasás Írás
Forráság Igen Igen
főág (alapértelmezett ág) Igen Nem

Lekéréses kérelmek futtatása

Hatókör Olvasás Írás
Forráság Igen Nem
Célág Igen Nem
Köztes ág (például refs/pull/1/merge) Igen Igen
főág (alapértelmezett ág) Igen Nem

Lekéréses kérelem elágazásai

Ág Olvasás Írás
Célág Igen Nem
Köztes ág (például refs/pull/1/merge) Igen Igen
főág (alapértelmezett ág) Igen Nem

Tipp.

Mivel a gyorsítótárak már hatókörrel vannak elosztva egy projektre, folyamatra és ágra, a gyorsítótárkulcsban nincs szükség projekt-, folyamat- vagy ágazonosítókra.

A gyorsítótár helyreállításának kondicionálása

Bizonyos esetekben a gyorsítótár sikeres visszaállításának más lépések futtatását kell eredményeznie. A függőségeket telepítő lépés például kihagyható, ha a gyorsítótárat visszaállították. Ez a cacheHitVar tevékenységbemenettel lehetséges. Ha ezt a bemenetet egy környezeti változó nevére állítja, akkor a változó gyorsítótár-találat inexact esetén a visszaállítási kulcs gyorsítótárának találatára lesz beállítva true false, ellenkező esetben a beállítás értéke . Ezt a változót ezután egy lépésfeltételben vagy egy szkriptben lehet hivatkozni.

A következő példában a rendszer kihagyja a install-deps.sh lépést a gyorsítótár visszaállításakor:

steps:
- task: Cache@2
  inputs:
    key: mykey | mylockfile
    restoreKeys: mykey
    path: $(Pipeline.Workspace)/mycache
    cacheHitVar: CACHE_RESTORED

- script: install-deps.sh
  condition: ne(variables.CACHE_RESTORED, 'true')

- script: build.sh

Bundler

A Bundlert használó Ruby-projekteknél felülbírálja a BUNDLE_PATH Bundler által használt környezeti változót annak az elérési útnak a beállításához, amelyben a Bundler gemeket keres.

Példa:

variables:
  BUNDLE_PATH: $(Pipeline.Workspace)/.bundle

steps:
- task: Cache@2
  displayName: Bundler caching
  inputs:
    key: 'gems | "$(Agent.OS)" | Gemfile.lock'
    path: $(BUNDLE_PATH)
    restoreKeys: | 
      gems | "$(Agent.OS)"
      gems

Ccache (C/C++)

A Ccache a C/C++ fordítói gyorsítótára. Ha a Ccache-t szeretné használni a folyamatban, győződjön meg arról, hogy Ccache telepítve van, és opcionálisan hozzáadja az Önhöz PATH (lásd : Ccache-futtatási módok). Állítsa be a CCACHE_DIR környezeti változót egy elérési útra $(Pipeline.Workspace) , és gyorsítótárazza ezt a könyvtárat.

Példa:

variables:
  CCACHE_DIR: $(Pipeline.Workspace)/ccache

steps:
- bash: |
    sudo apt-get install ccache -y    
    echo "##vso[task.prependpath]/usr/lib/ccache"
  displayName: Install ccache and update PATH to use linked versions of gcc, cc, etc

- task: Cache@2
  displayName: Ccache caching
  inputs:
    key: 'ccache | "$(Agent.OS)" | $(Build.SourceVersion)'
    path: $(CCACHE_DIR)
    restoreKeys: | 
      ccache | "$(Agent.OS)"

További részletekért tekintse meg a Ccache konfigurációs beállításait .

Docker-képek

A Docker-képek gyorsítótárazása jelentősen csökkenti a folyamat futtatásához szükséges időt.

variables:
  repository: 'myDockerImage'
  dockerfilePath: '$(Build.SourcesDirectory)/app/Dockerfile'
  tag: '$(Build.BuildId)'

pool:
  vmImage: 'ubuntu-latest'
steps:
  - task: Cache@2
    displayName: Cache task
    inputs:
      key: 'docker | "$(Agent.OS)" | cache'
      path: $(Pipeline.Workspace)/docker
      cacheHitVar: CACHE_RESTORED                #Variable to set to 'true' when the cache is restored
    
  - script: |
      docker load -i $(Pipeline.Workspace)/docker/cache.tar
    displayName: Docker restore
    condition: and(not(canceled()), eq(variables.CACHE_RESTORED, 'true'))

  - task: Docker@2
    displayName: 'Build Docker'
    inputs:
      command: 'build'
      repository: '$(repository)'
      dockerfile: '$(dockerfilePath)'
      tags: |
        '$(tag)'

  - script: |
      mkdir -p $(Pipeline.Workspace)/docker
      docker save -o $(Pipeline.Workspace)/docker/cache.tar $(repository):$(tag)
    displayName: Docker save
    condition: and(not(canceled()), not(failed()), ne(variables.CACHE_RESTORED, 'true'))
  • kulcs: (kötelező) – a gyorsítótár egyedi azonosítója.
  • elérési út: (kötelező) – a gyorsítótárazni kívánt mappa vagy fájl elérési útja.

Golang

Golang-projektek esetén megadhatja a go.mod fájlban letöltendő csomagokat. Ha a GOCACHE változó még nincs beállítva, állítsa be oda, ahová a gyorsítótárat le szeretné tölteni.

Példa:

variables:
  GO_CACHE_DIR: $(Pipeline.Workspace)/.cache/go-build/

steps:
- task: Cache@2
  inputs:
    key: 'go | "$(Agent.OS)" | go.mod'
    restoreKeys: | 
      go | "$(Agent.OS)"
    path: $(GO_CACHE_DIR)
  displayName: Cache GO packages

Gradle

A Gradle beépített gyorsítótárazási támogatásának használata jelentős hatással lehet a buildelési időre. A buildgyorsítótár engedélyezéséhez állítsa a GRADLE_USER_HOME környezeti változót egy elérési útra$(Pipeline.Workspace), és futtassa a buildet a fájllal--build-cache, vagy adja hozzáorg.gradle.caching=true.gradle.properties

Példa:

variables:
  GRADLE_USER_HOME: $(Pipeline.Workspace)/.gradle

steps:
- task: Cache@2
  inputs:
    key: 'gradle | "$(Agent.OS)" | **/build.gradle.kts' # Swap build.gradle.kts for build.gradle when using Groovy
    restoreKeys: |
      gradle | "$(Agent.OS)"
      gradle
    path: $(GRADLE_USER_HOME)
  displayName: Configure gradle caching

- task: Gradle@2
  inputs:
    gradleWrapperFile: 'gradlew'
    tasks: 'build'
    options: '--build-cache'
  displayName: Build

- script: |   
    # stop the Gradle daemon to ensure no files are left open (impacting the save cache operation later)
    ./gradlew --stop    
  displayName: Gradlew stop
  • restoreKeys: A tartalék kulcsok, ha az elsődleges kulcs meghibásodik (nem kötelező)

Feljegyzés

A gyorsítótárak nem módosíthatók, ha létrejön egy adott kulccsal rendelkező gyorsítótár egy adott hatókörhöz (ághoz), a gyorsítótár nem frissíthető. Ez azt jelenti, hogy ha a kulcs rögzített érték, az ugyanazon ághoz tartozó összes későbbi build nem fogja tudni frissíteni a gyorsítótárat, még akkor sem, ha a gyorsítótár tartalma módosult. Ha rögzített kulcsértéket szeretne használni, az restoreKeys argumentumot tartalék beállításként kell használnia.

Maven

A Maven rendelkezik egy helyi adattárral, ahol letöltéseket és beépített összetevőket tárol. Az engedélyezéshez állítsa be a maven.repo.local beállítást egy elérési útra $(Pipeline.Workspace) , és gyorsítótárazza ezt a mappát.

Példa:

variables:
  MAVEN_CACHE_FOLDER: $(Pipeline.Workspace)/.m2/repository
  MAVEN_OPTS: '-Dmaven.repo.local=$(MAVEN_CACHE_FOLDER)'

steps:
- task: Cache@2
  inputs:
    key: 'maven | "$(Agent.OS)" | **/pom.xml'
    restoreKeys: |
      maven | "$(Agent.OS)"
      maven
    path: $(MAVEN_CACHE_FOLDER)
  displayName: Cache Maven local repo

- script: mvn install -B -e

Ha Maven-feladatot használ, győződjön meg arról, hogy a MAVEN_OPTS változót is át kell adnia, mert az máskülönben felülíródik:

- task: Maven@4
  inputs:
    mavenPomFile: 'pom.xml'
    mavenOptions: '-Xmx3072m $(MAVEN_OPTS)'

.NET/NuGet

Ha a NuGet-függőségeket közvetlenül a projektfájlban kezeli PackageReferences , és rendelkezik egy packages.lock.json fájllal, engedélyezheti a gyorsítótárazást úgy, hogy a NUGET_PACKAGES környezeti változót egy elérési útra állítja a könyvtár alatt $(UserProfile) , és gyorsítótárazhatja azt. A függőségek zárolásáról további információt a projektfájlok csomaghivatkozásában talál. Ha több packages.lock.json szeretne használni, akkor is használhatja az alábbi példát módosítás nélkül. Az összes packages.lock.json fájl tartalma kivonatos lesz, és ha az egyik fájl módosul, létrejön egy új gyorsítótárkulcs.

Példa:

variables:
  NUGET_PACKAGES: $(Pipeline.Workspace)/.nuget/packages

steps:
- task: Cache@2
  inputs:
    key: 'nuget | "$(Agent.OS)" | $(Build.SourcesDirectory)/**/packages.lock.json'
    restoreKeys: |
       nuget | "$(Agent.OS)"
       nuget
    path: $(NUGET_PACKAGES)
  displayName: Cache NuGet packages

Node.js/npm

Különböző módokon engedélyezheti a gyorsítótárazást egy Node.js projektben, de az ajánlott módszer az npm megosztott gyorsítótár-könyvtárának gyorsítótárazása. Ezt a könyvtárat az npm felügyeli, és az összes letöltött modul gyorsítótárazott verzióját tartalmazza. A telepítés során az npm először (alapértelmezés szerint) ellenőrzi ezt a könyvtárat olyan modulok esetében, amelyek csökkenthetik vagy megszüntethetik a nyilvános npm-beállításjegyzékbe vagy egy magánregisztrációs adatbázisba irányuló hálózati hívásokat.

Mivel az npm megosztott gyorsítótár könyvtárának alapértelmezett elérési útja nem azonos minden platformon, javasoljuk, hogy felülbírálja a npm_config_cache környezeti változót a következő $(Pipeline.Workspace)elérési útra: . Ez azt is biztosítja, hogy a gyorsítótár elérhető legyen tároló- és nem tárolófeladatokból.

Példa:

variables:
  npm_config_cache: $(Pipeline.Workspace)/.npm

steps:
- task: Cache@2
  inputs:
    key: 'npm | "$(Agent.OS)" | package-lock.json'
    restoreKeys: |
       npm | "$(Agent.OS)"
    path: $(npm_config_cache)
  displayName: Cache npm

- script: npm ci

Ha a projekt nem rendelkezik fájllal package-lock.json , hivatkozzon inkább a package.json gyorsítótárkulcs bemenetében lévő fájlra.

Tipp.

Mivel npm ci a node_modules mappa törlése biztosítja, hogy a modulok egységes, megismételhető készlete legyen használatban, a híváskor npm cine gyorsítótárazhassonnode_modules.

Node.js/Yarn

Az npm-hez hasonlóan a Yarnban telepített csomagok gyorsítótárazásának különböző módjai is vannak. Az ajánlott módszer a Yarn megosztott gyorsítótármappájának gyorsítótárazása. Ezt a könyvtárat a Yarn kezeli, és az összes letöltött csomag gyorsítótárazott verzióját tartalmazza. A telepítés során a Yarn először (alapértelmezés szerint) ellenőrzi ezt a könyvtárat a moduloknál, ami csökkentheti vagy kiküszöbölheti a nyilvános vagy magánregisztrációs adatbázisokba irányuló hálózati hívásokat.

Példa:

variables:
  YARN_CACHE_FOLDER: $(Pipeline.Workspace)/.yarn

steps:
- task: Cache@2
  inputs:
    key: 'yarn | "$(Agent.OS)" | yarn.lock'
    restoreKeys: |
       yarn | "$(Agent.OS)"
       yarn
    path: $(YARN_CACHE_FOLDER)
  displayName: Cache Yarn packages

- script: yarn --frozen-lockfile

Python/Anaconda

A folyamat gyorsítótárazásának beállítása Anaconda-környezetekkel:

Példa

variables:
  CONDA_CACHE_DIR: /usr/share/miniconda/envs

# Add conda to system path
steps:
- script: echo "##vso[task.prependpath]$CONDA/bin"
  displayName: Add conda to PATH

- bash: |
    sudo chown -R $(whoami):$(id -ng) $(CONDA_CACHE_DIR)
  displayName: Fix CONDA_CACHE_DIR directory permissions

- task: Cache@2
  displayName: Use cached Anaconda environment
  inputs:
    key: 'conda | "$(Agent.OS)" | environment.yml'
    restoreKeys: | 
      python | "$(Agent.OS)"
      python
    path: $(CONDA_CACHE_DIR)
    cacheHitVar: CONDA_CACHE_RESTORED

- script: conda env create --quiet --file environment.yml
  displayName: Create Anaconda environment
  condition: eq(variables.CONDA_CACHE_RESTORED, 'false')

  • Windows

    - task: Cache@2
  displayName: Cache Anaconda
  inputs:
    key: 'conda | "$(Agent.OS)" | environment.yml'
    restoreKeys: | 
      python | "$(Agent.OS)"
      python
    path: $(CONDA)/envs
    cacheHitVar: CONDA_CACHE_RESTORED

- script: conda env create --quiet --file environment.yml
  displayName: Create environment
  condition: eq(variables.CONDA_CACHE_RESTORED, 'false')

PHP/Composer

A Composert használó PHP-projektek esetében felül kell bírálni a COMPOSER_CACHE_DIR Composer által használt környezeti változót .

Példa:

variables:
  COMPOSER_CACHE_DIR: $(Pipeline.Workspace)/.composer

steps:
- task: Cache@2
  inputs:
    key: 'composer | "$(Agent.OS)" | composer.lock'
    restoreKeys: |
      composer | "$(Agent.OS)"
      composer
    path: $(COMPOSER_CACHE_DIR)
  displayName: Cache composer

- script: composer install

Ismert problémák és visszajelzés

Ha problémákat tapasztal a folyamat gyorsítótárazásának beállításával kapcsolatban, ellenőrizze a tárházban található nyitott problémák microsoft/azure-pipelines-tasks listáját. Ha a problémája nem szerepel a listán hozzon létre egy újat, és adja meg a szükséges információkat a forgatókönyvéről.

Q&A

K: Törölhetem a gyorsítótárat?

V: A gyorsítótár törlése jelenleg nem támogatott. A meglévő gyorsítótárkulcshoz azonban sztringkonstanst (például version2) is hozzáadhat, hogy a kulcs úgy módosuljon, hogy a meglévő gyorsítótárakon ne legyen találat. Módosítsa például a következő gyorsítótárkulcsot:

key: 'yarn | "$(Agent.OS)" | yarn.lock'

módosítsa a következőre:

key: 'version2 | yarn | "$(Agent.OS)" | yarn.lock'

K: Mikor jár le a gyorsítótár?

V: A gyorsítótárak hét napnyi tevékenység nélkül lejárnak.

K: Mikor lesz feltöltve a gyorsítótár?

V: A folyamat utolsó lépése után létrejön egy gyorsítótár a gyorsítótárból path , és fel lesz töltve. További részletekért lásd a példát .

K: Van-e korlátozás a gyorsítótár méretére?

V: Nincs kényszerített korlát az egyes gyorsítótárak méretére vagy a szervezet összes gyorsítótárának teljes méretére vonatkozóan.