Folyamatfeltételek

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

Ez a cikk azOkat a feltételeket ismerteti, amelyek mellett egy Azure Pipelines-szakasz, feladat vagy lépés fut, és hogyan adhat meg különböző feltételeket. A szakaszokra, feladatokra és lépésekre vonatkozó további kontextusért tekintse meg az Azure Pipelines fő fogalmait.

• Alapértelmezés szerint egy feladat vagy szakasz akkor fut, ha nem függ semmilyen más feladattól vagy fázistól, vagy ha az összes függősége befejeződött és sikeres volt. Ez a követelmény nem csak a közvetlen függőségekre vonatkozik, hanem a rekurzívan kiszámított közvetett függőségekre is.

• Alapértelmezés szerint egy lépés akkor fut, ha a feladatban még semmi sem hiúsult meg, és az azt közvetlenül megelőző lépés befejeződött.

Ezt a viselkedést felülbírálhatja vagy testre szabhatja úgy, hogy egy szakaszt, feladatot vagy lépést arra kényszerít, hogy futtasson még akkor is, ha egy korábbi függőség meghiúsul, vagy egyéni feltételt ad meg.

Feljegyzés

Ez a cikk a YAML-folyamatok képességeit ismerteti. Klasszikus folyamatok esetén megadhatja, hogy milyen feltételek mellett futnak a tevékenységek vagy feladatok az egyes tevékenységek vezérlőbeállításaiban , illetve a kiadási folyamatban lévő feladatok további beállításai között.

Egy szakasz, feladat vagy lépés futtatásának feltételei

A folyamatdefiníció YAML-ben a következő feltételeket adhatja meg, amelyek mellett egy szakasz, feladat vagy lépés fut:

• Csak akkor, ha az azonos ügynökkészlettel rendelkező összes korábbi közvetlen és közvetett függőség sikeres. Ha különböző ügynökkészletekkel rendelkezik, ezek a szakaszok vagy feladatok párhuzamosan futnak. Ez a feltétel az alapértelmezett, ha nincs beállítva feltétel a YAML-ben.

• Még akkor is, ha egy korábbi függőség meghiúsul, kivéve, ha a futtatás megszakad. Használja succeededOrFailed() a YAML-ben ehhez a feltételhez.

• Még akkor is, ha egy korábbi függőség meghiúsul, és még akkor is, ha a futtatás megszakadt. Használja always() a YAML-ben ehhez a feltételhez.

• Csak akkor, ha egy korábbi függőség meghiúsul. Használja failed() a YAML-ben ehhez a feltételhez.

• Egyéni feltételek.

Alapértelmezés szerint a szakaszok, feladatok és lépések akkor futnak, ha minden közvetlen és közvetett függőség sikeres. Ez az állapot megegyezik a beállítással condition: succeeded(). További információ: sikeres állapotfüggvény.

Amikor egy szakasz, feladat vagy lépés tulajdonságát condition adja meg, felülírja az alapértelmezett condition: succeeded()értéket. A saját feltételek megadása akkor is futtathatja a szakaszt, a feladatot vagy a lépést, ha a build le van szakítva. Győződjön meg arról, hogy az írott feltételek figyelembe veszik a szülőszakasz vagy feladat állapotát.

Az alábbi YAML-példa a feltételeket és failed() a always() feltételeket mutatja be. Az első feladat lépése akkor is lefut, ha a függőségek meghiúsulnak, vagy a build megszakad. A második feladat csak akkor fut, ha az első feladat meghiúsul.

jobs:
- job: Foo

  steps:
  - script: echo Hello!
    condition: always() # this step runs, even if the build is canceled

- job: Bar
  dependsOn: Foo
  condition: failed() # this job runs only if Foo fails

A változókat feltételek szerint is beállíthatja és használhatja. Az alábbi példa egy változót isMain állít be és használ a kijelöléshez mainBuild.SourceBranch.

variables:
  isMain: $[eq(variables['Build.SourceBranch'], 'refs/heads/main')]

stages:
- stage: A
  jobs:
  - job: A1
    steps:
      - script: echo Hello Stage A!

- stage: B
  condition: and(succeeded(), eq(variables.isMain, true))
  jobs:
  - job: B1
    steps:
      - script: echo Hello Stage B!
      - script: echo $(isMain)

Fontos

A feltételek kiértékelése meghatározza, hogy egy szakaszt, feladatot vagy lépést szeretne-e elindítani. Ezért a futtatókörnyezetben az adott munkaegységen belül semmi sem számítható ki. Ha például olyan feladattal rendelkezik, amely egy szintaxissal rendelkező $[ ] futtatókörnyezeti kifejezéssel állít be egy változót, az adott feladatban nem használhatja ezt a változót egyéni feltételként.

Egyéni feltételek

