Megosztás a következőn keresztül:

Egyéni csővezeték-feladathoz bővítmény hozzáadása

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

Ez az útmutató bemutatja, hogyan hozhat létre, tesztelhet és tehet közzé egyéni buildelési vagy kiadási feladatokat Azure DevOps-bővítményekként. Az egyéni folyamatfeladatok lehetővé teszik az Azure DevOps kiterjesztését a csapat munkafolyamataihoz szabott speciális funkciókkal, az egyszerű segédprogramoktól a külső rendszerekkel való összetett integrációig.

Ismerje meg, hogyan végezheti el a következő feladatokat:

  • A fejlesztési környezet és a projektstruktúra beállítása
  • Feladatlogika létrehozása a TypeScript és az Azure Pipelines feladattár használatával
  • Átfogó egységtesztelés megvalósítása makett-keretrendszerekkel
  • A bővítmény csomagolása terjesztési célokra
  • Közzététel a Visual Studio Marketplace-en
  • Automatizált CI/CD-folyamatok beállítása bővítménykarbantartáshoz

További információ az Azure Pipelinesról: Mi az Az Azure Pipelines?

Megjegyzés

Ez a cikk az ügynökalapú bővítmények ügynöktevékenységeit ismerteti. A kiszolgálói feladatokkal és a kiszolgálóalapú bővítményekkel kapcsolatos információkért lásd: Kiszolgálói feladat létrehozása.

Előfeltételek

Mielőtt hozzákezdene, győződjön meg arról, hogy a következő követelmények teljesülnek:

Összetevő Követelmény Leírás
Azure DevOps-szervezet Kötelező Szervezet létrehozása , ha nem rendelkezik ilyen szervezettel
Szövegszerkesztő Ajánlott Visual Studio Code for IntelliSense és hibakeresési támogatás
Node.js Kötelező Telepítse a legújabb verziót (Node.js 20 vagy újabb verzió ajánlott)
TypeScript fordító Kötelező Telepítse a legújabb verziót (4.6.3-os vagy újabb verzió)
Azure DevOps CLI (tfx-cli) Kötelező Telepítés bővítmények csomagolásával npm i -g tfx-cli
Azure DevOps Extension SDK Kötelező Az azure-devops-extension-sdk csomag telepítése
Tesztelési keretrendszer Kötelező Mocha egységteszteléshez (telepítés közben telepítve)

Projektstruktúra

Hozzon létre egy home könyvtárat a projekthez. Az oktatóanyag elvégzése után a bővítménynek a következő struktúrával kell rendelkeznie:

|--- README.md    
|--- images                        
    |--- extension-icon.png  
|--- buildandreleasetask            // Task scripts location
    |--- task.json                  // Task definition
    |--- index.ts                   // Main task logic
    |--- package.json               // Node.js dependencies
    |--- tests/                     // Unit tests
        |--- _suite.ts
        |--- success.ts
        |--- failure.ts
|--- vss-extension.json             // Extension manifest

Fontos

A fejlesztési gépnek a Node.jslegújabb verzióját kell futtatnia az éles környezettel való kompatibilitás biztosításához. Frissítse a fájlt a task.json Node 20 használatára:

"execution": {
    "Node20_1": {
      "target": "index.js"
    }
}

1. Egyéni feladat létrehozása

Ez a szakasz végigvezeti az egyéni feladat alapszintű szerkezetének és implementálásának létrehozásán. Az ebben a lépésben szereplő összes fájlt a buildandreleasetask projekt könyvtárában home lévő mappában kell létrehozni.

Megjegyzés

Ez az útmutató a Windowst és a PowerShellt használja. A lépések minden platformon működnek, de a környezeti változó szintaxisa eltér. Macen vagy Linuxon cserélje le a .$env:<var>=<val>export <var>=<val>

A feladat-állványzat beállítása

Hozza létre az alapvető projektstruktúrát, és telepítse a szükséges függőségeket:

  1. A Node.js projekt inicializálásához nyissa meg a PowerShellt, nyissa meg a buildandreleasetask mappát, és futtassa a következőt:

    npm init --yes

    A package.json fájl az alapértelmezett beállításokkal jön létre. A --yes jelölő automatikusan elfogadja az összes alapértelmezett beállítást.

    Tipp

    Az Azure Pipelines-ügynökök elvárják, hogy a feladatmappák csomópontmodulokat is tartalmazzanak. Másolás node_modules a buildandreleasetask mappába. A VSIX-fájlméret (50 MB-os korlát) kezeléséhez fontolja meg a futtatás npm install --production vagy npm prune --production a csomagolás előtt.

  2. Telepítse az Azure Pipelines-feladattárat:

    npm install azure-pipelines-task-lib --save

  3. TypeScript-típusdefiníciók telepítése:

    npm install @types/node --save-dev
