Lägga till ett tillägg för anpassade pipelines-aktiviteter

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

Den här guiden vägleder dig genom att skapa, testa och publicera anpassade bygg- eller versionsaktiviteter som Azure DevOps-tillägg. Med anpassade pipelineuppgifter kan du utöka Azure DevOps med specialiserade funktioner som är skräddarsydda för teamets arbetsflöden, från enkla verktyg till komplexa integreringar med externa system.

Lär dig hur du utför följande uppgifter:

• Konfigurera utvecklingsmiljön och projektstrukturen
• Skapa aktivitetslogik med Hjälp av TypeScript och Azure Pipelines-aktivitetsbiblioteket
• Implementera omfattande enhetstestning med falska ramverk
• Paketera tillägget för distribution
• Publicera på Visual Studio Marketplace
• Konfigurera automatiserade CI/CD-pipelines för tilläggsunderhåll

Mer information om Azure Pipelines finns i Vad är Azure Pipelines?

Förutsättningar

Kontrollera att du har följande krav på plats innan du börjar:

Projektstruktur

Skapa en home katalog för projektet. När du har slutfört den här självstudien bör tillägget ha följande struktur:

|--- 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. Skapa en anpassad uppgift

Det här avsnittet vägleder dig genom att skapa den grundläggande strukturen och implementeringen av din anpassade uppgift. Alla filer i det här steget ska skapas i buildandreleasetask mappen i projektets home katalog.

Konfigurera aktivitetsramverk

Skapa den grundläggande projektstrukturen och installera nödvändiga beroenden:

1. Om du vill initiera Node.js projektet öppnar du PowerShell, går till mappen buildandreleasetask och kör:

   npm init --yes
   

   Filen package.json skapas med standardinställningar. Flaggan --yes accepterar alla standardalternativ automatiskt.

   Tips

   Azure Pipelines-agenter förväntar sig att uppgiftsmappar ska innehålla nodmoduler. Kopiera node_modules till mappen buildandreleasetask . Om du vill hantera VSIX-filstorleken (gränsen på 50 MB) bör du överväga att köra npm install --production eller npm prune --production före paketeringen.

2. Installera Aktivitetsbiblioteket för Azure Pipelines:

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

3. Installera TypeScript-typdefinitioner:

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

4. Konfigurera undantag för versionskontroll

   echo node_modules > .gitignore
   

   Byggprocessen ska köras npm install för att återskapa node_modules varje gång.

5. Installera beroenden för testning:

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

6. Installera TypeScript-kompilatorn:

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

   Anmärkning

   Installera TypeScript globalt för att säkerställa tsc att kommandot är tillgängligt. Utan det används TypeScript 2.3.4 som standard.

7. Konfigurera TypeScript-kompilering:

   tsc --init --target es2022
   

   Filen tsconfig.json skapas med målinställningarna för ES2022.

Implementera aktivitetslogik

När scaffolding har slutförts skapar du de viktigaste uppgiftsfilerna som definierar funktioner och metadata:

1. Skapa uppgiftsdefinitionsfilen: Skapa task.json i buildandreleasetask mappen. Den här filen beskriver din uppgift för Azure Pipelines-systemet, definierar indata, körningsinställningar och UI-presentation.

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

   Anmärkning

   Ersätt {{placeholders}} med aktivitetens faktiska information. Måste taskguid vara unik. Generera en med Hjälp av PowerShell: (New-Guid).Guid

2. Om du vill implementera aktivitetslogik skapar index.ts du med aktivitetens huvudfunktioner:

   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. Kompilera TypeScript till JavaScript:

   tsc
   

   Filen index.js skapas från TypeScript-källan.

Förstå task.json komponenter

Filen task.json är kärnan i din uppgiftsdefinition. Här är de viktigaste egenskaperna:

Säkerhetsbegränsningar

För produktionsaktiviteter lägger du till säkerhetsbegränsningar för att begränsa kommandoanvändning och variabel åtkomst:

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

