# Azion CLI rules-engine

Os comandos `rules-engine` da Azion CLI criam, listam, descrevem, atualizam, ordenam e excluem as regras do [Rules Engine](/pt-br/documentacao/plataforma/applications/rules-engine/) de uma aplicação. Uma regra guarda critérios que uma requisição ou uma resposta precisa atender e os behaviors que ela aplica em seguida. Cada regra pertence a uma fase, `request` ou `response`, e cada comando recebe essa fase com `--phase`. As opções que todo comando aceita, como `--format`, `--out` e `-y`, estão em [Opções globais](/pt-br/documentacao/devtools/cli/globals/).

---

## Criar

`azion create rules-engine` cria uma regra em uma fase de uma aplicação, a partir de um arquivo JSON:

```bash
azion create rules-engine [flags]
```

| Flag               | Curta | Tipo   | Padrão | Descrição                                                                                                                                                |
| ------------------ | ----- | ------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--application-id` | —     | int    | —      | ID da aplicação que executa a regra.                                                                                                                     |
| `--file`           | —     | string | —      | **Obrigatório**. Caminho de um arquivo JSON com os atributos da regra. Use `-` para ler o JSON da entrada padrão. Sem ele, o comando pergunta o caminho. |
| `--phase`          | —     | string | —      | Fase da regra, `request` ou `response`.                                                                                                                  |

Um valor de `--phase` diferente de `request` ou `response` é recusado com `Error: Invalid phase value provided. The value must be 'request' or 'response'.`

Este arquivo descreve uma regra que entrega toda requisição cuja URI começa com `/static`:

```json
{
  "name": "my-rule",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${uri}",
        "operator": "starts_with",
        "conditional": "if",
        "argument": "/static"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "deliver"
    }
  ]
}
```

Este comando cria a regra na fase de requisição da aplicação com ID `1234567890`:

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

O comando imprime o ID da regra:

```text
Created Rules Engine with ID 123456
```

---

## Listar

`azion list rules-engine` lista as regras de uma fase de uma aplicação, 50 por página:

```bash
azion list rules-engine [flags]
```

| Flag               | Curta | Tipo   | Padrão      | Descrição                                                                                                                       |
| ------------------ | ----- | ------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `--application-id` | —     | int    | —           | ID da aplicação cujas regras você lista.                                                                                        |
| `--details`        | —     | —      | —           | Adiciona as colunas `ORDER`, `PHASE` e `ACTIVE` às colunas `ID` e `NAME`.                                                       |
| `--filter`         | —     | string | —           | Nome pelo qual filtrar a lista.                                                                                                 |
| `--order-by`       | —     | string | —           | Campo pelo qual ordenar a lista.                                                                                                |
| `--page`           | —     | int    | `1`         | Número da página a retornar.                                                                                                    |
| `--page-size`      | —     | int    | `50`        | Número de regras em cada página.                                                                                                |
| `--phase`          | —     | string | `"request"` | **Obrigatório**. Fase das regras a listar, `request` ou `response`. Sem ela, o comando pergunta a fase em vez de usar o padrão. |

Este comando lista as regras da fase de requisição da aplicação com ID `1234567890`:

```bash
azion list rules-engine --application-id 1234567890 --phase request
```

O comando imprime uma linha por regra:

```text
ID      NAME
123456  my-rule
123457  my-rule-2
```

---

## Descrever

`azion describe rules-engine` imprime os critérios, os behaviors e a posição de uma regra:

```bash
azion describe rules-engine [flags]
```

| Flag               | Curta | Tipo   | Padrão | Descrição                                                                        |
| ------------------ | ----- | ------ | ------ | -------------------------------------------------------------------------------- |
| `--application-id` | —     | int    | —      | ID da aplicação que executa a regra.                                             |
| `--phase`          | —     | string | —      | Fase da regra, `request` ou `response`. Na outra fase, a regra não é encontrada. |
| `--rule-id`        | —     | int    | —      | ID da regra a descrever.                                                         |

Uma regra descrita na fase errada falha com `Error: Failed to describe the rule in Rules Engine: The given ID or API's endpoint doesn't exist or isn't available.`

Este comando descreve a regra com ID `123456` na fase de requisição:

```bash
azion describe rules-engine --application-id 1234567890 --rule-id 123456 --phase request
```

O comando imprime os atributos da regra:

```text
Rules Engine ID:   123456
Name:              my-rule
Active:            true
Criteria:          [[{"argument":"/static","conditional":"if","operator":"starts_with","variable":"${uri}"}]]
Behaviours:        [{"type":"deliver"}]
Description:
Order:             0
```

Com `--format json`, o comando imprime o objeto completo: `active`, `behaviors`, `created_at`, `criteria`, `description`, `id`, `last_editor`, `last_modified`, `name` e `order`. Com `--out` e o caminho de um arquivo, o comando grava o mesmo JSON nesse arquivo, com ou sem `--format json`.

---

## Atualizar

`azion update rules-engine` altera os atributos de uma regra a partir de um arquivo JSON:

```bash
azion update rules-engine [flags]
```

| Flag               | Curta | Tipo   | Padrão | Descrição                                                                                                                                                 |
| ------------------ | ----- | ------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--application-id` | —     | int    | —      | **Obrigatório**. ID da aplicação que executa a regra.                                                                                                     |
| `--file`           | —     | string | —      | **Obrigatório**. Caminho de um arquivo JSON com os atributos a alterar. Use `-` para ler o JSON da entrada padrão. Sem ele, o comando pergunta o caminho. |
| `--phase`          | —     | string | —      | **Obrigatório**. Fase da regra, `request` ou `response`.                                                                                                  |
| `--rule-id`        | —     | int    | —      | **Obrigatório**. ID da regra a atualizar.                                                                                                                 |

A atualização é parcial. As chaves que o arquivo omite mantêm os seus valores, então um arquivo sem `criteria` ou `behaviors` mantém os que a regra já tem.

Este arquivo renomeia a regra, a desativa e adiciona uma descrição:

```json
{
  "name": "my-rule-updated",
  "active": false,
  "description": "Delivers static files"
}
```

Este comando aplica o arquivo à regra com ID `123456`:

```bash
azion update rules-engine --application-id 1234567890 --rule-id 123456 --phase request --file rule-update.json
```

O comando imprime o ID da regra atualizada:

```text
Updated Rules Engine with ID 123456
```

---

## Ordenar regras

`azion update rules-engine-order` define a ordem em que as regras de uma fase são executadas, a partir de uma lista de IDs de regras:

```bash
azion update rules-engine-order [flags]
```

| Flag               | Curta | Tipo   | Padrão | Descrição                                                                                  |
| ------------------ | ----- | ------ | ------ | ------------------------------------------------------------------------------------------ |
| `--application-id` | —     | int    | —      | ID da aplicação que executa as regras.                                                     |
| `--phase`          | —     | string | —      | Fase das regras, `request` ou `response`.                                                  |
| `--rule-ids`       | —     | string | —      | IDs das regras na ordem em que são executadas, separados por vírgulas, como `123,456,789`. |

A lista precisa nomear todas as regras. Com uma de duas regras omitida, o comando falha com este erro:

```text
Error: Failed to order the rules in Rules Engine: ["When ordering you should provide the order for all rules."]. Check your settings and try again. If the error persists, contact Azion support.
```

Este comando move a regra com ID `123457` para antes da regra com ID `123456`:

```bash
azion update rules-engine-order --application-id 1234567890 --phase request --rule-ids "123457,123456"
```

O comando confirma a nova ordem:

```text
Ordered Rules Engine of Application with ID 1234567890
```

Uma listagem com `--details` mostra em seguida a nova posição de cada regra na coluna `ORDER`, a partir de `0`:

```bash
azion list rules-engine --application-id 1234567890 --phase request --details
```

```text
ID      NAME       ORDER  PHASE    ACTIVE
123457  my-rule-2  0      request  0x2e0067998a09
123456  my-rule    1      request  0x2e0067998dc8
```

---

## Excluir

`azion delete rules-engine` exclui uma regra:

```bash
azion delete rules-engine [flags]
```

| Flag               | Curta | Tipo   | Padrão      | Descrição                                                                                                    |
| ------------------ | ----- | ------ | ----------- | ------------------------------------------------------------------------------------------------------------ |
| `--application-id` | —     | int    | —           | ID da aplicação que executa a regra.                                                                         |
| `--phase`          | —     | string | `"request"` | **Obrigatório**. Fase da regra, `request` ou `response`. Sem ela, o comando pergunta a fase, mesmo com `-y`. |
| `--rule-id`        | —     | int    | —           | ID da regra a excluir.                                                                                       |

Este comando exclui a regra com ID `123457` da fase de requisição:

```bash
azion delete rules-engine --application-id 1234567890 --phase request --rule-id 123457 -y
```

O comando confirma a exclusão:

```text
Rule Engine 123457 was successfully deleted
```

---

## Usar um arquivo JSON

`azion create rules-engine` e `azion update rules-engine` leem os atributos de uma regra apenas de um arquivo JSON, passado com `--file`. Use `-` no lugar do caminho para ler o JSON da entrada padrão. O arquivo recebe estas chaves:

| Chave         | Tipo    | Descrição                                                                                                                                              |
| ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name`        | string  | Nome da regra.                                                                                                                                         |
| `active`      | boolean | Ativa (`true`) ou desativa (`false`) a regra.                                                                                                          |
| `description` | string  | Descrição da regra.                                                                                                                                    |
| `criteria`    | array   | Grupos de condições. Cada condição é um objeto com `variable`, `operator`, `conditional` e `argument`, como `${uri}`, `starts_with`, `if` e `/static`. |
| `behaviors`   | array   | Behaviors que a regra aplica, cada um deles um objeto com um `type`, como `deliver`.                                                                   |

Na criação, o arquivo traz a regra inteira. Na atualização, o arquivo traz apenas as chaves a alterar, e a regra mantém todos os outros valores. O ID da regra, o ID da aplicação e a fase vão na linha de comando com as suas flags.

---

## Recursos relacionados

- [Opções globais](/pt-br/documentacao/devtools/cli/globals.md): As opções que todo comando aceita, como `--format`, `--out` e `-y`.
- [Rules Engine](/pt-br/documentacao/plataforma/applications/rules-engine.md): Os critérios, os behaviors e as fases que uma regra pode usar em uma aplicação.
- [Azion CLI application](/pt-br/documentacao/devtools/cli/recursos/application.md): Os comandos que criam e gerenciam a aplicação cujo ID todo comando de regra recebe.
- [Azion CLI firewall-rule](/pt-br/documentacao/devtools/cli/recursos/firewall-rule.md): Os comandos que gerenciam as regras de um firewall, que têm o seu próprio comando de ordenação.
