Şablon türleri & kullanımı

Şablonlar yeniden kullanılabilir içerik, mantık ve parametreler tanımlamayı sağlar. Şablonlar iki şekilde çalışır. Bir şablonla yeniden kullanılabilir içerik eklemek veya işlem hattında izin verilenleri kontrol etmek için bir şablon kullanabilirsiniz. İkinci yaklaşım, şablonlarıyla güvenli işlem hatları oluşturmak için yararlıdır.

İçerik eklemek için bir şablon kullanılıyorsa, birçok programlama dilinde ekleme yönergesi gibi işlev gösterir. Bir dosyanın içeriği başka bir dosyaya eklenir. Bir şablon işlem hattında izin verilenleri kontrol edinca, şablon başka bir dosyanın izlemesi gereken mantığı tanımlar.

Şablonları kullanarak mantığınızı bir kez tanımlayın ve birkaç kez yeniden kullanın. Şablonlar, birden çok YAML dosyası içeriğini tek bir işlem hattında birleştirir. Parametreleri bir şablona üst işlem hattından aktarabilirsiniz.

Parametreler

Parametreleri ve bunların veri türlerini şablonda belirtebilirsiniz ve bu parametreleri bir işlem hattına aktarabilirsiniz. Parametreleri şablonların dışında da kullanabilirsiniz. Değişmez değerleri yalnızca parametre varsayılan değerleri için kullanabilirsiniz.

Parametreleri geçirme

Parametreler bir ad ve veri türü içermeli. içinde, azure-pipelines.yml parametresi yesNo bir boole değerine ayarlanırsa derleme başarılı olur. gibi yesNo bir dizeye ayar olduğunda apples derleme başarısız olur.

# File: simple-param.yml
parameters:
- name: yesNo # name of the parameter; required
  type: boolean # data type of the parameter; required
  default: false

steps:
- script: echo ${{ parameters.yesNo }}

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

extends:
  template: simple-param.yml
  parameters:
      yesNo: false # set to a non-boolean value to have the build fail

Çalışma zamanında şablon seçme parametreleri

Koşula bağlı olarak bir işlem hattı YAML'lerinden farklı şablonlar çağırabilirsiniz. Bu örnekte, experimental.yml parametre true olduğunda YAML experimentalTemplate çalıştıracak.

#azure-pipeline.yml
parameters:
- name: experimentalTemplate
  displayName: 'Use experimental build process?'
  type: boolean
  default: false

steps:
- ${{ if eq(parameters.experimentalTemplate, true) }}:
  - template: experimental.yml
- ${{ if not(eq(parameters.experimentalTemplate, true)) }}:
  - template: stable.yml

Parametre veri türleri

Veri türü	Notlar
string	string
number	ile values: kısıtlanabilir, aksi takdirde sayıya benzer herhangi bir dize kabul edilir
boolean	true veya false
object	herhangi bir YAML yapısı
step	tek bir adım
stepList	adım dizisi
job	tek bir iş
jobList	iş dizisi
deployment	tek bir dağıtım işi
deploymentList	dağıtım işleri dizisi
stage	tek bir aşama
stageList	aşama dizisi

Step, stepList, job, jobList, deployment, deploymentList, stage ve stageList veri türlerinin hepsi standart YAML şema biçimini kullanır. Bu örnek dize, sayı, boole, nesne, adım ve stepList'i içerir.

parameters:
- name: myString
  type: string
  default: a string
- name: myMultiString
  type: string
  default: default
  values:
  - default
  - ubuntu
- name: myNumber
  type: number
  default: 2
  values:
  - 1
  - 2
  - 4
  - 8
  - 16
- name: myBoolean
  type: boolean
  default: true
- name: myObject
  type: object
  default:
    foo: FOO
    bar: BAR
    things:
    - one
    - two
    - three
    nested:
      one: apple
      two: pear
      count: 3
- name: myStep
  type: step
  default:
    script: echo my step
- name: mySteplist
  type: stepList
  default:
    - script: echo step one
    - script: echo step two

trigger: none

jobs: 
- job: stepList
  steps: ${{ parameters.mySteplist }}
- job: myStep
  steps:
    - ${{ parameters.myStep }}

Bir nesnede iterate ve nesnesinde her dizeyi yazdırabilirsiniz.

parameters:
- name: listOfStrings
  type: object
  default:
  - one
  - two