npm install @types/q --save-dev

  4. Verziókövetési kizárások beállítása

    echo node_modules > .gitignore

    A buildelési folyamatnak minden alkalommal újra kell futnia npm install a node_modules újraépítéséhez.

  5. Tesztelési függőségek telepítése:

    npm install mocha --save-dev -g
npm install sync-request --save-dev
npm install @types/mocha --save-dev

  6. Telepítse a TypeScript-fordítót:

    npm install typescript@4.6.3 -g --save-dev

    Megjegyzés

    Telepítse a TypeScriptet globálisan, hogy a tsc parancs elérhető legyen. Nélküle a TypeScript 2.3.4 alapértelmezés szerint használható.

  7. TypeScript-fordítás konfigurálása:

    tsc --init --target es2022

    A tsconfig.json fájl es2022-es célbeállításokkal jön létre.

A feladatlogika implementálása

Az állványzatok elkészültével hozza létre a funkciókat és metaadatokat meghatározó alapvető feladatfájlokat:

  1. Hozza létre a feladatdefiníciós fájlt: Létrehozás task.json a buildandreleasetask mappában. Ez a fájl ismerteti a feladatot az Azure Pipelines-rendszerben, meghatározva a bemeneteket, a végrehajtási beállításokat és a felhasználói felületi bemutatót.

    {
 "$schema": "https://raw.githubusercontent.com/Microsoft/azure-pipelines-task-lib/master/tasks.schema.json",
 "id": "{{taskguid}}",
 "name": "{{taskname}}",
 "friendlyName": "{{taskfriendlyname}}",
 "description": "{{taskdescription}}",
 "helpMarkDown": "",
 "category": "Utility",
 "author": "{{taskauthor}}",
 "version": {
     "Major": 0,
     "Minor": 1,
     "Patch": 0
 },
 "instanceNameFormat": "Echo $(samplestring)",
 "inputs": [
     {
         "name": "samplestring",
         "type": "string",
         "label": "Sample String",
         "defaultValue": "",
         "required": true,
         "helpMarkDown": "A sample string"
     }
 ],
 "execution": {
     "Node20_1": {
         "target": "index.js"
     }
 }
 }

    Megjegyzés

    Cserélje le {{placeholders}} a tevékenység tényleges adataira. Ennek taskguid egyedinek kell lennie. Hozzon létre egyet a PowerShell használatával: (New-Guid).Guid

  2. A feladatlogika implementálásához hozza létre index.ts a tevékenység fő funkcióit:

    import tl = require('azure-pipelines-task-lib/task');

 async function run() {
     try {
         const inputString: string | undefined = tl.getInput('samplestring', true);
         if (inputString == 'bad') {
             tl.setResult(tl.TaskResult.Failed, 'Bad input was given');
             return;
         }
         console.log('Hello', inputString);
     }
     catch (err: any) {
         tl.setResult(tl.TaskResult.Failed, err.message);
     }
 }

 run();

  3. TypeScript fordítása JavaScriptre:

    tsc

    A index.js fájl a TypeScript-forrásból jön létre.

Az task.json összetevők ismertetése

A task.json fájl a feladatdefiníció középpontjában áll. A legfontosabb tulajdonságok a következők:

Tulajdonság Leírás példa
id A tevékenység egyedi GUID-azonosítója Létrehozva a következő használatával: (New-Guid).Guid
name Tevékenység neve szóközök nélkül (belsőleg használva) MyCustomTask
friendlyName Megjelenítendő név a felhasználói felületen My Custom Task
description A feladat funkcióinak részletes leírása Performs custom operations on files
author Közzétevő vagy szerző neve My Company
instanceNameFormat A feladat megjelenése a folyamat lépéseiben Process $(inputFile)
inputs Bemeneti paraméterek tömbje Lásd a következő bemeneti típusokat
execution Végrehajtási környezet specifikációja Node20_1, stb PowerShell3.
restrictions Parancsok és változók biztonsági korlátozásai Új feladatokhoz ajánlott

Biztonsági korlátozások

Éles feladatok esetén adjon hozzá biztonsági korlátozásokat a parancsok használatának és a változók elérésének korlátozásához:

"restrictions": {
  "commands": {
    "mode": "restricted"
  },
  "settableVariables": {
    "allowed": ["variable1", "test*"]
  }
}

A korlátozott mód csak az alábbi parancsokat engedélyezi:

  • logdetail, logissue, completesetprogress
  • setsecret, setvariable, debugsettaskvariable
  • prependpath, publish

A változók engedélyezési listája szabályozza, hogy mely változók állíthatók be a vagy a setvariableprependpath. Támogatja az alapszintű regex-mintákat.

Megjegyzés

Ehhez a funkcióhoz az ügynök 2.182.1-es vagy újabb verziója szükséges.

Bemeneti típusok és példák

A tevékenységparaméterek gyakori bemeneti típusai:

