Ćwiczenie — wdrażanie rozwiązania z wieloma kontenerami w klastrze Kubernetes

15 min

Potok wydania dostarczany z projektem jest przeznaczony do kompilowania rozwiązania jako kontenera platformy Docker i wdrażania go w usłudze aplikacja systemu Azure Service. Aby obsługiwać wdrażanie wielu kontenerów w klastrze Kubernetes, należy zmodyfikować ten potok.

W tej lekcji dowiesz się, jak wykonywać następujące czynności:

Zaktualizuj potok, aby wyzwolił zatwierdzenie w gałęzi głównej.
Zdefiniuj zmienne, które mają być współużytkowane w potoku.
Kompilowanie i publikowanie obrazów platformy Docker.
Publikowanie manifestów platformy Kubernetes.
Dodaj zadanie tworzenia wpisu tajnego ściągania obrazu do użycia między wystąpieniami usługi Kubernetes i rejestru kontenerów.
Wdrażanie zaktualizowanych obrazów w klastrze Kubernetes.

Aktualizowanie potoku w celu obsługi wyzwalaczy

Zaloguj się do organizacji usługi Azure DevOps, a następnie przejdź do projektu.
Wybierz pozycję Potoki, a następnie wybierz potok.
Wybierz pozycję Edytuj , aby edytować azure-pipelines.yml.

Andy: Był to etap kompilacji, który mieliśmy na miejscu dla poprzedniego rozwiązania z pojedynczym kontenerem. Wiedziałem, że to nie będzie działać prawidłowo, więc wyłączyłem go. Możemy rozpocząć od ponownego włączenia wyzwalaczy dla zatwierdzeń w main gałęzi.
Zastąp istniejący trigger wiersz w górnej części pliku poniższym fragmentem kodu. Spowoduje to wyzwolenie uruchomienia potoku za każdym razem, gdy zatwierdzenie zostanie wykonane w gałęzi głównej.
```
trigger:
- 'main'
```

Definiowanie zmiennych dostępnych w potoku

Andy: Musimy dodać dwie zmienne potoku. Jeden z nich służy do określania nazwy repozytorium rankingu, które jest liderem. Druga jest nazwą wpisu tajnego ściągania obrazu używanego do udostępniania wystąpień usługi AKS i usługi ACR podczas wdrażania.

Dodaj następujący wyróżniony kod do variables sekcji.

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

Kompilowanie i publikowanie obrazu platformy Docker w usłudze Azure Container Registry

Andy: Mamy już zadanie tworzenia aplikacji internetowej jako kontenera platformy Docker, który publikujemy w rejestrze kontenerów. Możemy po prostu użyć drugiego zadania, aby wykonać to samo dla naszej rankingu.

Dodaj drugie Docker@2 zadanie do skompilowania i opublikowania kontenera rankingu przy użyciu poniższego wyróżnionego fragmentu kodu. Dodaj to zadanie bezpośrednio po zadaniu kontenera internetowego.

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

Napiwek

Upewnij się, że dodane tutaj zadanie używa spójnych wcięcia z poprzednim zadaniem, ponieważ białe znaki są ważne w pliku YAML.

Publikowanie manifestów platformy Kubernetes

Andy: Myślę, że możemy przejść do następnego etapu. Czy widzisz coś brakującego?

Mara: Wspomniano, że w projekcie źródłowym istnieją pewne pliki manifestu, które definiują wdrożenie, oraz usługi, których potrzebuje platforma Kubernetes podczas wdrażania. Powinniśmy je opublikować przed zakończeniem tego etapu.

Andy: Czy musimy? Czy nadal nie będą znajdować się na dysku lokalnym?

Mara: Gdyby dodaliśmy zadania wdrażania w tym samym etapie co kompilacja. Jednak ponieważ nasze zadania wdrażania odbywają się we własnym etapie wdrażania , są uruchamiane w nowym środowisku, prawdopodobnie nawet na innym agencie. Należy pamiętać, aby opublikować wszystko, co ten etap powoduje, że inne potrzeby etapu.

Andy: To świetny punkt. Czy łatwo jest to zrobić? Musimy tylko upewnić się, że folder manifestów został skopiowany do nowego agenta.

Mara: To właśnie PublishBuildArtifacts@1 jest zadanie. Jest tak powszechne, że istnieje nawet skrót dla niego, publish.

publish Dodaj zadanie, które przechowuje folder manifestów dla przyszłego etapu, jak pokazano w poniższym fragmencie kodu. Upewnij się, że wcięcie tego zadania jest zgodne z poprzednim zadaniem.

- 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

Zastępowanie etapu wdrażania

Mara: Zamienię istniejący etap wdrażania na taki, który używa zadania wdrożenia. Zadanie wdrożenia to specjalny rodzaj zadania , który umożliwia skojarzenie wdrożenia z utworzonym wcześniej środowiskiem usługi Azure DevOps. Ułatwia to śledzenie historii wdrażania, co będzie szczególnie przydatne, ponieważ nasze rozwiązania stają się bardziej zaawansowane.

