Configure zone redundancy for Azure Functions

1. In the Azure portal, go to Create Function App. For more information about creating a function app in the portal, see Create a function app.

2. Select Functions Premium and then select Select.

3. On Create Function App (Functions Premium), on the Basics tab, enter the settings for your function app. Pay special attention to the settings in the following table (also highlighted in the following screenshot), which have specific requirements for zone redundancy.

   Setting	Suggested value	Notes for zone redundancy
   Region	Your preferred supported region	The region in which you create your Elastic Premium plan. Pick a region that supports availability zones. For a list of regions that support zone redundancy for Azure Functions Premium plans, see Reliability in Azure Functions - Resilience to availability zone failures - Requirements.
   Pricing plan	One of the Elastic Premium plans. For more information, see Available instance SKUs.	This article describes how to create a zone redundant app in a Premium plan. Zone redundancy isn't currently available in Consumption plans. For information on zone redundancy on App Service plans, see Configure availability zones for App Service.
   Zone redundancy	Enabled	This setting specifies whether your app is zone redundant. You can't select Enabled unless you choose a region that supports zone redundancy, as described previously.

   

4. On the Storage tab, enter the settings for your function app storage account. Pay special attention to the setting in the following table, which has specific requirements for zone redundancy.

   Setting	Suggested value	Notes for zone redundancy
   Storage account	A zone-redundant storage account	As described in the reliability guide for Azure Functions, use a zone-redundant storage account for your zone-redundant function app.

5. For the rest of the function app creation process, create your function app as normal. There are no settings in the rest of the creation process that affect zone redundancy.

1. When creating the storage account for the function app, choose a zone redundant SKU, such as Standard_ZRS. For example:

   az storage account create \
     --name <STORAGE_NAME> \
     --location <REGION> \
     --resource-group <RESOURCE_GROUP> \
     --sku Standard_ZRS \
     --allow-blob-public-access false
   

2. When creating the Premium plan, add the --zone-redundant true parameter:

   az functionapp plan create \
     --resource-group <RESOURCE_GROUP> \
     --name <PLAN_NAME> \
     --location <REGION> \
     --sku EP1 \
     --zone-redundant true
   

3. Create the function app and associate it with the zone-redundant Premium plan:

   az functionapp create \
     --resource-group <RESOURCE_GROUP> \
     --name <APP_NAME> \
     --storage-account <STORAGE_NAME> \
     --plan <PLAN_NAME> \
     --runtime <RUNTIME> \
     --runtime-version <RUNTIME_VERSION>
   

You can use a Bicep file to deploy to a zone-redundant Premium plan. To learn how to deploy function apps to a Premium plan, see Automate resource deployment in Azure Functions.

The only properties to be aware of while creating a zone-redundant hosting plan are the zoneRedundant property and the plan's instance count (capacity) fields. Set the zoneRedundant property to true and set the capacity property based on the workload requirement, but not less than 3. Choosing the right capacity varies based on several factors and high availability and fault tolerance strategies. A good rule of thumb is to specify sufficient instances for the application to ensure that losing one zone instance leaves sufficient capacity to handle expected load.

The following snippet is a Bicep template for a zone-redundant, Premium plan. It shows the zoneRedundant field and the capacity specification.

resource EPFuncPlan 'Microsoft.Web/serverfarms@2024-04-01' = {
    name: '<YOUR_PLAN_NAME>'
    location: '<YOUR_REGION_NAME>'
    sku: {
        name: 'EP1'
        tier: 'ElasticPremium'
        size: 'EP1'
        family: 'EP'
        capacity: 3
    }
    kind: 'elastic'
    properties: {
        perSiteScaling: false
        elasticScaleEnabled: true
        maximumElasticWorkerCount: 20
        isSpot: false
        reserved: false
        isXenon: false
        hyperV: false
        targetWorkerCount: 0
        targetWorkerSizeId: 0
        zoneRedundant: true
    }
}

To learn more about these templates, see Automate resource deployment in Azure Functions.

You can use an ARM template to deploy to a zone-redundant Premium plan. To learn how to deploy function apps to a Premium plan, see Automate resource deployment in Azure Functions.

The only properties to be aware of while creating a zone-redundant hosting plan are the zoneRedundant property and the plan's instance count (capacity) fields. Set the zoneRedundant property to true and set the capacity property based on the workload requirement, but not less than 3. Choosing the right capacity varies based on several factors and high availability and fault tolerance strategies. A good rule of thumb is to specify sufficient instances for the application to ensure that losing one zone instance leaves sufficient capacity to handle expected load.

