Övning – Distribuera en lösning med flera containrar till ett Kubernetes-kluster

15 minuter

Versionspipelinen som medföljer projektet är utformad för att skapa lösningen som en Docker-container och distribuera den till Azure App Service. För att stödja distributionen av flera containrar till ett Kubernetes-kluster måste du ändra den här pipelinen.

I den här lektionen får du lära dig att:

Uppdatera pipelinen så att den utlöses vid en commit till huvudgrenen.
Definiera variabler som ska delas över pipelinen.
Skapa och publicera Docker-avbildningar.
Publicera Kubernetes-manifest.
Lägg till en uppgift för att skapa en avbildningshämtningshemlighet för användning mellan dina Kubernetes- och containerregisterinstanser.
Distribuera uppdaterade avbildningar till ett Kubernetes-kluster.

Uppdatera pipelinen för att stödja utlösare

Logga in på din Azure DevOps-organisation och navigera sedan till projektet.
Välj Pipelinesoch välj sedan din pipeline.
Välj Redigera för att redigera din azure-pipelines.yml.

Andy: Det här var byggfasen som vi hade på plats för den tidigare lösningen med en enda container. Jag visste att den inte skulle köras korrekt, så jag inaktiverade den. Vi kan börja med att återaktivera triggers vid commit till main-grenen.
Ersätt den befintliga trigger raden överst i filen med följande kodfragment. Detta utlöser en pipelinekörning varje gång en commit görs till huvudgrenen.
```
trigger:
- 'main'
```

Definiera variabler som är tillgängliga i pipeline

Andy: Vi måste lägga till två pipelinevariabler. En för att ange namnet på rankningslistans lagringsplats, som är topplista. Den andra avser namnet på image pull-credentialen som används för delning mellan AKS- och ACR-instanser under distributionen.

Lägg till följande markerade kod i avsnittet variables.

variables:
  buildConfiguration: 'Release'
  leaderboardRepository: 'leaderboard'
  webRepository: 'web'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'secret'

Skapa och publicera Docker-avbildning till Azure Container Registry

Andy: Vi har redan en uppgift för att skapa webbappen som en Docker-container som vi publicerar i vårt containerregister. Vi kan bara använda en andra uppgift för att göra samma sak för vår rankningslista.

Lägg till en andra Docker@2 uppgift för att skapa och publicera leaderboardcontainern med hjälp av följande markerade kodfragment. Lägg till den här uppgiften direkt efter webbcontaineraktiviteten.

- task: Docker@2
  displayName: 'Build and push the web image to container registry'
  inputs:
    command: buildAndPush
    buildContext: $(Build.Repository.LocalPath)
    repository: $(webRepository)
    dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.Web/Dockerfile'
    containerRegistry: 'Container Registry Connection'
    tags: |
      $(tag)

- task: Docker@2
  displayName: 'Build and push the leaderboard image to container registry'
  inputs:
    command: buildAndPush
    buildContext: $(Build.Repository.LocalPath)
    repository: $(leaderboardRepository)
    dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.LeaderboardContainer/Dockerfile'
    containerRegistry: 'Container Registry Connection'
    tags: |
      $(tag)

Tips

Kontrollera att den uppgift som du lägger till här använder konsekvent indragning som den föregående uppgiften eftersom blanksteg är viktiga i en YAML-fil.

Publicera Kubernetes-manifesten

Andy: jag tror att vi kan gå vidare till nästa steg. Ser du något som saknas?

Mara: Du nämnde att det fanns några manifestfiler i källprojektet som definierar distributionen och tjänster som Kubernetes behöver när vi distribuerar. Vi bör publicera dem innan vi avslutar det här steget.

Andy: Behöver vi det? Finns de inte kvar på den lokala disken?

Mara: de skulle vara om vi lade till distributionsuppgifterna i samma fas som bygget. Men eftersom våra distributionsuppgifter sker i sin egen Distribuera fas körs den i en ny miljö, förmodligen även på en annan agent. Vi bör se till att publicera allt som den här fasen producerar som den andra fasen behöver.

