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:

• Configurare l'ambiente di compilazione con agenti ospitati da Microsoft o self-hosted.
• Ripristinare le dipendenze, compilare il progetto e testare con l'attività .NET Core (DotNetCoreCLI@2) o uno script.
• Testare il codice e usare l'attività pubblica code coverage per pubblicare i risultati del code coverage.
• Creare un pacchetto e recapitare l'output di compilazione a:
  • la pipeline.
  • un feed NuGet.
  • un .zip file per distribuire un'app Web in Azure.

Nota

Per informazioni su progetti .NET Framework, vedere Creare app ASP.NET con .NET Framework.

Prerequisiti

• Un account GitHub in cui è possibile creare un repository. Crearne una gratuitamente.
• Organizzazione e progetto di Azure DevOps. Crearne una gratuitamente.
• Possibilità di eseguire pipeline su agenti ospitati da Microsoft. È possibile acquistare un processo in parallelo oppure richiedere un livello gratuito.

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

Accedere ad Azure Pipelines. Dopo l'accesso, il browser passa a https://dev.azure.com/my-organization-name e visualizza il dashboard di Azure DevOps.

1. In un browser passare a dev.azure.com e accedere.
2. Selezionare l'organizzazione.
3. Creare un nuovo progetto selezionando Nuovo progetto o Crea progetto se si crea il primo progetto nell'organizzazione.
4. Immettere il nome del progetto.
5. Selezionare visibilità per il progetto.
6. Seleziona Crea.

1. In un browser passare al server Azure DevOps.
2. Selezionare la raccolta.
3. Creare un nuovo progetto selezionando Nuovo progetto o Crea progetto se si crea il primo progetto nella raccolta.
4. Immettere il nome del progetto.
5. Selezionare visibilità per il progetto.
6. Seleziona Crea.

Configurare l'ambiente di compilazione

Le compilazioni vengono eseguite su agenti ospitati da Microsoft. È possibile compilare i progetti .NET Core usando .NET Core SDK e il runtime in Windows, Linux e macOS.

In alternativa, è possibile usare un agente self-hosted. Con un agente self-hosted è possibile usare gli SDK privati o di anteprima non ufficialmente supportati da Azure DevOps Services ed eseguire compilazioni incrementali.

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.

YAML

Creare una nuova pipeline e selezionare l'origine

1. Accedere all'organizzazione di Azure DevOps e passare al progetto.

2. Passare a Pipeline e quindi selezionare Nuova pipeline o Crea pipeline se si crea la prima pipeline.

3. Eseguire i passaggi della procedura guidata selezionando prima di tutto GitHub come posizione del codice sorgente.

4. Si potrebbe essere reindirizzati a GitHub per l'accesso. In questo caso, immettere le credenziali di GitHub.

5. Quando si vede l’elenco dei repository, selezionarne uno.

6. È possibile che si venga reindirizzati a GitHub per installare l'app Azure Pipelines. In tal caso, selezionare Approva e installa.

Configura la pipeline

1. Quando viene visualizzata la scheda Configura , selezionare Mostra altro e selezionare il modello di pipeline ASP.NET Core nell'elenco.

2. Esaminare la nuova pipeline per verificare le operazioni del file YAML.

È possibile personalizzare il file YAML per i requisiti. Ad esempio, è possibile specificare il pool di agenti o aggiungere un'attività per installare .NET SDK diverso.

Salvare ed eseguire la pipeline

1. Quando si è pronti, selezionare Salva ed esegui.

   

2. Facoltativamente, è possibile modificare il messaggio di commit.

3. Eseguire il commit del nuovo file azure-pipelines.yml nel repository selezionando Salva ed esegui.

4. Per controllare la pipeline in azione, selezionare il processo nella sezione Processi .

Classico

Usare questi passaggi per creare la pipeline usando l'editor classico.

Creare una pipeline

1. Passare al progetto e selezionare Pipeline.

2. Selezionare Crea pipeline o Nuova pipeline se non si crea la prima pipeline per questo progetto.

3. Selezionare Usa l'editor classico.

Selezionare l'origine

1. Selezionare l'origine. Per questo esempio, selezionare GitHub.
2. Immettere le credenziali di GitHub per creare una connessione al servizio GitHub da usare nella pipeline.
3. Selezionare il repository e selezionare Continua.

Configura la pipeline

1. In Selezionare un modello trovare e selezionare ASP.NET Core.

   Viene visualizzata la pagina della pipeline in cui è possibile configurare la pipeline. Qui è possibile aggiungere attività, specificare i pool di agenti e gli agenti e configurare altre opzioni di compilazione.

2. Nella scheda Attività selezionare il pool di agenti (in genere predefinito)

