Build, test, and deploy .NET Core apps (.NET Core-apps bouwen, testen en implementeren)

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

Gebruik een Azure Pipeline om uw .NET Core-projecten automatisch te bouwen, testen en implementeren. In dit artikel leest u hoe u de volgende taken uitvoert:

Prerequisites

Uw eerste pijplijn maken

Bent u nieuw voor Azure Pipelines? Zo ja, dan raden we u aan eerst de volgende sectie uit te voeren.

Een .NET-project maken

Als u geen .NET-project hebt om mee te werken, maakt u een nieuw project op uw lokale systeem. Start by installing the .NET 8.0 SDK .

1. Een terminalvenster openen.

2. Maak een projectmap en navigeer ernaartoe.

3. Maak een nieuwe .NET 8-web-app.

   dotnet new webapp -f net8.0
   

4. Voer vanuit dezelfde terminalsessie de toepassing lokaal uit met behulp van de dotnet run opdracht uit uw projectmap.

   dotnet run
   

5. Once the application starts, press Ctrl-C to shut it down.

Een Git-opslagplaats maken en deze verbinden met GitHub

1. Maak vanuit de projectmap een lokale Git-opslagplaats en voer de toepassingscode door naar de hoofdbranch.

2. Verbind uw lokale Git-opslagplaats met een GitHub-opslagplaats.

Een DevOps-project maken

Create a new Azure DevOps project to host your pipeline.

Stel uw ontwikkelomgeving in

steps:
- task: UseDotNet@2
  inputs:
    version: '8.x'

Uw pijplijn maken

U kunt de YAML-pijplijneditor of de klassieke editor gebruiken om uw pijplijn te maken. Als u de klassieke editor wilt gebruiken, selecteert u De klassieke editor gebruiken.

U hebt nu een werkende pijplijn die u kunt aanpassen. Lees verder voor meer informatie over enkele veelgebruikte manieren om uw pijplijn aan te passen.

Omgeving bouwen

pool:
  name: myPrivateAgents
  demands:
  - agent.os -equals Darwin
  - anotherCapability -equals somethingElse

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

pool:
  vmImage: 'ubuntu-latest' 

steps:
- task: UseDotNet@2
  inputs:
    version: '5.x'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

Afhankelijkheden herstellen

NuGet is een populaire manier om afhankelijk te zijn van code die u niet bouwt. U kunt NuGet-pakketten en projectspecifieke hulpprogramma's downloaden die zijn opgegeven in het projectbestand door de dotnet restore opdracht uit te voeren via de .NET Core-taak of rechtstreeks in een script in uw pijplijn. Zie .NET Core-taak (DotNetCoreCLI@2) voor meer informatie.

U kunt NuGet-pakketten downloaden uit Azure Artifacts, NuGet.org of een andere externe of interne NuGet-opslagplaats. De .NET Core-taak is vooral handig om pakketten te herstellen van geverifieerde NuGet-feeds. Als uw feed zich in hetzelfde project bevindt als uw pijplijn, hoeft u zich niet te verifiëren.

Deze pijplijn maakt gebruik van een Azure Artifact-feed voor dotnet restore in de DotNetCoreCLI@2 taak.

trigger:
- main

pool:
  vmImage: 'windows-latest'

steps:
- task: UseDotNet@2
  displayName: 'Install .NET Core SDK'
  inputs:
    version: 8.x
    performMultiLevelLookup: true
    includePreviewVersions: true # Required for preview versions

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'restore'
    feedsToUse: 'select'
    vstsFeed: 'my-vsts-feed' # A series of numbers and letters

- task: DotNetCoreCLI@2
  inputs:
    command: 'build'
    arguments: '--configuration $(buildConfiguration)'
  displayName: 'dotnet build $(buildConfiguration)'

De dotnet restore opdracht maakt gebruik van de NuGet.exe verpakte met de .NET Core SDK en kan alleen pakketten herstellen die zijn opgegeven in de .NET Core-projectbestanden .csproj .

Als u ook een Microsoft .NET Framework-project in uw oplossing hebt of gebruikt package.json om uw afhankelijkheden op te geven, gebruikt u de NuGet-taak om deze afhankelijkheden te herstellen.

- task: NuGetCommand@2
  inputs:
    command: 'restore'
    restoreSolution: '**/*.sln'
    feedsToUse: 'select'

In .NET Core SDK versie 2.0 en hoger worden pakketten automatisch hersteld bij het uitvoeren van opdrachten zoals dotnet build. U moet echter nog steeds de .NET Core-taak gebruiken om pakketten te herstellen als u een geverifieerde feed gebruikt.

