Een taakextensie voor aangepaste pijplijnen toevoegen

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

Deze handleiding helpt u bij het maken, testen en publiceren van aangepaste build- of releasetaken als Azure DevOps-extensies. Met aangepaste pijplijntaken kunt u Azure DevOps uitbreiden met gespecialiseerde functionaliteit die is afgestemd op de werkstromen van uw team, van eenvoudige hulpprogramma's tot complexe integraties met externe systemen.

Meer informatie over het uitvoeren van de volgende taken:

• De ontwikkelomgeving en projectstructuur instellen
• Taaklogica maken met Behulp van TypeScript en de Azure Pipelines-taakbibliotheek
• Uitgebreide eenheidstests implementeren met mockframeworks
• Uw extensie verpakken voor distributie
• Publiceren naar Visual Studio Marketplace
• Geautomatiseerde CI/CD-pijplijnen instellen voor extensieonderhoud

Zie Wat is Azure Pipelines voor meer informatie over Azure Pipelines?

Vereisten

Voordat u begint, moet u ervoor zorgen dat u aan de volgende vereisten voldoet:

Projectstructuur

Maak een home map voor uw project. Nadat u deze zelfstudie hebt voltooid, moet uw extensie de volgende structuur hebben:

|--- 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

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

1. Een aangepaste taak maken

In deze sectie wordt u begeleid bij het maken van de basisstructuur en implementatie van uw aangepaste taak. Alle bestanden in deze stap moeten worden gemaakt in de map in de buildandreleasetask map in de map van home uw project.

De taakstructuur instellen

Maak de basisprojectstructuur en installeer de vereiste afhankelijkheden:

1. Als u het Node.js project wilt initialiseren, opent u PowerShell, gaat u naar de buildandreleasetask map en voert u het volgende uit:

   npm init --yes
   

   Het package.json bestand wordt gemaakt met standaardinstellingen. De --yes vlag accepteert automatisch alle standaardopties.

   Aanbeveling

   Azure Pipelines-agents verwachten dat taakmappen knooppuntmodules bevatten. Kopieer node_modules deze naar uw buildandreleasetask map. Als u de VSIX-bestandsgrootte (limiet van 50 MB) wilt beheren, kunt u overwegen om te worden uitgevoerd npm install --production of npm prune --production vóór de verpakking.

2. Installeer de Azure Pipelines-taakbibliotheek:

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

3. TypeScript-typedefinities installeren:

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

4. Uitsluitingen voor versiebeheer instellen

   echo node_modules > .gitignore
   

   Het buildproces moet elke keer worden uitgevoerd npm install om node_modules opnieuw te bouwen.

5. Testafhankelijkheden installeren:

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

6. TypeScript-compiler installeren:

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

   Notitie

   Installeer TypeScript globaal om ervoor te zorgen dat de tsc opdracht beschikbaar is. Zonder dit wordt TypeScript 2.3.4 standaard gebruikt.

7. TypeScript-compilatie configureren:

   tsc --init --target es2022
   

   Het tsconfig.json bestand wordt gemaakt met doelinstellingen voor ES2022.

De taaklogica implementeren

Als de scaffolding is voltooid, maakt u de kerntaakbestanden die functionaliteit en metagegevens definiëren:

1. Maak het taakdefinitiebestand: Maken task.json in de buildandreleasetask map. Dit bestand beschrijft uw taak in het Azure Pipelines-systeem, het definiëren van invoer, uitvoeringsinstellingen en ui-presentatie.

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

   Notitie

   Vervang {{placeholders}} door de werkelijke gegevens van uw taak. De taskguid moet uniek zijn. Genereer er een met Behulp van PowerShell: (New-Guid).Guid

2. Als u de taaklogica wilt implementeren, maakt index.ts u deze met de belangrijkste functionaliteit van uw taak:

   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 compileren naar JavaScript:

   tsc
   

   Het index.js bestand wordt gemaakt op basis van uw TypeScript-bron.

Informatie over task.json onderdelen

Het task.json bestand is het hart van uw taakdefinitie. Dit zijn de belangrijkste eigenschappen:

Beveiligingsbeperkingen

Voeg voor productietaken beveiligingsbeperkingen toe om het gebruik van opdrachten en variabele toegang te beperken:

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

Beperkte modus staat alleen deze opdrachten toe:

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

Besturingselementen voor toegestane acceptatielijsten voor variabelen die kunnen worden ingesteld via setvariable of prependpath. Ondersteunt eenvoudige regex-patronen.

Invoertypen en voorbeelden

Algemene invoertypen voor taakparameters:

"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"
    }
]

Uw taak lokaal testen

Voordat u de verpakking uitvoert, test u uw taak om te controleren of deze correct werkt:

1. Testen met ontbrekende invoer (mislukt):

   node index.js
   

   Verwachte uitvoer:

   ##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. Testen met geldige invoer (moet slagen):

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

   Verwachte uitvoer:

   ##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. Foutafhandeling testen:

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

   Met deze actie wordt het pad voor foutafhandeling in uw code geactiveerd.

   Aanbeveling

   Zie de richtlijnen voor update van Node runner voor informatie over taaklopers en Node.js versies.

Zie de naslaginformatie over build-/releasetaken voor meer informatie.

2. Uitgebreide eenheidstests implementeren

Het testen van uw taak zorgt voor een grondige betrouwbaarheid en helpt bij het ondervangen van problemen vóór de implementatie naar productiepijplijnen.

Testafhankelijkheden installeren

Installeer de vereiste testhulpprogramma's:

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

Test maken

1. Maak een tests map in de taakmap die een _suite.ts bestand bevat:

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

   Aanbeveling

   De testmap moet zich in de taakmap bevinden (bijvoorbeeld buildandreleasetask). Als er een synchronisatieaanvraagfout optreedt, installeert u deze in de taakmap: npm i --save-dev sync-request.

2. Maak success.ts in uw testmap om een geslaagde taakuitvoering te simuleren:

    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. Voeg de geslaagde test toe aan uw _suite.ts bestand:

    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. Maak failure.ts in uw testmap om foutafhandeling te testen:

   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. Voeg de fouttest toe aan uw _suite.ts bestand:

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

Uw tests uitvoeren

Voer de testsuite uit:

# Compile TypeScript
tsc

# Run tests
mocha tests/_suite.js

Beide tests moeten slagen. Stel voor uitgebreide uitvoer (vergelijkbaar met buildconsole-uitvoer) de omgevingsvariabele tracering in:

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

Best practices voor testdekking

• Alle invoercombinaties testen: geldige invoer, ongeldige invoer, ontbrekende vereiste invoer
• Testfoutscenario's: netwerkfouten, bestandssysteemfouten, machtigingsproblemen
• Gesimuleerde externe afhankelijkheden: Vertrouw niet op externe services in eenheidstests
• Uitvoer valideren: console-uitvoer, taakresultaten en gegenereerde artefacten controleren
• Prestatietests: Overweeg tests toe te voegen voor taken die grote bestanden verwerken

Aanbevolen procedures voor beveiliging

• Invoervalidatie: Invoer altijd valideren en opschonen
• Verwerking van geheimen: Gebruiken setSecret voor gevoelige gegevens
• Opdrachtbeperkingen: Opdrachtbeperkingen implementeren voor productietaken
• Minimale machtigingen: alleen benodigde machtigingen aanvragen
• Regelmatige updates: Afhankelijkheden en Node.js versies actueel houden

Nadat u uw taak lokaal hebt getest en uitgebreide eenheidstests hebt geïmplementeerd, verpakt u deze in een extensie voor Azure DevOps.

Verpakkingshulpprogramma's installeren

Installeer de platformoverschrijdende opdrachtregelinterface (tfx-cli):

npm install -g tfx-cli

Het extensiemanifest maken

Het extensiemanifest (vss-extension.json) bevat alle informatie over uw extensie, inclusief verwijzingen naar uw taakmappen en afbeeldingen.

1. Een installatiekopieënmap maken met een extension-icon.png bestand

2. Maken vss-extension.json in de hoofdmap van uw extensie (niet in de taakmap):

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

Eigenschappen van sleutelmanifest

Uw extensie verpakken

Uw extensie inpakken in een .vsix-bestand:

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

Versiebeheer

