Szakaszok, függőségek és feltételek hozzáadása

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

A szakasz egy logikai határ egy Azure DevOps-folyamatban. Szakaszok csoportos műveletei a szoftverfejlesztési folyamatban, például az alkalmazás felépítésében, a tesztek futtatásában és az üzem előtti üzembe helyezésben. Minden szakasz egy vagy több feladatot tartalmaz.

Ha egy folyamat több szakaszát definiálja, alapértelmezés szerint egymás után futnak. A szakaszok egymástól is függhetnek. A kulcsszóval dependsOn függőségeket határozhat meg. A szakaszok az előző fázis eredményei alapján is futtathatók feltételekkel.

A párhuzamos feladatok és licencelés szakaszainak működéséről a Párhuzamos feladatok konfigurálása és fizetése című témakörben olvashat.

Ha szeretné megtudni, hogy a szakaszok hogyan kapcsolódnak a folyamat más részeihez, például a feladatokhoz, tekintse meg a főbb folyamatokra vonatkozó fogalmakat.

A YAML-sémaszakaszok cikkéből megtudhatja azt is, hogyan kapcsolódnak a szakaszok a folyamat egyes részeihez.

YAML

A folyamatfeladatokat fázisokba szervezheti. A fázisok a folyamatok fő osztásai: az alkalmazás létrehozása, a tesztek futtatása és az előkészítésre való üzembe helyezés jó példák a szakaszokra. Ezek logikai határok a folyamatban, ahol szüneteltetheti a folyamatot, és különböző ellenőrzéseket hajthat végre.

Minden folyamatnak van legalább egy szakasza, még akkor is, ha nem definiálja explicit módon. A fázisokat függőségi gráfba is rendezheti, így az egyik fázis a másik előtt fut. Egy szakaszon legfeljebb 256 feladat lehet.

Klasszikus

A kiadási folyamat üzembehelyezési feladatait szakaszokba rendezheti. A szakaszok a kiadási folyamat fő részlegei. Ilyenek például a funkcionális tesztek futtatása, az üzem előtti üzembe helyezés és az éles környezetben való üzembe helyezés.

A kiadási folyamat egy szakasza feladatokbólés feladatokból áll.

A jóváhagyások és kapuk, az üzembehelyezési feltételek és az eseményindítók, valamint a sorba állítási szabályzatok szabályozzák, hogy a kiadás mikor lesz üzembe helyezve egy fázisban.

Szakaszok megadása

YAML

A legegyszerűbb esetben nincs szükség logikai határokra a folyamatban. Ezekben a forgatókönyvekben közvetlenül megadhatja a YAML-fájlban lévő feladatokat a stages kulcsszó nélkül. Ha például egy egyszerű folyamattal rendelkezik, amely külön környezetek vagy üzembe helyezési lépések nélkül hoz létre és tesztel egy kis alkalmazást, az összes feladatot közvetlenül, szakaszok használata nélkül definiálhatja.

pool:
  vmImage: 'ubuntu-latest'

jobs:
- job: BuildAndTest
  steps:
  - script: echo "Building the application"
  - script: echo "Running tests"

Ez a folyamat egy implicit szakaszsal és két feladattal rendelkezik. A stages kulcsszó nem használatos, mert csak egy szakasz van.

jobs:
- job: Build
  steps:
  - bash: echo "Building"

- job: Test
  steps:
  - bash: echo "Testing"

Ha több szakaszba szeretné rendezni a folyamatot, használja a kulcsszót stages . Ez a YAML két fázisból álló folyamatot határoz meg, ahol minden szakasz több feladatot tartalmaz, és minden feladat konkrét lépéseket hajt végre.

stages:
- stage: A
  displayName: "Stage A - Build and Test"
  jobs:
  - job: A1
    displayName: "Job A1 - build"
    steps:
    - script: echo "Building the application in Job A1"
      displayName: "Build step"
  - job: A2
    displayName: "Job A2 - Test"
    steps:
    - script: echo "Running tests in Job A2"
      displayName: "Test step"

- stage: B
  displayName: "Stage B - Deploy"
  jobs:
  - job: B1
    displayName: "Job B1 - Deploy to Staging"
    steps:
    - script: echo "Deploying to staging in Job B1"
      displayName: "Staging deployment step"
  - job: B2
    displayName: "Job B2 - Deploy to Production"
    steps:
    - script: echo "Deploying to production in Job B2"
      displayName: "Production deployment step"

Ha a fázis szintjén ad meg egy feladatot pool , az adott fázisban lévő összes feladat ezt a készletet használja, kivéve, ha a fázis a feladat szintjén van megadva.