Begränsat läge tillåter endast följande kommandon:

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

Variabel allowlist styr vilka variabler som kan anges via setvariable eller prependpath. Stöder grundläggande regexmönster.

Indatatyper och exempel

Vanliga indatatyper för aktivitetsparametrar:

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

Testa din uppgift lokalt

Testa uppgiften innan du paketerar den så att den fungerar korrekt:

1. Test med saknade indata (bör misslyckas):

   node index.js
   

   Förväntat resultat:

   ##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. Testa med giltiga indata (bör lyckas):

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

   Förväntat resultat:

   ##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. Testfelhantering:

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

   Den här åtgärden ska utlösa felhanteringssökvägen i koden.

   Tips

   Information om aktivitetslöpare och Node.js versioner finns i Uppdateringsvägledning för Node runner.

Mer information finns i aktivitetsreferensen Build/release.

2. Implementera omfattande enhetstestning

Genom att testa uppgiften noggrant säkerställer du tillförlitligheten och hjälper till att fånga upp problem innan du distribuerar till produktionspipelines.

Installera testberoenden

Installera de testverktyg som krävs:

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

Skapa test

1. Skapa en tests mapp i aktivitetskatalogen som innehåller en _suite.ts fil:

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

   Tips

   Testmappen ska finnas i aktivitetsmappen (till exempel buildandreleasetask). Om det uppstår ett fel med synkroniseringsbegäran installerar du det i aktivitetsmappen: npm i --save-dev sync-request.

2. Skapa success.ts i testkatalogen för att simulera lyckad aktivitetskörning:

    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. Lägg till framgångstestet i _suite.ts filen:

    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. Skapa failure.ts i testkatalogen för att testa felhantering:

   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. Lägg till feltestet i _suite.ts filen:

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

Kör dina tester

Kör testpaketet:

# Compile TypeScript
tsc

# Run tests
mocha tests/_suite.js

Båda testerna bör klara sig. För utförliga utdata (liknar utdata från byggkonsolen) anger du variabeln för spårningsmiljön:

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

Metodtips för testtäckning

• Testa alla indatakombinationer: Giltiga indata, ogiltiga indata, saknade obligatoriska indata
• Testfelscenarier: Nätverksfel, filsystemfel, behörighetsproblem
• Simulera externa beroenden: Förlita dig inte på externa tjänster i enhetstester
• Verifiera utdata: Kontrollera konsolens utdata, aktivitetsresultat och genererade artefakter
• Prestandatestning: Överväg att lägga till tester för uppgifter som bearbetar stora filer

Metodtips för säkerhet

• Indataverifiering: Verifiera och sanera alltid indata
• Hantering av hemligheter: Används setSecret för känsliga data
• Kommandobegränsningar: Implementera kommandobegränsningar för produktionsaktiviteter
• Minimal behörighet: Begär endast nödvändiga behörigheter
• Regelbundna uppdateringar: Håll beroenden och Node.js versioner aktuella

När du har testat din uppgift lokalt och implementerat omfattande enhetstester kan du paketera den i ett tillägg för Azure DevOps.

Installera paketeringsverktyg

Installera kommandoradsgränssnittet för plattformsoberoende (tfx-cli):

npm install -g tfx-cli

Skapa tilläggsmanifestet

Tilläggsmanifestet (vss-extension.json) innehåller all information om tillägget, inklusive referenser till dina aktivitetsmappar och bilder.

1. Skapa en avbildningsmapp med en extension-icon.png fil

2. Skapa vss-extension.json i tilläggets rotkatalog (inte i uppgiftsmappen):

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

Egenskaper för nyckelmanifest

Paketera ditt tillägg

Paketera tillägget i en .vsix-fil:

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

Versionshantering

• Tilläggsversion: Öka versionen i vss-extension.json för varje uppdatering
• Uppgiftsversion: Öka versionen för task.json varje aktivitetsuppdatering
• Automatisk inkrementering: Använd --rev-version för att automatiskt öka korrigeringsversionen

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

