Compartilhar via

Entrega contínua com o Azure Pipelines

Use o Azure Pipelines para implantar automaticamente seu projeto de código em um aplicativo de funções no Azure. O Azure Pipelines permite criar, testar e implantar com CI (integração contínua) e CD (entrega contínua) usando o Azure DevOps.

Os pipelines do YAML são definidos usando um arquivo YAML em seu repositório. Uma etapa é o menor bloco de construção de um pipeline e pode ser um script ou tarefa (script pré-empacotado). Saiba mais sobre os principais conceitos e componentes que compõem um pipeline.

Você usa a tarefa AzureFunctionApp para implantar seu código. Agora há duas versões de AzureFunctionApp, que são comparadas nesta tabela:

Comparação/versão AzureFunctionApp@2 AzureFunctionApp@1
Suporta o Plano de Consumo Flex ✔ ❌
Inclui suporte avançado à validação* ✔ ❌
Quando usar... Recomendado para novas implantações de aplicativo Mantido para implantações legadas

* O suporte avançado à validação torna os pipelines menos propensos a falhar devido a erros.

Escolha sua versão de tarefa na parte superior do artigo.

Observação

Atualize de AzureFunctionApp@1 para AzureFunctionApp@2 para ter acesso a novos recursos e suporte a longo prazo.

Pré-requisitos

Lembre-se de carregar o projeto de código local no repositório GitHub ou Azure Repos depois de publicá-lo em seu aplicativo de funções.

Compilar seu aplicativo

  1. Entre na sua organização do Azure DevOps e navegue até seu projeto.
  2. Em seu projeto, navegue até a página Pipelines. Em seguida, escolha a ação para criar um novo pipeline.
  3. Percorra as etapas do assistente selecionando primeiro GitHub como o local do código-fonte.
  4. Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.
  5. Quando a lista de repositórios for exibida, selecione o repositório de aplicativo de amostra.
  6. O Azure Pipelines analisará seu repositório e recomendará um modelo. Clique em Salvar e executar e selecione Fazer commit diretamente para a ramificação principal. Depois clique de novo em Salvar e executar.
  7. Uma nova execução é iniciada. Aguarde a conclusão da execução.

Exemplo de pipelines de build do YAML

Os pipelines específicos de idioma a seguir podem ser usados para a criação de aplicativos.

Você pode usar o exemplo a seguir para criar um arquivo YAML para compilar um aplicativo .NET:

pool:
  vmImage: 'windows-latest'
steps:
  - task: UseDotNet@2
    displayName: 'Install .NET 8.0 SDK'
    inputs:
      packageType: 'sdk'
      version: '8.0.x'
      installationPath: $(Agent.ToolsDirectory)/dotnet
  - script: |
      dotnet restore
      dotnet build --configuration Release
  - task: DotNetCoreCLI@2
    displayName: 'dotnet publish'
    inputs:
      command: publish
      arguments: '--configuration Release --output $(System.DefaultWorkingDirectory)/publish_output'
      projects: 'csharp/*.csproj'
      publishWebProjects: false
      modifyOutputPath: false
      zipAfterPublish: false
  - task: ArchiveFiles@2
    displayName: "Archive files"
    inputs:
      rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
      includeRootFolder: false
      archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
  - task: PublishBuildArtifacts@1
    inputs:
      PathtoPublish: '$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip'
      artifactName: 'drop'
  1. Entre na sua organização do Azure DevOps e navegue até seu projeto.
  2. Em seu projeto, navegue até a página Pipelines. Em seguida, selecione Novo pipeline.
  3. Selecione uma destas opções para Onde está seu código?:
    • GitHub: Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub. Quando essa conexão é sua primeira conexão do GitHub, o assistente também orienta você pelo processo de conexão do DevOps às suas contas do GitHub.
    • Git do Azure Repos: você pode escolher imediatamente um repositório em seu projeto de DevOps atual.
  4. Quando a lista de repositórios for exibida, selecione o repositório de aplicativo de amostra.
  5. O Azure Pipelines analisa seu repositório e, em Configurar seu pipeline, fornece uma lista de modelos potenciais. Escolha o modelo de aplicativo de funções apropriado para seu idioma. Se você não vir o modelo correto, selecione Mostrar mais.
  6. Clique em Salvar e executar e selecione Fazer commit diretamente para a ramificação principal. Depois clique de novo em Salvar e executar.
  7. Uma nova execução é iniciada. Aguarde a conclusão da execução.