"inputs": [
    {
        "name": "stringInput",
        "type": "string",
        "label": "Text Input",
        "defaultValue": "",
        "required": true,
        "helpMarkDown": "Enter a text value"
    },
    {
        "name": "boolInput",
        "type": "boolean",
        "label": "Enable Feature",
        "defaultValue": "false",
        "required": false
    },
    {
        "name": "picklistInput",
        "type": "pickList",
        "label": "Select Option",
        "options": {
            "option1": "First Option",
            "option2": "Second Option"
        },
        "defaultValue": "option1"
    },
    {
        "name": "fileInput",
        "type": "filePath",
        "label": "Input File",
        "required": true,
        "helpMarkDown": "Path to the input file"
    }
]

A feladat helyi tesztelése

A csomagolás előtt tesztelje a feladatot, hogy megfelelően működjön:

  1. Hiányzó bemenettel végzett tesztelés (sikertelennek kell lennie):

    node index.js

    Várt kimenet:

    ##vso[task.debug]agent.workFolder=undefined
##vso[task.debug]loading inputs and endpoints
##vso[task.debug]loaded 0
##vso[task.debug]task result: Failed
##vso[task.issue type=error;]Input required: samplestring
##vso[task.complete result=Failed;]Input required: samplestring

  2. Érvényes bemenettel végzett tesztelés (sikeresnek kell lennie):

    $env:INPUT_SAMPLESTRING="World"
node index.js

    Várt kimenet:

    ##vso[task.debug]agent.workFolder=undefined
##vso[task.debug]loading inputs and endpoints
##vso[task.debug]loading INPUT_SAMPLESTRING
##vso[task.debug]loaded 1
##vso[task.debug]samplestring=World
Hello World

  3. Hibakezelés tesztelése:

    $env:INPUT_SAMPLESTRING="bad"
node index.js

    Ennek a műveletnek aktiválnia kell a hibakezelési útvonalat a kódban.

    Tipp

    A feladatfuttatókkal és Node.js verziókkal kapcsolatos információkért tekintse meg a Csomópontfuttató frissítési útmutatóját.

További információkért tekintse meg a buildelési/kiadási feladatra vonatkozó referenciát.

2. Átfogó egységtesztelés megvalósítása

A feladat alapos tesztelése biztosítja a megbízhatóságot, és segít a problémák megoldásában az éles folyamatokba való üzembe helyezés előtt.

Tesztelési függőségek telepítése

Telepítse a szükséges tesztelési eszközöket:

npm install mocha --save-dev -g
npm install sync-request --save-dev
npm install @types/mocha --save-dev

Teszt létrehozása

  1. Hozzon létre egy tests fájlt tartalmazó _suite.ts mappát a feladatkönyvtárban:

     import * as path from 'path';
 import * as assert from 'assert';
 import * as ttm from 'azure-pipelines-task-lib/mock-test';

 describe('Sample task tests', function () {

     before( function() {
         // Setup before tests
     });

     after(() => {
         // Cleanup after tests
     });

     it('should succeed with simple inputs', function(done: Mocha.Done) {
         // Success test implementation
     });

     it('should fail if tool returns 1', function(done: Mocha.Done) {
         // Failure test implementation
     });    
   });

    Tipp

    A tesztmappának a feladatmappában kell lennie (például buildandreleasetask). Ha szinkronizálási kérési hibát tapasztal, telepítse a következő feladatmappába: npm i --save-dev sync-request.

  2. A sikeres feladatvégrehajtás szimulálásához hozzon létre success.ts a tesztkönyvtárban:

     import ma = require('azure-pipelines-task-lib/mock-answer');
 import tmrm = require('azure-pipelines-task-lib/mock-run');
 import path = require('path');

 let taskPath = path.join(__dirname, '..', 'index.js');
 let tmr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);

 // Set valid input for success scenario
 tmr.setInput('samplestring', 'human');

 tmr.run();

  3. Adja hozzá a sikerességi tesztet a _suite.ts fájlhoz:

     it('should succeed with simple inputs', function(done: Mocha.Done) {
     this.timeout(1000);

     let tp: string = path.join(__dirname, 'success.js');
     let tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);

     tr.runAsync().then(() => {
         console.log(tr.succeeded);
         assert.equal(tr.succeeded, true, 'should have succeeded');
         assert.equal(tr.warningIssues.length, 0, "should have no warnings");
         assert.equal(tr.errorIssues.length, 0, "should have no errors");
         console.log(tr.stdout);
         assert.equal(tr.stdout.indexOf('Hello human') >= 0, true, "should display Hello human");
         done();
     }).catch((error) => {
         done(error); // Ensure the test case fails if there's an error
     });
 });

  4. Hozzon létre failure.ts a tesztkönyvtárban a hibakezelés teszteléséhez:

    import ma = require('azure-pipelines-task-lib/mock-answer');
import tmrm = require('azure-pipelines-task-lib/mock-run');
import path = require('path');

let taskPath = path.join(__dirname, '..', 'index.js');
let tmr: tmrm.TaskMockRunner = new tmrm.TaskMockRunner(taskPath);

// Set invalid input to trigger failure
tmr.setInput('samplestring', 'bad');

tmr.run();

  5. Adja hozzá a hibatesztet a _suite.ts fájlhoz:

     it('should fail if tool returns 1', function(done: Mocha.Done) {
     this.timeout(1000);

     const tp = path.join(__dirname, 'failure.js');
     const tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);

     tr.runAsync().then(() => {
         console.log(tr.succeeded);
         assert.equal(tr.succeeded, false, 'should have failed');
         assert.equal(tr.warningIssues.length, 0, 'should have no warnings');
         assert.equal(tr.errorIssues.length, 1, 'should have 1 error issue');
         assert.equal(tr.errorIssues[0], 'Bad input was given', 'error issue output');
         assert.equal(tr.stdout.indexOf('Hello bad'), -1, 'Should not display Hello bad');
         done();
     });
 });

A tesztek futtatása

Hajtsa végre a tesztcsomagot:

# Compile TypeScript
tsc

# Run tests
mocha tests/_suite.js

Mindkét tesztnek át kell mennie. Részletes kimenet esetén (a konzolkimenethez hasonlóan) állítsa be a nyomkövetési környezeti változót:

$env:TASK_TEST_TRACE=1
mocha tests/_suite.js

A lefedettséggel kapcsolatos ajánlott eljárások tesztelése

  • Az összes bemeneti kombináció tesztelése: Érvényes bemenetek, érvénytelen bemenetek, hiányzó szükséges bemenetek
  • Tesztelési hibaforgatókönyvek: Hálózati hibák, fájlrendszerhibák, engedélyproblémák
  • Külső függőségek ki makettje: Ne támaszkodjanak külső szolgáltatásokra az egységtesztekben
  • Kimenetek ellenőrzése: Ellenőrizze a konzol kimenetét, a tevékenység eredményeit és a létrehozott összetevőket
  • Teljesítménytesztelés: Fontolja meg a nagyméretű fájlokat feldolgozó feladatok tesztjeinek hozzáadását

Ajánlott biztonsági eljárások

  • Bemenet ellenőrzése: A bemenetek ellenőrzése és megtisztítása
  • Titkos kódok kezelése: Bizalmas adatokhoz használható setSecret
  • Parancskorlátozások: Parancskorlátozások implementálása éles tevékenységekhez
  • Minimális engedélyek: Csak a szükséges engedélyek kérése
  • Rendszeres frissítések: Függőségek és Node.js verziók naprakészen tartása

A feladat helyi tesztelése és az átfogó egységtesztek implementálása után csomagolja be az Azure DevOps bővítményébe.

Csomagolóeszközök telepítése

Telepítse a platformfüggetlen parancssori felületet (tfx-cli):

npm install -g tfx-cli

A bővítményjegyzék létrehozása

A bővítményjegyzék (vss-extension.json) tartalmazza a bővítményre vonatkozó összes információt, beleértve a feladatmappákra és a rendszerképekre mutató hivatkozásokat is.

  1. Képmappa létrehozása fájllal extension-icon.png

  2. Létrehozás vss-extension.json a bővítmény gyökérkönyvtárában (nem a feladatmappában):

    {
 "manifestVersion": 1,
 "id": "my-custom-tasks",
 "name": "My Custom Tasks",
 "version": "1.0.0",
 "publisher": "your-publisher-id",
 "targets": [
     {
         "id": "Microsoft.VisualStudio.Services"
     }
 ],
 "description": "Custom build and release tasks for Azure DevOps",
 "categories": [
     "Azure Pipelines"
 ],
 "icons": {
     "default": "images/extension-icon.png"
 },
 "files": [
     {
         "path": "MyCustomTask"
     }
 ],
 "contributions": [
     {
         "id": "my-custom-task",
         "type": "ms.vss-distributed-task.task",
         "targets": [
             "ms.vss-distributed-task.tasks"
         ],
         "properties": {
             "name": "MyCustomTask"
         }
     }
 ]
}

Kulcsjegyzék tulajdonságai

Tulajdonság Leírás
publisher A marketplace-közzétevő azonosítója
contributions.id Egyedi azonosító a bővítményen belül
contributions.properties.name Meg kell egyeznie a feladatmappa nevével
files.path A tevékenységmappa elérési útja a jegyzékhez képest

Megjegyzés

Módosítsa a közzétevő értékét a közzétevő nevére. A közzétevő létrehozásáról további információt a Közzétevő létrehozása című témakörben talál.

Csomagold a bővítményt

Csomagolja be a bővítményt egy .vsix-fájlba:

tfx extension create --manifest-globs vss-extension.json