Strategi för versionshantering

Följ semantiska versionsprinciper för dina uppgiftsuppdateringar:

• Huvudversion: Icke-bakåtkompatibla ändringar av in- och utdata
• Delversion: Nya funktioner, bakåtkompatibla
• Korrigeringsversion: Endast felkorrigeringar

Uppdateringsprocess:

1. Uppdatera task.json version
2. Uppdatera vss-extension.json version
3. Testa noggrant i en testorganisation
4. Publicera och övervaka för problem

Publicera på Visual Studio Marketplace

1. Skapa utgivaren

1. Logga in på Visual Studio Marketplace-publiceringsportalen
2. Skapa en ny utgivare om du uppmanas att göra det:
   • Utgivaridentifierare: Används i tilläggsmanifestet (till exempel mycompany-myteam)
   • Visningsnamn: Offentligt namn som visas på marknadsplatsen (till exempel My Team)
3. Granska och acceptera Marketplace Publisher-avtalet

2. Ladda upp tillägget

Webbgränssnittsmetod:

1. Välj Ladda upp nytt tillägg
2. Välj din paketerade .vsix fil
3. Välj Ladda upp

Kommandoradsmetod:

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

3. Dela ditt tillägg

1. Högerklicka på ditt tillägg på Marketplace
2. Välj Dela
3. Ange organisationens namn
4. Lägg till fler organisationer efter behov

4. Installera i din organisation

Efter delning installerar du tillägget till din Azure DevOps-organisation:

1. Gå tillTillägg för >
2. Bläddra efter tillägget
3. Välj Hämta kostnadsfritt och installera

3. Paketera och publicera tillägget

Verifiera tillägget

Kontrollera att uppgiften fungerar korrekt efter installationen:

1. Skapa eller redigera en pipeline.
2. Lägg till din anpassade uppgift:
   • Välj Lägg till uppgift i pipelineredigeraren
   • Sök efter din anpassade uppgift efter namn
   • Lägg till den i din pipeline
3. Konfigurera aktivitetsparametrar:
   • Ange nödvändiga indata
   • Konfigurera valfria inställningar
4. Kör pipelinen för att testa funktioner
5. Övervaka körning:
   • Kontrollera aktivitetsloggarna för korrekt körning
   • Verifiera förväntade utdata
   • Se till att inga fel eller varningar visas

4. Automatisera tilläggspublicering med CI/CD

För att effektivt underhålla din anpassade uppgift skapar du automatiserade bygg- och versionspipelines som hanterar testning, paketering och publicering.

Förutsättningar för automatisering

• Uppgifter för Azure DevOps-tillägg: Installera tillägget kostnadsfritt
• Variabelgrupp: Skapa en pipelinebiblioteksvariabelgrupp med följande variabler:
  • publisherId: Ditt utgivar-ID för Marketplace
  • extensionId: Tilläggs-ID från vss-extension.json
  • extensionName: Tilläggsnamn från vss-extension.json
  • artifactName: Namn på VSIX-artefakten
• Tjänstanslutning: Skapa en Marketplace-tjänstanslutning med åtkomstbehörigheter för pipeline

Fullständig CI/CD-pipeline

Skapa en YAML-pipeline med omfattande steg för testning, paketering och publicering:

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'

Konfigurera package.json för testning

Lägg till testskript i :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"
  }
}

Uppdelning av pipelinesteg

Steg 1: Testa och verifiera

• Syfte: Säkerställa kodkvalitet och -funktioner
• Åtgärder: Installera beroenden, kompilera TypeScript, köra enhetstester, publicera resultat
• Validering: Alla tester måste godkännas för att fortsätta

Steg 2: Pakettillägg

• Syfte: Skapa distribuerat VSIX-paket
• Åtgärder: Fråga aktuell version, inkrementsversion, pakettillägg, publicera artefakter
• Versionshantering: Hanterar versionssteg automatiskt

Steg 3: Publicera på Marketplace

• Syfte: Distribuera till Visual Studio Marketplace
• Villkor: Körs endast på huvudgrenen efter lyckad paketering
• Miljö: Använder distributionsmiljön för godkännandegrindar

Bästa praxis för CI/CD

• Grenskydd: Publicera endast från huvud-/versionsgrenar
• Miljögrindar: Använda distributionsmiljöer för produktionsversioner
• Versionshantering: Automatisera versionssteg för att undvika konflikter
• Testtäckning: Säkerställa omfattande testtäckning före paketering
• Säkerhet: Använd tjänstanslutningar i stället för hårdkodade autentiseringsuppgifter
• Övervakning: Konfigurera aviseringar för misslyckade distributioner

För klassiska byggpipelines följer du de här stegen för att konfigurera paketering och publicering av tillägg:

1. Lägg till uppgiften Bash för att kompilera TypeScript till JavaScript.

2. Om du vill fråga efter den befintliga versionen, lägg till uppgiften Utökning av frågeversion och använd följande inmatningsdata:

   • Anslut till: Visual Studio Marketplace
   • Visual Studio Marketplace (tjänstanslutning): Tjänstanslutning
   • Utgivar-ID: ID för din Visual Studio Marketplace-utgivare
   • Tilläggs-ID: ID för tillägget i vss-extension.json filen
   • Uppdatera version: Patch
   • Utdatavariabel: Task.Extension.Version

3. Om du vill paketera tilläggen baserat på manifest-Json lägger du till aktiviteten Pakettillägg med hjälp av följande indata:

   • Rotmanifestmapp: Pekar på rotkatalogen som innehåller manifestfilen. Är till exempel $(System.DefaultWorkingDirectory) rotkatalogen
   • Manifestfil: vss-extension.json
   • Utgivar-ID: ID för din Visual Studio Marketplace-utgivare
   • Tilläggs-ID: ID för tillägget i vss-extension.json filen
   • Tilläggsnamn: Namnet på tillägget i vss-extension.json filen
   • Tilläggsversion: $(Task.Extension.Version)
   • Åsidosätt uppgiftens version: markerad som (sant)
   • Åsidosättningstyp: Ersätt endast ändringsfil (1.0.r)
   • Synlighet för tillägg: Om tillägget fortfarande är under utveckling anger du värdet till privat. Om du vill frigöra tillägget till allmänheten anger du värdet som offentligt.

4. Om du vill kopiera till publicerade filer lägger du till aktiviteten Kopiera filer med hjälp av följande indata:

   • Innehåll: Alla filer som ska kopieras för att publicera dem som en artefakt
   • Målmapp: Mappen som filerna kopieras till
     • Till exempel: $(Build.ArtifactStagingDirectory)

5. Lägg till Publicera kompileringsartefakter för att publicera artefakterna för användning i andra jobb eller pipelines. Använd följande indata:

   • Sökväg att publicera: Sökvägen till mappen som innehåller de filer som publiceras
     • Till exempel: $(Build.ArtifactStagingDirectory)
   • Artefaktnamn: Namnet på artefakten
   • Publiceringsplats för artefakter: Välj Azure Pipelines för att använda artefakten i framtida jobb

Steg 3: Ladda ned byggartefakter och publicera tillägget

1. Om du vill installera tfx-cli på byggagenten lägger du till Använd Node CLI för Azure DevOps (tfx-cli).

2. Om du vill ladda ned artefakterna till ett nytt jobb lägger du till uppgiften Ladda ned byggartefakter med hjälp av följande indata:

   • Ladda ned artefakter som skapats av: Om du laddar ned artefakten på ett nytt jobb från samma pipeline väljer du Aktuell version. Om du laddar ned på en ny pipeline väljer du Specifik version
   • Nedladdningstyp: Välj Specifik artefakt för att ladda ned alla filer som har publicerats.
   • Artefaktnamn: Den publicerade artefaktens namn
   • Målkatalog: Mappen där filerna ska laddas ned

