Criar e implementar no Azure Kubernetes Service com o Azure Pipelines

Serviços de DevOps do Azure

Use o Azure Pipelines para implantar automaticamente no Serviço Kubernetes do Azure (AKS). O Azure Pipelines permite criar, testar e implantar com integração contínua (CI) e entrega contínua (CD) usando o Azure DevOps.

Neste artigo, você aprenderá a criar um pipeline que cria e implanta continuamente seu aplicativo. Sempre que você altera seu código em um repositório que contém um Dockerfile, as imagens são enviadas por push para o Registro de Contêiner do Azure e os manifestos são implantados no cluster AKS.

Pré-requisitos

• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
• Uma conexão de serviço do Azure Resource Manager. Crie uma conexão de serviço do Azure Resource Manager.
• Uma conta GitHub. Crie uma conta gratuita no GitHub, se ainda não tiver uma.

Obter o código

Fork o seguinte repositório contendo um aplicativo de exemplo e um Dockerfile:

https://github.com/MicrosoftDocs/pipelines-javascript-docker

Criar recursos do Azure

Entre no portal do Azure e selecione o botão Cloud Shell no canto superior direito. Use a CLI do Azure ou o PowerShell para criar um cluster AKS.

Criar um registo de contentores

CLI do Azure

# Create a resource group
az group create --name myapp-rg --location eastus

# Create a container registry
az acr create --resource-group myapp-rg --name mycontainerregistry --sku Basic

# Create a Kubernetes cluster
az aks create \
    --resource-group myapp-rg \
    --name myapp \
    --node-count 1 \
    --enable-addons monitoring \
    --generate-ssh-keys

PowerShell

# Install Azure PowerShell
Install-Module -Name Az -Repository PSGallery -Force

# The Microsoft.OperationsManagement resource provider must be registered. This is a one-time activity per subscription.
Register-AzResourceProvider -ProviderNamespace Microsoft.OperationsManagement

# Create a resource group
New-AzResourceGroup -Name myapp-rg -Location eastus

# Create a container registry
New-AzContainerRegistry -ResourceGroupName myapp-rg -Name myContainerRegistry -Sku Basic -Location eastus

# Create a log analytics workspace (or use an existing one)
New-AzOperationalInsightsWorkspace -ResourceGroupName myapp-rg -Name myWorkspace -Location eastus

# Create an AKS cluster with monitoring add-on enabled
$aksParameters = @{ 
  ResourceGroupName = 'myapp-rg'
  Name = 'myapp'
  NodeCount = 1
  AddOnNameToBeEnabled = 'Monitoring'
  GenerateSshKey = $true
  WorkspaceResourceId = '/subscriptions/<subscription-id>/resourceGroups/myapp-rg/providers/Microsoft.OperationalInsights/workspaces/myWorkspace'
}

New-AzAksCluster @aksParameters

Entrar no Azure Pipelines

Entre no Azure Pipelines. Depois de entrar, seu navegador vai e https://dev.azure.com/my-organization-name exibe seu painel do Azure DevOps.

Dentro da organização selecionada, crie um projeto. Se você não tiver nenhum projeto em sua organização, verá uma tela Criar um projeto para começar . Caso contrário, selecione o botão Criar projeto no canto superior direito do painel.

Criar o pipeline

Conecte-se e selecione seu repositório

1. Entre na sua organização do Azure DevOps e vá para o seu projeto.

2. Vá para Pipelines e selecione Novo pipeline.

3. Siga as etapas do assistente selecionando primeiro o GitHub como o local do código-fonte.

4. Poderá ser redirecionado para o GitHub para iniciar sessão. Em caso afirmativo, insira suas credenciais do GitHub.

5. Quando vir a lista de repositórios, selecione o repositório.

6. Você pode ser redirecionado para o GitHub para instalar o aplicativo Azure Pipelines. Em caso afirmativo, selecione Aprovar e instalar.

7. Selecione Implantar no Serviço Kubernetes do Azure.

8. Se lhe for pedido, selecione a subscrição na qual criou o registo e o cluster.

9. Selecione o myapp cluster.

10. Em Namespace, selecione Existente e, em seguida, selecione padrão.

11. Selecione o nome do seu registro de contêiner.

12. Você pode deixar o nome da imagem definido como padrão.

13. Defina a porta de serviço como 8080.

14. Defina a caixa de seleção Habilitar aplicativo de revisão para solicitações pull para revisar a configuração relacionada ao aplicativo a ser incluída no pipeline YAML gerado automaticamente nas etapas subsequentes.