Verziókezelés

  • Bővítményverzió: Az egyes frissítések verziószámának vss-extension.json növelése
  • Feladat verziója: Az egyes tevékenységfrissítések task.json verziószámának növelése
  • Automatikus növekmény: A --rev-version javítás verziójának automatikus növelése
tfx extension create --manifest-globs vss-extension.json --rev-version

Fontos

A feladatverziót és a bővítményverziót is frissíteni kell ahhoz, hogy a módosítások érvénybe lépjenek az Azure DevOpsban.

Verziószámozási stratégia

Kövesse a feladatfrissítések szemantikai verziószámozási alapelveit:

  • Főverzió: A bemenetek/kimenetek kompatibilitástörő változásai
  • Alverzió: Új funkciók, visszamenőlegesen kompatibilis
  • Javítás verziója: Csak hibajavítások

Frissítési folyamat:

  1. Verzió frissítése task.json
  2. Verzió frissítése vss-extension.json
  3. Tesztelés alaposan egy tesztszervezetben
  4. Problémák közzététele és figyelése

Közzététel a Visual Studio Marketplace-en

1. A közzétevő létrehozása

  1. Bejelentkezés a Visual Studio Marketplace közzétételi portálra
  2. Ha a rendszer kéri, hozzon létre egy új közzétevőt:
    • Közzétevő azonosítója: A bővítményjegyzékben használatos (például mycompany-myteam)
    • Megjelenítendő név: A piactéren megjelenített nyilvános név (például My Team)
  3. Tekintse át és fogadja el a Marketplace Közzétevői Szerződését

2. Töltse fel a bővítményt

Webes felület metódusa:

  1. Válassza az Új bővítmény feltöltése lehetőséget
  2. A csomagolt .vsix fájl kiválasztása
  3. Válassza a Feltöltés lehetőséget

Parancssori módszer:

tfx extension publish --manifest-globs vss-extension.json --share-with yourOrganization

3. A bővítmény megosztása

  1. Kattintson a jobb gombbal a bővítményre a piactéren
  2. Válassza a Megosztás lehetőséget
  3. Adja meg a szervezet nevét
  4. Szükség szerint további szervezetek hozzáadása

Fontos

A közzétevőket ellenőrizni kell a bővítmények nyilvános megosztásához. További információ: Csomag/Közzététel/Telepítés.

4. Telepítés a szervezeten

A megosztás után telepítse a bővítményt az Azure DevOps-szervezetre:

  1. Ugrás a Szervezeti beállítások>bővítményekre
  2. A bővítmény megkeresése
  3. Válassza a Get it free and install (Ingyenes lekérése és telepítése) lehetőséget

3. A bővítmény csomagolása és közzététele

A bővítmény ellenőrzése

A telepítés után ellenőrizze, hogy a feladat megfelelően működik-e:

  1. Folyamat létrehozása vagy szerkesztése.
  2. Adja hozzá az egyéni feladatot:
    • Válassza a Feladat hozzáadása lehetőséget a folyamatszerkesztőben
    • Egyéni feladat megkeresése név szerint
    • Hozzáadás a folyamathoz
  3. Feladatparaméterek konfigurálása:
    • A szükséges bemenetek beállítása
    • Opcionális beállítások konfigurálása
  4. A folyamat futtatása a funkciók teszteléséhez
  5. Végrehajtás figyelése:
    • A feladatnaplók megfelelő végrehajtásának ellenőrzése
    • Várt kimenetek ellenőrzése
    • Győződjön meg arról, hogy nincsenek hibák vagy figyelmeztetések

4. Bővítmény-közzététel automatizálása CI/CD-vel

Az egyéni feladat hatékony fenntartása érdekében hozzon létre automatizált buildelési és kiadási folyamatokat, amelyek a tesztelést, a csomagolást és a közzétételt kezelik.

Az automatizálás előfeltételei

  • Azure DevOps-bővítményfeladatok: A bővítmény ingyenes telepítése
  • Változócsoport: Hozzon létre egy folyamattár változócsoportot az alábbi változókkal:
    • publisherId: A piactér közzétevő-azonosítója
    • extensionId: Bővítményazonosító a vss-extension.json
    • extensionName: Bővítmény neve vss-extension.json
    • artifactName: A VSIX-összetevő neve
  • Szolgáltatáskapcsolat: Marketplace-szolgáltatáskapcsolat létrehozása folyamathozzáférés-engedélyekkel

CI/CD-folyamat befejezése

Hozzon létre egy YAML-folyamatot átfogó fázisokkal a teszteléshez, a csomagoláshoz és a közzétételhez:

trigger: 
- main

pool:
  vmImage: "ubuntu-latest"

variables:
  - group: extension-variables # Your variable group name

