Förstå distributioner från slutpunkt till slutpunkt

  • 5 minuter

Pipelines är flexibla verktyg som du kan konfigurera på många olika sätt för att passa dina behov. I den här lektionen får du lära dig hur du använder pipelines för att distribuera en hel lösning, inklusive att konfigurera Azure-infrastrukturen och hur du utför andra distributionsåtgärder.

Hur många pipelines?

I vissa organisationer skiljer sig teamet som hanterar Azure-miljön från det team som utvecklar koden som körs i miljön. I dessa situationer är det ofta frestande att skapa flera pipelines, som var och en ägs av teamet som ansvarar för dess specifika område. Du kan till exempel skapa en pipeline för att distribuera Bicep-koden som distribuerar webbplatsens Azure-resurser och en annan pipeline som distribuerar webbplatsprogrammet.

Även om den här metoden kan ge dig viss flexibilitet i hur du hanterar pipelines kan det vara svårt att hålla allt synkroniserat. Anta till exempel att ditt webbplatsteam behöver en ny inställning i sin Azure App Service-app för att aktivera en funktion som den skapar. Pipelinen för programdistribution kan inte köras förrän pipelinen för infrastrukturdistributionen har slutförts. Det kan också bli komplicerat att skicka data, till exempel namnen på Azure-resurser som skapats av din infrastrukturpipeline, mellan pipelines.

I stället är det ofta bättre att skapa en enda pipeline som distribuerar allt som krävs för din lösning, även om olika personer eller olika team hanterar komponenterna. Du kan använda verktyg som Git och Azure DevOps för att samordna ditt arbete. När en ny funktion läggs till kan du använda en gren för att göra nödvändiga ändringar i Bicep-filen. Och när ändringen är redo att integreras och släppas utför en enda pipeline alla steg som krävs för att skapa och distribuera lösningen. En enda pipeline minskar risken för att saker och ting blir osynkroniserade.

Dricks

När du skapar kod för din lösning behöver du förmodligen distribuera den ofta så att du kan testa hur den fungerar. Du kanske upptäcker att distributionen av infrastrukturen tillsammans med programkoden gör att pipelinen körs långsamt och hämmar dina framsteg.

Om du är i den här positionen kan du överväga att inaktivera infrastrukturdistributionen för utvecklingsmiljön. Du kan använda sökvägsfilter, pipelinemallar och villkor för att uppnå detta. Du bör dock lämna den fullständiga distributionssekvensen intakt för dina andra miljöer.

Kontrollplanet och dataplanet

Många Azure-resurser tillhandahåller två olika plan för åtkomst. Kontrollplanet distribuerar och konfigurerar resursen. Med dataplanet kan du komma åt resursens funktioner.

När du skapar och distribuerar Bicep-filer interagerar du med kontrollplanet. I Azure är kontrollplanet Azure Resource Manager. Du använder Resource Manager för att definiera konfigurationen av var och en av dina resurser.

Men din pipeline behöver ofta göra mer än att bara interagera med kontrollplanet. Du kan till exempel behöva utföra andra uppgifter:

  • Ladda upp en blob till ett lagringskonto.
  • Ändra ett databasschema.
  • Gör ett API-anrop till en tjänst från tredje part.
  • Utlös uppdateringen av en maskininlärningsmodell.
  • Distribuera en webbplats till en Azure App Service-app.
  • Distribuera programvara till en virtuell dator.
  • Registrera en DNS-post (Domain Name Server) med en tredjepartsleverantör.

När du överväger en pipeline från slutpunkt till slutpunkt behöver du vanligtvis distribuera dina Azure-resurser och sedan utföra en serie åtgärder mot dataplan för dessa resurser. Ibland kallas dessa åtgärder för den sista milen i distributionen, eftersom du utför större delen av distributionen med hjälp av kontrollplanet, och endast en liten mängd konfiguration återstår.

Kommentar

Vissa resurser har ingen tydlig uppdelning mellan kontrollplanet och dataplanet. Dessa inkluderar Azure Data Factory och Azure API Management. Båda tjänsterna stöder helt automatiserade distributioner med hjälp av Bicep, men de kräver särskilda överväganden. Du hittar länkar till mer information på sidan Sammanfattning i slutet av modulen.

Så här utför du dataplansåtgärder

När du skapar en distributionspipeline som interagerar med dina resursers dataplan kan du använda någon av tre vanliga metoder:

  • Resource Manager-distributionsskript.
  • Pipelineskript.
  • Pipelineuppgifter.

Resource Manager-distributionsskript definieras i Bicep-filen. De kör Bash- eller PowerShell-skript och kan interagera med Azure CLI- eller Azure PowerShell-cmdletar. Du skapar en hanterad identitet så att distributionsskriptet kan autentisera till Azure, och Azure etablerar och hanterar automatiskt de andra resurser som krävs för att köra distributionsskriptet.

