Pianificare le attività di compilazione

  • 7 minuti

Mara dispone ora di una copia del codice di Space Game. La compilerà usando Microsoft Azure Pipelines anziché il server di compilazione Ubuntu 22.04 esistente. Prima di poter eseguire questa operazione, deve considerare gli script di compilazione esistenti. Seguiamola mentre esegue il mapping degli script esistenti alle attività di Azure Pipelines. Pensare a come la stessa operazione può essere eseguita con il proprio processo di compilazione.

Di seguito sono riportate alcune note che Mara ha raccolto quando ha parlato con Andy, il responsabile dello sviluppo:

  • Il computer di compilazione esegue Ubuntu 22.04.
  • Il computer di compilazione include strumenti di compilazione come:
    • npm, la gestione pacchetti per Node.js
    • NuGet, la gestione pacchetti per .NET
    • .NET SDK
  • Il progetto usa Sass (Syntactically Awesome Style Sheets) per semplificare la creazione di file CSS (Cascading Style Sheets).
  • Il progetto usa il toolkit gulp per comprimere i file JavaScript e CSS.

Un asset minimizzato esclude i dati non necessari come spazi vuoti e abbrevia i nomi delle variabili per accelerarne il download.

Di seguito sono indicati i passaggi che si verificano durante il processo di compilazione:

  1. Per installare i pacchetti di Node.js definiti in package.json, eseguire npm install.
  2. Per convertire i file Sass (.scss) in file CSS (.css), eseguire node-sass.
  3. Per minimizzare i file JavaScript e CSS, eseguire gulp.
  4. Per consentire al team del controllo di qualità di identificare il numero e la data di compilazione, stampare le informazioni di compilazione nella directory wwwroot.
  5. Per installare le dipendenze del progetto, eseguire dotnet restore.
  6. Per compilare l'app nelle configurazioni Debug e Release, eseguire dotnet build.
  7. Per comprimere l'applicazione come file con estensione zip e copiare i risultati in una condivisione di rete selezionabile dal team del controllo di qualità, eseguire dotnet publish.

Mara compila uno script della shell che esegue le attività identificate. Lo esegue sul suo portatile.

Nota

Non è necessario eseguire questo script o comprenderne completamente le funzionalità. In questa sezione viene illustrato il funzionamento di uno script di compilazione tipico.

#!/bin/bash

# Install Node.js modules as defined in package.json.
npm install --quiet

# Compile Sass (.scss) files to standard CSS (.css).
node-sass Tailspin.SpaceGame.Web/wwwroot

# Minify JavaScript and CSS files.
gulp

# Print the date to wwwroot/buildinfo.txt.
echo `date` > Tailspin.SpaceGame.Web/wwwroot/buildinfo.txt

# Install the latest .NET packages the app depends on.
dotnet restore

# Build the app under the Debug configuration.
dotnet build --configuration Debug

# Publish the build to the /tmp directory.
dotnet publish --no-build --configuration Debug --output /tmp/Debug

# Build the app under the Release configuration.
dotnet build --configuration Release

# Publish the build to the /tmp directory.
dotnet publish --no-build --configuration Release --output /tmp/Release

La directory /tmp riproduce la condivisione di rete del team.

Dopo aver eseguito lo script, Mara si rende conto che è incompleto. Ad esempio, non affronta gli errori. Non segnala a nessuno se si verificano errori di compilazione. Anche in caso di errori, l'esecuzione continua. Inoltre, non installa gli strumenti necessari per ogni passaggio.

Che cosa sono le attività di Azure Pipelines?

In Azure Pipelines un'attività è uno script o una procedura compressa che è stata astratta con un set di input.

Un'attività di Azure Pipelines astrae i dettagli sottostanti. Questa astrazione semplifica l'esecuzione di funzioni di compilazione comuni, ad esempio il download di strumenti di compilazione o pacchetti da cui dipende l'app, oppure la compilazione del progetto, eseguendo Visual Studio o Xcode.

