Partilhar 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ção no Azure. O Azure Pipelines permite criar, testar e implantar com integração contínua (CI) e entrega contínua (CD) usando o Azure DevOps.

Os pipelines 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ê utiliza a tarefa AzureFunctionApp para implantar o seu código. Existem agora duas versões do AzureFunctionApp, que são comparadas nesta tabela:

Comparação/versão AzureFunctionApp@2 AzureFunctionApp@1
Suporta o Plano de Consumo Flexível ✔ ❌
Inclui suporte aprimorado à validação* ✔ ❌
Quando usar... Recomendado para novas implantações de aplicativos Mantido para implantações herdadas

* O suporte de validação aprimorado torna os pipelines menos propensos a falhar devido a erros.

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

Nota

Atualize de AzureFunctionApp@1 para para AzureFunctionApp@2 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ção.

Compilar a sua aplicação

  1. Entre em sua organização do Azure DevOps e navegue até seu projeto.
  2. No 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 o GitHub como o local do seu código-fonte.
  4. Poderá ser redirecionado para o GitHub para iniciar sessão. Em caso afirmativo, insira suas credenciais do GitHub.
  5. Quando a lista de repositórios for exibida, selecione seu repositório de aplicativo de exemplo.
  6. O Azure Pipelines analisará seu repositório e recomendará um modelo. Selecione Salvar e executar, selecione Confirmar diretamente na ramificação principal e, em seguida, escolha Salvar e executar novamente.
  7. Uma nova execução é iniciada. Aguarde a conclusão da execução.

Exemplo de pipelines de construção YAML

Os seguintes pipelines específicos de idioma podem ser usados para criar aplicativos.

Você pode usar o exemplo a seguir para criar um arquivo YAML para criar 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 em sua organização do Azure DevOps e navegue até seu projeto.
  2. No seu projeto, navegue até a página Pipelines . Em seguida, selecione Novo pipeline.
  3. Selecione uma destas opções para Onde está o seu código?:
    • GitHub: Você pode ser redirecionado para o GitHub para entrar. Em caso afirmativo, insira suas credenciais do GitHub. Quando essa conexão é sua primeira conexão com o GitHub, o assistente também orienta você pelo processo de conexão do DevOps às suas contas do GitHub.
    • Azure Repos Git: Você pode escolher imediatamente um repositório em seu projeto DevOps atual.
  4. Quando a lista de repositórios for exibida, selecione seu repositório de aplicativo de exemplo.
  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ção apropriado para o seu idioma. Se não vir o modelo correto, selecione Mostrar mais.
  6. Selecione Salvar e executar, selecione Confirmar diretamente na ramificação principal e, em seguida, escolha Salvar e executar novamente.
  7. Uma nova execução é iniciada. Aguarde a conclusão da execução.

Exemplo de pipelines de construção YAML

Os seguintes pipelines específicos de idioma podem ser usados para criar aplicativos.

Você pode usar o exemplo a seguir para criar um arquivo YAML para criar 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 do Azure Functions. Para obter mais informações, consulte Visão geral das versões de tempo de execução do Azure Functions.

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'

Implante seu aplicativo

Você implantará com a tarefa Azure Function App Deploy 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 identidades de carga de trabalho.

Para implantar no Azure Functions, adicione este trecho no final do arquivo azure-pipelines.yml , dependendo se seu 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 Linux definindo como appTypefunctionAppLinux. Uma aplicação Flex Consumption é executada no Linux, e terás de definir tanto appType: functionAppLinux quanto isFlexConsumption: true.

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

Você implanta usando a tarefa Azure Function App Deploy. 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

Não há suporte para implantar numa aplicação Flex Consumption usando a tarefa @v1 de AzureFunctionApp.

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

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

Este fragmento ajusta appType para functionAppLinux, o que é necessário ao implantar em uma aplicação que corre em Linux. O padrão appType é Windows (functionApp).

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

Implantar um contêiner

Sugestão

Recomendamos usar o suporte do Azure Functions em Aplicativos de Contêiner do Azure para hospedar seu aplicativo de função em um contêiner Linux personalizado. Para obter mais informações, consulte Visão geral do Azure Functions on Azure Container Apps.

Ao implantar um aplicativo de função em contêiner, a tarefa de implantação que você usa 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ção em uma instância do Aplicativo de Contêiner do Azure otimizada para o Azure Functions.

Este código implanta a imagem base para um aplicativo de função 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>

Idealmente, você criaria seu próprio contêiner personalizado no pipeline em vez de usar uma imagem base, como mostrado neste exemplo. Para obter mais informações, consulte Implantar em aplicativos de contêiner do Azure a partir do Azure Pipelines.

Implantar em um slot

Importante

Atualmente, o plano Flex Consumption não suporta slots. Os aplicativos Linux também não suportam slots quando executados em um plano de consumo, e o suporte para esses aplicativos será desativado 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ção 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 YAML a seguir mostra como implantar em um slot de preparo e, em seguida, trocar 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, pode também adicionar a seguinte tarefa para executar uma troca de slot durante a 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 compilação no Azure, use o az functionapp devops-pipeline createcomando. O pipeline de compilação é criado para criar 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 liberação e, em seguida, confirma-o ao seu repositório. Os pré-requisitos para este comando dependem da localização 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 token de acesso pessoal (PAT) do GitHub que tenha permissões suficientes. Para obter mais informações, consulte Requisitos de permissão PAT do GitHub.

    • Você deve ter permissões para confirmar a ramificação principal em seu repositório GitHub para poder confirmar o arquivo YAML gerado automaticamente.

  • Se o seu código estiver nos repositórios do Azure:

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

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

Próximos passos

  • Analise a visão geral do Azure Functions.
  • Analise a visão geral do Azure DevOps.
  • Last updated on