YAML-sablonok használata folyamatokban újrafelhasználható és biztonságos folyamatokhoz

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022 | Azure DevOps Server 2020

A sablonok lehetővé teszik az újrafelhasználható tartalom, logika és paraméterek meghatározását a YAML-folyamatokban. A sablonok hatékony használatához alapvető ismeretekkel kell rendelkeznie Azure Pipelines kulcsfontosságú fogalmairól, például szakaszokról, lépésekről és feladatokról.

A sablonoknak két fő típusa van:

• Sablonokat tartalmaz: Újrafelhasználható tartalom beszúrása egy folyamatba. Ha egy sablont tartalom belefoglalására használnak, az úgy működik, mint egy belefoglalási irányelv számos programozási nyelven. A sablonból származó tartalom be lesz szúrva az azt tartalmazó folyamatba vagy sablonba.
• Kibővíti a sablonokat: A folyamatokban engedélyezett sémák szabályozása és definiálása. A bővítménysablon használata esetén meghatározza a folyamat által követendő logikát és struktúrát. Ez a biztonsági, megfelelőségi vagy szervezeti szabványok kikényszerítéséhez hasznos.

A sablonok segíthetnek a fejlesztés felgyorsításában. Előfordulhat például, hogy ugyanazon feladatok sorozata szerepel egy sablonban, majd többször is belefoglalja a sablont a YAML-folyamat különböző szakaszaiba.

A sablonok segíthetnek a folyamat biztonságossá tételében is. Amikor egy sablon szabályozza, hogy mi engedélyezett egy folyamatban, a sablon olyan logikát határoz meg, amelyet egy másik fájlnak követnie kell. Előfordulhat például, hogy korlátozni szeretné, hogy mely tevékenységek futtathatók. Ehhez a forgatókönyvhöz sablon használatával megakadályozhatja, hogy valaki sikeresen futtasson egy olyan feladatot, amely megsérti a szervezet biztonsági szabályzatait.

A sablonok teljes kihasználásához sablonkifejezéseket és sablonparamétereket is használnia kell.

Előfeltételek

termék	Követelmények
Azure DevOps	- Egy Azure DevOps-projekt. – A csővezetékek futtatásának képessége Microsoft által hosztolt ügynökökön. Vásárolhat párhuzamos feladatot , vagy ingyenes szintet kérhet. - A YAML és az Azure Pipelines alapszintű ismerete. További információért lásd: Az első pipeline létrehozása. - Engedélyek:      – Folyamat létrehozásához a Közreműködők csoportban kell lennie, és a csoportnak a buildfolyamat létrehozása engedélyt Engedélyezve állapotra kell állítania. A Projektgazdák csoport tagjai kezelhetik a folyamatokat.     - Szolgáltatáskapcsolatok létrehozásához: A szolgáltatáskapcsolatokhozrendszergazdai vagy létrehozói szerepkör szükséges.
GitHub	- Egy GitHub-fiók . – GitHub-szolgáltatáskapcsolat az Azure Pipelines engedélyezéséhez.
Azure	Egy Azure-előfizetés.

A sablonfrissítésekre vonatkozó korlátozások

A sablonok és sablonkifejezések robbanásszerű növekedést okozhatnak a folyamat méretét és összetettségét illetően. Az elszabadult növekedés megelőzése érdekében az Azure Pipelines a következő korlátokat szabja meg:

• Legfeljebb 100 különálló YAML-fájl szerepelhet (közvetlenül vagy közvetve)
• Legfeljebb 100 szintű sablon beágyazása (más sablonokat is beleértve)
• A YAML elemzése során legfeljebb 20 megabájtnyi memória fogyasztható el (a gyakorlatban ez általában 600 KB – 2 MB lemezen lévő YAML között van, a használt funkcióktól függően)

Kiterjesztés sablonból

A biztonság növelése érdekében megkövetelheti, hogy egy pipeline egy adott sablonból származzon. A fájl start-extends-template.yml határozza meg a paramétert buildSteps, amelyet aztán a folyamat azure-pipelines.ymlhasznál. Ha egy start-extends-template.yml egy szkriptszinttel továbbítódik buildStep-ban, akkor azt elutasítják, és az építés meghiúsul. Ha sablonból bővít, a szükséges sablon-jóváhagyás hozzáadásával növelheti a biztonságot.

