Managing configuration settings for Azure Functions

Question

Pulumi · Accepted Answer

Creating and managing configuration settings for Azure Functions involves defining the settings within an Azure Function App resource. Configuration settings are essentially environment variables used by the Azure Function runtime. These settings can include connection strings, API endpoints, or any other key-value pairs that your function needs to operate.

Below is an example of how to create an Azure Function App with specific application settings using Pulumi in TypeScript. We'll be using the `azure-native` provider package, which interfaces directly with Azure resources.

First, you'll need to import the required Pulumi and Azure Native SDK components. Then create an Azure Resource Group which acts as a logical container for your Azure Function App. Next, define an App Service Plan that will host your function app. Finally, define the Function App itself, including the app settings as part of the site configuration.

In the example, `appSettings` is an object that represents the configuration settings for the function app. For example, setting "FUNCTIONS_WORKER_RUNTIME" to "node" specifies that the function will use Node.js as the runtime.

Here's the TypeScript code:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native";

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: "MyFunctionAppResourceGroup",
});

// Create an Azure App Service Plan
const appServicePlan = new azure.web.AppServicePlan("appServicePlan", {
    resourceGroupName: resourceGroup.name,
    kind: "FunctionApp",
    // Consumption plan is suitable for serverless workloads
    sku: {
        name: "Y1",
        tier: "Dynamic",
    },
});

// Create an Azure Function App
const functionApp = new azure.web.WebApp("functionApp", {
    resourceGroupName: resourceGroup.name,
    serverFarmId: appServicePlan.id,
    kind: "FunctionApp",
    siteConfig: {
        appSettings: [
            { name: "FUNCTIONS_WORKER_RUNTIME", value: "node" }, // Modify as needed for your runtime
            { name: "APPLICATION_SETTING1", value: "value1" },
            // Add additional settings as needed
        ],
    },
    httpsOnly: true, // It is a good practice to only allow HTTPS traffic
});

// Export the Function App URL
export const endpoint = pulumi.interpolate`https://${functionApp.defaultHostName}/api/{functionName}`;
```

In this code:

- We are creating a new resource group called `MyFunctionAppResourceGroup`.
- An App Service Plan `appServicePlan` is instantiated, specifying the type of hosting to be serverless (`Dynamic` SKU in this case).
- The Function App `functionApp` is created, which is where our functions will reside.
- Within the `siteConfig` of our `functionApp`, we specify the app settings. This is where you would include any configuration key-value pairs that your Azure Function needs.
- The `httpsOnly` property ensures the Function App is only accessible via HTTPS.
- Finally, the code exports the endpoint URL of your Function App. Use this URL to invoke your functions.

After writing and deploying this code using Pulumi, you should have a fully configured Azure Function App that's ready for you to deploy your functions to. Remember to fill in the site configuration with your actual application settings.