---
name: azion-execute-uma-funcao-em-um-caminho-e-reverta-o
description: >-
  Execute uma instância de função em um caminho e um método com uma regra Run Function, e reverta o caminho desativando a regra.
---

# Execute uma função em um caminho e reverta-o

Você executa uma função em um caminho e um método de uma aplicação com uma regra *Run Function*, e reverte o caminho desativando essa regra, pelo Azion Console, pela API ou pela Azion CLI. Para criar a função e a sua instância antes, consulte [Primeiros passos com Functions](/pt-br/documentacao/plataforma/functions/primeiros-passos/).

Uma regra para um caminho move esse caminho para a função, enquanto todos os outros caminhos mantêm a regra que os atendia antes. O switch **Active** da regra, o campo `active` na API, é a reversão: uma regra desativada não é executada, e o caminho volta para a regra anterior sem mudança em nenhuma outra regra.

```mermaid
%%{init: {"layout": "dagre", "themeVariables": {"fontSize": "13px"}, "flowchart": {"nodeSpacing": 12, "rankSpacing": 12, "padding": 6, "wrappingWidth": 70, "minNodeWidth": 40, "useMaxWidth": true}}}%%
flowchart TD
  Req["Uma requisição chega à aplicação"] --> R1["Regra 1: todos os caminhos, Set Connector"]
  R1 --> R2{"Regra 2, se ativa: é GET /api/items?"}
  R2 -->|"sim"| Fn["Run Function: a instância responde"]
  R2 -->|"não, ou a regra está desativada"| Origin["A origem responde pelo connector"]
```

1. Toda requisição corresponde à primeira regra, que a envia à origem por um connector.
2. Uma requisição `GET` para `/api/items` também corresponde à segunda regra enquanto ela está ativa, e a instância da função a responde.
3. Qualquer outra requisição, e toda requisição depois que a segunda regra é desativada, é respondida pela origem.

---

## Pré-requisitos

