Mezipaměť kanálů

Služby Azure DevOps

Ukládání do mezipaměti kanálu může pomoct zkrátit dobu sestavení tím, že umožníte opětovnému použití výstupů nebo stažených závislostí z jednoho spuštění v pozdějších spuštěních. Tím se sníží nebo zabrání nákladům na opětovné vytvoření nebo opětovnému stažení stejných souborů. Ukládání do mezipaměti je užitečné zejména ve scénářích, kdy se na začátku každého spuštění stáhnou stejné závislosti. To je často časově náročný proces zahrnující stovky nebo tisíce síťových volání.

Ukládání do mezipaměti může být efektivní při vylepšení doby sestavení za předpokladu, že doba obnovení a uložení mezipaměti je kratší než doba, kdy se výstup znovu vytvoří úplně od začátku. Z tohoto důvodu nemusí být ukládání do mezipaměti efektivní ve všech scénářích a může mít ve skutečnosti negativní dopad na čas sestavení.

Poznámka:

Ukládání kanálů do mezipaměti je podporováno v úlohách fondu agentů pro kanály YAML i klasické kanály. Nepodporuje se ale v kanálech verze Classic.

Kdy použít artefakty a ukládání do mezipaměti

Ukládání kanálů do mezipaměti a artefakty kanálu provádějí podobné funkce, ale jsou navržené pro různé scénáře a neměly by se používat zaměnitelně.

• Artefakty kanálu použijte v případě, že potřebujete vzít konkrétní soubory vytvořené v jedné úloze a sdílet je s jinými úlohami (a tyto další úlohy pravděpodobně selžou bez nich).

• Ukládání kanálů do mezipaměti použijte, pokud chcete zlepšit dobu sestavení opětovným použitím souborů z předchozích spuštění (a nemáte tyto soubory vliv na schopnost úlohy spustit).

Poznámka:

Ukládání kanálů do mezipaměti a artefakty kanálu jsou bezplatné pro všechny úrovně (bezplatné a placené). Další podrobnosti najdete v tématu Využití úložiště artefaktů.

Úloha mezipaměti: jak funguje

Ukládání do mezipaměti se přidá do kanálu pomocí úlohy Mezipaměti. Tento úkol funguje stejně jako jakýkoli jiný úkol a je přidán do steps oddílu úlohy.

Když během spuštění dojde ke kroku mezipaměti, úloha obnoví mezipaměť na základě zadaných vstupů. Pokud se nenajde žádná mezipaměť, krok se dokončí a spustí se další krok v úloze.

Po spuštění všech kroků v úloze a za předpokladu úspěšného stavu úlohy se automaticky přidá speciální krok "Post-job: Cache" a aktivuje se pro každý krok obnovení mezipaměti, který nebyl vynechán. Tento krok zodpovídá za ukládání mezipaměti.

Poznámka:

Mezipaměti jsou neměnné, což znamená, že po vytvoření mezipaměti nelze jeho obsah změnit.

Konfigurace úlohy mezipaměti

Úloha mezipaměti má dva požadované argumenty: klíč a cestu:

• path: cesta ke složce, do které se má ukládat do mezipaměti. Může to být absolutní nebo relativní cesta. Relativní cesty jsou vyřešeny proti $(System.DefaultWorkingDirectory).

Poznámka:

Předdefinované proměnné můžete použít k uložení cesty ke složce, kterou chcete uložit do mezipaměti, ale zástupné cardy se nepodporují.

• klíč: měl by být nastaven na identifikátor mezipaměti, kterou chcete obnovit nebo uložit. Klíče se skládají z kombinace řetězcových hodnot, cest k souborům nebo vzorů souborů, kde je každý segment oddělený znakem | .

• Řetězce:
  Pevná hodnota (například název mezipaměti nebo názvu nástroje) nebo převzatá z proměnné prostředí (například aktuální operační systém nebo název aktuální úlohy)

• Cesty k souborům:
  Cesta ke konkrétnímu souboru, jehož obsah bude hashován. Tento soubor musí existovat v době, kdy je úloha spuštěna. Mějte na paměti, že každý segment klíče, který vypadá jako cesta k souboru, se bude považovat za cestu k souboru. Zejména to zahrnuje segmenty obsahující .. To může vést k selhání úlohy v případě, že tento soubor neexistuje.

  Tip

  Pokud se chcete vyhnout tomu, aby se s segmentem řetězce podobné cesty zacházelo jako s cestou k souboru, zabalte ho dvojitými uvozovkami, například: "my.key" | $(Agent.OS) | key.file