Uw builds kunnen mislukken vanwege verbindingsproblemen wanneer u pakketten herstelt vanuit NuGet.org. U kunt Azure Artifacts met upstream-bronnen gebruiken om de pakketten in de cache op te cachen. De referenties van de pijplijn worden automatisch gebruikt wanneer deze verbinding maakt met Azure Artifacts. These credentials are typically derived from the Project Collection Build Service account. Zie Connect to Azure Artifact feeds (Verbinding maken met Azure Artifact-feeds) voor meer informatie over het gebruik van Azure Artifacts om uw NuGet-pakketten in de cache op te slaan.

Als u een NuGet-opslagplaats wilt opgeven, plaatst u de URL in een NuGet.config bestand in uw opslagplaats. Als uw feed is geverifieerd, beheert u de referenties door een NuGet-serviceverbinding te maken op het tabblad Services onder Projectinstellingen.

Zie Publiceren naar NuGet-feeds voor meer informatie over NuGet-serviceverbindingen.

Pakketten herstellen vanuit een externe feed

Ga als volgt te werk om pakketten te herstellen vanuit een externe feed.

# do this before your build tasks
steps:
- task: DotNetCoreCLI@2
  displayName: Restore
  inputs:
    command: restore
    projects: '**/*.csproj'
    feedsToUse: config
    nugetConfigPath: NuGet.config    # Relative to root of the repository
    externalFeedCredentials: <Name of the NuGet service connection>

Uw project bouwen

Bouw uw .NET Core-projecten door de opdracht uit te dotnet build voeren. U kunt de opdracht als opdrachtregelscript aan uw pijplijn toevoegen of met behulp van de .NET Core-taak.

Build with the .NET Core task

YAML-voorbeeld om te bouwen met behulp van de DotNetCoreCLI@2 taak:

steps:
- task: DotNetCoreCLI@2
  displayName: Build
  inputs:
    command: build
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)' # Update this to match your needs

Build .NET Core with a command line script

YAML example to build using dotnet build as a script:

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'

.NET SDK-opdrachten toevoegen aan uw pijplijn

U kunt .NET SDK-opdrachten toevoegen aan uw project als script of met behulp van de .NET Core-taak. Met de taak .NET Core (DotNetCoreCLI@2) kunt u eenvoudig dotnet CLI-opdrachten toevoegen aan uw pijplijn. U kunt .NET Core-taken toevoegen door uw YAML-bestand te bewerken of de klassieke editor te gebruiken.

Add a .NET CLI command with the .NET Core task

Add a .NET Core CLI command in a script

U kunt .NET Core CLI-opdrachten toevoegen als een script in uw azure-pipelines.yml bestand.

Voorbeeld:

steps:
# ...
- script: dotnet test <test-project> 

Een hulpprogramma installeren

Als u een algemeen .NET Core-hulpprogramma zoals dotnetsay wilt installeren in uw build die wordt uitgevoerd in Windows, voert u de volgende stappen uit:

1. Voeg de .NET Core-taak toe en stel de volgende eigenschappen in:
   • Command: custom.
     • Pad naar projecten: laat leeg.
   • Aangepaste opdracht: hulpprogramma.
   • Argumenten: install -g dotnetsay.
2. Als u het hulpprogramma wilt uitvoeren, voegt u een opdrachtregel toe en stelt u de volgende eigenschappen in:
   • Script:dotnetsay.

Uw tests uitvoeren

Wanneer u projecten in uw opslagplaats hebt getest, kunt u de .NET Core-taak gebruiken om eenheidstests uit te voeren met behulp van testframeworks zoals MSTest, xUnit en NUnit. Het testproject moet verwijzen naar Microsoft.NET.Test.SDK versie 15.8.0 of hoger. Testresultaten worden automatisch gepubliceerd naar de service. Deze resultaten zijn beschikbaar in de samenvatting van de build en kunnen worden gebruikt voor het oplossen van problemen met mislukte tests en testtime-analyse.

U kunt een testtaak aan uw pijplijn toevoegen met behulp van de DotNetCoreCLI@2 taak of het volgende fragment toevoegen aan uw azure-pipelines.yml bestand:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

Wanneer u de .NET Core-taakeditor gebruikt, stelt u De opdracht in om te testen en moet het pad naar projecten verwijzen naar de testprojecten in uw oplossing.

U kunt de dotnet test opdracht ook uitvoeren met een specifieke logger en vervolgens de taak Testresultaten publiceren gebruiken:

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx
- task: PublishTestResults@2
  condition: succeededOrFailed()
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Codedekking verzamelen

