Scheduling Functions in Azure App Service with CRON Expressions

Question

Pulumi · Accepted Answer

Scheduling functions in Azure App Service with CRON expressions involves creating an Azure Function App, where you can deploy your code that will be executed according to a schedule defined by a CRON expression. In Pulumi, you would create an `AppService` with an associated `FunctionApp`, and then define the function's schedule within the app settings or the timer trigger function binding, depending on how you've structured your function.

Here is how you can do it:

1. **Define an App Service Plan**: This is the environment where your function app will run. You can choose the pricing tier that best suits your needs.

2. **Create a Function App**: This is the actual application where you will deploy your function code.

3. **Set Up the Timer Trigger**: A timer trigger uses a CRON expression to execute the function at regular intervals. The CRON schedule is part of the function's binding definition.

Below is a Pulumi program written in TypeScript that demonstrates how to set up an Azure Function App scheduled to run using a CRON expression.

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

// Step 1: Create an App Service Plan
const appServicePlan = new azure.appservice.Plan("app-service-plan", {
    resourceGroupName: "resource-group-name",
    location: "West US",
    sku: {
        tier: "Standard",
        size: "S1",
    },
});

// Step 2: Create the Function App 
// This Function App will use a consumption plan and deploy from a public GitHub repository.
const app = new azure.appservice.FunctionApp("function-app", {
    resourceGroupName: "resource-group-name",
    location: "West US",
    appServicePlanId: appServicePlan.id,
    appSettings: {
        // Settings for the Azure timer trigger: define your CRON expression here
        // CRON format: {second} {minute} {hour} {day} {month} {day-of-week}
        // Example: "0 */5 * * * *" runs every 5 minutes
        "FUNCTIONS_WORKER_RUNTIME": "node", // sets runtime to Node.js
        "WEBSITE_RUN_FROM_PACKAGE": "1", // runs the function from a package (zip file, or any other deployment)
        // Specify the Timer Trigger's CRON expression here
        "TimerTriggerCron": "0 0 */2 * * *", // every 2 hours
    },
    // Specify source code repository
    // If you have a repository with the function code, provide its URL here.
    sourceControl: {
        repoUrl: "https://github.com/your-repository/function-app-code.git",
        branch: "main",
    },
});

// Step 3: Define the resource export
// Export the Function App's endpoint for easy access.
export const endpoint = pulumi.interpolate`https://${app.defaultHostname}/api/your-timer-trigger-function-name`;
```

This Pulumi program sets up a Node.js function app that uses a timer trigger with a CRON expression for scheduling. The CRON format used in the `appSettings` defines when the function should be executed.

Please replace `"resource-group-name"` with the actual name of your Azure Resource Group, and adjust the CRON expression in `"TimerTriggerCron"` to fit the schedule you desire for your Azure Function. Additionally, replace `https://github.com/your-repository/function-app-code.git` with the URL of your GitHub repository containing the function code. Ensure your function code includes a timer trigger binding with the same CRON expression you've defined in the `appSettings`.

The endpoint of your function will be exported, so you can easily access it and test the function invocation.