# Use um bucket do Object Storage como origem

import DocButton from '~/components/webkit/DocButton.vue';
import Tabs from '~/components/tabs/Tabs'
import Code from '~/components/Code/Code.astro'

import Apiv4Rollout from '~/includes/snippets/apiv4Rollout/pt/snippet.mdx'

<Apiv4Rollout />

Este guia descreve o processo de configuração de um bucket como origem de uma application usando a [API da Azion](https://api.azion.com/), [Azion CLI](/pt-br/documentacao/produtos/azion-cli/visao-geral/), e [Azion Runtime](/pt-br/documentacao/runtime/api-reference/storage/).


Existem instruções separadas para API v3 usando configurações de [Origin legado](/pt-br/documentacao/produtos/build/applications/origins/) e API v4 usando o novo produto [Connectors](/pt-br/documentacao/produtos/secure/connectors).

:::tip
Se você não tem certeza de quais etapas se aplicam à sua conta, consulte [este guia](/pt-br/documentacao/produtos/guias/verificar-migracao-conta/) para determinar se sua conta já foi migrada.
:::

<DocButton href="/pt-br/documentacao/produtos/store/object-storage/" label="Consulte a referência do Object Storage" kind="secondary" target="_blank" size="medium" />



---

## Criar um bucket e fazer upload de arquivos

Esta seção descreve como você pode fazer upload de objetos para um bucket e manter a estrutura do projeto usando a [API da Azion](https://api.azion.com). Neste cenário, você criará uma aplicação estática usando dois arquivos, distribuídos em pastas da seguinte forma:

```txt
src/index.html
src/styles/style.css
```

1. Crie o seguinte arquivo `index.html` em um diretório local `src`:

```html title="src/index.html"
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="styles/style.css">
</head>
<body>
    <h1>Hello world!</h1>
    <p>I am an object from a bucket.</p>
</body>
</html>
```

2. Agora crie o arquivo `style.css`, que é referenciado no HTML, dentro de uma pasta `styles` no mesmo diretório:

```css title="src/styles/style.css"
body {
background-color: black;
}

h1, p {
    color: #F3652B;
}
```

   3. Execute a requisição `POST` a seguir no seu terminal, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/) e inserindo o nome desejado do bucket em `name` para criar um bucket de leitura apenas (read-only bucket):

```bash
curl --location 'https://api.azion.com/v4/storage/buckets' \
--header 'Accept: application/json;' \
--header 'Content-Type: application/json' \
--header 'Authorization: Token [TOKEN VALUE]' \
--data '{
    "name": "app-origin",
    "edge_access": "read_only"
}'
```

4. Você deve receber a seguinte resposta:

```json
{
  "state": "executed",
  "data": {
    "name": "app-origin",
    "edge_access": "read_only"
  }
}
```

5. Execute as seguintes requisições `POST` no seu terminal para cada arquivo, substituindo `<bucket_name>` pelo nome do bucket que você acabou de criar:

    - Para o arquivo `index.html`, execute o seguinte comando usando `src/index.html` como a chave do objeto, e adicionando o caminho do objeto como dados:

```bash
    curl --location 'https://api.azion.com/v4/storage/buckets/<bucket_name>/objects/src/index.html' \
    --header 'Accept: application/json;' \
    --header 'Content-Type: text/html' \
    --header 'Authorization: Token [TOKEN VALUE]' \
    --data '@./src/index.html'
```

    - Para o arquivo `styles.css`, execute o seguinte comando usando `src/styles/style.css` como a chave do objeto, e adicionando o caminho do objeto como dados:

```bash
    curl --location 'https://api.azion.com/v4/storage/buckets/<bucket_name>/objects/src/styles/style.css' \
    --header 'Accept: application/json;' \
    --header 'Content-Type: text/css' \
    --header 'Authorization: Token [TOKEN VALUE]' \
    --data '@./src/styles/style.css'
```

6. Você deve receber as seguintes respostas para os arquivos:

```json
{
    "state": "executed",
    "data": {
        "object_key": "src/index.html"
    }
}
```

```json
{
    "state": "executed",
    "data": {
        "object_key": "src/styles/style.css"
    }
}
```

:::caution[Atenção]
Quando um bucket é configurado com **permissões de read-write**, qualquer usuário pode acessar e modificar seu conteúdo (por exemplo, enviando uma requisição PUT para sobrescrever arquivos). Se o bucket for usado como origem para uma application, essa configuração pode expor o conteúdo a modificações não autorizadas. No entanto, se o bucket for acessado através de uma function, o risco é gerenciado pela lógica implementada no código da função, permitindo que os desenvolvedores imponham controles mais rigorosos sobre quem pode acessar ou modificar os dados. Para mitigar riscos, sempre verifique as permissões necessárias para cada caso de uso e implemente controles de acesso adequados. Saiba mais sobre [Autenticação e permissões](/pt-br/documentacao/produtos/gestao-de-contas/teams-permissions/). 
:::

---

## Crie uma application e defina o tipo de origem como Object Storage

Agora que seu bucket está populado com arquivos, você pode criar uma nova application e um domínio para definir o bucket como a origem do conteúdo e servir esses objetos.

<Tabs client:visible>
    <Fragment slot="tab.consoleedgeconnector">Console - Connectors</Fragment>
    <Fragment slot="tab.consoleorigins">Console - Origins</Fragment>
    <Fragment slot="tab.apiv4">API v4</Fragment>
    <Fragment slot="tab.apiv3">API v3</Fragment>
    <Fragment slot="tab.cli">CLI </Fragment>

<Fragment slot="panel.consoleedgeconnector">
Para facilitar esse processo, use o template [Applications Proxy](/pt-br/documentacao/produtos/guias/edge-application-proxy-template/):

1. Acesse [Azion Console](https://console.azion.com).
    - Se você ainda não tem uma conta, crie uma nova [visitando a página de inscrição](https://console.azion.com/signup).
2. Na página inicial, selecione a opção **+ Create**.
3. Encontre o cartão **Applications Proxy** na seção de templates e selecione-o.
4. Dê um nome fácil de lembrar para a sua aplicação.
5. Em **Route to bypass**, digite `/` para especificar o caminho raiz da aplicação.
6. Aguarde o término do processo de implantação.
7. Copie o domínio da aplicação, no formato `http://xxxxxxxxxx.map.azionedge.net/`.

:::note
O link para a application permite que você a veja no navegador. No entanto, leva um certo tempo para propagar e configurar a aplicação nas edge locations da Azion. Pode ser necessário aguardar alguns minutos para que a URL seja ativada e para que a página da aplicação seja efetivamente exibida no navegador.
:::

Agora você precisa configurar uma nova origem do tipo **Object Storage** e determinar que sua aplicação deve recuperar o conteúdo do bucket e prefixo que você criou. Para fazer isso:

1. [Acesse o Azion Console](/pt-br/documentacao/produtos/guias/como-acessar-o-azion-console/) > **Connectors**.
2. Clique no botão **+ Connector**.
3. Na seção **General**, dê ao seu conector um nome único e descritivo (por exemplo, `My Object Storage Connector`).
4. Na seção **Connector Type**, selecione **Object Storage**.
5. Na seção **Connection Options**:
    - Para **Bucket**, selecione o nome do bucket que você criou nos passos anteriores.
    - Para **Prefix**, digite `/src` (ou o prefixo que você usou ao fazer upload dos seus objetos).
6. Defina o **Status** como **Active**.
7. Clique no botão **Save**.

Para ativar o Connector na sua application:

1. Acesse a aba **Rules Engine**.
2. Edite a regra padrão ou adicione uma nova regra de requisição.
3. Na seção **Criteria**, para aplicar o Connector para toda a sua aplicação, defina os **criteria** como `If ${uri} starts with /`.
4. Na seção **Behavior**, selecione o comportamento Set Connector.
5. Selecione o Connector que você deseja aplicar.
6. Clique no botão **Save**.
7. Aguarde algum tempo para que as alterações se propaguem para o edge.

Uma vez que as alterações tenham sido feitas, acesse `http://xxxxxxxxxx.map.azionedge.net/index.html` para ver o arquivo HTML que você carregou com o estilo CSS aplicado.
</Fragment>


<Fragment slot="panel.consoleorigins">

:::caution[Atenção]
As etapas abaixo descrevem o fluxo legado via **Applications > Origins**. Para contas migradas, a forma oficial e recomendada é criar um **Connector** do tipo **Object Storage** (o seletor de buckets lista automaticamente seus buckets e possui campo de busca) e aplicar o comportamento **Set Connector** no **Rules Engine**.
:::
Para facilitar esse processo, use o template [Applications Proxy](/pt-br/documentacao/produtos/guias/edge-application-proxy-template/):

1. Acesse [Azion Console](https://console.azion.com).
    - Se você ainda não tem uma conta, crie uma nova [visitando a página de inscrição](https://console.azion.com/signup).
2. Na página inicial, selecione a opção **+ Create**.
3. Encontre o cartão **Applications Proxy** na seção de templates e selecione-o.
4. Dê um nome fácil de lembrar para a sua aplicação.
5. Em **Origin Address**, digite `httpbin.org`. 
    - Este é um origem temporária que será substituída posteriormente por uma origem de Object Storage.
6. Em **Bypass Route**, digite `/` para especificar o caminho raiz da aplicação.
7. Aguarde o término do processo de implantação.
8. Copie o domínio da aplicação, no formato `http://xxxxxxxxxx.map.azionedge.net/`.

:::note
O link para a application permite que você a veja no navegador. No entanto, leva um certo tempo para propagar e configurar a aplicação nas edge locations da Azion. Pode ser necessário aguardar alguns minutos para que a URL seja ativada e para que a página da aplicação seja efetivamente exibida no navegador.
:::

Agora você precisa configurar uma nova origem do tipo **Object Storage** e determinar que sua aplicação deve recuperar o conteúdo do bucket e prefixo que você criou. Para fazer isso:

1. [Acesse o Azion Console](/pt-br/documentacao/produtos/guias/como-acessar-o-azion-console/) > **Applications**.
2. Clique na aplicação de proxy que você criou nos passos anteriores.
3. Navegue até a guia **Origins**.
4. Clique no botão **+ Origin**.
5. Dê um nome fácil de lembrar para a sua origem.
6. Em **Origin Type**, selecione **Object Storage**.
7. Em **Bucket Name**, adicione o nome do bucket que você criou nos passos anteriores.
8. Em **Prefix**, adicione `/src`, que é o prefixo que você adicionou às chaves dos objetos carregados anteriormente.
9. Clique no botão **Save**.

Para ativar a origem na sua application:

10. Navegue até a guia **Rules Engine**.
11. Selecione **Standard Rule**.
12. Em **Behaviors**, no comportamento **Set Origin**, substitua a **Standard Origin** pela origem que você criou para o seu bucket.
13. Clique no botão **Save**.
14. Aguarde algum tempo para que as alterações se propaguem para o edge.

Uma vez que as alterações tenham sido feitas, acesse `http://xxxxxxxxxx.map.azionedge.net/index.html` para ver o arquivo HTML que você carregou com o estilo CSS aplicado.
</Fragment>

<Fragment slot="panel.apiv4">
1. Execute a seguinte requisição `POST` no seu terminal, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/):

<Code lang="bash" code={`curl --request POST \
  --url https://api.azion.com/v4/edge_application/applications \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "object storage app",
  "modules": {
    "edge_cache": {
      "enabled": true
    },
    "edge_functions": {
      "enabled": true
    },
    "application_accelerator": {
      "enabled": false
    },
    "image_processor": {
      "enabled": false
    },
    "tiered_cache": {
      "enabled": false
    }
  },
  "active": true,
  "debug": false
}'`} />




2. Você deve receber uma resposta semelhante a esta:

<Code lang="json" code={`{
  "state": "pending",
  "data": {
    "id": "edge_application_id",
    "name": "object storage app",
    "last_editor": "education1@azion.com",
    "last_modified": "2025-07-25T19:06:13.854005Z",
    "modules": {
      "edge_cache": {
        "enabled": true
      },
      "edge_functions": {
        "enabled": true
      },
      "application_accelerator": {
        "enabled": false
      },
      "image_processor": {
        "enabled": false
      },
      "tiered_cache": {
        "enabled": false
      }
    },
    "active": true,
    "debug": false,
    "product_version": "3.0"
  }
}`} />

3. Copie o valor do campo `edge_application_id` e cole-o em um editor de texto para salvá-lo para requisições posteriores.

4. Execute a seguinte requisição `POST` no seu terminal para criar um Connector, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/)

<Code lang="bash" code={`curl --request POST \
  --url https://api.azion.com/v4/edge_connector/connectors \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "object storage connector",
  "active": true,
  "type": "edge_storage",
  "attributes": {
    "bucket": "app-origin",
    "prefix": "/"
  }
}'
`} />

5. Copie o valor do campo `<connector_id>` e cole-o em um editor de texto para salvá-lo para requisições posteriores.

6. Você deve receber uma resposta semelhante a esta:

<Code lang="json" code={`{
  "id": "<connector_id>",
  "name": "object storage connector",
  "last_editor": "your-email@example.com",
  "last_modified": "2025-07-22T14:34:31.009649Z",
  "active": true,
  "product_version": "1.0",
  "type": "edge_storage",
  "attributes": {
    "bucket": "app-origin",
    "prefix": "/"
  }
}`} />

7. Execute a seguinte requisição `POST` no seu terminal, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/)

<Code lang="bash" code={`curl --request POST \
  --url https://api.azion.com/v4/workspace/workloads \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "object storage domain",
  "active": true,
  "infrastructure": 1,
  "protocols": {
    "http": {
      "versions": [
        "http1",
        "http2"
      ]
    }
  },
  "workload_domain_allow_access": true
}'`} />

8. Você deve receber uma resposta semelhante a esta:

<Code lang="json" code={`{
  "state": "pending",
  "data": {
    "id": "workload_id",
    "name": "object storage domain",
    "active": true,
    "last_editor": "your-email@example.com",
    "last_modified": "2025-07-25T18:58:25.817955Z",
    "infrastructure": 1,
    "tls": {
      "certificate": null,
      "ciphers": 7,
      "minimum_version": "tls_1_3"
    },
    "protocols": {
      "http": {
        "versions": [
          "http1",
          "http2"
        ],
        "http_ports": [
          80
        ],
        "https_ports": [
          443
        ],
        "quic_ports": null
      }
    },
    "mtls": {
      "verification": null,
      "certificate": null,
      "crl": null
    },
    "domains": [],
    "workload_domain_allow_access": true,
    "workload_domain": "xxxxxxxxxxx.azionedge.net",
    "product_version": "1.0"
  }
}`} />

9. Copie a URL no valor `workload_domain` e cole-a em um editor de texto para acessar mais tarde.

10. Execute a seguinte requisição `POST` para vincular o Workload à sua Applications, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/), `<edge_application_id>` pelo ID da application e `<workload_id>` pelo ID do Workload.

<Code lang="bash" code={`curl --request POST \
  --url https://api.azion.com/v4/workspace/workloads/<workload_id>/deployments \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "Object Storage App",
  "current": true,
  "active": true,
  "strategy": {
    "type": "default",
    "attributes": {
      "edge_application": "<edge_application_id>"
    }
  }
}'`} />


11. Execute a seguinte requisição `POST` no seu terminal para criar uma regra do **Rules Engine**, substituindo a variável `<edge_application_id>` pelo ID da Applications e `<connector_id>` pelo ID do Connector que você copiou anteriormente:

<Code lang="bash" code={`curl --request POST \
  --url https://api.azion.com/v4/edge_application/applications/<edge_application_id>/request_rules \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "string",
  "active": true,
  "criteria":
    [
      {
        "conditional": "if",
        "variable": "\${uri}",
        "operator": "starts_with",
        "argument": "/"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_edge_connector",
      "attributes": {
        "value": "<connector_id>"
      }
    }
  ]
}'
`} />

12. Você deve receber uma resposta semelhante a esta:

<Code lang="json" code={`{
  "state": "pending",
  "data": {
    "id": "<rule_id>",
    "name": "string",
    "active": true,
    "criteria": [
      [
        {
          "conditional": "if",
          "variable": "\${uri}",
          "operator": "starts_with",
          "argument": "/"
        }
      ]
    ],
    "behaviors": [
      {
        "type": "set_edge_connector",
        "attributes": {
          "value": "<connector_id>"
        }
      }
    ],
    "description": "",
    "order": 1,
    "last_editor": "your-email@example.com",
    "last_modified": "2025-07-25T19:29:30.684210Z"
  }
}`} />



13. Aguarde algum tempo para que as alterações se propaguem.

Uma vez que as alterações tenham sido feitas, acesse o domínio que você criou, no formato `http://xxxxxxxxxx.map.azionedge.net/index.html`, para ver o arquivo HTML que você carregou com o estilo CSS aplicado.

</Fragment>

<Fragment slot="panel.apiv3">
1. Execute a seguinte requisição `POST` no seu terminal, substituindo `[VALOR DO TOKEN]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/):

<Code lang="bash" code={`
curl --location 'https://api.azionapi.net/edge_applications' \
--header 'Accept: application/json;' \
--header 'Authorization: Token [TOKEN VALUE]' \
--header 'Content-Type: application/json' \
--data '{
    "name": "object storage app",
    "delivery_protocol": "http",
    "http3": false,
    "origin_type": "single_origin",
    "address": "httpbin.org",
    "origin_protocol_policy": "preserve",
    "host_header": "\${host}",
    "browser_cache_settings": "honor",
    "browser_cache_settings_maximum_ttl": 0,
    "cdn_cache_settings": "override",
    "cdn_cache_settings_maximum_ttl": 0
}'
`} />

2. Você deve receber uma mensagem semelhante a esta:

```json
{
    "results": {
        "id": <edge_application_id>,
        "name": "object storage app",
        "delivery_protocol": "http"
        ...
    },
    "schema_version": 3
}
```

3. Copie o valor do campo `edge_application_id` e cole-o em um editor de texto para salvá-lo para requisições posteriores.
4. Execute a seguinte requisição `POST` no seu terminal, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/) e `<edge_application_id>` pelo ID da application que você criou:

```bash
curl --location 'https://api.azionapi.net/domains' \
--header 'Accept: application/json;' \
--header 'Authorization: Token [TOKEN VALUE]' \
--header 'Content-Type: application/json' \
--data '{
    "name": "object storage domain",
    "cname_access_only": false,
    "digital_certificate_id": null,
    "edge_application_id": <edge_application_id>
}'
```

5. Você deve receber uma resposta semelhante a esta:

```json
{
    "results": {
        "id": <domain_id>,
        "name": "object storage domain",
        ...
        "edge_application_id": <edge_application_id>,
        "is_active": true,
        "domain_name": "xxxxxxxxxx.map.azionedge.net",
        ...
    },
    "schema_version": 3
}
```

6. Copie a URL no valor `domain_name` e cole-a em um editor de texto para acessar mais tarde. 
7. Execute a seguinte requisição `POST` para criar uma origem de Object Storage para a aplicação, substituindo `[TOKEN VALUE]` pelo seu [personal token](/pt-br/documentacao/produtos/guias/personal-tokens/), `<edge_application_id>` pelo ID da application, e o valor de `bucket` pelo nome do bucket que você criou:

```bash
curl --location 'https://api.azionapi.net/edge_applications/<edge_application_id>/origins' \
--header 'Accept: application/json;' \
--header 'Authorization: Token [TOKEN VALUE]' \
--header 'Content-Type: application/json' \
--data '{
    "name": "object storage origin",
    "origin_type": "object_storage",
    "bucket": "app-origin",
    "prefix": "/src"
}'
```

8. Você deve receber uma resposta semelhante a esta:

```json
{
  "results": {
    "origin_id": <origin_id>,
    "origin_key": "bdcd7003-ba53-4ed8-8ca0-05b1357cdafd",
    "name": "New Object Storage origin",
    "origin_type": "object_storage",
    ...
    "bucket": "new-bucket-rw",
    "prefix": "/"
  },
  "schema_version": 3
}
```

9. Copie o valor do campo `origin_id` e cole-o em um editor de texto para salvá-lo para requisições posteriores.
10. Execute a seguinte requisição `GET` no seu terminal para recuperar o ID da regra padrão do **Rules Engine** da sua application, substituindo a variável `<edge_application_id>` pelo ID da application que você copiou anteriormente:

```bash
curl --location 'https://api.azionapi.net/edge_applications/<edge_application_id>/rules_engine/request/rules' \
--header 'Accept: application/json;' \
--header 'Authorization: Token [TOKEN VALUE]'
```

11. Você deve receber uma resposta semelhante a esta:

```json
{
    ...
    "results": [
        {
            "id": <rule_id>,
            "name": "Default Rule",
            "phase": "default",
            "behaviors": [
                {
                    "name": "set_origin",
                    "target": "<origin_id>"
                },
                {
                    "name": "set_cache_policy",
                    "target": "<cache_setting_id>"
                }
            ],
            ...
            "description": ""
        }
    ]
}
```

12. Copie o valor do campo `rule_id` e cole-o em um editor de texto para salvá-lo para requisições posteriores.
13. Execute a seguinte requisição `PATCH` para modificar a regra padrão, substituindo `<rule_id>` pelo ID da regra que você recuperou no passo anterior, mantendo o objeto `set_cache_policy` igual ao recebido na resposta:

```bash
curl --location --request PATCH 'https://api.azionapi.net/edge_applications/<edge_application_id>/rules_engine/request/rules/<rule_id>' \
--header 'Accept: application/json;' \
--header 'Content-Type: application/json' \
--header 'Authorization: Token [TOKEN VALUE]' \
--data '{
    "behaviors": [
        {
            "name": "set_origin",
            "target": "<origin_id>"
        },
        {
            "name": "set_cache_policy",
            "target": "<cache_setting_id>"
        }
    ]
}'
```

14. Espere algum tempo pela propagação das mudanças.

Uma vez que as alterações tenham sido feitas, acesse o domínio que você criou, no formato `http://xxxxxxxxxx.map.azionedge.net/index.html`, para ver o arquivo HTML que você carregou com o estilo CSS aplicado.

</Fragment>

<Fragment slot="panel.cli">
## Requisitos

- [Azion CLI instalada](/pt-br/documentacao/produtos/azion-cli/visao-geral/#instalar-a-azion-cli). 
- [Um personal token configurado](/pt-br/documentacao/devtools/cli/globals/#token).

Para criar uma application com as configurações necessárias para usar um bucket como origem:

```bash 
azion create edge-application --name "object storage app" --delivery-protocol "http" --http3 false --origin-type "single_origin" --address "httpbin.org" --origin-protocol-policy "preserve" --host-header "${host}" --browser-cache-settings "honor" --browser-cache-settings-maximum-ttl 0 --cdn-cache-settings "override" --cdn-cache-settings-maximum-ttl 0
```

</Fragment>


</Tabs>

:::tip
Após criar sua aplicação com um bucket do Object Storage como origem, você pode gerenciar e configurar configurações, como [respostas de erro](/pt-br/documentacao/produtos/build/applications/error-responses/) e [configurações de cache](/pt-br/documentacao/produtos/guias/cache-settings/).
:::