Azure Pipelines Tutorial: Um guia completo de CI/CD para iniciantes

Se o seu pipeline de CI/CD continua quebrando ou parece lento e desajeitado, você não está sozinho. Já lidei com compilações que falharam, ambientes incompatíveis e colegas de equipe que acidentalmente sobrescreveram meu trabalho. O Azure Pipelines elimina essas frustrações com um serviço hospedado na nuvem que pode criar, testar e implantar quase todos os projetos em qualquer plataforma.

Por isso, neste tutorial, mostrarei a você como fazer isso:

1. Crie seu primeiro pipeline do Azure
2. Crie seu projeto na nuvem
3. Adicione testes automatizados para detectar erros com antecedência
4. Implemente na fase de preparação ou produção com um único envio
5. Monitore e otimize seu pipeline para obter velocidade e confiabilidade
6. Siga as práticas recomendadas comprovadas em projetos do mundo real

Vamos começar!

O que é o Azure Pipelines?

O Azure Pipelines é uma solução baseada em nuvem que simplifica o desenvolvimento, o teste e a implantação de aplicativos. 

Ele é um componente do kit de ferramentas Azure DevOps, que oferece suporte a todo o ciclo de vida de desenvolvimento de software. Também é uma opção flexível para equipes de todos os tamanhos, pois é compatível com várias plataformas e linguagens de programação. O GitHub, o Azure Repos e outros sistemas de controle de versão conhecidos estão integrados a ele. 

Os principais recursos do Azure Pipelines incluem: 

Na minha experiência, o Azure Pipelines é útil para quem deseja ter uma operação de CI/CD em sua equipe. Ele é flexível, dimensionável e se integra bem a outros serviços do Azure.

Arquitetura do Azure Pipelines (Fonte: Microsoft).

Se você está procurando uma compreensão mais ampla do Azure DevOps além dos pipelines, este tutorial do Azure DevOps vocêvocê conhecerá todo o ciclo de vida de CI/CD do início ao fim.

Configurando seu primeiro pipeline do Azure

Para trabalhar com o ambiente do Azure Pipelines, primeiro precisamos configurar tudo para promover um processo de criação, teste e implantação de ponta a ponta.

Pré-requisitos

Antes de começar a criar seu primeiro pipeline, verifique se você tem o seguinte:

1. Configuração da conta e da organização do Azure DevOps: Inscreva-se empara obter uma conta do Azure DevOpsnt se você ainda não tiver uma. Crie uma organização para gerenciar seus projetos. 
2. Repositório: Você precisará de um repositório de código com um projeto de amostra. Isso pode ser hospedado no Azure Repos ou no GitHub. Para este tutorial, usaremos um projeto Node.js simples.
3. Acesso ao portal do Azure: Você também precisará acessar o portal do Azure quando quiser implantar serviços do Azure, como o Azure Kubernetes Service (AKS) e muitos outros.

Se você precisar se atualizar sobre o ecossistema mais amplo do Azure, recomendo que confira o curso Understanding Microsoft Azure. 

Criando um novo projeto e repositório

Agora que sua conta e organização do Azure DevOps estão configuradas, vamos criar nosso primeiro projeto e repositório.

• Crie um novo projeto:
  • Faça login na sua conta do Azure DevOps.
  • Clique em Novo projeto, dê um nome a ele (por exemplo, "AzureDevOps-DataCamp-Tutorial") e escolha a visibilidade (pública ou privada).
  • Clique em Criar projeto.

• Configure um repositório:
  • Se você estiver usando o Azure Repos, navegue até a seçãoRepos e inicialize um novo repositório.
  • Como alternativa, você pode vincular um repositório existente do GitHub selecionando Importar repositório.
  • Dê um nome ao seu repositório, escolha o tipo de repositório (Git ou TFVC), cole a URL do repositório clonado e clique em Importar.

• Se você estiver usando o GitHubvocê pode vincular sua conta do GitHub ao Azure DevOps indo para o canto inferior esquerdo da interface do projeto e selecionando Configurações do projeto > Conexões do GitHub > Conectar sua conta do GitHub.

Para este tutorial, usaremos o Azure Repos como nosso repositório de código. Se você estiver apenas começando ou não tiver um motivo específico para escolher a TFVC, aconselho que escolha a Git.

Criando seu primeiro pipeline

É hora de criar nosso primeiro pipeline. Siga as etapas abaixo:

• Em você Pipelines clique em Criar pipeline.

