---
name: azion-configure-portas-http-e-https
description: >-
  Escolha as portas HTTP e HTTPS em que um workload escuta e envie cada porta para uma porta de origem pelo Azion Console, pela Azion CLI ou pela API.
---

# Configure portas HTTP e HTTPS

Você pode escolher as portas em que um [workload](/pt-br/documentacao/plataforma/workloads/) escuta para HTTP e HTTPS e enviar as requisições de cada porta para uma porta de origem pelo Azion Console, pela [Azion CLI](/pt-br/documentacao/devtools/cli/) ou pela API. Para a versão de TLS e o conjunto de cifras das portas HTTPS, consulte [Defina o conjunto de cifras TLS](/pt-br/documentacao/guias/seguranca-de-aplicacoes/tls-e-certificados/cifras/).

Duas portas participam de toda requisição. A porta de entrega é a porta à qual seus usuários se conectam, e o workload a define. A porta de origem é a porta à qual a Azion se conecta na sua origem, e o [connector](/pt-br/documentacao/plataforma/connectors/) da aplicação a define. Cada uma tem um padrão, `80` para HTTP e `443` para HTTPS, e você pode alterar uma sem alterar a outra.

Esta tabela mostra as combinações, com uma requisição de exemplo e a configuração que cada uma altera:

| Combinação                                                         | URL de origem                     | URL de entrega                 | O que alterar                                                                        |
| ------------------------------------------------------------------ | --------------------------------- | ------------------------------ | ------------------------------------------------------------------------------------ |
| Porta de origem padrão, porta de entrega padrão                    | `https://origin.example.com:443`  | `https://www.example.com:443`  | Nada                                                                                 |
| Porta de origem padrão, protocolo diferente do da porta de entrega | `http://origin.example.com:80`    | `https://www.example.com:443`  | A política de protocolo do connector                                                 |
| Porta de origem padrão, porta de entrega personalizada             | `http://origin.example.com:80`    | `http://www.example.com:8080`  | As portas do workload                                                                |
| Porta de origem personalizada, porta de entrega padrão             | `https://origin.example.com:9443` | `https://www.example.com:443`  | As portas do connector                                                               |
| Porta de origem personalizada, porta de entrega personalizada      | `https://origin.example.com:8443` | `https://www.example.com:9443` | As portas do workload e do connector, e uma regra por porta de entrega personalizada |

Uma conta que roda na API v3 define as portas de entrega na aplicação. Para mais informações, consulte [Main Settings](/pt-br/documentacao/plataforma/applications/main-settings-v3/) e [Migração para API v4](/pt-br/documentacao/fundamentos/api-v4-migration/).

---

Selecione uma interface. Os pré-requisitos e as etapas de cada tarefa seguem a sua escolha.

## Pré-requisitos

- Um workload cujo deployment nomeia uma aplicação. Para criar os dois, consulte [Primeiros passos com Workloads](/pt-br/documentacao/plataforma/workloads/primeiros-passos/).
- Para uma porta de origem personalizada, um connector para a sua origem que as regras da aplicação possam nomear. Para criar um connector e uma regra, consulte [Primeiros passos com Applications](/pt-br/documentacao/plataforma/applications/primeiros-passos/).

**Console**

- Acesso ao Azion Console. Para mais informações, consulte [Como acessar o Azion Console](/pt-br/documentacao/guias/plataforma/conta-e-billing/como-acessar-o-azion-console/).

**CLI**

- A [Azion CLI](/pt-br/documentacao/devtools/cli/), autorizada com a sua conta. Esta página corresponde à Azion CLI 4.23.0.
- O ID do workload. `azion create workload` o imprime como `Created Workload with ID <workload-id>`.
- O ID da aplicação e o ID do connector, para uma porta de origem personalizada.

**API**

- Um token pessoal para o header `Authorization`, no formato `Token [TOKEN VALUE]`. Para criar um token, consulte [Tokens pessoais](/pt-br/documentacao/fundamentos/personal-tokens/).
- `curl` ou outro cliente HTTP.
- O ID do workload e, para uma porta de origem personalizada, o ID da aplicação e o ID do connector.

---

## Defina as portas em que o workload escuta

