Implantar no Serviço de Aplicativo usando o Azure Pipelines

1. Entre na sua organização do Azure DevOps e navegue até seu projeto.

2. Acesse Pipelines e selecione Novo pipeline.

3. Quando solicitado, selecione o local do código-fonte: Azure Repos Git ou GitHub.

   Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.

4. Quando a lista de repositórios for exibida, selecione o repositório.

5. Você poderá ser redirecionado ao GitHub para instalar o aplicativo do Azure Pipelines. Se sim, selecione Aprovar e instalar.

6. Na guia Configurar, selecione ASP.NET Core.

7. Quando o novo pipeline for exibido, observe o YAML para ver o que ele faz. Ao final, selecione Salvar e executar.

Introdução:

1. Crie um pipeline e selecione o modelo de ASP.NET Core. Essa seleção adiciona automaticamente as tarefas necessárias para criar o código no repositório de exemplo.

2. Salve o pipeline e enfileire um build para vê-lo em ação.

   O modelo de pipeline do ASP.NET Core publica o arquivo zip de implantação como um artefato do Azure para a tarefa de implantação posteriormente.

1. Clique no final do arquivo YAML e selecione Mostrar assistente.

2. Use o assistente de tarefa para adicionar a tarefa do aplicativo Web do Azure.

   

   Como alternativa, você pode adicionar a tarefa de implantação do Serviço de Aplicativo do Azure (AzureRmWebAppDeployment).

3. Escolha sua assinatura do Azure. Não se esqueça de Autorizar a sua conexão. A autorização criará a conexão de serviço necessária.

4. Selecione o Tipo de aplicativo, o Nome do aplicativo e a Pilha de runtime com base no aplicativo do Serviço de Aplicativo. O YAML completo será semelhante ao código a seguir.

   variables:
     buildConfiguration: 'Release'
   
   steps:
   - task: DotNetCoreCLI@2
     inputs:
       command: 'publish'
       publishWebProjects: true
   - task: AzureWebApp@1
     inputs:
       azureSubscription: '<service-connection-name>'
       appType: 'webAppLinux'
       appName: '<app-name>'
       package: '$(System.DefaultWorkingDirectory)/**/*.zip'
   

   • azureSubscription: nome da conexão de serviço autorizada com a sua assinatura do Azure.
   • appName: nome do aplicativo existente.
   • package: caminho de arquivo para o pacote ou uma pasta que traz o conteúdo do serviço de aplicativo. Há suporte para caracteres curinga.

Introdução:

1. Crie um pipeline de lançamento selecionando Lançamentos no menu à esquerda e escolha Novo pipeline.

2. Selecione o modelo de implantação do Serviço de Aplicativo do Azure para a fase. Isso adiciona automaticamente as tarefas necessárias.

   Observação

   Se você estiver implantando um aplicativo Node.js no Serviço de Aplicativo no Windows, selecione o modelo Implantar Aplicativo Node.js no Serviço de Aplicativo do Azure. A única diferença entre esses modelos é que o modelo do Node.js configura a tarefa para gerar um arquivo web.config que contém um parâmetro que inicia o serviço iisnode.

3. Para vincular esse pipeline de lançamento ao artefato do Azure da etapa anterior, selecione Adicionar um artefato>Build.

4. Em Origem (pipeline de build), selecione o pipeline de build que você criou na seção anterior e escolha Adicionar.

5. Salve o pipeline de lançamento e crie uma versão para vê-lo em ação.

Para implantar um pacote da Web .zip (por exemplo, de um aplicativo Web ASP.NET) em um Aplicativo Web do Azure, use o snippet a seguir para implantar o build em um aplicativo.

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: 'webAppLinux'
    appName: '<app-name>'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

• azureSubscription: sua assinatura do Azure.
• appType: o tipo de aplicativo Web.
• appName: o nome do serviço de aplicativo existente.
• package: o caminho do arquivo para o pacote ou uma pasta que contém o conteúdo do serviço de aplicativo. Há suporte para caracteres curinga.

No caso de pipelines clássicos, é mais fácil definir as fases de build e lançamento em páginas separadas (Pipelines e Lançamentos, respectivamente). Em geral, você:

• Na página Pipelines, compile e teste o aplicativo usando o modelo de sua escolha, como ASP.NET Core, Node.js com Grunt, Maven ou outros, e publique um artefato.
• Na página Lançamento, use o modelo genérico de implantação do Serviço de Aplicativo do Azure para implantar o artefato.

Pode haver modelos para linguagens de programação específicas disponíveis para você escolher.

Por padrão, sua implantação ocorre com o aplicativo raiz no Aplicativo Web do Azure. Você pode fazer a implantação em um aplicativo virtual específico usando a propriedade VirtualApplication da tarefa de implantação do Serviço de Aplicativo do Azure (AzureRmWebAppDeployment):

- task: AzureRmWebAppDeployment@4
  inputs:
    VirtualApplication: '<name of virtual application>'

• VirtualApplication: o nome do Aplicativo Virtual configurado no portal do Azure. Confira Configurar um aplicativo do Serviço de Aplicativo no portal do Azure para obter mais detalhes.

Por padrão, sua implantação ocorre com o aplicativo raiz no Aplicativo Web do Azure. Caso deseje fazer a implantação em um aplicativo virtual específico, insira o nome dele na propriedade Aplicativo Virtual da tarefa de implantação do Serviço de Aplicativo do Azure.

O exemplo a seguir mostra como implantar em um slot de preparo e, em seguida, alternar para um slot de produção:

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    appName: '<app-name>'
    deployToSlotOrASE: true
    resourceGroupName: '<name of resource group>'
    slotName: staging
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    WebAppName: '<app-name>'
    ResourceGroupName: '<name of resource group>'
    SourceSlot: staging
    SwapWithProduction: true