stages:
  - stage: Test_and_validate
    displayName: 'Run Tests and Validate Code'
    jobs:
      - job: RunTests
        displayName: 'Execute unit tests'
        steps:
          - task: TfxInstaller@4
            displayName: 'Install TFX CLI'
            inputs:
              version: "v0.x"
          
          - task: Npm@1
            displayName: 'Install task dependencies'
            inputs:
              command: 'install'
              workingDir: '/MyCustomTask' # Update to your task directory
          
          - task: Bash@3
            displayName: 'Compile TypeScript'
            inputs:
              targetType: "inline"
              script: |
                cd MyCustomTask # Update to your task directory
                tsc
          
          - task: Npm@1
            displayName: 'Run unit tests'
            inputs:
              command: 'custom'
              workingDir: '/MyCustomTask' # Update to your task directory
              customCommand: 'test' # Ensure this script exists in package.json
          
          - task: PublishTestResults@2
            displayName: 'Publish test results'
            inputs:
              testResultsFormat: 'JUnit'
              testResultsFiles: '**/test-results.xml'
              searchFolder: '$(System.DefaultWorkingDirectory)'

  - stage: Package_extension
    displayName: 'Package Extension'
    dependsOn: Test_and_validate
    condition: succeeded()
    jobs:
      - job: PackageExtension
        displayName: 'Create VSIX package'
        steps:
          - task: TfxInstaller@4
            displayName: 'Install TFX CLI'
            inputs:
              version: "v0.x"
          
          - task: Npm@1
            displayName: 'Install dependencies'
            inputs:
              command: 'install'
              workingDir: '/MyCustomTask'
          
          - task: Bash@3
            displayName: 'Compile TypeScript'
            inputs:
              targetType: "inline"
              script: |
                cd MyCustomTask
                tsc
          
          - task: QueryAzureDevOpsExtensionVersion@4
            name: QueryVersion
            displayName: 'Query current extension version'
            inputs:
              connectTo: 'VsTeam'
              connectedServiceName: 'marketplace-connection'
              publisherId: '$(publisherId)'
              extensionId: '$(extensionId)'
              versionAction: 'Patch'
          
          - task: PackageAzureDevOpsExtension@4
            displayName: 'Package extension'
            inputs:
              rootFolder: '$(System.DefaultWorkingDirectory)'
              publisherId: '$(publisherId)'
              extensionId: '$(extensionId)'
              extensionName: '$(extensionName)'
              extensionVersion: '$(QueryVersion.Extension.Version)'
              updateTasksVersion: true
              updateTasksVersionType: 'patch'
              extensionVisibility: 'private'
              extensionPricing: 'free'
          
          - task: PublishBuildArtifacts@1
            displayName: 'Publish VSIX artifact'
            inputs:
              PathtoPublish: '$(System.DefaultWorkingDirectory)/*.vsix'
              ArtifactName: '$(artifactName)'
              publishLocation: 'Container'

  - stage: Publish_to_marketplace
    displayName: 'Publish to Marketplace'
    dependsOn: Package_extension
    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
    jobs:
      - deployment: PublishExtension
        displayName: 'Deploy to marketplace'
        environment: 'marketplace-production'
        strategy:
          runOnce:
            deploy:
              steps:
                - task: TfxInstaller@4
                  displayName: 'Install TFX CLI'
                  inputs:
                    version: "v0.x"
                
                - task: PublishAzureDevOpsExtension@4
                  displayName: 'Publish to marketplace'
                  inputs:
                    connectTo: 'VsTeam'
                    connectedServiceName: 'marketplace-connection'
                    fileType: 'vsix'
                    vsixFile: '$(Pipeline.Workspace)/$(artifactName)/*.vsix'
                    publisherId: '$(publisherId)'
                    extensionId: '$(extensionId)'
                    extensionName: '$(extensionName)'
                    updateTasksVersion: false
                    extensionVisibility: 'private'
                    extensionPricing: 'free'

package.json konfigurálása teszteléshez

Tesztszkriptek hozzáadása a következőhöz package.json:

{
  "scripts": {
    "test": "mocha tests/_suite.js --reporter xunit --reporter-option output=test-results.xml",
    "test-verbose": "cross-env TASK_TEST_TRACE=1 npm test"
  }
}

Folyamatszakaszok lebontása

1. szakasz: Tesztelés és ellenőrzés

  • Cél: A kód minőségének és működésének biztosítása
  • Műveletek: Függőségek telepítése, TypeScript fordítása, egységtesztek futtatása, eredmények közzététele
  • Ellenőrzés: Minden tesztnek át kell mennie a folytatáshoz

2. szakasz: Csomagbővítmény

  • Cél: Üzembe helyezhető VSIX-csomag létrehozása
  • Műveletek: Aktuális verzió, növekményes verzió, csomagbővítmény lekérdezése, összetevők közzététele
  • Verziószámozás: Automatikusan kezeli a verziónövekményeket

