Jegyzet
Az oldalhoz való hozzáférés engedélyezést igényel. Próbálhatod be jelentkezni vagy könyvtárat váltani.
Az oldalhoz való hozzáférés engedélyezést igényel. Megpróbálhatod a könyvtár váltását.
Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022
Ez a cikk azOkat a különböző feltételeket ismerteti, amelyek lehetővé teszik egy Azure Pipelines-szakasz, feladat vagy lépés futtatását, valamint hogy hogyan állíthatja be ezeket a feltételeket egy YAML-folyamatdefinícióban.
Megjegyzés
Ez a cikk a YAML-pipelínek 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.
Feltételek egy szakasz, feladat vagy lépés futtatásához
Alapértelmezés szerint egy folyamatfeladat vagy szakasz akkor fut, ha az nem függ más feladatoktól vagy fázisoktól, vagy ha az összes függősége befejeződött és sikeres volt. A függőségi követelmény a közvetlen függőségekre és a rekurzívan kiszámított közvetett függőségekre vonatkozik.
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. A szakaszokra, feladatokra és lépésekre vonatkozó további kontextusért tekintse meg az Azure Pipelines fő fogalmait.
Ezeket az alapértelmezett viselkedéseket felülbírálhatja vagy testre szabhatja úgy, hogy beállít egy szakaszt, feladatot vagy lépést a futtatáshoz, még akkor is, ha egy korábbi függőség meghiúsul vagy más eredményt ad.
Egyéni feltételeket is meghatározhat. A YAML-folyamatdefiníciókban a tulajdonság használatával adhatja meg azokat a condition feltételeket, amelyek mellett egy szakasz, feladat vagy lépés futtatható.
Megjegyzés
A feltételek az azonos ügynökkészlettel rendelkező összes korábbi közvetlen és közvetett függőségre vonatkoznak. A különböző ügynökkészletekben lévő szakaszok vagy feladatok párhuzamosan futnak.
A korábbi függőségi állapoton alapuló feltételek a következők:
-
Sikeres: Csak akkor fut, ha az összes korábbi függőség sikeres. Ez a viselkedés az alapértelmezett, ha nincs beállítva feltétel a YAML-ben. A feltétel alkalmazásához adja meg a .
condition: succeeded() -
Sikeres vagy sikertelen: Futtatás akkor is, ha egy korábbi függőség meghiúsul, kivéve, ha a futtatás megszakadt. A feltétel alkalmazásához adja meg a .
condition: succeededOrFailed() -
Mindig: Futtatás akkor is, ha egy korábbi függőség meghiúsul, még akkor is, ha a futtatás megszakadt. A feltétel alkalmazásához adja meg a .
condition: always() -
Sikertelen: Csak akkor fut, ha egy korábbi függőség meghiúsul. A feltétel alkalmazásához adja meg a .
condition: failed()
Fontos
Amikor egy szakasz, feladat vagy lépés tulajdonságát condition adja meg, felülírja az alapértelmezett feltételt. A szakasz, a feladat vagy a lépés akkor is lefuthat, ha a build le van szakítva. Győződjön meg arról, hogy a feltételek figyelembe veszik a szülőszakasz vagy feladat állapotát.
Példa feltételre
Az alábbi YAML-példa bemutatja a feltételeket és always() a failed() feltételeket. Az 1. feladat első szkriptfeladata rendelkezik egy always feltétellel, ezért akkor is fut, ha a függőségek meghiúsulnak, vagy a build megszakad. A második szkriptfeladatban exit job1 a job1 feladat meghiúsulására kényszeríti.
A folyamatszakaszok alapértelmezés szerint szekvenciálisan futnak, de a feladatok párhuzamosan is futtathatók. A dependsOn tulajdonság használatával explicit módon definiálhat függőségeket a szakaszok vagy feladatok között.
Egy másik feladat eredményétől függő feladatok feltételeinek megadásához használja dependsOn a függőséget. Az alábbi példában job2 a hiba miatt job1 függ job1 és fut.
jobs:
- job: job1
steps:
- script: echo Hello!
condition: always() # this step runs even if the build is canceled
- script: |
echo "This task will fail."
exit job1
- job: job2
dependsOn: job1
condition: failed() # this job runs only if job1 fails
Megjegyzés
Az Azure Pipelines felhasználói felületén manuálisan is futtathat függő fázisokat, ha a szülőszakasz meghiúsul. További információ: Gyermekszakaszok futtatása a szülőszakasz meghibásodása esetén.
Egyéni feltételek
Ha a beépített feltételek nem felelnek meg az igényeinek, egyéni feltételeket is megadhat kifejezésként a YAML-folyamatdefiníciókban.
Az ügynök kiértékeli a kifejezést a legbelső függvénytől kezdve, és kifelé haladva. A végeredmény egy logikai érték, amely meghatározza, hogy futtatja-e a szakaszt, a feladatot vagy a lépést. A szintaxis teljes útmutatója a Kifejezések című témakörben olvasható.
Fontos
A feltételek kiértékelése meghatározza, hogy egy szakaszt, feladatot vagy lépést szeretne-e elindítani. Ezért egy szakasz, feladat vagy lépés futásideje során kiszámított adatok nem használhatók ugyanazon a szakaszon, feladaton vagy lépésen belül. Ha például egy feladatban egy szintaxissal rendelkező futtatókörnyezeti kifejezéssel $[ ] állít be egy változót, akkor a változó nem használható az adott feladat feltételeiben.
Változók feltételekben
Beállíthatja a folyamatváltozókat, és feltételek között használhatja őket. A következő folyamat beállít egy változótisMain, és olyan feltételben használja, amely csak akkor futtatja a B fázist, ha a build forrásága .main
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)
Beállíthat egy feltételt a futtatásra, ha egy változó null értékű vagy üres sztring. Minden változó sztringként van kezelve az Azure Pipelinesban, így 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, '')
Más feladatfeltételekben használt feladatkimeneti változók
Létrehozhat egy változót egy olyan feladatban, amelyet az ugyanabban a fázisban lévő többi feladat feltételek között adhat meg. A függő feladatok számára elérhető változókat többfeladatos kimeneti változókéntisOutput=truekell megjelölni a következő kódhoz hasonlóan:
jobs:
- job: A
steps:
- bash: |
echo "This is job A."
echo "##vso[task.setvariable variable=doThing;isOutput=true]Yes" #set variable doThing to Yes
name: DetermineResult
- job: B
dependsOn: A
condition: eq(dependencies.A.outputs['DetermineResult.doThing'], 'Yes') #map doThing and check the value
steps:
- script: echo "Job A ran and doThing is Yes."
A következő lépésfeltételekben használt lépésváltozók
Létrehozhat egy változót egy olyan lépésben, amelyet az ugyanabban a feladatban szereplő jövőbeli lépések feltételekben határozhatnak meg. A lépésekből létrehozott változók alapértelmezés szerint elérhetők a feladat későbbi lépéseihez, és nem kell többfeladatos kimeneti változóként megjelölni.
A feladat egy lépésében létrehozott változókra a következő korlátozások vonatkoznak:
- A hatókör az ugyanabban a feladatban szereplő lépésekre vonatkozik .
- A következő lépésekben csak környezeti változókként érhetők el.
- Nem használható ugyanabban a lépésben, amely meghatározza őket.
Az alábbi példa létrehoz egy folyamatváltozót egy lépésben, és a változót egy későbbi lépés szkriptfeltételében használja.
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 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'))
A különböző eredmények feltételbeállításai
Az alábbi táblázat a különböző kívánt eredmények előállításához szükséges beállításokat mutatja condition be.
| Kívánt eredmény | Példafeltétel-beállítás |
|---|---|
Futtassa a forráságat mainakkor is, ha a szülő vagy előző szakasz, feladat vagy lépés sikertelen volt, vagy megszakították. |
eq(variables['Build.SourceBranch'], 'refs/heads/main') |
Futtassa, ha a forráság és main 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 main, é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 az ágakat user , ha a szülő vagy az 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 egy lekéréses kérelem aktiválta a buildet, és a szülő vagy előző szakasz, feladat vagy lépés sikertelen volt. | and(failed(), eq(variables['Build.Reason'], 'PullRequest')) |
| Futtassa az ütemezett verziót, még akkor is, ha a szülő vagy előző szakasz, feladat vagy lépés meghiúsult vagy törölték. | eq(variables['Build.Reason'], 'Schedule') |
Futtassa, ha a System.debug változó értéke be van állítva true, akkor is, ha a szülő vagy előző szakasz, feladat vagy lépés sikertelen volt, vagy megszakították. |
eq(variables['System.debug'], true) |
Megjegyzés
Release.Artifacts.{artifact-alias}.SourceBranchegyenértékű a .-nak.Build.SourceBranch
A build megsemmisítésének feltételei és kimenetei
A build megszakítása nem jelenti azt, hogy az összes fázis, feladat és lépés leáll. A feladatok, szakaszok vagy lépések futásának leállítása a megadott feltételektől függ, és a folyamat végrehajtásának melyik pontján mondta le a buildet. Ha egy szakasz, feladat vagy lépés szülője ki van hagyva, a szakasz, a feladat vagy a lépés nem fut a feltételektől függetlenül.
Egy szakasz, feladat vagy lépés akkor fut le, amikor a feltételek kiértékelése történik.true Ha egy 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 ellenőrzéséhez, hogy a feladatok, a szakaszok vagy a lépések futnak-e a build megszakításakor, adjon meg egy feladatállapot-ellenőrző függvényt a feltételek között.
Ha lemond egy buildet, amíg az az üzenetsor fázisában van, de még nem fut, a teljes futtatás megszakad, beleértve az összes többi szakaszt is.
Megjegyzés
Ha a feltételek bármelyike lehetővé teszi, hogy a tevékenységek a build megszakítása után is fussanak, adjon meg egy olyan időtúllépési értéket, amely elegendő időt biztosít a tevékenységek befejezéséhez a futtatás megszakítása után.
Példa fázisfeltételek eredményeire
Az alábbi példák a build megszakításának fázisain beállított különböző feltételek eredményeit mutatják be.
Példa 1. szakaszra
A következő folyamatban alapértelmezés szerint stage2 a sikeres befejezéstől stage1 függ.
stage2
condition Azonban a forráság mainminden esetben futtatható, állapottól függetlenülstage1.
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 a 2. szakaszra
A következő folyamatban alapértelmezés szerint stage2 a sikeres befejezéstől stage1 függ. A feladatnak Bstage2 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 futás közben stage1 megszakítja azt, stage2 és a feladatok egyáltalán nem futnak, annak ellenére, hogy a szakasz tartalmaz egy feladatot, amelynek a állapota kiértékeli a következőt true.
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 a 3. szakaszra
A következő folyamatban alapértelmezés szerint stage2 a sikeres befejezéstől stage1 függ. A feladaton B belüli stage2 lépésnek 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 futás közben stage1 megszakítja azt, stage2 és a feladat B egyáltalán nem fut, annak ellenére, hogy a feladat B tartalmaz egy lépést, amelynek a állapota kiértékelve lesz true.
Stage2 a program teljes egészében kihagyja, mert stage1 a program megszakította.
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 feladatfeltételek eredményeire
Az alábbi példák a feladatokra vonatkozó különböző feltételek eredményét mutatják be a build megszakításakor.
Példa feladatra 1
A következő YAML-folyamatban a futtatott feladat B a futtatott feladattól A függ. A feladatnak B van egy condition olyan készlete is, amely akkor fut, amikor a forráság a mainkövetkező.
Ha várólistára állít egy buildet az main ágon, és megszakítja azt, miközben a A feladat fut, a B feladat továbbra is fut, mert condition: eq(variables['Build.SourceBranch'], 'refs/heads/main') értékelése true lesz.
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 ismain, akkor a következőt conditionkell beállítaniaand(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main')).
Példa a 2. feladatra
A következő YAML-folyamatban a feladat B a sikeres feladattól A függ. A feladat B egy olyan készlettel condition rendelkezik, amely akkor fut, amikor a feladat A sikeres, és a build forrásága .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 nem fut, annak ellenére, hogy van egy condition , amely kiértékeli a következőt true. A feladat B feltételének kiértékelése azért történik, false mert a feladat A nem sikerült. Ezért a feladat B és a hozzá tartozó lépések kihagyva lesznek.
jobs:
- job: A
steps:
- script: sleep 30
- job: B
dependsOn: A
steps:
- script: echo step 2.1
condition: and(eq(variables['Build.SourceBranch'], 'refs/heads/main'), succeeded())
Példalépési feltétel eredménye
A lépésekhez feltételeket is beállíthat. A következő folyamatban a 2.3. lépés úgy van beállítva, hogy fusson, amikor a forráság condition.
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 még mindig végrehajtódik, mert a eq(variables['Build.SourceBranch'], 'refs/heads/main') eredménye true lesz.
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')
Paraméterek feltételekben
Paramétereket feltételek között is használhat. A paraméterbővítés a folyamat futtatása előtt történik, és lecseréli a konstans paraméterértékekkel körülvett ${{ }} értékeket. Mivel a paraméterbővítés a feltétel kiértékelése előtt történik, deklarálhat egy paramétert egy folyamatban, és beágyazhatja a paramétert a folyamat bármely feltételében.
Az condition alábbi példában két függvényt egyesítünk: succeeded() és ${{ eq(parameters.doThing, true) }}. A succeeded() függvény ellenőrzi, hogy az előző lépés sikeres volt-e. Ez a függvény akkor is visszaadja true , ha nincs előző lépés.
A ${{ eq(parameters.doThing, true) }} függvény ellenőrzi, hogy a doThing paraméter egyenlő-e .true A következő példában szereplő szkriptlépés azért fut, mert nem volt korábbi lépés, és parameters.doThing alapértelmezés szerint az true .
parameters:
- name: doThing
default: true
type: boolean
steps:
- script: echo I did a thing
condition: and(succeeded(), ${{ eq(parameters.doThing, true) }})
Sablonparaméterek feltételekben
Amikor egy paramétert átad egy folyamatsablonnak, beállíthatja a paraméter értékét a sablonfájlban, vagy a templateContext használatával továbbíthatja a paramétert a sablonnak.
Az alábbi parameters.yml sablonfájl a paraméter alapértelmezett értékével doThing deklarálja, true és a paramétert egy feladatfeltételben használja.
# parameters.yml
parameters:
- name: doThing
default: true
type: boolean
jobs:
- job: B
steps:
- script: echo I did a thing
condition: ${{ eq(parameters.doThing, true) }}
Az alábbi azure-pipelines.yml folyamatdefiníció a parameters.yml sablonfájlban található feladatra hivatkozik. A folyamat kimenete az, I did a thing hogy a paraméter doThing alapértelmezés szerint igaz.
# azure-pipelines.yml
extends:
template: parameters.yml
További sablonparaméter-példákért tekintse meg a sablon használati referenciáit.
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 a feltétel eq(dependencies.A.result,'SucceededWithIssues') a feladat B futtatását állítja be, miután a feladat A sikeres volt a problémák esetén.
jobs:
- job: A
steps:
- script: echo Job A ran
- job: B
dependsOn: A
condition: eq(dependencies.A.result,'SucceededWithIssues') # targets the result of the previous job
steps:
- script: echo Job A had issues
Miért fut a build, miután lemondtam?
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. További információkért tekintse meg a build megszakításának feltételes eredményeit.