• azureSubscription: sua assinatura do Azure.
• appType: (opcional) Use webAppLinux para implantar em um aplicativo Web no Linux.
• appName: o nome do serviço de aplicativo existente.
• deployToSlotOrASE: booliano. Implantar em um slot de implantação existente ou no Ambiente do Serviço de Aplicativo do Azure.
• resourceGroupName: nome do grupo de recursos. Necessário se deployToSlotOrASE for usado.
• slotName: Nome do slot, padrão para production. Necessário se deployToSlotOrASE for usado.
• package: o caminho do arquivo para o pacote ou uma pasta que contém o conteúdo do serviço de aplicativo. Há suporte para caracteres curinga.
• SourceSlot: slot enviado para produção quando SwapWithProduction for verdadeiro.
• SwapWithProduction: booliano. Troque o tráfego do slot de origem pela produção.

Use a opção Implantar no Slot ou Ambiente do Serviço de Aplicativo na tarefa Aplicativo Web do Azure para especificar o slot no qual fazer a implantação. Para trocar os slots, use a tarefa de gerenciamento do Serviço de Aplicativo do Azure.

Você pode usar trabalhos no seu arquivo YAML para configurar um pipeline de implantações. Usando trabalhos, você pode controlar a ordem de implantação em vários aplicativos Web.

jobs:
- job: buildandtest
  pool:
    vmImage: ubuntu-latest
 
  steps:
  # publish an artifact called drop
  - task: PublishPipelineArtifact@1
    inputs:
      targetPath: '$(Build.ArtifactStagingDirectory)' 
      artifactName: drop
  
  # deploy to Azure Web App staging
  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<staging-app-name>'
      deployToSlotOrASE: true
      resourceGroupName: <group-name>
      slotName: 'staging'
      package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- job: deploy
  dependsOn: buildandtest
  condition: succeeded()

  pool: 
    vmImage: ubuntu-latest  
  
  steps:
    # download the artifact drop from the previous job
  - task: DownloadPipelineArtifact@2
    inputs:
      source: 'current'
      artifact: 'drop'
      path: '$(Pipeline.Workspace)'

  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<production-app-name>'
      resourceGroupName: <group-name>
      package: '$(Pipeline.Workspace)/**/*.zip'

Se você quiser implantar em vários aplicativos Web, adicione fases ao pipeline de lançamento. Você pode controlar a ordem de implantação. Para saber mais, confira Fases.

O seguinte snippet mostra um exemplo de substituição de variável usando a tarefa Implantação do Serviço de Aplicativo do Azure (AzureRmWebAppDeployment):

jobs:
- job: test
  variables:
    connectionString: <test-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Test stage Azure service connection>'
      WebAppName: '<name of test stage web app>'
      enableXmlVariableSubstitution: true

- job: prod
  dependsOn: test
  variables:
    connectionString: <prod-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Prod stage Azure service connection>'
      WebAppName: '<name of prod stage web app>'
      enableXmlVariableSubstitution: true

Para alterar connectionString usando a substituição de variável:

1. Crie um pipeline de lançamento com duas fases.
2. Vincule o artefato da versão ao build que produz o pacote da Web.
3. Defina connectionString como uma variável em cada uma das fases. Defina o valor apropriado.
4. Selecione a opção substituição de variável XML em Transformações de Arquivo e Opções de Substituição de Variável para a tarefa Implantar o Serviço de Aplicativo do Azure.

Para fazer isso no YAML, use uma das seguintes técnicas:

• Isole as etapas de implantação em um trabalho separado e adicione uma condição a esse trabalho.
• Adicione uma condição à etapa.

O exemplo a seguir mostra como usar condições de etapa para implantar somente builds originados da ramificação principal:

- task: AzureWebApp@1
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  inputs:
    azureSubscription: '<service-connection-name>'
    appName: '<app-name>'

Para saber mais sobre condições, confira Especificar condições.

No pipeline de lançamento, você pode implementar várias verificações e condições para controlar a implantação:

• Defina filtros de ramificação para configurar o gatilho de implantação contínua no artefato do pipeline de lançamento.
• Defina as aprovações de pré-implantação como uma pré-condição para a implantação em uma fase.
• Configure portões como uma pré-condição para a implantação em uma fase.
• Especifique as condições para uma tarefa ser executada.

Para saber mais, confira Liberação, ramificação e gatilhos de fase,Controle de implantação de versão usando aprovações, Controle de implantação de versão usando portões e Especificar condições para executar uma tarefa.

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration)'
    zipAfterPublish: true
- task: AzureRmWebAppDeployment@4
  inputs:
    ConnectionType: 'AzureRM'
    azureSubscription: '<service-connection-name>'
    appType: 'webApp'
    WebAppName: '<app-name>'
    packageForLinux: '$(System.DefaultWorkingDirectory)/**/*.zip'
    enableCustomDeployment: true
    DeploymentType: 'webDeploy'

No pipeline de lançamento, supondo que você esteja usando o modelo de implantação do Serviço de Aplicativo do Azure:

1. Selecione a guia Tarefas e escolha Implantar o Serviço de Aplicativo do Azure. Esta é a tarefa AzureRmWebAppDeployment.

2. Na caixa de diálogo, verifique se Tipo de conexão está definido como Azure Resource Manager.

3. Na caixa de diálogo, expanda Opções de Implantação Adicionais e escolha Selecionar método de implantação. Verifique se a opção Implantação da Web está marcada como o método de implantação.

4. Salve o pipeline de lançamento.