Functions quickstart

Create your first function in Azion Console, the Azion CLI, or the API, instantiate it on an application, and trigger it with a Rules Engine rule.

Last updated

View as Markdown Agent setup

This guide instructs you through running your first function on Azion. The steps take about 10 minutes.

  • Create a function that returns Hello World!.
  • Instantiate the function on an application.
  • Add a Rules Engine rule that runs the instance on the /hello-world URI.
  • Request that URI and read the response.

Three objects make a function run, and each one links to the next:

  1. The function holds the JavaScript code.
  2. The function instance binds the function to an application. It also carries the Args, a JSON object passed into the execution context.
  3. The Rules Engine rule selects the instance with the Run Function behavior. The rule sets the execution phase and the criteria that trigger it.

Creating a function does not execute it. An instance without a Rules Engine rule never runs.

The Azion Terraform provider manages the same three objects. For every interface that carries them, refer to Functions.

Select the interface you will use. The prerequisites and every stage below follow that choice.

Prerequisites

  • An Azion account. To create one, refer to How to create an account on Azion.
  • The Edit Functions permission on the account. It grants permission to create, edit, and remove functions, and it also requires the permission View Functions.
  • The Edit Applications permission on the account. The instance and the rule change an application, and this permission grants permission to edit, create, and remove applications. It also requires the permission View Applications. Refer to Teams Permissions.
  • An application. To create one, refer to Applications quickstart.

Create the function

The function holds the code that answers the request. This one returns the string Hello World!.

To create the function in Azion Console:

Open the Functions page

Access Azion Console > Products Menu > Libraries > Functions.

Select + Function
Name the function

Enter a name for the function. For example: hello-world.

Paste the code in the Code tab

In the Code tab, paste the following code:

JavaScript
01export default {
02 async fetch(request, env, ctx) {
03 return new Response('Hello World!');
04 },
05};
Select Save

The function is saved and available to instantiate on an application.

To read the response of the function before it serves traffic, use Preview deployment. It runs the code in Azion Console without a deployment.

The CLI reads the code from a local file. To create the function:

Save the code to a file

Write the following code to index.js:

JavaScript
01export default {
02 async fetch(request, env, ctx) {
03 return new Response('Hello World!');
04 },
05};
Run the create command
azion create function --name hello-world --code ./index.js --active true
Read the output

The command prints the id of the new function:

Created function with ID 12346

Record the id. The instance takes it. For every flag the command accepts, refer to Azion CLI create.

The request body carries the code as a JSON string, so newlines are escaped as \n.

Send the create request

Replace [TOKEN VALUE] with your personal token:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/functions \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "name": "hello-world",
08 "code": "export default {\n async fetch(request, env, ctx) {\n return new Response(\"Hello World!\");\n },\n};"
09}
Read the response

A 202 carries the function:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": 12345,
05 "name": "hello-world",
06 "last_editor": "user@example.com",
07 "last_modified": "2026-01-01T12:00:00.385220Z",
08 "product_version": "2.0",
09 "active": true,
10 "runtime": "azion_js",
11 "execution_environment": "application",
12 "default_args": {},
13 "reference_count": 0,
14 "code": "export default {\n async fetch(request, env, ctx) {\n return new Response(\"Hello World!\");\n },\n};"
15 }
16}

Record the id. The instance takes it. The "state": "pending" value means the change takes a few minutes to propagate.

Instantiate the function on your application

An instance binds the function to one application, and one function can back several instances. Each path turns on the Functions module for the application, then creates the instance.

To bind the function to an application in Azion Console:

Still in Azion Console, go to Products Menu > Build > Applications
Select the application that runs the function
In the Main Settings tab, turn on the Functions module
Select Save
Go to the Functions Instances tab
Select + Function Instance
Name the instance

Enter a name for the instance. For example: hello-world instance.

Select the function

Select the hello-world function.

Select Save

The new instance appears in the Functions Instances tab.

To turn on the module and create the instance with the Azion CLI, replace the application id and the function id with your own:

Turn on the Functions module
azion update application --application-id <application_id> --functions true

The command confirms the application:

Updated Application with ID <application_id>
Create the instance
azion create function-instance --application-id <application_id> --function-id <function_id> --name "hello-world instance"
Read the output

The command prints the id of the new instance:

Created Function Instance with ID 12348

Record the instance id. The rule takes it.

Two requests turn on the module and create the instance.

Turn on the Functions module

Replace <application_id> with your application ID:

Shell
01curl --request PATCH \
02 --url https://api.azion.com/v4/workspace/applications/<application_id> \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "modules": {
08 "functions": {
09 "enabled": true
10 }
11 }
12}