# File: start-extends-template.yml
parameters:
- name: buildSteps # the name of the parameter is buildSteps
  type: stepList # data type is StepList
  default: [] # default value of buildSteps
stages:
- stage: secure_buildstage
  pool:
    vmImage: windows-latest
  jobs:
  - job: secure_buildjob
    steps:
    - script: echo This happens before code 
      displayName: 'Base: Pre-build'
    - script: echo Building
      displayName: 'Base: Build'

    - ${{ each step in parameters.buildSteps }}:
      - ${{ each pair in step }}:
          ${{ if ne(pair.value, 'CmdLine@2') }}:
            ${{ pair.key }}: ${{ pair.value }}       
          ${{ if eq(pair.value, 'CmdLine@2') }}: 
            # Step is rejected by raising a YAML syntax error: Unexpected value 'CmdLine@2'
            '${{ pair.value }}': error         

    - script: echo This happens after code
      displayName: 'Base: Signing'

# File: azure-pipelines.yml
trigger:
- main

extends:
  template: start-extends-template.yml
  parameters:
    buildSteps:  
      - bash: echo Test #Passes
        displayName: succeed
      - bash: echo "Test"
        displayName: succeed
      # Step is rejected by raising a YAML syntax error: Unexpected value 'CmdLine@2'
      - task: CmdLine@2
        inputs:
          script: echo "Script Test"
      # Step is rejected by raising a YAML syntax error: Unexpected value 'CmdLine@2'
      - script: echo "Script Test"

Sablonból erőforrásokkal való kiterjesztés

Az extends használatával az erőforrásokat tartalmazó sablonból is kiterjeszthet az Azure-folyamatban.

# File: azure-pipelines.yml
trigger:
- none

extends:
  template: resource-extends-template.yml

# File: resource-extends-template.yml
resources:
  pipelines:
  - pipeline: my-pipeline 
    source: sourcePipeline

steps:
- script: echo "Testing resource template"

Sablon beszúrása

Beszúrhat tartalmat egy YAML-ből, és felhasználhatja azt egy másik YAML-ben. Ha tartalmat szúr be egy YAML-ből egy másikba, azzal nem kell manuálisan belefoglalnia ugyanazt a logikát több helyen. A insert-npm-steps.yml fájlsablon olyan lépéseket tartalmaz, amelyek újra felhasználhatók a fájlban azure-pipelines.yml.

Feljegyzés

A sablonfájloknak a folyamatfuttatás kezdetén létezniük kell a fájlrendszerben. Az artefaktumokban nem hivatkozhat sablonokra.

# File: templates/insert-npm-steps.yml

steps:
- script: npm install
- script: yarn install
- script: npm run compile

# File: azure-pipelines.yml

jobs:
- job: Linux
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - template: templates/insert-npm-steps.yml  # Template reference
- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - template: templates/insert-npm-steps.yml  # Template reference

Lépések újrafelhasználása több feladat között

Sablon beszúrása több feladat egy vagy több lépésének újrafelhasználásához. A sablon lépésein kívül minden feladat további lépéseket is meghatározhat.

# File: templates/insert-npm-steps.yml
steps:
- script: npm install
- script: npm test

# File: azure-pipelines.yml

jobs:
- job: Linux
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - template: templates/insert-npm-steps.yml  # Template reference

- job: macOS
  pool:
    vmImage: 'macOS-latest'
  steps:
  - template: templates/insert-npm-steps.yml  # Template reference

- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - script: echo This script runs before the template's steps, only on Windows.
  - template: templates/insert-npm-steps.yml  # Template reference
  - script: echo This step runs after the template's steps.

Feladatok újrafelhasználása több sablonban

A lépésekhez hasonlóan a feladatok is újra felhasználhatók sablonokkal.

# File: templates/insert-jobs.yml
jobs:
- job: Ubuntu
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - bash: echo "Hello Ubuntu"

- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - bash: echo "Hello Windows"

# File: azure-pipelines.yml

jobs:
- template: templates/insert-jobs.yml  # Template reference

Ha több feladattal dolgozik, ne felejtse el eltávolítani a feladat nevét a sablonfájlból, hogy elkerülje az ütközést

# File: templates/insert-multiple-jobs.yml
jobs:
- job: 
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - bash: echo "Hello Ubuntu"

- job:
  pool:
    vmImage: 'windows-latest'
  steps:
  - bash: echo "Hello Windows"

