Mallparametrar

Du kan ange parametrar och deras datatyper i en mall och referera till dessa parametrar i en pipeline. Med templateContext kan du också skicka egenskaper till steg, steg och jobb som används som parametrar i en mall.

Du kan också använda parametrar utanför mallar. Du kan bara använda literaler för parameterstandardvärden. Läs mer om parametrar i YAML-schemat.

Överföra parametrar

Parametrarna måste innehålla ett namn och en datatyp. I azure-pipelines.yml, om parametern yesNo är inställd på ett booleskt värde, lyckas bygget. Om yesNo är inställt på en sträng som applesmisslyckas bygget.

# 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:
- main

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

Använda templateContext för att skicka egenskaper till mallar

Du kan använda templateContext för att skicka fler egenskaper till steg, steg och jobb som används som parametrar i en mall. Mer specifikt kan du ange templateContext inom datatypen för parametern jobList, deploymentList eller stageList.

templateContext gör det enklare att konfigurera miljöer vid bearbetning av varje jobb. Genom att kombinera ett jobb och dess miljöegenskaper, hjälper templateContext att skapa YAML som är lättare att underhålla och förstå.

I det här exemplet har parametern testSet i testing-template.yml datatypen jobList. Mallen testing-template.yml skapar en ny variabel testJob med hjälp av varje nyckelord. Mallen refererar sedan till testJob.templateContext.expectedHTTPResponseCode, som anges i azure-pipeline.yml och skickas till mallen.

När svarskoden är 200 gör mallen en REST-begäran. När svarskoden är 500 matar mallen ut alla miljövariabler för felsökning.

templateContext kan innehålla egenskaper.

#testing-template.yml

parameters: 
- name: testSet
  type: jobList

jobs:
- ${{ each testJob in parameters.testSet }}:  # Iterate over each job in the 'testSet' parameter
  - ${{ if eq(testJob.templateContext.expectedHTTPResponseCode, 200) }}: # Check if the HTTP response is 200
    - job:
      steps: 
      - powershell: 'Invoke-RestMethod -Uri https://blogs.msdn.microsoft.com/powershell/feed/ | Format-Table -Property Title, pubDate'
      - ${{ testJob.steps }}    
  - ${{ if eq(testJob.templateContext.expectedHTTPResponseCode, 500) }}: # Check if the HTTP response is 500
    - job:
      steps:
      - powershell: 'Get-ChildItem -Path Env:\' # Run a PowerShell script to list environment variables
      - ${{ testJob.steps }} # Include additional steps from the 'testJob' object

#azure-pipeline.yml

trigger: none

pool:
  vmImage: ubuntu-latest

extends:
  template: testing-template.yml 
  parameters:
    testSet:  # Define the 'testSet' parameter to pass to the template
    - job: positive_test # Define a job named 'positive_test'
      templateContext:
        expectedHTTPResponseCode: 200 # Set the expected HTTP response code to 200 for this job
      steps:
      - script: echo "Run positive test" 
    - job: negative_test # Define a job named 'negative_test'
      templateContext:
        expectedHTTPResponseCode: 500 # Set the expected HTTP response code to 500 for this job
      steps:
      - script: echo "Run negative test" 

Parametrar för att välja en mall under körning

Du kan anropa olika mallar från en YAML-pipeline beroende på ett villkor. I det här exemplet experimental.yml körs YAML när parametern experimentalTemplate är sann.

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

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

Parameterdatatyper

Datatyperna step, , stepListjob, jobList, deploymentdeploymentList, stageoch stringListanvänder stageList yaml-standardschemaformat. I det här exemplet ingår string, number, boolean, object, stepoch stepList.

parameters:
- name: myString  # Define a parameter named 'myString'
  type: string  # The parameter type is string
  default: a string  # Default value is 'a string'

