---
name: azion-instale-a-integracao-scheduled-blocking
description: >-
  Instale Scheduled Blocking pelo Azion Marketplace e execute-a em um firewall para controlar o acesso à sua application com base em um cronograma.
---

# Instale a integração Scheduled Blocking

Você instala a integração Scheduled Blocking pelo Azion Marketplace e a executa em um [Firewall](/pt-br/documentacao/plataforma/firewall/), pelo Azion Console. A integração controla o acesso à sua application com base em um cronograma: nos intervalos e nos dias da semana que você define, ela nega, descarta ou responde as requisições com uma resposta estática.

Cinco objetos precisam existir antes que uma requisição seja bloqueada: a function instalada, um firewall com o módulo **Functions**, uma function instance com o cronograma, uma regra do Rules Engine com o behavior **Run Function** e um deployment do workload vinculado ao firewall. Cada seção abaixo cria um deles.

---

## Pré-requisitos

- Uma conta Azion. Para entrar, consulte [Como acessar o Azion Console](/pt-br/documentacao/guias/plataforma/conta-e-billing/como-acessar-o-azion-console/).
- Uma application servida por um [workload](/pt-br/documentacao/plataforma/workloads/), cujo deployment você vincula ao firewall na última seção.
- A [Azion CLI](/pt-br/documentacao/devtools/cli/) instalada e autorizada, para a última seção.
- Ativar um produto ou um módulo pode gerar custos de uso. Para mais informações, consulte [Preços](/pt-br/documentacao/fundamentos/precos/).

---

## Instale a integração

A function é instalada uma vez por conta. Para instalá-la:

1. **Abra o Marketplace**

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

2. **Encontre a integração**

   Digite `Scheduled Blocking` no campo **Search on Marketplace** e selecione o card da integração. Navegar pelos cards e pelas categorias leva à mesma página.

3. **Selecione Install**

O card mostra `Successfully installed!` e `Latest version installed!`, e a function aparece na lista **Function** do drawer **Create Instance**.

---

## Crie o firewall

O firewall é onde a function é instanciada e onde fica a regra que a executa. Para criar um:

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

   Acesse [Azion Console](https://console.azion.com/) > **Firewalls** e crie um firewall.

2. **Nomeie o firewall**

   Na seção **General**, digite um **Name**. Por exemplo: `scheduled-blocking-firewall`.

3. **Ative o módulo Functions**

   Na seção **Modules**, ative o switch **Functions**.

4. **Salve o firewall**

O firewall mostra uma aba **Functions Instances** enquanto o módulo **Functions** estiver ativado. Para usar um firewall existente, ative o módulo **Functions** dele e salve-o. Para conhecer cada configuração deste formulário, consulte [Defina as configurações principais de um firewall](/pt-br/documentacao/guias/seguranca-de-aplicacoes/firewall-e-waf/firewall-definir-main-settings/).

---

## Crie a function instance

A instância guarda o cronograma e a ação que a function executa. Para criá-la:

1. **Abra a aba Functions Instances**

   Em **Firewalls**, selecione seu firewall e selecione a aba **Functions Instances**.

2. **Selecione + Function**

   Um firewall que não tem instância mostra a mesma ação como **Function Instance**. O drawer **Create Instance** abre.

3. **Nomeie a instância**

   Em **Name**, digite um nome. Por exemplo: `scheduled-blocking`.

4. **Selecione a function instalada**

   Em **Function**, selecione a function Scheduled Blocking. A lista contém apenas as functions que executam em um firewall.

5. **Digite os argumentos**

   Em **Arguments**, o editor vem preenchido com os argumentos padrão da integração em JSON. Defina seu cronograma, como a próxima seção descreve.

6. **Selecione Save**

A instância aparece na aba **Functions Instances**.

### Argumentos

Os argumentos são uma lista de entradas de cronograma. Cada entrada define uma ação, um intervalo e os dias da semana em que se aplica:

```json
{
  "schedule": [
    {
      "action": "deny",
      "execute_action_when": "in_interval",
      "interval": {
        "starts_at_utc": "00:00",
        "finishes_at_utc": "00:59"
      },
      "week_days": {
        "Sun": true,
        "Mon": true,
        "Tue": true,
        "Wed": true,
        "Thu": true,
        "Fri": false,
        "Sat": true
      }
    },
    {
      "action": "drop",
      "execute_action_when": "not_in_interval",
      "interval": {
        "starts_at_utc": "01:00",
        "finishes_at_utc": "20:00"
      },
      "week_days": {
        "Mon": true,
        "Tue": true
      }
    },
    {
      "action": "static_response",
      "execute_action_when": "in_interval",
      "static_response_data": {
        "status": 503,
        "message": "You can write a custom message here",
        "html": "<!-- Some HTML can go here -->"
      },
      "interval": {
        "starts_at_utc": "20:00",
        "finishes_at_utc": "23:59"
      },
      "week_days": {
        "Sun": true,
        "Sat": true
      }
    }
  ]
}
```

| Atributo                       | Tipo de dado            | Descrição                                                                                                                                                                                                                                                                         |
| ------------------------------ | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `action`                       | String                  | A ação que a function executa quando uma requisição corresponde aos critérios de disparo. `Deny` encerra a requisição com uma resposta HTTP 403 Forbidden. `Drop` encerra a requisição sem resposta ao cliente. `static_response` encerra a requisição com uma resposta estática. |
| `execute_action_when`          | String                  | `in_interval` executa a `action` quando a function é chamada durante o intervalo de tempo. `not_in_interval` executa a `action` quando a function é chamada fora do intervalo de tempo.                                                                                           |
| `interval`                     | Dicionário de strings   | O intervalo de tempo. Os valores usam o formato `HH:MM`, em um relógio de 24 horas. A function usa o fuso horário UTC.                                                                                                                                                            |
| `interval.starts_at_utc`       | String                  | O horário de início do intervalo.                                                                                                                                                                                                                                                 |
| `interval.finishes_at_utc`     | String                  | O horário de término do intervalo.                                                                                                                                                                                                                                                |
| `week_days`                    | Dicionário de booleanos | Os dias da semana em que a function executa. Cada chave é um dia em formato de três letras (`EEE`) que começa com letra maiúscula. A function ignora um dia inválido e lê um dia que não está no dicionário como `false`.                                                         |
| `static_response_data`         | Dicionário de strings   | A página de resposta estática que a function retorna quando a `action` é `static_response`.                                                                                                                                                                                       |
| `static_response_data.status`  | Número                  | O código de status da resposta estática.                                                                                                                                                                                                                                          |
| `static_response_data.message` | String                  | A mensagem personalizada na página de resposta estática.                                                                                                                                                                                                                          |
| `static_response_data.html`    | String                  | O HTML personalizado que a function entrega como resposta estática.                                                                                                                                                                                                               |

> **nota**
>
> Com a ação `static_response`, você define tanto o código de status da resposta quanto uma página HTML personalizada que a function entrega aos seus usuários.

---

## Crie a regra

A instância não bloqueia nada até que uma regra a execute. Uma regra do [Rules Engine para Firewall](/pt-br/documentacao/plataforma/firewall/rules-engine/) seleciona as requisições que chegam à instância, por meio de um behavior **Run Function**. Para criar a regra:

1. **Abra a aba Rules Engine**

   Em **Firewalls**, selecione seu firewall e selecione a aba **Rules Engine**.

2. **Selecione + Rule**

3. **Nomeie a regra**

   Em **Name**, digite um nome. Por exemplo: `Run Scheduled Blocking`.

4. **Defina o critério**

   Na seção **Criteria**, selecione os domínios que executam a integração. Por exemplo: if `Host` *matches* `yourdomain.com`.

5. **Adicione o behavior Run Function**

   Na seção **Behaviors**, selecione **Run Function** e selecione a instância pelo nome que você deu a ela.

6. **Selecione Save**

O firewall executa a instância em cada requisição ao domínio do critério.

---

## Vincule o firewall ao workload

O vínculo fica no deployment do workload, então crie um deployment que indique tanto a application quanto o firewall:

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

O comando imprime o id do novo deployment:

```text
Created Workload Deployment with ID 123456
```

As requisições ao domínio do workload chegam ao firewall, e a regra executa a instância de Scheduled Blocking em cada uma delas.

---

## Próximos passos

- [Integrações do Marketplace](/pt-br/documentacao/plataforma/marketplace/integracoes.md): Todas as integrações que o Azion Marketplace oferece e onde cada uma executa.
- [Rules Engine para Firewall](/pt-br/documentacao/plataforma/firewall/rules-engine.md): Todos os critérios e behaviors que uma regra de firewall aceita.
- [Atualize uma integração](/pt-br/documentacao/guias/desenvolvimento-de-aplicacoes/integracoes/atualizar-uma-integracao.md): Mova uma integração instalada para a versão mais recente.
