Feladatok meghatározása a folyamatban

Azure DevOps Services | Azure DevOps Server 2022 – Azure DevOps Server 2019

A folyamatot feladatokba rendezheti. Minden folyamathoz tartozik legalább egy feladat. A feladatok olyan lépések sorozatai, amelyek egymás után futnak egységként. Más szóval a feladat az ütemezhető legkisebb munkaegység.

A folyamatokat alkotó fő fogalmakkal és összetevőkkel kapcsolatos információkért tekintse meg az új Azure Pipelines-felhasználók legfontosabb fogalmait.

Az Azure Pipelines nem támogatja a YAML-folyamatok feladatprioritását. A feladatok futásának szabályozásához feltételeket és függőségeket adhat meg.

Egyetlen feladat definiálása

YAML

A legegyszerűbb esetben egy folyamat egyetlen feladatból áll. Ebben az esetben csak akkor kell explicit módon használnia a job kulcsszót, ha sablont használ. Közvetlenül megadhatja a YAML-fájl lépéseit.

Ez a YAML-fájl egy Microsoft által üzemeltetett ügynökön és kimeneteken futó feladatokkal rendelkezikHello world.

pool:
  vmImage: 'ubuntu-latest'
steps:
- bash: echo "Hello world"

Előfordulhat, hogy további tulajdonságokat szeretne megadni a feladathoz. Ebben az esetben használhatja a kulcsszót job .

jobs:
- job: myJob
  timeoutInMinutes: 10
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - bash: echo "Hello world"

A folyamat több feladatból is állhat. Ebben az esetben használja a kulcsszót jobs .

jobs:
- job: A
  steps:
  - bash: echo "A"

- job: B
  steps:
  - bash: echo "B"

A folyamat több fázisból állhat, amelyek mindegyike több feladattal rendelkezik. Ebben az esetben használja a kulcsszót stages .

stages:
- stage: A
  jobs:
  - job: A1
  - job: A2

- stage: B
  jobs:
  - job: B1
  - job: B2

A feladat megadásához a teljes szintaxis a következő:

- job: string  # name of the job, A-Z, a-z, 0-9, and underscore
  displayName: string  # friendly name to display in the UI
  dependsOn: string | [ string ]
  condition: string
  strategy:
    parallel: # parallel strategy
    matrix: # matrix strategy
    maxParallel: number # maximum number simultaneous matrix legs to run
    # note: `parallel` and `matrix` are mutually exclusive
    # you may specify one or the other; including both is an error
    # `maxParallel` is only valid with `matrix`
  continueOnError: boolean  # 'true' if future jobs should run even if this job fails; defaults to 'false'
  pool: pool # agent pool
  workspace:
    clean: outputs | resources | all # what to clean up before the job runs
  container: containerReference # container to run this job inside
  timeoutInMinutes: number # how long to run the job before automatically cancelling
  cancelTimeoutInMinutes: number # how much time to give 'run always even if cancelled tasks' before killing them
  variables: { string: string } | [ variable | variableReference ] 
  steps: [ script | bash | pwsh | powershell | checkout | task | templateReference ]
  services: { string: string | container } # container resources to run as a service container
  uses: # Any resources (repos or pools) required by this job that are not already referenced
    repositories: [ string ] # Repository references to Azure Git repositories
    pools: [ string ] # Pool names, typically when using a matrix strategy for the job

Ha a feladat elsődleges célja az alkalmazás üzembe helyezése (az alkalmazás létrehozása vagy tesztelése helyett), akkor használhat egy speciális típusú, úgynevezett üzembe helyezési feladatot.

Az üzembehelyezési feladat szintaxisa a következő:

- deployment: string        # instead of job keyword, use deployment keyword
  pool:
    name: string
    demands: string | [ string ]
  environment: string
  strategy:
    runOnce:
      deploy:
        steps:
        - script: echo Hi!

Bár az üzembehelyezési feladatokhoz is hozzáadhat lépéseket, jobjavasoljuk, hogy inkább egy üzembe helyezési feladatot használjon. Az üzembe helyezési feladatoknak van néhány előnye. Üzembe helyezhet például egy környezetben, amely olyan előnyöket is tartalmaz, mint például az üzembe helyezett adatok előzményeinek megtekintése.

Klasszikus

Ha feladatokat szeretne hozzáadni a buildelési folyamathoz, szerkessze a folyamatot a Folyamatok lapon. Válassza a ... lehetőséget egy feladat hozzáadásához.

Ha feladatokat szeretne hozzáadni a kiadási folyamathoz, szerkessze a folyamatot a Pipelines Releasesből>. Tekintse meg a szakaszfeladatokat abban a szakaszban, ahol hozzá szeretné adni a feladatot. Válassza a ... lehetőséget egy feladat hozzáadásához.

Feladatok típusai

A feladatok különböző típusúak lehetnek, attól függően, hogy hol futnak.

YAML

• Az ügynökkészlet-feladatok egy ügynökkészletben található ügynökön futnak.
• A kiszolgálófeladatok az Azure DevOps Serveren futnak.
• A tárolófeladatok egy ügynökkészletben található ügynökhöz tartozó tárolóban futnak. A tárolók kiválasztásáról további információt a Tárolófeladatok definiálása című témakörben talál.

Klasszikus

• Az ügynökkészlet-feladatok egy ügynökkészletben található ügynökön futnak.
• A kiszolgálófeladatok az Azure DevOps Serveren futnak.
• Az üzembehelyezésicsoport-feladatok üzembehelyezési csoportban található gépeken futnak. Ezek a feladatok csak kiadási folyamatban érhetők el. A célkiszolgálók üzembe helyezési csoportjainak definiálásáról további információt az Üzembehelyezési csoport feladatai című témakörben talál.

Ügynökkészlet-feladatok

Ezek a leggyakoribb típusú feladatok, és egy ügynökkészlet ügynökén futnak.

• A Microsoft által üzemeltetett ügynökök használatakor a folyamat minden feladata új ügynököt kap.
• A saját üzemeltetésű ügynökökkel kapcsolatos igényeket használva megadhatja, hogy az ügynök milyen képességeket használjon a feladat futtatásához. Ugyanazt az ügynököt szerezheti be az egymást követő feladatokhoz, attól függően, hogy egynél több ügynök van-e az ügynökkészletben, amely megfelel a folyamat igényeinek. Ha a készletben csak egy ügynök található, amely megfelel a folyamat igényeinek, a folyamat megvárja, amíg ez az ügynök elérhetővé válik.

Feljegyzés

Az igényeket és képességeket saját üzemeltetésű ügynökökkel való használatra tervezték, hogy a feladatok megfelelhessenek a feladat követelményeinek megfelelő ügynöknek. A Microsoft által üzemeltetett ügynökök használatakor kiválaszt egy olyan képet az ügynökhöz, amely megfelel a feladat követelményeinek, így bár lehetőség van képességek hozzáadására a Microsoft által üzemeltetett ügynökökhöz, nem kell a Microsoft által üzemeltetett ügynökökkel használnia a képességeket.

YAML

pool:
  name: myPrivateAgents    # your job runs on an agent in this pool
  demands: agent.os -equals Windows_NT    # the agent must have this capability to run the job
steps:
- script: echo hello world

Vagy több igény:

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse
steps:
- script: echo hello world

Klasszikus

Megadhatja a folyamat, a feladatok vagy mindkettő követelményeit. Ha a folyamatokban és a feladatokban is követelményeket ad meg, a rendszernek az ügynök kiválasztásához a két követelménycsoport egyesítésére van szükség.

További információ az ügynök képességeiről.

Kiszolgálói feladatok

A kiszolgálói feladatok feladatait a kiszolgálón (Azure Pipelines vagy TFS) vezénylik és hajtják végre. A kiszolgálói feladatokhoz nincs szükség ügynökre vagy célszámítógépre. Most már csak néhány feladat támogatott egy kiszolgálói feladatban. A kiszolgálói feladatok maximális időtartama 30 nap.

Ügynök nélküli feladatok által támogatott feladatok

Ügynök nélküli feladatok esetében jelenleg csak a következő feladatok támogatottak:

• Tevékenység késleltetése
• Azure-függvényfeladat meghívása
• REST API-feladat meghívása
• Manuális érvényesítési feladat
• Közzététel az Azure Service Bus-feladatban
• Azure Monitor-riasztások lekérdezése feladat
• Munkaelemek lekérdezése feladat

Mivel a tevékenységek bővíthetőek, bővítmények használatával több ügynök nélküli tevékenységet is hozzáadhat. Az ügynök nélküli feladatok alapértelmezett időtúllépése 60 perc.

YAML

A kiszolgálói feladat megadásának teljes szintaxisa a következő:

jobs:
- job: string
  timeoutInMinutes: number
  cancelTimeoutInMinutes: number
  strategy:
    maxParallel: number
    matrix: { string: { string: string } }

  pool: server # note: the value 'server' is a reserved keyword which indicates this is an agentless job

Az egyszerűsített szintaxist is használhatja:

jobs:
- job: string
  pool: server # note: the value 'server' is a reserved keyword which indicates this is an agentless job

Klasszikus

Kiszolgálói feladatot a szerkesztőben a "..." elemet választva vehet fel. a folyamat Feladat lapján található Folyamat csatornán. A kiszolgálói feladat tulajdonságai akkor jelennek meg, amikor kiválasztja a feladatot a szerkesztőben.

Függőségek

Ha több feladatot határoz meg egyetlen szakaszban, megadhatja a közöttük lévő függőségeket. A folyamatoknak legalább egy, függőségek nélküli feladatot kell tartalmazniuk. Alapértelmezés szerint az Azure DevOps YAML-folyamatfeladatok párhuzamosan futnak, kivéve, ha az dependsOn érték be van állítva.

Feljegyzés

Minden ügynök egyszerre csak egy feladatot futtathat. Több feladat párhuzamos futtatásához több ügynököt kell konfigurálni. Elegendő párhuzamos feladatra is szüksége van.

YAML

Több feladat és függőségük meghatározásának szintaxisa a következő:

jobs:
- job: string
  dependsOn: string
  condition: string

Példafeladatok, amelyek egymás után jönnek létre:

jobs:
- job: Debug
  steps:
  - script: echo hello from the Debug build
- job: Release
  dependsOn: Debug
  steps:
  - script: echo hello from the Release build

Párhuzamos buildelési példafeladatok (függőségek nélkül):

jobs:
- job: Windows
  pool:
    vmImage: 'windows-latest'
  steps:
  - script: echo hello from Windows
- job: macOS
  pool:
    vmImage: 'macOS-latest'
  steps:
  - script: echo hello from macOS
- job: Linux
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: echo hello from Linux

Példa a kifúvatott ventilátorra:

jobs:
- job: InitialJob
  steps:
  - script: echo hello from initial job
- job: SubsequentA
  dependsOn: InitialJob
  steps:
  - script: echo hello from subsequent A
- job: SubsequentB
  dependsOn: InitialJob
  steps:
  - script: echo hello from subsequent B

Példa a beillő ventilátorra:

jobs:
- job: InitialA
  steps:
  - script: echo hello from initial A
- job: InitialB
  steps:
  - script: echo hello from initial B
- job: Subsequent
  dependsOn:
  - InitialA
  - InitialB
  steps:
  - script: echo hello from subsequent

Klasszikus

Új feladat hozzáadásához válassza a "..." lehetőséget. a folyamat Feladat lapján található folyamatcsatornán. A feladatok végrehajtásának feltételei és sorrendje akkor jelenik meg, amikor kiválasztja a feladatot a szerkesztőben.

Ha több feladatot ad meg egy buildelési folyamatban, azok alapértelmezés szerint párhuzamosan futnak. A feladatok végrehajtásának sorrendjét a feladatok közötti függőségek konfigurálásával adhatja meg. A feladatfüggőségek nem támogatottak a kiadási folyamatokban. A kiadási folyamatban több feladat fut egymás után.

Az alábbi folyamat például két ügynökfeladat és egy kiszolgálói feladat használatával külön végrehajtási feladatokra osztja a teljes kiadás végrehajtását.

A fenti példában:

1. A kiadás első feladatában szereplő feladatok egy ügynökön futnak, és a feladat befejezése után az ügynök ki lesz adva.

2. A kiszolgálói feladat tartalmaz egy manuális beavatkozási feladatot, amely az Azure Pipelineson vagy a TFS-en fut. A feladat nem hajtható végre ügynökön vagy célkiszolgálón, és nem is igényel. A manuális beavatkozási feladat megjeleníti az üzenetét, és megvárja a felhasználó "önéletrajz" vagy "elutasítás" válaszát. Ebben a példában, ha eléri a konfigurált időtúllépést, a tevékenység automatikusan elutasítja az üzembe helyezést (ha nem szeretné, hogy automatikus választ hozzon létre, állítsa nullára az időtúllépést a vezérlési beállítások szakaszban).

3. Ha a kiadás folytatódik, a harmadik feladat feladatai futnak – valószínűleg egy másik ügynökön. Ha a kiadás elutasításra kerül, ez a feladat nem fut, és a kiadás sikertelenként van megjelölve.

Fontos megérteni a szakaszos végrehajtás néhány következményét:

• Minden feladat különböző ügynököket használhat. Ne feltételezze, hogy egy korábbi feladat állapota elérhető a későbbi feladatok során.

• A Continue on Error and Always run options for tasks in each job nincs hatással a következő feladatok tevékenységeire. Például az Always run on a task on the first job end of the first job nem garantálja, hogy a következő feladatokban lévő tevékenységek futnak.

Feltételek

Megadhatja az egyes feladatok futtatásának feltételeit. Alapértelmezés szerint egy feladat akkor fut, ha az nem függ más feladatoktól, vagy ha az összes feladat, amelytől függ, befejeződött és sikeres volt. Ezt a viselkedést úgy szabhatja testre, hogy egy feladat futtatására kényszeríti a feladatot, még akkor is, ha egy korábbi feladat meghiúsul, vagy egyéni feltételt ad meg.

YAML

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

jobs:
- job: A
  steps:
  - script: exit 1

- job: B
  dependsOn: A
  condition: failed()
  steps:
  - script: echo this will run when A fails

- job: C
  dependsOn:
  - A
  - B
  condition: succeeded('B')
  steps:
  - script: echo this will run when B runs and succeeds

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

jobs:
- job: A
  steps:
  - script: echo hello

- job: B
  dependsOn: A
  condition: and(succeeded(), eq(variables['build.sourceBranch'], 'refs/heads/main'))
  steps:
  - script: echo this only runs for master

Megadhatja, hogy egy feladat egy korábbi feladatban beállított kimeneti változó értéke alapján fusson. Ebben az esetben csak a közvetlenül függő feladatokban beállított változókat használhatja:

jobs:
- job: A
  steps:
  - script: "echo '##vso[task.setvariable variable=skipsubsequent;isOutput=true]false'"
    name: printvar

- job: B
  condition: and(succeeded(), ne(dependencies.A.outputs['printvar.skipsubsequent'], 'true'))
  dependsOn: A
  steps:
  - script: echo hello from B

Klasszikus

A feladat futtatása ügynök- vagy kiszolgálófeladaton beállítással csak adott feltételek teljesülése esetén futtathatja a feladatokat. Válasszon ki egy előre definiált feltételt, vagy válassza az "egyéni" lehetőséget, és adjon meg egy igaz vagy hamis értéket kiértékelő kifejezést. Beágyazott kifejezések használhatók, és a kifejezések hozzáférhetnek a kiadási folyamatban elérhető változókhoz.

Időtúllépések

Ha el szeretné kerülni az erőforrás-felhasználást, ha a feladat nem válaszol vagy túl sokáig várakozik, érdemes korlátozni, hogy mennyi ideig futhasson a feladat. A feladat időtúllépési beállításával megadhatja a feladat futtatására vonatkozó korlátot percekben. Az érték nullára állítása azt jelenti, hogy a feladat futtatható:

• Örökre a saját üzemeltetésű ügynökökön
• 360 percig (6 óra) a Microsoft által üzemeltetett ügynökökön nyilvános projekttel és nyilvános adattárral
• 60 percig a Microsoft által üzemeltetett ügynökök magánprojekttel vagy privát adattárral (kivéve, ha további kapacitást fizetnek)

Az időtúllépési időszak a feladat futásának kezdetekor kezdődik. Nem tartalmazza azt az időt, amikor a feladat várólistára kerül, vagy egy ügynökre vár.

YAML

Ez timeoutInMinutes lehetővé teszi a feladat végrehajtásának időtartamára vonatkozó korlát beállítását. Ha nincs megadva, az alapértelmezett érték 60 perc. Ha 0 meg van adva, a maximális korlátot használja a rendszer (a fent leírtak szerint).

Ez cancelTimeoutInMinutes lehetővé teszi a feladat megszakítási idejének korlátozását, ha az üzembe helyezési feladat úgy van beállítva, hogy továbbra is fusson, ha egy korábbi feladat sikertelen volt. Ha nincs megadva, az alapértelmezett érték 5 perc. Az értéknek 1 és 35790 perc közötti tartományban kell lennie.

jobs:
- job: Test
  timeoutInMinutes: 10 # how long to run the job before automatically cancelling
  cancelTimeoutInMinutes: 2 # how much time to give 'run always even if cancelled tasks' before stopping them

Klasszikus

Jelölje ki a feladatot, majd adja meg az időtúllépési értéket.

A Beállítások lapon megadhatja a folyamat összes feladatának alapértelmezett értékeit. Ha nemero értéket ad meg a feladat időtúllépéséhez, az felülírja a folyamatbeállításokban megadott értékeket. Ha nulla értéket ad meg, akkor a rendszer a folyamatbeállításokból származó időtúllépési értéket használja. Ha a folyamat értéke szintén nulla, akkor nincs időtúllépés.

Az időtúllépések a következő szintű elsőbbséget élvezik.

1. A Microsoft által üzemeltetett ügynökök esetében a feladatok korlátozottak abban az esetben, ha a projekt típusa alapján futtathatók, és hogy fizetős párhuzamos feladattal futnak-e. Amikor a Microsoft által üzemeltetett feladat időtúllépési időköze el nem telik, a feladat leáll. A Microsoft által üzemeltetett ügynökök esetében a feladatok nem futhatnak tovább ennél az intervallumnál, függetlenül a feladatban megadott feladatszintű időtúllépéstől.
2. A feladat szintjén konfigurált időtúllépés határozza meg a feladat futtatásának maximális időtartamát. Amikor a feladatszint időtúllépési időköze eltelik, a feladat leáll. Ha a feladatot Egy Microsoft által üzemeltetett ügynökön futtatják, a feladatszint időtúllépésének beállítása a Microsoft által üzemeltetett feladatok beépített időkorlátjánál nagyobb időközre nincs hatással, és a Rendszer a Microsoft által üzemeltetett feladatok időtúllépését használja.
3. Az időtúllépést külön-külön is beállíthatja – lásd a tevékenységvezérlési beállításokat. Ha a feladatszint időtúllépési időköze a tevékenység befejezése előtt eltelik, a futó feladat leáll, még akkor is, ha a tevékenység hosszabb időtúllépési intervallummal van konfigurálva.

Többfeladatos konfiguráció

Egyetlen ön által létrehozott feladatból egyszerre több feladatot is futtathat több ügynökön. Néhány példa:

• Többkonfigurációs buildek: Több konfigurációt is létrehozhat párhuzamosan. Létrehozhat például egy Visual C++ alkalmazást mindkettőhöz debug és release konfigurációhoz mindkét x86 x64 platformon. További információ: Visual Studio Build – több konfiguráció több platformhoz.

• Többkonfigurációs üzemelő példányok: Több üzembe helyezést is futtathat párhuzamosan, például különböző földrajzi régiókba.

• Többkonfigurációs tesztelés: Egyszerre több konfigurációt is futtathat.

• A többkonfiguráció mindig létrehoz legalább egy feladatot, még akkor is, ha egy többkonfigurációs változó üres.

YAML

A matrix stratégia lehetővé teszi, hogy egy feladat több alkalommal, különböző változókészletekkel legyen elküldve. A maxParallel címke korlátozza a párhuzamosság mértékét. A rendszer háromszor küldi el a következő feladatot a hely és a böngésző megadott értékeivel. Egyszerre azonban csak két feladat fut.

jobs:
- job: Test
  strategy:
    maxParallel: 2
    matrix: 
      US_IE:
        Location: US
        Browser: IE
      US_Chrome:
        Location: US
        Browser: Chrome
      Europe_Chrome:
        Location: Europe
        Browser: Chrome

Feljegyzés

A mátrix konfigurációs neveinek (a fentihez hasonlóan US_IE ) csak egyszerű latin betűs betűket (A-Z, a-z), számokat és aláhúzásjeleket (_) kell tartalmazniuk. Az oszlopok nevének betűvel kell kezdődnie. Emellett legalább 100 karakter hosszúságúnak kell lenniük.

Kimeneti változók használatával is létrehozhat egy mátrixot. Ez hasznos lehet, ha szkripttel kell létrehoznia a mátrixot.

matrix sztringezett JSON-objektumot tartalmazó futtatókörnyezeti kifejezést fogad el. A kibontott JSON-objektumnak meg kell egyeznie a mátrixozási szintaxissal. Az alábbi példában keményen kódoltuk a JSON-sztringet, de szkriptnyelv vagy parancssori program is létrehozhatja.

jobs:
- job: generator
  steps:
  - bash: echo "##vso[task.setVariable variable=legs;isOutput=true]{'a':{'myvar':'A'}, 'b':{'myvar':'B'}}"
    name: mtrx
  # This expands to the matrix
  #   a:
  #     myvar: A
  #   b:
  #     myvar: B
- job: runner
  dependsOn: generator
  strategy:
    matrix: $[ dependencies.generator.outputs['mtrx.legs'] ]
  steps:
  - script: echo $(myvar) # echos A or B depending on which leg is running

Klasszikus

Ha több feladatot szeretne több konfigurációs beállítással futtatni, azonosítsa a szorzó nevű változót, és adja meg a szorzó értékeinek listáját. A lista minden értékéhez külön feladat fut. A szorzók buildeléshez vagy üzembe helyezéshez való használatához a következőkkel kell rendelkeznie:

• Definiáljon egy vagy több változót a folyamat Változók lapján vagy egy változócsoportban. Az ebben a kontextusban szorzóváltozóként ismert változókat az ügynököknek egyenként átadni kívánt értékek vesszővel tagolt listájaként kell definiálni.

• Adja meg a szorzó változó nevét zárójelek $ és zárójelek nélkül a Szorzók paraméter értékeként. A titkos változók szorzó változóként való használata nem támogatott.

• Ha több szorzóváltozó esetében szeretné végrehajtani a feladatot, írja be a változóneveket vesszővel tagolt listaként – kihagyva az $ egyes változók zárójeleit és zárójeleit.

• Ha az üzembe helyezés során használt ügynökök számát az előfizetéshez konfiguráltnál kisebb számra szeretné korlátozni, adja meg ezt az értéket az ügynökök maximális száma paraméterként.

A Hely és a Böngésző nevű változót például az alábbiak szerint határozhatja meg:

• Helyen = US,Europe
• Böngésző = IE,Chrome,Edge,Firefox

A következő konfiguráció nyolc alkalommal hajtja végre az üzembe helyezést egyszerre legfeljebb négy ügynök használatával:

• Multiplikátorok = Location,Browser
• Ügynökök maximális száma = 4

A többkonfigurációval több feladatot is futtathat, mindegyik egy vagy több változó (szorzó) eltérő értékével. Ha ugyanazt a feladatot több ügynökön szeretné futtatni, használhatja a párhuzamosság többügynökből álló lehetőségét. A fenti tesztszeletelési példa többügynökön keresztül is elvégezhető.

Szeletelés

Az ügynökfeladatokkal párhuzamosan futtathat tesztcsomagokat. Futtathat például egy nagy, 1000 tesztből álló csomagot egyetlen ügynökön. Vagy használhat két ügynököt, és 500 tesztet futtathat mindegyiken párhuzamosan.

A szeletelés alkalmazásához a feladat tevékenységeinek elég intelligensnek kell lenniük ahhoz, hogy megértsék a szeletet, amelyhez tartoznak.

A Visual Studio tesztfeladat egy olyan feladat, amely támogatja a tesztelési szeletelést. Ha több ügynököt telepített, megadhatja, hogyan fut párhuzamosan a Visual Studio tesztfeladat ezeken az ügynökökön.

YAML

A parallel stratégia lehetővé teszi a feladatok többszöri duplikálását. Változók System.JobPositionInPhase , és System.TotalJobsInPhase az egyes feladatokhoz lesznek hozzáadva. A változók ezután a szkripteken belül használhatók a feladatok közötti munka megosztására. Lásd: Párhuzamos és többszörös végrehajtás ügynökfeladatokkal.

A következő feladatot ötször küldi el a rendszer a megfelelő értékekkel System.JobPositionInPhase és System.TotalJobsInPhase beállítással.

jobs:
- job: Test
  strategy:
    parallel: 5

Klasszikus

Adja meg a szeletelés alkalmazásához egy ügynökfeladat többügynök-beállítását . A feladat annyiszor lesz elküldve, mint a megadott ügynökök száma, valamint a változók System.JobPositionInPhase , és System.TotalJobsInPhase automatikusan be vannak állítva az egyes feladatokban.

Feladatváltozók

HA YAML-t használ, a feladathoz változók is megadhatóak. A változók átadhatók a tevékenységbemeneteknek a $(variableName) makrószintaxis használatával, vagy a szakaszváltozó használatával érhetők el egy szkripten belül.

YAML

Az alábbi példa egy feladat változóinak definiálását és a tevékenységeken belüli használatát szemlélteti.

variables:
  mySimpleVar: simple var value
  "my.dotted.var": dotted var value
  "my var with spaces": var with spaces value

steps:
- script: echo Input macro = $(mySimpleVar). Env var = %MYSIMPLEVAR%
  condition: eq(variables['agent.os'], 'Windows_NT')
- script: echo Input macro = $(mySimpleVar). Env var = $MYSIMPLEVAR
  condition: in(variables['agent.os'], 'Darwin', 'Linux')
- bash: echo Input macro = $(my.dotted.var). Env var = $MY_DOTTED_VAR
- powershell: Write-Host "Input macro = $(my var with spaces). Env var = $env:MY_VAR_WITH_SPACES"

Klasszikus

A feladatváltozók még nem támogatottak a webszerkesztőben.

A feltétel használatáról további információt a Feltételek megadása című témakörben talál.

Munkaterület

Amikor egy ügynökkészlet-feladatot futtat, az létrehoz egy munkaterületet az ügynökön. A munkaterület egy könyvtár, amelyben letölti a forrást, futtatja a lépéseket, és kimeneteket hoz létre. A munkaterület könyvtárára változóval Pipeline.Workspace hivatkozhat a feladatban. Ebben a szakaszban különböző alkönyvtárak jönnek létre:

• Build.SourcesDirectory itt töltik le a feladatok az alkalmazás forráskódját.
• Build.ArtifactStagingDirectory Itt töltik le a tevékenységek a folyamathoz szükséges összetevőket, vagy feltöltik az összetevőket a közzétételük előtt.
• Build.BinariesDirectory ahol a tevékenységek megírják a kimenetüket.
• Common.TestResultsDirectory itt töltik fel a feladatok a teszteredményeket.

YAML

Az $(Build.ArtifactStagingDirectory) és $(Common.TestResultsDirectory) mindig minden build előtt törlődnek és újra létrejönnek.

Ha egy saját üzemeltetésű ügynökön futtat egy folyamatot, alapértelmezés szerint egyik alkönyvtárat $(Build.ArtifactStagingDirectory) $(Common.TestResultsDirectory) sem távolítja el két egymást követő futtatás között. Ennek eredményeképpen növekményes buildeket és üzembe helyezéseket hajthat végre, feltéve, hogy a tevékenységek implementálva vannak a használatukhoz. Ezt a viselkedést felülbírálhatja a workspace feladat beállításával.

Fontos

A munkaterület tiszta beállításai csak a saját üzemeltetésű ügynökökre vonatkoznak. A feladatok mindig egy új ügynökön futnak a Microsoft által üzemeltetett ügynökökkel.

- job: myJob
  workspace:
    clean: outputs | resources | all # what to clean up before the job runs

Az egyik beállítás megadásakor a rendszer a clean következőképpen értelmezi őket:

• outputs: Törlés Build.BinariesDirectory új feladat futtatása előtt.
• resources: Törlés Build.SourcesDirectory új feladat futtatása előtt.
• all: Új feladat futtatása előtt törölje a teljes Pipeline.Workspace könyvtárat.

  jobs:
  - deployment: MyDeploy
    pool:
      vmImage: 'ubuntu-latest'
    workspace:
      clean: all
    environment: staging

Feljegyzés

Az ügynök képességeitől és a folyamatigénytől függően minden feladat átirányítható egy másik ügynökhöz a saját üzemeltetésű készletben. Ennek eredményeképpen új ügynököt kaphat a következő folyamatfuttatásokhoz (vagy ugyanabban a folyamatban lévő szakaszokhoz vagy feladatokhoz), így a tisztítás nem garantálja, hogy a későbbi futtatások, feladatok vagy szakaszok hozzáférhetnek a korábbi futtatások, feladatok vagy szakaszok kimeneteihez. Az ügynöki képességek és a folyamatigények konfigurálhatók úgy, hogy megadják, mely ügynököket használják a folyamatfeladatok futtatásához, de ha csak egyetlen ügynök van a készletben, amely megfelel az igényeknek, nincs garancia arra, hogy a későbbi feladatok ugyanazt az ügynököt használják, mint a korábbi feladatok. További információ: Igény megadása.

A munkaterület megtisztítása mellett a tisztítást is konfigurálhatja a folyamatbeállítások felhasználói felületén a Tiszta beállítás konfigurálásával. Ha a Tiszta beállítás igaz, amely egyben az alapértelmezett értéke is, az egyenértékű a folyamat minden kivételi lépésének megadásávalclean: true. Ha megadja clean: true, a git beolvasása előtt futtatja git clean -ffdx a elemet git reset --hard HEAD . A Tiszta beállítás konfigurálása:

1. Szerkessze a folyamatot, válassza a ..., majd az Eseményindítók lehetőséget.

   

2. Válassza ki a YAML-t, kérje le a forrásokat, és konfigurálja a kívánt Tiszta beállítást. Az alapértelmezett érték igaz.

   

Klasszikus

Ha egy saját üzemeltetésű ügynökön futtat egy folyamatot, alapértelmezés szerint egyik alkönyvtár sem lesz megtisztítva két egymást követő futtatás között. Ennek eredményeképpen növekményes buildeket és üzembe helyezéseket futtathat, feltéve, hogy a tevékenységek implementálva vannak ehhez. Ezt a viselkedést azonban felülbírálhatja a Clean build feladat alatti Get sources beállítással. A beállítások a használt adattár típusától függően változnak.

• GitHub
• Azure Repos Git
• TFVC

Összetevő letöltése

Ez a példa YAML-fájl közzéteszi az összetevőt WebSite , majd letölti az összetevőt a fájlba $(Pipeline.Workspace). Az üzembe helyezési feladat csak akkor fut, ha a buildelési feladat sikeres.

YAML

# test and upload my code as an artifact named WebSite
jobs:
- job: Build
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - script: npm test
  - task: PublishBuildArtifacts@1
    inputs:
      pathtoPublish: '$(System.DefaultWorkingDirectory)'
      artifactName: WebSite

# download the artifact and deploy it only if the build job succeeded
- job: Deploy
  pool:
    vmImage: 'ubuntu-latest'
  steps:
  - checkout: none #skip checking out the default repository resource
  - task: DownloadBuildArtifacts@0
    displayName: 'Download Build Artifacts'
    inputs:
      artifactName: WebSite
      downloadPath: $(Pipeline.Workspace)

  dependsOn: Build
  condition: succeeded()

Klasszikus

A kiadási folyamatban dönthet úgy, hogy kihagyja az összetevők letöltését a feladat végrehajtása során. Ezt a lehetőséget akkor használhatja, ha saját egyéni logikát szeretne implementálni az összetevők feladatok használatával való letöltéséhez, vagy ha az adott feladat tevékenységei nem támaszkodnak az összetevőkre.

Azt is megteheti, hogy letölt bizonyos összetevőket a feladat végrehajtása során egy kiadásban. Akkor használja ezt a lehetőséget, ha egy adott feladat tevékenységei csak adott összetevőkre támaszkodnak.

A dependsOn és a feltétel használatáról további információt a feltételek megadása című témakörben talál.

Hozzáférés az OAuth-jogkivonathoz

Engedélyezheti, hogy a feladatban futó szkriptek hozzáférjenek az aktuális Azure Pipelines- vagy TFS OAuth-biztonsági jogkivonathoz. A jogkivonat használható az Azure Pipelines REST API-val való hitelesítéshez.

YAML

Az OAuth-jogkivonat mindig elérhető a YAML-folyamatok számára. Explicit módon le kell képezni a feladatba vagy a lépésbe a használatával env. Példa:

steps:
- powershell: |
    $url = "$($env:SYSTEM_TEAMFOUNDATIONCOLLECTIONURI)$env:SYSTEM_TEAMPROJECTID/_apis/build/definitions/$($env:SYSTEM_DEFINITIONID)?api-version=4.1-preview"
    Write-Host "URL: $url"
    $pipeline = Invoke-RestMethod -Uri $url -Headers @{
      Authorization = "Bearer $env:SYSTEM_ACCESSTOKEN"
    }
    Write-Host "Pipeline = $($pipeline | ConvertTo-Json -Depth 100)"
  env:
    SYSTEM_ACCESSTOKEN: $(system.accesstoken)

Klasszikus

A feladat vezérlőbeállításaiban válassza az OAuth-jogkivonat elérésének engedélyezése szkriptek számára lehetőséget. A jogkivonat környezeti változóként SYSTEM_ACCESSTOKENérhető el.

A következő lépések

• Üzembehelyezési csoport feladatai
• Feltételek