• Extensieversie: De versie vss-extension.json voor elke update verhogen
• Taakversie: De versie task.json voor elke taakupdate verhogen
• Automatisch verhogen: gebruiken --rev-version om de patchversie automatisch te verhogen

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

Versiebeheerstrategie

Volg de semantische versiebeheerprincipes voor uw taakupdates:

• Primaire versie: Belangrijke wijzigingen in invoer/uitvoer
• Secundaire versie: nieuwe functies, compatibel met eerdere versies
• Patchversie: alleen opgeloste fouten

Updateproces:

1. Updateversie task.json
2. Updateversie vss-extension.json
3. Grondig testen in een testorganisatie
4. Publiceren en bewaken op problemen

Publiceren naar Visual Studio Marketplace

1. Uw uitgever maken

1. Meld u aan bij de Visual Studio Marketplace-publicatieportal
2. Maak een nieuwe uitgever als hierom wordt gevraagd:
   • Uitgever-id: wordt gebruikt in het extensiemanifest (bijvoorbeeld mycompany-myteam)
   • Weergavenaam: Openbare naam die wordt weergegeven in de marketplace (bijvoorbeeld My Team)
3. De Marketplace Publisher-overeenkomst controleren en accepteren

2. Upload uw extensie

Methode voor webinterface:

1. Nieuwe extensie uploaden selecteren
2. Kies het verpakte .vsix bestand
3. Uploaden selecteren

Opdrachtregelmethode:

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

3. Uw extensie delen

1. Klik met de rechtermuisknop op uw extensie in de marketplace
2. Selecteer Delen
3. Voer de naam van uw organisatie in
4. Meer organisaties toevoegen indien nodig

4. Installeren in uw organisatie

Nadat u de extensie hebt gedeeld, installeert u de extensie voor uw Azure DevOps-organisatie:

1. Ga naar Organisatie-instellingenuitbreidingen>
2. Bladeren naar uw extensie
3. Selecteer Gratis downloaden en installeren

3. Uw extensie verpakken en publiceren

Uw extensie controleren

Controleer na de installatie of uw taak correct werkt:

1. Een pijplijn maken of bewerken.
2. Voeg uw aangepaste taak toe:
   • Taak toevoegen selecteren in de pijplijneditor
   • Zoeken naar uw aangepaste taak op naam
   • Deze toevoegen aan uw pijplijn
3. Taakparameters configureren:
   • Vereiste invoer instellen
   • Optionele instellingen configureren
4. De pijplijn uitvoeren om de functionaliteit te testen
5. Uitvoering bewaken:
   • Taaklogboeken controleren op de juiste uitvoering
   • Verwachte uitvoer controleren
   • Zorg ervoor dat er geen fouten of waarschuwingen zijn

4. Publicatie van extensies automatiseren met CI/CD

Als u uw aangepaste taak effectief wilt onderhouden, maakt u geautomatiseerde build- en release-pijplijnen die het testen, verpakken en publiceren verwerken.

Vereisten voor automatisering

• Azure DevOps-extensietaken: de extensie gratis installeren
• Variabelegroep: Maak een pijplijnbibliotheekvariabelegroep met deze variabelen:
  • publisherId: Uw marketplace-uitgever-id
  • extensionId: Extensie-id van vss-extension.json
  • extensionName: Extensienaam uit vss-extension.json
  • artifactName: Naam voor het VSIX-artefact
• Serviceverbinding: Een Marketplace-serviceverbinding maken met machtigingen voor pijplijntoegang

Ci/CD-pijplijn voltooien

Maak een YAML-pijplijn met uitgebreide fasen voor testen, verpakken en publiceren:

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 configureren voor testen

Testscripts toevoegen aan uw 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"
  }
}

Uitsplitsing van pijplijnfase

Fase 1: Testen en valideren

• Doel: Codekwaliteit en -functionaliteit garanderen
• Acties: Afhankelijkheden installeren, TypeScript compileren, eenheidstests uitvoeren, resultaten publiceren
• Validatie: alle tests moeten worden doorgegeven om door te gaan

Fase 2: Pakketextensie

• Doel: Implementeerbaar VSIX-pakket maken
• Acties: Query uitvoeren op de huidige versie, incrementele versie, pakketextensie, artefacten publiceren
• Versiebeheer: hiermee worden versieverhogingen automatisch verwerkt

