Přidání rozšíření vlastních úloh kanálů

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

Zjistěte, jak nainstalovat rozšíření do vaší organizace pro vlastní úlohy sestavení nebo vydání v Azure DevOps. Další informace najdete v tématu Co je Azure Pipelines?

Požadavky

K vytváření rozšíření pro Azure DevOps potřebujete následující software a nástroje.

|--- README.md    
|--- images                        
    |--- extension-icon.png  
|--- buildandreleasetask            // where your task scripts are placed
|--- vss-extension.json             // extension's manifest

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

1. Vytvoření vlastního úkolu

Proveďte všechny části tohoto postupu ve buildandreleasetask složce.

Vytvoření generování uživatelského rozhraní úloh

1. Vytvořte strukturu složek pro úlohu a nainstalujte požadované knihovny a závislosti.

2. Otevřete příkazové okno PowerShellu, přejděte do složky buildandreleasetask a spusťte následující příkaz.

   npm init --yes
   

   npm initpackage.json vytvoří soubor. Přidali --yes jsme parametr pro přijetí všech výchozích npm init možností.

   Tip

   Agent automaticky nenainstaluje požadované moduly, protože očekává, že složka úloh zahrne moduly uzlu. Pokud chcete tento problém zmírnit, zkopírujte ho do node_modules buildandreleasetasksložky . S tím, jak se váš úkol zvětší, je snadné překročit limit velikosti (50 MB) souboru VSIX. Než zkopírujete složku uzlu, možná budete chtít spustit npm install --production nebo npm prune --productionnebo můžete napsat skript pro sestavení a zabalení všeho.

3. Přidejte azure-pipelines-task-lib do knihovny.

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

4. Ujistěte se, že jsou pro externí závislosti nainstalované typy TypeScriptu.

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

5. Vytvořte .gitignore soubor a přidejte do něj node_modules. Proces sestavení by měl provést a npm install vytvořit typings install tak, aby se node_modules sestavily pokaždé a nemusely být vráceny se změnami.

   echo node_modules > .gitignore
   

6. Nainstalujte Mocha jako vývojovou závislost.

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

7. Zvolte TypeScript verze 2.3.4 nebo 4.6.3.

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

   Poznámka:

   Ujistěte se, že je TypeScript nainstalovaný globálně s npm ve vašem vývojovém prostředí, takže tsc je příkaz k dispozici. Pokud tento krok přeskočíte, použije se ve výchozím nastavení TypeScript verze 2.3.4 a budete muset balíček nainstalovat globálně, aby byl tsc příkaz k dispozici.

8. Vytvoření tsconfig.json možností kompilátoru Tento soubor zajistí, že se vaše soubory TypeScript zkompilují do souborů JavaScriptu.

   tsc --init --target es2022
   

Vytvoření úkolu

Teď, když je generování uživatelského rozhraní hotové, můžeme vytvořit vlastní úkol.

1. Ve složce vytvořte task.json soubor buildandreleasetask . Tento task.json soubor popisuje úlohu sestavení/vydání a je to, co systém sestavení/verze používá k vykreslení možností konfigurace uživateli a ke zjištění, které skripty se mají spustit v době sestavení/vydání.

2. Zkopírujte následující kód a nahraďte {{placeholders}} informacemi o úkolu. Nejdůležitější zástupný symbol je taskguida musí být jedinečný.

   {
    "$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"
        }
    }
    }
   

3. Vytvořte index.ts soubor pomocí následujícího kódu jako odkazu. Tento kód se spustí, když se úloha zavolá.

   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();
   

4. Zadejte "tsc" ze buildandreleasetask složky, ze které chcete zkompilovat index.js soubor z index.ts.

komponenty task.json

Podívejte se na následující popis některých součástí task.json souboru.

(New-Guid).Guid

Spuštění úlohy

Spusťte úlohu node index.js z PowerShellu.