The following snippet is an ARM template for a zone-redundant, Premium plan. It shows the zoneRedundant field and the capacity specification.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
        "type": "Microsoft.Web/serverfarms",
        "apiVersion": "2024-04-01",
        "name": "<YOUR_PLAN_NAME>",
        "location": "<YOUR_REGION_NAME>",
        "sku": {
            "name": "EP1",
            "tier": "ElasticPremium",
            "size": "EP1",
            "family": "EP", 
            "capacity": 3
        },
        "kind": "elastic",
        "properties": {
            "perSiteScaling": false,
            "elasticScaleEnabled": true,
            "maximumElasticWorkerCount": 20,
            "isSpot": false,
            "reserved": false,
            "isXenon": false,
            "hyperV": false,
            "targetWorkerCount": 0,
            "targetWorkerSizeId": 0, 
            "zoneRedundant": true
        }
    }
  ]
}

To learn more about these templates, see Automate resource deployment in Azure Functions.

Not currently supported, choose another tab.

Follow these steps to enable zone redundancy on an existing Elastic Premium plan:

1. Enable zone redundancy on the plan:

   az appservice plan update \
     --resource-group <RESOURCE_GROUP> \
     --name <PLAN_NAME> \
     --set zoneRedundant=true sku.capacity=2
   

   Note

   The sku.capacity=2 parameter in this command sets the intended minimum, but the system doesn't enforce it until you complete step 2.

2. Update always-ready instances to at least 2 for each function app that needs to be zone redundant in the plan:

   az functionapp update \
     --resource-group <RESOURCE_GROUP> \
     --name <APP_NAME> \
     --set siteConfig.minimumElasticInstanceCount=2
   

   The plan's actual sku.capacity updates to reflect the highest minimumElasticInstanceCount across all apps.

To disable zone redundancy on an existing plan:

az appservice plan update \
  --resource-group <RESOURCE_GROUP> \
  --name <PLAN_NAME> \
  --set zoneRedundant=false

After disabling zone redundancy, you can optionally reduce minimumElasticInstanceCount back to 1 on your function apps if desired.

You can update an existing Elastic Premium plan to be zone-redundant by using Bicep templates. The following example shows how to enable zone redundancy:

resource EPFuncPlan 'Microsoft.Web/serverfarms@2024-04-01' existing = {
  name: '<YOUR_PLAN_NAME>'
}

resource EPFuncPlanUpdate 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: EPFuncPlan.name
  location: EPFuncPlan.location
  sku: {
    name: 'EP1'
    tier: 'ElasticPremium'
    size: 'EP1'
    family: 'EP'
    capacity: 2
  }
  kind: 'elastic'
  properties: {
    perSiteScaling: false
    elasticScaleEnabled: true
    maximumElasticWorkerCount: 20
    isSpot: false
    reserved: false
    isXenon: false
    hyperV: false
    targetWorkerCount: 0
    targetWorkerSizeId: 0
    zoneRedundant: true
  }
}

resource FunctionApp 'Microsoft.Web/sites@2024-04-01' = {
  name: '<YOUR_APP_NAME>'
  location: EPFuncPlan.location
  kind: 'functionapp'
  properties: {
    serverFarmId: EPFuncPlan.id
    siteConfig: {
      minimumElasticInstanceCount: 2
    }
  }
}

You can update an existing Elastic Premium plan to be zone-redundant by using ARM templates. The following example shows how to enable zone redundancy:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2024-04-01",
      "name": "<YOUR_PLAN_NAME>",
      "location": "<YOUR_REGION_NAME>",
      "sku": {
        "name": "EP1",
        "tier": "ElasticPremium",
        "size": "EP1",
        "family": "EP",
        "capacity": 2
      },
      ...
      "properties": {
        ...
        "zoneRedundant": true
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2024-04-01",
      "name": "<YOUR_APP_NAME>",
      "location": "<YOUR_REGION_NAME>",
      "kind": "functionapp",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', '<YOUR_PLAN_NAME>')]",
        "siteConfig": {
          "minimumElasticInstanceCount": 2
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', '<YOUR_PLAN_NAME>')]"
      ]
    }
  ]
}

In the Azure portal, go to your function app. Under Settings, select Instances. The Instances page shows each running instance and the availability zone it's placed in.

Use the following commands to query instance zone placement:

RESOURCE_ID=$(az functionapp show \
  --resource-group <RESOURCE_GROUP> \
  --name <APP_NAME> \
  --query id -o tsv)

az rest \
  --method get \
  --url "${RESOURCE_ID}/instances?api-version=2024-04-01" \
  --query "value[].{machineName:properties.machineName, physicalZone:properties.physicalZone}" \
  -o table

In this example, replace <RESOURCE_GROUP> and <APP_NAME> with the names of your resource group and function app, respectively.

Example output:

MachineName     PhysicalZone
--------------  --------------
pl1sdlwk0002Q7  chinanorth2-az3
pl0sdlwk0002HP  chinanorth2-az1

In the output:

• machineName is the internal name of the worker instance.
• physicalZone shows the actual availability zone the instance is placed in (format: {region}-az{N}).
• For a zone-redundant plan with two or more instances, you see instances distributed across different zones.