Create an application rule

Add a rule to an application from Azion Console, the Azion CLI, or the API, and apply a cache setting to every path that starts with /static/.

Last updated

View as Markdown Agent setup

You can create a rule in Rules Engine for Applications from Azion Console, the Azion CLI, or the API. A rule runs its behaviors on every request that matches its criteria. The application changes what it does, and your code stays as it is. Rules are also how the application uses its cache settings, function instances, and connectors. The rule on this page applies a cache setting to the paths that start with /static/.

To rewrite a request path or remove the Server header from responses, refer to Create request and response rules. A firewall has rules of its own. For those, refer to Create a firewall rule.

Choose your interface once. The prerequisites and the procedure on this page follow that choice.

Prerequisites

  • The Azion CLI, installed and authorized with your account. The commands on this page match Azion CLI 4.23.0. For more information, refer to Azion CLI.
  • The ID of the application. Azion Console shows it in the address of the application’s page, after /applications/edit/.
  • The ID of the cache setting. The Cache Settings tab of the application lists it in the ID column.
  • A personal token, sent in the Authorization header as Token [TOKEN VALUE]. To create one, refer to Manage a personal token.
  • curl, or another HTTP client.
  • The ID of the application. Azion Console shows it in the address of the application’s page, after /applications/edit/.
  • The ID of the cache setting. The Cache Settings tab of the application lists it in the ID column.

Apply a cache setting to one path

The rule in this section runs in the Request Phase. It matches the requests whose ${uri} starts with /static/. Its Set Cache Policy behavior applies your cache setting to them. Requests to other paths keep the cache behavior they had. The criterion also matches longer paths, such as /static/css/site.css.

A rule’s phase is fixed when you create it. To run a behavior in the Response Phase instead, create a new rule in that phase.

The ${uri} variable needs no Product on the application. Set Cache Policy relies on Cache, which every new application runs. Other variables and behaviors need Application Accelerator, Image Processor, or Functions enabled on the application. In Azion Console, each of those options carries a note such as - Required Application Accelerator. To enable a Product, refer to Enable Products on an application.

To create the rule with the Azion CLI, save its definition as rule.json. The file holds the rule’s name, an optional description, whether it is active, its criteria, and its behaviors:

JSON
01{
02 "name": "apply-static-assets-cache",
03 "description": "Applies the static-assets cache setting to /static/",
04 "active": true,
05 "criteria": [
06 [
07 {
08 "variable": "${uri}",
09 "operator": "starts_with",
10 "conditional": "if",
11 "argument": "/static/"
12 }
13 ]
14 ],
15 "behaviors": [
16 {
17 "type": "set_cache_policy",
18 "attributes": {
19 "value": "<cache-setting-id>"
20 }
21 }
22 ]
23}

criteria is a list of groups, and each group is a list of conditions. The first condition takes "conditional": "if". In the set_cache_policy behavior, attributes.value holds the ID of your cache setting.

Then create the rule in the Request Phase, with your application ID in place of <application-id>:

azion create rules-engine --application-id <application-id> --phase request --file rule.json

The command prints the ID of the new rule:

Created Rules Engine with ID <rule-id>

The --phase flag sets the phase of the rule. The file holds the same body that the API accepts.

To create the rule with the API, send a POST request to the request_rules endpoint of your application. The endpoint sets the phase, and the body carries the rule’s name, description, active, criteria, and behaviors:

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 {
07 "name": "apply-static-assets-cache",
08 "description": "Applies the static-assets cache setting to /static/",
09 "active": true,
10 "criteria": [
11 [
12 {
13 "variable": "${uri}",
14 "operator": "starts_with",
15 "conditional": "if",
16 "argument": "/static/"
17 }
18 ]
19 ],
20 "behaviors": [
21 {
22 "type": "set_cache_policy",
23 "attributes": {
24 "value": "<cache-setting-id>"
25 }
26 }
27 ]
28}

criteria is a list of groups, and each group is a list of conditions. The first condition takes "conditional": "if". In the set_cache_policy behavior, attributes.value holds the ID of your cache setting.

The API answers 202 and returns the rule:

{"state":"pending","data":{"id":<rule-id>,…,"behaviors":[{"type":"set_cache_policy","attributes":{"value":<cache-setting-id>}}],"order":0,…}}

The response adds the rule’s id and its order, and returns the cache setting ID as a number. The order is the rule’s position among the request rules of the application, counted from 0. The first request rule of an application takes 0, and the next one takes 1.

While Application Accelerator is off on the application, the API refuses a criterion on ${request_uri} with 400:

{"errors":[{"code":"25047","title":"Missing Required Modules","detail":" It requires any of the following modules to be enabled: ['application_accelerator'].","status":"400","source":{"pointer":"/data/criteria/0/0/variable"},"meta":{"message_prefix":"","owner_modules":"any","missing_required_modules":["application_accelerator"]}}]}

Use ${uri}, which needs no Product, or enable Application Accelerator before you send the rule. For every variable, operator, and behavior the body accepts, refer to Rules Engine for Applications and the Azion API reference.

To create the rule in Azion Console:

Open the application

Access Azion Console > Applications, then select your application.

Select the Rules Engine tab
Select + Rule
Name the rule

In the General section, enter a Name, such as apply-static-assets-cache.

(Optional) Describe the rule

In Description, enter a note about what the rule does. The note takes up to 1,000 characters.

Select the phase

In the Phase section, select Request Phase.

Select the variable

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

Select the operator

Select starts_with as the operator.

Enter the argument

Enter /static/ as the argument.

Select the behavior

In the Behaviors section, select Set Cache Policy.

Select the cache setting

In the second dropdown of the behavior, select your cache setting.

Keep the rule active

Under Status, make sure that Active is turned on.

Select Save

The rule appears in the Rules Engine tab, under the Request heading. To run a second behavior in the same rule, select + Add Behavior before you save it.

A new rule can take a few minutes to propagate. To read the cache status of a response under /static/, refer to Check the cache status of a response.

Next steps

Rules Engine for ApplicationsEvery variable, operator, and behavior an application rule accepts, by phase.Create request and response rulesRewrite a request path and remove the Server header from responses, in Azion Console.Check the cache status of a responseRead whether a response under the rule's path came from the cache.Enable Products on an applicationTurn on Application Accelerator, Image Processor, or Functions for the variables and behaviors they add.Create device groupsGroup devices by User-Agent to manage application behaviors and cache policies for each group.