Di seguito è riportato un esempio che usa l'attività DotNetCoreCLI@2 per compilare un progetto C# destinato a .NET:

task: DotNetCoreCLI@2
  displayName: 'Build the project'
  inputs:
    command: 'build'
    arguments: '--no-restore --configuration Release'
    projects: '**/*.csproj'

Questa attività può essere convertita dalla pipeline in questo comando:

dotnet build MyProject.csproj --no-restore --configuration Release

Frammentiamo ulteriormente questa attività:

  • L'attività DotNetCoreCLI@2 esegue il mapping al comando dotnet.
  • displayName definisce il nome dell'attività visualizzato nell'interfaccia utente. Questa operazione sarà presto visibile in azione.
  • inputs definisce gli argomenti che vengono trasmessi al comando.
    • command specifica di eseguire il sottocomando dotnet build.
    • arguments specifica gli argomenti aggiuntivi da trasmettere al comando.
    • projects specifica i progetti da compilare. Questo esempio usa il modello con caratteri jolly **/*.csproj. Sia ** che *.csproj sono esempi di informazioni denominate criteri GLOB. La parte ** specifica di eseguire la ricerca nella directory corrente e in tutte le directory figlio. La parte *.csproj specifica un file con estensione .csproj. I caratteri jolly consentono di agire su più file senza specificarli. Per agire solo su un file specifico, specificare tale file anziché usare caratteri jolly.

"@" nel nome dell'attività, ad esempio DotNetCoreCLI@2, fa riferimento alla versione dell'attività. Man mano che nuove versioni di attività diventano disponibili, è possibile eseguire gradualmente la migrazione alla versione più recente per sfruttare le nuove funzionalità.

Come vengono usate le attività in una pipeline?

Successivamente, Mara eseguirà il mapping dei comandi script esistenti alle attività di Azure Pipelines. Una pipeline viene creata utilizzando un file YAML, un formato compatto che semplifica la strutturazione del tipo di dati presenti nei file di configurazione. I file YAML della pipeline vengono in genere gestiti direttamente con il codice sorgente dell'app.

Mara in passato ha usato YAML per definire configurazioni e attività di compilazione simili. Inoltre, le piace l'idea di mantenere la definizione di compilazione come codice, proprio come qualsiasi altra parte del suo progetto.

Per definire la compilazione, Mara sceglie di usare Visual Studio Code per creare un file YAML. Al suo interno, immette tutte le attività di Azure Pipelines che userà per sostituire i comandi di script esistenti.

Eseguire il mapping di comandi script alle attività di Azure Pipelines

A questo punto, vedremo come Mara esegue il mapping dei comandi dal suo script alle attività di Azure Pipelines.

Per eseguire il mapping di ogni comando, Mara fa riferimento alla documentazione di riferimento. La documentazione categorizza le attività in base alla funzione, ad esempio la compilazione o la distribuzione.

Ad esempio, l'attività dell'interfaccia della riga di comando di .NET Core DotNetCoreCLI@2 consente di eseguire i comandi dotnet.

Questa tabella associa i comandi script alle nuove attività di Azure Pipelines:

Comando Script Attività di Azure Pipelines
npm install Npm@1
node-sass CmdLine@2 (o script)
gulp gulp@1
echo `date` CmdLine@2 (o script)
dotnet restore DotNetCoreCLI@2
dotnet build DotNetCoreCLI@2
dotnet publish DotNetCoreCLI@2

Non esiste un tipo di attività integrato che esegue node-sass o stampa la data in un file. Per questi, Mara usa l'attività CmdLine@2, che le consente di eseguire qualsiasi comando che desidera. Più comunemente, viene visualizzata l'attività script, una scelta rapida da tastiera per CmdLine@2. Per altre informazioni sugli altri collegamenti di attività comuni, vedere Informazioni di riferimento sullo schema YAML per Azure Pipelines - passaggi.

Presto procederemo a creare un file YAML personalizzato che usa queste attività.

Verificare le conoscenze

1.

Un'attività di compilazione: