Deploying zipped code packages to Azure Functions

Question

Pulumi · Accepted Answer

Deploying zipped code packages to Azure Functions involves several steps: you need to create the necessary Azure resources, such as an App Service plan, and a Function App. Then, you'll deploy your zipped code package to the Function App.

In Pulumi, this process is described with code that defines the desired state of your cloud resources. Pulumi then makes the necessary API calls to Azure to make the cloud environment match your code.

Below, I will provide you with a Pulumi program written in TypeScript that accomplishes the following:

1. Creates a resource group to contain and organize Azure resources.
2. Defines an App Service plan, which is a set of compute resources for your function to run on.
3. Establishes a Function App, which is the context in which your function code will execute.
4. Deploys the zipped code package to the Function App.

Here is the detailed code to set up and deploy a zipped code package to Azure Functions using Pulumi:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as storage from "@pulumi/azure-native/storage";
import * as web from "@pulumi/azure-native/web";
import * as resource from "@pulumi/azure-native/resources";

// Create an Azure Resource Group
const resourceGroup = new resource.ResourceGroup("my-resource-group");

// Create a Storage Account required by the Function App
const storageAccount = new storage.StorageAccount("mystorageaccount", {
    resourceGroupName: resourceGroup.name,
    kind: "StorageV2",
    sku: {
        name: "Standard_LRS",
    },
});

// Export the primary key of the Storage Account
const storageAccountKeys = pulumi.all([resourceGroup.name, storageAccount.name]).apply(
    ([resourceGroupName, accountName]) => {
        return storage.listStorageAccountKeys({ resourceGroupName, accountName });
    },
);

const primaryStorageKey = storageAccountKeys.keys[0].value;

// Create a Service Plan (required to deploy the Function App)
const appServicePlan = new web.AppServicePlan("myappserviceplan", {
    resourceGroupName: resourceGroup.name,
    kind: "FunctionApp",
    sku: {
        name: "Y1",
        tier: "Dynamic",
    },
});

// Create a Function App
const app = new web.WebApp("myfunctionapp", {
    resourceGroupName: resourceGroup.name,
    serverFarmId: appServicePlan.id,
    siteConfig: {
        appSettings: [
            { name: "AzureWebJobsStorage", value: primaryStorageKey },
            { name: "FUNCTIONS_WORKER_RUNTIME", value: "node" },
            { name: "WEBSITE_NODE_DEFAULT_VERSION", value: "~10" },
        ],
        http2Enabled: true,
    },
    kind: "FunctionApp",
    httpsOnly: true,
});

// Deploy zipped code to the Function App using the `WEBSITE_RUN_FROM_PACKAGE` app setting
app.siteConfig.apply(siteConfig => {
    const appSettings = siteConfig.appSettings || [];
    appSettings.push({
        name: "WEBSITE_RUN_FROM_PACKAGE",
        value: "https://mysite.com/path/to/functionapp.zip",
    });
    return {
        appSettings,
    };
});

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

Let's go over the key parts of this program:

- We use the `@pulumi/azure-native/resources`, `@pulumi/azure-native/storage`, and `@pulumi/azure-native/web` packages to interact with Azure resources in our code.
- We create a new resource group that will contain all of the resources for our function app using `new resource.ResourceGroup`.
- A storage account is necessary for Azure Functions to store the function execution logs, code, and other system-generated files.
- The `appServicePlan` defines the compute resources your function will run on. For Azure Functions, we can use the `Y1` SKU, which corresponds to the Dynamic (Consumption) plan, where billing is based on the function’s actual resource usage.
- The `app` is a `web.WebApp` resource representing the Azure Function App itself.
- In the `siteConfig.appSettings`, we configure important settings for the Function App, including the connection to the Azure Storage Account via `AzureWebJobsStorage` and the runtime for the functions through `FUNCTIONS_WORKER_RUNTIME`.
- The `WEBSITE_RUN_FROM_PACKAGE` app setting points to the URL of the zipped code package. This can be a SAS URL pointing to a blob in Azure Blob Storage, or any other valid HTTP/HTTPS URL that points to your zipped code package. You would replace "https://mysite.com/path/to/functionapp.zip" with the URL of your actual package.
- Finally, we export the endpoint of the Function App, which you can use to call your deployed functions.

Please note that the `primaryStorageKey` is sensitive and should be handled according to your security best practices. Moreover, you'll need to replace `https://mysite.com/path/to/functionapp.zip` with the URL to your own zipped package.

To deploy this program, you will compile it to JavaScript using `tsc`, the TypeScript compiler, and then run `pulumi up` through the Pulumi CLI. Ensure you have set up your Azure credentials correctly and Pulumi is [authenticated](https://www.pulumi.com/docs/intro/cloud-providers/azure/setup/) with Azure.