Implantar em VMs do Linux em um ambiente

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

Você pode adicionar máquinas virtuais como recursos em ambientes do Azure Pipelines e direcioná-las para implantações. Para um fluxo de trabalho de CI/CD (integração contínua e implantação contínua), o histórico de implantação do ambiente fornece rastreabilidade para cada VM até o commit de acionamento.

Este artigo mostra como configurar um pipeline do Azure DevOps para implantações em vários recursos de VM (máquina virtual) do Linux em um ambiente. Essas instruções criam e implantam um aplicativo JavaScript ou Java, mas você pode adaptá-las para qualquer aplicativo que publique um pacote de implantação da Web.

Para obter mais informações sobre os ambientes e recursos direcionados por um trabalho de implantação, consulte a definição do esquema YAML de jobs.deployment.environment. Para obter mais informações sobre trabalhos de implantação, consulte a definição jobs.deployment .

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Uma organização e um projeto do Azure DevOps. Inscreva-se no Azure Pipelines.

Criar um ambiente e adicionar VMs do Linux

Em seu projeto do Azure Pipelines, crie um ambiente e adicione suas VMs do Linux como recursos de ambiente seguindo as instruções em Criar um ambiente e adicione uma VM.

Execute o script de registro do agente copiado em cada VM para registrá-lo no ambiente. Você também pode atribuir marcas às VMs individuais respondendo aos prompts interativos.

Criar e executar o pipeline de build

Crie um pipeline de CI que compila e implanta seu aplicativo sempre que houver uma confirmação no main branch do repositório de código.

Criar o pipeline YAML

1. Em seu projeto do Azure DevOps, selecione Pipelines>Novo pipeline ou Criar Pipeline e selecione GitHub como o local do código-fonte.
2. Na tela Selecionar um repositório , selecione o repositório de amostra bifurcado.
3. Na página Configurar seu pipeline, selecione Pipeline inicial.
4. Na tela Revisar o YAML do pipeline, substitua o código inicial gerado pelo código a seguir, dependendo do tempo de execução.

Adicionar o trabalho de build

O Build trabalho executa tarefas para criar e testar seu projeto e envia a saída de build para um drop local. Esse trabalho é executado nos agentes de build especificados no pipeline pool, não em suas VMs de ambiente do Linux.

trigger:
- main

pool:
  vmImage: ubuntu-latest

jobs:  
- job: Build
  displayName: Build
  steps:
  - task: UseNode@1
    inputs:
      version: '16.x'
    displayName: 'Install Node.js'
  - script: |
      npm install
      npm run build --if-present
      npm run test --if-present
    displayName: 'npm install, build and test'
  - task: ArchiveFiles@2
    displayName: 'Archive files'
    inputs:
      rootFolderOrFile: '$(System.DefaultWorkingDirectory)'
      includeRootFolder: false
      archiveType: tar
      tarCompression: gz
      archiveFile: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
      replaceExistingArchive: true
  - upload: $(Build.ArtifactStagingDirectory)/$(Build.BuildId).gz
    artifact: drop

trigger:
- main

pool:
  vmImage: ubuntu-latest

jobs:  
- job: Build
  displayName: Build Maven Project
  steps:
  - task: Maven@4
    displayName: 'Maven Package'
    inputs:
      mavenPomFile: 'pom.xml'
  - task: CopyFiles@2
    displayName: 'Copy Files to artifact staging directory'
    inputs:
      SourceFolder: '$(System.DefaultWorkingDirectory)'
      Contents: '**/target/*.?(war|jar)'
      TargetFolder: $(Build.ArtifactStagingDirectory)
  - upload: $(Build.ArtifactStagingDirectory)
    artifact: drop

Executar o pipeline

Para salvar o arquivo azure-pipelines.yml no repositório e iniciar o pipeline de CI/CD, selecione Salvar e executar e selecione Salvar e executar novamente.

Quando o pipeline for concluído, visualize a página de Resumo da tarefa para verificar se a tarefa de build foi executada com êxito e se um artefato publicado aparece em Relacionado.

Adicionar e executar a tarefa de implantação

Um trabalho de implantação executa preDeploy, deploy, routeTraffic e postRouteTraffic uma vez, e em seguida executa on: success ou on: failure. Se você implantar em VMs de ambiente, a fase preDeploy será executada no agente de compilação, e não nas VMs do ambiente. Todas as outras etapas são executadas em VMs registradas no ambiente.

1. A etapa opcional preDeploy é executada antes da implantação. Você pode usar esta etapa para orquestração, preparação de Máquina Virtual, artefatos e verificações de integridade.
2. A deploy etapa implanta o objeto de implantação nas VMs do ambiente de destino.
3. A etapa routeTraffic opcional pode aplicar a comutação de tráfego.
4. A etapa opcional postRouteTraffic pode realizar testes de integridade e notificações.
5. As etapas personalizadas on.failure e on.success podem fornecer notificações ou recuperação.

Um trabalho de implantação em um ambiente com resourceType: VirtualMachine exige que as VMs de ambiente possam executar todas as tarefas de pipeline, por exemplo, Bash ou CLI do Azure. Você pode usar a preDeploy etapa para instalar o software e as permissões necessários em VMs de destino.

Por exemplo, se uma etapa de implantação usar a CLI do Azure, as VMs do agente deverão ter a CLI do Azure instalada e disponível no PATH para o usuário do agente. O usuário do agente deve ter permissão para executar a CLI e deve se autenticar no Azure. Talvez seja necessário adicionar o usuário do agente aos sudoers ou configurar variáveis de ambiente para automatizar a instalação.

Você pode usar um preDeploy script para instalar a CLI do Azure nas VMs de destino. Para autenticar no Azure, você pode executar az login, ou, para automação, definir um principal de serviço e executar az login --service-principal na etapa preDeploy.

Adicionar tarefa de implantação

O trabalho de implantação de exemplo a seguir é iniciado quando o Build trabalho é concluído com êxito. Para adicionar a tarefa ao pipeline:

1. Selecione o ícone Mais ações no canto superior direito na página Resumo , selecione Editar pipeline e adicione o seguinte código ao final do pipeline. Substitua <environment-name> pelo nome do ambiente que você criou.

   Opcionalmente, você pode selecionar VMs específicas do ambiente para receber a implantação usando o tags parâmetro e especificando o <VMtag> que você definiu para a VM.

   - deployment: VMDeploy
     displayName: Web deploy
     dependsOn: Build
     condition: succeeded()
     environment:
       name: <environment-name>
       resourceType: VirtualMachine
       tags: <VMtag> # VMs to deploy to
   

2. Adicione um strategy ao deployment trabalho. A estratégia de implantação runOnce é a mais simples e é executada por padrão se você não especificar strategy. Essa estratégia executa as etapas de implantação uma vez em cada VM no ambiente, sem nenhum paralelismo ou gerenciamento de tráfego.

     strategy:
        runOnce:
          deploy:
             steps:
             - script: echo my first deployment
   

3. Depois de adicionar o trabalho de implantação, selecione Validar e salvar, depois salve, selecione Executar e selecione Executar novamente. A cada execução desse trabalho, o histórico de implantação registra contra o ambiente.

   Observação

   Na primeira vez que executar o pipeline que usa o ambiente, você deve conceder permissão para todas as execuções do pipeline acessarem o pool de agentes e o ambiente. Selecione o símbolo De espera ao lado do trabalho na tela Resumo da execução do pipeline e selecione Permitir para conceder as permissões necessárias.

Estratégia de implantação sem interrupção

Você pode usar rolling em vez de runOnce como estratégia de implantação. Uma estratégia de implantação sem interrupção pode orquestrar paralelismo, verificações de integridade e roteamento de tráfego. Embora a estratégia runOnce seja executada em uma única VM de cada vez, uma implantação escalonada pode ser executada em paralelo em conjuntos escalonados de até cinco VMs de destino, dependendo da configuração.

O maxParallel parâmetro define o número ou o percentual de VMs que devem permanecer disponíveis, garantindo que o aplicativo possa lidar com solicitações e reduzindo o tempo de inatividade geral durante as implantações. Esse parâmetro também determina condições de êxito e falha para a implantação.

