Lägga till faser, beroenden och villkor

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019 | TFS 2018

Kommentar

Microsoft Visual Studio Team Foundation Server 2018 och tidigare versioner har följande skillnader i namngivning:

  • Pipelines för build och release kallas definitioner
  • Körningar kallas byggen
  • Tjänstanslutningar kallas tjänstslutpunkter
  • Faser kallas miljöer
  • Jobb kallas faser

En fas är en logisk gräns i en Azure DevOps-pipeline. Steg kan användas för att gruppera åtgärder i din programutvecklingsprocess (till exempel skapa appen, köra tester, distribuera till förproduktion). Varje steg innehåller ett eller flera jobb.

När du definierar flera steg i en pipeline körs de som standard en efter en. Steg kan också vara beroende av varandra. Du kan använda nyckelordet dependsOn för att definiera beroenden. Faser kan också köras baserat på resultatet av en tidigare fas med villkor.

Information om hur faser fungerar med parallella jobb och licensiering finns i Konfigurera och betala för parallella jobb.

Information om hur faser relaterar till andra delar av en pipeline, till exempel jobb, finns i Viktiga pipelines-begrepp.

Du kan också lära dig mer om hur faser relaterar till delar av en pipeline i yaml-schemastegsartikeln.

Du kan organisera pipelinejobb i faser. Steg är de viktigaste divisionerna i en pipeline: skapa den här appen, kör dessa tester och distribuera till förproduktion är bra exempel på steg. Det är logiska gränser i pipelinen där du kan pausa pipelinen och utföra olika kontroller.

Varje pipeline har minst ett steg även om du inte uttryckligen definierar den. Du kan också ordna faser i ett beroendediagram så att en fas körs före en annan. Det finns en gräns på 256 jobb för en fas.

Kommentar

Stöd för faser har lagts till i Azure DevOps Server 2019.1.

Den här versionen av TFS stöder inte YAML.

Ange faser

Kommentar

Stöd för faser har lagts till i Azure DevOps Server 2019.1.

I det enklaste fallet behöver du inga logiska gränser i pipelinen. I så fall behöver du inte uttryckligen använda nyckelordet stage . Du kan ange jobben direkt i YAML-filen.

# this has one implicit stage and one implicit job
pool:
  vmImage: 'ubuntu-latest'
steps:
- bash: echo "Hello world"
# this pipeline has one implicit stage
jobs:
- job: A
  steps:
  - bash: echo "A"

- job: B
  steps:
  - bash: echo "B"

Om du organiserar din pipeline i flera steg använder du nyckelordet stages .

stages:
- stage: A
  jobs:
  - job: A1
  - job: A2

- stage: B
  jobs:
  - job: B1
  - job: B2

Om du väljer att ange en pool på stegnivå använder alla jobb som definierats i den fasen poolen om de inte anges på jobbnivå.

Kommentar

I Azure DevOps Server 2019 kan pooler endast anges på jobbnivå.

stages:
- stage: A
  pool: StageAPool
  jobs:
  - job: A1 # will run on "StageAPool" pool based on the pool defined on the stage
  - job: A2 # will run on "JobPool" pool
    pool: JobPool

Den fullständiga syntaxen för att ange en fas är:

stages:
- stage: string  # name of the stage, A-Z, a-z, 0-9, and underscore
  displayName: string  # friendly name to display in the UI
  dependsOn: string | [ string ]
  condition: string
  pool: string | pool
  variables: { string: string } | [ variable | variableReference ] 
  jobs: [ job | templateReference]

Den här versionen av TFS stöder inte YAML-pipelines.

Ange beroenden

Kommentar

Stöd för faser har lagts till i Azure DevOps Server 2019.1.

När du definierar flera steg i en pipeline körs de som standard sekventiellt i den ordning som du definierar dem i YAML-filen. Undantaget är när du lägger till beroenden. Med beroenden körs faser i ordning dependsOn efter kraven.