- name: myMultiString  # Define a parameter named 'myMultiString'
  type: string  # The parameter type is string
  default: default  # Default value is 'default', only one default
  values:  # Allowed values for 'myMultiString'
  - default  
  - ubuntu  

- name: myStringlist # Define a parameter named 'myStringlist'
  type: stringList # The parameter type is stringList
  displayName: Regions
  values: # Allowed values for 'myStringlist'
    - WUS
    - CUS
    - EUS
  default: # Default values
    - WUS
    - CUS
    
- name: myNumber  # Define a parameter named 'myNumber'
  type: number  # The parameter type is number
  default: 2  # Default value is 2
  values:  # Allowed values for 'myNumber'
  - 1  
  - 2  
  - 4  
  - 8  
  - 16  

- name: myBoolean  # Define a parameter named 'myBoolean'
  type: boolean  # The parameter type is boolean
  default: true  # Default value is true

- name: myObject  # Define a parameter named 'myObject'
  type: object  # The parameter type is object
  default:  # Default value is an object with nested properties
    foo: FOO  # Property 'foo' with value 'FOO'
    bar: BAR  # Property 'bar' with value 'BAR'
    things:  # Property 'things' is a list
    - one  
    - two  
    - three  
    nested:  # Property 'nested' is an object
      one: apple  # Property 'one' with value 'apple'
      two: pear  # Property 'two' with value 'pear'
      count: 3  # Property 'count' with value 3

- name: myStep  # Define a parameter named 'myStep'
  type: step  # The parameter type is step
  default:  # Default value is a step
    script: echo my step 

- name: mySteplist  # Define a parameter named 'mySteplist'
  type: stepList  # The parameter type is stepList
  default:  # Default value is a list of steps
    - script: echo step one  
    - script: echo step two  
    
trigger: none  

jobs: 
- job: stepList  # Define a job named 'stepList'
  steps: ${{ parameters.mySteplist }}  # Use the steps from the 'mySteplist' parameter

- job: myStep  # Define a job named 'myStep'
  steps:
    - ${{ parameters.myStep }}  # Use the step from the 'myStep' parameter

- job: stringList  # Define a job named 'stringList'
  steps:
  - ${{ each region in parameters.myStringlist }}:
      - script: echo ${{region}}

Iterera genom parametrar och deras datatyper

Med Azure Pipelines kan du iterera genom parametrar för olika datatyper, till exempel strängar, objekt, tal och booleska värden. Den här flexibiliteten möjliggör dynamiskt pipelinebeteende baserat på parametervärden. Nedan visas exempel som visar hur du itererar genom parametrar och hanterar olika datatyper.

Iterera genom enkla parametrar

Du kan loopa igenom enkla parametrar som strängar, tal och booleska värden. I det här exemplet itererar pipelinen genom en lista med parametrar och skriver ut deras namn och värden.

# start.yaml
parameters:
- name: myStringName
  type: string
  default: a string value
- name: myNumber
  type: number
  default: 2
- name: myBoolean
  type: boolean
  default: true

steps: 
- ${{ each parameter in parameters }}:
  - script: echo ${{ parameter.Key }} 
  - script: echo ${{ parameter.Value }}

# azure-pipeline.yaml
trigger: none

extends:
  template: start.yaml

Iterera genom objekten

Med objekt kan du definiera komplexa parameterstrukturer, till exempel kapslade element. Du kan iterera genom objekt för att komma åt deras nycklar och värden eller kapslade egenskaper.

Exempel: Iterera genom objektnycklar och värden

Följande mallfil definierar parametern myObject som ett objekt med standardnyckel/värde-par. Jobbet itererar genom nycklarna och skriver ut deras värden.

# object-keys-template.yml

parameters:
  - name: myObject
    type: object
    default:
      key1: 'value1'
      key2: 'value2'
      key3: 'value3'

