Glossary
Look up what Application, rule, phase, criterion, behavior, cache setting, cache key, Tiered Cache, and the other Applications terms mean.
Definitions for the terms the Applications documentation uses, including those of Cache, Application Accelerator, and Image Processor.
| Term | Definition |
|---|---|
| Add Request Header | The Rules Engine for Applications behavior that adds a header in the Field: value form to the request, in the Request Phase, add_request_header in the API. With Accept: image/webp, it makes the automatic conversion of Image Processor deliver WEBP to every request its rule matches. The API refuses the name add_header with 10039 Invalid Choice. |
| Advanced Cache Key | A Feature of Application Accelerator that varies the cache key by parts of a request beyond the URL: the query string, cookies, device groups, and the request method. It needs Application Accelerator on in the Application, and each cache setting configures it in its modules.application_accelerator object, through the four Cache vary by controls. Application Accelerator settings documents each control and where it sits in Azion Console and the API. |
| Application | The entity that runs its rules on the requests received by a Workload, once that Workload’s deployment sets that Application. A new Application starts with Cache and Functions on, Application Accelerator and Image Processor off, and no rules. The Application field of a Workload’s Deployment Settings in Azion Console sets it, the API serves your Applications at /v4/workspace/applications, and Applications documents the Platform Resource. |
| Application Accelerator | A Platform Resource nested in Applications that unlocks four capabilities for the cache and the rules of an Application: cache variation, the caching of POST and OPTIONS responses, a Max Age below 60 seconds, and the Rules Engine behaviors that Azion Console marks - Required Application Accelerator, with the ${request_uri} and ${device_group} variables. It is off in a new Application, modules.application_accelerator.enabled in the API, and with cache variation, a cache setting can add the query string, cookies, the device group, or the request method to the cache key. Applications describes it, and the Application Accelerator overview follows a request through it. |
| autocrop | The centered crop that a WidthxHeight resize can apply so the derived image fills the requested box. The crop is vertical or horizontal, depending on how the original dimensions fit the requested ones, as Image Processor URL parameters shows. |
| behavior | The action a rule runs on the requests its criteria match, such as Set Cache Policy, Set Connector, or Run Function. A rule runs its behaviors in the order it lists them, a behavior that ends the processing stops the behaviors and rules after it in its phase, and Rules Engine for Applications names the Platform Resource each behavior needs. On a cache setting, behavior is also the field of each Cache vary by control, and Application Accelerator settings lists the values of each. |
| Bypass Cache | The Rules Engine for Applications behavior that sends a matching request to the origin and keeps the response out of Azion’s cache, bypass_cache in the API. It runs in the Request Phase, requires Application Accelerator, leaves the browser cache to Set Cache Policy, and differs from a TTL of 0 seconds, as Bypass Cache and a TTL of 0 explains. It acts on Azion’s cache only, so an Application with active Tiered Cache settings keeps caching objects in the Tiered Cache layer for the Max Age of the cache setting. |
| Cache | A Platform Resource nested in Applications that stores copies of the responses to the requests received by an Application, to serve later requests for the same object from those copies. Each copy stays in the data center that stored it. It is always on in an Application: the API refuses modules.cache.enabled set to false with 31001, and Azion Console shows the Cache switch locked on, with the note Automatically enabled in all accounts. Applications describes it, and the Cache overview follows a request through it. |
| cache key | The index entry under which Cache stores an object, case sensitive. In Cache, the default setting ignores the query string, so the key concatenates the scheme, host, and path, as in httpsstatic.example.com/page/site.js, and each variation adds a value after the @@ separator: under allowlist and denylist, that value includes the query string arguments a setting names, but under all, the whole query string follows the path, before @@. When the cache setting that serves images names ims in its allowlist, the key carries the ims query string after @@, and a converted image carries its format at the end. Under the default setting, the ims value is not part of the key, so every size and processing of the path shares a key, and the first one stored answers every ims value; Cache keys documents every form. |
| cache key purge | A Real-Time Purge type, cachekey in the API, that clears the objects stored under each key of a list. A key can name one variation, by query string, cookie, or image format, so a purge of every variation of an object lists each key. It is the only purge type that reaches the Tiered Cache layer. |
| cache setting | A set of values that tell Cache how to store and serve a response: the TTLs of Azion’s cache and of the browser, and the inputs that tell two requests apart. It belongs to one Application and carries Max Age, stale cache, Large File Optimization, and Tiered Cache, plus the four Cache vary by controls in its modules.application_accelerator object. It acts only through a rule that applies that cache setting with Set Cache Policy to the requests the rule matches; Cache settings documents every field, and Cache quickstart creates a first one. |
| cache status | The state of a response in Cache, at the start of the x-cache header: HIT, MISS, EXPIRED, STALE, UPDATING, REVALIDATED, or BYPASS. A response that Azion does not store reports - while Application Accelerator is on, but with it off, a GET or HEAD response that is not stored reports MISS, with x-cache-expires-in: 0. Cache keys gives the meaning of each one. |
| cache variation | A further copy of an object stored under its own key because the request method, a query string argument, a cookie, a device group, an image format, or a byte range of a large file differs. While Application Accelerator is off in the Application, the API refuses a variation with 21013, and that includes the query-string variation on ims that Image Processor settings describes. Image Processor processes an image whether Application Accelerator is on or off; Application Accelerator settings documents the four controls. |
| Connector | The entity that routes the requests of an Application to your origin, once a rule sets the ID of that Connector in the Set Connector behavior. It belongs to Connectors, the Platform Resource that replaces the origins that earlier versions of Applications configured on the Application. With Load Balancer enabled, one Connector of the http type can spread traffic across several origins. |
| criterion | A single condition inside a rule: a variable such as ${uri}, a comparison operator, and an argument when the operator takes one, sent in the API as variable, operator, conditional, and argument. Inside a group, criteria combine with and and or, and and takes precedence over or. The groups of a rule are joined by and, and the API carries them as an array of groups, [[{...}]]. Rules Engine for Applications lists every variable and operator. |
| Debug Rules | The setting of an Application that logs the Rules Engine rules each request ran, debug in the API and off in a new Application. With it on, the rules that ran appear in the $traceback field in Data Stream and Real-Time Events, and in the stacktrace field of the Real-Time Events GraphQL API. Main Settings shows where to turn it on in Azion Console, and Debug rules created with Rules Engine shows how to read those logs. |
| derived image | The image that Image Processor builds from the source image on the origin. Image Processor returns it without saving it as an asset of the account, and the source image stays unchanged. The Image Processor overview describes how a request produces one. |
| device group | A name and a regular expression that an Application compares with the User-Agent header of each request. A request belongs to the group when its header matches the expression. Each device group belongs to one Application, and a rule tests it through the ${device_group} variable, which requires Application Accelerator. Cache vary by Devices varies the cache key by it, and Device Groups documents the matching. |
| filter | The ims component that transforms an image beyond a resize or a crop, written filters:name(argument), as in filters:quality(15). One ims string combines several filters, separated by :. Image Processor URL parameters documents rotate, quality, watermark, format, and fill. |
fit-in |
The ims prefix that fits the derived image inside a WidthxHeight box and keeps the aspect ratio of the source image, as in ?ims=fit-in/400x400. An image smaller than the box keeps its original size. Both dimensions are optional, and Image Processor URL parameters shows each form. |
| Forward Cookies | The Rules Engine for Applications behavior that sends the Set-Cookie header of the origin to the user even when the response comes from cache. It runs in the Request Phase and requires Application Accelerator. |
| Function Instance | The entity that binds one of your Functions to one Application or one Firewall, with the arguments it runs with. The API serves the Function Instances of an Application at /v4/workspace/applications/<application-id>/functions, and a rule with the Run Function behavior invokes a Function Instance by its ID in attributes.value. Function Instances documents its fields. |
| Image Processor | A Platform Resource nested in Applications that builds a new image, the derived image, from an image on the origin of an Application. It is off in a new Application, and each Application turns it on separately, in modules.image_processor.enabled in the API or with --image-processor in Azion CLI. Applications describes it, and the Image Processor overview follows a request through it. |
ims |
The query string parameter that tells Image Processor which transformation to apply, as in ?ims=400x. It can sit anywhere in the query string, and an ims value that Image Processor cannot parse returns the source image without a transformation. Image Processor URL parameters documents every value it accepts and its position. |
| Large File Optimization | A Feature of Cache that stores a large object as fragments of 1,024 kB, off by default and turned on per cache setting in modules.cache.large_file_cache.enabled. Azion caches each fragment when a user requests it, under its own cache key ending in @@bytes=<start>-<end>, and the Feature applies to Tiered Cache too when that layer is on. Expiration and freshness describes the mechanism. |
| Main Settings | The set of values that apply to an Application as a whole: its name, the Platform Resources turned on in it, whether it logs the rules each request runs, and whether it is active. Azion Console groups them in the Main Settings tab of the Application, in four sections: General, which carries the name, Modules, Debug Rules, and Status. Delivery and protocol settings belong to the Workload that receives the requests, not to Main Settings. Main Settings documents each section. |
| Max Age | The cache setting field for how many seconds Azion’s cache keeps a copy of an object, modules.cache.max_age in the API, with a default of 60 in Azion Console, the API, and the CLI. The API refuses a value below 60 with 21021 while Application Accelerator is off, a value below 3 with 21020 while Application Accelerator and Tiered Cache are both on, and a value above 31536000 with 10068. The browser cache has a Max Age of its own, browser_cache.max_age; Applications limits carries the bounds that depend on the Platform Resources turned on. |
modules |
The API object that carries the switches of an Application, application_accelerator, cache, functions, and image_processor, each with an enabled value. Azion Console renders it as the Modules section of Main Settings, whose Default Modules are the same four, beside a Subscription modules group with a Contact sales action. Tiered Cache is not one of these switches: each cache setting turns it on in its own modules.cache.tiered_cache.enabled field. |
| Optimize Images | The Rules Engine for Applications behavior that applies Image Processor to the requests its rule matches, optimize_images in the API. It runs in the Request Phase, takes no arguments, and requires Image Processor on in the Application. The API accepts it alone in a rule, with no Set Cache Policy beside it. |
| phase | One of the two stages in which an Application runs rules: the Request Phase, on the request before a response exists, and the Response Phase, on the response delivered to the user. You set the phase of a rule when you create it, and you cannot change it later, so a rule in the other phase is a new rule. Caching is decided in the Request Phase, and Rules Engine for Applications lists the phases each variable and behavior is available in. |
| Real-Time Purge | A Platform Resource that removes cached objects from Cache or Tiered Cache before their TTL ends. Once an object is in neither Cache nor Tiered Cache, the next request for it fetches the current version from the origin. A purge names its objects by URL, by cache key, or by a wildcard expression, and Azion queues it and lists it in the purge history once it completes. Real-Time Purge documents the three types and the layer each one reaches. |
| rule | An entry in Rules Engine for Applications that runs its behaviors, in one phase, on the requests its criteria match. Each rule carries a name and its phase, rules run in the order you arrange them, and a new Application has none. The API serves the rules of the Request Phase at /v4/workspace/applications/<application-id>/request_rules and those of the Response Phase at /v4/workspace/applications/<application-id>/response_rules, and Rules Engine for Applications lists their fields. |
| Rules Engine for Applications | A Feature of Applications that holds the rules of an Application. The Application runs them in order as if-then logic, with the criteria as the if and the behaviors as the then. Azion Console shows it as the Rules Engine tab of each Application, with the rules grouped by phase. Rules Engine for Applications documents every variable, operator, and behavior. |
| Run Function | The Rules Engine for Applications behavior that invokes a Function Instance on the requests its rule matches, run_function in the API with the Function Instance ID in attributes.value. It runs in the Request Phase and in the Response Phase, which accepts only Functions written in Lua, and it needs Functions on in the Application, modules.functions.enabled in the API. Function Instances documents how it references the Function Instance. |
| Set Cache Policy | The Rules Engine for Applications behavior that applies a cache setting to a matching request, set_cache_policy in the API with the cache setting ID in attributes.value. It runs in the Request Phase and works with Application Accelerator on or off. A cache setting acts only through a rule that carries this behavior, and the API refuses to delete a setting in use with 21014 Cannot Delete Cache Setting. |
| Set Connector | The Rules Engine for Applications behavior that routes the requests its rule matches to a Connector, set_connector in the API with the Connector ID in attributes.value. It runs in the Request Phase, and when more than one matching rule carries it, only the last one runs. |
| source image | The image file on the origin that Image Processor reads to build a derived image. Image Processor reads it without changing it, and each transformation yields a separate derived image. The Image Processor overview describes the path between the two. |
| stale cache | A Feature of Cache that can answer with an expired copy during a stale window, when a revalidation attempt with the origin fails. Each cache setting turns it on in modules.cache.stale_cache.enabled, and the window is the stale-while-revalidate value of the origin under Honor cache policies, or 300 seconds under Override cache behavior or when the origin omits the directive, as Expiration and freshness describes. |
| Tiered Cache | A Feature of Cache that adds a second cache layer between the data center that answers a request and the origin, in the region the topology of the cache setting selects. The first layer is the cache of that data center. On a miss in the first layer, the data center asks the Tiered Cache layer before the request goes to the origin, and each cache setting turns Tiered Cache on in its own modules.cache.tiered_cache.enabled field, on every plan. The setting must use Override cache behavior, or the API answers 21001, and, with Application Accelerator on, a Max Age of at least 3 seconds; Tiered Cache covers the regions it runs in and the purge type that clears it. |
| TTL | Time to live: the number of seconds Azion’s cache or the browser keeps a copy of an object. Under Honor cache policies, the Cache-Control and Expires headers the origin sends set it. When a cache setting overrides them, its Max Age sets it: modules.cache.max_age for Azion’s cache and browser_cache.max_age for the browser. |
| URL purge | A Real-Time Purge type, url in the API, that clears the object behind each URL of a list. It is not recursive, and Azion converts each URL to its cache key without the variations, so an object that varies by cookie, device group, or image format needs a cache key or wildcard purge. Sent without a scheme, a URL clears the HTTP and the HTTPS copy alike. |
| variable | A value of the request or the response, written ${name}, that a criterion tests or a behavior argument inserts, such as ${uri}, ${host}, or ${device_group}. Each variable is available in the Request Phase, the Response Phase, or both, as Rules Engine for Applications lists. In an Application, ${request_uri} requires Application Accelerator, and a rule that uses it while Application Accelerator is off is refused with 25047 Missing Required Modules, while the same rule with ${uri} is accepted. |
| WASM Image Processor | The WebAssembly library that processes images inside a Function, through loadImage, resize, getImageResponse, and clean, for the webp, jpeg, and png formats. It is separate from the Image Processor Platform Resource: Image Processor transforms a request through the ims query string, and the library runs inside your code. Image Processor settings points to its reference. |
| WebSocket Proxy | A Feature of Applications that carries a WebSocket connection, a single bidirectional TCP connection, between your users and your origin. An Application with it on treats a request that carries Upgrade: websocket and Connection: upgrade as a WebSocket connection and proxies it to the origin, and a valid connection answers 101 Switching Protocols. WebSocket Proxy documents its requirements and availability. |
| wildcard purge | A Real-Time Purge type, wildcard in the API, that clears every object matching one expression carrying * in its path or query string. An expression can carry more than one *, but a request carries one expression, and the API refuses a second with 10065. It clears Azion’s cache only: a wildcard purge sent to the Tiered Cache layer is refused with 30001. |
x-cache |
The debug response header that carries the cache status of a response, the IP address of the server that answered, and the protocol, in the form <STATUS> from <IP> with <protocol>. A request has to carry Pragma: azion-debug-cache for Azion to add it to the response. Cache keys lists every status it can carry. |
x-cache-key |
The debug response header that carries the cache key of a response, as in x-cache-key: httpsstatic.example.com/page/site.js. It comes back only on a request sent with Pragma: azion-debug-cache, and it reads x-cache-key: - on a response that Azion does not store while Application Accelerator is on. Cache keys breaks the key down element by element. |