Cvičení – nasazení řešení s více kontejnery do clusteru Kubernetes

15 min

Nasazovací kanál poskytovaný vaším projektem je navržen pro sestavení řešení jako Docker kontejner a nasazení do služby Azure App Service. Pokud chcete podporovat nasazení více kontejnerů do clusteru Kubernetes, musíte tento kanál upravit.

V této lekci se naučíte:

Aktualizujte pipeline tak, aby se aktivovala při commitu do hlavní větve.
Definujte proměnné, které se mají sdílet v rámci potrubí.
Sestavte a publikujte image Dockeru.
Publikování manifestů Kubernetes
Přidejte úlohu pro vytvoření tajného klíče pro získání obrazu, který bude použit mezi instancemi Kubernetes a registru kontejnerů.
Nasazení aktualizovaných imagí do clusteru Kubernetes

Aktualizovat potrubí pro podporu spouštěčů

Přihlaste se ke své organizaci Azure DevOps a přejděte k projektu.
Vyberte Pipelinesa pak vyberte vaše potrubí.
Vyberte Upravit a upravte azure-pipelines.yml.

Andy: Toto byla fáze sestavení, kterou jsme použili pro předchozí řešení s jedním kontejnerem. Věděl jsem, že to nebude fungovat správně, takže jsem ho zakázal. Můžeme začít opětovným povolením triggerů při potvrzeních do main větve.
Nahraďte existující trigger řádek v horní části souboru následujícím fragmentem kódu. Aktivuje se spuštění pipeline při každém commitu do hlavní větve.
```
trigger:
- 'main'
```

Definování proměnných přístupných v rámci kanálu

Andy: Budeme muset přidat dvě proměnné potrubí. Jedno pro zadání názvu úložiště tabulky výsledků, což je tabulka výsledků. Druhým je název tajného klíče pro stahování image, který se používá pro sdílení mezi instancemi AKS a ACR během nasazení.

Do oddílu variables přidejte následující zvýrazněný kód.

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

Sestavení a publikování image Dockeru do služby Azure Container Registry

Andy: Už máme úkol vytvořit webovou aplikaci jako kontejner Dockeru, který publikujeme do registru kontejneru. Druhý úkol můžeme použít jenom k tomu, abychom to udělali pro naši tabulku výsledků.

Přidejte druhý Docker@2 úkol pro sestavení a publikování kontejneru tabulky výsledků pomocí následujícího zvýrazněného fragmentu kódu. Přidejte tento úkol přímo za úlohu webového kontejneru.

- 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)

Spropitné

Ujistěte se, že úkol, který sem přidáte, používá stejné odsazení jako u předchozího úkolu, protože jsou prázdné znaky důležité v souboru YAML.

Publikování manifestů Kubernetes

Andy: myslím, že můžeme přejít na další fázi. Vidíte něco, co chybí?

Mara: Zmínili jste se, že ve zdrojovém projektu byly nějaké soubory manifestu, které definují nasazení a služby, které Kubernetes potřebuje při nasazení. Před dokončením této fáze bychom je měli publikovat.

Andy: Potřebujeme? Nebudou stále na místním disku?

Mara: Byly by, kdybychom přidávali úlohy nasazení do stejné fáze jako sestavení. Vzhledem k tomu, že naše úlohy nasazení probíhají ve své vlastní fázi Nasazení, se provádí v novém prostředí a pravděpodobně i na jiném agentovi. Měli bychom se ujistit, že publikujeme cokoli, co tato fáze vytvoří a co druhá fáze potřebuje.

Andy: To je skvělý bod. Je to snadné? Musíme pouze zajistit, aby manifesty složky byly zkopírovány k novému agentovi.

Mara: To je to, k čemu slouží PublishBuildArtifacts@1 úkol. Je to tak běžné, že tam je dokonce i zkratka pro to, publish.

Přidejte publish úlohu, která ukládá manifesty složky pro, určené pro budoucí fázi, jak je znázorněno v následujícím fragmentu kódu. Ujistěte se, že odsazení tohoto úkolu odpovídá odsazení předchozího úkolu.

- 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

Nahrazení fáze nasazení

Mara: nahradím naši stávající fázi Deploy jinou, která používá nasazovací úlohu. Úloha nasazení je speciální druh úlohy, která nám umožňuje přidružit naše nasazení k prostředí Azure DevOps vytvořenému dříve. To usnadňuje sledování historie nasazení, což bude zvlášť užitečné, protože naše řešení jsou propracovanější.

Odeberte existující fázi Deploy (vše po fázi sestavení) a nahraďte ji následujícím fragmentem kódu. Poznamenejte si zvýrazněný řádek, který označuje, které prostředí nasazení se má využít.
```
- 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: Prvním krokem, který přidáme do fáze nasazení, je stažení artefaktů manifestu publikovaných dříve pomocí úlohy DownloadBuildArtifacts@0.

Andy: Hádám, je tu download zkratka pro tento úkol?

Mara: Přesně správně! Specifikátor current můžeme použít k označení, že chceme artefakt z aktuálního spuštění kanálu.
Přidejte zvýrazněné řádky jako první krok fáze Nasazení.
```
- 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: Teď potřebujeme vytvořit tajemství pro stahování image, které bude sdíleno mezi našimi instancemi ACR a AKS. Víte, jestli existuje úkol, který můžeme použít?

Mara: Právě jsem se na to díval/a, a máme štěstí. Úloha KubernetesManifest@0 podporuje akci pro vytvoření potřebného tajného kódu.

Úloha manifestu Kubernetes

Úloha manifestu Kubernetes je navržená tak, aby spravovala všechny hlavní operace nasazení požadované pro Kubernetes. Podporuje několik možností action, které se liší od vytváření tajných kódů až po nasazení imagí. V tomto případě se použije akce createSecret spolu s následujícími parametry:

action označuje spuštění funkce. V tomto případě createSecret vytvoří sdílený tajný klíč.
connectionType určuje typ připojení služby, které se má použít. Možnosti: azureResourceManager nebo kubernetesServiceConnection.
secretName určuje název tajného kódu, který se má vytvořit.
dockerRegistryEndpoint určuje název připojení služby Azure Container Registry Services.
azureSubscriptionConnection určuje název připojení služeb ARM.
azureResourceGroup určuje název vaší skupiny prostředků.
kubernetesCluster určuje název clusteru AKS.
namespace určuje obor názvů Kubernetes, na který se tato akce vztahuje.

Na konec vašeho pipeline přidejte následující fragment kódu. Ujistěte se, že název skupiny prostředků i název clusteru odpovídají názvům dříve vytvořených skupin prostředků. Ujistěte se, že odsazení tohoto úkolu odpovídá odsazení úkolu stažení .
```
- 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: Posledním krokem je aktivace nasazení našich imagí do clusteru Kubernetes. Na základě dokumentace to vypadá, že můžeme použít stejný úkol, ale s jinou akcí a parametry.
- action označuje spuštění funkce. V tomto případě je deploy nasadit do clusteru AKS.
- connectionType určuje typ připojení služby, které se má použít. Možnosti: azureResourceManager nebo kubernetesServiceConnection.
- azureSubscriptionConnection určuje název připojení služeb ARM.
- azureResourceGroup určuje název vaší skupiny prostředků.
- kubernetesCluster určuje název clusteru AKS.
- namespace určuje obor názvů Kubernetes, na který se tato akce vztahuje.
- imagePullSecrets určuje seznam tajných kódů potřebných k načtení z registru kontejneru.
- containers určuje seznam imagí kontejneru, které se mají nasadit.

Na konec potrubí přidejte následující kód úryvku. Ujistěte se, že název skupiny prostředků i název clusteru odpovídají názvům dříve vytvořených skupin prostředků. Ujistěte se, že odsazení tohoto úkolu odpovídá předchozímu úkolu.

- 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)

Spusťte svůj pipeline

V pravém horním rohu stránky vyberte Uložit. Vyberte Uložit a potvrďte zprávu potvrzení.
Vyberte Spustit, potvrďte název větve a pak vyberte Spustit pro spuštění pipeline.
Vyberte Pipelinesa poté vyberte svou pipeline, abyste zobrazili protokoly během jejího spuštění.
Po dokončení běhu pipeline vyberte Prostředí v levém podokně a pak vyberte prostředí Dev pro zobrazení úloh nasazení.
Teď se podívejme na naši nasazenou webovou aplikaci a koncový bod rozhraní API. K tomu potřebujeme získat externí IP adresy jak pro webové služby , tak pro služby výsledkové tabule .
Přejděte na web Azure Portal, vyberte cluster AKS a pak vyberte Služby a příchozí přenos dat.
Vyberte externí IP pro svou službu web, abyste mohli zobrazit svůj web na AKS.
Vraťte se do okna portálu Azure, kde jste skončili, a zkopírujte externí IP pro vaši službu žebříčku. Tato IP adresa je místem, kde je rozhraní API tabulky výsledků veřejně hostované.
Zástupný symbol v následujícím odkazu nahraďte externí IP adresou, kterou jste zkopírovali. Můžete také přidat parametr dotazu pageSize=10, aby se v prohlížeči snadněji zobrazila odpověď JSON. Na nové kartě prohlížeče použijte adresu URL, která je podobná následující.
```
http://[IP]/api/Leaderboard?pageSize=10
```
Nezpracovanou odpověď JSON můžete zobrazit z rozhraní API tabulky výsledků hostovaného v clusteru AKS. Teď máte rozhraní REST API, které můžete volat z jiných aplikací.

Andy: To se ukázalo skvěle! Myslím, že použití Kubernetes by pro nás bylo skvělým způsobem, jak přijmout širší strategii mikroslužeb.

Váš názor

Byla tato stránka užitečná?