Ha a beépített feltételek nem felelnek meg az igényeinek, egyéni feltételeket is megadhat. A feltételeket kifejezésként kell írnia a YAML-folyamatdefiníciókban.

Az ügynök kiértékeli a kifejezést a legbelső függvénytől kezdve, és kifelé halad. A végeredmény egy logikai érték, amely meghatározza, hogy a tevékenységnek, feladatnak vagy fázisnak futnia kell-e. A szintaxis teljes útmutatója a Kifejezések című témakörben olvasható.

Ha a feltételek bármelyike lehetővé teszi, hogy a feladat a build megszakítása után is fusson, adjon meg ésszerű értéket a megszakítási időtúllépéshez, hogy ezek a tevékenységek elegendő időt töltsenek a felhasználó futásának megszakítása után.

A build megszakításának kimenetei

A build megszakítása nem jelenti azt, hogy az összes fázis, feladat vagy lépés leáll. A megadott feltételektől és a folyamat végrehajtásának melyik szakaszától, feladatától vagy lépésétől függ, hogy melyik szakasz, feladat vagy lépés leállítja a buildet. Ha a rendszer kihagy egy szakaszt, feladatot vagy lépés szülőjét, a tevékenység a feltételektől függetlenül nem fut.

Egy szakasz, feladat vagy lépés akkor fut le, amikor a feltételek kiértékelése történik.true Ha a feltétel nem veszi figyelembe a tevékenység szülőjének állapotát, a tevékenység akkor is lefuthat, ha a szülőjét megszakítja. Annak szabályozásához, hogy a szakaszok, a feladatok vagy a feltételekkel rendelkező lépések futnak-e a build leállásakor, ügyeljen arra, hogy a feltételek között szerepeljen egy feladatállapot-ellenőrző függvény .

Az alábbi példák a build megszakításakor megadott különböző feltételek eredményeit mutatják be a szakaszokon, feladatokon vagy lépéseken.

Példa 1. szakaszra

A következő folyamat alapértelmezés szerint stage2 attól függ, hogy conditionstage2 a forráság mainmindig fusson, állapottól függetlenül stage1stage1.

Ha várólistára állít egy buildet az main ágon, és futás közben stage1 megszakítja azt, stage2 akkor is fut, mert eq(variables['Build.SourceBranch'], 'refs/heads/main') a kiértékelése így truetörténik.

stages:
- stage: stage1
  jobs:
  - job: A
    steps:
      - script: echo 1; sleep 30
- stage: stage2
  condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')
  jobs:
  - job: B
    steps:
      - script: echo 2

Példa 2. szakaszra

A következő folyamatban stage2 alapértelmezés szerint függ stage1 . A feladatnak Bstage2 van egy készlete condition . Ha várólistára állít egy buildet az main ágon, és futás közben stage1 megszakítja azt, stage2 akkor nem fut, annak ellenére, hogy olyan feladatot tartalmaz, amelynek a állapota kiértékeli a következőt true.

Ennek az az oka, hogy stage2 az alapértelmezett condition: succeeded()érték a megszakítás időpontjára stage1false van kiértékelve. Ezért a rendszer kihagyja, stage2 és egyik feladat sem fut.

stages:
- stage: stage1
  jobs:
  - job: A
    steps:
      - script: echo 1; sleep 30
- stage: stage2
  jobs:
  - job: B
    condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')
    steps:
      - script: echo 2

Példa 3. szakaszra

A következő folyamat alapértelmezés szerint stage2 a függvénytől stage1függ, és a feladaton B belüli lépésnek van egy condition készlete.

Ha várólistára állít egy buildet az main ágon, és futás közben stage1 megszakítja azt, stage2 akkor nem fut, annak ellenére, hogy tartalmaz egy olyan lépést a feladatban B , amelynek állapota kiértékeli a következőt true. Ennek az az oka, hogy stage2 a rendszer kihagyja a lemondást stage1 .

stages:
- stage: stage1
  jobs:
  - job: A
    steps:
      - script: echo 1; sleep 30
- stage: stage2
  jobs:
  - job: B
    steps:
      - script: echo 2
        condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')

Példa feladatra 1

A következő YAML-folyamatban a feladat B alapértelmezés szerint a feladattól A függ, de a feladatnak B van egy condition olyan készlete, amely akkor fut, amikor a forráság van main. Ha várólistára állít egy buildet az main ágon, és megszakítja azt a feladat A futtatása közben, a feladat B továbbra is fut, mert eq(variables['Build.SourceBranch'], 'refs/heads/main') a kiértékelése így truetörténik.

jobs:
- job: A
  steps:
  - script: sleep 30
- job: B
  dependsOn: A 
  condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')
  steps:
    - script: echo step 2.1