Exemplo de pipelines de build do YAML

Os pipelines específicos de idioma a seguir podem ser usados para a criação de aplicativos.

Você pode usar o exemplo a seguir para criar um arquivo YAML para compilar um aplicativo .NET.

Se você vir erros ao criar seu aplicativo, verifique se a versão do .NET que você usa corresponde à sua versão Azure Functions. Para obter mais informações, consulte Visão geral de versões do Azure Functions runtime.

pool:
  vmImage: 'windows-latest'
steps:
  - task: UseDotNet@2
    displayName: 'Install .NET 8.0 SDK'
    inputs:
      packageType: 'sdk'
      version: '8.0.x'
      installationPath: $(Agent.ToolsDirectory)/dotnet
  - script: |
      dotnet restore
      dotnet build --configuration Release
  - task: DotNetCoreCLI@2
    displayName: 'dotnet publish'
    inputs:
      command: publish
      arguments: '--configuration Release --output $(System.DefaultWorkingDirectory)/publish_output'
      projects: 'csharp/*.csproj'
      publishWebProjects: false
      modifyOutputPath: false
      zipAfterPublish: false
  - task: ArchiveFiles@2
    displayName: "Archive files"
    inputs:
      rootFolderOrFile: "$(System.DefaultWorkingDirectory)/publish_output"
      includeRootFolder: false
      archiveFile: "$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip"
  - task: PublishBuildArtifacts@1
    inputs:
      PathtoPublish: '$(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip'
      artifactName: 'drop'

Implantar seu aplicativo

Você implantará com a tarefa Implantação de aplicativo de funções do Azure v2. Esta tarefa requer uma conexão de serviço do Azure como entrada. Uma conexão de serviço do Azure armazena as credenciais para se conectar do Azure Pipelines ao Azure. Você deve criar uma conexão que use a federação de identidade de carga de trabalho.

Para implantar no Azure Functions, adicione este snippet no final do azure-pipelines.yml arquivo, dependendo se o aplicativo é executado no Linux ou no Windows:

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <Name of your Azure subscription>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip
    deploymentMethod: 'auto' # 'auto' | 'zipDeploy' | 'runFromPackage'. Required. Deployment method. Default: auto.
    #Uncomment the next lines to deploy to a deployment slot
    #Note that deployment slots is not supported for Linux Dynamic SKU
    #deployToSlotOrASE: true
    #resourceGroupName: '<RESOURCE_GROUP>'
    #slotName: '<SLOT_NAME>'

O padrão appType é Windows (functionApp). Você pode especificar o Linux definindo o appType como functionAppLinux. Um aplicativo Flex Consumption é executado no Linux, e é necessário configurar ambos appType: functionAppLinux e isFlexConsumption: true.

O trecho de código pressupõe que as etapas de compilação no arquivo YAML produzem o arquivo zip na pasta $(System.ArtifactsDirectory) no seu agente.

Você implanta usando a tarefa Implantar Aplicativo de Funções do Azure . Esta tarefa requer uma conexão de serviço do Azure como entrada. Uma conexão de serviço do Azure armazena as credenciais para se conectar do Azure Pipelines ao Azure.

Importante

A implantação em um aplicativo de Consumo Flexível não tem suporte usando @v1 da tarefa AzureFunctionApp.

Para implantar no Azure Functions, adicione este snippet no final do azure-pipelines.yml arquivo:

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'ubuntu-latest'

- task: DownloadBuildArtifacts@1 # Add this at the end of your file
  inputs:
    buildType: 'current'
    downloadType: 'single'
    artifactName: 'drop'
    itemPattern: '**/*.zip'
    downloadPath: '$(System.ArtifactsDirectory)'
- task: AzureFunctionApp@1
  inputs:
    azureSubscription: $(azureSubscription)
    appType: functionAppLinux # default is functionApp
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.zip

Esse snippet define appType como functionAppLinux, o que é necessário ao implantar em um aplicativo que é executado no Linux. O padrão appType é Windows (functionApp).

O exemplo pressupõe que as etapas de build em seu arquivo YAML produzam o arquivo zip na $(System.ArtifactsDirectory) pasta em seu agente.

