MSDN Tutorials

Automating Azure Functions Deployment with Azure DevOps Pipelines

This tutorial guides you through setting up an Azure DevOps pipeline to automatically deploy your Azure Functions. By leveraging CI/CD principles, you can streamline your development workflow and ensure consistent deployments.

Prerequisites

• An Azure subscription.
• An Azure DevOps organization and project.
• An Azure Function App created in your Azure subscription.
• Your Azure Functions code hosted in a Git repository (e.g., Azure Repos, GitHub).

Step 1: Create a New Pipeline

Navigate to your Azure DevOps project and go to the Pipelines section. Click on Create Pipeline.

Choose your repository source (e.g., Azure Repos Git, GitHub) and select the repository containing your Azure Functions code.

Step 2: Configure the Pipeline (YAML)

Azure DevOps will suggest a starter pipeline. We'll use a YAML definition to configure our build and release process.

Replace the default content with the following YAML:

trigger:
  branches:
    include:
      - main # Or your main branch name

pool:
  vmImage: 'windows-latest' # Or 'ubuntu-latest'

variables:
  azureSubscription: 'Your Azure Service Connection Name' # Replace with your Service Connection name
  functionAppName: 'your-function-app-name' # Replace with your Function App name
  azureFunctionSlotName: 'production' # Or the slot name you want to deploy to

steps:
- task: AzureFunctionApp@1
  displayName: 'Deploy Azure Functions'
  inputs:
    azureSubscription: '$(azureSubscription)'
    appType: 'functionApp'
    appName: '$(functionAppName)'
    package: '$(Build.ArtifactStagingDirectory)/functionapp.zip'
    deploymentMethod: 'zipDeploy'
    deployToSlotOrASE: true
    resourceGroupName: 'your-resource-group-name' # Replace with your resource group name
    slotName: '$(azureFunctionSlotName)'
    # Optional: For specific runtime versions, uncomment and adjust
    # runtime: 'dotnet' # e.g., 'dotnet', 'node', 'python', 'powershell'
    # project: '$(Build.SourcesDirectory)/YourFunctionProjectFolder' # Path to your function app project directory

# If you need a build step before deployment (e.g., for .NET, Node.js)
# - task: DotNetCoreCLI@2
#   displayName: 'Build .NET Core App'
#   inputs:
#     command: 'publish'
#     publishWebProjects: false
#     arguments: '--configuration Release --output $(Build.ArtifactStagingDirectory)'
#     zipAfterPublish: true

# - task: ArchiveFiles@2
#   displayName: 'Archive files'
#   inputs:
#     rootFolderOrFile: '$(Build.ArtifactStagingDirectory)'
#     includeRootFolder: false
#     archiveType: 'zip'
#     archiveFile: '$(Build.ArtifactStagingDirectory)/functionapp.zip'
#     replaceExisting: true

# Example for Node.js (adjust as needed)
# - task: Npm@1
#   displayName: 'npm install and build'
#   inputs:
#     command: 'install'
#     workingDir: '$(Build.SourcesDirectory)/YourFunctionProjectFolder'
# - task: Npm@1
#   displayName: 'npm build (if applicable)'
#   inputs:
#     command: 'custom'
#     customCommand: 'run build'
#     workingDir: '$(Build.SourcesDirectory)/YourFunctionProjectFolder'
# - task: ArchiveFiles@2
#   displayName: 'Archive Node.js Function App'
#   inputs:
#     rootFolderOrFile: '$(Build.SourcesDirectory)/YourFunctionProjectFolder'
#     includeRootFolder: false
#     archiveType: 'zip'
#     archiveFile: '$(Build.ArtifactStagingDirectory)/functionapp.zip'
#     replaceExisting: true

                        Copy
                    

Explanation of Key Fields:

• trigger: Defines when the pipeline should run. Here, it's set to trigger on commits to the main branch.
• pool: Specifies the agent pool to use for running the pipeline. windows-latest or ubuntu-latest are common choices.
• variables: Defines variables for your pipeline. Make sure to replace placeholders with your actual values.
• azureSubscription: The name of your Azure service connection in Azure DevOps. This connection authenticates to your Azure subscription.
• functionAppName: The name of your Azure Function App resource.
• azureFunctionSlotName: The deployment slot to deploy to. production is common, but you might use other slots for staging or testing.
• task: AzureFunctionApp@1: This task is specifically designed for deploying Azure Function Apps.
• inputs: Configuration for the AzureFunctionApp@1 task.
  • azureSubscription, appName, slotName: Refer to the variables defined above.
  • package: Points to the ZIP file containing your function app code. This is usually generated by a build step.
  • deploymentMethod: 'zipDeploy': A recommended method for deploying Azure Functions.
  • deployToSlotOrASE: true: Enables deployment to a slot.
  • resourceGroupName: The Azure resource group where your Function App resides.
• Commented-out build tasks: Depending on your function app's runtime (.NET, Node.js, Python, etc.), you'll need to add appropriate build tasks before the deployment step to package your code.

Step 3: Set Up Azure Service Connection

Before the pipeline can deploy to Azure, it needs to authenticate. In your Azure DevOps project, go to Project settings > Service connections.

Click Create service connection, select Azure Resource Manager, and choose the authentication method (e.g., Service principal automatic).

Follow the prompts to select your subscription and resource group. Give the service connection a meaningful name (e.g., AzureDevOpsConnection) and ensure this name matches the azureSubscription variable in your YAML pipeline.

Step 4: Run the Pipeline

Save your pipeline definition. You can then manually trigger a run by clicking the Run pipeline button on the pipeline view. If you committed the YAML to your repository, it will trigger automatically based on your trigger configuration.

Step 5: Verify Deployment

Once the pipeline run completes successfully, navigate to your Azure Function App in the Azure portal. Check the Deployment Center to see the deployment history. You can also test your function endpoints to ensure they are working correctly.

Advanced Scenarios

• Multiple Environments: Use separate deployment slots (e.g., staging, production) and create separate stages or jobs in your pipeline to deploy to each.
• Approval Gates: Implement manual approval steps before deploying to production to ensure quality control.
• Testing: Integrate automated testing (unit tests, integration tests) into your pipeline before or after deployment.
• Configuration Management: Use Azure Key Vault for managing secrets and application settings.

By following these steps, you can establish a robust and automated deployment process for your Azure Functions, significantly improving your team's productivity and the reliability of your applications.