V následujícím příkladu úloha selže, protože nebyly zadány vstupy (samplestring je povinný vstup).

 node index.js
 ##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

Jako opravu můžeme nastavit samplestring vstup a spustit úlohu znovu.

$env:INPUT_SAMPLESTRING="Human"
node index.js
##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]Agent.ProxyUrl=undefined
##vso[task.debug]Agent.CAInfo=undefined
##vso[task.debug]Agent.ClientCert=undefined
##vso[task.debug]Agent.SkipCertValidation=undefined
##vso[task.debug]samplestring=Human
Hello Human

Tentokrát byl úkol úspěšný, protože samplestring byl zadán a správně vypíše text "Hello Human!".

2. Testování jednotek skriptů úkolů

Proveďte testy jednotek, abyste mohli rychle otestovat skript úkolu, a ne externí nástroje, které volá. Otestujte všechny aspekty cesty úspěchu i selhání.

1. Nainstalujte testovací nástroje. V tomto postupu používáme Jako testovací ovladač Mocha .

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

2. Vytvořte tests složku obsahující soubor s následujícím obsahem _suite.ts :

   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() {
   
       });
   
       after(() => {
   
       });
   
       it('should succeed with simple inputs', function(done: Mocha.Done) {
           // Add success test here
       });
   
       it('it should fail if tool returns 1', function(done: Mocha.Done) {
           // Add failure test here
       });    
   });
   

   Tip

   Testovací složka by měla být umístěná ve složce buildandreleasetask. Pokud se zobrazí chyba žádosti o synchronizaci, můžete ji obejít přidáním žádosti sync-request do složky buildandreleasetask pomocí příkazu npm i --save-dev sync-request.

3. V testovacím adresáři vytvořte success.ts soubor s následujícím obsahem. Toto vytvoření souboru simuluje spuštění úlohy a napodobuje všechna volání vnějších metod.

   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);
   
   tmr.setInput('samplestring', 'human');
   
   tmr.run();
   

   Test úspěchu ověří, že s příslušnými vstupy proběhne úspěšně bez chyb nebo upozornění a vrátí správný výstup.

4. Přidejte do _suite.ts souboru následující příklad úspěšného testu a spusťte spuštění runneru úkolu.

       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.run(); //current, old function.
       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
       });
   });
   

5. Ve svém testovacím adresáři vytvořte failure.ts soubor jako spouštěč úkolů s následujícím obsahem:

   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);
   
   tmr.setInput('samplestring', 'bad');
   
   tmr.run();
   

   Test selhání ověří, že když nástroj získá chybný nebo neúplný vstup, selže očekávaným způsobem s užitečným výstupem.

6. Do souboru přidejte následující kód _suite.ts , který spustí spouštěč úloh.

   it('it should fail if tool returns 1', function(done: Mocha.Done) {
       this.timeout(1000);
   
       let tp = path.join(__dirname, 'failure.js');
       let tr: ttm.MockTestRunner = new ttm.MockTestRunner(tp);
   
       tr.run();
       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();
   });
   

7. Spusťte testy.

   tsc
   mocha tests/_suite.js
   

   Oba testy by měly proběhnout. Pokud chcete spustit testy s podrobnějším výstupem (co byste viděli v konzole sestavení), nastavte proměnnou prostředí: TASK_TEST_TRACE=1.

   $env:TASK_TEST_TRACE=1
   

3. Vytvoření souboru manifestu přípony

Manifest rozšíření obsahuje všechny informace o vašem rozšíření. Obsahuje odkazy na vaše soubory, včetně složek úkolů a složek obrázků. Ujistěte se, že jste vytvořili složku obrázků s extension-icon.png. Následující příklad je manifest rozšíření, který obsahuje úlohu sestavení nebo vydání.

Zkopírujte následující .json kód a uložte vss-extension.json ho jako soubor do adresáře home .