Implantar um contêiner

Dica

É recomendável usar o suporte do Azure Functions nos Aplicativos de Contêiner do Azure para hospedar seu aplicativo de funções em um contêiner personalizado do Linux. Para obter mais informações, consulte a visão geral do Azure Functions nos Aplicativos de Contêiner do Azure.

Ao implantar um aplicativo de funções em contêineres, a tarefa de implantação usada depende do ambiente de hospedagem específico.

Você pode usar a tarefa Implantar Aplicativos de Contêiner do Azure (AzureContainerApps) para implantar uma imagem de aplicativo de funções em uma instância do Aplicativo de Contêiner do Azure otimizada para o Azure Functions.

Esse código implanta a imagem base para um aplicativo de funções de modelo de processo isolado do .NET 8:

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: AzureContainerApps@1
  inputs:
    azureSubscription: <Name of your Azure subscription>
    imageToDeploy: 'mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0'
    containerAppName: <Name of your container app>
    resourceGroup: <Name of the resource group>

O ideal é criar seu próprio contêiner personalizado no pipeline em vez de usar uma imagem base, conforme mostrado neste exemplo. Para obter mais informações, consulte Implantar em Aplicativos de Contêiner do Azure por meio de Azure Pipelines.

Implantar em um slot

Importante

Atualmente, o plano Flex Consumption não dá suporte a slots. Os aplicativos Linux também não dão suporte a slots durante a execução em um plano de consumo, e o suporte para esses aplicativos será descontinuado no futuro.

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <Name of your Azure subscription>
  appName: <Name of the function app>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <Name of your Azure subscription>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.DefaultWorkingDirectory)/build$(Build.BuildId).zip
    deploymentMethod: 'auto' # 'auto' | 'zipDeploy' | 'runFromPackage'. Required. Deployment method. Default: auto.
    deployToSlotOrASE: true
    resourceGroupName: '<RESOURCE_GROUP>'
    slotName: '<SLOT_NAME>'

Você pode configurar seu aplicativo de funções para ter vários slots. Os slots permitem que você implante seu aplicativo com segurança e teste-o antes de disponibilizá-lo para seus clientes.

O trecho de código YAML a seguir mostra como implantar em um slot de preparo e, em seguida, alternar para um slot de produção:

- task: AzureFunctionApp@1
  inputs:
    azureSubscription: <Azure service connection>
    appType: functionAppLinux
    appName: <Name of the function app>
    package: $(System.ArtifactsDirectory)/**/*.zip
    deployToSlotOrASE: true
    resourceGroupName: <Name of the resource group>
    slotName: staging

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: <Azure service connection>
    WebAppName: <name of the function app>
    ResourceGroupName: <name of resource group>
    SourceSlot: staging
    SwapWithProduction: true

Ao usar slots de implantação, você também pode adicionar a seguinte tarefa para realizar uma troca de slots como parte da sua implantação.

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: <AZURE_SERVICE_CONNECTION>
    WebAppName: <APP_NAME>
    ResourceGroupName: <RESOURCE_GROUP>
    SourceSlot: <SLOT_NAME>
    SwapWithProduction: true

Criar um pipeline com a CLI do Azure

Para criar um pipeline de build no Azure, use o az functionapp devops-pipeline createcomando. O pipeline de compilação é criado para compilar e liberar quaisquer alterações de código feitas em seu repositório. O comando gera um novo arquivo YAML que define o pipeline de compilação e versão e, em seguida, o confirma para seu repositório. Os pré-requisitos para esse comando dependem do local do seu código.

  • Se o seu código estiver no GitHub:

    • Você deve ter permissões de gravação para sua assinatura.

    • Você deve ser o administrador do projeto no Azure DevOps.

    • Você deve ter permissões para criar um PAT (token de acesso pessoal) do GitHub que tenha permissões suficientes. Para obter mais informações, consulte requisitos de permissão do GitHub PAT.

    • Você deve ter permissões para confirmar o Branch principal em seu repositório do GitHub, para que você possa confirmar o arquivo YAML gerado automaticamente.

  • Se seu código estiver em Azure Repos:

    • Você deve ter permissões de gravação para sua assinatura.

    • Você deve ser o administrador do projeto no Azure DevOps.

Próximas etapas

  • Last updated on