As portas HTTP e HTTPS de um workload são duas listas no objeto `protocols.http` dele. As portas HTTP vêm de quatro valores: `80`, `8008`, `8080` e `8880`. As portas HTTPS vêm de doze: `443`, `8443`, `9440`, `9441`, `9442`, `9443`, `7777`, `8888`, `9553`, `9653`, `8035` e `8090`. Um workload novo escuta em `80` e `443`.

**Console**

Para definir as portas no Azion Console:

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

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

2. **Abra o workload**

   Selecione o workload que atende a aplicação. O formulário de edição dele abre.

3. **Selecione as portas HTTP**

   Na seção **Protocol Settings**, selecione em **HTTP Ports** cada porta em que o workload escuta para HTTP.

4. **Selecione as portas HTTPS**

   Com **HTTPS support** ativado, selecione em **HTTPS Ports** cada porta em que o workload escuta para HTTPS.

5. **Salve o workload**

   Selecione **Save**.

Azion Console mostra "Your workload has been updated", e a seção **Protocol Settings** lista as portas que você selecionou.

**CLI**

Para definir as portas com a Azion CLI, salve um arquivo JSON com o ID do workload e o objeto `protocols.http` inteiro, aqui como `ports.json`. Este exemplo escuta em `80` e `8080` para HTTP e em `443` e `8443` para HTTPS:

```json
{
  "id": <workload-id>,
  "protocols": {
    "http": {
      "versions": ["http1", "http2"],
      "http_ports": [80, 8080],
      "https_ports": [443, 8443],
      "quic_ports": null
    }
  }
}
```

A lista `versions` deste arquivo deixa o HTTP/3 de fora. Para manter o HTTP/3, adicione `http3` a `versions` e uma porta HTTP/3 a `quic_ports`, como descreve [Configurações de workload](/pt-br/documentacao/plataforma/workloads/configuracoes/#protocolos-e-portas).

Atualize o workload com o arquivo:

```bash
azion update workload --file ports.json
```

O comando imprime o ID do workload que ele atualizou:

```text
Updated Workload with ID <workload-id>
```

Para confirmar a alteração, descreva o workload:

```bash
azion describe workload --workload-id <workload-id> --format json
```

Este trecho da saída mostra as portas em `protocols.http`:

```json
{
 "protocols": {
  "http": {
   "http_ports": [
    80,
    8080
   ],
   "https_ports": [
    443,
    8443
   ],
   "versions": [
    "http1",
    "http2"
   ]
  }
 },
 …
}
```

**API**

Para definir as portas com a API, envie uma requisição `PATCH` para o workload com o objeto `protocols.http` inteiro. Este exemplo escuta em `80` e `8080` para HTTP e em `443` e `8443` para HTTPS:

```bash
curl --request PATCH \
  --url https://api.azion.com/v4/workspace/workloads/<workload-id> \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{
  "protocols": {
    "http": {
      "versions": ["http1", "http2"],
      "http_ports": [80, 8080],
      "https_ports": [443, 8443],
      "quic_ports": null
    }
  }
}'
```

A API aceita a atualização, e o workload passa a listar as portas em `protocols.http`. A lista `versions` desta requisição deixa o HTTP/3 de fora. Para manter o HTTP/3, adicione `http3` a `versions` e uma porta HTTP/3 a `quic_ports`, como descreve [Configurações de workload](/pt-br/documentacao/plataforma/workloads/configuracoes/#protocolos-e-portas).

Duas recusas impedem a alteração. Uma porta HTTP fora dos quatro valores é recusada com `Invalid choices for multiple choices field: [80, 8008, 8080, 8880].` Uma lista `versions` que contém `http3` sem `http1` e `http2` é recusada com `Missing required choices for multiple choices field: ['http1', 'http2'].` Para cada recusa e a correção dela, consulte [Configurações de workload](/pt-br/documentacao/plataforma/workloads/configuracoes/#erros).

Uma alteração de workload leva vários minutos para chegar a toda a infraestrutura distribuída da Azion, e as requisições podem receber as portas antigas ou as novas nesse intervalo. Repita uma requisição até que as respostas coincidam.

---

## Defina a porta de origem no connector

A porta de origem pertence ao connector que uma regra da aplicação nomeia, não ao workload. Cada endereço de um connector carrega duas portas de origem: `http_port`, `80` por padrão, e `https_port`, `443` por padrão. Para uma origem que escuta em outra porta, defina essa porta no endereço ao criar ou editar o connector.

O `transport_policy` do connector decide se a Azion se conecta à origem por HTTP ou por HTTPS. Por exemplo, `force_https` faz toda conexão com a origem usar HTTPS, qualquer que seja o protocolo da requisição do usuário. Para cada política e o protocolo que ela usa, consulte [Configurações de connector](/pt-br/documentacao/plataforma/connectors/configuracoes/#opcoes-de-conexao).

Quando duas portas de entrega precisam de portas de origem diferentes, crie um connector por porta de origem. Depois, encaminhe cada porta de entrega para o connector dela com uma regra, como mostra Encaminhe uma porta personalizada para o connector dela.

---

## Encaminhe uma porta personalizada para o connector dela

Uma regra na aplicação pode enviar as requisições de uma porta de entrega para o connector de uma porta de origem. A regra roda na fase de requisição. O critério dela compara `${server_port}`, a porta do servidor que recebe a requisição, com a porta de entrega. O behavior dela, **Set Connector**, nomeia o connector. Para as variáveis e o comportamento, consulte [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine/).

Este exemplo envia as requisições que chegam na porta de entrega `8080` para um connector cujo endereço usa a porta de origem que você quer.

**Console**

Para criar a regra no Azion Console:

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

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

2. **Selecione a aba Rules Engine**

3. **Selecione + Rule**

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

   Em **General**, digite `route-port-8080` como **Name**.

5. **Selecione a fase de requisição**

   Em **Phase**, selecione *Request Phase*.

6. **Defina o critério**

   Em **Criteria**, selecione a variável `${server_port}` e o operador `is_equal`, e digite `8080` como argumento.

7. **Selecione o behavior Set Connector**

   Em **Behaviors**, selecione **Set Connector**.

8. **Selecione o connector**

   Em **Connector**, selecione o connector cujo endereço usa a porta de origem para `8080`.

9. **Selecione Create**

A regra aparece na aba **Rules Engine**, sob o título **Request**.

**CLI**

Para criar a regra com a Azion CLI, mantenha a regra em um arquivo: na linha de comando, o shell expandiria `${server_port}`. Salve este corpo como `rule.json` e substitua `<connector-id>` pelo ID do connector:

```json
{
  "name": "route-port-8080",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${server_port}",
        "conditional": "if",
        "operator": "is_equal",
        "argument": "8080"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_connector",
      "attributes": { "value": <connector-id> }
    }
  ]
}
```

Crie a regra na fase de requisição da sua aplicação. Substitua `<application-id>` pelo ID da sua aplicação:

```bash
azion create rules-engine --application-id <application-id> --phase request --file rule.json
```

O comando imprime o ID da regra que ele criou:

```text
Created Rules Engine with ID <rule-id>
```

**API**

Para criar a regra com a API, mantenha o corpo da requisição em um arquivo: na linha de comando, o shell expandiria `${server_port}`. Salve este corpo como `rule.json` e substitua `<connector-id>` pelo ID do connector:

```json
{
  "name": "route-port-8080",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${server_port}",
        "conditional": "if",
        "operator": "is_equal",
        "argument": "8080"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_connector",
      "attributes": { "value": <connector-id> }
    }
  ]
}
```

Envie uma requisição `POST` para as regras da fase de requisição da sua aplicação. Substitua `<application-id>` pelo ID da sua aplicação:

```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 @rule.json
```

A API responde `202`, com `state` definido como `pending`, e a resposta traz a regra armazenada com o `id` dela.

Assim que a regra se propaga, uma requisição que chega na porta de entrega `8080` alcança a sua origem na porta do connector que a regra nomeia. Para cada outra porta de entrega personalizada, crie mais uma regra com essa porta como argumento e o connector dela.

---

## Próximos passos

- [Configurações de workload](/pt-br/documentacao/plataforma/workloads/configuracoes.md): Consulte cada valor de porta, a porta HTTP/3 e as recusas do objeto protocols.
- [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine.md): Combine server\_port com outros critérios e reordene as regras de uma fase.
- [Connectors](/pt-br/documentacao/plataforma/connectors.md): Defina os endereços, as portas de origem e a política de protocolo de um connector.
- [Defina o conjunto de cifras TLS](/pt-br/documentacao/guias/seguranca-de-aplicacoes/tls-e-certificados/cifras.md): Escolha a versão mínima de TLS e o conjunto de cifras das portas HTTPS.