Nevytvářit tento soubor ve složce buildandreleasetask.

{
    "manifestVersion": 1,
    "id": "build-release-task",
    "name": "Fabrikam Build and Release Tools",
    "version": "0.0.1",
    "publisher": "fabrikam",
    "targets": [
        {
            "id": "Microsoft.VisualStudio.Services"
        }
    ],    
    "description": "Tools for building/releasing with Fabrikam. Includes one build/release task.",
    "categories": [
        "Azure Pipelines"
    ],
    "icons": {
        "default": "images/extension-icon.png"        
    },
    "files": [
        {
            "path": "buildandreleasetask"
        }
    ],
    "contributions": [
        {
            "id": "custom-build-release-task",
            "type": "ms.vss-distributed-task.task",
            "targets": [
                "ms.vss-distributed-task.tasks"
            ],
            "properties": {
                "name": "buildandreleasetask"
            }
        }
    ]
}

Příspěvky

Soubory

4. Zabalte rozšíření

Zabalte všechny soubory dohromady, abyste získali rozšíření do Visual Studio Marketplace. Všechna rozšíření jsou zabalená jako soubory .vsix kompatibilní s VSIX 2.0. Microsoft poskytuje rozhraní příkazového řádku (CLI) pro více platforem pro zabalení rozšíření.

Jakmile budete mít tfx-cli, přejděte do domovského adresáře rozšíření a spusťte následující příkaz:

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

Jakmile je vaše zabalená přípona v souboru .vsix, jste připraveni publikovat své rozšíření na Marketplace.

5. Publikování rozšíření

Pokud chcete rozšíření publikovat, nejprve vytvoříte vydavatele, pak ho nahrajete a nakonec ho nasdílíte.

Vytvoření vydavatele

Všechna rozšíření, včetně rozšíření od Microsoftu, jsou identifikována jako poskytovaná vydavatelem. Pokud ještě nejste členem existujícího vydavatele, vytvoříte ho.

1. Přihlaste se k portálu publikování na webu Visual Studio Marketplace.
2. Pokud ještě nejste členem existujícího vydavatele, zobrazí se výzva k vytvoření vydavatele. Pokud se nezobrazí výzva k vytvoření vydavatele, posuňte se dolů na konec stránky a v části Související weby vyberte Publikovat rozšíření.
   • Zadejte identifikátor vydavatele, například: mycompany-myteam.
     • Tento identifikátor se používá jako hodnota atributu v souboru manifestu publisher rozšíření.
   • Zadejte zobrazovaný název vydavatele, například: My Team.
3. Zkontrolujte smlouvu vydavatele Marketplace a vyberte Vytvořit.

Je definován váš vydavatel. V budoucí verzi můžete udělit oprávnění k zobrazení a správě rozšíření vydavatele. Publikování rozšíření v rámci běžného vydavatele je jednodušší a bezpečnější, aniž byste museli sdílet sadu přihlašovacích údajů mezi uživateli.

Nahrání rozšíření

Najděte tlačítko Nahrát novou příponu, přejděte do zabaleného souboru .vsix a vyberte Nahrát.

1. Rozšíření můžete nahrát také prostřednictvím rozhraní příkazového řádku (CLI) pomocí tfx extension publish příkazu místo tfx extension create zabalení a publikování rozšíření v jednom kroku. Volitelně můžete rozšíření sdílet --share-with s jedním nebo více účty po publikování.

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

2. Vytvořte osobní přístupový token (PAT).

   • Vyberte obor Marketplace (publikování). Tento obor omezuje token jenom na možnost publikovat rozšíření na Marketplace.

Sdílení rozšíření

Teď, když jste nahráli rozšíření, je na Marketplace, ale nikdo ho neuvidí. Sdílejte ji s vaší organizací, abyste ji mohli nainstalovat a otestovat.

