Partilhar via

Criar e implementar no Azure Kubernetes Service com o Azure Pipelines

  • Artigo

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

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

# 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

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@0
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              secretName: $(imagePullSecret)
              namespace: $(k8sNamespace)
              dockerRegistryEndpoint: $(dockerRegistryServiceConnection)

          - task: KubernetesManifest@0
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: deploy
              namespace: $(k8sNamespace)
              manifests: |
                $(System.ArtifactsDirectory)/manifests/deployment.yml
                $(System.ArtifactsDirectory)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(containerRegistry)/$(imageRepository):$(tag)

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.

Serviços de DevOps do Azure | Azure DevOps Server 2020 | Azure DevOps Server 2019

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

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

# 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

Configurar a autenticação

Ao usar o Registro de Contêiner do Azure (ACR) com o Serviço Kubernetes do Azure (AKS), você deve estabelecer um mecanismo de autenticação. Isto pode ser conseguido de duas formas:

  1. Conceda acesso ao AKS ao ACR. Consulte Autenticar com o Registro de Contêiner do Azure do Serviço Kubernetes do Azure.

  2. Use um segredo de pull de imagem do Kubernetes. Um segredo de pull de imagem pode ser criado usando a tarefa de implantação do Kubernetes.

Criar um pipeline de versão

O pipeline de compilação usado para configurar a CI já criou uma imagem do Docker e a enviou por push para um Registro de Contêiner do Azure. Ele também empacotou e publicou um gráfico de Helm como um artefato. No pipeline de lançamento, implantaremos a imagem do contêiner como um aplicativo Helm no cluster AKS.

  1. No Azure Pipelines , abra o resumo da sua compilação.

  2. No resumo da compilação, escolha o ícone Liberar para iniciar um novo pipeline de versão.

    Se você tiver criado anteriormente um pipeline de liberação que usa esses artefatos de compilação, será solicitado que você crie uma nova versão. Nesse caso, vá para a página Lançamentos e inicie um novo pipeline de lançamento a partir daí, escolhendo o + ícone.

  3. Selecione o modelo de trabalho vazio.

  4. Abra a página Tarefas e selecione Trabalho do agente.

  5. Escolha + adicionar uma nova tarefa e adicionar uma tarefa do instalador da ferramenta Helm. Isso garante que o agente que executa as tarefas subsequentes tenha o Helm e o Kubectl instalados.

  6. Escolha + novamente e adicione uma tarefa Package and deploy Helm charts . Configure as configurações para esta tarefa da seguinte maneira:

    • Tipo de Conexão: Selecione o Azure Resource Manager para se conectar a um cluster AKS usando uma conexão de serviço do Azure. Como alternativa, se você quiser se conectar a qualquer cluster Kubernetes usando kubeconfig ou uma conta de serviço, você pode selecionar Conexão de serviço Kubernetes. Nesse caso, você precisará criar e selecionar uma conexão de serviço do Kubernetes em vez de uma assinatura do Azure para a configuração a seguir.

    • Assinatura do Azure: selecione uma conexão na lista em Conexões de Serviço do Azure Disponíveis ou crie uma conexão de permissões mais restrita à sua assinatura do Azure. Se você vir um botão Autorizar ao lado da entrada, use-o para autorizar a conexão com sua assinatura do Azure. Se não vir a subscrição do Azure necessária na lista de subscrições, consulte Criar uma ligação de serviço do Azure para configurar manualmente a ligação.

    • Grupo de recursos: insira ou selecione o grupo de recursos que contém o cluster AKS.

    • Cluster Kubernetes: insira ou selecione o cluster AKS que você criou.

    • Comando: Selecione init como o comando Helm. Isso instala o Tiller no cluster Kubernetes em execução. Ele também irá configurar qualquer configuração local necessária. Marque Use a versão de imagem canária para instalar a versão de pré-lançamento mais recente do Tiller. Você também pode optar por atualizar o Tiller se ele estiver pré-instalado marcando Upgrade Tiller. Se essas opções estiverem habilitadas, a tarefa será executada helm init --canary-image --upgrade

  7. Escolha + o trabalho Agente e adicione outra tarefa Pacote e implante gráficos de leme. Configure as configurações para esta tarefa da seguinte maneira:

    • Cluster Kubernetes: insira ou selecione o cluster AKS que você criou.

    • Namespace: insira seu namespace de cluster do Kubernetes onde você deseja implantar seu aplicativo. O Kubernetes suporta vários clusters virtuais apoiados pelo mesmo cluster físico. Esses clusters virtuais são chamados de namespaces. Você pode usar namespaces para criar ambientes diferentes, como desenvolvimento, teste e preparo no mesmo cluster.

    • Comando: Selecione atualizar como o comando Helm. Você pode executar qualquer comando Helm usando esta tarefa e passar opções de comando como argumentos. Quando você seleciona a atualização, a tarefa mostra mais alguns campos:

      • Tipo de gráfico: Selecione Caminho do arquivo. Como alternativa, você pode especificar Nome do gráfico se quiser especificar uma URL ou um nome de gráfico. Por exemplo, se o nome do gráfico for stable/mysql, a tarefa será executada helm upgrade stable/mysql

      • Caminho do gráfico: pode ser um caminho para um gráfico empacotado ou um caminho para um diretório de gráfico descompactado. Neste exemplo, você está publicando o gráfico usando uma compilação de CI, portanto, selecione o pacote de arquivos usando o seletor de arquivos ou insira $(System.DefaultWorkingDirectory)/**/*.tgz

      • Nome da versão: insira um nome para o seu lançamento, por exemplo, azuredevops

      • Recriar pods: marque esta caixa de seleção se houver uma alteração de configuração durante o lançamento e você quiser substituir um pod em execução pela nova configuração.

      • Redefinir valores: marque esta caixa de seleção se quiser que os valores incorporados no gráfico substituam todos os valores fornecidos pela tarefa.

      • Forçar: Marque esta caixa de seleção se, caso ocorram conflitos, você quiser atualizar e reverter para excluir, recriar o recurso e reinstalar a versão completa. Isso é útil em cenários em que a aplicação de patches pode falhar (por exemplo, para serviços porque o endereço IP do cluster é imutável).

      • Argumentos: insira os argumentos do comando Helm e seus valores; --set image.repository=$(imageRepoName) --set image.tag=$(Build.BuildId) Consulte esta seção para obter uma descrição do motivo pelo qual estamos usando esses argumentos.

      • Ativar TLS: marque esta caixa de seleção para habilitar conexões fortes baseadas em TLS entre Helm e Tiller.

      • Certificado de autoridade de certificação: especifique um certificado de autoridade de certificação a ser carregado e usado para emitir certificados para o cliente Tiller e Helm.

      • Certificado: Especifique o certificado Tiller ou o certificado do cliente Helm

      • Chave: Especifique a chave Tiller ou a chave do cliente Helm

  8. Na página Variáveis do pipeline, adicione uma variável chamada imageRepoName e defina o valor como o nome do repositório de imagens Helm. Normalmente, isso está no formato example.azurecr.io/coderepository

  9. Salve o pipeline de liberação.