• Vzory souborů:
  Čárkami oddělený seznam zástupných znaků ve stylu globu, který musí odpovídat alespoň jednomu souboru. Příklad:

  • **/yarn.lock: Všechny soubory yarn.lock v adresáři zdrojů
  • */asset.json, !bin/**: všechny asset.json soubory umístěné v adresáři v adresáři zdrojů s výjimkou adresáře bin

Obsah libovolného souboru identifikovaného cestou k souboru nebo vzorem souboru je hashován, aby se vytvořil klíč dynamické mezipaměti. To je užitečné, když má váš projekt soubory, které jednoznačně identifikují, co se ukládá do mezipaměti. Například soubory jako package-lock.json, , yarn.lockGemfile.locknebo Pipfile.lock jsou běžně odkazovány v klíči mezipaměti, protože všechny představují jedinečnou sadu závislostí.

Relativní cesty k souborům nebo vzory souborů jsou vyřešeny proti $(System.DefaultWorkingDirectory).

Příklad:

Tady je příklad ukazující, jak ukládat závislosti nainstalované pomocí Yarn do mezipaměti:

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

V tomto příkladu obsahuje klíč mezipaměti tři části: statický řetězec ("yarn"), operační systém, na kterém úloha běží, protože tato mezipaměť je jedinečná pro operační systém a hodnota hash yarn.lock souboru, který jednoznačně identifikuje sadu závislostí v mezipaměti.

Při prvním spuštění po přidání úlohy bude krok mezipaměti hlásit "chybějící mezipaměť", protože mezipaměť identifikovaná tímto klíčem neexistuje. Po posledním kroku se z souborů a $(Pipeline.Workspace)/s/.yarn nahraje se mezipaměť. V dalším spuštění nahlásí krok mezipaměti "přístup do mezipaměti" a obsah mezipaměti se stáhne a obnoví.

Při použití checkout: selfje úložiště rezervováno $(Pipeline.Workspace)/sa vaše .yarn složka se obvykle nachází v samotném úložišti.

Poznámka:

Pipeline.Workspace je místní cesta k agentu, na kterém běží váš kanál, kde se vytvářejí všechny adresáře. Tato proměnná má stejnou hodnotu jako Agent.BuildDirectory.

Nezapomeňte proměnnou YARN_CACHE_FOLDER aktualizovat, pokud používáte cokoli jiného, než checkout: self je toto, mělo by odkazovat na úložiště, ve kterém .yarn se nachází.

Obnovení klíčů

restoreKeys lze použít, pokud se chcete dotazovat na více přesných klíčů nebo předpon klíčů. To se používá k návratu k jinému klíči v případě, že key nepřináší hit. Obnovovací klíč vyhledá klíč podle předpony a v důsledku toho získá nejnovější vytvořenou položku mezipaměti. To je užitečné, pokud kanál nemůže najít přesnou shodu, ale místo toho chce použít částečnou mezipaměť. Pokud chcete vložit více klíčů obnovení, oddělte je pomocí nového řádku a označte klíč obnovení (další podrobnosti najdete v příkladu). Pořadí, ve kterém se klíče obnovení budou zkoušet, budou odshora dolů.

Požadovaný software v místním agentu

Archivní software / platforma	Windows	Linux	Mac
GNU Tar	Požaduje se	Požaduje se	No
BSD Tar	No	Ne	Požaduje se
7-Zip	Doporučené	No	Ne

Výše uvedené spustitelné soubory musí být ve složce uvedené v proměnné prostředí PATH. Mějte na paměti, že hostovaní agenti se dodávají se softwarem, který je součástí, to platí jenom pro agenty v místním prostředí.

Příklad:

Tady je příklad použití obnovovaných klíčů podle Yarn:

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

V tomto příkladu se úloha mezipaměti pokusí zjistit, jestli klíč existuje v mezipaměti. Pokud klíč v mezipaměti neexistuje, pokusí se použít první obnovovací klíč yarn | $(Agent.OS). Tím se pokusíte vyhledat všechny klíče, které přesně odpovídají danému klíči, nebo má tento klíč jako předponu. K dosažení předpony může dojít v případě, že došlo k jinému yarn.lock segmentu hash. Pokud byl například následující klíč yarn | $(Agent.OS) | old-yarn.lock v mezipaměti, ve které old-yarn.lock byl výsledek jiné hodnoty hash než yarn.lock, vrátí klíč obnovení částečný přístup. Pokud u prvního klíče obnovení dojde k chybě, použije se další obnovovací klíč yarn , který se pokusí najít libovolný klíč, který yarnzačíná . Výsledek pro přístupy předpony vynese jako výsledek naposledy vytvořený klíč mezipaměti.

Poznámka:

Kanál může mít jednu nebo více úloh ukládání do mezipaměti. Kapacita úložiště ukládání do mezipaměti není nijak omezena a úlohy a úlohy ze stejného kanálu můžou přistupovat ke stejné mezipaměti a sdílet je.

Izolace a zabezpečení mezipaměti

Aby se zajistila izolace mezi mezipamětí z různých kanálů a různých větví, každá mezipaměť patří do logického kontejneru označovaného jako obor. Obory poskytují hranici zabezpečení, která zajišťuje, že úloha z jednoho kanálu nemá přístup k mezipamětí z jiného kanálu a úloha, která vytváří žádost o přijetí změn, má přístup ke čtení do mezipamětí cílové větve žádosti o přijetí změn (pro stejný kanál), ale nemůže zapisovat (vytvářet) mezipaměti v oboru cílové větve.

Když během spuštění dojde k kroku mezipaměti, vyžádá se ze serveru mezipaměť identifikovaná klíčem. Server pak vyhledá mezipaměť s tímto klíčem z oborů viditelných pro úlohu a vrátí mezipaměť (pokud je k dispozici). Při ukládání mezipaměti (na konci úlohy) se mezipaměť zapíše do oboru představujícího kanál a větev. Další informace naleznete níže.

CI, ruční a naplánovaná spuštění

Obor	Čtení	Zápis
Zdrojová větev	Ano	Yes
main větev	Yes	No
master větev	Yes	No

Spuštění žádostí o přijetí změn

Obor	Čtení	Zápis
Zdrojová větev	Yes	No
Cílová větev	Yes	No
Zprostředkující větev (například refs/pull/1/merge)	Ano	Yes
main větev	Yes	No
master větev	Yes	No

Spuštění forku žádosti o přijetí změn

Pobočka	Čtení	Zápis
Cílová větev	Yes	No
Zprostředkující větev (například refs/pull/1/merge)	Ano	Yes
main větev	Yes	No
master větev	Yes	No

Tip

Vzhledem k tomu, že mezipaměti jsou již vymezeny na projekt, kanál a větev, není nutné do klíče mezipaměti zahrnout žádné identifikátory projektu, kanálu ani větve.

Klimatizace při obnovení mezipaměti

V některých scénářích by úspěšné obnovení mezipaměti mělo způsobit spuštění jiné sady kroků. Například krok, který nainstaluje závislosti, se dá přeskočit, pokud se mezipaměť obnovila. To je možné pomocí cacheHitVar vstupu úkolu. Nastavení tohoto vstupu na název proměnné prostředí způsobí, že se proměnná nastaví, když dojde k true dosažení mezipaměti, inexact v případě dosažení mezipaměti obnovovací klíče, jinak je nastavená na falsehodnotu . Na tuto proměnnou se pak dá odkazovat v podmínce kroku nebo ve skriptu.

V následujícím příkladu se install-deps.sh krok při obnovení mezipaměti přeskočí:

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

U projektů Ruby využívajících Bundler přepište BUNDLE_PATH proměnnou prostředí, kterou sada Bundler používá k nastavení cesty Bundler , ve které hledá gemy.

Příklad:

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++)

Ccache je mezipaměť kompilátoru pro C/C++. Pokud chcete použít mezipaměť Ccache v kanálu, ujistěte se, že Ccache je nainstalovaná a volitelně přidaná do vašeho PATH kanálu (viz režimy spuštění mezipaměti). Nastavte proměnnou CCACHE_DIR prostředí na cestu pod $(Pipeline.Workspace) tímto adresářem a do mezipaměti.

Příklad:

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)"

Další podrobnosti najdete v nastavení konfigurace Ccache.

Image Dockeru

Ukládání imagí Dockeru do mezipaměti výrazně zkracuje dobu potřebnou ke spuštění kanálu.

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'))

• key: (povinné) – jedinečný identifikátor mezipaměti.
• path: (povinné) – cesta ke složce nebo souboru, který chcete uložit do mezipaměti.

Golang

U projektů jazyka Go můžete zadat balíčky, které se mají stáhnout v souboru go.mod . Pokud proměnná GOCACHE ještě není nastavená, nastavte ji na místo, kam chcete mezipaměť stáhnout.

Příklad:

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

Použití integrované podpory ukládání do mezipaměti gradle může mít významný dopad na čas sestavení. Pokud chcete povolit mezipaměť sestavení, nastavte GRADLE_USER_HOME proměnnou prostředí na cestu pod $(Pipeline.Workspace) a buď spusťte sestavení se souborem--build-cache, nebo ho gradle.properties přidejte org.gradle.caching=true do souboru.

Příklad:

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: Náhradní klíče, pokud primární klíč selže (volitelné)

Poznámka:

Mezipaměti jsou neměnné, jakmile se vytvoří mezipaměť s konkrétním klíčem pro určitý obor (větev), mezipaměť nelze aktualizovat. To znamená, že pokud je klíč pevnou hodnotou, nebudou moci všechna následná sestavení pro stejnou větev aktualizovat mezipaměť ani v případě, že se změnil obsah mezipaměti. Pokud chcete použít pevnou hodnotu klíče, musíte argument použít restoreKeys jako záložní možnost.

Maven

Maven má místní úložiště, ve kterém ukládá stažené a sestavené artefakty. Chcete-li tuto složku povolit, nastavte maven.repo.local možnost na cestu pod $(Pipeline.Workspace) touto složkou a do mezipaměti.

Příklad:

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

Pokud používáte úlohu Maven, nezapomeňte také předat MAVEN_OPTS proměnnou, protože se přepíše jinak:

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

.NET/NuGet

Pokud používáte PackageReferences ke správě závislostí NuGet přímo v souboru projektu a máte packages.lock.json soubor, můžete ukládání do mezipaměti povolit nastavením NUGET_PACKAGES proměnné prostředí na cestu pod $(UserProfile) tímto adresářem a uložením tohoto adresáře do mezipaměti. Další podrobnosti o uzamčení závislostí najdete v referenčních informacích k balíčku v souborech projektu. Pokud chcete použít více packages.lock.json, můžete dál použít následující příklad, aniž byste museli provádět změny. Obsah všech packages.lock.json souborů bude hashován a pokud se některý ze souborů změní, vygeneruje se nový klíč mezipaměti.

Příklad:

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

Ukládání do mezipaměti v projektu Node.js se dá povolit různými způsoby, ale doporučeným způsobem je uložit do mezipaměti sdílený adresář mezipaměti npm. Tento adresář spravuje npm a obsahuje verzi všech stažených modulů v mezipaměti. Během instalace npm nejprve zkontroluje tento adresář (ve výchozím nastavení) pro moduly, které můžou omezit nebo eliminovat síťová volání veřejného registru npm nebo do privátního registru.

Vzhledem k tomu, že výchozí cesta k adresáři sdílené mezipaměti npm není stejná napříč všemi platformami, doporučuje se přepsat npm_config_cache proměnnou prostředí na cestu pod $(Pipeline.Workspace). Tím také zajistíte, že mezipaměť bude přístupná z úloh kontejnerů a nekontejnerových úloh.

Příklad:

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

Pokud váš projekt soubor nemá package-lock.json , místo toho na něj odkazujte package.json ve vstupu klíče mezipaměti.

Tip

Protože npm ci odstraní node_modules složku, aby se zajistila konzistentní, opakovatelná sada modulů, měli byste se vyhnout ukládání do mezipaměti node_modules při volání npm ci.

Node.js/Yarn

Stejně jako u npm existují různé způsoby ukládání balíčků nainstalovaných do mezipaměti s Yarn. Doporučeným způsobem je ukládat do mezipaměti složku sdílené mezipaměti Yarn. Tento adresář spravuje Yarn a obsahuje verzi uložené v mezipaměti všech stažených balíčků. Během instalace Yarn nejprve zkontroluje tento adresář (ve výchozím nastavení) pro moduly, které můžou omezit nebo eliminovat síťová volání veřejných nebo privátních registrů.

Příklad:

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

Nastavení ukládání kanálu do mezipaměti s prostředími Anaconda:

Příklad

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

U projektů PHP používajících Composer přepište proměnnou COMPOSER_CACHE_DIR prostředí, kterou používá Composer.

Příklad:

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

Známé problémy a zpětná vazba

Pokud máte problémy s nastavením ukládání do mezipaměti pro váš kanál, projděte si seznam otevřených problémů v úložišti microsoft/azure-pipelines-tasks . Pokud svůj problém v seznamu nevidíte, vytvořte nový a uveďte potřebné informace o svém scénáři.

Q&A

Otázka: Můžu vymazat mezipaměť?

A: Vymazání mezipaměti se v současné době nepodporuje. Ke stávajícímu klíči mezipaměti ale můžete přidat řetězcový literál (například version2) a změnit tak klíč způsobem, který zabrání případným zásahům do existujících mezipamětí. Změňte například následující klíč mezipaměti z tohoto:

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

Na toto:

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

Otázka: Kdy vyprší platnost mezipaměti?

A: Platnost mezipaměti vyprší po sedmi dnech žádné aktivity.

Otázka: Kdy se mezipaměť nahraje?

A: Po posledním kroku kanálu se z mezipaměti vytvoří mezipaměť path a nahraje se. Další podrobnosti najdete v příkladu.

Otázka: Existuje omezení velikosti mezipaměti?

A: Neexistuje žádné vynucené omezení velikosti jednotlivých mezipamětí ani celkové velikosti všech mezipamětí v organizaci.