Fase 3: Publiceren naar marketplace

• Doel: Implementeren in Visual Studio Marketplace
• Voorwaarden: alleen uitgevoerd op de hoofdbranch na geslaagde verpakking
• Omgeving: maakt gebruik van implementatieomgeving voor goedkeuringspoorten

Beste werkwijzen voor CI/CD

• Vertakkingsbeveiliging: alleen publiceren vanuit hoofd-/release-vertakkingen
• Omgevingspoorten: implementatieomgevingen gebruiken voor productiereleases
• Versiebeheer: Incrementen van versies automatiseren om conflicten te voorkomen
• Testdekking: uitgebreide testdekking garanderen voordat de verpakking wordt verpakt
• Beveiliging: Serviceverbindingen gebruiken in plaats van vastgelegde referenties
• Bewaking: Waarschuwingen instellen voor mislukte implementaties

Voor klassieke build-pijplijnen volgt u deze stappen om uitbreidingspakketten en -publicatie in te stellen:

1. Voeg de Bash taak toe om het TypeScript te compileren in JavaScript.

2. Om de bestaande versie op te vragen, voegt u de taak Query Extension Version toe met behulp van de volgende invoer:

   • Verbinding maken met: Visual Studio Marketplace
   • Visual Studio Marketplace (Serviceverbinding): Serviceverbinding
   • Uitgever-id: id van uw Visual Studio Marketplace-uitgever
   • Extensie-id: id van uw extensie in het vss-extension.json bestand
   • Versie-update: Patch
   • Uitvoervariabele: Task.Extension.Version

3. Als u de extensies wilt verpakken op basis van manifest-Json, voegt u de pakketextensietaak toe met behulp van de volgende invoer:

   • Hoofdmap voor manifesten: wijst naar de hoofdmap die het manifestbestand bevat. Bijvoorbeeld, $(System.DefaultWorkingDirectory) is de hoofdmap
   • Manifestbestand: vss-extension.json
   • Uitgever-id: id van uw Visual Studio Marketplace-uitgever
   • Extensie-id: id van uw extensie in het vss-extension.json bestand
   • Extensienaam: naam van uw extensie in het vss-extension.json bestand
   • Extensieversie: $(Task.Extension.Version)
   • Takenversie overschrijven: aangevinkt (waar)
   • Overridetype: Alleen patch vervangen (1.0.r)
   • Zichtbaarheid van extensies: als de extensie nog in ontwikkeling is, stelt u de waarde in op privé. Als u de extensie wilt vrijgeven aan het publiek, stelt u de waarde in op openbaar.

4. Als u naar gepubliceerde bestanden wilt kopiëren, voegt u de taak Bestanden kopiëren toe met behulp van de volgende invoer:

   • Inhoud: Alle bestanden die moeten worden gekopieerd voor publicatie als artefact
   • Doelmap: de map waarnaar de bestanden worden gekopieerd
     • Bijvoorbeeld: $(Build.ArtifactStagingDirectory)

5. Voeg bouwartefacten publiceren toe om de artefacten te publiceren voor gebruik in andere taken of in pijplijnen. Gebruik de volgende invoer:

   • Pad om te publiceren: het pad naar de map met de bestanden die worden gepubliceerd
     • Bijvoorbeeld: $(Build.ArtifactStagingDirectory)
   • Artefactnaam: de naam die aan het artefact is gegeven
   • Publicatielocatie voor artefacten: Kies Azure Pipelines om het artefact in toekomstige taken te gebruiken

Fase 3: Build-artefacten downloaden en de extensie publiceren

1. Als u de tfx-cli wilt installeren op uw buildagent, voegt u Node CLI gebruiken voor Azure DevOps (tfx-cli) toe.

2. Om de bouwartefacten op een nieuwe taak te downloaden, voegt u de taak Download bouwartefacten toe met de volgende invoer:

   • Download artifacts die zijn gemaakt door: Als u het artifact in een nieuwe job uit dezelfde pijplijn downloadt, selecteert u Huidige build. Als u aan het downloaden bent via een nieuwe pijplijn, selecteert u Specifieke build
   • Downloadtype: Kies Specifiek artefact om alle bestanden te downloaden die zijn gepubliceerd.
   • Artefactnaam: de naam van het gepubliceerde artefact
   • Doelmap: de map waarin de bestanden gedownload moeten worden