stages:
- stage: A
  pool: StageAPool
  jobs:
  - job: A1 # will run on "StageAPool" pool based on the pool defined on the stage
  - job: A2 # will run on "JobPool" pool
    pool: JobPool

Klasszikus

Ha szakaszt szeretne hozzáadni a kiadási folyamathoz, válassza ki a kiadási folyamatot a Kiadások lapon, válassza a Szerkesztés, majd a Folyamat lapot. Bár a szakaszok meghatározásának legfontosabb része az automatizálási feladatok, a kiadási folyamat egy szakaszához több tulajdonságot és beállítást is konfigurálhat. A következőket teheti:

• Szükség esetén módosítsa a szakasz nevét.
• Jelöljön ki egy felhasználót vagy csoportot a szakasz tulajdonosának. A szakasztulajdonosok értesítést kapnak, ha az adott szakasz üzembe helyezése meghiúsul. A színpad tulajdonjoga nem tartalmazza automatikusan az engedélyeket.
• Törölje a szakaszt a folyamatból.
• A szakaszok sorrendjének módosítása.
• Mentse a szakasz másolatát szakaszsablonként.
• A szakasz biztonsági beállításainak kezelése.

Függőségek megadása

YAML

Ha több fázist határoz meg egy folyamatban, azok alapértelmezés szerint egymás után futnak a YAML-fájlban megadott sorrendben. Ez alól kivételt képeznek a függőségek hozzáadásakor. Függőségek esetén a szakaszok a követelmények sorrendjében futnak dependsOn .

A csővezetékeknek legalább egy olyan szakaszt kell tartalmazniuk, amelynek nincsenek függőségei.

A szakaszok definiálásával kapcsolatos további információkért lásd: Szakaszok a YAML-sémában.

Az alábbi példaszakaszok egymás után futnak. Ha nem használ kulcsszót dependsOn , a szakaszok a definiált sorrendben futnak.

stages:
- stage: Build
  displayName: "Build Stage"
  jobs:
  - job: BuildJob
    steps:
    - script: echo "Building the application"
      displayName: "Build Step"

- stage: Test
  displayName: "Test Stage"
  jobs:
  - job: TestJob
    steps:
    - script: echo "Running tests"
      displayName: "Test Step"

Párhuzamosan futó példaszakaszok:

stages:
- stage: FunctionalTest
  displayName: "Functional Test Stage"
  jobs:
  - job: FunctionalTestJob
    steps:
    - script: echo "Running functional tests"
      displayName: "Run Functional Tests"

- stage: AcceptanceTest
  displayName: "Acceptance Test Stage"
  dependsOn: [] # Runs in parallel with FunctionalTest
  jobs:
  - job: AcceptanceTestJob
    steps:
    - script: echo "Running acceptance tests"
      displayName: "Run Acceptance Tests"

Példa a ventilátor és a ventilátor viselkedésére:

stages:
- stage: Test

- stage: DeployUS1
  dependsOn: Test    #  stage runs after Test

- stage: DeployUS2
  dependsOn: Test    # stage runs in parallel with DeployUS1, after Test

- stage: DeployEurope
  dependsOn:         # stage runs after DeployUS1 and DeployUS2
  - DeployUS1
  - DeployUS2

Klasszikus

A függőségek szabályozása eseményindítók beállításával a kiadási folyamat egyes szakaszaiban:

• A szakaszok eseményindítóval futnak, vagy manuálisan indulnak el.
• A kiadás utáni eseményindító esetén a szakasz a kiadás kezdetekor azonnal elindul, és párhuzamosan fut más, azonos eseményindítóval rendelkező szakaszokkal.
• A Szakasz utáni eseményindítóval a szakasz az összes függő szakasz befejezése után indul el. Ezzel modellezheti a szakaszok szétterjedési és összefutási viselkedését.

Feltételek meghatározása

Kifejezésekkel adhatja meg azokat a feltételeket, amelyek mellett az egyes szakaszok futnak. Alapértelmezés szerint egy szakasz akkor fut, ha nem függ semmilyen más fázistól, vagy ha az összes fázis, amelytől függ, befejeződött és sikeres volt. Ezt a viselkedést úgy szabhatja testre, hogy egy szakaszt arra kényszerít, hogy futtasson még akkor is, ha egy előző szakasz meghibásodik, vagy egyéni feltételt ad meg.