3. Selezionare la specifica dell'agente. Per questo esempio, selezionare windows-latest.

   È possibile aggiungere altre attività al processo di Agent selezionando + nel processo dell'agente e selezionando un'altra attività dal catalogo. Ad esempio, è possibile aggiungere l'attività Usa .NET Core come prima attività per installare la versione necessaria di .NET SDK.

Salvare ed eseguire la pipeline

1. Selezionare Salva e accodamento dall'elenco a discesa Salva e coda nella parte superiore della pagina.
2. In Esegui pipeline immettere un commento e selezionare Salva ed esegui.

È possibile visualizzare la pipeline in azione selezionando il processo nella sezione Processi nella scheda Riepilogo .

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

Ambiente di compilazione

È possibile usare Azure Pipelines per compilare i progetti .NET Core in Windows, Linux o macOS senza la necessità di configurare l'infrastruttura.

Ad esempio, Ubuntu è impostato qui nel file YAML della pipeline.

pool:
  vmImage: 'ubuntu-latest' 

Per un elenco completo delle immagini e altri esempi di configurazione, vedere Agenti ospitati da Microsoft.

Gli agenti ospitati da Microsoft in Azure Pipelines includono diverse versioni preinstallate degli SDK .NET Core supportati. Gli agenti ospitati da Microsoft non includono alcune delle versioni precedenti di .NET Core SDK. In genere non includono versioni non definitive. Se sono necessarie queste versioni dell'SDK negli agenti ospitati da Microsoft, installarle usando l'attività UseDotNet@2 .

Ad esempio, per installare 5.0.x SDK, aggiungere il frammento di codice seguente:

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

Gli agenti Windows includono già un runtime .NET Core. Per installare un SDK più recente, impostare su performMultiLevelLookup true nel frammento di codice seguente:

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

Suggerimento

Per risparmiare sui costi di esecuzione del programma di installazione dello strumento, è possibile configurare un agente Linux, macOS o Windows self-hosted. È anche possibile usare agenti self-hosted per risparmiare tempo aggiuntivo se si dispone di un repository di grandi dimensioni o si eseguono compilazioni incrementali. Un agente self-hosted consente anche di usare l'anteprima o gli SDK privati che non sono ufficialmente supportati da Azure DevOps o sono disponibili solo negli ambienti aziendali o locali.

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.

Quando si usano agenti ospitati da Microsoft, si ottiene un nuovo computer ogni volta che si esegue una compilazione, che ripristina i pacchetti con ogni esecuzione. Il ripristino può richiedere una quantità significativa di tempo. Per attenuare il problema, è possibile usare Azure Artifacts o un agente self-hosted con il vantaggio di usare la cache dei pacchetti.

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.

YAML

È possibile aggiungere il comando di ripristino alla pipeline usando l'editor della pipeline YAML inserendo direttamente il frammento di codice seguente nel azure-pipelines.yml file o usando l'assistente attività per aggiungere l'attività .NET Core .

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

Sostituire il segnaposto> con il <nome della connessione del servizio.

Per usare l'assistente attività:

Per aggiungere un'attività di compilazione usando l'assistente attività, seguire questa procedura:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.

2. Selezionare .NET Core dal catalogo attività.

3. Selezionare il comando di ripristino dall'elenco a discesa Comando .

4. Nel campo Percorso progetto immettere il percorso dei .csproj file.

5. Selezionare Aggiungi.

6. Selezionare Salva per eseguire il commit della modifica.

Classico

Usare questi passaggi per aggiungere un'attività di ripristino usando l'editor classico:

1. Selezionare Attività nella pipeline e selezionare il processo che esegue le attività di compilazione.

2. Selezionare questa opzione + per aggiungere una nuova attività a tale processo.

3. Nel catalogo attività trovare e selezionare Attività .NET Core e selezionare Aggiungi.

4. Selezionare l'attività per aprire l'editor attività.

5. Selezionare Ripristina nell'elenco Comandi e specificare le altre opzioni necessarie per questa attività.

6. Nell'elenco di attività trascinare l'attività per posizionarla prima dell'attività di compilazione.

7. Nell'elenco a discesa Salva e coda selezionare un'opzione per salvare la modifica.

Nota

Assicurarsi che il feed personalizzato sia specificato nel NuGet.config file e che le credenziali siano specificate nella connessione al servizio NuGet.

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

YAML

È possibile aggiungere un'attività di compilazione usando l'editor della pipeline YAML modificando direttamente il file o aggiungendo l'attività .NET Core usando l'assistente attività.

Per aggiungere un'attività di compilazione usando l'assistente attività, seguire questa procedura:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.

2. Selezionare .NET Core dal catalogo attività.

3. Selezionare il comando di compilazione dall'elenco a discesa Comando .

4. Nel campo Percorso progetto immettere il percorso dei .csproj file.

5. Selezionare Aggiungi.

6. Selezionare Salva per eseguire il commit della modifica.

Classico

Per aggiungere un'attività di compilazione usando l'editor classico, seguire questa procedura:

1. Selezionare Attività nella pipeline.

2. Selezionare il processo che esegue le attività di compilazione.

3. Selezionare questa opzione + per aggiungere una nuova attività a tale processo.

4. Nel catalogo attività trovare e aggiungere l'attività .NET Core .

5. Selezionare l'attività e selezionare Compila dall'elenco a discesa Comando .

6. Nel campo Percorso progetto immettere il percorso dei .csproj file.

7. Trascinare l'attività per posizionarla nella sequenza di attività corretta nella pipeline.

8. Selezionare l'elenco a discesa Salva e coda e selezionare un'opzione per salvare le modifiche.

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

YAML

È possibile aggiungere un'attività di compilazione usando l'editor della pipeline YAML modificando direttamente il file o aggiungendo l'attività Riga di comando.

Per aggiungere l'attività Riga di comando, seguire questa procedura:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.

2. Selezionare la riga di comando dal catalogo attività.

3. Facoltativamente, aggiungere un nome visualizzato.

4. Immettere il dotnet build comando con i parametri. Ad esempio: dotnet build --configuration $(buildConfiguration).

5. Immettere il percorso del .csproj file come directory di lavoro.

6. Selezionare Aggiungi.

7. Selezionare Salva per eseguire il commit della modifica.

Classico

Per aggiungere un'attività di compilazione usando l'editor classico, seguire questa procedura:

1. Selezionare Attività nella pipeline.

2. Selezionare il processo che esegue le attività di compilazione.

3. Selezionare questa opzione + per aggiungere una nuova attività a tale processo.

4. Nel catalogo attività trovare e aggiungere l'attività Riga di comando.

5. Facoltativamente, aggiungere un nome visualizzato.

6. Immettere il dotnet build comando con i parametri. Ad esempio: dotnet build --configuration $(buildConfiguration).

7. Immettere il percorso del .csproj file come directory di lavoro.

8. Trascinare l'attività per posizionarla nella sequenza di attività corretta nella pipeline.

9. Selezionare l'elenco a discesa Salva e coda e selezionare un'opzione per salvare le modifiche.

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

YAML

Per aggiungere un comando dell'interfaccia della riga di comando di .NET Core usando l'editor della pipeline YAML, seguire questa procedura:

1. Passare alla posizione nel file YAML in cui si desidera inserire l'attività.

2. Selezionare .NET Core dal catalogo attività.

3. Selezionare il comando da eseguire.

4. Configurare tutte le opzioni necessarie.

5. Selezionare Aggiungi.

6. Selezionare Salva per eseguire il commit della modifica.

Classico

Per aggiungere un'attività .NET Core usando l'editor classico, seguire questa procedura:

1. Selezionare Attività nella pipeline.

2. Selezionare il processo che esegue le attività di compilazione.

3. Selezionare questa opzione + per aggiungere una nuova attività a tale processo.

4. Nel catalogo attività trovare e aggiungere l'attività .NET Core .

5. Selezionare l'attività e selezionare il comando da eseguire.

6. Configurare tutte le opzioni necessarie.

7. Trascinare l'attività per posizionarla nella sequenza di attività corretta nella pipeline.

8. Nell'elenco a discesa Salva e coda selezionare un'opzione per salvare le modifiche.

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

Per pubblicare l'output della compilazione .NET nella pipeline, eseguire le attività seguenti:

• Eseguire dotnet publish --output $(Build.ArtifactStagingDirectory) nell'interfaccia della riga di comando di .NET o aggiungere l'attività DotNetCoreCLI@2 con il comando publish.
• Pubblicare l'artefatto usando l'attività Pubblica artefatto pipeline.

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

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'

Nota

L'attività DotNetCoreCLI@2 ha un publishWebProjects input impostato su true per impostazione predefinita. Questa attività pubblica tutti i progetti Web nel repository per impostazione predefinita. Altre informazioni e informazioni sono disponibili nell'attività open source in GitHub.

Per copiare altri file nella directory di compilazione prima della pubblicazione, usare l'attività Copia file (CopyFile@2).

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

Nota

L'attività NuGetAuthenticate@1 non supporta l'autenticazione della chiave API NuGet. Se si usa una chiave API NuGet, usare l'attività NuGetCommand@2 con l'input impostato su con l'argomento command --api-key.push Ad esempio: dotnet nuget push --api-key $(NuGetApiKey).

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:

• Le versioni non definitive di .NET Core SDK non sono installate negli agenti ospitati da Microsoft. Dopo il rilascio di una nuova versione di .NET Core SDK, l'implementazione in tutti i data center di Azure Pipelines può richiedere alcune settimane. Non è necessario attendere il completamento di questa implementazione. È possibile usare l'attività Usa .NET Core per installare la versione di .NET Core SDK desiderata negli agenti ospitati da Microsoft.

• 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