Configure zone redundancy for Azure Functions

1. To create a function app in a zone-redundant plan, you must have an existing zone-redundant storage account. If you don't already have a zone-redundant storage account, create one before you proceed.

2. 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.

3. Select Flex Consumption and then select the Select button.

4. On the Create Function App (Flex Consumption) page, 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 your Flex Consumption plan is created. 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.
   Zone redundancy	Enabled	This setting specifies whether your app is zone redundant. You can only select Enabled when you've chosen a region that supports zone redundancy.

   

5. On the Storage tab, select the zone-redundant storage account for your function app. 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.

6. 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 Flex Consumption plan and app, add the --zone-redundant true parameter:

   az functionapp create \
     --resource-group <RESOURCE_GROUP> \
     --name <APP_NAME> \
     --storage-account <STORAGE_NAME> \
     --flexconsumption-location <REGION> \
     --runtime <RUNTIME> \
     --runtime-version <RUNTIME_VERSION> \
     --zone-redundant true 
   

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

The only property to be aware of while creating a zone-redundant hosting plan is the zoneRedundant property. Set the zoneRedundant property to true.

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

resource flexFuncPlan 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: <YOUR_PLAN_NAME>
  location: <YOUR_REGION_NAME>
  kind: 'functionapp'
  sku: {
    tier: 'FlexConsumption'
    name: 'FC1'
  }
  properties: {
    reserved: true
    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 Flex Consumption plan. To learn how to deploy function apps to a Flex Consumption plan, see Automate resource deployment in Azure Functions.

The only property to be aware of while creating a zone-redundant hosting plan is the zoneRedundant property. Set the zoneRedundant property to true.

The following ARM template snippet is for a zone-redundant, Flex Consumption plan. It shows the zoneRedundant field 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>",
      "kind": "functionapp",
      "sku": {
        "tier": "FlexConsumption",
        "name": "FC1"
      },
      "properties": {
        "reserved": true,
        "zoneRedundant": true
      }
    }
  ]
}

To learn more about these templates, see Automate resource deployment in 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.

1. In the Azure portal, search for and select the function app to update.

2. Under Settings, select Scale and Concurrency.

3. On the Zone redundancy tab, check Add zone redundancy to enable the feature. If already checked, you can uncheck this box to disable the feature.

4. Select Save to commit your changes and restart the app.

Update the app by using the --zone-redundant parameter of the az functionapp plan update command. Use a value of true to enable zone redundancy and false to disable the feature. This example enables zone redundancy for an existing app in a Flex Consumption plan:

PLAN_RESOURCE_ID=$(az functionapp show --resource-group <RESOURCE_GROUP> --name <APP_NAME> --query "properties.serverFarmId"  -o tsv) 

az functionapp plan update --ids $PLAN_RESOURCE_ID --set zoneRedundant=true

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

You can use this Bicep file to add the zoneRedundant property set to true in an existing plan definition:

resource existingServerFarm 'Microsoft.Web/serverfarms@2024-04-01' existing = {
  name: '<YOUR_PLAN_NAME>'
  scope: resourceGroup()
}

resource updatedServerFarm 'Microsoft.Web/serverfarms@2024-04-01' = {
  name: existingServerFarm.name
  location: '<YOUR_REGION_NAME>'
  kind: 'functionapp'
  sku: {
    tier: 'FlexConsumption'
    name: 'FC1'
  }
  properties: {
    reserved: true
    zoneRedundant: true  // Enables zone redundancy
  }
}

In this file, replace <YOUR_PLAN_NAME> and <YOUR_REGION_NAME> with the name of your plan and region, respectively. To learn how to deploy a Bicep file, see Deploy your template.

You can use this ARM template fragment to set the zoneRedundant property to true in an existing plan definition:

{
  "$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>",
      "kind": "functionapp",
      "sku": {
        "tier": "FlexConsumption",
        "name": "FC1"
      },
      "properties": {
        "reserved": true,
        "zoneRedundant": true
      }
    }
  ]
}

In this template, replace <YOUR_PLAN_NAME> and <YOUR_REGION_NAME> with the name of your plan and region, respectively. To learn how to deploy an ARM template, see Deploy your template.

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  westus3-az3
pl0sdlwk0002HP  westus3-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.