Wanneer u bouwt op het Windows-platform, kunnen metrische gegevens over de codedekking worden verzameld met behulp van de ingebouwde gegevensverzamelaar voor dekkingsgegevens. Het testproject moet verwijzen naar Microsoft.NET.Test.SDK versie 15.8.0 of hoger.

Wanneer u de .NET Core-taak gebruikt om tests uit te voeren, worden dekkingsgegevens automatisch naar de server gepubliceerd. Het .coverage bestand kan worden gedownload uit de samenvatting van de build voor weergave in Visual Studio.

Voeg het volgende fragment toe aan uw azure-pipelines.yml bestand:

steps:
# ...
# do this after other tasks such as building
- task: DotNetCoreCLI@2
  inputs:
    command: test
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration $(buildConfiguration) --collect "Code Coverage"'

De .NET Core-taak toevoegen via de taakeditor:

1. Voeg de .NET Core-taak toe aan uw buildtaak en stel de volgende eigenschappen in:

   1. Opdracht: testen.
   2. Pad naar projecten: Moet verwijzen naar de testprojecten in uw oplossing.
   3. Argumenten: --configuration $(BuildConfiguration) --collect "Code Coverage".

2. Zorg ervoor dat de optie Testresultaten publiceren geselecteerd blijft.

If you choose to run the dotnet test command, specify the test results logger and coverage options. Gebruik vervolgens de taak Testresultaten publiceren:

steps:
# ...
# do this after your tests have run
- script: dotnet test <test-project> --logger trx --collect "Code Coverage"
- task: PublishTestResults@2
  inputs:
    testRunner: VSTest
    testResultsFiles: '**/*.trx'

Metrische gegevens voor codedekking verzamelen met Coverlet

Als u bouwt op Linux of macOS, kunt u Coverlet of een vergelijkbaar hulpprogramma gebruiken om metrische gegevens voor codedekking te verzamelen.

You can publish code coverage results to the server with the Publish Code Coverage Results task (PublishCodeCoverageResults@2) task. The coverage tool must be configured to generate results in Cobertura or JaCoCo coverage format.

Voer de volgende taken uit om tests uit te voeren en codedekking te publiceren met Coverlet:

• Voeg een verwijzing toe naar het coverlet.collector NuGet-pakket.

• Voeg het volgende fragment toe aan uw azure-pipelines.yml bestand:

  - task: UseDotNet@2
    inputs:
      version: '8.x'
      includePreviewVersions: true # Required for preview versions
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet build'
    inputs:
      command: 'build'
      configuration: $(buildConfiguration)
  
  - task: DotNetCoreCLI@2
    displayName: 'dotnet test'
    inputs:
      command: 'test'
      arguments: '--configuration $(buildConfiguration) --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura'
      publishTestResults: true
      projects: 'MyTestLibrary' # update with your test project directory
  
  - task: PublishCodeCoverageResults@2
    displayName: 'Publish code coverage report'
    inputs:
      codeCoverageTool: 'Cobertura'
      summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  

Uw code verpakken en leveren

You can publish your build artifacts by:

• Publiceren op Azure Pipelines.
• Pakketten publiceren naar Azure Artifacts.
• Een NuGet-pakket maken en publiceren naar uw NuGet-feed.
• Een .zip archief maken om uw web-app te implementeren.

Artefacten publiceren naar Azure Pipelines

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishPipelineArtifact@1
  inputs:
    targetPath: '$(Build.ArtifactStagingDirectory)' 
    artifactName: 'myWebsite'

steps:

- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

# this code takes all the files in $(Build.ArtifactStagingDirectory) and uploads them as an artifact of your build.
- task: PublishBuildArtifacts@1
  inputs:
    PathtoPublish: '$(Build.ArtifactStagingDirectory)'
    ArtifactName: 'drop'

Publiceren naar een NuGet-feed

Als u een NuGet-pakket wilt maken en naar uw NuGet-feed wilt publiceren, voegt u het volgende codefragment toe:

steps:
# ...
# do this near the end of your pipeline in most cases
- script: dotnet pack /p:PackageVersion=$(version)  # define version variable elsewhere in your pipeline
- task: NuGetAuthenticate@1
  inputs:
    nuGetServiceConnections: '<Name of the NuGet service connection>'
- task: NuGetCommand@2
  inputs:
    command: push
    nuGetFeedType: external
    publishFeedCredentials: '<Name of the NuGet service connection>'
    versioningScheme: byEnvVar
    versionEnvVar: version