Ha azt szeretné, hogy a feladat B csak akkor fusson, ha a feladat A sikeres, és a buildforrás az main ág, akkor a condition megfelelőnek kell lennie and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main')).

Példa a 2. feladatra

A következő folyamatban a feladat B alapértelmezés szerint a feladattól A függ. Ha várólistára állít egy buildet az main ágon, és megszakítja azt a feladat A futtatása közben, a feladat B nem fut, annak ellenére, hogy a lépése condition kiértékeli a következőt true.

Ennek az az oka, hogy a feladat B alapértelmezett condition: succeeded()értéke a feladat A megszakításának időpontjára false lesz kiértékelve. Ezért a feladat B kimarad, és egyik lépés sem fut.

jobs:
- job: A
  steps:
  - script: sleep 30
- job: B
  dependsOn: A 
  steps:
    - script: echo step 2.1
      condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')
      

Példa lépésre

A lépésekhez feltételek is tartozhatnak.

A következő folyamatban a 2.3. lépésnek van egy condition olyan készlete, amely akkor fut, amikor a forráság a mainkövetkező. Ha várólistára állít egy buildet az main ágon, és a 2.1. vagy a 2.2. lépés futtatása közben megszakítja azt, a 2.3. lépés továbbra is fut, mert eq(variables['Build.SourceBranch'], 'refs/heads/main') a truekiértékelése így történik.

steps:
  - script: echo step 2.1
  - script: echo step 2.2; sleep 30
  - script: echo step 2.3
    condition: eq(variables['Build.SourceBranch'], 'refs/heads/main')

Feltételbeállítások

Az alábbi táblázat a különböző eredmények előállításához használható példabeállításokat condition mutatja be.

Feljegyzés

Release.Artifacts.{artifact-alias}.SourceBranchegyenértékű a .-nak.Build.SourceBranch

Kívánt eredmény	Példafeltétel-beállítás
Futtassa, ha a forráság a fő, akkor is, ha a szülő vagy előző szakasz, feladat vagy lépés meghiúsult, vagy megszakították.	eq(variables['Build.SourceBranch'], 'refs/heads/main')
Futtassa, ha a forráság fő, és a szülő vagy előző szakasz, feladat vagy lépés sikeres volt.	and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
Futtassa, ha a forráság nem fő, és a szülő vagy előző szakasz, feladat vagy lépés sikeres volt.	and(succeeded(), ne(variables['Build.SourceBranch'], 'refs/heads/main'))
Futtassa a felhasználói témakör ágait, ha a szülő vagy előző szakasz, feladat vagy lépés sikeres volt.	and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/heads/users/'))
Futtassa a folyamatos integrációs (CI) buildeket, ha a szülő vagy előző fázis, feladat vagy lépés sikeres volt.	and(succeeded(), in(variables['Build.Reason'], 'IndividualCI', 'BatchedCI'))
Futtassa, ha a buildet egy lekéréses kérelem ágszabályzata aktiválta, és a szülő vagy előző fázis, feladat vagy lépés sikertelen volt.	and(failed(), eq(variables['Build.Reason'], 'PullRequest'))
Futtassa az ütemezett buildet, még akkor is, ha a szülő vagy előző szakasz, feladat vagy lépés meghiúsult vagy megszakadt.	eq(variables['Build.Reason'], 'Schedule')
Futtassa, ha egy változó igaz értékre van állítva, akkor is, ha a szülő vagy előző szakasz, feladat vagy lépés meghiúsult vagy megszakadt.	eq(variables['System.debug'], true)

Feljegyzés

Beállíthat egy feltételt a futtatásra, ha egy változó null értékű (üres sztring). Mivel minden változó sztringként van kezelve az Azure Pipelinesban, egy üres sztring egyenértékű null az alábbi folyamatokkal:

variables:
- name: testEmpty
  value: ''

jobs:
  - job: A
    steps:
    - script: echo testEmpty is blank
    condition: eq(variables.testEmpty, '')

Paraméterek feltételekben

A paraméterek bővítése a feltételek mérlegelése előtt történik. Ezért ha egy paramétert ugyanabban a folyamatban deklarál, mint egy feltétel, beágyazhatja a paramétert a feltételbe. A következő YAML-szkript azért fut, mert parameters.doThing igaz.

parameters:
- name: doThing
  default: true
  type: boolean

steps:
- script: echo I did a thing
  condition: ${{ eq(parameters.doThing, true) }}

Az condition előző folyamat két függvényt egyesít: succeeded() és eq('${{ parameters.doThing }}', true). A succeeded() függvény ellenőrzi, hogy az előző lépés sikeres volt-e. A succeeded() függvény azért ad true vissza, mert nem volt előző lépés.

A eq('${{ parameters.doThing }}', true) függvény ellenőrzi, hogy a doThing paraméter egyenlő-e .true Mivel az alapértelmezett érték doThing az true, a feltétel alapértelmezés szerint visszatér true , kivéve, ha a folyamat más értéket állít be.

