Exercício - Implantar uma solução de vários contêineres em um cluster Kubernetes

15 minutos

O pipeline de liberação fornecido com seu projeto foi projetado para criar a solução como um contêiner do Docker e implantá-la no Serviço de Aplicativo do Azure. Para dar suporte à implantação de vários contêineres em um cluster Kubernetes, você precisa modificar esse pipeline.

Nesta unidade, você aprenderá a:

Atualize o pipeline para ser acionado quando houver uma confirmação na ramificação principal.
Defina variáveis a serem compartilhadas no pipeline.
Crie e publique imagens do Docker.
Publique manifestos do Kubernetes.
Adicione uma tarefa para criar um segredo de extração de imagem para uso entre o seu Kubernetes e as instâncias do seu registo de contentores.
Implante imagens atualizadas em um cluster do Kubernetes.

Atualizar o fluxo de trabalho para dar suporte a disparadores

Entre em sua organização do Azure DevOps e navegue até seu projeto.
Selecione Pipelinese, em seguida, selecione o seu pipeline.
Selecione Edit para editar azure-pipelines.yml.

Andy: Esta foi a etapa de construção que tínhamos em uso para a solução anterior de contentor único. Eu sabia que não ia funcionar corretamente, então eu o desativei. Podemos começar por reativar os gatilhos nos commits na branch main.
Substitua a linha trigger existente na parte superior do arquivo pelo seguinte trecho. Isso aciona uma execução do pipeline toda vez que um commit é feito na ramificação principal.
```
trigger:
- 'main'
```

Definir variáveis acessíveis através do pipeline

Andy: Vamos precisar adicionar duas variáveis de pipeline. Um para especificar o nome do repositório da tabela de classificação, que é tabela de classificação. O outro é para o nome do segredo de extração de imagem usado para partilha entre instâncias AKS e ACR durante a implantação.

Adicione o seguinte código realçado à seção variables.

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

Criar e publicar imagem do Docker no Registro de Contêiner do Azure

Andy: Já temos uma tarefa para criar o aplicativo Web como um contêiner do Docker, que publicamos em nosso registro de contêiner. Podemos simplesmente usar uma segunda tarefa para fazer o mesmo para nossa tabela de classificação.

Adicione uma segunda tarefa Docker@2 para criar e publicar o contêiner da tabela de classificação usando o seguinte trecho realçado. Adicione esta tarefa logo após a tarefa de contêiner da Web.

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

Dica

Certifique-se de que a tarefa adicionada aqui usa recuo consistente com a tarefa anterior, pois o espaço em branco é importante em um arquivo YAML.

Publicar os manifestos do Kubernetes

Andy: acho que podemos passar para a próxima fase. Vê falta alguma coisa?

Mara: Você mencionou que havia alguns arquivos de manifesto no projeto de origem que definem a implantação e os serviços que o Kubernetes precisa quando implantamos. Devemos publicá-las antes de terminarmos esta fase.

Andy: Precisamos? Eles ainda não estarão no disco local?

Mara: Seria o caso se estivéssemos a adicionar as tarefas de implantação dentro do mesmo estágio da construção. No entanto, como as nossas tarefas de implementação acontecem na sua própria fase Deploy, são executadas num ambiente novo, provavelmente até mesmo num agente diferente. Devemos ter a certeza de publicar tudo o que esta fase produz e que a outra fase necessita.

Andy: Esse é um ótimo ponto. É fácil de fazer? Só precisamos garantir que a pasta de manifestos seja copiada para o novo agente.

Mara: É para isso que serve a tarefa PublishBuildArtifacts@1. É tão comum que há até uma abreviatura para isso, publish.

Adicione uma tarefa publish que armazene a pasta de manifestos para um estágio futuro, conforme mostrado no trecho de código a seguir. Certifique-se de que a indentação desta tarefa está alinhada com a da tarefa anterior.

- 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

Substitua a fase de implantação

Mara: vou substituir nosso estágio Deploy existente por um que use um trabalho de implantação. Um trabalho de implantação é um tipo especial de trabalho que nos permite associar a nossa implantação ao ambiente do Azure DevOps criado anteriormente. Isso facilita o acompanhamento do histórico de implantação, o que será especialmente útil à medida que nossas soluções se tornam mais sofisticadas.

Remova o estágio existente Implantar (tudo após o estágio de compilação) e substitua-o pelo trecho a seguir. Anote a linha realçada que indica o ambiente de implantação a ser utilizado.
```
- 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: O primeiro passo que adicionaremos na fase de implantação é baixar os artefatos do manifesto publicados anteriormente usando a tarefa DownloadBuildArtifacts@0.

Andy: Deixe-me adivinhar, existe uma abreviatura download para essa tarefa?

Mara: Exatamente! Podemos usar o especificador current para indicar que queremos o artefato da execução atual do pipeline.
Adicione as linhas realçadas como o primeiro passo da fase Implantar.
```
- 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: Agora precisamos criar um segredo de pull de imagem que será compartilhado entre nossas instâncias ACR e AKS. Sabe se há alguma tarefa que possamos usar?

