Parámetros de plantilla

Puede especificar parámetros y sus tipos de datos en una plantilla y hacer referencia a esos parámetros en una canalización. Con templateContext, también puede pasar propiedades a fases, pasos y trabajos que se usan como parámetros en una plantilla.

También puede usar parámetros fuera de las plantillas. Solo puede usar literales para los valores predeterminados del parámetro. Más información sobre los parámetros del esquema de YAML.

Pasar parámetros

Los parámetros deben contener un nombre y un tipo de datos. En azure-pipelines.yml, cuando el parámetro yesNo se establece en un valor booleano, la compilación se realiza correctamente. Cuando yesNo se establece en una cadena como apples, se produce un error en la compilación.

# 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

Uso de templateContext para pasar propiedades a plantillas

Puede usar templateContext para pasar más propiedades a fases, pasos y trabajos que se usan como parámetros en una plantilla. En concreto, puede especificar templateContext dentro del tipo de datos de parámetro jobList, deploymentListo stageList.

Puede usar templateContext para facilitar la configuración de entornos al procesar cada trabajo. Al agrupar un trabajo y su objeto de propiedades de entorno, templateContext puede ayudarle a tener más fácil de mantener y comprender el YAML.

En este ejemplo, el parámetro testSet de testing-template.yml tiene el tipo jobList de datos. La plantilla testing-template.yml crea una variable testJob con la palabra clave each. A continuación, la plantilla hace referencia a testJob.templateContext.expectedHTTPResponseCode, que se establece en azure-pipeline.yml y se pasa a la plantilla.

Cuando el código de respuesta es 200, la plantilla realiza una solicitud REST. Cuando el código de respuesta es 500, la plantilla genera todas las variables de entorno para la depuración.

templateContext puede contener propiedades.

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

Parámetros para seleccionar una plantilla en tiempo de ejecución

Puede llamar a diferentes plantillas de una canalización YAML en función de una condición. En este ejemplo, el YAML experimental.yml se ejecuta cuando el parámetro experimentalTemplate es true.

#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

Tipos de datos de parámetro

Tipo de datos	Notas
string	string
number	se puede restringir a values:; de lo contrario, se aceptará cualquier cadena de tipo numérico.
boolean	true o false
object	cualquier estructura YAML
step	un solo paso
stepList	secuencia de pasos
job	un solo trabajo
jobList	secuencia de trabajos
deployment	un único trabajo de implementación
deploymentList	secuencia de trabajos de implementación
stage	una sola fase
stageList	la secuencia de fases

Los tipos de datos stepList, job, jobList, deployment, deploymentList, stage y stageList usan el formato de esquema YAML estándar. En este ejemplo se incluyen string, number, boolean, object, step y 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'
  values:  # Allowed values for 'myMultiString'
  - default  
  - ubuntu  

- 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

Puede recorrer en iteración un objeto e imprimir cada cadena del objeto .

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

steps:
- ${{ each value in parameters.listOfStrings }}: # Iterate over each value in the 'listOfStrings' parameter
  - script: echo ${{ value }} # Output the current value in the iteration

Además, puede recorrer en iteración los elementos anidados dentro de un objeto.

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

También puede hacer referencia directamente a las claves de un objeto y a los valores correspondientes.

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'

Parámetros obligatorios

Puede agregar un paso de validación al principio de la plantilla para comprobar los parámetros que necesita.

Este es un ejemplo que comprueba el parámetro solution mediante Bash:

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

Para mostrar que se produce un error en la plantilla si falta el parámetro necesario:

# 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