Compilare, testare e distribuire app .NET Core

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

Usare una pipeline di Azure per compilare, testare e distribuire automaticamente i progetti .NET Core. Questo articolo illustra come eseguire le attività seguenti:

Prerequisiti

Creare la prima pipeline

Non si ha più di Azure Pipelines? In tal caso, è consigliabile provare prima la sezione seguente.

Creare un progetto .NET

Se non si ha un progetto .NET da usare, crearne uno nuovo nel sistema locale. Per iniziare, installare la versione più recente di .NET 8.0 SDK .

1. Aprire una finestra del terminale.

2. Creare una directory di progetto e passare alla directory.

3. Creare una nuova app Web .NET 8.

   dotnet new webapp -f net8.0
   

4. Dalla stessa sessione del terminale eseguire l'applicazione in locale usando il dotnet run comando dalla directory del progetto.

   dotnet run
   

5. Dopo aver avviato l'applicazione, premere CTRL+C per arrestarla.

Creare un repository Git e connetterlo a GitHub

1. Dalla directory del progetto creare un repository Git locale ed eseguire il commit del codice dell'applicazione nel ramo principale.

2. Connettere il repository Git locale a un repository GitHub.

Creare un progetto DevOps

Configurare l'ambiente di compilazione

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

Creare la pipeline

È possibile usare l'editor della pipeline YAML o l'editor classico per creare la pipeline. Per usare l'editor classico, selezionare Usa l'editor classico.

È ora disponibile una pipeline di lavoro pronta per la personalizzazione. Altre informazioni su alcuni dei modi comuni per personalizzare la pipeline.

Ambiente di compilazione

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

Ripristinare le dipendenze

NuGet è un modo comune per dipendere dal codice che non si compila. È possibile scaricare pacchetti NuGet e strumenti specifici del progetto specificati nel file di progetto eseguendo il dotnet restore comando tramite l'attività .NET Core o direttamente in uno script nella pipeline. Per altre informazioni, vedere Attività .NET Core (DotNetCoreCLI@2).For more information, see .NET Core task (DotNetCoreCLI@2).

È possibile scaricare pacchetti NuGet da Azure Artifacts, NuGet.org o da un altro repository NuGet esterno o interno. L'attività .NET Core è particolarmente utile per ripristinare i pacchetti dai feed NuGet autenticati. Se il feed si trova nello stesso progetto della pipeline, non è necessario eseguire l'autenticazione.

Questa pipeline usa un feed di Azure Artifact per dotnet restore nell'attività DotNetCoreCLI@2 .

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

Il dotnet restore comando usa il NuGet.exe pacchetto con .NET Core SDK e può ripristinare solo i pacchetti specificati nei file di progetto .csproj .NET Core.

Se nella soluzione è presente anche un progetto Microsoft .NET Framework o si usa package.json per specificare le dipendenze, usare l'attività NuGet per ripristinare tali dipendenze.

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

In .NET Core SDK versione 2.0 e successive i pacchetti vengono ripristinati automaticamente quando si eseguono comandi come dotnet build. Tuttavia, è comunque necessario usare l'attività .NET Core per ripristinare i pacchetti se si usa un feed autenticato.

Le compilazioni possono non riuscire a causa di problemi di connessione quando si ripristinano i pacchetti da NuGet.org. È possibile usare Azure Artifacts con origini upstream per memorizzare nella cache i pacchetti. Le credenziali della pipeline vengono usate automaticamente quando si connette ad Azure Artifacts. Queste credenziali vengono in genere derivate dall'account del servizio di compilazione raccolta progetti. Per altre informazioni sull'uso di Azure Artifacts per memorizzare nella cache i pacchetti NuGet, vedere Connettersi ai feed di Azure Artifact.

Per specificare un repository NuGet, inserire l'URL in un NuGet.config file nel repository. Se il feed è autenticato, gestire le credenziali creando una connessione al servizio NuGet nella scheda Servizi in Impostazioni progetto.

Per altre informazioni sulle connessioni al servizio NuGet, vedere Pubblicare nei feed NuGet.

Ripristinare i pacchetti da un feed esterno

Eseguire le operazioni seguenti per ripristinare i pacchetti da un feed esterno.

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

Compilare il progetto

Compilare i progetti .NET Core eseguendo il dotnet build comando . È possibile aggiungere il comando alla pipeline come script della riga di comando o usando l'attività .NET Core.

Compilazione di .NET Core con l'attività .NET Core