Sablonparaméterek feltételekben

Amikor egy paramétert egy sablonnak ad át, be kell állítania a paraméter értékét a sablonban, vagy a templateContext használatával kell átadnia a paramétert a sablonnak.

A következő parameters.yml fájl például deklarálja a paramétert és az doThing alapértelmezett értéket:

# parameters.yml
parameters:
- name: doThing
  default: true # value passed to the condition
  type: boolean

jobs:
  - job: B
    steps:
    - script: echo I did a thing
    condition: ${{ eq(parameters.doThing, true) }}

A folyamatkód a parameters.yml sablonra hivatkozik. A folyamat kimenete azért van, I did a thing mert a paraméter doThing igaz.

# azure-pipeline.yml
parameters:
- name: doThing
  default: true 
  type: boolean

trigger:
- none

extends:
  template: parameters.yml

További sablonparaméter-példákért tekintse meg a sablon használati referenciáit.

A következő feladatfeltételekben használt feladatkimeneti változók

A változót elérhetővé teheti a jövőbeli feladatok számára, és megadhatja egy feltételben. A jövőbeli feladatok számára elérhető változókat többfeladatos kimeneti változóként isOutput=truekell megjelölni a következő kódhoz hasonlóan:

jobs:
- job: Foo
  steps:
  - bash: |
      echo "This is job Foo."
      echo "##vso[task.setvariable variable=doThing;isOutput=true]Yes" #set variable doThing to Yes
    name: DetermineResult
- job: Bar
  dependsOn: Foo
  condition: eq(dependencies.Foo.outputs['DetermineResult.doThing'], 'Yes') #map doThing and check the value
  steps:
  - script: echo "Job Foo ran and doThing is Yes."

A következő lépés feltételeiben használt lépésben létrehozott változók

Létrehozhat egy változót, amely a jövőbeli lépésekhez elérhető egy feltételben való megadásához. A lépésekből létrehozott változók alapértelmezés szerint elérhetők a jövőbeli lépésekhez, és nem kell többfeladatos kimeneti változóként megjelölni.

A lépésekből létrehozott hatókörváltozókkal kapcsolatban fontos tudnivalókat érdemes megjegyezni.

• A feladat egy lépésében létrehozott változók hatóköre az ugyanabban a feladatban szereplő lépésekre terjed ki.
• A lépésben létrehozott változók csak környezeti változókként érhetők el a következő lépésekben.
• A lépésben létrehozott változók nem használhatók az őket definiáló lépésben.

Az alábbi példa bemutatja, hogyan hozhat létre folyamatváltozót egy lépésben, és használhatja a változót egy későbbi lépés feltételében és szkriptjében.

steps:

# This step creates a new pipeline variable: doThing. This variable is available to subsequent steps.
- bash: |
    echo "##vso[task.setvariable variable=doThing]Yes"
  displayName: Step 1

# This step is able to use doThing, so it uses doThing in its condition
- script: |
    # Access the variable from Step 1 as an environment variable.
    echo "Value of doThing (as DOTHING env var): $DOTHING."
  displayName: Step 2
  condition: and(succeeded(), eq(variables['doThing'], 'Yes')) # or and(succeeded(), eq(variables.doThing, 'Yes'))

GYIK

Hogyan aktiválhatok egy feladatot, ha az előző feladat hibásan fejeződött be?

Az előző feladat eredményét egy feltételben használhatja. A következő YAML-ben például a feltétel eq(dependencies.A.result,'SucceededWithIssues') lehetővé teszi a feladat B futtatását, mert a feladat A sikeres volt a problémák miatt.

jobs:
- job: A
  displayName: Job A
  continueOnError: true # next job starts even if this one fails
  steps:
  - script: echo Job A ran
  - script: exit 1

- job: B
  dependsOn: A
  condition: eq(dependencies.A.result,'SucceededWithIssues') # targets the result of the previous job 
  displayName: Job B
  steps:
  - script: echo Job B ran

Lemondtam a buildet, de még mindig fut. Miért?

Ezt a problémát akkor tapasztalhatja, ha egy fázisban konfigurált feltétel nem tartalmaz feladatállapot-ellenőrző függvényt. A probléma megoldásához adjon hozzá egy feladatállapot-ellenőrző függvényt a feltételhez.

Ha lemond egy feladatot, amíg az az üzenetsor fázisában van, de nem fut, a teljes feladat megszakad, beleértve az összes többi szakaszt is. További információkért tekintse meg a jelen cikk korábbi részében szereplő buildek megszakításának feltételes eredményeit.

Kapcsolódó tartalom

• Feladatok meghatározása a folyamatban
• Szakaszok, függőségek és feltételek hozzáadása