Uw buildtaken plannen

  • 7 minuten

Mara heeft nu een kopie van de Space Game-code . Ze gaat het bouwen met behulp van Microsoft Azure Pipelines in plaats van de bestaande Ubuntu 22.04-buildserver. Voordat ze dat kan doen, moet ze nadenken over de bestaande buildscripts. Volg deze stappen terwijl ze de bestaande scripts toe wijst aan Azure Pipelines-taken. Denk na over hoe u hetzelfde kunt doen met uw eigen buildproces.

Hier volgen enkele opmerkingen die Mara verzamelde toen ze met Andy sprak, de dev lead:

  • Op de buildcomputer wordt Ubuntu 22.04 uitgevoerd.
  • De build-machine bevat buildhulpprogramma's zoals:
    • npm, het pakketbeheerprogramma voor Node.js
    • NuGet, pakketbeheerder voor .NET
    • .NET SDK
  • Het project maakt gebruik van Syntactically Awesome Style Sheets (Sass) om het eenvoudiger te maken om trapsgewijze opmaakmodellen (CSS)-bestanden te maken.
  • Het project maakt gebruik van de gulp-toolkit om JavaScript- en CSS-bestanden te minificeren.

Met een minified asset worden overbodige gegevens (zoals witruimte) uitgesloten en worden namen van variabelen ingekort, zodat deze sneller kunnen worden gedownload.

Dit zijn de stappen die plaatsvinden tijdens het buildproces:

  1. Als u de Node.js-pakketten wilt installeren die zijn gedefinieerd in package.json, voert u uit npm install.
  2. Als u Sasss-bestanden (.scss)-bestanden wilt converteren naar CSS-bestanden (.css), voert u de opdracht uit node-sass.
  3. Als u JavaScript- en CSS-bestanden wilt minificeren, voert u het volgende uit gulp.
  4. Als u het QA-team wilt helpen bij het identificeren van het buildnummer en de datum, drukt u buildgegevens af naar de wwwroot map.
  5. Voer uit dotnet restoreom de afhankelijkheden van het project te installeren.
  6. Als u de app wilt bouwen onder configuraties voor foutopsporing en release, voert u de opdracht uit dotnet build.
  7. Als u de toepassing als een .zip-bestand wilt verpakken en de resultaten wilt kopiëren naar een netwerkshare die het QA-team kan ophalen, voert u uit dotnet publish.

Mara bouwt een shellscript waarmee de taken worden uitgevoerd die ze heeft geïdentificeerd. Ze voert het uit op haar laptop.

Notitie

U hoeft dit script niet uit te voeren of volledig te begrijpen wat het doet. Hier ziet u wat een typisch buildscript kan doen.

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

De /tmp map bootst de netwerkshare van het team na.

Nadat ze het script heeft uitgevoerd, realiseert Mara zich dat het onvolledig is. Er worden bijvoorbeeld geen fouten weergegeven. Er wordt niemand op de hoogte gesteld als er buildfouten optreden. Zelfs als er fouten zijn, blijft deze actief. Ook worden de hulpprogramma's die elke stap vereist, niet geïnstalleerd.

Wat zijn Azure Pipelines-taken?

In Azure Pipelines is een taak een verpakt script of een procedure die is geabstraheerd met een set invoer.

Een Azure Pipelines-taak abstraheert de onderliggende details. Deze abstractie maakt het eenvoudiger om algemene buildfuncties uit te voeren, zoals het downloaden van buildhulpprogramma's of pakketten waarop uw app afhankelijk is, of om uw project te bouwen, Visual Studio of Xcode uit te voeren.

Als u een C#-project wilt bouwen dat is gericht op .NET, volgt een voorbeeld waarin de DotNetCoreCLI@2 taak wordt gebruikt:

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

De pijplijn kan deze taak vertalen naar deze opdracht:

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

Laten we deze taak nog eens opsplitsen:

  • De DotNetCoreCLI@2 taak wordt toegewezen aan de dotnet opdracht.
  • displayName definieert de taaknaam die wordt weergegeven in de gebruikersinterface. U ziet dit binnenkort in actie.
  • inputs definieert argumenten die worden doorgegeven aan de opdracht.
    • command geeft aan om de dotnet build subopdracht uit te voeren.
    • arguments geeft aanvullende argumenten op die moeten worden doorgegeven aan de opdracht.
    • projects geeft aan welke projecten moeten worden gebouwd. In dit voorbeeld wordt het jokertekenpatroon **/*.csprojgebruikt. Beide ** en *.csproj zijn voorbeelden van zogenaamde globpatronen. Het ** onderdeel geeft aan om de huidige map en alle onderliggende mappen te doorzoeken. Het *.csproj onderdeel geeft een .csproj-bestand op. Met jokertekens kunt u op meerdere bestanden reageren zonder dat u elke bestanden hoeft op te geven. Als u alleen op een specifiek bestand moet reageren, kunt u dat bestand opgeven in plaats van jokertekens te gebruiken.

Het @-bestand in de taaknaam, bijvoorbeeld, DotNetCoreCLI@2verwijst naar de versie van de taak. Naarmate er nieuwe taakversies beschikbaar komen, kunt u geleidelijk migreren naar de nieuwste versie om te profiteren van nieuwe functies.

Hoe worden taken gebruikt in een pijplijn?

Vervolgens gaat Mara de bestaande scriptopdrachten toewijzen aan Azure Pipelines-taken. Er wordt een pijplijn gemaakt met behulp van een YAML-bestand. Dit is een compacte indeling waarmee u eenvoudig het soort gegevens in configuratiebestanden kunt structuren. YAML-pijplijnbestanden worden doorgaans rechtstreeks onderhouden met de broncode van uw app.

Mara gebruikte YAML eerder om vergelijkbare buildtaken en configuraties te definiëren. Ze houdt ook van het idee om de builddefinitie als code te onderhouden, net als elk ander deel van haar project.

Om haar build te definiëren, kiest Mara ervoor om Visual Studio Code te gebruiken om een YAML-bestand te maken. Hierin voert ze alle Azure Pipelines-taken in die ze gaat gebruiken om de bestaande scriptopdrachten te vervangen.

Scriptopdrachten toewijzen aan Azure Pipelines-taken

Nu volgt u de opdrachten van Mara in kaart van haar script naar Azure Pipelines-taken.

Om elke opdracht toe te wijzen, verwijst Mara naar de referentiedocumentatie. De documentatie categoriseert taken op functie, zoals bouwen of implementeren.

Met de .NET Core CLI-taakDotNetCoreCLI@2 kunt u bijvoorbeeld opdrachten uitvoeren dotnet .

Deze tabel koppelt de scriptopdrachten aan de nieuwe Azure Pipelines-taken:

Scriptopdracht Azure Pipelines-taak
npm install Npm@1
node-sass CmdLine@2 (of script)
gulp gulp@1
echo `date` CmdLine@2 (of script)
dotnet restore DotNetCoreCLI@2
dotnet build DotNetCoreCLI@2
dotnet publish DotNetCoreCLI@2

Er is geen ingebouwd taaktype waarmee de datum wordt uitgevoerd node-sass of afgedrukt naar een bestand. Hiervoor gebruikt Mara de CmdLine@2 taak, waarmee ze een opdracht kan uitvoeren die ze wil. Meestal ziet u de script taak, een snelkoppeling voor CmdLine@2. Zie de naslaginformatie over YAML-schema's voor Azure Pipelines voor meer informatie over de andere veelgebruikte taaksnelkoppelingen.

U maakt binnenkort zelf een YAML-bestand dat gebruikmaakt van deze taken.