3. Använd följande indata för att hämta uppgiften Publicera tillägg :

   • Anslut till: Visual Studio Marketplace
   • Anslutning till Visual Studio Marketplace: ServiceConnection
   • Indatafiltyp: VSIX-fil
   • VSIX-fil: /Publisher.*.vsix
   • Utgivar-ID: ID för din Visual Studio Marketplace-utgivare
   • Tilläggs-ID: ID för tillägget i vss-extension.json filen
   • Tilläggsnamn: Namnet på tillägget i vss-extension.json filen
   • Tilläggssynlighet: Antingen privat eller offentlig

Valfritt: Installera och testa tillägget

När du har publicerat tillägget måste det installeras i Azure DevOps-organisationer.

Installera tillägg till organisationen

Installera det delade tillägget i några få steg:

1. Gå till Organisationsinställningar och välj Tillägg.

2. Leta upp tillägget i avsnittet Tillägg som delas med mig :

   • Välj tilläggslänken
   • Välj Hämta kostnadsfritt eller Installera

3. Kontrollera att tillägget visas i listan Installerade tillägg:

   • Bekräfta att den är tillgänglig i ditt pipelineaktivitetsbibliotek

Sluttill-slut-testning

Utför omfattande testning efter installationen:

1. Skapa en testpipeline:

   • Lägga till din anpassade uppgift i en ny pipeline
   • Konfigurera alla indataparametrar
   • Testa med olika indatakombinationer

2. Verifiera funktioner:

   • Kör pipelinen och övervaka körningen
   • Kontrollera aktivitetsutdata och loggar
   • Verifiera felhantering med ogiltiga indata

3. Testprestanda:

   • Testa med stora indatafiler (om tillämpligt)
   • Övervaka resursanvändning
   • Verifiera timeout-beteende

Vanliga frågor

F: Hur hanteras annullering av aktiviteter?

S: Pipelineagenten skickar SIGINT och SIGTERM signalerar till aktivitetsprocesser. Även om aktivitetsbiblioteket inte tillhandahåller explicit avbokningshantering kan din uppgift implementera signalhanterare. Mer information finns i Avbryta agentjobb.

F: Hur tar jag bort en uppgift från min organisation?

S: Automatisk borttagning stöds inte eftersom det skulle bryta befintliga pipelines. Istället:

1. Inaktuell uppgift: Markera aktiviteten som inaktuell
2. Versionshantering: Öka aktivitetsversionen
3. Kommunikation: Meddela användare om tidslinjen för utfasning

F: Hur uppgraderar jag min uppgift till den senaste Node.js versionen?

S: Uppgradera till den senaste Node-versionen för bättre prestanda och säkerhet. Information om migrering finns i Uppgradera uppgifter till Nod 20.

Stöd för flera nodversioner genom att inkludera flera körningsavsnitt i task.json:

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

Agenter med Nod 20 använder önskad version, medan äldre agenter återgår till Nod 10.

Så här uppgraderar du dina uppgifter:

• För att se till att koden fungerar som förväntat testar du dina uppgifter på de olika Node Runner-versionerna.

• I körningsavsnittet för aktiviteten uppdaterar du från Node eller Node10 till Node16 eller Node20.

• Om du vill ha stöd för äldre serverversioner bör du lämna Node/Node10 målet. Äldre Versioner av Azure DevOps Server kanske inte har den senaste Node Runner-versionen inkluderad.

• Du kan välja att dela den startpunkt som definierats i målet eller ha mål optimerade för den nodversion som används.

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

Relaterat innehåll

• Tilläggsmanifest referens
• Integrera anpassade byggpipeline-uppgifter med förlängningar
• Exempel på bygg-/versionsuppgift