15. Selecione Validar e configurar.

    À medida que o Azure Pipelines cria seu pipeline, o processo:

    • Crie uma conexão de serviço de registro do Docker para permitir que seu pipeline envie imagens por push para o registro de contêiner.

    • Crie um ambiente e um recurso Kubernetes dentro do ambiente. Para um cluster habilitado para RBAC, o recurso Kubernetes criado cria implicitamente objetos ServiceAccount e RoleBinding no cluster para que o ServiceAccount criado não possa executar operações fora do namespace escolhido.

    • Gere um arquivo azure-pipelines.yml , que define seu pipeline.

    • Gere arquivos de manifesto do Kubernetes. Esses arquivos são gerados pela hidratação do deployment.yml e service.yml modelos com base nas seleções que você fez. Quando estiver pronto, selecione Salvar e executar.

16. Selecione Guardar e executar.

17. Você pode alterar a mensagem de confirmação para algo como Adicionar pipeline ao nosso repositório. Quando estiver pronto, selecione Salvar e executar para confirmar o novo pipeline no repositório e, em seguida, comece a primeira execução do novo pipeline!

Ver a implantação do seu aplicativo

À medida que o pipeline é executado, observe o estágio de construção e, em seguida, o estágio de implantação, passe de azul (em execução) para verde (concluído). Você pode selecionar os estágios e trabalhos para observar seu pipeline em ação.

Nota

Se estiver a utilizar um agente alojado pela Microsoft, terá de adicionar o intervalo de IP do mesmo à firewall. Obtenha a lista semanal de intervalos de IP no ficheiro JSON semanal, publicado todas as quartas-feiras. Os novos intervalos de IP entram em vigor na segunda-feira seguinte. Para obter mais informações, veja Agentes alojados na Microsoft. Para encontrar os intervalos de IP necessários para a sua organização do Azure DevOps, saiba como identificar os possíveis intervalos de IP para os agentes alojados na Microsoft.

Depois que a execução do pipeline for concluída, explore o que aconteceu e vá ver seu aplicativo implantado. Do resumo do pipeline:

1. Selecione o separador Ambientes.

2. Selecione Exibir ambiente.

3. Selecione a instância do seu aplicativo para o namespace no qual você implantou. Se você usou os padrões, então é o aplicativo myapp no namespace padrão .

4. Selecione a guia Serviços .

5. Selecione e copie o endereço IP externo para a área de transferência.

6. Abra um novo separador ou janela do navegador e introduza <o endereço> IP:8080.

Se você estiver criando nosso aplicativo de exemplo, o Hello world aparecerá em seu navegador.

Como o pipeline é construído

Quando você terminou de selecionar as opções e, em seguida, continuou a validar e configurar o pipeline, o Azure Pipelines criou um pipeline para você, usando o modelo Implantar no Serviço Kubernetes do Azure.

O estágio de compilação usa a tarefa do Docker para criar e enviar a imagem para o Registro de Contêiner do Azure.

- stage: Build
  displayName: Build stage
  jobs:  
  - job: Build
    displayName: Build job
    pool:
      vmImage: $(vmImageName)
    steps:
    - task: Docker@2
      displayName: Build and push an image to container registry
      inputs:
        command: buildAndPush
        repository: $(imageRepository)
        dockerfile: $(dockerfilePath)
        containerRegistry: $(dockerRegistryServiceConnection)
        tags: |
          $(tag)
          
    - task: PublishPipelineArtifact@1
      inputs:
        artifactName: 'manifests'
        path: 'manifests'

O trabalho de implantação usa a tarefa de manifesto do Kubernetes para criar os nós de cluster do imagePullSecret Kubernetes necessários para extrair do recurso Registro de Contêiner do Azure. Os arquivos de manifesto são usados pela tarefa de manifesto do Kubernetes para implantar no cluster do Kubernetes. Os arquivos service.yml de manifesto e deployment.ymlo , foram gerados quando você usou o modelo Implantar no Serviço Kubernetes do Azure.

- stage: Deploy
  displayName: Deploy stage
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy job
    pool:
      vmImage: $(vmImageName)
    environment: 'myenv.aksnamespace' #customize with your environment
    strategy:
      runOnce:
        deploy:
          steps:
          - task: DownloadPipelineArtifact@2
            inputs:
              artifactName: 'manifests'
              downloadPath: '$(System.ArtifactsDirectory)/manifests'

          - task: KubernetesManifest@1
            displayName: Create imagePullSecret
            inputs:
              action: 'createSecret'
              connectionType: 'kubernetesServiceConnection'
              kubernetesServiceConnection: 'myapp-default' #customize for your Kubernetes service connection
              secretType: 'dockerRegistry'
              secretName: '$(imagePullSecret)'
              dockerRegistryEndpoint: '$(dockerRegistryServiceConnection)'

          - task: KubernetesManifest@1
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: 'deploy'
              connectionType: 'kubernetesServiceConnection'
              kubernetesServiceConnection: 'myapp-default' #customize for your Kubernetes service connection
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              containers: '$(containerRegistry)/$(imageRepository):$(tag)'
              imagePullSecrets: '$(imagePullSecret)'

Clean up resources (Limpar recursos)

Sempre que terminar de usar os recursos criados, você pode usar o seguinte comando para excluí-los:

az group delete --name myapp-rg

Digite y quando for solicitado.