Vyberte rozšíření pravým tlačítkem a vyberte Sdílet a zadejte informace o vaší organizaci. Můžete ho sdílet s dalšími účty, ke kterým chcete mít přístup i k rozšíření.

Teď, když je vaše rozšíření sdílené na Marketplace, musí ho nainstalovat každý, kdo ho chce použít.

6. Vytvoření kanálu buildu a verze pro publikování rozšíření na Marketplace

Vytvořte kanál buildu a verze v Azure DevOps, který pomáhá udržovat vlastní úlohu na Marketplace.

Požadavky

trigger: 
- main
pool:
vmImage: "ubuntu-latest"
variables:
- group: variable-group # Rename to whatever you named your variable group in the prerequisite stage of step 6
stages:
- stage: Run_and_publish_unit_tests
jobs:
- job:
steps:
- task: TfxInstaller@4
inputs:
version: "v0.x"
- task: Npm@1
inputs:
command: 'install'
workingDir: '/TaskDirectory' # Update to the name of the directory of your task
- task: Bash@3
displayName: Compile Javascript
inputs:
targetType: "inline"
script: |
cd TaskDirectory # Update to the name of the directory of your task
tsc
- task: Npm@1
inputs:
command: 'custom'
workingDir: '/TestsDirectory' # Update to the name of the directory of your task's tests
customCommand: 'testScript' # See the definition in the explanation section below - it may be called test
- task: PublishTestResults@2
inputs:
testResultsFormat: 'JUnit'
testResultsFiles: '**/ResultsFile.xml'
- stage: Package_extension_and_publish_build_artifacts
jobs:
- job:
steps:
- task: TfxInstaller@4
inputs:
version: "0.x"
- task: Npm@1
inputs:
command: 'install'
workingDir: '/TaskDirectory' # Update to the name of the directory of your task
- task: Bash@3
displayName: Compile Javascript
inputs:
targetType: "inline"
script: |
cd TaskDirectory # Update to the name of the directory of your task
tsc
- task: QueryAzureDevOpsExtensionVersion@4
name: QueryVersion
inputs:
connectTo: 'VsTeam'
connectedServiceName: 'ServiceConnection' # Change to whatever you named the service connection
publisherId: '$(PublisherID)'
extensionId: '$(ExtensionID)'
versionAction: 'Patch'
- task: PackageAzureDevOpsExtension@4
inputs:
rootFolder: '$(System.DefaultWorkingDirectory)'
publisherId: '$(PublisherID)'
extensionId: '$(ExtensionID)'
extensionName: '$(ExtensionName)'
extensionVersion: '$(QueryVersion.Extension.Version)'
updateTasksVersion: true
updateTasksVersionType: 'patch'
extensionVisibility: 'private' # Change to public if you're publishing to the marketplace
extensionPricing: 'free'
- task: CopyFiles@2
displayName: "Copy Files to: $(Build.ArtifactStagingDirectory)"
inputs:
Contents: "**/*.vsix"
TargetFolder: "$(Build.ArtifactStagingDirectory)"
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: '$(Build.ArtifactStagingDirectory)'
ArtifactName: '$(ArtifactName)'
publishLocation: 'Container'
- stage: Download_build_artifacts_and_publish_the_extension
jobs:
- job:
steps:
- task: TfxInstaller@4
inputs:
version: "v0.x"
- task: DownloadBuildArtifacts@0
inputs:
buildType: "current"
downloadType: "single"
artifactName: "$(ArtifactName)"
downloadPath: "$(System.DefaultWorkingDirectory)"
- task: PublishAzureDevOpsExtension@4
inputs:
connectTo: 'VsTeam'
connectedServiceName: 'ServiceConnection' # Change to whatever you named the service connection
fileType: 'vsix'
vsixFile: '$(PublisherID).$(ExtensionName)/$(PublisherID)..vsix'
publisherId: '$(PublisherID)'
extensionId: '$(ExtensionID)'
extensionName: '$(ExtensionName)'
updateTasksVersion: false
extensionVisibility: 'private' # Change to public if you're publishing to the marketplace
extensionPricing: 'free'

