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 main Build.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 condition stage2 a forráság mainmindig fusson, állapottól függetlenül stage1 stage1.
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 B stage2 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 stage1 false 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', succeeded())
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: and(succeeded(), ${{ 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.