Ha testre szabja az előző lépések alapértelmezett feltételét egy szakaszhoz, akkor eltávolítja a befejezés és a sikeresség feltételeit. Ha tehát egyéni feltételt használ, gyakran használatos and(succeeded(),custom_condition) annak ellenőrzésére, hogy az előző szakasz sikeresen lefutott-e. Ellenkező esetben a szakasz az előző szakasz eredményétől függetlenül fut.

Megjegyzés:

A sikertelen ('JOBNAME/STAGENAME') és a sikeres ('JOBNAME/STAGENAME') feltételek a következő példában látható módon csak YAML-folyamatok esetében működnek.

YAML

Példa egy szakasz futtatására az előző szakasz futtatásának állapota alapján:

stages:
- stage: A

# stage B runs if A fails
- stage: B
  condition: failed()

# stage C runs if B succeeds
- stage: C
  dependsOn:
  - A
  - B
  condition: succeeded('B')

Példa egyéni feltétel használatára:

stages:
- stage: A

- stage: B
  condition: and(succeeded(), eq(variables['build.sourceBranch'], 'refs/heads/main'))

Klasszikus

Ha az After release vagy az After stage triggereket adja meg, akkor megadhatja a kiadásban felhasznált artefaktumok ágszűrőit is. A kiadások csak akkor lesznek üzembe helyezve egy fázisban, ha az ágszűrők teljesülnek.

Sorbanállási szabályzatok megadása

YAML

A YAML-folyamatok nem támogatják a sorba állítási szabályzatokat. A csővezeték minden futtatása független a többi futtatástól, és nem érzékel más futtatásokat. Más szóval a két egymást követő véglegesítés két folyamatot indíthat el, és mindkettő ugyanazt a szakaszsorozatot hajtja végre anélkül, hogy megvárná egymást. Bár a YAML-folyamatokra sorba állítási szabályzatokat hozunk létre, javasoljuk, hogy manuális jóváhagyásokkal manuálisan rendezze és vezérelje a végrehajtás sorrendjét, ha ez fontos.

Klasszikus

Bizonyos esetekben előfordulhat, hogy gyorsabban hozhat létre buildeket, mint amennyit üzembe lehet helyezni. Azt is megteheti, hogy több ügynököt is konfigurál, és például ugyanabból a kiadási folyamatból hoz létre kiadásokat a különböző összetevők üzembe helyezéséhez. Ilyen esetekben hasznos lehet szabályozni, hogyan kerüljenek sorba a kiadások egy fázisban. A sorba állítási szabályzatok ezt a vezérlést biztosítják.

A sorkezelési szabályzathoz a következő lehetőségek közül választhat:

• Párhuzamos üzemelő példányok száma: Ezt a lehetőséget akkor használja, ha dinamikusan épít ki új erőforrásokat a fázisban, és fizikailag képes egyszerre több kiadás üzembe helyezését kezelni, de korlátozni szeretné a párhuzamos üzembe helyezések számát.

• Ha maximális számú üzembe helyezést ad meg, két további lehetőség jelenik meg:

  • Az összes üzembe helyezése sorrendben: Ezt a lehetőséget akkor használja, ha az összes kiadást egymás után szeretné üzembe helyezni ugyanabban a megosztott fizikai erőforrásban. A buildek egymás utáni üzembe helyezésével biztosíthatja, hogy két üzembe helyezési feladat ne célozza meg egyszerre ugyanazokat a fizikai erőforrásokat, még akkor sem, ha több build- és kiadási ügynök áll rendelkezésre. Emellett gondoskodnia kell arról, hogy a szakasz előzetes üzembe helyezési jóváhagyási kérelmei sorrendben legyenek elküldve.

  • Telepítse a legújabb verziót, és mondja le a többit: Ezt a lehetőséget akkor használja, ha a kiadásoknál gyorsabban készít buildeket, és csak a legújabb buildet szeretné üzembe helyezni.

A beállítások működésének megértéséhez fontolja meg azt a forgatókönyvet, amelyben az egyetlen kiadási folyamat R1, R2, ..., R5 kiadásai gyorsan egymás után jönnek létre. Tegyük fel, hogy a folyamat első szakasza QA néven van elnevezve, és előre üzembe helyezést és üzembe helyezés utáni jóváhagyókat is definiált.

• Ha nem határoz meg korlátot a párhuzamos üzemelő példányok számára, a rendszer a kiadások létrehozása után mind az öt jóváhagyási kérelmet elküldi. Ha a jóváhagyók minden kiadást jóváhagynak, azok mind párhuzamosan kerülnek üzembe helyezésre a QA szakaszban. (ha a A minőségbiztosítási fázisban nem definiáltak előre üzembe helyezési jóváhagyókat, az öt kiadás automatikusan üzembe lesz helyezve ezzel a fázissal párhuzamosan.

• Ha korlátot ad meg, és minden üzembe helyezés egymás után történik, és a korlát már el lett érve, először az R1 kiadás előzetes üzembe helyezési jóváhagyása kerül elküldésre. A jóváhagyás befejezése után megkezdődik az R1 kiadás üzembe helyezése a minőségbiztosítási fázisban. Ezután a rendszer elküldi az üzembe helyezés utáni jóváhagyásra vonatkozó kérést az R1 kiadáshoz. Csak az üzembe helyezés utáni jóváhagyás befejezése után kezdődik meg az R2 kiadás végrehajtása, és a rendszer elküldi az előzetes üzembe helyezés jóváhagyását. A folyamat így folytatódik az összes kiadás esetében.

• Ha korlátot ad meg, és telepíti a legújabbat, és visszavonja a többit, és a korlát már el lett érve, akkor az R2, R3 és R4 kiadások ki lesznek hagyva, és a QA fázisban lévő R5 előzetes üzembe helyezési jóváhagyása azonnal ki lesz küldve, miután az R1 kiadás utáni üzembe helyezési jóváhagyás megtörtént.

Jóváhagyások megadása

YAML

Manuálisan szabályozhatja, hogy mikor fusson egy szakasz jóváhagyási ellenőrzésekkel. Ezt gyakran használják az éles környezetekben történő üzembe helyezési folyamatok felügyeletére. Az ellenőrzések egy olyan mechanizmus, amely az erőforrás tulajdonosának rendelkezésére áll annak szabályozására, hogy a folyamat egy szakasza mikor és mikor használhat fel erőforrást. Egy erőforrás, például egy környezet tulajdonosaként megadhatja azokat az ellenőrzéseket, amelyeket teljesítenie kell ahhoz, hogy megkezdődjön az erőforrás egy szakaszának felhasználása.

Jelenleg a manuális jóváhagyási ellenőrzések támogatottak a környezetekben. További információ: Jóváhagyások.

Klasszikus

A folyamat egyes szakaszainak elején vagy végén manuális jóváhagyásokat adhat hozzá. További információért tekintse meg a Kiadási jóváhagyások és kapuk áttekintése című részt.

Manuális eseményindító hozzáadása

A manuálisan aktivált YAML-folyamatszakaszok lehetővé teszik, hogy egységes csővezeték legyen, anélkül, hogy azt mindig a végéig kellene futtatni.

Például a folyamat tartalmazhat szakaszokat építésre, tesztelésre, előkészítési környezetbe való üzembe helyezésre és éles környezetbe való üzembe helyezésre. Előfordulhat, hogy azt szeretné, hogy az éles üzembe helyezés kivételével minden fázis automatikusan fusson, amelyet érdemes manuálisan aktiválni, amikor készen áll.

A funkció használatához adja hozzá a trigger: manual tulajdonságot egy szakaszhoz.

Az alábbi példában a fejlesztési fázis automatikusan fut, míg az éles fázis manuális aktiválást igényel. Mindkét szakasz egy hello world kimeneti szkriptet futtat.

stages:
- stage: Development
  displayName: Deploy to development
  jobs:
  - job: DeployJob
    steps:
    - script: echo 'hello, world'
      displayName: 'Run script'
- stage: Production
  displayName: Deploy to production
  trigger: manual
  jobs:
  - job: DeployJob
    steps:
    - script: echo 'hello, world'
      displayName: 'Run script'

Szakasz megjelölése kihagyhatatlannak

Jelöljön meg egy szakaszt isSkippable: false-ként, hogy megakadályozza, hogy a folyamat felhasználói kihagyják a fázisokat. Előfordulhat például, hogy van egy YAML-sablonja, amely egy olyan szakaszt injektál, amely kártevőészlelést végez az összes folyamatban. Ha ezt a szakaszt állítja be isSkippable: false , a folyamat nem fogja tudni kihagyni a kártevők észlelését.

A következő példában a kártevőészlelési szakasz nem kihagyhatóként van megjelölve, ami azt jelenti, hogy a folyamat futtatásának részeként kell végrehajtani.

- stage: malware_detection
  displayName: Malware detection
  isSkippable: false
  jobs:
  - job: check_job
    ...

Ha egy szakasz nem ugorható ki, akkor egy letiltott jelölőnégyzettel jelenik meg a Fázisok futtatásához konfigurációs panelen.