• Selecione Repositórios do Azure Git como a fonte e escolha seu repositório.

• Você pode configurar seu pipeline usando o editor YAML ou Classic. Vamos usar o YAML, uma forma baseada em código de definir o pipeline.
• Salve o pipeline e execute-o para ver se tudo funciona corretamente.

Escolhendo o YAML em vez do editor clássico

O Azure Pipelines oferece duas maneiras de você definir seus pipelines:

• Pipelines YAML: Uma maneira baseada em código para descrever seu pipeline. Eles são definidos em um arquivo .yaml ou .yml em seu repositório de origem, permitindo o controle de versão e uma melhor colaboração.
• Editor clássico: O Classic Editor é uma interface visual de arrastar e soltar fácil de usar que é menos flexível para cenários complexos.

Na minha experiência, os pipelines YAML oferecem mais flexibilidade e são melhores para as equipes queseguem as práticas de IaC (Infrastructure as Code). Mas esse Editor Clássico é perfeito para você que está se renovando e tem uma maneira mais visual de fazer as coisas. 

No entanto, para escalabilidade de longo prazo, os pipelines YAML são recomendados em vez do Classic Editor.

Criando com o Azure Pipelines

Agora, vamos ver como podemos criar com o Azure Pipelines. 

Nesta seção, especificaremos as etapas que o Azure Pipelines executa para criar seu código, como a instalação de dependências, a compilação e a execução de testes. Vamos expressar essas etapas em um arquivo de configuração em nosso repositório de código-fonte usando YAML, uma forma simples e legível para descrever as etapas de uma receita.

Sintaxe do pipeline YAML

Aqui está um exemplo simples de um pipeline YAML:

# This section defines the trigger(s) for the pipeline.
# 'main' specifies that the pipeline will run whenever changes are pushed to the 'main' branch.
trigger:
- main  # automatically triggers this pipeline when changes are made to the 'main' branch.

# This defines the pool where the pipeline will run.
# 'ubuntu-latest' specifies the virtual machine image for executing tasks.
pool:
  vmImage: 'ubuntu-latest'  # This uses the latest Ubuntu image provided by Azure DevOps.

# Steps contain the individual tasks or actions that the pipeline will execute.
steps:
- script: echo Hello, world!  # A script task to run shell commands. This one prints "Hello, world!".
  displayName: 'Run my first pipeline script'  # A friendly name for this step, making it easier to identify in the pipeline logs.

Vamos detalhar o código passo a passo:

• trigger: Especifica a ramificação que aciona o pipeline (por exemplo, main).
• pool: Define o agente de compilação (por exemplo, ubuntu-latest).
• steps: Lista as tarefas a serem executadas, como a instalação de dependências e a execução de um script de compilação.

Configuração das etapas de compilação

Para adicionar etapas de compilação ao seu pipeline YAML, você deve definir o "script" na seção "etapas".

Para um aplicativo Node.js simples, por exemplo, nosso arquivo azure-pipelines.yml abaixo contém código que o Azure DevOps criou automaticamente.

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'

Vamos dar uma olhada na compilação steps no pipeline YAML acima: 

1. Instale o Node.js: Use a tarefa NodeTool@0 para especificar a versão do Node.js. 
2. Instale as dependências: Execute npm install para instalar as dependências do projeto. 
3. Compilar o código (criar o projeto): Execute npm run build para compilar o código. 

Executando o pipeline

Nosso pipeline pode ser acionado manualmente ou configurado para ser executado automaticamente quando ocorrerem eventos como o envio de ramificações.

• Gatilho manual: Clique em Run Pipeline na interface do Azure DevOps para acionar o pipeline manualmente.

• Gatilho automático: Configure acionadores com base em eventos do repositório para enviar alterações para a ramificação main e acionar o pipeline automaticamente. Aqui está um exemplo:

trigger:
- main

Depois de executar o pipeline, você pode visualizar os logs e solucionar problemas.

Para acessar os registros, vá para o resumo da execução do pipeline e selecione o trabalho ou a tarefa específica. Isso exibirá os logs dessa etapa; assim como na imagem abaixo, você pode escolher qualquer trabalho (Build, Push ou Update) para visualizar os logs brutos.

Para solucionar problemas comuns, você pode verificar se há problemas comuns no pipeline, como tempos limite, restrições de recursos ou configurações incorretas.

Adicionando testes ao seu pipeline

