Azure Functions warmup trigger
This article explains how to work with the warmup trigger in Azure Functions. A warmup trigger is invoked when an instance is added to scale a running function app. The warmup trigger lets you define a function that's run when a new instance of your function app is started. You can use a warmup trigger to pre-load custom dependencies during the pre-warming process so your functions are ready to start processing requests immediately. Some actions for a warmup trigger might include opening connections, loading dependencies, or running any other custom logic before your app begins receiving traffic.
The following considerations apply when using a warmup trigger:
- The warmup trigger isn't available to apps running on the Consumption plan.
- The warmup trigger isn't supported on version 1.x of the Functions runtime.
- Support for the warmup trigger is provided by default in all development environments. You don't have to manually install the package or register the extension.
- There can be only one warmup trigger function per function app, and it can't be invoked after the instance is already running.
- The warmup trigger is only called during scale-out operations, not during restarts or other non-scale startups. Make sure your logic can load all required dependencies without relying on the warmup trigger. Lazy loading is a good pattern to achieve this goal.
- Dependencies created by warmup trigger should be shared with other functions in your app. To learn more, see Static clients.
Example
A C# function can be created using one of the following C# modes:
- In-process class library: compiled C# function that runs in the same process as the Functions runtime.
- Isolated worker process class library: compiled C# function that runs in a worker process that is isolated from the runtime. Isolated worker process is required to support C# functions running on non-LTS versions .NET and the .NET Framework.
- C# script: used primarily when creating C# functions in the Azure portal.
The following example shows a C# function that runs on each new instance when it's added to your app.
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
namespace WarmupSample
{
//Declare shared dependencies here
public static class Warmup
{
[FunctionName("Warmup")]
public static void Run([WarmupTrigger()] WarmupContext context,
ILogger log)
{
//Initialize shared dependencies here
log.LogInformation("Function App instance is warm 🌞🌞🌞");
}
}
}
The following example shows a warmup trigger that runs when each new instance is added to your app.
@FunctionName("Warmup")
public void warmup( @WarmupTrigger Object warmupContext, ExecutionContext context) {
context.getLogger().info("Function App instance is warm 🌞🌞🌞");
}
The following example shows a warmup trigger in a function.json file and a JavaScript function that runs on each new instance when it's added to your app.
Here's the function.json file:
{
"bindings": [
{
"type": "warmupTrigger",
"direction": "in",
"name": "warmupContext"
}
]
}
The configuration section explains these properties.
Here's the JavaScript code:
module.exports = async function (context, warmupContext) {
context.log('Function App instance is warm 🌞🌞🌞');
};
Here's the function.json file:
{
"bindings": [
{
"type": "warmupTrigger",
"direction": "in",
"name": "warmupContext"
}
]
}
PowerShell example code pending.
The following example shows a warmup trigger in a function.json file and a Python function that runs on each new instance when it'is added to your app.
Your function must be named warmup
(case-insensitive) and there may only be one warmup function per app.
Here's the function.json file:
{
"bindings": [
{
"type": "warmupTrigger",
"direction": "in",
"name": "warmupContext"
}
]
}
For more information, see Configuration.
Here's the Python code:
import logging
import azure.functions as func
def main(warmupContext: func.Context) -> None:
logging.info('Function App instance is warm 🌞🌞🌞')
Attributes
Both in-process and isolated worker process C# libraries use the WarmupTrigger
attribute to define the function. C# script instead uses a function.json configuration file.
Use the WarmupTrigger
attribute to define the function. This attribute has no parameters.
Annotations
Annotations aren't required by a warmup trigger. Just use a name of warmup
(case-insensitive) for the FunctionName
annotation.
Configuration
The following table explains the binding configuration properties that you set in the function.json file.
function.json property | Description |
---|---|
type | Required - must be set to warmupTrigger . |
direction | Required - must be set to in . |
name | Required - the variable name used in function code. A name of warmupContext is recommended for the binding parameter. |
See the Example section for complete examples.
Usage
The following considerations apply to using a warmup function in C#:
- Your function must be named
warmup
(case-insensitive) using theFunctionName
attribute. - A return value attribute isn't required.
- You must be using version
3.0.5
of theMicrosoft.Azure.WebJobs.Extensions
package, or a later version. - You can pass a
WarmupContext
instance to the function.
Your function must be named warmup
(case-insensitive) using the FunctionName
annotation.
The function type in function.json must be set to warmupTrigger
.
Next steps
Feedback
Submit and view feedback for