steps:
- ${{ each value in parameters.listOfStrings }}:
  - script: echo ${{ value }}

Şablondan genişletme

Güvenliği artırmak için, bir işlem hattının belirli bir şablondan genişlet uygulanmasını zorunlu abilirsiniz. dosyası, start.yml daha sonra işlem buildSteps hattında kullanılan parametresini azure-pipelines.yml tanımlar. içinde, start.yml bir buildStep betik adımıyla geçirilirse reddedilir ve işlem hattı derlemesi başarısız olur. Şablondan genişleterek gerekli bir şablon onayı ekleyerek güvenliği artırabilirsiniz.

# File: start.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: vs2017-win2016
  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') }}: 
            '${{ pair.value }}': error         

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

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

extends:
  template: start.yml
  parameters:
    buildSteps:  
      - bash: echo Test #Passes
        displayName: succeed
      - bash: echo "Test"
        displayName: succeed
      - task: CmdLine@2
        displayName: Test 3 - Will Fail
        inputs:
          script: echo "Script Test"

Kaynakları olan bir şablonu genişletme

Azure işlem extends hattında kaynakları içeren bir şablonu genişletmek için de kullanabilirsiniz.

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

extends:
  template: resource-template.yml

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

steps:
 - script: echo "Testing resource template"

Şablon ekleme

Bir YAML'den içerik kopyalayıp farklı bir YAML'de yeniden kullanabilirsiniz. Bir YAML'den diğerine içerik kopyalamak, aynı mantığı birden çok yere el ile eklemek zorunda kalmadan sizi kurtarır. Dosya include-npm-steps.yml şablonu, içinde yeniden kullanılan adımları azure-pipelines.yml içerir.

Şablon dosyalarının işlem hattı çalıştırması başında dosya sisteminiz üzerinde mevcut olması gerekir. Bir yapıtta şablonlara başvurasınız.

# File: templates/include-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/include-npm-steps.yml  # Template reference
- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - template: templates/include-npm-steps.yml  # Template reference

Yeniden kullanma adımı

Birkaç iş arasında bir veya daha fazla adımı yeniden kullanmak için bir şablon abilirsiniz. Şablondan gelen adımlara ek olarak, her iş daha fazla adım tanımlayabilir.

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

# File: azure-pipelines.yml

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

- job: macOS
  pool:
    vmImage: 'macOS-latest'
  steps:
  - template: templates/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/npm-steps.yml  # Template reference
  - script: echo This step runs after the template's steps.

İş yeniden kullanımı

Adımlar gibi işler de şablonlarla yeniden kullanılabilir.

# File: templates/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/jobs.yml  # Template reference

Birden çok iş ile çalışırken, çakışmayı önlemek için şablon dosyasındaki işin adını kaldırmayı unutmayın

# File: templates/jobs.yml
jobs:
- job: 
  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/jobs.yml  # Template reference
- template: templates/jobs.yml  # Template reference
- template: templates/jobs.yml  # Template reference

Yeniden kullanma aşaması

Aşamalar şablonlarla da yeniden kullanılabilir.

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

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

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

pool:
  vmImage: 'ubuntu-latest'

stages:
- stage: Install
  jobs: 
  - job: npminstall
    steps:
    - task: Npm@1
      inputs:
        command: 'install'
- template: templates/stages1.yml
- template: templates/stages2.yml

Parametrelerle iş, aşama ve adım şablonları

# 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

Şablonu işlem hattında tükettiğiniz zaman, şablon parametreleri için değerleri belirtin.

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

Parametreleri adım veya aşama şablonlarıyla da kullanabilirsiniz. Örneğin, parametreleri olan adımlar:

# 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

Şablonu işlem hattında tükettiğiniz zaman, şablon parametreleri için değerleri belirtin.

# File: azure-pipelines.yml

steps:
- script: npm install

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

Parametreler skaler dizelerle sınırlı değildir. Veri türleri listesine bakın. Örneğin, türünü object kullanarak:

# 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 }}

Değişkeni yeniden kullanma

Değişkenler bir YAML içinde tanımlanabilir ve başka bir şablona dahil edilir. Tüm değişkenlerinizi tek bir dosyada depolamak için bu yararlı olabilir. Bir işlem hattına değişken eklemek için şablon kullanıyorsanız, dahil edilen şablon yalnızca değişkenleri tanımlamak için kullanılabilir. Bir şablondan genişleterek adımları ve daha karmaşık mantığı kullanabilirsiniz. Türü kısıtlamak istediğiniz zaman değişkenler yerine parametreleri kullanın.

Bu örnekte değişkeni içinde favoriteVeggie yer azure-pipelines.yml almaktadır.

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

# File: azure-pipelines.yml

variables:
- template: vars.yml  # Template reference

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

Başvuru şablonu yolları

Şablon yolları, dahil edildiklerini içeren dosyayla göreli olması gerekir. Burada örnek bir iç içe geçmiş hiyerarşi yer alır.

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

Ardından, içinde fileA.yml ve gibi fileB.ymlfileC.yml başvurarak.

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

Başlangıç fileC.yml noktanız bu ise, ve gibi fileA.yml bir şey dahil fileB.yml olabilir.

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

Başlangıç fileB.yml noktanız olduğunda, ve gibi fileA.yml bir şey dahil etmek fileC.yml için.

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

Diğer depoları kullanma

Şablonlarınızı başka depolarda tutabilirsiniz. Örneğin, tüm uygulama işlem hatlarınızı kullanmak istediğiniz temel bir işlem hattına sahip olduğunu varsayalım. Şablonu bir çekirdek repoya yer ve ardından uygulama repolarından her biri için başvurabilirsiniz:

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

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

Artık bu şablonu birden çok işlem hattında yeniden kullanabilirsiniz. Çekirdek resources repo konumunu sağlamak için belirtimi kullanın. Çekirdek repoya başvurarak içinde @ verdiği adı resources kullanın.

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

için, type: githubname yukarıdaki <identity>/<repo> örneklerde olduğu gibi. için type: git (Azure Repos), name şu şekildedir: <project>/<repo> . Bu proje ayrı bir Azure DevOps kuruluşta ise, projeye erişimi olan türde bir hizmet bağlantısı yapılandırmanız ve bunu YAML'ye dahil edin:

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

Depolar, işlem hattı başlatıldığında yalnızca bir kez çözümlenir. Bundan sonra, işlem hattı süresi boyunca aynı kaynak kullanılır. Yalnızca şablon dosyaları kullanılır. Şablonlar tamamen genişletilirse, son işlem hattı tamamen kaynak depoda tanımlanmış gibi çalışır. Bu, işlem hattınız içinde şablon depodan betikleri kullanabileceğiniz anlamına gelir.

Şablonun belirli, sabit bir sürümünü kullanmak için sabit bir sürümüne ref sabitlenin. dalları refs ( refs/heads/<name> ) veya etiketleridir ( refs/tags/<name> ). Belirli bir işlemeyi sabitlemek için önce bu işlemeye işaret eden bir etiket oluşturun ve ardından bu etikete sabitlenin.

Ana işlem @self hattının bulunduğu depoya başvurmak için de kullanabilirsiniz. Bu, genişletme işlem hattının deposundaki içeriklere geri başvurmak extends için şablonlar için kullanışlıdır. Örnek:

# 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: []

Şablon ifadeleri

İşlem hattı başlatma sırasında değerlerin dinamik olarak nasıl çözümlenmiş olduğunu belirtmek için şablon ifadelerini kullanın. Şablon ifadenizi şu söz dizimlerine sarmala: ${{ }} .

Şablon ifadeleri şablon parametrelerini ve değişkenleri genişletebilirsiniz. Parametreleri kullanarak bir şablonun nasıl genişletileceklerini etkileyebilirsiniz. nesnesi, parameters bir parameters gibi çalışır. Şablon ifadelerinde yalnızca önceden tanımlanmış değişkenler kullanılabilir.

Örneğin, bir şablon tanımlarsınız:

# File: steps/msbuild.yml

parameters:
- name: 'solution'
  default: '**/*.sln'
  type: string

steps:
- task: msbuild@1
  inputs:
    solution: ${{ parameters['solution'] }}  # index syntax
- task: vstest@2
  inputs:
    solution: ${{ parameters.solution }}  # property dereference syntax

Ardından şablona başvurur ve isteğe bağlı parametresini solution ilersiniz:

# File: azure-pipelines.yml

steps:
- template: steps/msbuild.yml
  parameters:
    solution: my.sln

Bağlam

