# Glossary [Applications](/en/documentation/platform/applications/) and the Products enabled on an application, [Cache](/en/documentation/platform/applications/#cache), [Application Accelerator](/en/documentation/platform/applications/#application-accelerator), and [Image Processor](/en/documentation/platform/applications/#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](/en/documentation/platform/applications/rules-engine/#behaviors) lists every behavior. | | Add Request Header | The [Rules Engine for Applications](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/applications/application-accelerator/settings/#cache-variation) 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](/en/documentation/platform/applications/application-accelerator/settings/#cache-variation) 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](/en/documentation/platform/workloads/) selects it in the **Application** field of its **Deployment Settings**, the API serves it at `/v4/workspace/applications`, and [Applications](/en/documentation/platform/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](/en/documentation/platform/applications/#application-accelerator) describes it, and [How Applications works](/en/documentation/platform/applications/how-it-works/#application-accelerator) 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](/en/documentation/platform/applications/image-processor/url-parameters/#resize) 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](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/applications/rules-engine/#bypass-cache) 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](/en/documentation/platform/applications/how-it-works/#application-accelerator) explains. It does not reach [Tiered Cache](/en/documentation/platform/applications/cache/tiered-cache/#bypass-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](/en/documentation/platform/applications/#cache) describes it, and [How Applications works](/en/documentation/platform/applications/how-it-works/#cache) 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](/en/documentation/platform/applications/cache/cache-keys/#key-format) documents every form. | | cache key purge | A [Real-Time Purge](/en/documentation/platform/applications/cache/real-time-purge/#cache-key-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](/en/documentation/platform/applications/cache/tiered-cache/#purge) 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](/en/documentation/platform/applications/cache/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](/en/documentation/platform/applications/cache/cache-keys/#cache-status) 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](/en/documentation/platform/applications/image-processor/settings/#cache-variation) 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](/en/documentation/platform/applications/application-accelerator/settings/#cache-variation) 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](/en/documentation/platform/applications/device-groups/), `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](/en/documentation/platform/applications/cache/cache-keys/#variations) lists the prefix with the other variations. | | connector | The object an application sends requests to so they reach your origin, created in [Connectors](/en/documentation/platform/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](/en/documentation/platform/connectors/#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](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/real-time-events/), and in the `$stacktrace` variable in the GraphQL API. To read those logs, refer to [Debug rules created with Rules Engine](/en/documentation/guides/application-development/getting-started/debug-rules/). | | 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](/en/documentation/platform/applications/application-accelerator/settings/#cache-variation) 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](/en/documentation/platform/applications/how-it-works/#image-processor) 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](/en/documentation/platform/applications/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](/en/documentation/platform/workloads/), not to the application, and the [Applications quickstart](/en/documentation/platform/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](/en/documentation/platform/applications/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](/en/documentation/platform/applications/image-processor/url-parameters/#resize) shows each form. | | Forward Cookies | The [Rules Engine for Applications](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/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//functions`. A rule with the **Run Function** behavior invokes it, naming its ID in `attributes.value`. [Function instances](/en/documentation/platform/applications/functions-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](/en/documentation/platform/applications/#image-processor) describes it, and [How Applications works](/en/documentation/platform/applications/how-it-works/#image-processor) follows a request through it. | | `imageProcessedMetrics` | The GraphQL dataset holding request metrics for the images that went through Image Processor. [Image Processor settings](/en/documentation/platform/applications/image-processor/settings/#usage-and-event-data) 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](/en/documentation/platform/applications/limits/#image-processor) carries the volume each plan includes, and [Pricing](/en/documentation/fundamentals/pricing/#image-processor) 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](/en/documentation/guides/platform/observability/query-image-processor-usage-data-with-graphql/) 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](/en/documentation/platform/applications/image-processor/url-parameters/#position-of-the-ims-parameter) documents every value it accepts and its position. | | `ims_http` | The value of the **Proxy Upstream** field in a [Real-Time Events](/en/documentation/platform/real-time-events/) record when Image Processor answered as the upstream. In some cases Image Processor is the origin of [Tiered Cache](/en/documentation/platform/applications/cache/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=-`, and the feature applies to Tiered Cache too when that layer is on. [How Applications works](/en/documentation/platform/applications/how-it-works/#cache) 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](/en/documentation/platform/workloads/) that serves the application. [Main Settings](/en/documentation/platform/applications/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](/en/documentation/platform/applications/rules-engine/#criteria) 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](/en/documentation/platform/applications/limits/#application-accelerator) 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](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/applications/image-processor/url-parameters/#resize) 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](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/workloads/) holds the domains, protocols, and certificates, and the application its deployment names holds the rules. [How Applications works](/en/documentation/platform/applications/how-it-works/#the-path-a-request-travels) 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](/en/documentation/platform/applications/cache/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](/en/documentation/platform/applications/how-it-works/#the-path-a-request-travels) 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//request_rules`, and [Rules Engine for Applications](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/applications/rules-engine/) documents every variable, operator, and behavior. | | Run Function | The [Rules Engine for Applications](/en/documentation/platform/applications/rules-engine/) 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](/en/documentation/platform/applications/functions-instances/#run-function-behavior) documents how it names the instance. | | Set Cache Policy | The [Rules Engine for Applications](/en/documentation/platform/applications/rules-engine/#set-cache-policy) 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](/en/documentation/platform/applications/rules-engine/) behavior that sends the requests its rule matches to a [connector](/en/documentation/platform/connectors/), `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](/en/documentation/platform/applications/how-it-works/#image-processor) 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](/en/documentation/platform/applications/how-it-works/#cache) 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](/en/documentation/platform/applications/cache/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](/en/documentation/platform/applications/cache/tiered-cache/#topology) documents each region. | | TTL | The number of seconds Azion's cache or the browser keeps a copy of an object, set per [cache setting](/en/documentation/platform/applications/cache/cache-settings/) 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](/en/documentation/platform/applications/cache/real-time-purge/#url-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](/en/documentation/platform/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](/en/documentation/platform/applications/image-processor/settings/#wasm-image-processor-library) 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](/en/documentation/platform/applications/websocket/) documents its requirements and availability. | | wildcard purge | A [Real-Time Purge](/en/documentation/platform/applications/cache/real-time-purge/#wildcard-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 ` from with `. A request has to carry `Pragma: azion-debug-cache` for Azion to add it to the response. [Cache keys](/en/documentation/platform/applications/cache/cache-keys/#debug-headers) 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](/en/documentation/platform/applications/cache/cache-keys/#key-format) breaks the key down element by element. |