Edit

Share via

Continuous delivery with Azure Pipelines

  • Article
  • 11/07/2024

Use Azure Pipelines to automatically deploy to Azure Functions. Azure Pipelines lets you build, test, and deploy with continuous integration (CI) and continuous delivery (CD) using Azure DevOps.

YAML pipelines are defined using a YAML file in your repository. A step is the smallest building block of a pipeline and can be a script or task (prepackaged script). Learn about the key concepts and components that make up a pipeline.

You'll use the AzureFunctionApp task to deploy to Azure Functions. There are now two versions of the AzureFunctionApp task (AzureFunctionApp@1, AzureFunctionApp@2). AzureFunctionApp@2 includes enhanced validation support that makes pipelines less likely to fail because of errors.

Choose your task version at the top of the article. YAML pipelines aren't available for Azure DevOps 2019 and earlier.

Note

The AzureFunctionApp@2 is highly recommended. Deploying to an app on the Flex Consumption plan is only supported in version 2.

Prerequisites

Build your app

  1. Sign in to your Azure DevOps organization and navigate to your project.
  2. In your project, navigate to the Pipelines page. Then select New pipeline.
  3. Select one of these options for Where is your code?:
    • GitHub: You might be redirected to GitHub to sign in. If so, enter your GitHub credentials. When this connection is your first GitHub connection, the wizard also walks you through the process of connecting DevOps to your GitHub accounts.
    • Azure Repos Git: You're immediately able to choose a repository in your current DevOps project.
  4. When the list of repositories appears, select your sample app repository.
  5. Azure Pipelines analyzes your repository and in Configure your pipeline provides a list of potential templates. Choose the appropriate function app template for your language. If you don't see the correct template select Show more.
  6. Select Save and run, then select Commit directly to the main branch, and then choose Save and run again.
  7. A new run is started. Wait for the run to finish.

Example YAML build pipelines

The following language-specific pipelines can be used for building apps.

You can use the following sample to create a YAML file to build a .NET app.

If you see errors when building your app, verify that the version of .NET that you use matches your Azure Functions version. For more information, see Azure Functions runtime versions overview.

pool:
  vmImage: 'windows-latest'
steps:
- script: |
    dotnet restore
    dotnet build --configuration Release
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    arguments: '--configuration Release --output publish_output'
    projects: '*.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'

Deploy your app

You'll deploy with the Azure Function App Deploy task. This task requires an Azure service connection as an input. An Azure service connection stores the credentials to connect from Azure Pipelines to Azure.

To deploy to Azure Functions, add the following snippet at the end of your azure-pipelines.yml file. The default appType is Windows. You can specify Linux by setting the appType to functionAppLinux. Deploying to a Flex Consumption app is not supported with @v1 of the AzureFunctionApp task.

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: <Azure service connection>
    appType: functionAppLinux # default is functionApp
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.zip
    #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 Name>'
    #slotName: '<Slot name>'

The snippet assumes that the build steps in your YAML file produce the zip archive in the $(System.ArtifactsDirectory) folder on your agent.

Deploy a container

You can automatically deploy your code as a containerized function app after every successful build. To learn more about containers, see Working with containers and Azure Functions.

The simplest way to deploy to a container is to use the Azure Function App on Container Deploy task.

To deploy, add the following snippet at the end of your YAML file:

trigger:
- main

variables:
  # Container registry service connection established during pipeline creation
  dockerRegistryServiceConnection: <Docker registry service connection>
  imageRepository: <Name of your image repository>
  containerRegistry: <Name of the Azure container registry>
  dockerfilePath: '$(Build.SourcesDirectory)/Dockerfile'
  tag: '$(Build.BuildId)'

  # Agent VM image name
  vmImageName: 'ubuntu-latest'

- task: AzureFunctionAppContainer@1 # Add this at the end of your file
  inputs:
    azureSubscription: '<Azure service connection>'
    appName: '<Name of the function app>'
    imageName: $(containerRegistry)/$(imageRepository):$(tag)

The snippet pushes the Docker image to your Azure Container Registry. The Azure Function App on Container Deploy task pulls the appropriate Docker image corresponding to the BuildId from the repository specified, and then deploys the image.

For a complete end-to-end pipeline example, including building the container and publishing to the container registry, see this Azure Pipelines container deployment example.

Deploy to a slot

You can configure your function app to have multiple slots. Slots allow you to safely deploy your app and test it before making it available to your customers.

The following YAML snippet shows how to deploy to a staging slot, and then swap to a production slot:

- 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

Create a pipeline with Azure CLI

To create a build pipeline in Azure, use the az functionapp devops-pipeline create command. The build pipeline is created to build and release any code changes that are made in your repo. The command generates a new YAML file that defines the build and release pipeline and then commits it to your repo. The prerequisites for this command depend on the location of your code.

  • If your code is in GitHub:

    • You must have write permissions for your subscription.

    • You must be the project administrator in Azure DevOps.

    • You must have permissions to create a GitHub personal access token (PAT) that has sufficient permissions. For more information, see GitHub PAT permission requirements.

    • You must have permissions to commit to the main branch in your GitHub repository so you can commit the autogenerated YAML file.

  • If your code is in Azure Repos:

    • You must have write permissions for your subscription.

    • You must be the project administrator in Azure DevOps.

Build your app

  1. Sign in to your Azure DevOps organization and navigate to your project.
  2. In your project, navigate to the Pipelines page. Then choose the action to create a new pipeline.
  3. Walk through the steps of the wizard by first selecting GitHub as the location of your source code.
  4. You might be redirected to GitHub to sign in. If so, enter your GitHub credentials.
  5. When the list of repositories appears, select your sample app repository.
  6. Azure Pipelines will analyze your repository and recommend a template. Select Save and run, then select Commit directly to the main branch, and then choose Save and run again.
  7. A new run is started. Wait for the run to finish.

Example YAML build pipelines

The following language-specific pipelines can be used for building apps.

You can use the following sample to create a YAML file to build a .NET app:

pool:
  vmImage: 'windows-latest'
steps:
- script: |
    dotnet restore
    dotnet build --configuration Release
- task: DotNetCoreCLI@2
  inputs:
    command: publish
    arguments: '--configuration Release --output publish_output'
    projects: '*.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'

Deploy your app

You'll deploy with the Azure Function App Deploy v2 task. This task requires an Azure service connection as an input. An Azure service connection stores the credentials to connect from Azure Pipelines to Azure. You should create a connection that uses workload identity federation.

The v2 version of the task includes support for newer applications stacks for .NET, Python, and Node. The task includes networking predeployment checks. When there are predeployment issues, deployment stops.

To deploy to Azure Functions, add the following snippet at the end of your azure-pipelines.yml file. The default appType is Windows. You can specify Linux by setting the appType to functionAppLinux. Deploying to a Flex Consumption app requires you to set both appType: functionAppLinux and isFlexConsumption: true.

trigger:
- main

variables:
  # Azure service connection established during pipeline creation
  azureSubscription: <SUBSCRIPTION_NAME>
  appName: <APP_NAME>
  # Agent VM image name
  vmImageName: 'windows-latest'

- task: AzureFunctionApp@2 # Add this at the end of your file
  inputs:
    azureSubscription: <AZURE_SERVICE_CONNECTION>
    appType: functionApp # this specifies a Windows-based function app
    appName: $(appName)
    package: $(System.ArtifactsDirectory)/**/*.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>'

Next steps

Additional resources