Pipelines måste innehålla minst en fas utan beroenden.

Syntaxen för att definiera flera steg och deras beroenden är:

stages:
- stage: string
  dependsOn: string
  condition: string

Exempelfaser som körs sekventiellt:

# if you do not use a dependsOn keyword, stages run in the order they are defined
stages:
- stage: QA
  jobs:
  - job:
    ...

- stage: Prod
  jobs:
  - job:
    ...

Exempelfaser som körs parallellt:

stages:
- stage: FunctionalTest
  jobs:
  - job:
    ...

- stage: AcceptanceTest
  dependsOn: []    # this removes the implicit dependency on previous stage and causes this to run in parallel
  jobs:
  - job:
    ...

Exempel på ut-och-fläkt-in:

stages:
- stage: Test

- stage: DeployUS1
  dependsOn: Test    # this stage runs after Test

- stage: DeployUS2
  dependsOn: Test    # this stage runs in parallel with DeployUS1, after Test

- stage: DeployEurope
  dependsOn:         # this stage runs after DeployUS1 and DeployUS2
  - DeployUS1
  - DeployUS2

Den här versionen av TFS stöder inte YAML-pipelines.

Definiera villkor

Du kan ange under vilka villkor varje fas körs med uttryck. Som standard körs en fas om den inte är beroende av någon annan fas, eller om alla faser som den är beroende av har slutförts och lyckats. Du kan anpassa det här beteendet genom att tvinga en fas att köras även om en tidigare fas misslyckas eller genom att ange ett anpassat villkor.

Om du anpassar standardvillkoret för föregående steg för en fas tar du bort villkoren för slutförande och framgång. Om du använder ett anpassat villkor är det därför vanligt att använda and(succeeded(),custom_condition) för att kontrollera om föregående steg har körts. Annars körs fasen oavsett resultatet av föregående fas.

Kommentar

Villkor för misslyckades ('JOBNAME/STAGENAME') och lyckades ('JOBNAME/STAGENAME') enligt följande exempel fungerar endast för YAML-pipelines.

Kommentar

Stöd för faser har lagts till i Azure DevOps Server 2019.1.

Exempel för att köra en fas baserat på statusen för att köra ett tidigare steg:

stages:
- stage: A

# stage B runs if A fails
- stage: B
  condition: failed()

# stage C runs if B succeeds
- stage: C
  dependsOn:
  - A
  - B
  condition: succeeded('B')

Exempel på användning av ett anpassat villkor:

stages:
- stage: A

- stage: B
  condition: and(succeeded(), eq(variables['build.sourceBranch'], 'refs/heads/main'))

Den här versionen av TFS stöder inte YAML-pipelines.

Ange köprinciper

YAML-pipelines stöder inte köprinciper. Varje körning av en pipeline är oberoende av och omedveten om andra körningar. Med andra ord kan dina två efterföljande incheckningar utlösa två pipelines, och båda kör samma sekvens av steg utan att vänta på varandra. Medan vi arbetar med att skicka köprinciper till YAML-pipelines rekommenderar vi att du använder manuella godkännanden för att manuellt sekvensera och styra körningsordningen om detta är viktigt.

Den här versionen av TFS stöder inte YAML-pipelines.

Ange godkännanden

Du kan manuellt styra när en fas ska köras med hjälp av godkännandekontroller. Detta används ofta för att styra distributioner till produktionsmiljöer. Kontroller är en mekanism som är tillgänglig för resursägaren för att kontrollera om och när en fas i en pipeline kan använda en resurs. Som ägare av en resurs, till exempel en miljö, kan du definiera kontroller som måste uppfyllas innan en fas som förbrukar resursen kan starta.

För närvarande stöds manuella godkännandekontroller i miljöer. Mer information finns i Godkännanden.

Godkännanden stöds ännu inte i YAML-pipelines i den här versionen av Azure DevOps Server.

Den här versionen av TFS stöder inte YAML-pipelines.