Esempio YAML per la compilazione con l'attività DotNetCoreCLI@2:

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

Compilazione di .NET Core con script della riga di comando

Esempio YAML per la compilazione con dotnet build come script:

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

Aggiungere comandi .NET SDK alla pipeline

È possibile aggiungere comandi .NET SDK al progetto come script o usando l'attività .NET Core. L'attività .NET Core (DotNetCoreCLI@2) consente di aggiungere facilmente comandi dell'interfaccia della riga di comando dotnet alla pipeline. È possibile aggiungere attività .NET Core modificando il file YAML o usando l'editor classico.

Aggiungere un comando dell'interfaccia della riga di comando di .NET usando l'attività .NET Core

Aggiungere un comando dell'interfaccia della riga di comando di .NET Core usando uno script

È possibile aggiungere comandi dell'interfaccia della riga di comando di .NET Core come nel script azure-pipelines.yml file.

Esempio:

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

Installare uno strumento

Per installare uno strumento globale .NET Core come dotnetsay nella compilazione in esecuzione in Windows, seguire questa procedura:

1. Aggiungere l'attività .NET Core e impostare le proprietà seguenti:
   • Comando: personalizzato.
     • Percorso dei progetti: lasciare vuoto.
   • Comando personalizzato: strumento.
   • Argomenti: install -g dotnetsay.
2. Per eseguire lo strumento, aggiungere una riga di comando e impostare le proprietà seguenti:
   • Script: dotnetsay.

Esecuzione dei test

Quando sono presenti progetti di test nel repository, è possibile usare l'attività .NET Core per eseguire unit test usando framework di test come MSTest, xUnit e NUnit. Il progetto di test deve fare riferimento a Microsoft.NET.Test.SDK versione 15.8.0 o successiva. I risultati dei test vengono pubblicati automaticamente nel servizio. Questi risultati sono disponibili nel riepilogo della compilazione e possono essere usati per la risoluzione dei problemi relativi ai test non riusciti e all'analisi dei tempi di test.

È possibile aggiungere un'attività di test alla pipeline usando l'attività DotNetCoreCLI@2 o aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

Quando si usa l'editor di attività .NET Core , impostare Comando per testare e Percorso per i progetti deve fare riferimento ai progetti di test nella soluzione.

In alternativa, è possibile eseguire il dotnet test comando con un logger specifico e quindi usare l'attività Pubblica risultati test:

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'

Raccogliere code coverage

Quando si usa la piattaforma Windows, è possibile raccogliere le metriche di code coverage usando l'agente di raccolta dati di copertura predefinito. Il progetto di test deve fare riferimento a Microsoft.NET.Test.SDK versione 15.8.0 o successiva.

Quando si usa l'attività .NET Core per eseguire test, i dati di copertura vengono pubblicati automaticamente nel server. Il .coverage file può essere scaricato dal riepilogo della compilazione per la visualizzazione in Visual Studio.

Aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

Per aggiungere l'attività .NET Core tramite l'editor attività:

1. Aggiungere l'attività .NET Core al processo di compilazione e impostare le proprietà seguenti:

   1. Comando: test.
   2. Percorso dei progetti: fare riferimento ai progetti di test nella soluzione.
   3. Argomenti: --configuration $(BuildConfiguration) --collect "Code coverage".

2. Assicurarsi che l'opzione Pubblica risultati test rimanga selezionata.

Se si sceglie di eseguire il dotnet test comando, specificare il logger dei risultati del test e le opzioni di copertura. Usare quindi l'attività Pubblica risultati test:

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'

Raccogliere le metriche di code coverage con Coverlet

Se si sta creando in Linux o macOS, è possibile usare Coverlet o uno strumento simile per raccogliere le metriche di code coverage.

È possibile pubblicare i risultati del code coverage nel server con l'attività Pubblica risultati code coverage (PublishCodeCoverageResults@1). Lo strumento di copertura deve essere configurato per generare risultati in formato Cobertura o JaCoCo coverage.

Per eseguire test e pubblicare code coverage con Coverlet, eseguire le attività seguenti:

• Aggiungere un riferimento al pacchetto NuGet coverlet.collector.

• Aggiungere il frammento di codice seguente al azure-pipelines.yml file:

  - 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@1
    displayName: 'Publish code coverage report'
    inputs:
      codeCoverageTool: 'Cobertura'
      summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'
  

Creare un pacchetto e recapitare il codice

È possibile pubblicare gli artefatti di compilazione in base a:

• Pubblicazione in Azure Pipelines.
• Pubblicazione di pacchetti in Azure Artifacts.
• Creazione di un pacchetto NuGet e pubblicazione nel feed NuGet.
• Creazione di un archivio .zip per distribuire l'app Web.

Pubblicare elementi in 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'

Pubblicare in un feed NuGet

Per creare un pacchetto NuGet e pubblicarlo nel feed NuGet, aggiungere il frammento di codice seguente:

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

Per altre informazioni sul controllo delle versioni e sulla pubblicazione di pacchetti NuGet, vedere Pubblicare nei feed NuGet.

Pubblicare un pacchetto NuGet in Azure Artifacts

È possibile pubblicare i pacchetti NuGet nel feed di Azure Artifacts usando il NuGetCommand@2 per eseguire il push nel feed di Azure Artifact. Ad esempio, vedere Pubblicare pacchetti NuGet con Azure Pipelines.

Distribuire un'app Web

Per creare un archivio di file .zip pronto per la pubblicazione in un'app Web, aggiungere il frammento di codice seguente:

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

Per pubblicare questo archivio in un'app Web, vedere Distribuzione di Azure App Web.

Creare un'immagine ed eseguire il push nel registro contenitori

È anche possibile compilare un'immagine per l'app ed eseguirne il push in un registro contenitori.

Pubblicare i simboli

È possibile usare l'attività PublishSymbols@2 per pubblicare simboli in un server di simboli di Azure Artifacts o in una condivisione file.

Ad esempio, per pubblicare simboli in una condivisione file, aggiungere il frammento di codice seguente al azure-pipelines.yml file:

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

Quando si usa l'editor classico, selezionare Origini indice che pubblica i simboli dal catalogo attività da aggiungere alla pipeline.

Per altre informazioni, vedere Pubblicare simboli.

Risoluzione dei problemi

Se è possibile compilare il progetto nel computer di sviluppo, ma si verificano problemi durante la compilazione in Azure Pipelines, esplorare le possibili cause e le azioni correttive seguenti:

• Controllare le versioni e il runtime di .NET Core SDK nel computer di sviluppo e assicurarsi che corrispondano all'agente. È possibile includere uno script dotnet --version della riga di comando nella pipeline per stampare la versione di .NET Core SDK. Usare il programma di installazione dello strumento .NET Core per distribuire la stessa versione nell'agente oppure aggiornare i progetti e il computer di sviluppo alla versione più recente di .NET Core SDK.

• È possibile usare una logica nell'IDE di Visual Studio non codificata nella pipeline. Azure Pipelines esegue ognuno dei comandi specificati nelle attività una dopo l'altra in un nuovo processo. Esaminare i log dalla compilazione delle pipeline per visualizzare i comandi esatti eseguiti come parte della compilazione. Ripetere gli stessi comandi nello stesso ordine nel computer di sviluppo per individuare il problema.

• Se si dispone di una soluzione mista che include alcuni progetti .NET Core e alcuni progetti .NET Framework, è consigliabile usare anche l'attività NuGet per ripristinare i pacchetti specificati nei packages.config file. Aggiungere l'attività MSBuild o Compilazione di Visual Studio per compilare i progetti .NET Framework.

• Le compilazioni potrebbero non riuscire in modo intermittente durante il ripristino dei pacchetti: NuGet.org si verificano problemi di rete tra il data center di Azure e NuGet.org. È possibile esaminare se l'uso di Azure Artifacts con NuGet.org come origine upstream migliora l'affidabilità delle compilazioni, perché non è presente nel controllo.

• In alcuni casi, quando viene implementata una nuova versione di .NET Core SDK o Visual Studio, la compilazione potrebbe interrompersi. Ad esempio, una versione o una funzionalità più recente dello strumento NuGet viene fornita con l'SDK potrebbe interrompere la compilazione. Per isolare questo problema, usare l'attività Programma di installazione strumenti .NET Core per specificare la versione di .NET Core SDK usata nella compilazione.

Domande frequenti

D: Dove è possibile ottenere altre informazioni su Azure Artifacts?

R: Gestione pacchetti in Azure Artifacts

D: Dove è possibile ottenere altre informazioni sui comandi di .NET Core?

R: Strumenti dell'interfaccia della riga di comando di .NET Core

D: Dove è possibile ottenere altre informazioni sull'esecuzione dei test nella soluzione?

R: Unit testing nei progetti .NET Core

D: Dove è possibile ottenere altre informazioni sulle attività?

R: Attività di compilazione e rilascio