# Primeiros passos com Firewall

Este guia orienta você a negar a sua primeira requisição com um [firewall](/pt-br/documentacao/plataforma/firewall/).

- Crie um firewall para a aplicação que você já atende.
- Adicione uma regra que nega toda requisição para um caminho.
- Vincule o firewall ao [workload](/pt-br/documentacao/plataforma/workloads/) que atende a sua aplicação.
- Envie uma requisição para esse caminho e leia o `403` que ela retorna.

Quatro objetos transformam uma requisição em uma decisão, e cada um se liga ao seguinte:

1. O **firewall** guarda as regras. Ele fica ativo desde o momento em que você o cria.
2. A **regra** nesse firewall combina um critério com um comportamento. O critério seleciona requisições, e o comportamento decide o que acontece com elas. Neste guia, o critério seleciona todo caminho que começa com `/deny-test`, e o comportamento nega a requisição.
3. O **deployment** do workload que atende a sua aplicação nomeia esse firewall, ao lado da aplicação.
4. A **requisição** para o domínio do workload encontra a regra, e uma requisição negada nunca chega à sua aplicação.

Um firewall não inspeciona nada por conta própria. Enquanto o deployment de um workload não o nomear, nenhuma requisição chega às regras dele.

Web Application Firewall (WAF), Network Shield e Bot Manager são produtos habilitados em um firewall. Este guia não precisa de nenhum deles, porque Deny é nativo de todo firewall. Os primeiros passos de cada produto partem de um firewall vinculado a um workload, que é o que este guia deixa pronto para você.

---

Selecione a interface que você usa. Os pré-requisitos e cada etapa desta página seguem essa escolha.

## Pré-requisitos

- Uma conta Azion. Para criar uma, consulte [Criar uma conta](/pt-br/documentacao/fundamentos/criar-uma-conta/).
- Um workload que atende uma aplicação no domínio de workload dele. Para mais informações, consulte [Workloads](/pt-br/documentacao/plataforma/workloads/).

**Console**

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

**CLI**

- [Azion CLI](/pt-br/documentacao/devtools/cli/) instalada e autorizada.
- O ID do seu workload e o ID da aplicação que ele atende.

**API**

- Um personal token e o `curl`. Para criar um token, consulte [Como criar um personal token](/pt-br/documentacao/guias/plataforma/conta-e-billing/personal-tokens/).
- O ID do seu workload e o ID da aplicação que ele atende.

---

## Crie o firewall

Um firewall novo não tem regras, e ele começa ativo. A regra Deny que este guia adiciona não precisa de nenhum produto ativado, então as configurações padrão permanecem.

**Console**

Para criar o firewall no Azion Console:

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

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

2. **Inicie um firewall**

   Selecione **Firewall**. A página **Create Firewall** abre.

3. **Nomeie o firewall**

   Na seção **General**, informe um **Name**. Por exemplo: `storefront-firewall`.

4. **Deixe as outras seções como abrem**

   Uma regra Deny não precisa de nenhum interruptor em **Modules**. Em **Status**, **Active** continua ativado.

5. **Selecione Create**

Azion Console exibe a mensagem "Your Firewall has been created" e abre o firewall. As abas dele são **Main Settings**, **Functions Instances** e **Rules Engine**. **Functions Instances** aparece somente enquanto **Functions** está ativado.

**CLI**

Para criar o firewall pela Azion CLI:

```bash
azion create firewall --name "storefront-firewall" --active true
```

O comando imprime o ID do firewall novo:

```text
Created Firewall with ID 12352
```

O firewall fica ativo, com Functions e Network Shield ativados e WAF desativado. Anote o ID. A regra e o vínculo com o seu workload o passam como `--firewall-id`.

**API**

Para criar o firewall pela API, envie uma requisição `POST` para o endpoint de firewalls. Substitua `[TOKEN VALUE]` pelo seu personal token:

```bash
curl --request POST \
  --url https://api.azion.com/v4/workspace/firewalls \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data '{"name": "storefront-firewall"}'
```

Este trecho da resposta mostra o firewall novo e as configurações com que ele começa:

```json
{
  "state": "pending",
  "data": {
    "id": 12353,
    "name": "storefront-firewall",
    "modules": {
      "ddos_protection": { "enabled": true },
      "functions": { "enabled": true },
      "network_protection": { "enabled": true },
      "waf": { "enabled": false }
    },
    "debug": false,
    "active": true,
    …
    "product_version": "2.0",
    …
    "version": 0
  }
}
```

O firewall fica ativo, e `waf` é a única entrada de `modules` que começa desativada. Anote o `id`. A regra e o vínculo com o seu workload o passam como `<firewall-id>`.

---

## Adicione uma regra que nega um caminho

Uma regra do [Rules Engine para Firewall](/pt-br/documentacao/plataforma/firewall/rules-engine/) combina critérios com comportamentos. A regra desta etapa carrega um critério, uma URI de requisição que começa com `/deny-test`, e um comportamento, Deny. Deny recusa a requisição com `403 Forbidden`, e ele não precisa de nenhum produto ativado.

O critério corresponde a todo caminho que começa com `/deny-test`, então `/deny-test/page` também corresponde. Para mais informações, consulte [Deny (403 Forbidden)](/pt-br/documentacao/plataforma/firewall/rules-engine/#deny-403-forbidden).

**Console**

Para adicionar a regra no Azion Console:

1. **Abra o firewall**

   Acesse [Azion Console](https://console.azion.com/) > **Secure** > **Firewalls** e selecione o firewall que você criou.

2. **Selecione a aba Rules Engine**

3. **Inicie uma regra**

   Selecione **Rule**. O drawer **Create Rule** abre.

4. **Nomeie a regra**

   Na seção **General**, informe um **Name**. Por exemplo: `Deny the test path`.

5. **Defina o critério**

   Na seção **Criteria**, o primeiro critério abre com *Request Uri* e *starts with*. Informe `/deny-test` como argumento dele.

6. **Selecione o comportamento Deny**

   Na seção **Behaviors**, selecione *Deny (403 Forbidden)*.

7. **Selecione Save**

Azion Console exibe a mensagem "Rule successfully created". A regra aparece na lista **Rules Engine** com o status *Active*.

**CLI**

`azion create firewall-rule` lê a regra inteira de um arquivo JSON. `criteria` é uma lista de grupos, e o primeiro critério de um grupo carrega a condicional `if`. Salve esta regra como `rule.json`:

```json
{
  "name": "Deny the test path",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${request_uri}",
        "conditional": "if",
        "operator": "starts_with",
        "argument": "/deny-test"
      }
    ]
  ],
  "behaviors": [
    { "type": "deny" }
  ]
}
```

Crie a regra. Substitua `<firewall-id>` pelo ID do seu firewall:

```bash
azion create firewall-rule --firewall-id <firewall-id> --file rule.json
```

O comando imprime o ID da regra nova:

```text
Created Firewall Rule with ID 123460
```

A regra fica ativa no firewall.

**API**

O corpo da requisição é a própria regra. `criteria` é uma lista de grupos, e o primeiro critério de um grupo carrega a condicional `if`. Salve esta regra como `rule.json`:

```json
{
  "name": "Deny the test path",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${request_uri}",
        "conditional": "if",
        "operator": "starts_with",
        "argument": "/deny-test"
      }
    ]
  ],
  "behaviors": [
    { "type": "deny" }
  ]
}
```

Envie uma requisição `POST` para as regras do seu firewall. Substitua `<firewall-id>` pelo ID do seu firewall:

```bash
curl --request POST \
  --url https://api.azion.com/v4/workspace/firewalls/<firewall-id>/request_rules \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data @rule.json
```

Este trecho da resposta mostra o `id` da regra nova e a `order` dela entre as regras do firewall:

```json
{
  "state": "pending",
  "data": {
    "id": 123459,
    …
    "behaviors": [{ "type": "deny" }],
    "description": "",
    "order": 0
  }
}
```

A API atribui `order` na ordem de criação, começando em `0`. A regra fica ativa no firewall.

---

## Vincule o firewall ao seu workload

Um firewall não tem domínio próprio. O workload carrega o domínio. O deployment dele guarda exatamente três configurações: a aplicação, o firewall e a custom page. Nomeie a aplicação que o workload atende hoje, e a custom page dele se ele usar uma, ao lado do seu firewall. Enquanto o deployment não nomear o seu firewall, a regra Deny não corresponde a nenhuma requisição.

**Console**

Para vincular o firewall no Azion Console:

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

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

2. **Abra o seu workload**

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

3. **Selecione o firewall**

   No campo **Firewall** de **Deployment Settings**, selecione o firewall que você criou. **Application** e **Custom Page** mantêm o que o workload atende hoje.

4. **Selecione Save**

O deployment do workload nomeia o seu firewall, ao lado da aplicação e da custom page dele.

**CLI**

Para vincular o firewall pela Azion CLI, crie um deployment que nomeia o seu firewall e a aplicação que o workload atende hoje. Substitua os três IDs:

```bash
azion create workload-deployment --workload-id <workload-id> \
  --name storefront-deployment --application-id <application-id> \
  --firewall-id <firewall-id> --strategy-type default --active true --current true
```

O comando imprime o ID do deployment novo:

```text
Created Workload Deployment with ID 123462
```

`--current true` faz dele o deployment atual do workload, que nomeia a sua aplicação e o seu firewall. Se o workload usa uma custom page, adicione `--custom-page <custom-page-id>` ao comando.

**API**

Para vincular o firewall pela API, envie uma requisição `POST` para os deployments do seu workload. O firewall vai em `strategy.attributes.firewall`, ao lado da aplicação que o workload atende hoje. Se o workload usa uma custom page, nomeie-a também em `custom_page`. Substitua os três IDs:

```bash
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": "storefront-deployment",
  "current": true,
  "active": true,
  "strategy": {
    "type": "default",
    "attributes": {
      "application": <application-id>,
      "firewall": <firewall-id>
    }
  }
}'
```

A resposta retorna o deployment. O `strategy.attributes` dele guarda a aplicação, o firewall e `custom_page`, que é `null` quando o workload não usa custom page:

```json
{
  "state": "pending",
  "data": {
    "id": 123461,
    "name": "storefront-deployment",
    "current": true,
    "active": true,
    "strategy": {
      "type": "default",
      "attributes": {
        "application": <application-id>,
        "firewall": <firewall-id>,
        "custom_page": null
      }
    },
    "last_editor": "user@example.com",
    "last_modified": "2026-01-01T12:00:00.000000Z",
    "created_at": "2026-01-01T12:00:00.000000Z"
  }
}
```

O deployment atual do workload nomeia a sua aplicação e o seu firewall.

---

## Confirme que o caminho responde 403

A verificação é a mesma, qualquer que seja a interface que criou o firewall. O seu workload responde no domínio de workload dele, no formato `<id>.map.azionedge.net`, escrito nesta etapa como `<your-workload-domain>`.

Um workload recém-vinculado a um firewall pode levar vários minutos para aplicar a primeira regra, e nenhuma duração é garantida. Enquanto o vínculo se propaga, as respostas à mesma requisição alternam entre a resposta anterior e a nova. Até lá, o caminho ainda chega à sua aplicação. Envie a requisição de novo até ela responder `403`. Para mais informações, consulte [Propagação](/pt-br/documentacao/plataforma/firewall/como-funciona/).

Envie uma requisição para o caminho negado:

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

O firewall a recusa com `403`:

```text
HTTP/2 403
server: nginx
date: Thu, 01 Jan 2026 12:00:00 GMT
content-type: text/html; charset=utf-8
x-content-type-options: nosniff
x-azion-request-id: 0123456789abcdef0123456789abcdef
x-azion-edge-location: <edge-location>
alt-svc: h3=":443"; ma=86400
```

A resposta também carrega um header `content-security-policy` longo, omitido deste trecho. O corpo é a página de erro padrão da Azion, com o título Forbidden, e ela lista o seu endereço IP e o ID da requisição. Nenhum header nomeia o firewall ou a regra que recusou a requisição.

Requisições para qualquer outro caminho não correspondem à regra, e a sua aplicação as responde como antes. O seu firewall nega toda requisição cujo caminho começa com `/deny-test`.

---

## Próximos passos

- [Primeiros passos com WAF](/pt-br/documentacao/plataforma/firewall/waf/primeiros-passos.md): Crie um rule set de WAF, aplique-o com um comportamento Set WAF e veja uma requisição com forma de injection ser recusada.
- [Primeiros passos com Network Shield](/pt-br/documentacao/plataforma/firewall/network-shield/primeiros-passos.md): Coloque o seu próprio endereço IP em uma network list e negue essa lista em um caminho de teste.
- [Primeiros passos com Bot Manager](/pt-br/documentacao/plataforma/firewall/bot-manager/primeiros-passos.md): Execute Bot Manager Lite a partir de uma regra Run Function e leia o score que ele dá a uma requisição.
- [Rules Engine para Firewall](/pt-br/documentacao/plataforma/firewall/rules-engine.md): Cada critério, operador e comportamento que uma regra de firewall aceita, com o corpo da regra para a API e a CLI.
- [Como Firewall funciona](/pt-br/documentacao/plataforma/firewall/como-funciona.md): O caminho que uma requisição percorre por um firewall, a ordem em que as regras dele são executadas e como uma mudança se propaga.
- [Limites de Firewall](/pt-br/documentacao/plataforma/firewall/limites.md): Os limites de regras e de instâncias de função por firewall, e os limites que cada produto acrescenta.