Distributionsskript är bra när du behöver köra ett grundläggande skript i distributionsprocessen. Men de ger dig inte enkelt åtkomst till andra element från din pipeline.

Du kan också köra din egen logik inifrån en distributionspipeline. Azure Pipelines tillhandahåller ett omfattande ekosystem med uppgifter för vanliga saker som du behöver göra. Om du inte hittar en uppgift som uppfyller dina behov kan du använda ett skript för att köra din egen Bash- eller PowerShell-kod. Pipelineuppgifter och skript körs från pipelinens agent. Du behöver ofta autentisera uppgiften eller skriptet till dataplanet för den tjänst som du använder, och hur du autentiserar beror på tjänsten.

Pipelineuppgifter och skript ger dig flexibilitet och kontroll. De gör också att du kan komma åt pipelineartefakter, som du lär dig om snart. I den här modulen fokuserar vi på pipelineskript och uppgifter. Vi länkar till mer information om Resource Manager-distributionsskript på sidan Sammanfattning i slutet av modulen.

Utdata

En pipeline skapar och konfigurerar vanligtvis dina Azure-resurser genom att distribuera en Bicep-fil. De efterföljande delarna av pipelinen interagerar sedan med dataplanet för dessa resurser. För att kunna interagera med resurserna behöver pipelineuppgifterna och stegen information om den Azure-resurs som du skapade.

Anta till exempel att du har en Bicep-fil som distribuerar ett lagringskonto. Du vill att din pipeline ska distribuera lagringskontot och sedan ladda upp några blobar till en blobcontainer i lagringskontot. Pipelineaktiviteten som laddar upp blobarna måste känna till namnet på lagringskontot som ska anslutas till och namnet på blobcontainern som filen ska laddas upp till.

Det är bra att låta Bicep-filen bestämma namnen på dina Azure-resurser. Den kan använda parametrar, variabler eller uttryck för att skapa namnen för lagringskontot och blobcontainern. Bicep-filen kan sedan exponera utdata som ger varje resurs namn. Senare steg i pipelinen kan läsa värdet för utdata. På så sätt behöver din pipelinedefinition inte hårdkoda namn eller annan information som kan ändras mellan miljöer. Definitionen behöver inte heller baseras på regler som definieras i Bicep-filen.

Med Azure Pipelines kan du sprida värdena för utdata med hjälp av pipelinevariabler. Du kan ange värdet för en pipelinevariabel i ett pipelineskript. Du använder en särskilt formaterad loggutdata som Azure Pipelines förstår hur man tolkar, som du ser här:

stages:
- stage: Stage1
  jobs:
  - job: Job1
    steps:
      # Set the variable's value.
      - script: |
          echo "##vso[task.setvariable variable=myVariableName;isOutput=true]VariableValue"
        name: Step1

      # Read the variable's value.
      - script:
          echo $(myVariableName)

När du skapar en variabel i ett jobb, men vill komma åt den i ett annat jobb i samma fas, måste du mappa den.

stages:
- stage: Stage2
  jobs:
  - job: Job2
    steps:
      # Set the variable's value.
      - script: |
          echo "##vso[task.setvariable variable=myVariableName;isOutput=true]VariableValue"
        name: Step1

  - job: Job3
    dependsOn: Job2
    variables: # Map the variable to this job.
      myVariableName: $[ dependencies.Job2.outputs['Step1.myVariableName'] ]
    steps:
      # Read the variable's value.
      - script: |
          echo $(myVariableName)

För att få åtkomst till en variabel mellan pipelinesteg måste du också mappa variabeln, men du använder en annan syntax:

stages:
- stage: Stage2
  jobs:
  - job: Job2
    steps:
      # Set the variable's value.
      - script: |
          echo "##vso[task.setvariable variable=myVariableName;isOutput=true]VariableValue"
        name: Step1

  - job: Job3
    dependsOn: Job2
    variables: # Map the variable to this job.
      myVariableName: $[ dependencies.Job2.outputs['Step1.myVariableName'] ]
    steps:
      # Read the variable's value.
      - script: |
          echo $(myVariableName)

- stage: Stage3
  dependsOn: Stage2
  jobs:
  - job: Job4
    variables: # Map the variable to this stage.
      myVariableName: $[ stageDependencies.Stage2.Job2.outputs['Step1.myVariableName'] ]
    steps:
      # Read the variable's value.
    - script: |
        echo $(myVariableName)

Genom att använda Bicep-utdata och pipelinevariabler kan du skapa en pipeline för flera steg som distribuerar Bicep-koden och sedan utföra olika åtgärder på resurserna som en del av distributionen.