Referencia de uso de la plantilla

Para aumentar la seguridad, puede aplicar que una canalización se extienda desde una plantilla determinada. El archivo start.yml define el parámetro buildSteps, que luego se usa en la canalización azure-pipelines.yml. En start.yml, si buildStep se pasa con un paso de script, se rechaza y se produce un error en la compilación de canalización. Al extender desde una plantilla, puede aumentar la seguridad agregando una aprobación de plantilla necesaria.

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

Extensión desde una plantilla con recursos

También puede usar extends para ampliar desde una plantilla de la canalización de Azure que contenga recursos.

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

Puede copiar contenido de un YAML y reutilizarlo en otro YAML. Copiar contenido de un YAML a otro le ahorra tener que incluir manualmente la misma lógica en varios lugares. La plantilla de archivo include-npm-steps.yml contiene pasos que se reutilizan en azure-pipelines.yml.

# 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

Reutilización de pasos

Puede insertar una plantilla para reutilizar uno o varios pasos en varios trabajos. Además de los pasos de la plantilla, cada trabajo puede definir más pasos.

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

Reutilización de trabajos

Al igual que los pasos, los trabajos se pueden reutilizar con plantillas.

# 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

Al trabajar con varios trabajos, recuerde quitar el nombre del trabajo en el archivo de plantilla para evitar conflictos

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

Reutilización de fases

Las fases también se pueden reutilizar con plantillas.

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

pool:
  vmImage: 'ubuntu-latest'

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

Plantillas de trabajo, fases y pasos con parámetros

En las plantillas siguientes:

• templates/npm-with-params.yml define dos parámetros: name y vmImage crea un trabajo con el parámetro name para el nombre del trabajo y el parámetro vmImage para la imagen de máquina virtual.
• La canalización (azure-pipelines.yml) hace referencia a la plantilla tres veces, cada una con valores de parámetros diferentes que hacen referencia a los nombres de imagen de máquina virtual y del sistema operativo.
• La canalización compilada se ejecuta en una imagen de máquina virtual diferente y se denomina según el sistema operativo especificado. Cada trabajo realiza los pasos de prueba de npm install y npm.

# 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

Al consumir la plantilla en la canalización, especifique valores para los parámetros de plantilla.

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

Plantillas de fase con varios parámetros

En las plantillas siguientes:

• La plantilla stage-template.yml define cuatro parámetros: stageName, jobName, vmImage y scriptPath, todos de tipo cadena. La plantilla crea una fase mediante el parámetro stageName para establecer el nombre de la fase, define un trabajo con jobName e incluye un paso para ejecutar un script.
• A continuación, la canalización azure-pipeline.yml define dinámicamente fases y trabajos mediante parámetros y ejecuta un trabajo que ejecuta un script, build-script.sh.

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

Plantillas con pasos y parámetros

También puede usar parámetros con plantillas de paso o fase.

En las plantillas siguientes:

• La plantilla (templates/steps-with-params.yml) define un parámetro denominado runExtendedTests con un valor predeterminado de false.
• La canalización (azure-pipelines.yml) ejecuta npm test y npm test --extended porque el parámetro runExtendedTests es true.

# 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

Al consumir la plantilla en la canalización, especifique valores para los parámetros de plantilla.

# File: azure-pipelines.yml

steps:
- script: npm install

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

Los parámetros no se limitan a las cadenas escalares. Consulte la lista de tipos de datos. Por ejemplo, con el tipo object:

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

Reutilización de variables

Las variables se pueden definir en un YAML e incluirse en otra plantilla. Esto podría ser útil si desea almacenar todas las variables en un archivo. Si usa una plantilla para incluir variables en una canalización, la plantilla incluida solo se puede usar para definir variables. Puede usar pasos y lógica más compleja al extender desde una plantilla. Use parámetros en lugar de variables cuando desee restringir el tipo.

En este ejemplo, la variable favoriteVeggie se incluye en azure-pipelines.yml.

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

Plantillas de variables con parámetro

Puede pasar parámetros a variables con plantillas. En este ejemplo, va a pasar el parámetro DIRECTORY a una variable RELEASE_COMMAND.

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

Al consumir la plantilla en la canalización, especifique valores para los parámetros de plantilla.

# 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