jobs:
- job: ExampleJob
  displayName: 'Example object parameter job'
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: |
      echo "Keys in myObject:"
      echo "Key1: ${{ parameters.myObject.key1 }}"
      echo "Key2: ${{ parameters.myObject.key2 }}"
      echo "Key3: ${{ parameters.myObject.key3 }}"
    displayName: 'Display object keys and values'

Pipelinen åsidosätter myObject:s standardvärden med anpassade värden.

# azure-pipelines.yml

trigger:
- main

extends:
  template: object-keys-template.yml
  parameters:
    myObject:
      key1: 'customValue1'
      key2: 'customValue2'
      key3: 'customValue3'

Exempel: Iterera genom kapslade objekt

Mallen definierar en listOfFruits parameter som innehåller objekt med kapslade matriser och använder sedan kapslade loopar för att bearbeta varje frukt och dess associerade färger.

# File: nested-objects-template.yml

parameters:
- name: listOfFruits
  type: object
  default:
  - fruitName: 'apple'
    colors: ['red', 'green']
  - fruitName: 'lemon'
    colors: ['yellow']

steps:
- ${{ each fruit in parameters.listOfFruits }}: # Iterate over each fruit in the 'listOfFruits'
  - ${{ each fruitColor in fruit.colors }}: # Iterate over each color in the current fruit's colors
    - script: echo ${{ fruit.fruitName }} ${{ fruitColor }} # Echo the current fruit's name and color

Pipeline-filen visar hur man kan åsidosätta standardvärdena med anpassade fruktdata.

# File: azure-pipelines.yml

trigger:
- main

extends:
  template: nested-objects-template.yml
  parameters:
    listOfFruits:
    - fruitName: 'banana'
      colors: ['yellow']
    - fruitName: 'grape'
      colors: ['purple', 'green']

Inkludera en lista med steg dynamiskt med parametern stepList

I det här exemplet stepList används parametertypen för att dynamiskt inkludera en lista med steg i byggprocessen.

• Huvudpipelinen (azure-pipelines.yml) definierar två jobb: skapa och distribuera.
• Byggjobbet använder en mall (build.yml) och skickar en lista över bygguppgifter med hjälp av parametern stepList .
• Mallen build.yml innehåller dynamiskt de steg som definierats i parametern build_tasks .

#azure-pipelines.yml

trigger:
- main

jobs:
  - job: build
    displayName: 'Build .NET Core Application'
    pool:
      vmImage: 'ubuntu-latest'

    steps:
      - checkout: self

      - template: build.yml
        parameters:
          build_tasks:
            - task: DotNetCoreCLI@2
              displayName: 'Restore'
              inputs:
                command: 'restore'
                projects: '**/*.csproj'  

            - task: DotNetCoreCLI@2
              displayName: 'Build'
              inputs:
                command: 'build'
                arguments: '--no-restore'
                projects: '**/*.csproj' 

  - job: deploy
    displayName: 'Pack for Azure App Service deployment'
    dependsOn: build
    pool:
      vmImage: 'ubuntu-latest'
    steps:
      - download: current
        artifact: drop

Mallen: build.yml

• Definierar parametern build_tasks med stepList-typen och en tom standardlista.
• Anger .NET Core SDK till 8.x.
• Itererar över varje steg i parametern build_tasks .
• Kör varje steg som definierats i build_tasks listan.

#build.yml

parameters:
  - name: build_tasks
    type: stepList
    default: []

steps:
  - task: UseDotNet@2
    displayName: 'Use .NET Core SDK'
    inputs:
      packageType: 'sdk'
      version: '8.x'

  - ${{ each step in parameters.build_tasks }}:
      - ${{ step }}

  - task: DotNetCoreCLI@2
    displayName: 'Publish'
    inputs:
      command: 'publish'
      arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)'
      projects: '**/*.csproj'

  - task: PublishBuildArtifacts@1
    displayName: 'Publish Artifact'
    inputs:
      PathtoPublish: '$(Build.ArtifactStagingDirectory)'
      ArtifactName: 'drop'