# File: azure-pipelines.yml

jobs:
- template: templates/insert-multiple-job.yml  # Template reference
- template: templates/insert-multiple-jobs.yml  # Template reference
- template: templates/insert-multiple-jobs.yml  # Template reference

Szakaszok újrafelhasználása több sablonban

A szakaszok sablonokkal is újra felhasználhatók.

# File: templates/insert-stage1.yml
stages:
- stage: Angular
  jobs:
  - job: angularinstall
    steps:
    - script: npm install angular

# File: templates/insert-stage2.yml
stages:
- stage: Build
  jobs:
  - job: build
    steps:
    - script: npm run build

# File: azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

stages:
- stage: Install
  jobs: 
  - job: npminstall
    steps:
    - task: Npm@1
      inputs:
        command: 'install'
- template: templates/insert-stage1.yml # Template reference
- template: templates/insert-stage2.yml # Template reference

Paraméterek hozzáadása feladat-, szakasz- és lépéssablonokhoz

Az alábbi sablonokban:

• templates/npm-with-params.yml két paramétert határoz meg: name és vmImage, és létrehoz egy munkafolyamatot, ahol a névparaméter a munkafolyamat neve, és a vmImage paraméter a VM kép.
• A folyamat (azure-pipelines.yml) háromszor hivatkozik a sablonra, amelyek mindegyike különböző paraméterértékekkel rendelkezik, amelyek az operációs rendszer és a virtuálisgép-rendszerképek nevére hivatkoznak.
• A beépített folyamat egy másik virtuálisgép-lemezképen fut, és a megadott operációs rendszer szerint van elnevezve. Minden feladat végrehajtja az npm telepítését és az npm tesztelési lépéseit.

# File: templates/npm-with-params.yml

parameters:
- name: name  # defaults for any parameters that aren't specified
  default: ''
- name: vmImage
  default: ''

jobs:
- job: ${{ parameters.name }}
  pool: 
    vmImage: ${{ parameters.vmImage }}
  steps:
  - script: npm install
  - script: npm test

Amikor felhasználja a sablont a folyamatban, adja meg a sablon paramétereinek értékeit.

# File: azure-pipelines.yml

jobs:
- template: templates/npm-with-params.yml  # Template reference
  parameters:
    name: Linux
    vmImage: 'ubuntu-latest'

- template: templates/npm-with-params.yml  # Template reference
  parameters:
    name: macOS
    vmImage: 'macOS-latest'

- template: templates/npm-with-params.yml  # Template reference
  parameters:
    name: Windows
    vmImage: 'windows-latest'

Több paraméterrel rendelkező szakasz sablonok

Az alábbi sablonokban:

• A stage-template.yml sablon négy paramétert határoz meg: stageName, jobName, vmImageés scriptPath, az összes típusú sztringet. A sablon létrehoz egy szakaszt a stageName paraméterrel a szakasznév beállításához, definiál egy feladatot a jobName paraméterrel, és magában foglal egy lépést egy szkript futtatására.
• A folyamat ezután azure-pipeline.ymldinamikusan definiálja a fázisokat és a feladatokat paraméterekkel, build-script.shmajd futtat egy szkriptet végrehajtó feladatot.

# stage-template.yml

parameters:
  - name: stageName
    type: string
  - name: jobName
    type: string
  - name: vmImage
    type: string
  - name: scriptPath
    type: string

stages:
  - stage: ${{ parameters.stageName }}
    jobs:
      - job: ${{ parameters.jobName }}
        pool:
          vmImage: ${{ parameters.vmImage }}
        steps:
          - script: ./${{ parameters.scriptPath }}

# azure-pipelines.yml
trigger:
- main

stages:
- template: stage-template.yml
  parameters:
    stageName: 'BuildStage'
    jobName: 'BuildJob'
    scriptPath: 'build-script.sh' # replace with script in your repository
    vmImage: 'ubuntu-latest'

Sablonok lépésekkel és paraméterekkel

A paramétereket lépés- vagy szakaszsablonokkal is használhatja.

Az alábbi sablonokban:

• A sablon (templates/steps-with-params.yml) egy hamis alapértelmezett értékkel elnevezett runExtendedTests paramétert határoz meg.
• A csővezeték (azure-pipelines.yml) fut npm test és npm test --extended mivel a runExtendedTests paraméter igaz.

# File: templates/steps-with-params.yml