Usuń istniejący etap wdrażania (wszystko po etapie kompilacji) i zastąp go poniższym fragmentem kodu. Zanotuj wyróżniony wiersz wskazujący, że środowisko wdrażania ma być używane.
```
- 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: Pierwszym krokiem, który dodamy na etapie wdrażania, jest pobranie artefaktów manifestu opublikowanych wcześniej przy użyciu DownloadBuildArtifacts@0 zadania .

Andy: Niech domyślam się, czy jest download skrót tego zadania?

Mara: Dokładnie poprawne! Możemy użyć specyfikatora current , aby wskazać, że chcemy artefaktu z bieżącego uruchomienia potoku.
Dodaj wyróżnione wiersze jako pierwszy krok etapu Wdrażanie .
```
- 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: Teraz musimy utworzyć wpis tajny ściągania obrazu, który będzie współużytkowany między naszymi wystąpieniami usługi ACR i usługi AKS. Czy wiesz, czy istnieje zadanie, którego możemy użyć?

Mara: Po prostu szukałem tego w górę i mamy szczęście. Zadanie KubernetesManifest@0 obsługuje akcję w celu utworzenia wymaganego wpisu tajnego.

Zadanie manifestu platformy Kubernetes

Zadanie manifestu platformy Kubernetes zostało zaprojektowane tak, aby zarządzać wszystkimi głównymi operacjami wdrażania wymaganymi dla platformy Kubernetes. Obsługuje wiele action opcji, od tworzenia wpisów tajnych do wdrażania obrazów. W takim przypadku createSecret jest używana akcja wraz z następującymi parametrami:

action wskazuje funkcję do uruchomienia. W takim przypadku createSecret tworzy wspólny klucz tajny.
connectionType określa typ połączenia z usługą do użycia. Opcje: azureResourceManager lub kubernetesService Połączenie ion.
secretName określa nazwę wpisu tajnego do utworzenia.
dockerRegistryEndpoint określa nazwę połączenia usług Azure Container Registry Services.
azureSubscriptionConnection określa nazwę połączenia usług ARM.
azureResourceGroup określa nazwę grupy zasobów.
kubernetesCluster określa nazwę klastra usługi AKS.
namespace Określa przestrzeń nazw Kubernetes, do których ma zastosowanie ta akcja.

Dodaj następujący fragment kodu na końcu potoku. Upewnij się, że zarówno nazwa grupy zasobów, jak i nazwa klastra są zgodne z nazwami utworzonych wcześniej. Upewnij się, że wcięcie tego zadania jest zgodne z zadaniem pobierania.
```
- 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: Ostatnim krokiem jest wyzwolenie wdrożenia naszych obrazów w klastrze Kubernetes. Na podstawie dokumentacji wygląda na to, że możemy użyć tego samego zadania, ale z inną akcją i parametrami.
- action wskazuje funkcję do uruchomienia. W tym przypadku w deploy celu wdrożenia w klastrze usługi AKS.
- connectionType określa typ połączenia z usługą do użycia. Opcje: azureResourceManager lub kubernetesService Połączenie ion.
- azureSubscriptionConnection określa nazwę połączenia usług ARM.
- azureResourceGroup określa nazwę grupy zasobów.
- kubernetesCluster określa nazwę klastra usługi AKS.
- namespace Określa przestrzeń nazw Kubernetes, do których ma zastosowanie ta akcja.
- imagePullSecrets określa listę wpisów tajnych wymaganych do ściągnięcia z rejestru kontenerów.
- containers określa listę obrazów kontenerów do wdrożenia.

Dodaj następujący fragment kodu na końcu potoku. Upewnij się, że zarówno nazwa grupy zasobów, jak i nazwa klastra są zgodne z nazwami utworzonych wcześniej. Upewnij się, że wcięcie tego zadania jest zgodne z poprzednim zadaniem.

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

Uruchamianie potoku

Wybierz pozycję Zapisz w prawym górnym rogu strony. Wybierz pozycję Zapisz , aby potwierdzić komunikat zatwierdzenia.
Wybierz pozycję Uruchom, potwierdź nazwę gałęzi, a następnie wybierz pozycję Uruchom , aby wyzwolić uruchomienie potoku.
Wybierz pozycję Potoki, a następnie wybierz potok, aby wyświetlić dzienniki podczas uruchamiania potoku.
Po zakończeniu przebiegu potoku wybierz pozycję Środowiska w okienku po lewej stronie, a następnie wybierz środowisko deweloperskie , aby wyświetlić zadania wdrażania.
Teraz zapoznajmy się z wdrożoną aplikacją internetową i punktem końcowym interfejsu API. W tym celu musimy uzyskać zewnętrzne adresy IP zarówno dla usług internetowych, jak i wiodących.
Przejdź do witryny Azure Portal, wybierz klaster usługi AKS, a następnie wybierz pozycję Usługi i ruch przychodzący.
Wybierz zewnętrzny adres IP usługi internetowej, aby wyświetlić witrynę w usłudze AKS.
Wróć do okna witryny Azure Portal, w którym została przerwana, a następnie skopiuj zewnętrzny adres IP dla usługi rankingowej . Ten adres IP to miejsce, w którym interfejs API rankingu jest publicznie hostowany.
Zastąp symbol zastępczy w poniższym linku skopiowanymi zewnętrznym adresem IP. Możesz również dodać pageSize=10 parametr zapytania, aby ułatwić wyświetlanie odpowiedzi JSON w przeglądarce. Użyj adresu URL, takiego jak poniższy na nowej karcie przeglądarki.
```
http://[IP]/api/Leaderboard?pageSize=10
```
Możesz wyświetlić nieprzetworzoną odpowiedź JSON z interfejsu API rankingu hostowanego w klastrze usługi AKS. Masz teraz interfejs API REST, który można wywoływać z innych aplikacji.

Andy: To okazało się wspaniałe! Myślę, że użycie platformy Kubernetes byłoby dla nas doskonałym sposobem na przyjęcie szerszej strategii mikrousług.