Environment Variables¶

Azure Functions uses environment variables for runtime configuration, connection strings, and application settings. This reference documents the important variables, where they are configured, and their default values.

flowchart TD
    A[Configuration sources] --> B[local.settings.json for local only]
    A --> C[Azure App Settings in function app]
    A --> D["CI/CD pipeline variables and secrets"]
    C --> E[Runtime variables]
    C --> F[Monitoring variables]
    C --> G[Python worker variables]
    C --> H[Application-specific variables]

Configuration Locations¶

local.settings.json Example¶

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "FUNCTIONS_EXTENSION_VERSION": "~4",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "APPLICATIONINSIGHTS_CONNECTION_STRING": "",
    "AZURE_FUNCTIONS_ENVIRONMENT": "Development",
    "LOG_LEVEL": "DEBUG"
  }
}

Important: local.settings.json is only used during local development with func host start. It is not deployed to Azure. In Azure, the equivalent settings are configured as App Settings.

Runtime Variables¶

These variables are required or consumed by the Azure Functions runtime:

FUNCTIONS_WORKER_RUNTIME¶

Must be set to python. Without this, the Azure Functions host does not know to start the Python language worker.

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "FUNCTIONS_WORKER_RUNTIME=python"

FUNCTIONS_EXTENSION_VERSION¶

Specifies the major version of the Azure Functions runtime. Use ~4 to pin to the latest 4.x release:

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "FUNCTIONS_EXTENSION_VERSION=~4"

AzureWebJobsFeatureFlags¶

Current runtimes (4.x+) enable worker indexing by default, so this setting is not required for the v2 Python programming model.

Note: Older runtimes (< 4.x) may need this flag.

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "AzureWebJobsFeatureFlags=EnableWorkerIndexing"

AzureWebJobsStorage¶

Connection string (classic Consumption, Premium) or identity-based settings (Flex Consumption) for the Azure Storage account used by the Functions host for internal operations (lease management, timer state, Durable Functions state). For HTTP-only apps running locally, you can use Azurite:

AzureWebJobsStorage=UseDevelopmentStorage=true

For identity-based connections (required on Flex Consumption, optional on other plans), use the suffix pattern:

AzureWebJobsStorage__accountName=$STORAGE_NAME

Monitoring Variables¶

OpenTelemetry mode is configured in host.json using telemetryMode, not by a TELEMETRY_MODE environment variable:

{
  "telemetryMode": "OpenTelemetry"
}

APPLICATIONINSIGHTS_CONNECTION_STRING¶

This is the primary way to connect your function app to Application Insights. When set, the Functions runtime automatically sends request traces, dependency calls, exceptions, and performance counters:

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=xxx;IngestionEndpoint=https://eastus-8.in.applicationinsights.azure.com/"

Tip: Use the full connection string format rather than just the APPINSIGHTS_INSTRUMENTATIONKEY. The connection string supports regional endpoints and Private Link.

Python Worker Variables¶

PYTHON_THREADPOOL_THREAD_COUNT¶

Controls the thread pool size for synchronous function execution. Increase this if your functions are I/O-bound (waiting on HTTP calls, database queries):

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "PYTHON_THREADPOOL_THREAD_COUNT=16"

FUNCTIONS_WORKER_PROCESS_COUNT¶

Run multiple Python worker processes to increase throughput. Each process handles requests independently:

az functionapp config appsettings set \
  --name $APP_NAME \
  --resource-group $RG \
  --settings "FUNCTIONS_WORKER_PROCESS_COUNT=4"

Caution: More worker processes means more memory usage. On the Consumption plan, stay within the 1.5 GB memory limit per instance. On Flex Consumption, size worker count against the configured instance memory (512 MB, 2048 MB, or 4096 MB).

Application-Specific Variables¶

These are custom variables defined by the reference application:

Access any environment variable in Python:

import os

log_level = os.environ.get("LOG_LEVEL", "INFO")
environment = os.environ.get("AZURE_FUNCTIONS_ENVIRONMENT", "Production")

Setting Variables in Bicep¶

Configure app settings in your infrastructure-as-code:

resource functionApp 'Microsoft.Web/sites@2023-01-01' = {
  name: functionAppName
  location: location
  properties: {
    siteConfig: {
      appSettings: [
        { name: 'FUNCTIONS_WORKER_RUNTIME', value: 'python' }
        { name: 'FUNCTIONS_EXTENSION_VERSION', value: '~4' }
        { name: 'AzureWebJobsStorage__accountName', value: storageAccountName }
        { name: 'APPLICATIONINSIGHTS_CONNECTION_STRING', value: appInsights.properties.ConnectionString }
      ]
    }
  }
}

Note: The example above uses the classic siteConfig.appSettings pattern. On Flex Consumption, app settings are configured through functionAppConfig and resource-level properties. See the guide's infra/main.bicep for the Flex Consumption Bicep pattern.

See Also¶

• host.json Reference
• Python Runtime
• Troubleshooting

Sources¶

• Python v2 Programming Model (Microsoft Learn)