Mara: Estava a pesquisar sobre isso, e estamos com sorte. A tarefa KubernetesManifest@0 suporta uma ação para criar o segredo necessário.

Tarefa de manifesto do Kubernetes

A tarefa de manifesto do Kubernetes foi projetada para gerenciar todas as principais operações de desdobramento necessárias para a plataforma Kubernetes. Ele suporta várias opções de action que vão desde a criação de segredos até a implantação de imagens. Nesse caso, a ação createSecret é usada, juntamente com os seguintes parâmetros:

action indica o recurso a ser executado. Nesse caso, createSecret cria o segredo compartilhado.
connectionType especifica o tipo de conexão de serviço a ser usada. Opções: azureResourceManager ou kubernetesServiceConnection.
secretName especifica o nome do segredo a ser criado.
dockerRegistryEndpoint especifica o nome da conexão dos Serviços de Registro de Contêiner do Azure.
azureSubscriptionConnection especifica o nome da conexão dos Serviços ARM.
azureResourceGroup especifica o nome do seu grupo de recursos.
kubernetesCluster especifica o nome do cluster AKS.
namespace especifica o namespace Kubernetes ao qual essa ação se aplica.

Adicione o seguinte trecho ao final do pipeline. Certifique-se de que o nome do grupo de recursos e o nome do cluster correspondam aos nomes dos que você criou anteriormente. Certifique-se de que a indentação desta tarefa corresponda à da tarefa de download .
```
- 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: A etapa final é acionar a implantação de nossas imagens no cluster Kubernetes. Com base na documentação, parece que podemos usar a mesma tarefa, mas com uma ação e parâmetros diferentes.
- action indica o recurso a ser executado. Neste caso, use deploy para implantar no cluster AKS.
- connectionType especifica o tipo de conexão de serviço a ser usada. Opções: azureResourceManager ou kubernetesServiceConnection.
- azureSubscriptionConnection especifica o nome da conexão dos Serviços ARM.
- azureResourceGroup especifica o nome do seu grupo de recursos.
- kubernetesCluster especifica o nome do cluster AKS.
- namespace especifica o namespace Kubernetes ao qual essa ação se aplica.
- imagePullSecrets especifica a lista de segredos necessários para extrair do registro de contêiner.
- containers especifica a lista de imagens de contêiner a serem implantadas.

Adicione o seguinte fragmento de código ao final do pipeline. Certifique-se de que o nome do grupo de recursos e o nome do cluster correspondam aos nomes dos que você criou anteriormente. Certifique-se de que o recuo desta tarefa seja igual ao da tarefa anterior.

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

Corra o seu pipeline

Selecione Guardar no canto superior direito da página. Selecione Salvar para confirmar sua mensagem de confirmação.
Selecione Executar, confirme o nome da ramificação e, em seguida, selecione Executar para iniciar uma execução de pipeline.
Selecione Pipelinese, em seguida, selecione seu pipeline para exibir os logs conforme o pipeline é executado.
Após a conclusão da execução do pipeline, selecione Ambientes no painel esquerdo e, em seguida, selecione o ambiente Dev para exibir os trabalhos de implantação.
Agora vamos conferir nosso aplicativo Web implantado e nosso endpoint de API. Para fazer isso, precisamos obter os endereços IP externos para os serviços web e tabela de classificação.
Navegue até o portal do Azure, selecione seu cluster AKS e selecione Serviços e entradas.
Selecione o IP externo para o seu serviço de web para visualizar o seu site no AKS.
Volte para a janela do portal do Azure de onde parou e, em seguida, copie o IP externo para o seu serviço de de tabela de classificação. Este endereço IP é onde a API da tabela de classificação está hospedada publicamente.
Substitua o espaço reservado no link a seguir pelo IP externo copiado. Você também pode adicionar um parâmetro de consulta pageSize=10 para facilitar a visualização da resposta JSON em seu navegador. Utilize uma URL como a seguinte numa nova aba do navegador.
```
http://[IP]/api/Leaderboard?pageSize=10
```
Você pode visualizar a resposta JSON bruta da API do placar de líderes hospedada em seu cluster AKS. Agora você tem uma API REST que pode chamar de outros aplicativos.

Andy: Isso ficou ótimo! Acho que usar o Kubernetes seria uma ótima maneira de adotarmos uma estratégia de microsserviços mais ampla.