3. szakasz: Közzététel a piactéren

  • Cél: Üzembe helyezés a Visual Studio Marketplace-en
  • Feltételek: Csak a főágon fut a sikeres csomagolás után
  • Környezet: Üzembehelyezési környezetet használ jóváhagyási kapukhoz

Ajánlott eljárások a CI/CD-hez

  • Ágvédelem: Csak a fő/kiadási ágakból való közzététel
  • Környezeti kapuk: Üzemi környezetek használata éles kiadásokhoz
  • Verziókezelés: Verziónövekmények automatizálása az ütközések elkerülése érdekében
  • Tesztelési lefedettség: Átfogó tesztelési lefedettség biztosítása a csomagolás előtt
  • Biztonság: Szolgáltatáskapcsolatok használata a merevlemezes hitelesítő adatok helyett
  • Figyelés: Riasztások beállítása sikertelen üzemelő példányokhoz

A klasszikus buildelési folyamatok esetében kövesse az alábbi lépéseket a bővítmények csomagolásának és közzétételének beállításához:

  1. Adja hozzá a Bash TypeScript JavaScriptbe fordításához tartozó feladatot.

  2. A meglévő verzió lekérdezéséhez adja hozzá a Lekérdezésbővítmény verziója feladatot a következő bemenetekkel:

    • Csatlakozás a következőhöz: Visual Studio Marketplace
    • Visual Studio Marketplace (szolgáltatáskapcsolat): Szolgáltatáskapcsolat
    • Közzétevő azonosítója: A Visual Studio Marketplace-közzétevő azonosítója
    • Bővítmény azonosítója: A fájlban lévő vss-extension.json bővítmény azonosítója
    • Verzió növelése: Javítás
    • Kimeneti változó: Task.Extension.Version

  3. Ha a bővítményeket json jegyzék alapján szeretné csomagolni, adja hozzá a Csomagbővítmény feladatot a következő bemenetek használatával:

    • Gyökér manifesztek mappa: A manifesztfájlt tartalmazó gyökérkönyvtárra hivatkozik. Például $(System.DefaultWorkingDirectory) a gyökérkönyvtár
    • Jegyzékfájl: vss-extension.json
    • Közzétevő azonosítója: A Visual Studio Marketplace-közzétevő azonosítója
    • Bővítmény azonosítója: A fájlban lévő vss-extension.json bővítmény azonosítója
    • Bővítmény neve: A fájlban lévő vss-extension.json bővítmény neve
    • Bővítmény verziója: $(Task.Extension.Version)
    • Feladatok verziójának felülbírálása: kiválasztva (igaz)
    • Felülbírálás típusa: Csak a folt cseréje (1.0.r)
    • Bővítmény láthatósága: Ha a bővítmény még fejlesztés alatt áll, állítsa be az értéket privátra. A bővítmény nyilvános kiadásához állítsa az értéket nyilvánosra.

  4. A közzétett fájlokba való másoláshoz adja hozzá a Fájlok másolása feladatot a következő bemenetekkel:

    • Tartalom: Az összes fájl, amelyeket közzétételhez műtárgyként másolni kell
    • Célmappa: Az a mappa, amelybe a fájlok át lesznek másolva
      • Például: $(Build.ArtifactStagingDirectory)

  5. Adja hozzá a Build-artefaktok közzététele elemet az artefaktok közzétételéhez, hogy más feladatokban vagy folyamatokban is felhasználhatók legyenek. Használja a következő bemeneteket:

    • Közzététel elérési útja: A közzétett fájlokat tartalmazó mappa elérési útja
      • Például: $(Build.ArtifactStagingDirectory)
    • Összetevő neve: Az összetevőnek adott név
    • Összetevők közzétételi helye: Az Azure Pipelines kiválasztása az összetevő jövőbeli feladatokban való használatához

3. szakasz: Buildösszetevők letöltése és a bővítmény közzététele

  1. A tfx-cli buildügynökre való telepítéséhez adja hozzá a Use Node CLI for Azure DevOps (tfx-cli) szolgáltatást.

  2. Ha az összetevőket egy új feladatra szeretné letölteni, adja hozzá a buildösszetevők letöltése feladatot a következő bemenetekkel:

    • A következő által létrehozott összetevők letöltése: Ha az összetevőt egy új feladatra tölti le ugyanabból a folyamatból, válassza az Aktuális build lehetőséget. Ha új folyamatra tölt le, válassza az Adott build lehetőséget
    • Letöltés típusa: Válassza ki az Adott összetevőt az összes közzétett fájl letöltéséhez.
    • Összetevő neve: A közzétett összetevő neve
    • Célkönyvtár: Az a mappa, amelyben a fájlokat le kell tölteni

  3. A Közzétételi bővítmény feladat lekéréséhez használja a következő bemeneteket:

    • Csatlakozás a következőhöz: Visual Studio Marketplace
    • Visual Studio Marketplace-kapcsolat: ServiceConnection
    • Bemeneti fájl típusa: VSIX-fájl
    • VSIX-fájl: /Publisher.*.vsix
    • Közzétevő azonosítója: A Visual Studio Marketplace-közzétevő azonosítója
    • Bővítmény azonosítója: A fájlban lévő vss-extension.json bővítmény azonosítója
    • Bővítmény neve: A fájlban lévő vss-extension.json bővítmény neve
    • Bővítmény láthatósága: Privát vagy nyilvános

