Utiliser des modèles YAML dans des pipelines pour des processus réutilisables et sécurisés

Pour renforcer la sécurité, vous pouvez appliquer qu’un pipeline s’étend à partir d’un modèle particulier. Le fichier start-extends-template.yml définit le paramètre buildSteps, qui est ensuite utilisé dans le pipeline azure-pipelines.yml. Dans start-extends-template.yml, si un buildStep est passé avec une étape de script, il est rejeté et la build du pipeline échoue. Lors de l’extension à partir d’un modèle, vous pouvez augmenter la sécurité en ajoutant une approbation de modèle requise.

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

Étendre à partir d’un modèle avec des ressources

Vous pouvez également utiliser extends pour étendre à partir d’un modèle dans votre pipeline Azure qui contient des ressources.

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

Vous pouvez insérer du contenu à partir d’un yaML et le réutiliser dans un autre YAML. L’insertion de contenu d’un YAML vers un autre vous permet d’inclure manuellement la même logique à plusieurs emplacements. Le insert-npm-steps.yml modèle de fichier contient des étapes qui sont réutilisées dans azure-pipelines.yml.

# 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

Réutiliser les étapes de plusieurs travaux

Vous pouvez insérer un modèle pour réutiliser une ou plusieurs étapes dans plusieurs travaux. En plus des étapes du modèle, chaque travail peut définir d’autres étapes.

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

Réutiliser des travaux sur plusieurs modèles

Tout comme les étapes, les travaux peuvent être réutilisés avec des modèles.

# 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

Lorsque vous travaillez avec plusieurs travaux, n’oubliez pas de supprimer le nom du travail dans le fichier de modèle, afin d’éviter les conflits

# 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

Réutiliser des phases sur plusieurs modèles

Les phases peuvent également être réutilisées avec des modèles.

# 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

Ajouter des paramètres aux modèles de travail, d’étape et d’étape

Dans les modèles suivants :

• templates/npm-with-params.yml définit deux paramètres : name et vmImage et crée une tâche avec le paramètre name pour le nom de la tâche et le paramètre vmImage pour l’image VM.
• Le pipeline (azure-pipelines.yml) fait référence au modèle trois fois, chacun avec des valeurs de paramètres différentes se référant au système d’exploitation et aux noms d’images VM.
• Le pipeline construit s’exécute sur une image VM différente et est nommé en fonction du système d’exploitation spécifié. Chaque tâche exécute les étapes npm install et npm test.

# 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

Lorsque vous utilisez le modèle dans votre pipeline, spécifiez des valeurs pour les paramètres du modèle.

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

Modèles de stage avec plusieurs paramètres

Dans les modèles suivants :

• Le modèle stage-template.yml définit quatre paramètres : stageName, jobName, vmImage, et scriptPath, tous de type string. Le modèle crée un stage en utilisant le paramètre stageName pour définir le nom du stage, définit une tâche avec jobName et inclut une étape pour exécuter un script.
• Le pipeline, azure-pipeline.yml, définit ensuite dynamiquement des stages et des tâches en utilisant des paramètres et exécute une tâche qui exécute 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'

Modèles avec des étapes et des paramètres

Vous pouvez également utiliser des paramètres avec des modèles d’étape ou de phase.

Dans les modèles suivants :

• Le modèle (templates/steps-with-params.yml) définit un paramètre nommé runExtendedTests avec une valeur par défaut de false.
• Le pipeline (azure-pipelines.yml) exécute npm test et npm test --extended parce que le paramètre runExtendedTests est vrai.

# 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

Lorsque vous utilisez le modèle dans votre pipeline, spécifiez des valeurs pour les paramètres du modèle.

# File: azure-pipelines.yml

steps:
- script: npm install

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

Les paramètres ne sont pas limités aux chaînes scalaires. Consultez la liste des types de données. Par exemple, à l’aide du type 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 }}

Réutilisation des variables

Les variables peuvent être définies dans un YAML et incluses dans un autre modèle. Cela peut être utile si vous souhaitez stocker toutes vos variables dans un seul fichier. Si vous utilisez un modèle pour inclure des variables dans un pipeline, le modèle inclus ne peut être utilisé que pour définir des variables. Vous pouvez utiliser des étapes et une logique plus complexe lorsque vous étendez à partir d’un modèle.

Dans cet exemple, la variable favoriteVeggie est incluse dans azure-pipelines.yml.

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

Modèles de variables avec des paramètres

Vous pouvez passer des paramètres à des variables avec des modèles. Dans cet exemple, vous transmettez le DIRECTORY paramètre à une RELEASE_COMMAND variable.

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

Lorsque vous utilisez le modèle dans votre pipeline, spécifiez des valeurs pour les paramètres du modèle.

# 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