Compile e implante no Serviço de Kubernetes do Azure com o Azure Pipelines

Azure DevOps Services

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

Neste artigo, aprenda a criar um pipeline que compila 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 ao Registro de Contêiner do Azure e os manifestos são implantados em seu cluster do AKS.

Pré-requisitos

• Uma conta do Azure com uma assinatura 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 do GitHub. Crie uma conta do GitHub gratuitamente, caso ainda não tenha uma.

Obter o código

Crie fork para o seguinte repositório contendo um aplicativo de exemplo e um Dockerfile:

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

Criar os recursos do Azure

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

Criar um registro de contêiner

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, o navegador vai para https://dev.azure.com/my-organization-name e exibe o painel do Azure DevOps.

Na 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

Conectar e selecionar seu repositório

1. Entre na organização do Azure DevOps e acesse seu projeto.

2. Acesse Pipelines e selecione Novo pipeline.

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

4. Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.

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

6. Você poderá ser redirecionado ao GitHub para instalar o aplicativo do Azure Pipelines. Se sim, selecione Aprovar e instalar.

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

8. Se for solicitado, selecione a assinatura na qual você criou o registro e o cluster.

9. Selecione o cluster myapp.

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

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

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

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

14. Marque a caixa de seleção Habilitar aplicativo de revisão para solicitações de pull para que a configuração relacionada ao aplicativo de revisãoseja incluída no YAML gerado automaticamente pelo YAML nas etapas subsequentes.

15. Selecione Validate and configure.

    Conforme o Azure Pipelines cria o pipeline, o processo fará o seguinte:

    • Criará uma conexão de serviço do registro do Docker para permitir que o pipeline envie imagens ao registro de contêiner.

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

    • Gerará um arquivo azure-pipelines.yml que definirá seu pipeline.

    • Gerará arquivos de manifesto do Kubernetes. Esses arquivos são gerados por meio da hidratação dos modelos deployment.yml e service.yml com base nas seleções feitas. Ao final, selecione Salvar e executar.

16. Selecione Salvar e executar.

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

Ver a implantação do aplicativo

À medida que o pipeline é executado, observe como o estágio de compilação e, em seguida, o estágio de implantação mudam a cor de azul (em execução) para verde (concluído). É possível selecionar os estágios e trabalhos para observar seu pipeline em ação.

Observação

Com um agente hospedado pela Microsoft, você deve adicionar o intervalo de IP dele ao firewall. Obtenha a lista semanal de intervalos de IP no arquivo JSON semanal, que é publicado toda quarta-feira. Os novos intervalos de IP entram em vigor na segunda-feira seguinte. Para saber mais, confira Agentes hospedados pela Microsoft. Para encontrar os intervalos de IP necessários para sua organização do Azure DevOps, saiba como identificar os intervalos de IP possíveis para agentes hospedados pela Microsoft.

Depois da execução do pipeline, veja o que aconteceu e o aplicativo implantado. No resumo do pipeline:

1. Selecione a guia Ambientes.

2. Selecione Exibir ambiente.

3. Selecione a instância do aplicativo para o namespace no qual ele foi implantado. Se você usou os padrões, é 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 uma nova guia ou janela do navegador e digite <Endereço IP>:8080.

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

Como o pipeline é compilado

Quando você selecionou as opções e, em seguida, validou e configurou o pipeline, o Azure Pipelines criou um pipeline para você com o modelo Implantar no Serviço de Kubernetes do Azure.

O estágio de compilação usa a tarefa do Docker para criar e enviar a imagem ao 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 o imagePullSecret necessário para os nós de cluster do Kubernetes a fim de efetuar pull do recurso do Registro de Contêiner do Azure. Em seguida, os arquivos de manifesto são usados ​​pela tarefa de manifesto do Kubernetes na implantação no cluster do Kubernetes. Os arquivos de manifesto, service.yml e deployment.yml, foram gerados quando você usou o modelo Implantar no Serviço de 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)'

Limpar os recursos

Ao concluir a criação de recursos, você pode usar o seguinte comando para excluí-los:

az group delete --name myapp-rg

Insira y quando solicitado.