Nem kötelező: A bővítmény telepítése és tesztelése

A bővítmény közzététele után telepíteni kell az Azure DevOps-szervezetekben.

Bővítmény telepítése a szervezet számára

Telepítse a megosztott bővítményt néhány lépésben:

  1. Lépjen a Szervezeti beállítások elemre , és válassza a Bővítmények lehetőséget.

  2. Keresse meg a bővítményt a Velem megosztott bővítmények szakaszban:

    • A bővítmény hivatkozásának kiválasztása
    • Válassza a Get it free or Install (Ingyenes vagy Telepítés) lehetőséget

  3. Ellenőrizze, hogy a bővítmény megjelenik-e a Telepített bővítmények listában:

    • Ellenőrizze, hogy elérhető-e a folyamat feladattárában

Megjegyzés

Ha nem látja a Bővítmények lapot, győződjön meg arról, hogy a szervezet adminisztrációs szintjén (https://dev.azure.com/{organization}/_admin) van, és nem a projekt szintjén.

Teljes körű tesztelés

A telepítés után végezzen átfogó tesztelést:

  1. Tesztfolyamat létrehozása:

    • Egyéni tevékenység hozzáadása új folyamathoz
    • Az összes bemeneti paraméter konfigurálása
    • Tesztelés különböző bemeneti kombinációkkal

  2. Funkciók ellenőrzése:

    • A folyamat futtatása és a végrehajtás figyelése
    • Feladatkimenetek és naplók ellenőrzése
    • Hibakezelés ellenőrzése érvénytelen bemenetekkel

  3. Tesztteljesítmény:

    • Nagy bemeneti fájlokkal végzett tesztelés (ha van)
    • Erőforrás-használat figyelése
    • Időtúllépési viselkedés ellenőrzése

Gyakori kérdések

K: Hogyan történik a feladattörlés kezelése?

Válasz: A folyamatügynök elküldi SIGINT és SIGTERM jelzi a feladatfolyamatokat. Bár a feladattár nem biztosít explicit lemondási kezelést, a feladat képes jelkezelőket implementálni. További részletekért lásd: Ügynökfeladatok lemondása.

K: Hogyan távolíthatok el egy feladatot a szervezetemből?

Válasz: Az automatikus törlés nem támogatott , mert megszakítaná a meglévő folyamatokat. Helyette:

  1. A tevékenység elavultként való megjelölése
  2. Verziókezelés: A feladat verziójának ütköztetése
  3. Kommunikáció: A felhasználók értesítése az elavulás idővonaláról

K: Hogyan frissíthetem a feladatomat a legújabb Node.js verzióra?

V: Frissítsen a csomópont legújabb verziójára a jobb teljesítmény és biztonság érdekében. A migrálással kapcsolatos útmutatásért lásd: Feladatok frissítése a Node 20-ra.

Több csomópontverzió támogatásához több végrehajtási szakaszt is be kell sorolni a következőbe task.json:

"execution": {
  "Node20_1": {
    "target": "index.js"
  },
  "Node10": {
    "target": "index.js"
  }
}

A Node 20-tal rendelkező ügynökök az előnyben részesített verziót használják, míg a régebbi ügynökök visszaállnak a Node 10-esre.

A feladatok frissítése:

  • Annak érdekében, hogy a kód a várt módon viselkedjen, tesztelje a feladatokat a Node különböző futóverzióiban.

  • A feladat végrehajtási szakaszában frissítsen a Node vagy Node10 állapotról a Node16 vagy Node20 állapotra.

  • A régebbi kiszolgálóverziók támogatásához el kell hagynia a Node/Node10 célt. Előfordulhat, hogy a régebbi Azure DevOps Server-verziók nem tartalmazzák a Node legújabb futóverzióit.

  • Megadhatja, hogy megosztja-e a célban definiált belépési pontot, vagy hogy a célokat a használt csomópontverzióra optimalizálja.

    "execution": {
   "Node10": {
     "target": "bash10.js",
     "argumentFormat": ""
   },
   "Node16": {
     "target": "bash16.js",
     "argumentFormat": ""
   },
   "Node20_1": {
     "target": "bash20.js",
     "argumentFormat": ""
   }
}

Fontos

Ha nem adja hozzá a Node 20 futó támogatását az egyéni feladatokhoz, nem fognak működni azokról az ügynökökről, amelyek a pipelines-agent-*kiadási csatornáról lettek telepítve.

Kapcsolódó tartalom

  • Last updated on