parameters:
- name: 'runExtendedTests'  # defaults for any parameters that aren't specified
  type: boolean
  default: false

steps:
- script: npm test
- ${{ if eq(parameters.runExtendedTests, true) }}:
  - script: npm test --extended

Amikor felhasználja a sablont a folyamatban, adja meg a sablon paramétereinek értékeit.

# File: azure-pipelines.yml

steps:
- script: npm install

- template: templates/steps-with-params.yml  # Template reference
  parameters:
    runExtendedTests: 'true'

Feljegyzés

A megadott típus nélküli skaláris paraméterek sztringekként vannak kezelve. Például eq(true, parameters['myparam']) visszaadja true akkor is, ha a myparam paraméter a szó false, amennyiben myparam nincs explicit módon boolean. A nem üres karakterláncok logikai értékké alakulnak true kontextusban. A kifejezés átírható a sztringek explicit összehasonlítása érdekében: eq(parameters['myparam'], 'true').

A paraméterek nem korlátozódnak skaláris sztringekre. Tekintse meg az adattípusok listáját. Például a object következő típust használva:

# azure-pipelines.yml
jobs:
- template: process.yml
  parameters:
    pool:   # this parameter is called `pool`
      vmImage: ubuntu-latest  # and it's a mapping rather than a string

# process.yml
parameters:
- name: 'pool'
  type: object
  default: {}

jobs:
- job: build
  pool: ${{ parameters.pool }}

Változók újrafelhasználása

A változók definiálhatók egy YAML-ben, és egy másik sablonban is megtalálhatók. Ez akkor lehet hasznos, ha az összes változót egy fájlban szeretné tárolni. Ha egy sablont használ változók folyamatba való belefoglalásához, a belefoglalt sablon csak változók definiálására használható. A sablonból való kibővítéskor lépések és összetettebb logika is használható.

Feljegyzés

Változók helyett paramétereket használjon a hozzáadott biztonsághoz, például a típus megadásához. A paraméterek rendszerhéj-tevékenységekhez való használatának fontosságáról a rendszerhéj-tevékenységek argumentumainak engedélyezése paraméterérvényesítési dokumentációjában talál további információt.

Ebben a példában a favoriteVeggie változó szerepel a azure-pipelines.yml-ben.

# File: insert-vars.yml
variables:
  favoriteVeggie: 'brussels sprouts'

# File: azure-pipelines.yml

variables:
- template: insert-vars.yml  # Template reference

steps:
- script: echo My favorite vegetable is ${{ variables.favoriteVeggie }}.

Változósablonok paraméterekkel

Paramétereket adhat át a változóknak sablonokkal. Ebben a példában a DIRECTORY paramétert egy RELEASE_COMMAND változónak adja át.

# File: templates/package-release-with-params.yml

parameters:
- name: DIRECTORY 
  type: string
  default: "." # defaults for any parameters that specified with "." (current directory)

variables:
- name: RELEASE_COMMAND
  value: grep version ${{ parameters.DIRECTORY }}/package.json | awk -F \" '{print $4}'  

Amikor felhasználja a sablont a folyamatban, adja meg a sablon paramétereinek értékeit.

# File: azure-pipelines.yml

variables: # Global variables
  - template: package-release-with-params.yml # Template reference
    parameters:
      DIRECTORY: "azure/checker"

pool:
  vmImage: 'ubuntu-latest'

stages:
- stage: Release_Stage 
  displayName: Release Version
  variables: # Stage variables
  - template: package-release-with-params.yml  # Template reference
    parameters:
      DIRECTORY: "azure/todo-list"
  jobs: 
  - job: A
    steps: 
    - bash: $(RELEASE_COMMAND) #output release command

Továbbfejlesztés egy sablon alapján, és változókat tartalmazó sablon használata

Az egyik gyakori forgatókönyv egy fejlesztési, tesztelési és élesítési fázisokkal rendelkező folyamat, amely használ egy változókra vonatkozó inklúziós sablont, valamint egy szakaszokhoz és feladatokhoz kiterjesztett sablont is.

Az alábbi példában a variables-template.yml definiál egy virtuális gép változókészletet, amelyeket aztán a azure-pipeline.yml használ.

# variables-template.yml

variables:
- name: devVmImage
  value: 'ubuntu-latest'
- name: testVmImage
  value: 'ubuntu-latest'
- name: prodVmImage
  value: 'ubuntu-latest'

Az alábbi fájl stage-template.yml egy újrafelhasználható fáziskonfigurációt határoz meg három paraméterrel (name, vmImage, steps) és egy nevesített Buildfeladattal.

# stage-template.yml
parameters:
- name: name
  type: string
  default: ''
- name: vmImage
  type: string
  default: ''
- name: steps
  type: stepList
  default: []

stages:
- stage: ${{ parameters.name }}
  jobs:
  - job: Build
    pool:
      vmImage: ${{ parameters.vmImage }}
    steps: ${{ parameters.steps }}

Az alábbi folyamatban a azure-pipelines.yml változókat a variables-template.yml segítségével importáljuk, majd a stage-template.yml sablont használjuk az egyes fázisokhoz. Minden fázis (Dev, Test, Prod) ugyanazzal a sablonnal, de különböző paraméterekkel van definiálva, ami a fázisok közötti konzisztenciához vezet, miközben lehetővé teszi a testreszabást. A "Prod" szakasz tartalmaz egy környezeti változót, amely példaként szolgál a hitelesítéshez használható dologra. A paraméterek definiálásáról további információt a Sablonparaméterek című témakörben talál.

# azure-pipelines.yml
trigger:
- main

variables:
- template: variables-template.yml

stages:
- template: stage-template.yml
  parameters:
    name: Dev
    vmImage: ${{ variables.devVmImage }}
    steps:
      - script: echo "Building in Dev"
- template: stage-template.yml
  parameters:
    name: Test
    vmImage: ${{ variables.testVmImage }}
    steps:
      - script: echo "Testing in Test"
- template: stage-template.yml
  parameters:
    name: Prod
    vmImage: ${{ variables.prodVmImage }}
    steps:
      - script: echo "Deploying to Prod"
        env:
          SYSTEM_ACCESSTOKEN: $(System.AccessToken)

Referenciasablon elérési útjai

A sablon elérési útja lehet abszolút elérési út az adattárban, vagy relatív út ahhoz a fájlhoz viszonyítva, amely tartalmazza a sablont.

Abszolút elérési út használatához a sablon elérési útjának egy /-vel kell kezdődnie. Az összes többi elérési út relatívnek minősül.

Íme egy példa beágyazott hierarchiára.

|
+-- fileA.yml
|
+-- dir1/
     |
     +-- fileB.yml
     |
     +-- dir2/
          |
          +-- fileC.yml

Majd a fileA.yml után, a fileB.yml és fileC.yml elemekre hivatkozhat hasonló módon.

steps:
- template: dir1/fileB.yml
- template: dir1/dir2/fileC.yml

Ha a fileC.yml kiindulási pont, akkor így foglalhatja bele a fileA.yml és fileB.yml elemeket.

steps:
- template: ../../fileA.yml
- template: ../fileB.yml

Amikor fileB.yml a kiindulási pont, belefoglalhatja fileA.yml és fileC.yml ilyen módon.

steps:
- template: ../fileA.yml
- template: dir2/fileC.yml

Alternatív megoldásként a fileB.yml a fileA.yml és fileC.yml abszolút elérési útvonalak használatára hivatkozhat ily módon.

steps:
- template: /fileA.yml
- template: /dir1/dir2/fileC.yml

Sablonok tárolása más adattárakban

A sablonokat más adattárakban is megtarthatja. Tegyük fel például, hogy rendelkezik egy alapfolyamatgal, amelyet az összes alkalmazásfolyamatot használni szeretne. A sablont elhelyezheti egy központi adattárban, majd az egyes alkalmazás-adattárakból is hivatkozhat rá:

# Repo: Contoso/BuildTemplates
# File: common.yml
parameters:
- name: 'vmImage'
  default: 'ubuntu-22.04'
  type: string

jobs:
- job: Build
  pool:
    vmImage: ${{ parameters.vmImage }}
  steps:
  - script: npm install
  - script: npm test

Most már több folyamatban is felhasználhatja ezt a sablont. A specifikáció segítségével resources adja meg a központi adattár helyét. Amikor az alapvető adattárra hivatkozik, használja a @-t és azt a nevet, amit a resources-ben megadott.

# Repo: Contoso/LinuxProduct
# File: azure-pipelines.yml
resources:
  repositories:
    - repository: templates
      type: github
      name: Contoso/BuildTemplates

jobs:
- template: common.yml@templates  # Template reference

# Repo: Contoso/WindowsProduct
# File: azure-pipelines.yml
resources:
  repositories:
    - repository: templates
      type: github
      name: Contoso/BuildTemplates
      ref: refs/tags/v1.0 # optional ref to pin to

jobs:
- template: common.yml@templates  # Template reference
  parameters:
    vmImage: 'windows-latest'

\type: github esetében \name \<identity>/<repo> ugyanúgy, mint az előző példában. Azure Repos esetén a type: git, name<project>/<repo>. Ha a projekt egy külön Azure DevOps-szervezetben található, konfigurálnia kell egy szolgáltatáskapcsolatot típusú Azure Repos/Team Foundation Server a projekthez való hozzáféréssel, és bele kell foglalnia a YAML-be:

resources:
  repositories:
  - repository: templates
    name: Contoso/BuildTemplates
    endpoint: myServiceConnection # Azure DevOps service connection
jobs:
- template: common.yml@templates

Az adattárak csak egyszer kerülnek feloldásra, amikor a pipeline elindul. Ezt követően ugyanazt az erőforrást használja a folyamat végrehajtása során. A rendszer csak a sablonfájlokat használja. A sablonok teljes kibontása után a végső folyamat úgy fut, mintha teljes egészében a forrásadattárban lett volna definiálva. Ez azt jelenti, hogy nem használhat szkripteket a folyamat sablon-adattárából.

Ha a sablon egy adott, rögzített verzióját szeretné használni, ügyeljen arra, hogy rögzítsen egy ref. Ezek refs vagy ágak (refs/heads/<name>), vagy címkék (refs/tags/<name>). Ha egy adott véglegesítést szeretne rögzíteni, először hozzon létre egy, a véglegesítésre mutató címkét, majd rögzítse a címkét.

Feljegyzés

Ha nincs megadva ref, a folyamat alapértelmezés szerint refs/heads/mainhasznál.

Egy adott véglegesítést a Gitben is rögzíthet egy adattárerőforrás SHA-értékével. Az SHA-érték egy 40 karakteres ellenőrzőösszeg kivonat, amely egyedileg azonosítja a véglegesítést.

resources:
  repositories:
    - repository: templates
      type: git
      name: Contoso/BuildTemplates
      ref: 1234567890abcdef1234567890abcdef12345678

A @self-t is használhatja arra, hogy hivatkozzon arra az adattárra, ahol az eredeti csővezeték található. Ez kényelmesen használható a extends sablonokban, ha vissza akar hivatkozni a kiterjesztett folyamat adattárának tartalmaira. Példa:

# Repo: Contoso/Central
# File: template.yml
jobs:
- job: PreBuild
  steps: []

  # Template reference to the repo where this template was
  # included from - consumers of the template are expected
  # to provide a "BuildJobs.yml"
- template: BuildJobs.yml@self

- job: PostBuild
  steps: []

# Repo: Contoso/MyProduct
# File: azure-pipelines.yml
resources:
  repositories:
    - repository: templates
      type: git
      name: Contoso/Central

extends:
  template: template.yml@templates

# Repo: Contoso/MyProduct
# File: BuildJobs.yml
jobs:
- job: Build
  steps: []

GYIK

Hogyan használhatok változókat a sablonokon belül?

Vannak olyan időszakok, amikor hasznos a paraméterek változókon alapuló értékekre történő beállítása. A paraméterek ki vannak bontva már egy pipeline futtatásának feldolgozása elején, így nem minden változó érhető el. A sablonokban elérhető előre meghatározott változók megtekintéséhez lásd Az előre meghatározott változók használata című szakaszt.

Ebben a példában az előre definiált változók Build.SourceBranchBuild.Reason szerepelnek a template.yml feltételeiben.

# File: azure-pipelines.yml
trigger:
- main

extends:
  template: template.yml

# File: template.yml
steps:
- script: echo Build.SourceBranch = $(Build.SourceBranch) # outputs refs/heads/main
- script: echo Build.Reason = $(Build.Reason) # outputs IndividualCI
- ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/main') }}: 
  - script: echo I run only if Build.SourceBranch = refs/heads/main 
- ${{ if eq(variables['Build.Reason'], 'IndividualCI') }}: 
  - script: echo I run only if Build.Reason = IndividualCI 
- script: echo I run after the conditions