Glossary

Applications and the Products enabled on an application, Cache, Application Accelerator, and Image Processor, use each term in this table in a sense of their own.

Term	Definition
action	The name other platforms give to what a rule does to a request it matches, which an application calls a behavior. A rule that routes by path elsewhere transfers with its match condition as criteria, its action as behaviors, and its backend server as a connector. Rules Engine for Applications lists every behavior.
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. A request that Image Processor converts to WEBP must carry `Accept: image/webp`, and this behavior adds it. The API refuses the name `add_header` with `10039 Invalid Choice`.
Advanced Cache Key	The feature 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 the application, and a cache setting configures it through its four Cache vary by controls. Azion Console names no control after it: the controls sit in the Application Accelerator section of the cache setting, which Application Accelerator settings documents.
allowlist	The value of the `behavior` field of a Cache vary by control that varies the cache key only by the attributes the cache setting names, and ignores every other one the request carries. The Behavior dropdown of Azion Console shows it as Allowlist. It bounds how many objects a variation creates, because an attribute the setting does not name produces no further object; Application Accelerator settings lists the values each control accepts.
application	An instance of Applications, the Platform Resource that holds the logic a workload runs on its requests, set in the Main Settings, Device Groups, Cache Settings, Functions Instances, and Rules Engine tabs. A new application starts with Cache and Functions on, Application Accelerator and Image Processor off, and no rules. A workload selects it in the Application field of its Deployment Settings, the API serves it at `/v4/workspace/applications`, and Applications documents the resource.
Application Accelerator	The Product enabled on an application that puts the rest of a request into the cache key. Its switch, Application Accelerator in Main Settings › Modules, is off on a new application and unlocks cache variation, the caching of `POST` and `OPTIONS` responses, a Max Age below 60 seconds, seven Rules Engine behaviors, and the `${request_uri}` and `${device_group}` variables. Applications describes it, and How Applications works follows a request through it.
autocrop	The centered crop a `WidthxHeight` resize can apply so the derived image fills the requested box, vertically or horizontally depending on how the original dimensions fit the requested ones. Setting one dimension to `orig` prevents it, 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 finalizing behavior stops every behavior and rule after it, and Rules Engine for Applications names the Product each behavior needs. On a cache setting, `behavior` is also the field of each Cache vary by control, with the values `ignore`, `all`, `allowlist`, and `denylist`.
Bypass Cache	The Rules Engine for Applications behavior that sends every request its rule matches 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 How Applications works explains. It does not reach Tiered Cache: an application with active Tiered Cache settings keeps caching objects in that layer for the minimum TTL.
Cache	The Product enabled on an application that stores copies of responses on Azion’s distributed infrastructure and answers later requests from them. Its switch in Main Settings › Modules carries the helper text “Automatically enabled in all accounts.”, and a new application reports `modules.cache.enabled` as `true`. Applications describes it, and How Applications works 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 to it: a method prefix, the query string arguments a setting names, or a value after the `@@` separator. In Image Processor, the cache setting that serves images names `ims` in its query string allowlist, and a converted image carries its format after `@@`; 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	The object, created with + Cache on the Cache Settings tab of an application, that holds how long Azion’s cache and the browser keep a response and what makes two requests different. Its Browser Cache and Cache sections carry Max Age, Stale cache, Large file optimization, and Tiered Cache, and its Application Accelerator section carries the four Cache vary by controls. It belongs to one application and applies to no request until a Set Cache Policy rule names it; Cache settings documents every field.
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 the platform does not cache reports `-`. Cache keys gives the meaning of each one.
cache variation	In Cache, 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. In Image Processor, the `cache_vary_by_querystring` field that varies the cache on `ims`, set through its Behavior, Fields, and Sort controls, as Image Processor settings shows. Every Cache vary by control requires Application Accelerator, because its fields belong to `modules.application_accelerator`, while processing an image does not; Application Accelerator settings documents the four controls.
Cache vary by Cookies	The cache setting control that varies the cache key by the value of named cookies, `cache_vary_by_cookies` in the API. It carries a `behavior` and, in `cookie_names`, the list of cookies the behavior applies to.
Cache vary by Devices	The cache setting control that varies the cache key by device group, `cache_vary_by_devices` in the API. It carries a Behavior, with the options Allowlist, Denylist, Ignore, and All in Azion Console, and, in `device_group`, the list of device groups the behavior applies to.
Cache vary by Method	The cache setting control that names the request methods whose responses Azion caches, `cache_vary_by_method` in the API and empty by default. It accepts `POST`, `OPTIONS`, or both, sent as `post` and `options`, and nothing else. Without Application Accelerator on the application, the API refuses a value with `21013`.
Cache vary by Query String	The cache setting control that varies the cache key by named query string arguments, `cache_vary_by_querystring` in the API. It carries a Behavior, the Fields the behavior applies to, one per line in Azion Console, and Sort.
complex request	A request whose method is anything other than `GET` or `HEAD`. Azion prefixes the method to the cache key of a complex request, as in `optionshttpsstatic.example.com/page`, so an `OPTIONS` response and a `GET` response for one path are separate objects. Cache keys lists the prefix with the other variations.
connector	The object an application sends requests to so they reach your origin, created in Connectors, the Platform Resource that took over the settings once made under Origins. A rule with the Set Connector behavior selects it by ID. One connector can reach several origins and distribute traffic among them through Load Balancer.
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`. Criteria combine with `and` and `or`, `and` takes implicit precedence, and the API carries them as an array of groups, `[[{...}]]`. Rules Engine for Applications lists every variable and operator.
Debug Rules	The Main Settings section that logs the Rules Engine rules each request ran, `debug` in the API and off on a new application. With it on, executed rules appear in the `$traceback` field in Data Stream and Real-Time Events, and in the `$stacktrace` variable in the GraphQL API. To read those logs, refer to Debug rules created with Rules Engine.
denylist	The value of the `behavior` field of a Cache vary by control that varies the cache key by every attribute the request carries except the ones the cache setting names. The Behavior dropdown shows it as Denylist, and Application Accelerator settings lists the controls that accept it.
derived image	The output Image Processor builds from the source image on the origin and returns to a request carrying an `ims` query string. The original stays untouched, and Azion keeps no derived image as a stored asset. How Applications works describes how a request produces one.
device group	A named set of devices that an application recognizes by matching the `User-Agent` header of a request against a regular expression, created on the Device Groups tab. A rule tests it through the `${device_group}` variable, which requires Application Accelerator, and Cache vary by Devices varies the cache key by it. Device Groups documents the matching.
edge hostname	The name other platforms give to the hostname they assign to the configuration that serves your domains. On Azion it is the workload domain, which Azion assigns to a new workload under `map.azionedge.net`. Domains belong to the workload, not to the application, and the Applications quickstart sends a first request to the workload domain.
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 is not scaled up and 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 object that attaches a function created in Functions to an application, with the arguments it runs with, listed on the Functions Instances tab and served by the API at `/v4/workspace/applications/<application-id>/functions`. A rule with the Run Function behavior invokes it, naming its ID in `attributes.value`. Function instances documents its fields.
Image Processor	The Product enabled on an application that returns a derived image built from a source image on the origin, following the `ims` query string of the request. Its switch, Image Processor in Main Settings › Modules, is off on a new application, `modules.image_processor.enabled` in the API and `--image-processor` in Azion CLI. Applications describes it, and How Applications works follows a request through it.
`imageProcessedMetrics`	The GraphQL dataset holding request metrics for the images that went through Image Processor. Image Processor settings lists it with the other surfaces that report Image Processor activity.
Images	The usage meter that counts the images Image Processor processes, whether to optimize, crop, resize, filter, or convert them. Each request Image Processor handles counts as one image, and an image served from cache without processing does not count. Applications limits carries the volume each plan includes, and Pricing carries the rate.
`images_processed`	The `metricName` of the consumption GraphQL query that returns the total number of images Image Processor processed, under `productId` `1441110021`. Query usage data from Image Processor carries the full query.
`ims`	The query string parameter that tells Image Processor which transformation to apply, as in `?ims=400x`. It goes last in the URL, because a request that carries another parameter after `ims=` may return a `504` error. Image Processor URL parameters documents every value it accepts and its position.
`ims_http`	The value of the Proxy Upstream field in a Real-Time Events record when Image Processor answered as the upstream. In some cases Image Processor is the origin of Tiered Cache, processing the image and then caching it.
Large File Optimization	The Cache feature, turned on per cache setting with the Large file optimization toggle, that stores a large object as fragments of 1,024 kB. 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. How Applications works describes the mechanism.
Main Settings	The application tab whose four sections are General, which carries the name, Modules, Debug Rules, and Status. Delivery and protocol settings are not on it, because they belong to the workload that serves the application. Main Settings documents each section.
match condition	The name other platforms give to the test that decides whether a rule acts on a request, which an application calls a criterion. Criteria combine with `and` and `or`, and Rules Engine for Applications lists every variable and operator.
Max Age	The Azion Console 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 the 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 Tiered Cache is on, and a value above `31536000` with `10068`. The Browser Cache section carries a Max Age of its own, `browser_cache.max_age`; Applications limits carries the bounds that depend on the Products 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 has no key there, because it is a switch inside a cache setting.
Optimize Images	The Rules Engine for Applications behavior that turns on Image Processor for the requests its rule matches, `optimize_images` in the API. It runs in the Request Phase, takes no arguments, and requires Image Processor on the application. The API accepts it alone in a rule, with no Set Cache Policy beside it.
`orig`	The `ims` dimension value that keeps the original measurement of the source image on one axis, while the other axis takes the requested value. A derived image with an `orig` dimension is not autocropped, as Image Processor URL parameters shows.
phase	One of the two stages in which an application runs rules: the Request Phase, which handles the request before a response exists, and the Response Phase, which handles the response delivered to the user. You choose the phase when you create a rule, and it cannot be changed afterward, 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.
property	The name other platforms give to the configuration that serves a site: its hostnames and the rules applied to their requests. On Azion it is two objects: a workload holds the domains, protocols, and certificates, and the application its deployment names holds the rules. How Applications works follows a request through both.
Real-Time Purge	The Platform Resource that clears objects from Cache or Tiered Cache ahead of their TTL, so the origin serves the latest version on the next request. A purge names its objects by URL, by cache key, or by a wildcard expression, and Azion queues it after the confirmation message and lists it in the history once it completes. Real-Time Purge documents the three types and the layer each one reaches.
route	The name other platforms give to a path pattern and what serves the requests that match it. On an application it is a Request Phase rule: a criterion on `${uri}` matches the path, and Set Connector sends the request to a connector. Two such rules send `/api/` to one origin and every other path to another, as How Applications works shows.
rule	An entry in Rules Engine for Applications that runs its behaviors, in one phase, on the requests its criteria match. Rules run in the order you arrange them, and a new application has none: you create each one with + Rule, naming it in General before you choose its Phase. The API serves the rules of the Request Phase at `/v4/workspace/applications/<application-id>/request_rules`, and Rules Engine for Applications lists their fields.
Rules Engine for Applications	The feature of an application that holds its rules and runs them in order, with if-then logic: the criteria are the if, and the behaviors are the then. Azion Console shows it as the Rules Engine tab, 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 runs a function instance on the requests its rule matches, `run_function` in the API with the instance ID in `attributes.value`. It runs in the Request Phase and the Response Phase, and it needs the Functions switch on in Main Settings › Modules. Function instances documents how it names the instance.
Set Cache Policy	The Rules Engine for Applications behavior that names a cache setting and puts it in effect for the requests its rule matches, `set_cache_policy` in the API with the cache setting ID in `attributes.value`. It runs in the Request Phase and does not require Application Accelerator. A cache setting that no Set Cache Policy rule names applies to no request, 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 sends 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.
Sort	The Cache vary by Query String control that groups the same query string arguments under one cache key whatever order they arrive in, `sort_enabled` in the API and off by default. Without it, `?a=1&b=2` and `?b=2&a=1` are two objects that hold one response. With it, a URL purge has to send the arguments in alphabetical order.
source image	The original image, stored on the origin, that Image Processor reads to answer a request carrying an `ims` query string. Azion writes nothing back to it, because each transformation yields a derived image and leaves the original where it is. How Applications works describes the path between the two.
stale cache	The Cache behavior that answers with an expired copy for the length of a stale window when revalidation with the origin fails, turned on per cache setting with the Stale cache toggle. Under Honor cache policies the window is the `stale-while-revalidate` value of the origin, and under Override cache behavior, or when the origin omits the directive, it is 300 seconds. During the window Azion fetches a fresh version in the background, as How Applications works describes.
Tiered Cache	The second cache layer between Azion’s cache and the origin, kept in one region, shared by every data center, and holding objects longer than the first layer. Every plan includes it, and its Tiered Cache toggle sits in a cache setting rather than in Main Settings. The setting must use Override cache behavior, or the API answers `21001`, and a Max Age of at least 3 seconds; Tiered Cache covers the regions it runs in and the purge type that clears it.
topology	The Tiered Cache setting that selects the region where the second cache layer holds objects: `nearest-region`, `br-east-1`, or `us-east-1`, in `modules.cache.tiered_cache.topology`. The API refuses any other value with `10039 Invalid Choice`, and Tiered Cache documents each region.
TTL	The number of seconds Azion’s cache or the browser keeps a copy of an object, set per cache setting by Max Age: `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. On an application, `${request_uri}` requires Application Accelerator, and a rule that uses it without that Product 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 Functions function, through `loadImage`, `resize`, `getImageResponse`, and `clean`, for the `webp`, `jpeg`, and `png` formats. It is not the Image Processor Product: 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	The application feature that keeps a WebSocket connection, a single bidirectional TCP connection, open 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 does not reach the Tiered Cache layer, and a wildcard purge sent to that 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 the platform does not cache. Cache keys breaks the key down element by element.