Bir şablon ifadesi içinde geçirilen parameters parametrelerin değerlerini içeren bağlama erişebilirsiniz. Buna ek olarak, YAML dosyasında belirtilen tüm değişkenlerin yanı sıra önceden tanımlanmış değişkenlerin birçoğuna (bu konudaki her değişkende belirtilmiştir) içeren bağlama variables erişebilirsiniz. variables Daha da önemlisi, işlem hattında depolananlar veya bir çalıştırmayı başlatmanız için verilenler gibi çalışma zamanı değişkenleri yoktur. Şablon genişletmesi çalıştırmanın çok erken bir zamanlarındagerçekleşir, bu nedenle bu değişkenler kullanılamaz.

Gerekli parametreler

Gerekli parametreleri kontrol etmek için şablon başlangıcına bir doğrulama adımı abilirsiniz.

Bash kullanarak parametreyi (herhangi bir solution platformda çalışmasına olanak sağlayan) kontrol etmek için bir örnek burada vemektedir:

# File: steps/msbuild.yml

parameters:
- name: 'solution'
  default: ''
  type: string

steps:
- bash: |
    if [ -z "$SOLUTION" ]; then
      echo "##vso[task.logissue type=error;]Missing template parameter \"solution\""
      echo "##vso[task.complete result=Failed;]"
    fi
  env:
    SOLUTION: ${{ parameters.solution }}
  displayName: Check for required parameters
- task: msbuild@1
  inputs:
    solution: ${{ parameters.solution }}
- task: vstest@2
  inputs:
    solution: ${{ parameters.solution }}

Gerekli parametre eksikse şablonun başarısız olduğunu göstermek için:

# File: azure-pipelines.yml

# This will fail since it doesn't set the "solution" parameter to anything,
# so the template will use its default of an empty string
steps:
- template: steps/msbuild.yml

Şablon ifadesi işlevleri

Şablonlarınız içinde genel işlevleri kullanabilirsiniz. Ayrıca birkaç şablon ifadesi işlevi de kullanabilirsiniz.

biçim

• Basit dize belirteci değiştirme
• En az parametre: 2. En fazla parametre: N
• Örnek: ${{ format('{0} Build', parameters.os) }} → 'Windows Build'

Coalesce

• İlk boş olmayan, null olmayan dize bağımsız değişkenini değerlendirir
• En az parametre: 2. En fazla parametre: N
• Örnek:

parameters:
- name: 'restoreProjects'
  default: ''
  type: string
- name: 'buildProjects'
  default: ''
  type: string

steps:
- script: echo ${{ coalesce(parameters.foo, parameters.bar, 'Nothing to see') }}

Ekleme

YaML işlem hattının yapısını değiştirmek için şablon ifadelerini kullanabilirsiniz. Örneğin, bir diziye eklemek için:

# File: jobs/build.yml

parameters:
- name: 'preBuild'
  type: stepList
  default: []
- name: 'preTest'
  type: stepList
  default: []
- name: 'preSign'
  type: stepList
  default: []

jobs:
- job: Build
  pool:
    vmImage: 'windows-latest'
  steps:
  - script: cred-scan
  - ${{ parameters.preBuild }}
  - task: msbuild@1
  - ${{ parameters.preTest }}
  - task: vstest@2
  - ${{ parameters.preSign }}
  - script: sign

# File: .vsts.ci.yml

jobs:
- template: jobs/build.yml
  parameters:
    preBuild:
    - script: echo hello from pre-build
    preTest:
    - script: echo hello from pre-test

Bir dizi bir diziye ekildiğinde, iç içe geçmiş dizi düzdür.

Bir eşlemeye eklemek için özel özelliğini ${{ insert }} kullanın.

# Default values
parameters:
- name: 'additionalVariables'
  type: object
  default: {}

jobs:
- job: build
  variables:
    configuration: debug
    arch: x86
    ${{ insert }}: ${{ parameters.additionalVariables }}
  steps:
  - task: msbuild@1
  - task: vstest@2

jobs:
- template: jobs/build.yml
  parameters:
    additionalVariables:
      TEST_SUITE: L0,L1

Koşullu ekleme

Koşullu olarak bir diziye veya bir şablonda eşleme eklemek için eklemeleri ve ifade değerlendirmesini kullanın. Şablon söz if dizimi if şablonların dışında da kullanabilirsiniz.

Örneğin, bir şablonda bir diziye eklemek için:

# File: steps/build.yml

parameters:
- name: 'toolset'
  default: msbuild
  type: string
  values:
  - msbuild
  - dotnet

steps:
# msbuild
- ${{ if eq(parameters.toolset, 'msbuild') }}:
  - task: msbuild@1
  - task: vstest@2

# dotnet
- ${{ if eq(parameters.toolset, 'dotnet') }}:
  - task: dotnet@1
    inputs:
      command: build
  - task: dotnet@1
    inputs:
      command: test

# File: azure-pipelines.yml

steps:
- template: steps/build.yml
  parameters:
    toolset: dotnet

Örneğin, bir şablonda eşlemeye eklemek için:

# File: steps/build.yml

parameters:
- name: 'debug'
  type: boolean
  default: false

steps:
- script: tool
  env:
    ${{ if eq(parameters.debug, true) }}:
      TOOL_DEBUG: true
      TOOL_DEBUG_DIR: _dbg

steps:
- template: steps/build.yml
  parameters:
    debug: true

Değişkenler için koşullu ekleme de kullanabilirsiniz. Bu örnekte, her start zaman yazdırır ve yalnızca değişkeni this is a testfoo değerine eşit olduğunda test yazdırır.

variables:
  - name: foo
    value: test

pool:
  vmImage: 'ubuntu-latest'

steps:
- script: echo "start" # always runs
- ${{ if eq(variables.foo, 'test') }}:
  - script: echo "this is a test" # runs when foo=test

Iterative ekleme

eachyönergesi, YAML dizisine (dizi) veya eşlemeye (anahtar-değer çiftleri) dayalı olarak iterative eklemeye izin verir.

Örneğin, her işin adımlarını diğer ön ve son adımlarla sarmaabilirsiniz:

# job.yml
parameters:
- name: 'jobs'
  type: jobList
  default: []

jobs:
- ${{ each job in parameters.jobs }}: # Each job
  - ${{ each pair in job }}:          # Insert all properties other than "steps"
      ${{ if ne(pair.key, 'steps') }}:
        ${{ pair.key }}: ${{ pair.value }}
    steps:                            # Wrap the steps
    - task: SetupMyBuildTools@1       # Pre steps
    - ${{ job.steps }}                # Users steps
    - task: PublishMyTelemetry@1      # Post steps
      condition: always()

# azure-pipelines.yml
jobs:
- template: job.yml
  parameters:
    jobs:
    - job: A
      steps:
      - script: echo This will get sandwiched between SetupMyBuildTools and PublishMyTelemetry.
    - job: B
      steps:
      - script: echo So will this!

Ayrıca, yineleyenin özelliklerini de işebilirsiniz. Örneğin, daha fazla bağımlılık eklemek için:

# job.yml
parameters:
- name: 'jobs'
  type: jobList
  default: []

jobs:
- job: SomeSpecialTool                # Run your special tool in its own job first
  steps:
  - task: RunSpecialTool@1
- ${{ each job in parameters.jobs }}: # Then do each job
  - ${{ each pair in job }}:          # Insert all properties other than "dependsOn"
      ${{ if ne(pair.key, 'dependsOn') }}:
        ${{ pair.key }}: ${{ pair.value }}
    dependsOn:                        # Inject dependency
    - SomeSpecialTool
    - ${{ if job.dependsOn }}:
      - ${{ job.dependsOn }}

# azure-pipelines.yml
jobs:
- template: job.yml
  parameters:
    jobs:
    - job: A
      steps:
      - script: echo This job depends on SomeSpecialTool, even though it's not explicitly shown here.
    - job: B
      dependsOn:
      - A
      steps:
      - script: echo This job depends on both Job A and on SomeSpecialTool.

Bir değerden kaçış

