Konfigurera program och virtuella datorer

Slutförd

Det är vanligt att skapa appar och annan anpassad kod för din Azure-lösning. Anpassade appar kan innehålla webbplatser, API:er och bakgrundsappar som körs utan mänsklig interaktion. I den här lektionen får du lära dig hur du utformar en pipeline för att skapa och distribuera en app tillsammans med dess infrastruktur.

Skapa program

Många typer av appar måste kompileras eller skapas innan de kan användas. Byggprocessen tar källkoden för appen, utför en sekvens med aktiviteter på den och skapar sedan en uppsättning distribuerade filer.

Byggprocessen kompilerar källkoden till binära filer eller körbara filer, men den innehåller vanligtvis även andra aktiviteter:

• Komprimera de bildfiler som hanteras av webbplatsens användare.
• Linting din kod för att kontrollera att den följer bra kodningsmetoder.
• Köra enhetstester som verifierar beteendet för enskilda delar av din app.

Utöver de här stegen kan du även utföra steg som att signera filerna digitalt för att säkerställa att de inte kan ändras.

Oavsett vilken serie steg som kan vara är utdata från byggprocessen en distribuerbar artefakt. Artefakten sparas vanligtvis i pipelineagentens filsystem. Senare steg i pipelinen måste fungera med artefakten för att distribuera den via dina miljöer och testa den när den utvecklas genom de kvalitetsgrindar som du definierar i pipelinedefinitionen.

Kommentar

Du kanske har hört talas om termerna kontinuerlig integrering och kontinuerlig distribution, eller CI och CD. En byggprocess finns i den kontinuerliga integreringsdelen av din pipeline.

Pipelineartefakter

Artefakterna som genereras i pipelinen lagras inte på Git-lagringsplatsen. De härleds från källkoden men är inte själva kod, så de hör inte hemma i en lagringsplats för källkontroll. De skapas i pipelineagentens filsystem. En ny agent skapas för varje pipelinejobb, så du behöver ett sätt att dela filerna mellan jobb och agenter.

Pipelineartefakter är ett sätt att lagra filer i Azure Pipelines och de är associerade med den specifika körningen av din pipeline. Du använder den PublishBuildArtifacts inbyggda pipelineaktiviteten för att instruera Azure Pipelines att publicera en fil eller mapp från agentens filsystem som en pipelineartefakt:

- task: PublishBuildArtifacts@1
  displayName: Publish folder as a pipeline artifact
  inputs:
    artifactName: my-artifact-name
    pathToPublish: '$(Build.ArtifactStagingDirectory)/my-folder'

Egenskapen pathToPublish är den plats som innehåller din kompilerade kod eller utdatafiler i pipelineagentens filsystem. Innehållet på den här platsen publiceras till artefakten. Du kan ange en enskild fil eller en mapp.

Varje artefakt har ett namn som du anger med hjälp av aktivitetsegenskapen artifactName . Du använder artefaktnamnet för att referera till det senare i pipelinen. Efterföljande pipelinejobb och -steg kan ladda ned artefakten så att de kan arbeta med den för att till exempel distribuera webbplatsen till den server som är värd för den:

När du använder distributionsjobb hämtas pipelineartefakter automatiskt som standard. Om du använder vanliga jobb använder du uppgiften DownloadBuildArtifacts för att ladda ned en pipelineartefakt:

- task: DownloadBuildArtifacts@0
  inputs:
    buildType: current
    downloadType: single
    artifactName: my-artifact-name
    downloadPath: '$(System.ArtifactsDirectory)'

Distribuera appar

Byggprocessen för en app genererar och publicerar en distributionsbar artefakt. Senare steg i pipelinen distribuerar artefakten. Hur du distribuerar en app beror på vilken tjänst du använder för att vara värd för den.

Distribuera till Azure App Service

Leksaksföretaget använder Azure App Service som värd för sin webbplats. Du kan skapa och konfigurera en App Service-app med hjälp av Bicep. Men när det är dags att distribuera appen har du flera alternativ för att hämta den kompilerade appen till värdinfrastrukturen. De här alternativen hanteras som en del av App Service-dataplanet.

