Using azure appservice with timermonitor

Question

Pulumi · Accepted Answer

To create a scheduled function using Azure App Service with a timer trigger, we are going to provision an Azure Function App that runs a simple function on a schedule. A timer trigger for Azure Functions is like a cron job that allows you to run a function at a scheduled time.

In the Pulumi program below, you'll see an example of how to create a Function App with a timer trigger. This example assumes that you have already set up the necessary Pulumi configuration and Azure account.

Here are the steps we are going to take in the Pulumi program:
1. Create a new resource group to organize our resources.
2. Create an App Service Plan which defines the underlying host for our Function App.
3. Create a Storage Account required by the Function App to manage its state and the function's execution.
4. Create the Function App itself within the context of the resource group, service plan, and storage account.
5. Define the timer trigger as part of the App Settings for the Function App.

Take a look at the TypeScript program below:

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "West Europe",
});

// Create an Azure App Service Plan
const appServicePlan = new azure.appservice.Plan("myAppServicePlan", {
    resourceGroupName: resourceGroup.name,
    kind: "FunctionApp",
    sku: {
        tier: "Dynamic",
        size: "Y1", // This is the consumption plan, which is pay-per-execution
    },
    location: resourceGroup.location,
});

// Create an Azure Storage Account for the Function App
const storageAccount = new azure.storage.Account("mystorageaccount", {
    resourceGroupName: resourceGroup.name,
    accountTier: "Standard",
    accountReplicationType: "LRS",
    location: resourceGroup.location,
});

// Create the Function App with a Timer Trigger defined in App Settings
const functionApp = new azure.appservice.FunctionApp("myFunctionApp", {
    resourceGroupName: resourceGroup.name,
    appServicePlanId: appServicePlan.id,
    storageAccountName: storageAccount.name,
    storageAccountAccessKey: storageAccount.primaryAccessKey,
    // Define the Timer Trigger in the App Settings
    appSettings: {
        "runtime": "dotnet",
        "WEBSITE_RUN_FROM_PACKAGE": "1", // Run from a deployment package (zip file or a URL to one)
        // Define the Timer Trigger function with a schedule
        // Here "0 */5 * * * *" means every 5 minutes. Adjust as needed.
        "TimerTriggerCron": "0 */5 * * * *",
    },
    osType: "linux",
    location: resourceGroup.location,
}, { dependsOn: [storageAccount] }); // Ensure storage account creation completes first

// Export the Function App endpoint
export const endpoint = functionApp.defaultHostname;
```

This program sets up the infrastructure needed for an Azure Timer Trigger Function. Here's a breakdown of what each resource does:

- `ResourceGroup`: Organizes related resources. All the resources we create are associated with this group.
- `Plan`: Defines the compute resources for our function (the App Service Plan). We're using a "Dynamic" plan which is the Azure Functions’ consumption plan.
- `StorageAccount`: Azure Functions requires an Azure storage account, as it uses Azure Blob Storage for various management operations such as logging and keeping track of executions and triggers.
- `FunctionApp`: This is our actual function application, where the code for our triggered function would reside.

The `appSettings` of the `FunctionApp` resource includes the setting for `TimerTriggerCron`, which determines the timing for our function's execution.

Please note that actual function code and deployment mechanism should be deployed separately. It could be deployed via the Azure portal, through Azure DevOps, GitHub Actions, or other CI/CD tooling, or using additional automation within Pulumi.

Also, remember to change the `location`, resource names, and schedule to fit your requirements. The schedule here is set as `0 */5 * * * *`, which is the cron expression for every five minutes. You'll need to adjust this to meet the schedule you want.