3. Gebruik de volgende invoer om de Publiceer Extensie taak op te halen:

   • Verbinding maken met: Visual Studio Marketplace
   • Visual Studio Marketplace-verbinding: ServiceConnection
   • Invoerbestandstype: VSIX-bestand
   • VSIX-bestand: /Publisher.*.vsix
   • Uitgever-id: id van uw Visual Studio Marketplace-uitgever
   • Extensie-id: id van uw extensie in het vss-extension.json bestand
   • Extensienaam: naam van uw extensie in het vss-extension.json bestand
   • Zichtbaarheid van extensies: privé of openbaar

Optioneel: Uw extensie installeren en testen

Nadat u uw extensie hebt gepubliceerd, moet deze worden geïnstalleerd in Azure DevOps-organisaties.

Extensie installeren voor organisatie

Installeer uw gedeelde extensie in een paar stappen:

1. Ga naar Organisatie-instellingen en selecteer Extensies.

2. Zoek uw extensie in de sectie Extensies gedeeld met mij :

   • Selecteer de extensiekoppeling
   • Selecteer Gratis downloaden of Installeren selecteren

3. Controleer of de extensie wordt weergegeven in de lijst met geïnstalleerde extensies:

   • Controleer of deze beschikbaar is in uw pijplijntaakbibliotheek

Eind-tot-eind testen

Voer na de installatie uitgebreide tests uit:

1. Een testpijplijn maken:

   • Uw aangepaste taak toevoegen aan een nieuwe pijplijn
   • Alle invoerparameters configureren
   • Testen met verschillende invoercombinaties

2. Functionaliteit valideren:

   • De pijplijn uitvoeren en de uitvoering controleren
   • Taakuitvoer en logboeken controleren
   • Foutafhandeling met ongeldige invoer controleren

3. Testprestaties:

   • Testen met grote invoerbestanden (indien van toepassing)
   • Resourcegebruik bewaken
   • Time-outgedrag valideren

Veelgestelde vragen

V: Hoe wordt het annuleren van taken afgehandeld?

A: De pijplijnagent verzendt SIGINT en SIGTERM signalen naar taakprocessen. Hoewel de taakbibliotheek geen expliciete annuleringsafhandeling biedt, kan uw taak signaalhandlers implementeren. Zie Annulering van agenttaken voor meer informatie.

V: Hoe kan ik een taak uit mijn organisatie verwijderen?

A: Automatisch verwijderen wordt niet ondersteund omdat bestaande pijplijnen hierdoor worden verbroken. In plaats van:

1. De taak verwijderen: De taak markeren als afgeschaft
2. Versiebeheer: De taakversie op stoten
3. Communicatie: gebruikers informeren over de tijdlijn voor afschaffing

V: Hoe kan ik mijn taak upgraden naar de meest recente Node.js versie?

A: Voer een upgrade uit naar de nieuwste knooppuntversie voor betere prestaties en beveiliging. Zie Taken upgraden naar Node 20 voor hulp bij migratie.

Ondersteuning voor meerdere knooppuntversies door meerdere uitvoeringssecties op te tellen in task.json:

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

Agents met Node 20 gebruiken de voorkeursversie, terwijl oudere agents terugvallen op Node 10.

Uw taken up te graden:

• Test uw taken op de verschillende Node runner-versies om ervoor te zorgen dat uw code werkt zoals verwacht.

• In de uitvoeringssectie van uw taak, werk bij van Node of Node10 naar Node16 of Node20.

• Als u oudere serverversies wilt ondersteunen, moet u het Node/Node10 doel verlaten. Oudere Versies van Azure DevOps Server bevatten mogelijk niet de nieuwste versie van Node runner.

• U kunt ervoor kiezen om het toegangspunt dat is gedefinieerd in het doel te delen of doelen te laten optimaliseren voor de knooppuntversie die wordt gebruikt.

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

Verwante inhoud

• Verwijzing naar het extensiemanifest
• Aangepaste build-pijplijntaken integreren met extensies
• Voorbeelden van build-/releasetaken