tam anlamıyla içeren bir değerden kaçış karakterine ihtiyacınız ${{ varsa, değeri bir ifade dizesinde sarmalar. Örneğin ${{ 'my${{value' }} veya ${{ 'my${{value with a '' single quote too' }} olabilir.

Dayatılan sınırlar

Şablonlar ve şablon ifadeleri, bir işlem hattının boyutuna ve karmaşıklığına büyük bir artışa neden olabilir. Bu durum, kaçışlı büyümeyi önlemeye Azure Pipelines aşağıdaki sınırları zorlar:

• En fazla 100 ayrı YAML dosyası dahil olabilir (doğrudan veya dolaylı olarak)
• 20'den fazla şablon iç içe yerleştirme düzeyi yoktur (diğer şablonlar dahil olmak üzere şablonlar)
• YAML ayrıştırırken en fazla 10 megabayt bellek tüketilir (kullanılan belirli özelliklere bağlı olarak bu genellikle 600 KB ile 2 MB disk üzerinde YAML arasında olur)

Şablon parametreleri

Parametreleri şablonlara geçebilirsiniz. bölümü, parameters şablonda hangi parametrelerin kullanılabilir olduğunu ve bunların varsayılan değerlerini tanımlar. Şablonlar işlem hattı çalıştırılamadan hemen önce genişletilir, böylece çevrelene değerler, kapsayan işlem hattından aldığı ${{ }} parametrelerle değiştirilir. Sonuç olarak, parametrelerde yalnızca önceden tanımlanmış değişkenler kullanılabilir.

Birden çok işlem hattında parametreleri kullanmak için bkz. değişken grubu oluşturma.

Parametrelerle iş, aşama ve adım şablonları

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

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

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

Şablonu işlem hattında tükettiğiniz zaman, şablon parametreleri için değerleri belirtin.

# 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-10.13'

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

Parametreleri adım veya aşama şablonlarıyla da kullanabilirsiniz. Örneğin, parametreleri olan adımlar:

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

parameters:
  runExtendedTests: 'false'  # defaults for any parameters that aren't specified

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

Şablonu işlem hattında tükettiğiniz zaman, şablon parametreleri için değerleri belirtin.

# File: azure-pipelines.yml

steps:
- script: npm install

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

Parametreler skaler dizelerle sınırlı değildir. Parametrenin genişlet olduğu yer bir eşleme bekliyorsa, parametre bir eşleme olabilir. Benzer şekilde, sıraların beklendiği yere diziler geçirebilirsiniz. Örnek:

# 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:
  pool: {}

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

Diğer depoları kullanma

Şablonlarınızı başka depolarda tutabilirsiniz. Örneğin, tüm uygulama işlem hatlarınızı kullanmak istediğiniz temel bir işlem hattına sahip olduğunu varsayalım. Şablonu bir çekirdek repoya yer ve ardından uygulama repolarından her biri için başvurabilirsiniz:

# Repo: Contoso/BuildTemplates
# File: common.yml
parameters:
  vmImage: 'ubuntu 16.04'

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

Artık bu şablonu birden çok işlem hattında yeniden kullanabilirsiniz. Çekirdek resources repo konumunu sağlamak için belirtimi kullanın. Çekirdek repoya başvurarak içinde @ verdiği adı resources kullanın.

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

İçin type: github , name<identity>/<repo> Yukarıdaki örneklerde olduğu gibidir. type: git(Azure Repos) için, name<project>/<repo> . Proje aynı kuruluşta olmalıdır; çapraz kuruluş başvuruları desteklenmez.

Depolar, işlem hattı başlatıldığında yalnızca bir kez çözümlenir. Bundan sonra, işlem hattı sırasında aynı kaynak kullanılır. Yalnızca şablon dosyaları kullanılır. Şablonlar tamamen genişletildiğinde, son işlem hattı tamamen kaynak deposunda tanımlanmış gibi çalışır. Bu, işlem hattınızdaki şablon deposundan betikleri kullanamayacağı anlamına gelir.

Şablonun belirli, sabit bir sürümünü kullanmak istiyorsanız, bir başvurusuna sabitlediğinizden emin olun. Refs dallardır ( refs/heads/<name> ) veya Etiketler ( refs/tags/<name> ). Belirli bir yürütmeyi sabitlemek istiyorsanız, önce bu yürütmeye işaret eden bir etiket oluşturun, ardından bu etikete sabitleyin.

İfadeler

Ardışık düzen başlatma sırasında değerlerin dinamik olarak nasıl çözümlendiğini belirtmek için şablon ifadelerini kullanın. Şablon ifadenizi bu söz dizimi içinde sarın: ${{ }} .

Şablon ifadeleri, şablon parametrelerini ve ayrıca değişkenleri genişletebilir. Bir şablonun nasıl genişletildiğini etkilemek için parametreleri kullanabilirsiniz. parametersNesnesi bir ifadede parameters gibi çalışacaktır.

Örneğin, bir şablon tanımlarsınız:

# File: steps/msbuild.yml

parameters:
  solution: '**/*.sln'

steps:
- task: msbuild@1
  inputs:
    solution: ${{ parameters['solution'] }}  # index syntax
- task: vstest@2
  inputs:
    solution: ${{ parameters.solution }}  # property dereference syntax

Sonra şablona başvuru ve isteğe bağlı parametreye geçitirsiniz solution :

# File: azure-pipelines.yml

steps:
- template: steps/msbuild.yml
  parameters:
    solution: my.sln

Bağlam

Bir şablon ifadesi içinde, parameters geçirilen parametrelerin değerlerini içeren bağlama erişiminiz vardır. Ayrıca, variables YAML dosyasında belirtilen tüm değişkenleri ve variablesiçeren bağlamına erişebilirsiniz. Daha da önemlisi, işlem hattında depolanan veya bir çalıştırmayı başlattığınızda belirtilen çalışma zamanı değişkenlerine sahip değildir. Şablon genişletmesi çalıştırmada erkenyapılır, bu nedenle bu değişkenler kullanılamaz.

Gerekli parametreler

Gerekli parametreleri denetlemek için şablonunuzun başına bir doğrulama adımı ekleyebilirsiniz.

Aşağıda, solution Bash (herhangi bir platformda çalışmasını sağlayan) parametresini denetleyen bir örnek verilmiştir:

# File: steps/msbuild.yml

parameters:
  solution: ''

steps:
- bash: |
    if [ -z "$SOLUTION" ]; then
      echo "##vso[task.logissue type=error;]Missing template parameter \"solution\""
      echo "##vso[task.complete result=Failed;]"
    fi
  env:
    SOLUTION: ${{ parameters.solution }}
  displayName: Check for required parameters
- task: msbuild@1
  inputs:
    solution: ${{ parameters.solution }}
- task: vstest@2
  inputs:
    solution: ${{ parameters.solution }}

Gerekli parametrenin eksik olması durumunda şablonun başarısız olduğunu göstermek için:

# File: azure-pipelines.yml

# This will fail since it doesn't set the "solution" parameter to anything,
# so the template will use its default of an empty string
steps:
- template: steps/msbuild.yml

Şablon ifadesi işlevleri

Şablonlarınızın genel işlevlerini kullanabilirsiniz. Birkaç şablon ifadesi işlevini de kullanabilirsiniz.

biçim

• Basit dize belirteci değiştirme
• Min parametreleri: 2. En fazla Parametreler: N
• Örnek: ${{ format('{0} Build', parameters.os) }} → 'Windows Build'

Coalesce

• İlk boş olmayan, boş olmayan dize bağımsız değişkeni olarak değerlendirilir
• Min parametreleri: 2. En fazla Parametreler: N
• Örnek:

parameters:
  restoreProjects: ''
  buildProjects: ''

steps:
- script: echo ${{ coalesce(parameters.foo, parameters.bar, 'Nothing to see') }}

Noktasına

Bir YAML işlem hattının yapısını değiştirmek için şablon ifadeleri kullanabilirsiniz. Örneğin, bir diziye eklemek için:

# File: jobs/build.yml

parameters:
  preBuild: []
  preTest: []
  preSign: []

jobs:
- job: Build
  pool:
    vmImage: 'windows-latest'
  steps:
  - script: cred-scan
  - ${{ parameters.preBuild }}
  - task: msbuild@1
  - ${{ parameters.preTest }}
  - task: vstest@2
  - ${{ parameters.preSign }}
  - script: sign

# File: .vsts.ci.yml

jobs:
- template: jobs/build.yml
  parameters:
    preBuild:
    - script: echo hello from pre-build
    preTest:
    - script: echo hello from pre-test

Bir dizi diziye eklendiğinde, iç içe geçmiş dizi düzleştirilir.

Eşlemeye eklemek için özel özelliğini kullanın ${{ insert }} .

# Default values
parameters:
  additionalVariables: {}

jobs:
- job: build
  variables:
    configuration: debug
    arch: x86
    ${{ insert }}: ${{ parameters.additionalVariables }}
  steps:
  - task: msbuild@1
  - task: vstest@2

jobs:
- template: jobs/build.yml
  parameters:
    additionalVariables:
      TEST_SUITE: L0,L1

Koşullu ekleme

Bir diziye veya eşlemeye koşullu olarak eklemek istiyorsanız, Eklenenler ve Expression Evaluation kullanın.

Örneğin, bir diziye eklemek için:

# File: steps/build.yml

parameters:
  toolset: msbuild

steps:
# msbuild
- ${{ if eq(parameters.toolset, 'msbuild') }}:
  - task: msbuild@1
  - task: vstest@2

# dotnet
- ${{ if eq(parameters.toolset, 'dotnet') }}:
  - task: dotnet@1
    inputs:
      command: build
  - task: dotnet@1
    inputs:
      command: test

# File: azure-pipelines.yml

steps:
- template: steps/build.yml
  parameters:
    toolset: dotnet

Örneğin, bir eşlemeye eklemek için:

# File: steps/build.yml

parameters:
  debug: false

steps:
- script: tool
  env:
    ${{ if eq(parameters.debug, 'true') }}:
      TOOL_DEBUG: true
      TOOL_DEBUG_DIR: _dbg

steps:
- template: steps/build.yml
  parameters:
    debug: true

Yinelemeli ekleme

eachYönergesi, YAML dizisine (dizi) veya eşlemeye (anahtar-değer çiftleri) göre yinelemeli ekleme sağlar.

Örneğin, her bir işin adımını ek ön ve son adımla kaydırabilirsiniz:

# job.yml
parameters:
  jobs: []

jobs:
- ${{ each job in parameters.jobs }}: # Each job
  - ${{ each pair in job }}:          # Insert all properties other than "steps"
      ${{ if ne(pair.key, 'steps') }}:
        ${{ pair.key }}: ${{ pair.value }}
    steps:                            # Wrap the steps
    - task: SetupMyBuildTools@1       # Pre steps
    - ${{ job.steps }}                # Users steps
    - task: PublishMyTelemetry@1      # Post steps
      condition: always()

# azure-pipelines.yml
jobs:
- template: job.yml
  parameters:
    jobs:
    - job: A
      steps:
      - script: echo This will get sandwiched between SetupMyBuildTools and PublishMyTelemetry.
    - job: B
      steps:
      - script: echo So will this!

Ayrıca, yinelediğiniz her türlü özelliği de düzenleyebilirsiniz. Örneğin, daha fazla bağımlılık eklemek için:

# job.yml
parameters:
  jobs: []

jobs:
- job: SomeSpecialTool                # Run your special tool in its own job first
  steps:
  - task: RunSpecialTool@1
- ${{ each job in parameters.jobs }}: # Then do each job
  - ${{ each pair in job }}:          # Insert all properties other than "dependsOn"
      ${{ if ne(pair.key, 'dependsOn') }}:
        ${{ pair.key }}: ${{ pair.value }}
    dependsOn:                        # Inject dependency
    - SomeSpecialTool
    - ${{ if job.dependsOn }}:
      - ${{ job.dependsOn }}

# azure-pipelines.yml
jobs:
- template: job.yml
  parameters:
    jobs:
    - job: A
      steps:
      - script: echo This job depends on SomeSpecialTool, even though it's not explicitly shown here.
    - job: B
      dependsOn:
      - A
      steps:
      - script: echo This job depends on both Job A and on SomeSpecialTool.

Kaçış

Tam olarak içeren bir değeri kaçış yapmanız gerekiyorsa ${{ , değeri bir ifade dizesinde sarın. Örneğin ${{ 'my${{value' }} veya ${{ 'my${{value with a '' single quote too' }} olabilir.

Sınırlar

Şablonlar ve şablon ifadeleri, bir işlem hattının boyutuna ve karmaşıklığına patlayıcı büyüme oluşmasına neden olabilir. Azure Pipelines, ard arda büyümesini önlemeye yardımcı olmak için aşağıdaki limitleri uygular:

• 50 'den fazla farklı YAML dosyası dahil edilebilir (doğrudan veya dolaylı olarak)
• YAML ayrıştırılırken 10 megabayttan fazla bellek tüketti (uygulamada, kullanılan belirli özelliklere bağlı olarak, bu genellikle 600 KB-2 MB 'lık bir disk üzerinde).
• Şablon ifadesine göre 2000 karakterden fazlasına izin verilmiyor