- Uma aplicação servida por um workload, com uma regra que envia todas as requisições a um connector. Para criá-los, consulte [Primeiros passos com Applications](/pt-br/documentacao/plataforma/applications/primeiros-passos/).
- Application Accelerator na aplicação, que o behavior *Run Function* exige. Para ativá-lo, consulte [Ative Application Accelerator](/pt-br/documentacao/guias/performance-e-confiabilidade/cache-e-purge/cache-settings/#ative-application-accelerator).
- Uma instância de função na aplicação. Para criar a função e a instância, consulte [Primeiros passos com Functions](/pt-br/documentacao/plataforma/functions/primeiros-passos/), que cria as duas.
- Um [personal token](/pt-br/documentacao/guias/plataforma/conta-e-billing/personal-tokens/), para os procedimentos pela API.
- A [Azion CLI](/pt-br/documentacao/devtools/cli/) instalada e autorizada, para os procedimentos pela CLI.

Os exemplos executam a instância `<function-instance-id>` em `GET /api/items` da aplicação `<application-id>`, no domínio `www.example.com`. Substitua-os pelos seus valores.

---

## Crie a regra para o caminho e o método

A regra carrega dois grupos de critérios, um para o caminho e outro para o método. Os grupos se unem com `and`, então uma requisição só corresponde quando os dois correspondem, e um `POST` para o mesmo caminho continua chegando à origem. Nem `${uri}` nem `${request_method}` exigem um Produto na aplicação.

Uma regra nova é criada no fim da Request Phase, depois da regra que envia todos os caminhos ao connector. Uma regra posicionada depois de outra que encerra o processamento, como *Deliver* ou *Finish Request Phase*, nunca é executada para as requisições que essa outra regra corresponde.

**Console**

Para criar a regra no Azion Console:

1. **Vá para a aba Rules Engine**

   Acesse [Azion Console](https://console.azion.com/) > **Applications** > **sua aplicação** e vá para a aba **Rules Engine**.

2. **Selecione + Rule**

3. **Nomeie a regra**

   Insira um nome que identifique o caminho. Por exemplo: `function - GET /api/items`.

4. **Selecione Request Phase**

5. **Corresponda ao caminho**

   Na seção **Criteria**, defina o critério como `${uri}` *is equal* `/api/items`.

6. **Corresponda ao método**

   Adicione um segundo grupo de critérios com um critério: `${request_method}` *is equal* `GET`.

7. **Na seção Behaviors, selecione Run Function**

8. **Selecione a instância da função**

9. **Selecione Save**

A regra aparece na lista **Request**, depois da regra que envia todos os caminhos ao connector.

**API**

Os critérios carregam `${uri}`, que um shell expande, então o corpo é enviado de um arquivo. Para criar a regra:

1. **Escreva a regra em um arquivo**

   Salve o conteúdo a seguir como `rule.json`, com o ID da instância da função em `attributes.value`:

   ```json
   {
     "name": "function - GET /api/items",
     "active": true,
     "criteria": [
       [
         { "variable": "${uri}", "conditional": "if", "operator": "is_equal", "argument": "/api/items" }
       ],
       [
         { "variable": "${request_method}", "conditional": "if", "operator": "is_equal", "argument": "GET" }
       ]
     ],
     "behaviors": [{ "type": "run_function", "attributes": { "value": <function-instance-id> } }]
   }
   ```

2. **Envie a requisição de criação**

   ```bash
   curl --request POST \
     --url https://api.azion.com/v4/workspace/applications/<application-id>/request_rules \
     --header 'Accept: application/json' \
     --header 'Authorization: Token <personal-token>' \
     --header 'Content-Type: application/json' \
     --data @rule.json
   ```

A API responde `202` com `"state": "pending"` e a regra como foi armazenada, com o seu `id` e a `order` que ela ocupa na fase. Guarde o `id` para a reversão.

**CLI**

A CLI lê a regra de um arquivo JSON. Para criar a regra:

1. **Escreva a regra em um arquivo**

   Salve o conteúdo a seguir como `rule.json`, com o ID da instância da função em `attributes.value`:

   ```json
   {
     "name": "function - GET /api/items",
     "active": true,
     "criteria": [
       [
         { "variable": "${uri}", "conditional": "if", "operator": "is_equal", "argument": "/api/items" }
       ],
       [
         { "variable": "${request_method}", "conditional": "if", "operator": "is_equal", "argument": "GET" }
       ]
     ],
     "behaviors": [{ "type": "run_function", "attributes": { "value": <function-instance-id> } }]
   }
   ```

2. **Crie a regra**

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

   O comando imprime o ID da regra:

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

Guarde o ID da regra para a reversão.

`GET /api/items` executa a instância da função, e todas as outras requisições continuam chegando à origem. Uma regra nova leva alguns minutos para chegar a todos os data centers. Quando *Run Function* não aparece na lista de behaviors, a aplicação precisa de Application Accelerator.

---

## Reverta o caminho

Desativar a regra mantém os seus critérios e o seu behavior, então ativá-la de novo move o caminho de volta para a função. A atualização muda somente `active`.

**Console**

Para desativar a regra no Azion Console:

1. **Vá para a aba Rules Engine**

   Acesse [Azion Console](https://console.azion.com/) > **Applications** > **sua aplicação** e vá para a aba **Rules Engine**.

2. **Selecione a regra**

   Na lista **Request**, selecione `function - GET /api/items`.

3. **Desative o switch Active**

   Na seção **Status**, desative **Active**.

4. **Selecione Save**

**API**

Para desativar a regra, envie uma requisição `PATCH` com `active` definido como `false`. Substitua `<rule-id>` pelo `id` que a criação retornou:

```bash
curl --request PATCH \
  --url https://api.azion.com/v4/workspace/applications/<application-id>/request_rules/<rule-id> \
  --header 'Accept: application/json' \
  --header 'Authorization: Token <personal-token>' \
  --header 'Content-Type: application/json' \
  --data '{ "active": false }'
```

A regra mantém os seus critérios e o seu behavior, com `active` definido como `false`. Para mover o caminho para a função de novo, envie a mesma requisição com `"active": true`.

**CLI**

A atualização é parcial, então um arquivo só com `active` mantém o restante da regra. Para desativar a regra:

1. **Escreva a mudança em um arquivo**

   Salve o conteúdo a seguir como `rollback.json`:

   ```json
   { "active": false }
   ```

2. **Atualize a regra**

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

   O comando imprime o ID da regra:

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

Para mover o caminho para a função de novo, execute o mesmo comando com `{ "active": true }` no arquivo.

`GET /api/items` volta a chegar à origem quando a mudança se propaga. Durante a propagação, alguns data centers ainda executam a função, então as duas versões respondem por alguns minutos.

---

## Verifique qual versão responde

O **Upstream Addr** de um registro de requisição indica quem a respondeu, e `127.0.0.1:1666` indica o Azion Runtime. Para verificar o caminho no Real-Time Events:

1. **Abra o Real-Time Events**

   Acesse [Azion Console](https://console.azion.com/) > **Real-Time Events**.

2. **Selecione a fonte de dados HTTP Requests**

3. **Filtre pelo caminho**

   Em **Filter by**, insira `request_uri like '/api/items%'`.

4. **Leia o Upstream Addr de cada registro**

Enquanto a regra está ativa, os registros `GET` carregam `127.0.0.1:1666`. Depois da reversão, os registros novos carregam o endereço e a porta da origem. Para a sintaxe do filtro, consulte [Filtrar eventos](/pt-br/documentacao/guias/plataforma/observabilidade/adicionar-filtros-events/).

---

## Próximos passos

- [Como Functions funciona](/pt-br/documentacao/plataforma/functions/como-funciona.md): Como uma função, a sua instância e a regra que a executa se combinam em cada requisição.
- [Rules Engine para Applications](/pt-br/documentacao/plataforma/applications/rules-engine.md#run-function): O behavior Run Function, os campos da regra e a API que atualiza uma regra.
- [Azion CLI rules-engine](/pt-br/documentacao/devtools/cli/recursos/rules-engine.md): Todas as flags dos comandos que criam, atualizam e ordenam regras.
- [Modernizar uma aplicação monolítica sem reescrevê-la](/pt-br/documentacao/casos-de-uso/construir-e-executar-aplicacoes/modernizar-uma-aplicacao-monolitica-sem-reescreve-la.md): Mova uma rota de um monolito por vez para uma função, e reverta cada uma.
- [Criar agentes de IA](/pt-br/documentacao/casos-de-uso/construir-e-executar-workloads-de-ai/criar-agentes-de-ia.md): Execute a função do agente no caminho da API, com uma regra que você desativa para revertê-la.