Další informace naleznete v tématu Určení událostí, které aktivují kanály.

Fáze kanálu

Následující část vám pomůže pochopit, jak fáze kanálu fungují.

Fáze 1: Spuštění a publikování testů jednotek

Tato fáze spouští testy jednotek a publikuje výsledky testů do Azure DevOps.

Pokud chcete spustit testy jednotek, přidejte do souboru package.json vlastní skript, jako je následující příklad.

"scripts": {
    "testScript": "mocha ./TestFile --reporter xunit --reporter-option output=ResultsFile.xml"
},

1. Pokud chcete nainstalovat tfx-cli do agenta sestavení, přidejte "Use Node CLI for Azure DevOps (tfx-cli)" (Použít rozhraní příkazového řádku uzlu pro Azure DevOps (tfx-cli).

2. Přidejte úlohu npm pomocí příkazu install a zacílíte složku se souborem package.json.

3. Přidejte úlohu Bash, která zkompiluje TypeScript do JavaScriptu.

4. Přidejte úlohu "npm" pomocí příkazu "custom", zaměřte se na složku, která obsahuje testy jednotek, a zadejte testScript jako příkaz. Použijte následující vstupy:

   • Příkaz: vlastní
   • Pracovní složka, která obsahuje package.json: /TestsDirectory
   • Příkaz a argumenty: testScript

5. Přidejte úlohu Publikovat výsledky testu. Pokud používáte reportér Mocha XUnit, ujistěte se, že je formát výsledku "JUnit" a ne "XUnit". Nastavte složku výsledků hledání na kořenový adresář. Použijte následující vstupy:

   • Formát výsledku testu: JUnit
   • Soubory výsledků testů: **/ResultsFile.xml
   • Složka výsledků hledání: $(System.DefaultWorkingDirectory)

   Po publikování výsledků testu by výstup na kartě testy měl vypadat jako v následujícím příkladu.

   

Fáze 2: Zabalení rozšíření a publikování artefaktů sestavení

1. Pokud chcete nainstalovat tfx-cli do agenta sestavení, přidejte "Use Node CLI for Azure DevOps (tfx-cli)" (Použít rozhraní příkazového řádku uzlu pro Azure DevOps (tfx-cli).

2. Přidejte úlohu npm pomocí příkazu install a zacílíte složku se souborem package.json.

3. Přidejte úlohu Bash, která zkompiluje TypeScript do JavaScriptu.

4. Přidejte úlohu "Verze rozšíření dotazu" pro dotazování na stávající verzi rozšíření. Použijte následující vstupy:

   • Připojení: Visual Studio Marketplace
   • Visual Studio Marketplace (připojení služby): Připojení ke službě
   • ID vydavatele: ID vydavatele sady Visual Studio Marketplace
   • ID přípony: ID vaší přípony v souboru vss-extension.json
   • Zvýšení verze: Oprava
   • Výstupní proměnná: Task.Extension.Version

5. Přidejte úlohu Rozšíření balíčku pro zabalení rozšíření na základě kódu JSON manifestu. Použijte následující vstupy:

   • Kořenová složka manifestů: Odkazuje na kořenový adresář, který obsahuje soubor manifestu. Například $(System.DefaultWorkingDirectory) je kořenový adresář.
   • Soubory manifestu: vss-extension.json
   • ID vydavatele: ID vydavatele sady Visual Studio Marketplace
   • ID přípony: ID vaší přípony v souboru vss-extension.json
   • Název přípony: Název vaší přípony v souboru vss-extension.json
   • Verze rozšíření: $(Task.Extension.Version)
   • Přepsání verze úkolů: zaškrtnuto (true)
   • Typ přepsání: Nahrazení pouze opravy (1.0.r)
   • Viditelnost rozšíření: Pokud je rozšíření stále ve vývoji, nastavte hodnotu na privátní. Pokud chcete rozšíření uvolnit pro veřejnost, nastavte hodnotu na veřejnou.

6. Přidejte úlohu Kopírovat soubory a zkopírujte publikované soubory. Použijte následující vstupy:

   • Obsah: Všechny soubory, které se mají zkopírovat pro jejich publikování jako artefakt
   • Cílová složka: Složka, do které se soubory zkopírují
     • Příklad: $(Build.ArtifactStagingDirectory)

7. Přidejte "Publikovat artefakty sestavení" a publikujte artefakty pro použití v jiných úlohách nebo kanálech. Použijte následující vstupy:

   • Cesta k publikování: Cesta ke složce, která obsahuje publikované soubory
     • Příklad: $(Build.ArtifactStagingDirectory)
   • Název artefaktu: Název udělený artefaktu
   • Umístění publikování artefaktů: Zvolte Azure Pipelines, aby se artefakt používal v budoucích úlohách.

Fáze 3: Stažení artefaktů sestavení a publikování rozšíření

1. Pokud chcete nainstalovat tfx-cli do agenta sestavení, přidejte "Use Node CLI for Azure DevOps (tfx-cli)" (Použít rozhraní příkazového řádku uzlu pro Azure DevOps (tfx-cli).

2. Přidejte úlohu Stažení artefaktů sestavení pro stažení artefaktů do nové úlohy. Použijte následující vstupy:

   • Stažení artefaktů vytvořených: Pokud stahujete artefakt do nové úlohy ze stejného kanálu, vyberte Aktuální sestavení. Pokud stahujete nový kanál, vyberte Konkrétní sestavení.
   • Typ stahování: Zvolte "Konkrétní artefakt" a stáhněte všechny publikované soubory.
   • Název artefaktu: Název publikovaného artefaktu.
   • Cílový adresář: Složka, do které se mají soubory stáhnout.

3. Posledním úkolem, který potřebujete, je úkol Publikovat rozšíření. Použijte následující vstupy:

   • Připojení: Visual Studio Marketplace
   • Připojení k Visual Studio Marketplace: ServiceConnection
   • Typ vstupního souboru: Soubor VSIX
   • Soubor VSIX: /Publisher.*.vsix
   • ID vydavatele: ID vydavatele sady Visual Studio Marketplace
   • ID přípony: ID vaší přípony v souboru vss-extension.json
   • Název přípony: Název vaší přípony v souboru vss-extension.json
   • Viditelnost rozšíření: Soukromá nebo veřejná

Volitelné: Instalace a otestování rozšíření

Během několika kroků nainstalujte rozšíření, které s vámi někdo sdílí:

1. V ovládacích panelech organizace (https://dev.azure.com/{organization}/_admin) přejděte na stránku správy kolekce projektů.
2. Na kartě Rozšíření vyhledejte rozšíření ve skupině Rozšíření sdílená se mnou a vyberte odkaz na rozšíření.
3. Nainstalujete rozšíření.

Pokud kartu Rozšíření nevidíte, ujistěte se, že jste v ovládacích panelech (stránka správy na úrovni https://dev.azure.com/{organization}/_adminkolekce projektů) a ne na stránce pro správu projektu.

Pokud kartu Rozšíření nevidíte, nebudou rozšíření pro vaši organizaci povolená. K funkci rozšíření můžete získat přednostní přístup tak, že se připojíte k programu Visual Studio Partner Program.

Pokud chcete zabalit a publikovat rozšíření Azure DevOps na Visual Studio Marketplace, můžete si stáhnout úlohy rozšíření Azure DevOps.

Nejčastější dotazy

Podívejte se na následující nejčastější dotazy týkající se přidání vlastních úloh sestavení nebo vydaných verzí do rozšíření pro Azure DevOps.

Otázka: Jak můžu omezit využití příkazů Azure Pipelines pro úlohu?

Můžete omezit použití příkazů Azure Pipelines a proměnné, které se nastaví podle úlohy. Tato akce může být užitečná, pokud chcete zabránit neomezenému přístupu k proměnným nebo příkazům vso pro vlastní skripty, které se provádějí. Doporučujeme, abyste ho nastavili pro nové úkoly. Pro použití možná budete muset do souboru task.json přidat následující příkaz:

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

Je-li restricted zadána hodnota pro mode – můžete spustit pouze následující příkazy podle úkolu:

• logdetail
• logissue
• complete
• setprogress
• setsecret
• setvariable
• debug
• settaskvariable
• prependpath
• publish

Omezení settableVariables umožňují předat seznam povolených proměnných, které se nastaví podle setvariable příkazů nebo prependpath příkazů. Umožňuje také základní regulární výrazy. Pokud by například seznam povolených byl: ['abc', 'test*'], nastavení abc, testnebo test1 jako proměnné s libovolnou hodnotou nebo před jejich umístěním na cestu by bylo úspěšné, ale pokud se pokusíte nastavit proxy proměnné, zobrazí se upozornění. Prázdný seznam znamená, že žádné proměnné se nezmění podle úkolu.

Pokud je settableVariables tento klíč commands vynechán, nepoužije se relevantní omezení.

Funkce omezení je dostupná od verze agenta verze 2.182.1 .

Otázka: Jak se zpracovává signál zrušení úlohou?

A: Agent kanálu odesílá a SIGTERM signalizuje SIGINT příslušný podřízený proces. V knihovně úloh nejsou explicitní prostředky ke zpracování. Další informace naleznete v tématu Zrušení úloh agenta.

Otázka: Jak můžu úkol odebrat z kolekce projektů?

A: Automatické odstraňování úkolů nepodporujeme. Automatické odstranění není bezpečné a přeruší stávající kanály, které už takové úlohy používají. Úkoly ale můžete označit jako zastaralé. Uděláte to tak, že narazíte na verzi úlohy a označíte ji jako zastaralou.

Otázka: Jak můžu upgradovat vlastní úlohu na nejnovější uzel?

A: Doporučujeme upgradovat na nejnovější verzi uzlu. Například informace najdete v tématu Upgrade úkolů na Node 20.

Vzhledem k tomu, že agenti hostovaní Microsoftem a různé verze Azure DevOps Serveru mají různé životní cyklus, můžou se nainstalovat různé verze Node Runneru v závislosti na tom, kde je úloha spuštěná. Aby bylo možné spustit stejnou úlohu na agentech s různými verzemi Node Runneru, může soubor task.json obsahovat několik oddílů spuštění. V následujícím příkladu si agenti Azure Pipeline, které zahrnují spouštěč Node 20, ve výchozím nastavení vyberou a ty, které se nebudou vracet k implementaci Node 10.

  "execution": {
    "Node10": {
      "target": "bash.js",
      "argumentFormat": ""
    },
    "Node20_1": {
      "target": "bash.js",
      "argumentFormat": ""
    }

Upgrade úkolů:

• Otestujte úlohy na různých verzích Node Runneru, abyste měli jistotu, že se váš kód chová podle očekávání.

• V části provádění úkolu aktualizujte z Node nebo Node10 do Node16 nebo Node20.

• Pokud chcete podporovat starší verze serveru, měli byste ponechat Node/Node10 cíl. Starší verze Azure DevOps Serveru nemusí obsahovat nejnovější verzi Node Runneru.

• Můžete se rozhodnout sdílet vstupní bod definovaný v cíli nebo mít cíle optimalizované pro použitou verzi uzlu.

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

Související články

• Referenční informace k manifestu rozšíření
• Schéma JSON úlohy sestavení/vydání
• Příklady úloh sestavení/vydání