Zie Publiceren naar NuGet-feeds voor meer informatie over versiebeheer en het publiceren van NuGet-pakketten.

Een NuGet-pakket publiceren naar Azure Artifacts

U kunt uw NuGet-pakketten publiceren naar uw Azure Artifacts-feed met behulp van de NuGetCommand@2 om naar uw Azure Artifact-feed te pushen. Zie Bijvoorbeeld NuGet-pakketten publiceren met Azure Pipelines.

Een web-app implementeren

Als u een .zip bestandsarchief wilt maken dat klaar is om te publiceren naar een web-app, voegt u het volgende fragment toe:

steps:
# ...
# do this after you've built your app, near the end of your pipeline in most cases
# for example, you do this before you deploy to an Azure web app on Windows
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    publishWebProjects: True
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
    zipAfterPublish: True

Als u dit archief wilt publiceren naar een web-app, raadpleegt u de implementatie van Azure Web Apps.

Build an image and push to container registry

U kunt ook een image bouwen voor uw app en naar een containerregister uploaden.

Symbolen publiceren

U kunt de PublishSymbols@2 taak gebruiken om symbolen te publiceren naar een Azure Artifacts-symboolserver of een bestandsshare.

Als u bijvoorbeeld symbolen wilt publiceren naar een bestandsshare, voegt u het volgende codefragment toe aan uw azure-pipelines.yml bestand:

- task: PublishSymbols@2
  inputs:
    SymbolsFolder: '$(Build.SourcesDirectory)'
    SearchPattern: '**/bin/**/*.pdb'
    IndexSources: true
    PublishSymbols: true
    SymbolServerType: 'FileShare' 
    SymbolsPath: '\\server\shareName'

When using the classic editor, select Index sources publish symbols from the task catalog to add to your pipeline.

Zie Symbolen publiceren voor meer informatie.

Problemen oplossen

Als u uw project op uw ontwikkelcomputer kunt bouwen, maar u problemen ondervindt met het bouwen ervan in Azure Pipelines, bekijkt u de volgende mogelijke oorzaken en corrigerende acties:

• Controleer de .NET Core SDK-versies en -runtime op uw ontwikkelcomputer en zorg ervoor dat deze overeenkomen met de agent. U kunt een opdrachtregelscript dotnet --version in uw pijplijn opnemen om de versie van de .NET Core SDK af te drukken. Gebruik het .NET Core Tool Installer om dezelfde versie op de agent te implementeren of werk uw projecten en ontwikkelcomputer bij naar de nieuwere versie van de .NET Core SDK.

• Mogelijk gebruikt u een aantal logica in de Visual Studio IDE die niet in uw pijplijn is gecodeerd. Azure Pipelines voert elk van de opdrachten die u in de taken opgeeft, achtereenvolgens uit in een nieuw proces. Bekijk de logboeken van de pijplijnbuild om de exacte opdrachten te zien die zijn uitgevoerd als onderdeel van de build. To locate the problem, repeat the same commands in the same order on your development machine.

• Als u een gemengde oplossing hebt met enkele .NET Core-projecten en sommige .NET Framework-projecten, moet u ook de NuGet-taak gebruiken om pakketten te herstellen die zijn opgegeven in packages.config bestanden. Voeg de MSBuild - of Visual Studio Build-taak toe om de .NET Framework-projecten te bouwen.

• Uw builds kunnen af en toe mislukken tijdens het herstellen van pakketten: NuGet.org problemen ondervindt of er netwerkproblemen zijn tussen het Azure-datacenter en NuGet.org. U kunt verkennen of het gebruik van Azure Artifacts met NuGet.org als een upstream-bron de betrouwbaarheid van uw builds verbetert, omdat deze niet in onze controle staat.

• Occasionally, a when new version of the .NET Core SDK or Visual Studio is rolled out, your build might break. Bijvoorbeeld, een nieuwere versie of functie van het NuGet-hulpprogramma die met de SDK wordt geleverd, kan uw build breken. Als u dit probleem wilt isoleren, gebruikt u de taak .NET Core Tool Installer om de versie op te geven van de .NET Core SDK die in uw build wordt gebruikt.

Veelgestelde vragen

V: Waar vind ik meer informatie over Azure Artifacts?

A: Azure Artifacts

V: Waar vind ik meer informatie over .NET Core-opdrachten?

A: .NET Core CLI tools

V: Waar vind ik meer informatie over het uitvoeren van tests in mijn oplossing?

A: Eenheidstests in .NET Core-projecten

V: Waar vind ik meer informatie over taken?

A: Taken voor build en release