The response returns the modules the application now carries:

JSON
01{
02 "cache": { "enabled": true },
03 "functions": { "enabled": true },
04 "application_accelerator": { "enabled": false },
05 "image_processor": { "enabled": false }
06}
Create the instance

Replace <function_id> with the id the function create returned:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/applications/<application_id>/functions \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data {
07 "name": "hello-world instance",
08 "function": <function_id>,
09 "args": {},
10 "active": true
11}
Read the response

A 202 carries the instance:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": 12347,
05 "name": "hello-world instance",
06 "args": {},
07 "function": 12345,
08 "active": true,
09 "last_editor": "user@example.com",
10 "last_modified": "2026-01-01T12:00:21.272376Z"
11 }
12}

The function field holds the id of the function the instance runs. It differs from id, which is unique for each instance.

Record the instance id. The rule takes it.

Add the rule that runs the function

An instance runs only when a Rules Engine rule selects it. This rule runs the instance on requests to /hello-world.

To add the rule in Azion Console:

In the same application, go to the Rules Engine tab
Select + Rule
Name the rule

Enter a name for the rule. For example: Run hello-world.

Select Request Phase
Select the variable in the Criteria section

In the Criteria section, select the ${uri} variable.

Select is equal as the comparison operator
Enter the argument

Enter /hello-world as the argument.

In the Behaviors section, select Run Function
Select the instance you created
Select Save

The rule runs the instance on every request whose URI is /hello-world.

If Run Function is not in the Behaviors list, the application also needs the Application Accelerator module. Refer to Run Function is missing from the behaviors list for the fix.

The CLI reads the rule from a JSON file. To add the rule:

Write the rule to a file

Save the following as rule.json, with the id of your instance in attributes.value:

JSON
01{
02 "name": "Run hello-world",
03 "description": "Run the function on /hello-world",
04 "active": true,
05 "criteria": [
06 [
07 {
08 "conditional": "if",
09 "variable": "${uri}",
10 "operator": "is_equal",
11 "argument": "/hello-world"
12 }
13 ]
14 ],
15 "behaviors": [
16 {
17 "type": "run_function",
18 "attributes": { "value": 12348 }
19 }
20 ]
21}
Create the rule
azion create rules-engine --application-id <application_id> --phase request --file rule.json
Read the output

The command prints the id of the new rule:

Created Rules Engine with ID 234568

The rule runs the instance on every request whose URI is /hello-world.

To add the rule with the Azion API:

Write the rule to a file

The criteria carry ${uri}, which a shell expands, so the body is sent from a file. Save the following as rule.json, with the id of your instance in attributes.value:

JSON
01{
02 "name": "Run hello-world",
03 "description": "Run the function on /hello-world",
04 "active": true,
05 "criteria": [
06 [
07 {
08 "conditional": "if",
09 "variable": "${uri}",
10 "operator": "is_equal",
11 "argument": "/hello-world"
12 }
13 ]
14 ],
15 "behaviors": [
16 {
17 "type": "run_function",
18 "attributes": { "value": 12347 }
19 }
20 ]
21}
Send the create request
Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/applications/<application_id>/request_rules \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: application/json' \
06 --data @rule.json
Read the response

A 202 carries the rule, with the order it holds among the rules of the application:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": 234567,
05 "name": "Run hello-world",
06 "active": true,
07 "behaviors": [
08 {
09 "type": "run_function",
10 "attributes": { "value": 12347 }
11 }
12 ],
13 "order": 0,
14 "last_editor": "user@example.com",
15 "last_modified": "2026-01-01T12:01:25.270982Z"
16 }
17}

The rule runs the instance on every request whose URI is /hello-world.

New rules can take a few minutes to propagate. Wait before you request the URI.

Verify the response

Your application answers on a domain in the format xxxxxxxxx.map.azionedge.net. To set the domain for your application, refer to Add a custom domain to a workload.

To confirm that the function runs, request the URI set in the rule:

curl https://<your-azion-domain>/hello-world

The response body is the string the function returns:

Hello World!

The function now runs on every request that matches the rule criteria.

Next steps

How it worksThe invocation chain in detail, from the function to the request that triggers it.Function instancesPass Args to an instance in JSON.Environment variablesStore configuration and secrets outside the function code, then read each one by key at run time.JavaScript examplesFunction code to adapt for your own logic.Best practicesWhat each part of the handler does, and the design choices that keep an invocation inside its limits.Local developmentBuild and run the project on your own machine with the azion dev command.