Andy: Det är en bra poäng. Är det lätt att göra? Vi behöver bara se till att -manifesten mapp kopieras till den nya agenten.

Mara: Det är vad PublishBuildArtifacts@1 uppgift är till för. Det är så vanligt att det till och med finns en förkortning för det, publish.

Lägg till en publish-uppgift som lagrar -manifesten i-mappen för en framtida fas, enligt följande kodfragment. Kontrollera att indraget för den här uppgiften matchar den föregående uppgiftens indrag.

- task: Docker@2
  displayName: 'Build and push the leaderboard image to container registry'
  inputs:
    command: buildAndPush
    buildContext: $(Build.Repository.LocalPath)
    repository: $(leaderboardRepository)
    dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.LeaderboardContainer/Dockerfile'
    containerRegistry: 'Container Registry Connection'
    tags: |
      $(tag)

- publish: '$(Build.SourcesDirectory)/manifests'
  artifact: manifests

Ersätt distributionssteget

Mara: Jag kommer att ersätta vår befintliga Implementering med en som använder ett implementeringsjobb. Ett distributionsjobb är en speciell typ av jobb som gör att vi kan associera vår distribution med Azure DevOps-miljön som skapades tidigare. Det gör det enklare att spåra distributionshistoriken, vilket är särskilt användbart när våra lösningar blir mer avancerade.

Ta bort den befintliga Deploy-fasen (allt som kommer efter byggfasen) och ersätt den med följande kodfragment. Anteckna den markerade raden som anger vilken distributionsmiljö som ska användas.
```
- stage: 'Deploy'
  displayName: 'Deploy the containers'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: 'Dev'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
```
Mara: Det första steget vi lägger till i distributionssteget är att ladda ned manifestartefakterna som publicerades tidigare med hjälp av DownloadBuildArtifacts@0 uppgiften.

Andy: Låt mig gissa, finns det en download förkortning för den uppgiften?

Mara: Exakt rätt! Vi kan använda current-specificeraren för att ange att vi vill ha artefakten från den aktuella körningen av pipelinen.
Lägg de markerade raderna som det första steget i steget Distribuera.
```
- stage: 'Deploy'
  displayName: 'Deploy the containers'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: 'spike.default'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: manifests
```
Andy: Nu måste vi skapa en pull-hemlighet för avbildningar som delas mellan våra ACR- och AKS-instanser. Vet du om det finns en uppgift som vi kan använda?

Mara: Jag kollade precis upp det, och vi har tur. Uppgiften KubernetesManifest@0 stödjer en åtgärd för att skapa den hemlighet som behövs.

Kubernetes-manifestuppgift

Kubernetes-manifestuppgiften är utformad för att hantera alla vanliga distributionsåtgärder som krävs för Kubernetes. Det stöder flera action alternativ som sträcker sig från att skapa lösenord till att distribuera bilder. I det här fallet används åtgärden createSecret tillsammans med följande parametrar:

action anger vilken funktion som ska köras. I det här fallet skapar createSecret den delade hemligheten.
connectionType anger vilken typ av tjänstanslutning som ska användas. Alternativ: azureResourceManager eller kubernetesServiceConnection.
secretName anger namnet på hemligheten som ska skapas.
dockerRegistryEndpoint anger namnet på Azure Container Registry Services-anslutningen.
azureSubscriptionConnection anger namnet på ARM Services-anslutningen.
azureResourceGroup anger namnet på resursgruppen.
kubernetesCluster anger namnet på ditt AKS-kluster.
namespace anger kubernetes-namnområdet som den här åtgärden gäller för.

Lägg till följande kodfragment i slutet av pipelinen. Kontrollera att både resursgruppens namn och klusternamnet matchar namnen på de som du skapade tidigare. Se till att indraget av den här uppgiften matchar det med nedladdnings--uppgift.
```
- task: KubernetesManifest@1
  displayName: Create imagePullSecret
  inputs:
    action: createSecret
    connectionType: azureResourceManager
    secretName: $(imagePullSecret)
    dockerRegistryEndpoint: 'Container Registry Connection'
    azureSubscriptionConnection: 'Kubernetes Cluster Connection'
    azureResourceGroup: 'tailspin-space-game-rg'
    kubernetesCluster: 'tailspinspacegame-24591'
    namespace: 'default'
```
Andy: Det sista steget är att utlösa distributionen av våra avbildningar till Kubernetes-klustret. Baserat på dokumentationen ser det ut som om vi kan använda samma uppgift men med en annan åtgärd och parametrar.
- action anger vilken funktion som ska köras. I detta scenario används deploy för att distribuera till ett AKS-kluster.
- connectionType anger vilken typ av tjänstanslutning som ska användas. Alternativ: azureResourceManager eller kubernetesServiceConnection.
- azureSubscriptionConnection anger namnet på ARM Services-anslutningen.
- azureResourceGroup anger namnet på resursgruppen.
- kubernetesCluster anger namnet på ditt AKS-kluster.
- namespace anger kubernetes-namnområdet som den här åtgärden gäller för.
- imagePullSecrets anger listan över hemligheter som behövs för att hämta från containerregistret.
- containers anger listan över containeravbildningar som ska distribueras.

Lägg till följande kodfragment i slutet av pipelinen. Kontrollera att både resursgruppens namn och klusternamnet matchar namnen på de som du skapade tidigare. Se till att indraget för den här aktiviteten matchar den föregående aktivitetens.

- task: KubernetesManifest@1
  displayName: Deploy to Kubernetes cluster
  inputs:
    action: deploy
    connectionType: azureResourceManager
    azureSubscriptionConnection: 'Kubernetes Cluster Connection'
    azureResourceGroup: 'tailspin-space-game-rg'
    kubernetesCluster: 'tailspinspacegame-24591'
    namespace: 'default'
    manifests: |
      $(Pipeline.Workspace)/manifests/deployment.yml
      $(Pipeline.Workspace)/manifests/service.yml
    imagePullSecrets: |
      $(imagePullSecret)
    containers: |
      $(RegistryName)/$(webRepository):$(tag)
      $(RegistryName)/$(leaderboardRepository):$(tag)

Kör din pipeline

Välj Spara i det övre högra hörnet på sidan. Välj Spara för att bekräfta incheckningsmeddelandet.
Välj Kör, bekräfta grennamnet och välj sedan Kör för att starta en pipelinekörning.
Välj Pipelinesoch välj sedan din pipeline för att visa loggarna när pipelinen körs.
När pipelinekörningen har slutförts väljer du Miljöer i det vänstra fönstret och väljer sedan Dev-miljön för att visa dina distributionsjobb.
Nu ska vi gå och kolla in vår distribuerade webbapp och API-slutpunkt. För att göra det måste vi hämta externa IP-adresser för både webb och leaderboard tjänster.
Gå till Azure-portalen, välj ditt AKS-kluster och välj sedan Tjänster och ingresser.
Välj den externa IP- för din webbtjänst för att visa webbplatsen på AKS.
Gå tillbaka till azure-portalfönstret där du slutade och kopiera sedan externa IP- för din leaderboard-tjänsten. Den här IP-adressen är där rankningsliste-API:et finns offentligt.
Ersätt platshållaren i följande länk med den externa IP-adress som du kopierade. Du kan också lägga till en pageSize=10 frågeparameter för att göra det enklare att visa JSON-svaret i webbläsaren. Använd en URL som följande på en ny webbläsarflik.
```
http://[IP]/api/Leaderboard?pageSize=10
```
Du kan visa det råa JSON-svaret från ranknings-API:et som finns i AKS-klustret. Nu har du ett REST-API som du kan anropa från andra program.

Andy: Det här blev bra! Jag tror att användning av Kubernetes skulle vara ett bra sätt för oss att anta en bredare mikrotjänststrategi.