Feltételek megadása
Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019
Megadhatja az egyes szakaszok, feladatok vagy lépések futtatásának feltételeit. Alapértelmezés szerint egy feladat vagy szakasz akkor fut, ha az nem függ semmilyen más feladattól vagy fázistól, vagy ha az összes feladat vagy szakasz, amelytől függ, befejeződött és sikeres volt. Ebbe nem csak a közvetlen függőségek tartoznak, hanem azok rekurzív módon kiszámított függőségei is. Alapértelmezés szerint egy lépés akkor fut, ha a feladatában 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 testre szabhatja, ha egy szakaszt, feladatot vagy lépést akkor is futtatásra kényszerít, ha egy korábbi függőség meghiúsul, vagy ha egyéni feltételt szab meg.
Megadhatja, mely feltételek mellett fusson egy lépés, feladat vagy szakasz.
Csak akkor, ha az azonos ügynökkészlettel rendelkező összes korábbi közvetlen és közvetett függőség sikeres volt. Ha különböző ügynökkészletekkel rendelkezik, ezek a szakaszok vagy feladatok egyidejűleg futnak. Ez az alapértelmezett érték, ha nincs megadva feltétel a YAML-ben.
Még akkor is, ha egy korábbi függőség meghiúsult, kivéve, ha a futtatás megszakadt. Használja
succeededOrFailed()
a YAML-ben ehhez a feltételhez.Még akkor is, ha egy korábbi függőség meghiúsult, 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úsult. Használja
failed()
a YAML-ben ehhez a feltételhez.
- Egyéni feltételek
Alapértelmezés szerint a lépések, feladatok és szakaszok akkor futnak, ha az összes közvetlen és közvetett függőség sikeres volt. Mintha a "condition: succeeded()" értéket adta volna meg (lásd a sikeres állapotfüggvényt).
jobs:
- job: Foo
steps:
- script: echo Hello!
condition: always() # this step will always run, even if the pipeline is canceled
- job: Bar
dependsOn: Foo
condition: failed() # this job will only run if Foo fails
A változókat feltételek között is használhatja.
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)
A rendszer kiértékeli a feltételeket, hogy eldöntse, elindít-e egy szakaszt, feladatot vagy lépést.
Ez azt jelenti, hogy az adott munkaegységen belüli futtatókörnyezetben semmi sem lesz elérhető.
Ha például olyan feladattal rendelkezik, amely egy szintaxist használó futtatókörnyezeti kifejezéssel $[ ]
állít be egy változót, az egyéni feltételben nem használhatja ezt a változót.
A YAML nem támogatott a TFS-ben.
Feljegyzés
Amikor saját condition
tulajdonságot ad meg egy szakaszhoz/feladathoz/lépéshez, felülírja annak alapértelmezett condition: succeeded()
értékét. Ez azt eredményezheti, hogy a szakasz / feladat / lépés akkor is fut, ha a build le van szakítva. Ügyeljen arra, hogy saját feltételei megírásakor vegye figyelembe a szülőszakasz/ feladat állapotát.
Egyéni feltétel engedélyezése
Ha a beépített feltételek nem felelnek meg az igényeinek, egyéni feltételeket is megadhat.
A feltételek YAML-folyamatokban szereplő kifejezésként íródnak. 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 szakasznak futnia kell-e vagy sem. A szintaxis teljes útmutatója a kifejezésekről szóló cikkben olvasható.
Lehetővé teszi az Ön által szabott feltételek bármelyike a feladat futtatását, akkor is, ha a buildet egy felhasználó megszakította? Ha igen, akkor adjon meg egy ésszerű értéket a megszakítási időtúllépéshez, hogy az ilyen típusú feladatoknak elegendő ideje legyen a futtatás megszakítása után.
Folyamat viselkedése a buildelés megszakításakor
Ha egy build le van szakítva, az nem jelenti azt, hogy az összes szakasza, feladata vagy lépése leáll. A döntés a megadott fázistól, feladattól vagy lépéstől conditions
, valamint a folyamat végrehajtásának azon pontjától függ, amikor megszakította a buildet.
Ha a feltétel nem veszi figyelembe a szakasz/feladat/lépés szülőjének állapotát, akkor a feltétel kiértékelése true
esetén a szakasz, a feladat vagy a lépés akkor is lefut, ha a szülője megszakítva van. Ha a szülője ki van hagyva, akkor a szakasz, a feladat vagy a lépés nem fog futni.
Lássunk néhány példát.
Ebben a folyamatban alapértelmezés szerint függstage1
, stage2
és stage2
van egy condition
készlete. stage2
csak akkor fut, ha a forráság .main
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
Ha várólistára állít egy buildet az main
ágon, és futás közben stage1
megszakítja azt, stage2
akkor is futni fog, mert eq(variables['Build.SourceBranch'], 'refs/heads/main')
a kiértékelése így true
történik.
Ebben a folyamatban a stage2
következőtől stage1
függ: . A feladatnak B
van egy condition
készlete.
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
Ha várólistára állít egy buildet az main
ágon, és futás közben stage1
megszakítja azt, stage2
akkor nem fog futni, annak ellenére, hogy olyan feladatot B
tartalmaz, amelynek a állapota kiértékeli.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.
Tegyük fel, hogy a következő YAML-folyamatot futtatja. Figyelje meg, hogy alapértelmezés szerint attól függstage1
, stage2
és ennek script: echo 2
van egy condition
készlete.
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')
Ha várólistára állít egy buildet az main
ágon, és futás közben stage1
megszakítja azt,stage2
akkor nem fog futni, annak ellenére, hogy tartalmaz egy lépést a feladatbanB
, amelynek a állapota kiértékeli a következőttrue
. Ennek az az oka, hogy stage2
a rendszer kihagyja a lemondást stage1
.
Ha meg szeretné akadályozni, hogy a szakaszok, feladatok vagy lépések conditions
a build megszakításakor fussanak, ügyeljen arra, hogy a szülő állapota legyen figyelembe véve a conditions
. További információ: Feladatállapot-függvények.
Példák
Futtassa a fő ágat még akkor is, ha megszakadt, akkor is, ha nem sikerül
eq(variables['Build.SourceBranch'], 'refs/heads/main')
Futtassa a fő ágat, ha sikeres
and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
Futtassa, ha az ág nem fő, ha sikeres
and(succeeded(), ne(variables['Build.SourceBranch'], 'refs/heads/main'))
Futtatás felhasználói témakörágakhoz, ha sikeres
and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/heads/users/'))
Futtassa a folyamatos integrációs (CI) buildeket, ha sikeres
and(succeeded(), in(variables['Build.Reason'], 'IndividualCI', 'BatchedCI'))
Futtatás, ha a buildet egy lekéréses kérelem ágszabályzata futtatja, ha nem sikerül
and(failed(), eq(variables['Build.Reason'], 'PullRequest'))
Futtassa, ha a build ütemezett, akkor is, ha nem sikerül, még akkor is, ha megszakították
eq(variables['Build.Reason'], 'Schedule')
Release.Artifacts. {artifact-alias}. A SourceBranch a Build.SourceBranch-nek felel meg.
Mindig futtassa, ha egy változó igaz értékre van állítva, még akkor is, ha nem sikerül
eq(variables['System.debug'], true)
Futtatás, ha egy változó null (üres sztring)
Mivel az Azure Pipelinesban minden változó sztringként van kezelve, az üres sztring egyenértékű null
ebben a folyamatban.
variables:
- name: testEmpty
value: ''
jobs:
- job: A
steps:
- script: echo testEmpty is blank
condition: eq(variables.testEmpty, '')
Használjon egy sablonparamétert a feltétel részeként
Ha ugyanabban a folyamatban deklarál egy paramétert, amelyben a feltétel is szerepel, a paraméterbővítés a feltételek figyelembe vétele előtt történik. Ebben az esetben beágyazhat paramétereket a feltételekbe. A YAML-fájl szkriptje azért fog futni, mert parameters.doThing
igaz.
A condition
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 igaz értéket ad vissza, mert nem volt korábbi lépés.
A eq('${{ parameters.doThing }}', true)
függvény ellenőrzi, hogy a doThing paraméter egyenlő-e.true
Mivel a doThing alapértelmezett értéke igaz, a feltétel alapértelmezés szerint igaz értéket ad vissza, kivéve, ha egy másik érték van beállítva a folyamatban.
További sablonparaméter-példákért tekintse meg a Sablontípusok > használat című témakört.
parameters:
- name: doThing
default: true
type: boolean
steps:
- script: echo I did a thing
condition: ${{ eq(parameters.doThing, true) }}
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 tulajdonságokat kell átadnia a sablonoknak.
# 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) }}
# azure-pipeline.yml
parameters:
- name: doThing
default: true
type: boolean
trigger:
- none
extends:
template: parameters.yml
A folyamat kimenete azért van, I did a thing
mert a paraméter doThing
igaz.
Használja egy feltételben szereplő feladat kimeneti változóját egy következő feladatban
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 kell megjelölni a következő használatávalisOutput=true
: .
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."
Használjon egy feltételben szereplő lépésből létrehozott folyamatváltozót egy következő lépésben
A változót elérhetővé teheti a jövőbeli lépések számára, és megadhatja egy feltételben. Alapértelmezés szerint a lépésből létrehozott változók elérhetők a jövőbeli lépésekhez, és nem kell többfeladatos kimeneti változóként megjelölni a használatávalisOutput=true
.
A fenti megközelítéssel és hatókörkezeléssel kapcsolatban néhány fontos dolgot é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 a következő lépésekben lesznek elérhetők környezeti változókként.
- A lépésben létrehozott változók nem használhatók az őket definiáló lépésben.
Az alábbiakban egy folyamatváltozót hozunk létre egy lépésben, és a változót egy későbbi lépés feltételében és szkriptjében használjuk.
steps:
# This step creates a new pipeline variable: doThing. This variable will be available to subsquent steps.
- bash: |
echo "##vso[task.setvariable variable=doThing]Yes"
displayName: Step 1
# This step is able to use doThing, so it uses it in its condition
- script: |
# You can 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 használhatja. Ebben a YAML-fájlban például a feltétel eq(dependencies.A.result,'SucceededWithIssues')
lehetővé teszi a feladat futtatását, mert az A feladat 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 történik?
Ez a probléma akkor jelentkezik, ha a 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 üzenetsorban van, de nem fut, a teljes feladat megszakad, beleértve az összes többi szakaszt is.
További információ a folyamatok viselkedéséről a build lemondásakor.
Kapcsolódó cikkek
Visszajelzés
https://aka.ms/ContentUserFeedback.
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ:Visszajelzés küldése és megtekintése a következőhöz: