Implantar em VMs Linux num ambiente

Serviços de DevOps do Azure | 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 integração contínua e entrega contínua (CI/CD), o histórico de implantação do ambiente fornece rastreabilidade para cada máquina virtual (VM) até ao commit que a acionou.

Este artigo mostra como configurar um pipeline de DevOps do Azure para implantações em vários recursos de máquina virtual (VM) Linux em um ambiente. Estas instruções criam e implementam 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 ambientes e recursos alvo de um trabalho de implementação, consulte o esquema YAML 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 subscrição 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 Linux

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

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

Criar e executar o pipeline de compilação

Crie um pipeline de CI que crie e implante seu aplicativo sempre que houver uma confirmação para a main ramificação do seu repositório de código.

Criar o pipeline YAML

1. Em seu projeto do Azure DevOps, selecione Pipelines>New pipeline ou Create Pipeline e, em seguida, selecione GitHub como o local do seu código-fonte.
2. Na tela Selecione um repositório, selecione seu repositório de exemplo bifurcado.
3. No ecrã Configurar o seu pipeline, selecione pipeline inicial.
4. Na tela Review your pipeline YAML , substitua o código inicial gerado pelo código a seguir, dependendo do seu tempo de execução.

Adicionar a tarefa de compilação

A Build tarefa executa tarefas para criar e testar o seu projeto e carrega os resultados da compilação para uma drop localização. Esse trabalho é executado nos agentes de compilação especificados no pipeline pool, não nas VMs do ambiente 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, em seguida, selecione Salvar e executar novamente.

Quando o pipeline terminar, exiba a página Resumo do trabalho para verificar se o trabalho de compilação foi executado com êxito e se 1 artefato publicado aparece em Relacionado.

Adicionar e executar o trabalho de implantação

Uma tarefa de implantação executa preDeploy, deploy, routeTraffic e postRouteTraffic ganchos de ciclo de vida uma vez e, em seguida, executa on: success ou on: failure. Se implementar em VMs de ambiente, a fase preDeploy será executada no agente de build, não nas VMs de 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 este passo para orquestração, preparação de VMs e artefactos, e verificações de saúde.
2. A deploy etapa implanta o objeto de implantação nas VMs do ambiente de destino.
3. A etapa opcional routeTraffic pode aplicar o redirecionamento de tráfego.
4. ** A etapa opcional postRouteTraffic pode realizar verificações 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 requer que as VMs do ambiente possam executar todas as tarefas de pipeline, como Bash ou CLI do Azure. Você pode usar a preDeploy etapa para instalar o software necessário e as permissões nas VMs de destino.

Por exemplo, se uma etapa de implantação usa a CLI do Azure, as VMs do agente devem ter a CLI do Azure instalada e disponível no PATH para o usuário do agente. O usuário 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 ao arquivo sudoers, ou então 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 então para automação, definir um principal de serviço e executar az login --service-principal em um passo preDeploy.

Adicionar o trabalho de implantação

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

1. Selecione o ícone Mais ações no canto superior direito da 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 qualquer 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, selecione Salvar, selecione Executar e selecione Executar novamente. A cada execução deste trabalho, o histórico de implantação registra-se em relação ao ambiente.

   Nota

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

Estratégia de implementação contínua

Você pode usar uma estratégia rolling em vez de runOnce. Uma estratégia de implantação contínua pode orquestrar paralelismo, verificações de integridade e roteamento de tráfego. Enquanto a runOnce estratégia é executada em uma única VM de cada vez, uma implantação gradual pode ser realizada em paralelo em conjuntos em rotação de até cinco VMs de destino, dependendo da configuração maxParallel.

O maxParallel parâmetro define o número ou a porcentagem 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 as condições de sucesso e falha para a implantação.

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

Exemplo de trabalho 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 manualmente esses requisitos ou o pipeline deve instalá-los ou implementá-los.

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

O aplicativo Node.js requer Node, possivelmente dependências npm, e um gerenciador de serviços como systemd para estar presente e configurado em cada VM de agente. Para ser automatizado, o script de implantação de pipeline deve ser não interativo 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

Rastreabilidade do pipeline de acesso no ambiente

A guia do ambiente Implantações fornece rastreabilidade completa dos commits e itens de trabalho, e um histórico de implantação cruzada entre pipelines para o ambiente.

Conteúdos relacionados

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