Você adiciona testes ao seu pipeline para garantir a qualidade do código e detectar problemas no início do desenvolvimento. No Azure Pipelines, você pode integrar unidades, integração ou outros testes adicionando etapas na configuração do pipeline.

Configuração das etapas de teste

Inclua etapas de teste em seu pipeline para garantir a qualidade do código. Você pode usar estruturas populares como Jest, Mocha ou NUnit. Por exemplo, veja como você pode adicionar testes de unidade com o Jest:

- script: |
    npm test
  displayName: 'Run unit tests with Jest'

Visualização dos resultados do teste

Há relatórios de teste incorporados no Azure Pipelines. Você pode configurar a publicação do resultado do teste para simplificar o acompanhamento e visualizar os resultados do teste nos logs do pipeline. É assim que você faz:

• Primeiro, navegue até Builds > Resultados do teste.
• Para publicar os resultados do teste, use a tarefa PublishTestResults@2 para exibir os resultados. Isso torna o programa geral mais fácil. Por exemplo:

- task: PublishTestResults@2
  inputs:
    testResultsFiles: '**/test-results.xml'
    testRunTitle: 'Unit Tests'

Implantação com o Azure Pipelines

Nas etapas de implantação do arquivo YAML do pipeline do Azure, você pode implantar automaticamente seu aplicativo em vários ambientes, como teste, preparação e produção. Nesta seção, analisaremos algumas maneiras de implantar com o Azure Pipelines.

Implantando no Azure Web Apps

O Azure Web Apps é um serviço no Portal do Azure que permite que você desenvolva, implante e gerencie aplicativos Web em escala. 

Para implantar no Azure Web Apps, você deve vincular os dois serviços. Veja como você pode fazer isso:

• Na parte inferior esquerda do seu projeto, vá para Configurações do projeto e clique em Conexões de serviço sob a seção Pipelines seção.

• Clique em Nova conexão de serviço e escolha Gerenciador de recursos do Azure.

• Faça a autenticação com sua conta do Azure.
• Implante no Serviço de Aplicativo do Azure:
  • Volte para os pipelines e configure o pipeline.
  • Em seu pipeline, adicione uma tarefa para implantar no Azure.
  • Especifique o grupo de recursos e os detalhes do serviço. 

Aqui está um exemplo de um pipeline de implantação YAML para um aplicativo Node.js simples no Azure App Service:

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1
  inputs:
    # This specifies your Azure subscription service connection
    azureSubscription: 'your-azure-subscription'
    # This specifies the name of your web app
    appName: 'your-app-name'
    # This specifies the location of the app package or files to be deployed
    package: '$(Build.ArtifactStagingDirectory)'

Vamos detalhar o código acima para que você possa adaptá-lo ao seu caso de uso:

• Substitua your-azure-subscription pelo nome da conexão de serviço que dá acesso à sua assinatura do Azure.
• Substitua your-app-name pelo nome real do seu aplicativo Web no Azure. 
• Substitua $(Build.ArtifactStagingDirectory) pelo diretório no qual você colocará o pacote ou os arquivos do aplicativo Web para implementação. $(Build.ArtifactStagingDirectory) - Essa variável aponta para a pasta onde os artefatos de compilação (os arquivos do aplicativo) ficam depois de terem sido compilados.

Configuração da implantação contínua (CD)

Depois que tudo em nosso código for aprovado em todos os testes e verificações, a próxima etapa é configurar a implantação contínua. Siga as etapas descritas abaixo.

Modelo de implantação do pipeline de versão do Azure (Fonte: Microsoft)

• Crie um pipeline de lançamento:
• Ir para Pipelines > Releases e clique em New Pipeline.

• Selecione a Implantação do serviço de aplicativos do Azure modelo.

• Configurar ambientes:
• Adicionar e configurar Dispositivo, Preparação, QAe Produção ambientes onde você deseja que o aplicativo seja implantado.

• Vincule o artefato do seu pipeline de compilação como a fonte para o pipeline de liberação, selecionando Adicionar um artefato.

• Configure aprovações e portões:
• É necessário configurar aprovações de pré-implantação para ambientes sensíveis, como ambientes de produção. Por exemplo, pode ser necessário que um líder de equipe aprove a liberação. Você também pode adicionar portas como testes automatizados ou verificações de monitoramento para garantir que a implementação atenda aos padrões de qualidade.

Em minha experiência, essa fase é necessária para manter a estabilidade em ambientes de desenvolvimento exigentes. As aprovações e os portões proporcionam controle e garantem que somente códigos de alta qualidade cheguem à produção.

Implementação no Kubernetes

O Kubernetes facilita a execução de aplicativos em contêineres confiáveis e dimensionáveis. Ao usar o Azure Kubernetes Service (AKS), você obtém um ambiente gerenciado que simplifica a implantação e as operações. Nesta seção, mostrarei como implantar seu aplicativo no AKS usando o Azure Pipelines.

Prepare seu cluster AKS

Você pode criar um cluster AKS usando o portal do Azure ou a CLI. Aqui está um comando básico da CLI do Bash para provisionar o cluster:

az aks create \
  --resource-group <ResourceGroupName> \
  --name <AKSClusterName> \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

Vamos detalhar o comando acima:

• --resource-group: Isso indica o grupo de recursos do Azure no qual o cluster AKS será criado.
• --name: Refere-se ao nome do seu cluster AKS.
• --node-count: Isso define o número de nós no cluster (por exemplo, 3 neste exemplo).
• --enable-addons monitoring: Isso torna possível o monitoramento e a análise com o Azure Monitor para Contêineres.
• --generate-ssh-keys: Isso gera automaticamente chaves SSH para acesso seguro ao nó, se você não as fornecer.

Não se esqueça de substituir e pelos nomes reais do grupo de recursos e do cluster.

O Kubectl precisa ser configurado depois que o cluster AKS for configurado. Isso garante que o agente do pipeline ou o computador local possa usar o site kubectl para se comunicar com o cluster.

Você pode acelerar suas tarefas do Azure usando a linha de comando paravocê pode acelerar suas tarefas do Azure usando a linha de comando - esta folha de dicas da CLI do Azure é uma referência útil.

Criar um arquivo YAML de implantação 

Vamos usar como exemplo um arquivo YAML de implantação básica para implantar uma imagem do Docker no Kubernetes:

# This defines the API version and the kind of Kubernetes resource we are creating.
# 'apps/v1' is the API version, and 'Deployment' is the resource type.
apiVersion: apps/v1
kind: Deployment

# Metadata contains information to identify the resource uniquely.
# 'name' specifies the name of the Deployment.
metadata:
  name: my-app  # Name of the Deployment, used for identification.

# "spec" specifies the intended deployment state.
spec:
  # Number of replicas/pods we want for this Deployment.
  replicas: 3  # Ensures high availability by running three app replicas.

  # Selector is used to define the labels that this Deployment will manage.
  selector:
    matchLabels:
      app: my-app  # This ensures that only Pods with the label 'app: my-app' are managed by this Deployment.

  # Template specifies the blueprint for the pods created by the Deployment.
  template:
    metadata:
      labels:
        app: my-app  # Labels for the Pods, matching the selector above.

    # A specification for the containers of the Pods.
    spec:
      containers:
      - name: my-app  # Name of the container. This is useful for linking to the container in logs, etc.
        image: mycontainerregistry.azurecr.io/my-app:latest  # Pull the container image you will call from your container registry.
        ports:
        - containerPort: 80  # The container listens on port 80.

Implantar usando o Azure Pipelines

Em seu pipeline YAML, inclua uma tarefa para implantar no AKS.

# This defines a task for deploying Kubernetes manifests within an Azure DevOps pipeline.
- task: KubernetesManifest@0  # Task type for working with Kubernetes manifest files.
  inputs:
    # This configures what to do with the Kubernetes manifest files.
    action: 'deploy'  # 'deploy' action ensures the Kubernetes manifests are applied to the cluster.

    # This defines the namespace where the Kubernetes resources will be deployed.
    namespace: 'default'  # 'default' is the namespace for deploying resources. Change if needed.

    # All this does is point to the manifest files that define the desired state of your Kubernetes resources.
    manifests: '$(Build.ArtifactStagingDirectory)/manifests/*.yaml'
    # The 'manifests' variable points to the location of all the YAML files (e.g., Deployment, Service, etc.) that will be applied during the deployment.

    # To access private container registry images, use the image pull secret.
    imagePullSecrets: 'my-registry-secret'
    # This instructs Kubernetes on which secret to use when pulling images from a private container registry.
    # Ensure that 'my-registry-secret' exists in the namespace before the deploy

Confirme e envie o arquivo YAML para acionar a implantação.

O AKS simplifica a orquestração de contêineres, facilitando o gerenciamento de dimensionamento, atualizações e reversões. Na minha experiência, ele é indispensável para aplicativos modernos nativos da nuvem.