Use a bucket as an application origin

Serve the objects of an Object Storage bucket through an application, with a storage connector and a Rules Engine rule that sends requests to it.

Last updated

View as Markdown Agent setup

You can serve the objects of an Object Storage bucket through an application by pairing a connector to the bucket with a Rules Engine rule. A request to the domain of the workload that serves the application then returns the object stored under the matching key. To connect an application to an HTTP server instead, refer to Connect an application to an origin.

An account that has not migrated to API v4 builds the same path through the legacy Origins of the application. For more information, refer to Origins.

Choose the interface you work in. The prerequisites and the procedures change with your choice.

Prerequisites

  • A bucket whose workloads_access is read_only or read_write. A restricted bucket cannot back an application. To create a bucket, refer to Object Storage quickstart.
  • An application served by a workload. To create both, refer to Applications quickstart.
  • A personal token, sent in the Authorization header as Token [TOKEN VALUE], because this page uploads the objects with the API. To create a token, 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/.

Upload the objects to serve

The connector serves what the bucket already holds, so the objects go in first. The example on this page serves a page of two objects, both stored under the src prefix of a bucket named app-origin:

Text
01src/index.html
02src/styles/style.css

In a local src directory, create index.html. The page links its stylesheet by a relative path:

HTML
01<!DOCTYPE html>
02<html lang="en">
03<head>
04 <meta charset="UTF-8">
05 <meta name="viewport" content="width=device-width, initial-scale=1.0">
06 <title>Document</title>
07 <link rel="stylesheet" href="styles/style.css">
08</head>
09<body>
10 <h1>Hello world!</h1>
11 <p>I am an object from a bucket.</p>
12</body>
13</html>

In a styles directory inside src, create style.css, the file the page links to:

CSS
01body {
02 background-color: black;
03}
04
05h1,
06p {
07 color: white;
08}

To upload the HTML file with the API, send a POST request with the object key in the path. Content-Type sets the type the object is stored and served with:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/storage/buckets/app-origin/objects/src/index.html \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: text/html' \
06 --data-binary '@./src/index.html'

The API answers 201 with the key the object is stored under:

JSON
01{
02 "state": "executed",
03 "data": {
04 "object_key": "src/index.html"
05 }
06}

To upload the stylesheet, send the same request with its own key and type:

Shell
01curl --request POST \
02 --url https://api.azion.com/v4/workspace/storage/buckets/app-origin/objects/src/styles/style.css \
03 --header 'Accept: application/json' \
04 --header 'Authorization: Token [TOKEN VALUE]' \
05 --header 'Content-Type: text/css' \
06 --data-binary '@./src/styles/style.css'

The response carries the key of the second object:

JSON
01{
02 "state": "executed",
03 "data": {
04 "object_key": "src/styles/style.css"
05 }
06}

The bucket holds the two objects. The src/ segment of each key is part of the key, not a folder, and the platform creates it with the object. Without a Content-Type header, the platform detects the type of the object. Azion Console and the Azion CLI upload objects too. For more information, refer to Object Storage quickstart.

Create a connector to the bucket

A connector to a bucket names the bucket an application reads from and the prefix inside it. The prefix sets where the application’s paths start. With the prefix /src, the object stored under src/index.html answers at /index.html, and src/styles/style.css answers at /styles/style.css. The prefix is optional in the API and required in Azion Console.

In Azion Console, you set up connectors in the Connectors menu, not in a tab of the application. For each field of the Console form and of the request body, refer to Connector settings.

In the API, the connector’s type is storage, and its attributes carry bucket, the name of the bucket, and prefix. For the example on this page, bucket is app-origin and prefix is /src.

Create the connector with a POST request to /v4/workspace/connectors. Then copy the ID of the connector, which the API returns in data.id: the rule that sends requests to the bucket names the connector by this ID.

To create the connector in Azion Console:

Open the Connectors page

Access Azion Console > Connectors.

Start a new connector
Name the connector

In the General section, enter app-origin-connector in Name.

Select the Object Storage type

In the Connector Type section, select Object Storage.

Select the bucket

Select app-origin as the bucket the connector reads from.

Set the prefix

Enter /src in Prefix, the prefix the objects were uploaded under.

Select Create

Azion Console shows Connector successfully created.

Send requests to the bucket

A connector receives no request until a rule sets it. The rule in this section runs in the Request Phase of the application. Its criterion matches every path, with the ${uri} variable, the starts_with operator, and / as the argument, so the whole application reads from the bucket. Its behavior sets the connector.

The ${uri} variable works on every application. A criterion on ${request_uri} needs Application Accelerator on the application. For every variable and operator, refer to Rules Engine for Applications.

To create the rule with the API, send a POST request to the request_rules endpoint of the application. Replace <application-id> with the ID of your application, and <connector-id> with the ID of the connector to the bucket:

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": "serve-the-bucket",
08 "active": true,
09 "criteria": [
10 [
11 {
12 "variable": "${uri}",
13 "conditional": "if",
14 "operator": "starts_with",
15 "argument": "/"
16 }
17 ]
18 ],
19 "behaviors": [
20 {
21 "type": "set_connector",
22 "attributes": {
23 "value": <connector-id>
24 }
25 }
26 ]
27}

The API answers 202 and returns the rule:

JSON
01{
02 "state": "pending",
03 "data": {
04 "id": <rule-id>,
05 "name": "serve-the-bucket",
06 "active": true,
07 "criteria": [
08 [
09 {
10 "conditional": "if",
11 "variable": "${uri}",
12 "operator": "starts_with",
13 "argument": "/"
14 }
15 ]
16 ],
17 "behaviors": [
18 {
19 "type": "set_connector",
20 "attributes": {
21 "value": <connector-id>
22 }
23 }
24 ],
25 "description": "",
26 "order": 0,
27 "last_editor": "user@example.com",
28 "last_modified": "2026-01-01T12:00:26.750242Z",
29 "created_at": "2026-01-01T12:00:26.750262Z"
30 }
31}

The rule is the first of the application’s Request Phase, at order 0.

To create the rule in Azion Console:

Open the application

Access Azion Console > Applications, then select your application.

Select the Rules Engine tab
Start a rule

Select + Rule.

Name the rule

In the General section, enter a Name, such as serve-the-bucket.

Select the phase

In the Phase section, select Request Phase. A rule keeps the phase it is created in.

Set the criterion

In the Criteria section, set the variable to ${uri}, the operator to starts_with, and the argument to /.

Set the connector

In the Behaviors section, select Set Connector, then select the connector to the bucket in Connector.

Save the rule

Select Save.

The rule appears in the Rules Engine tab of the application, under Request.

For the behavior and its attributes, refer to Set Connector.

Confirm that the application serves the bucket

The rule takes some time to propagate. Until then, the domain of the workload does not answer with the objects.

To confirm the delivery path, request the page through the domain of your workload, with that domain in place of <your-workload-domain>:

curl https://<your-workload-domain>/index.html

The response body is the object stored under src/index.html, which the /src prefix serves at /index.html. It carries the heading Hello world! and the paragraph I am an object from a bucket. A workload’s domain ends in .map.azionedge.net, and the API returns it in workload_domain when it creates the workload.

Go to the same address in a browser. The browser renders the page with the stylesheet applied, which it loads from /styles/style.css under the same prefix.

If the domain does not return the object yet, the rule has not propagated. Send the request again, and look for another cause only after that. For more information, refer to Troubleshoot Applications.

Next steps

Cache settingsSet how long the objects the application serves stay cached.ConnectorsEvery field of a connector to a bucket, and the other connector types.How Object Storage worksWhat the access level changes, and the path a request takes to an object.Buckets and objectsBucket names, access levels, object keys, and prefixes.