Para obter mais informações sobre a estratégia de implantação sem interrupção, consulte a definição de esquema jobs.deployment.strategy.rolling .

Exemplo de tarefa de implantação

As implantações em recursos de VM exigem que as VMs tenham todos os aplicativos, dependências e permissões necessários instalados e configurados. Você deve pré-instalar esses requisitos manualmente ou o pipeline deve instalá-los ou implementá-los.

A implantação do aplicativo Java para recursos de VM é mais fácil de implementar porque é auto-suficiente. A JVM (Máquina Virtual Java) geralmente é pré-instalada em agentes de VM e você não precisa se preocupar com dependências de aplicativo, permissões ou gerenciamento de pacotes. Você pode simplesmente baixar o arquivo JAR e executá-lo com java -jar.

O aplicativo Node.js requer Node, possivelmente dependências npm e um gerenciador de serviços como o systemd para estar presente e configurado em cada máquina virtual do agente. Para ser automatizado, o script de implantação de pipeline deve ser não interinterativo e capaz de reiniciar e gerenciar o serviço do aplicativo.

- stage: Deploy
  displayName: Rolling Deploy to VMs
  dependsOn: Build
  condition: succeeded()
  jobs:
  - deployment: RollingDeploy
    displayName: Rolling deploy to Ubuntu VMs
    environment:
      name: <environment-name>
      resourceType: VirtualMachine
    strategy:
      rolling:
        maxParallel: 1   #or 2 for parallel. For percentages, use x%
        preDeploy:
          steps:
          - download: current
            artifact: drop
          - script: echo "Pre-deploy on $(hostname)"
        deploy:
          steps:
          - script: |
              echo "Unpacking Node.js app on $(hostname)"
              sudo mkdir -p /opt/pipelines-javascript
              sudo tar -xzf $(Pipeline.Workspace)/drop/$(Build.BuildId).tar.gz -C /opt/pipelines-javascript --strip-components=1
              cd /opt/pipelines-javascript
              echo "Installing production dependencies"
              sudo npm ci --only=production
              echo "Restarting Node.js service"
              sudo systemctl restart pipelines-javascript
            displayName: 'Extract, install, and restart Node.js service'
        routeTraffic:
          steps:
          - script: echo "Routing traffic on $(hostname)"
        postRouteTraffic:
          steps:
          - script: echo "Post-route health check on $(hostname)"
        on:
          failure:
            steps:
            - script: echo "Deployment failed on $(hostname)"
          success:
            steps:
            - script: echo "Deployment succeeded on $(hostname)"

- deployment: VMDeploy
  displayName: web
  dependsOn: Build
  condition: succeeded()
  environment:
    name: <environment name>
    resourceType: VirtualMachine
  strategy:
      rolling:
        maxParallel: 1   #or 2 for parallel. For percentages, use x%
        preDeploy:
          steps:
          - download: current
            artifact: drop
          - script: echo initialize, cleanup, backup, install certs
        deploy:
          steps:
          - task: Bash@3
            displayName: Start Java app, check health, and stop
            inputs:
              targetType: 'inline'
              script: |
                JAR=$(ls $(Pipeline.Workspace)/drop/target/*.jar | head -n 1)
                java -jar "$JAR" --server.port=8081 &
                PID=$!
                # Health check loop
                for i in {1..10}; do
                  if curl -sf http://localhost:8081/actuator/health; then
                    echo "App is up!"
                    break
                  else
                    echo "Waiting for app to be healthy... ($i/10)"
                    sleep 3
                  fi
                done
                # Stop the app manually
                kill $PID 2>/dev/null || echo "Process already exited" 
        routeTraffic:
          steps:
          - script: echo routing traffic
        postRouteTraffic:
          steps:
          - script: echo health check post-route traffic
        on:
          failure:
            steps:
            - script: echo Restore from backup! This is on failure
          success:
            steps:
            - script: echo Notify! This is on success

Acesse a rastreabilidade do pipeline no ambiente

A guia Implantações de ambiente fornece rastreamento completo de confirmações e itens de trabalho e um histórico de implantação entre pipelines para o ambiente.

Conteúdo relacionado

• Ambientes
• Recursos de VM em ambientes
• Trabalhos de implantação