Feltételek megadása

  • Cikk

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 trueeseté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. stage2csak 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 truetörténik.

Ebben a folyamatban a stage2 következőtől stage1fü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, stage2akkor 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 stage1false 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.