Munkák meghatározása a folyamatláncban

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

A pipeline-t feladatokba rendezheti. Minden csővezetékhez 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 tartalmaz egy feladatot, amely egy Microsoft által üzemeltetett ügynökön fut, és eredményt ad .

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 folyamatlánc több feladatot is tartalmazhat. 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 áll, 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 üzembe helyezési feladatokhoz is hozzáadhat lépéseket, javasoljuk, hogy inkább egy job használjon. Az üzembe helyezési feladatoknak van néhány előnye. Például üzembe helyezhet egy környezetet, amely többek között olyan előnyöket kínál, mint az üzembe helyezések előzményeinek megtekintése.

Klasszikus

Ha feladatokat szeretne hozzáadni a build pipeline-hoz, szerkessze a pipeline-t a Pipelines oldalon. 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>Releases menüpontbó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ési csoport 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ökcsoport-feladatok

Az ügynökkészlet-feladatok a leggyakoribb feladatok. Ezek a feladatok az ügynökkészlet ügynökeinek egyikén futnak. Megadhatja azt a készletet, amelyen futtatni szeretné a feladatot, és igényekkel is megadhatja, hogy az ügynöknek milyen képességekre van szüksége a feladat futtatásához. Az ügynökök lehetnek a Microsoft által üzemeltetett vagy saját üzemeltetésű ügynökök. További információért lásd: Azure Pipelines-ügynökök.

• Ha Microsoft által üzemeltetett ügynököket használ, a folyamat minden feladata új ügynököt kap.
• Ha saját üzemeltetésű ügynököket használ, követelmények segítségével meghatározhatja, hogy az ügynök milyen képességeket igényel a feladat futtatásához. Ugyanazt az ügynököt az egymást követő feladatokhoz is beszerezheti, 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 a saját üzemeltetésű ügynökökkel való használatra tervezték, így a feladatokhoz hozzárendelhető az az ügynök, amelyik teljesíti a feladat követelményeit. A Microsoft által üzemeltetett ügynökök használatakor kiválaszt egy képet az ügynökhöz, amely megfelel a feladat követelményeinek. 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

A folyamatokban, a feladatokban vagy mindkettőben megadhatja az igényeket. 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ó összehangolja és végrehajtja a feladatokat egy kiszolgálói feladatban. 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 munkahelyek á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 úgy adhat hozzá, hogy kiválasztja a "..." elemet a Folyamat csatornán a Feladatok lapon. 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 csővezetékeknek legalább egy, függőség 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úvatásra:

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 munka hozzáadásához válassza a "..." lehetőséget a folyamat Feladatok lapján a 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 telepítési folyamatokban. A kiadási folyamatban több feladat fut egymás után.

A folyamat például két ügynökfeladat és egy kiszolgálói feladathasználatával külön végrehajtási feladatokra osztja a teljes kiadási végrehajtást.

1. A verziókiadás első feladatsorának feladatai egy ügynökön futnak meg. Az ügynök a feladat befejezése után szabadul fel.

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

3. A harmadik helyeken a feladatok akkor futnak, ha a kiadás folytatódik, esetleg 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 és Always run opciók az egyes munka feladataira nincsenek hatással a következő munkák feladataira. Ha például a Mindig futtasd beállításra kerül egy feladaton az első munkamenet végén, az nem garantálja, hogy a következő munkamenetekben a feladatok futnak.

Feltételek

Megadhatja az egyes feladatok futtatásának feltételeit. Alapértelmezés szerint egy feladat akkor fut, ha nem függ más feladatoktól, vagy ha az összes feladat, amelytől függ, sikeresen befejeződött. 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 Run this job lehetőséget egy ügynök- vagy kiszolgálófeladaton használja, hogy a feladatok csak akkor fussanak le, ha az adott feltételek teljesülnek. 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ások kihasználását, amikor a feladat nem válaszol vagy túl sokáig várakozik, beállíthat egy időkorlátot arra, hogy meddig futhat 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 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ökkel privát projekttel vagy privát adattárral (kivéve, ha extra kapacitás kerül kifizetésre)

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 van megadva, a rendszer a maximális korlátot használja.

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 csővezeték értéke is 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 időtartama korlátozott, a projekt típusától és attól függően, hogy fizetős párhuzamos feladatként futtatják-e őket. Amikor a Microsoft által üzemeltetett feladat időtúllépési időköze lejár, a feladat megszakad. 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ést meghaladó beépített időtúllépés nincs hatással.
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 x86x64 platformon. További információ: Visual Studio Build – több konfiguráció több platformhoz.

• Többkonfigurációs üzembe helyezések: Több üzembe helyezést is végezhet párhuzamosan, például különböző földrajzi régiókban.

• 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átrixkonfigurációs neveknek (mint a példában US_IE) csak egyszerű latin betűs betűket (A - Z, a - z), számokat és aláhúzásjeleket (_) kell tartalmazniuk. Nekik betűvel kell kezdődniük. Emellett legfeljebb 100 karakter hosszúságúnak kell lenniük.

Kimeneti változók használatával is létrehozhat egy mátrixot. Ez a módszer akkor lehet hasznos, 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 használatával 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 esetében az $-t és a zárójeleket.

• Ha az üzembe helyezés során használt ügynökök számát az előfizetéshez beállítottnál kevesebbre szeretné korlátozni, adja meg ezt az értéket Ü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. Az előző tesztszeletelési példa többügynöki opcióval is elvégezhető.

Szeletelés

Egy ügynökfeladat használható tesztcsomagok párhuzamos futtatásához. Például futtathat egy 1000 tesztből álló nagy 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 feladatoknak elég intelligensnek kell lenniük ahhoz, hogy megértsék azt 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 multi-agent opciót egy ügynökfeladatnál a szeletelés alkalmazásához. 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 feladatot futtat az ügynökkészlet használatával, az létrehoz egy munkaterületet az ügynök számára. A munkaterület egy könyvtár, amelyben letölti a forrást, futtatja a lépéseket, és kimeneteket hoz létre. A Pipeline.Workspace változóval hivatkozhat a feladatban a munkaterület könyvtárára. Ez alatt 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

A $(Build.ArtifactStagingDirectory) és a $(Common.TestResultsDirectory) minden build előtt törlődik és újra létrejön.

Ha egy saját üzemeltetésű ügynökön futtat egy pipeline-t, alapértelmezés szerint egyik, a és $(Build.ArtifactStagingDirectory) kivételével, alkönyvtár sem kerül tisztításra két egymást követő futtatás között. Ennek eredményeképpen fokozatos buildeket és üzembe helyezéseket hajthat végre, ha a feladatok úgy vannak implementálva, hogy kihasználják őket. 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, amelyet a Microsoft üzemeltet.

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

Amikor a clean lehetőségek egyikét megadja, a rendszer azokat a következőképpen értelmezi:

• outputs: Töröljék Build.BinariesDirectory egy új feladat futtatása előtt.
• resources: Töröljék Build.SourcesDirectory egy ú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 következtében új végrehajtót szerezhet be a következő folyamatfuttatásokhoz (vagy ugyanabban a folyamatban lévő szakaszokhoz vagy feladatokhoz), így a tisztítás hiánya nem garantálja, hogy a későbbi futtatások, feladatok vagy szakaszok képesek hozzáférni a korábbi futtatások, feladatok vagy szakaszok kimeneteihez. Az ügynök képességei és a folyamatigények konfigurálhatók, 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 a követelmé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 clean: true lépésének megadásával. Amikor megadja a clean: true-t, a git beolvasása előtt futtassa a git clean -ffdx-et, majd a git reset --hard HEAD-t. A Tiszta beállítás konfigurálása:

1. Szerkessze a munkafolyamatát, válassza ki a ... elemet, és válassza a Triggerek 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, ha a tevékenységek implementálva vannak ehhez. Ezt a viselkedést azonban felülbírálhatja a Clean build feladat alatti Get sources opcióval. A beállítások a használt adattár típusától függően változnak.

• GitHub
• Azure Repos Git
• TFVC

Artifaktum 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: PublishPipelineArtifact@1
    inputs:
      artifactName: Website
      targetPath: '$(System.DefaultWorkingDirectory)'

# 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: DownloadPipelineArtifact@2
    displayName: 'Download Pipeline Artifact'
    inputs:
      artifactName: Website
      targetPath: '$(Pipeline.Workspace)'
  dependsOn: Build
  condition: succeeded()

Klasszikus

A kiadási folyamatban kihagyhatja 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 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. A env használatával explicit módon le kell képezni a feladatba vagy a lépésbe. Itt van egy 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 token elérhető SYSTEM_ACCESSTOKEN környezeti változóként.

A következő lépések

• Üzembehelyezési csoport feladatai
• Feltételek