Den vanligaste metoden är att använda AzureRmWebAppDeployment Azure Pipelines-uppgiften:

- task: AzureRmWebAppDeployment@4
  inputs:
    azureSubscription: MyServiceConnection
    ResourceGroupName: MyResourceGroup
    WebAppName: my-app-service
    Package: '$(Pipeline.Workspace)/my-artifact-name/website.zip'

Du måste ange flera informationsdelar för att distribuera din app till App Service. Den här informationen innehåller resursgruppen och resursnamnet för App Service-appen, som du anger med hjälp ResourceGroupName av indata och WebAppName . Som du lärde dig i föregående lektion bör du lägga till utdata i Bicep-filen och använda en pipelinevariabel för att sprida appnamnet via pipelinen. Du måste också ange en .zip fil med appen som ska distribueras med hjälp Package av indata, vilket vanligtvis är sökvägen till en pipelineartefakt.

App Service har ett eget autentiseringssystem för dataplanet som används för distributioner. Uppgiften AzureRmWebAppDeployment hanterar autentiseringsprocessen automatiskt åt dig:

Uppgiften AzureRmWebAppDeployment använder tjänstens huvudnamn som är associerat med tjänstanslutningen för att automatiskt skapa och ladda ned nödvändiga autentiseringsuppgifter för distributionen . Den använder sedan autentiseringsuppgifterna för distributionen när den kommunicerar med Api:et för App Service-dataplanet .

App Service innehåller också några andra distributionsrelaterade funktioner, inklusive distributionsfack. Slots hjälper dig att distribuera nya versioner av dina appar utan driftstopp på ett säkert sätt. De hjälper dig också att förbereda och värma upp den nya versionen av ditt program innan du skickar produktionstrafik till det. Vi använder inte platser i den här modulen, men vi tillhandahåller en länk till mer information om dem på sidan Sammanfattning i slutet av modulen.

Distribuera appar till andra Azure-tjänster

Azure erbjuder många andra alternativ för att vara värd för dina appar, som var och en har sin egen metod för distribution.

Azure Functions bygger på App Service och använder en distributionsprocess som liknar den som beskrevs tidigare.

Om du distribuerar till en virtuell dator måste du vanligtvis ansluta till den virtuella datorinstansen för att installera din app. Du behöver ofta använda specialiserade verktyg, till exempel Chef, Puppet eller Ansible, för att orkestrera en distribution till virtuella datorer.

Om du använder Kubernetes eller Azure Kubernetes Service (AKS) skulle du använda en något annorlunda metod för att skapa och distribuera din lösning. När appen har skapats skapar pipelinen en containeravbildning och publicerar den till ett containerregister, som Kubernetes-klustret sedan läser från. Eftersom containerregistret behåller det kompilerade programmet använder du vanligtvis inte en pipelineartefakt.

I den här modulen fokuserar vi på Azure App Service för att illustrera de pipelinebegrepp som ingår. På sidan Sammanfattning i slutet av modulen tillhandahåller vi länkar till mer information om hur du distribuerar till andra värdtjänster.

Testa appar i din pipeline

I en tidigare modul lärde du dig om värdet och vikten av att köra automatiserade tester från din pipeline. När du distribuerar en app är det bra att pipelinen kör några tester som anropar appens kod. Sådana tester minskar risken för att ett app- eller distributionsfel kan orsaka driftstopp. I mer avancerade scenarier kan du till och med utföra en uppsättning testfall mot din app, till exempel anropa API:er eller skicka och övervaka en syntetisk transaktion.

Många appar implementerar slutpunkter för hälsokontroll. När en slutpunkt för hälsokontroll tar emot en begäran utför den en rad kontroller mot webbplatsen, till exempel att säkerställa att databaser och nätverkstjänster kan nås från appmiljön. Svaret som webbplatsen returnerar anger om appen är felfri. Utvecklare kan skriva och anpassa sina egna hälsokontroller efter appens krav. Om din app har en slutpunkt för hälsokontroll är det ofta klokt att övervaka den från din pipeline när distributionsfasen är klar.

Din distributionspipeline

I nästa övning uppdaterar du distributionspipelinen för att lägga till nya jobb för att skapa webbplatsens program och distribuera det till varje miljö: