Compartilhar via

Parâmetros de runtime

  • Artigo

Azure DevOps Services | Azure DevOps Server 2022 | Azure DevOps Server 2020

Os parâmetros de runtime permitem que você tenha mais controle sobre quais valores podem ser passados para um pipeline. Com parâmetros de runtime, você pode:

  • Fornecer valores diferentes para scripts e tarefas em runtime
  • Tipos de parâmetros de controle, intervalos permitidos e padrões
  • Selecionar dinamicamente trabalhos e estágios com expressões de modelo

Você pode especificar parâmetros em modelos e no pipeline. Os parâmetros têm tipos de dados como e string e podem ser restritos a um subconjunto de valores. A seção parameters em um YAML define quais parâmetros estão disponíveis.

Os parâmetros só estão disponíveis no momento da análise do modelo. Os parâmetros são expandidos pouco antes da execução do pipeline para que os valores cercados por ${{ }} sejam substituídos por valores de parâmetro. Use variáveis se precisar que seus valores estejam mais amplamente disponíveis durante a execução de pipeline.

Observação

Essas diretrizes não se aplicam a pipelines clássicos. Para parâmetros em pipelines clássicos, confira Parâmetros de processo (clássico).

Os parâmetros devem conter um nome e um tipo de dados. Os parâmetros não podem ser opcionais. Um valor padrão precisa ser atribuído no arquivo YAML ou quando você executa o pipeline. Se você não atribuir um valor padrão ou definir default como false, o primeiro valor disponível será usado.

Use templateContext para passar propriedades extras para fases, etapas e trabalhos que são usados como parâmetros em um modelo.

Usar parâmetros em pipelines

Defina parâmetros de runtime no início de um YAML.

Esse pipeline de exemplo inclui um parâmetro image com três agentes hospedados como opções string. Na seção trabalhos, o valor pool especifica o agente do parâmetro usado para executar o trabalho. O trigger é definido como nenhum para que você possa selecionar o valor de image ao disparar manualmente o pipeline para execução.

parameters:
- name: image
  displayName: Pool Image
  type: string
  default: ubuntu-latest
  values:
  - windows-latest
  - ubuntu-latest
  - macOS-latest

trigger: none

jobs:
- job: build
  displayName: build
  pool: 
    vmImage: ${{ parameters.image }}
  steps:
  - script: echo building $(Build.BuildNumber) with ${{ parameters.image }}

Na página de execuções de pipeline, selecione Executar pipeline para executar o pipeline. Você verá a opção de selecionar a imagem da piscina. Se você não fizer uma seleção, a opção padrão ubuntu-latest será usada. Você não terá a opção de selecionar uma imagem de pool se executar o pipeline no editor YAML.

Parâmetros de runtime

Usar condicionais com parâmetros

Você também pode usar parâmetros como parte da lógica condicional. Com condicionais, parte de um YAML será executada se atender aos critérios if.

Usar parâmetros para determinar quais etapas são executadas

Esse pipeline adiciona um segundo parâmetro booliano, test, que pode ser usado para controlar se os testes devem ou não ser executados no pipeline. Quando o valor de test é true, a etapa que gera Executar todos os testes é executada.

parameters:
- name: image
  displayName: Pool Image
  values:
  - windows-latest
  - ubuntu-latest
  - macOS-latest
- name: test
  displayName: Run Tests?
  type: boolean
  default: false

trigger: none

jobs:
- job: build
  displayName: Build and Test
  pool: 
    vmImage: ${{ parameters.image }}
  steps:
  - script: echo building $(Build.BuildNumber)
  - ${{ if eq(parameters.test, true) }}:
    - script: echo "Running all the tests"

Usar parâmetros para definir qual configuração é usada

Você também pode usar parâmetros para definir quais trabalhos são executados. Neste exemplo, diferentes arquiteturas são compiladas dependendo do valor do parâmetro config, que é um tipo string. Por padrão, as arquiteturas x86 e x64 são criadas.

parameters:
- name: configs
  type: string
  default: 'x86,x64'

trigger: none

jobs:
- ${{ if contains(parameters.configs, 'x86') }}:
  - job: x86
    steps:
    - script: echo Building x86...
- ${{ if contains(parameters.configs, 'x64') }}:
  - job: x64
    steps:
    - script: echo Building x64...
- ${{ if contains(parameters.configs, 'arm') }}:
  - job: arm
    steps:
    - script: echo Building arm...

Excluir seletivamente uma fase

Você também pode usar parâmetros para definir se uma fase é executada. Neste exemplo, há um pipeline com quatro fases e trabalhos diferentes para cada fase. A fase teste de desempenho será executada se o parâmetro runPerfTests for true. O valor padrão de runPerfTests é false, portanto, sem nenhuma atualização, apenas três dos quatro estágios são executados.

parameters:
- name: runPerfTests
  type: boolean
  default: false

trigger: none

stages:
- stage: Build
  displayName: Build
  jobs:
  - job: Build
    steps:
    - script: echo running Build


- stage: UnitTest
  displayName: Unit Test
  dependsOn: Build
  jobs:
  - job: UnitTest
    steps:
    - script: echo running UnitTest


- ${{ if eq(parameters.runPerfTests, true) }}:
  - stage: PerfTest
    displayName: Performance Test
    dependsOn: Build
    jobs:
    - job: PerfTest
      steps:
      - script: echo running PerfTest


- stage: Deploy
  displayName: Deploy
  dependsOn: UnitTest
  jobs:
  - job: Deploy
    steps:
    - script: echo running UnitTest

Executar um loop por meio de parâmetros

Você também pode executar um loop pelos parâmetros de cadeia de caracteres, número e booliano.

Neste exemplo, você executa um loop pelos parâmetros e imprime o nome e o valor de cada parâmetro. Há quatro parâmetros diferentes e cada um representa um tipo diferente. myStringName é uma cadeia de caracteres de linha única. myMultiString é uma cadeia de caracteres de várias linhas. myNumber is a number. myBoolean é um valor booliano. Na seção de etapas, as tarefas de script geram a chave e o valor de cada parâmetro.

# start.yaml
parameters:
- name: myStringName
  type: string
  default: a string value
- 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

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

# azure-pipeline.yaml
trigger: none

extends:
  template: start.yaml

Verificar se há um objeto de parâmetro vazio

Você pode usar a length() expressão para verificar se um parâmetro de objeto não tem valor.

parameters:
- name: foo
  type: object
  default: []

steps:
- checkout: none
- ${{ if eq(length(parameters.foo), 0) }}:
  - script: echo Foo is empty
    displayName: Foo is empty

Inclua dinamicamente uma lista de etapas com o parâmetro stepList

Neste exemplo, o tipo de parâmetro stepList é usado para incluir dinamicamente uma lista de etapas no processo de compilação.

  • O pipeline principal (azure-pipelines.yml) define dois trabalhos: build e deploy.
  • O trabalho de compilação usa um modelo (build.yml) e passa uma lista de tarefas de compilação usando o parâmetro stepList.
  • O modelo build.yml inclui dinamicamente as etapas definidas no parâmetro 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

O modelo build.yml:

  • Define o parâmetro build_tasks com o tipo stepList e uma lista vazia padrão.
  • Define o SDK do .NET Core como 6.x.
  • Itera em cada etapa do parâmetro build_tasks.
  • Executa cada etapa definida na lista build_tasks.
#build.yml

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

steps:
  - task: UseDotNet@2
    displayName: 'Use .NET Core SDK'
    inputs:
      packageType: 'sdk'
      version: '6.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'

Tipos de dados do parâmetro

Tipo de dados Observações
string string
number pode ser restrito a values:, caso contrário, qualquer cadeia de caracteres semelhante a número será aceita
boolean true ou false
object qualquer estrutura do YAML
step uma etapa única
stepList sequência de etapas
job um trabalho único
jobList sequência de trabalhos
deployment um trabalho de implantação única
deploymentList sequência de trabalhos de implantação
stage uma fase única
stageList sequência de fases

Os tipos de dados de fase, stepList, trabalho, jobList, implantação, deploymentList, fase e stageList usam o formato de esquema YAML padrão. Este exemplo inclui cadeia de caracteres, número, booliano, objeto, etapa e 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