Argumentos usados na tarefa de atualização do Helm

No pipeline de compilação, a imagem do contêiner é marcada com $(Build.BuildId) e isso é enviado por push para um Registro de Contêiner do Azure. Em um gráfico Helm, você pode parametrizar os detalhes da imagem do contêiner, como o nome e a marca, porque o mesmo gráfico pode ser usado para implantar em ambientes diferentes. Esses valores também podem ser especificados no arquivo values.yaml ou ser substituídos por um arquivo de valores fornecido pelo usuário, que por sua vez pode ser substituído por --set parâmetros durante a instalação ou atualização do Helm.

Neste exemplo, passamos os seguintes argumentos:

--set image.repository=$(imageRepoName) --set image.tag=$(Build.BuildId)

O valor de $(imageRepoName) foi definido na página Variáveis (ou na seção de variáveis do seu arquivo YAML). Como alternativa, você pode substituí-lo diretamente pelo nome do repositório de imagens no valor arguments --set ou no arquivo values.yaml . Por exemplo:

  image:
    repository: VALUE_TO_BE_OVERRIDDEN
    tag: latest

Outra alternativa é definir a opção Definir valores da tarefa para especificar os valores de argumento como pares chave-valor separados por vírgula.

Criar uma versão para implantar seu aplicativo

Agora você está pronto para criar uma versão, o que significa iniciar o processo de execução do pipeline de liberação com os artefatos produzidos por uma compilação específica. Isso resulta na implantação da compilação:

  1. Escolha + Liberar e selecione Criar uma versão.

  2. No painel Criar uma nova versão, verifique se a versão do artefato que você deseja usar está selecionada e escolha Criar.

  3. Escolha o link de liberação na mensagem da barra de informações. Por exemplo: "Release Release-1 foi criado".

  4. Na visualização do pipeline, escolha o link de status nos estágios do pipeline para ver os logs e a saída do agente.