Criar e implantar no Serviço Kubernetes do Azure usando o Azure Pipelines

Serviços de DevOps do Azure

Utilize Azure Pipelines para efetuar a implantação 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 altera o código num repositório que contém um Dockerfile, as imagens são enviadas para o Registo de Contentores do Azure, e os manifestos são então implantados no cluster AKS.

Prerequisites

• 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 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 os 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

# 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

# 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

Iniciar sessão no Azure Pipelines

Entre no Azure Pipelines. Depois de iniciar sessão, o seu navegador vai para https://dev.azure.com/my-organization-name e exibe o seu dashboard 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 a linha de produção

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 seu 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 cluster myapp.

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. Marque a caixa de seleção Habilitar aplicativo de revisão para pull requests para que a configuração relacionada ao aplicativo de revisão seja incluída no pipeline YAML gerado automaticamente nas etapas subsequentes.

15. Selecione Validar e configurar.

    Enquanto o Azure Pipelines cria o seu pipeline, o processo:

    • Crie uma ligação de serviço de registo do Docker para permitir que a sua pipeline carregue imagens para o registo de contentores.

    • 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 ficheiros são gerados pelo preenchimento dos modelos deployment.yml e service.yml com base nas seleções que efetuou. 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!

Veja a implementação da sua aplicação

À 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 tarefas para observar o seu pipeline em funcionamento.

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 tu usaste os padrões, então trata-se do aplicativo myapp no namespace padrão.

4. Selecione a guia Serviços .

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

6. Abra um novo separador ou janela no 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 elementos necessários de que os nós do cluster Kubernetes precisam para extrair do recurso Registro de Contêiner do Azure. Os ficheiros de manifesto são então usados pela tarefa de manifesto do Kubernetes para implementar no cluster do Kubernetes. Os ficheiros de manifesto, service.yml e deployment.yml, foram gerados quando utilizou o modelo Implementar 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)'

Limpeza de 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.