---
name: azion-conecte-uma-aplicacao-a-uma-origem
description: >-
  Crie um connector para uma origem HTTP e envie as requisições de uma aplicação a ele com uma regra do Rules Engine, pelo Azion Console ou pela API.
---

# Conecte uma aplicação a uma origem

Você pode conectar uma [aplicação](/pt-br/documentacao/plataforma/applications/) a uma origem com um [connector](/pt-br/documentacao/plataforma/connectors/) e uma regra do [Rules Engine](/pt-br/documentacao/plataforma/applications/rules-engine/) que o define. A origem, também chamada de backend, é o servidor do qual a Azion obtém o seu conteúdo. Ela pode ser um serviço de object storage, um servidor em cloud ou outra infraestrutura que hospeda os assets ou os dados da sua aplicação. Você cria os dois pelo Azion Console ou pela API.

Para servir os objetos de um bucket, consulte [Use um bucket como origem de uma aplicação](/pt-br/documentacao/guias/desenvolvimento-de-aplicacoes/dados/bucket-como-connector/). Para distribuir as requisições entre vários endereços, consulte [Balanceie o tráfego entre múltiplas origens](/pt-br/documentacao/guias/performance-e-confiabilidade/disponibilidade/configure-multiplas-origens/). Uma conta que [não migrou para a API v4](/pt-br/documentacao/guias/seguranca-de-aplicacoes/acesso-e-compliance/verificar-migracao-conta/) configura as origens nas Origins legadas da aplicação. Para mais informações, consulte [Origins](/pt-br/documentacao/plataforma/connectors/origins/).

---

Escolha a interface em que você trabalha. Os pré-requisitos e os procedimentos mudam conforme a sua escolha.

## Pré-requisitos

- Uma aplicação servida por um [workload](/pt-br/documentacao/plataforma/workloads/). Para criar os dois, consulte [Primeiros passos com Applications](/pt-br/documentacao/plataforma/applications/primeiros-passos/).

**Console**

- Acesso ao Azion Console. Para entrar, consulte [Acesse Azion Console](/pt-br/documentacao/guias/plataforma/conta-e-billing/como-acessar-o-azion-console/).

**API**

- Um personal token, enviado no header `Authorization` como `Token [TOKEN VALUE]`. Para criar um, consulte [Gerencie um personal token](/pt-br/documentacao/guias/plataforma/conta-e-billing/personal-tokens/).
- `curl` ou outro cliente HTTP.
- O ID da aplicação. Azion Console mostra o ID no endereço da página da aplicação, depois de `/applications/edit/`.

---

## Crie um connector para a origem

Um connector guarda o endereço da origem e as opções que a Azion usa para se conectar a ela. No Azion Console, você configura connectors no menu Connectors, e não em uma aba da aplicação. Para cada campo desse formulário, consulte [Configurações de connector](/pt-br/documentacao/plataforma/connectors/configuracoes/#enderecos). O connector desta seção acessa `httpbin.org` por HTTPS.

**Console**

Para criar o connector no Azion Console:

1. **Abra a página Connectors**

   Acesse [Azion Console](https://console.azion.com/) > **Connectors**.

2. **Inicie um novo connector**

3. **Dê um nome ao connector**

   Na seção **General**, insira `httpbin-connector` em **Name**.

4. **Selecione o tipo HTTP**

   Na seção **Connector Type**, selecione o tipo HTTP.

5. **Insira o endereço da origem**

   Na seção **Address Management**, insira `httpbin.org` em **Address**. Um endereço com protocolo ou porta é recusado com `Address must be a valid IPv4, IPv6, or hostname, without protocol or port.`

6. **Envie httpbin.org no header Host**

   Insira `httpbin.org` como o host que o connector envia à origem no header `Host`.

7. **Conecte-se à origem por HTTPS**

   Em **Transport Protocol Policy**, selecione a opção que força HTTPS.

8. **Selecione Create**

Azion Console mostra `Connector successfully created`.

**API**

Para criar o connector com a API, envie uma requisição `POST` ao endpoint de connectors:

```bash
curl --request POST \
  --url https://api.azion.com/v4/workspace/connectors \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "httpbin-connector",
  "type": "http",
  "attributes": {
    "addresses": [
      {
        "address": "httpbin.org"
      }
    ],
    "connection_options": {
      "transport_policy": "force_https",
      "host": "httpbin.org"
    }
  }
}'
```

O corpo define quatro valores:

| Chave              | O que define                                                                                                      |
| ------------------ | ----------------------------------------------------------------------------------------------------------------- |
| `type`             | `http` conecta a uma origem HTTP ou HTTPS.                                                                        |
| `addresses`        | O endereço da origem. Um connector para uma única origem traz um endereço.                                        |
| `transport_policy` | `force_https` faz a Azion se conectar à origem por HTTPS, qualquer que seja o protocolo da requisição do usuário. |
| `host`             | O valor que a Azion envia à origem no header `Host`.                                                              |

A API responde `202` e retorna o connector:

```json
{
  "state": "pending",
  "data": {
    "version_id": null,
    "version_state": null,
    "id": <connector-id>,
    "name": "httpbin-connector",
    "last_editor": "user@example.com",
    "last_modified": "2026-01-01T12:00:00.190116Z",
    "created_at": "2026-01-01T12:00:00.190133Z",
    "active": true,
    "product_version": "1.0",
    "type": "http",
    "attributes": {
      "addresses": [
        {
          "active": true,
          "address": "httpbin.org",
          "http_port": 80,
          "https_port": 443,
          "modules": null
        }
      ],
      "connection_options": {
        "dns_resolution": "both",
        "transport_policy": "force_https",
        "http_version_policy": "http1_1",
        "host": "httpbin.org",
        "path_prefix": "",
        "following_redirect": false,
        "real_ip_header": "X-Real-IP",
        "real_port_header": "X-Real-PORT"
      },
      "modules": {
        "load_balancer": {
          "enabled": false,
          "config": null
        },
        "origin_shield": {
          "enabled": false,
          "config": null
        }
      }
    },
    "is_versioned": false,
    "version": null
  }
}
```

A resposta preenche o que o corpo deixou de fora. O connector e o endereço dele estão ativos, o endereço usa a porta `80` para HTTP e `443` para HTTPS, e [Load Balancer](/pt-br/documentacao/plataforma/connectors/#load-balancer) e [Origin Shield](/pt-br/documentacao/plataforma/connectors/#origin-shield) estão desabilitados em `modules`. Copie o valor de `data.id`: a regra que envia as requisições ao connector o identifica por esse ID.

### Endereço, path e header Host

Insira o endereço como um nome de domínio ou um endereço IPv4 ou IPv6, sem `http://` ou `https://`. Em vez disso, a chave `transport_policy` define o protocolo. Quando o conteúdo fica sob um path, como `https://bucket.s3.amazonaws.com/applications/your-app`, divida a URL. O hostname, `bucket.s3.amazonaws.com`, vai no endereço, e o path, `/applications/your-app`, vai no prefixo de path do connector, `path_prefix`. Um endereço que traz o path faz as requisições à origem falharem.

A chave `host` recebe um nome de domínio fixo ou a variável `${host}`. A Azion envia um nome fixo, como `httpbin.org`, qualquer que seja o domínio que o usuário requisitou. Use um nome fixo quando a origem serve um único virtualhost, ou responde a um virtualhost em um endereço diferente do que está no DNS. Um nome fixo também serve para uma origem que precisa de um hostname específico para roteamento, correspondência de certificado ou controle de acesso. `${host}`, o padrão, encaminha o header `Host` da requisição do usuário, para uma origem que serve vários virtualhosts a partir de um endereço. Um valor vazio é recusado.

> **Atenção**
>
> Algumas origens verificam o header `Host`, por meio de controles de acesso baseados em Host, de uma allowlist de IPs ligada a um hostname ou de uma configuração que o valida. Uma origem assim pode rejeitar requisições depois que o valor muda. Verifique a configuração de virtualhost da origem antes de alterar `host`.

Uma origem que exige autenticação HMAC, como um bucket privado de object storage, precisa de uma região, uma access key e uma secret key válidas no connector. Sem credenciais válidas, a origem recusa a requisição: o endpoint S3 do Azion Object Storage responde a uma requisição sem assinatura com `401` e `UnauthorizedAccess`. Uma alteração no endereço ou no header Host de um connector alcança todas as regras que o definem. Revise essas regras antes de alterar um connector que serve tráfego de produção.

---

## Envie as requisições ao connector

Um connector não recebe nenhuma requisição até que uma regra o defina. A regra desta seção é executada na fase de requisição da aplicação. O critério dela corresponde a todos os paths, com a variável `${uri}`, o operador `starts_with` e `/` como argumento, e o behavior dela define o connector. Uma aplicação começa sem regras, então é esta regra que envia as requisições dela à origem.

Para enviar apenas um path, como `/httpbin`, use o operador `is_equal` com esse path como argumento. Só com essa regra, uma requisição a qualquer outro path recebe `404`.

A variável `${uri}` funciona em todas as aplicações. Um critério com `${request_uri}` precisa de [Application Accelerator](/pt-br/documentacao/plataforma/applications/application-accelerator/primeiros-passos/) ativado na aplicação. Para todas as variáveis e todos os operadores, consulte [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine/#criterios).

**Console**

Para criar a regra no Azion Console:

1. **Abra a aplicação**

   Acesse [Azion Console](https://console.azion.com/) > **Applications** e selecione a sua aplicação.

2. **Selecione a aba Rules Engine**

3. **Inicie uma regra**

   Selecione **+ Rule**.

4. **Dê um nome à regra**

   Na seção **General**, insira um **Name**, como `send-to-httpbin`.

5. **Selecione a fase**

   Na seção **Phase**, selecione *Request Phase*. Uma regra mantém a fase em que é criada.

6. **Defina o critério**

   Na seção **Criteria**, defina a variável como `${uri}`, o operador como `starts_with` e o argumento como `/`.

7. **Defina o connector**

   Na seção **Behaviors**, selecione *Set Connector* e, em seguida, selecione o seu connector em **Connector**.

8. **Salve a regra**

   Selecione **Save**.

A regra aparece na aba **Rules Engine** da aplicação, em **Request**.

**API**

Para criar a regra com a API, envie uma requisição `POST` ao endpoint `request_rules` da aplicação. Substitua `<application-id>` pelo ID da sua aplicação e `<connector-id>` pelo ID do connector:

```bash
curl --request POST \
  --url https://api.azion.com/v4/workspace/applications/<application-id>/request_rules \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "name": "send-to-httpbin",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${uri}",
        "conditional": "if",
        "operator": "starts_with",
        "argument": "/"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_connector",
      "attributes": {
        "value": <connector-id>
      }
    }
  ]
}'
```

A API responde `202` e retorna a regra:

```json
{
  "state": "pending",
  "data": {
    "id": <rule-id>,
    "name": "send-to-httpbin",
    "active": true,
    "criteria": [
      [
        {
          "conditional": "if",
          "variable": "${uri}",
          "operator": "starts_with",
          "argument": "/"
        }
      ]
    ],
    "behaviors": [
      {
        "type": "set_connector",
        "attributes": {
          "value": <connector-id>
        }
      }
    ],
    "description": "",
    "order": 0,
    "last_editor": "user@example.com",
    "last_modified": "2026-01-01T12:00:26.750242Z",
    "created_at": "2026-01-01T12:00:26.750262Z"
  }
}
```

A regra é a primeira da fase de requisição da aplicação, com `order` `0`.

A mesma regra com `${request_uri}` no lugar de `${uri}`, em uma aplicação sem Application Accelerator, é recusada com `400`:

```json
{
  "errors": [
    {
      "code": "25047",
      "title": "Missing Required Modules",
      "detail": " It requires any of the following modules to be enabled: ['application_accelerator'].",
      "status": "400",
      "source": {
        "pointer": "/data/criteria/0/0/variable"
      },
      "meta": {
        "message_prefix": "",
        "owner_modules": "any",
        "missing_required_modules": [
          "application_accelerator"
        ]
      }
    }
  ]
}
```

O erro aponta para a variável em `source.pointer` e nomeia o Produto ausente em `meta.missing_required_modules`.

Para o behavior e os atributos dele, consulte [Set Connector](/pt-br/documentacao/plataforma/applications/rules-engine/#set-connector).

---

## Confirme que a aplicação alcança a origem

A regra leva alguns minutos para se propagar. Até lá, a aplicação responde como respondia antes de a regra existir.

Para confirmar a rota, envie uma requisição ao domínio do seu workload, com esse domínio no lugar de `<your-workload-domain>`:

```bash
curl -i https://<your-workload-domain>/
```

A resposta é a que `httpbin.org` retorna para `/`. O domínio de um workload termina em `.map.azionedge.net`, e a API o retorna em `workload_domain` quando cria o workload. Se a resposta ainda não vier da origem, envie a requisição novamente até que venha. Se nunca vier, consulte [Solucionar problemas de Applications](/pt-br/documentacao/plataforma/applications/solucao-de-problemas/).

---

## Próximos passos

- [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine.md): Todas as variáveis, operadores e behaviors que uma regra aceita, incluindo Set Connector.
- [Connectors](/pt-br/documentacao/plataforma/connectors.md): Todas as opções de conexão de um connector HTTP e os outros tipos de connector.
- [Balanceie o tráfego entre múltiplas origens](/pt-br/documentacao/guias/performance-e-confiabilidade/disponibilidade/configure-multiplas-origens.md): Ative Load Balancer em um connector e atribua pesos a vários endereços de origem.
- [Use um bucket como origem de uma aplicação](/pt-br/documentacao/guias/desenvolvimento-de-aplicacoes/dados/bucket-como-connector.md): Sirva os objetos de um bucket do Object Storage pelo mesmo tipo de regra.
