---
name: azion-assine-requisicoes-de-origem-com-hmac
description: >-
  Sirva um bucket privado compatível com S3 por meio de um connector que assina cada requisição de origem com credenciais HMAC.
---

# Assine requisições de origem com HMAC

Você pode servir os objetos de um bucket privado por meio de um [connector](/pt-br/documentacao/plataforma/connectors/) que assina cada requisição ao endpoint compatível com S3 do bucket, pelo Azion Console, pela Azion CLI ou pela API. A assinatura é HMAC, uma configuração de [Origin Shield](/pt-br/documentacao/plataforma/connectors/#origin-shield) em um connector do tipo `http`. Para aceitar na sua origem apenas os endereços da Azion, consulte [Libere os IPs da Azion na sua origem](/pt-br/documentacao/suporte/obter-ranges-ip-azion/).

Os exemplos usam o endpoint de Azion Object Storage `s3.us-east-005.azionstorage.net` com a região `us-east-005`, e um objeto chamado `hello.txt` na raiz do bucket. Substitua-os pelo endpoint, pela região e por um objeto do seu provedor.

---

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

## Pré-requisitos

- Uma aplicação servida por um workload, e o workload domain ou um domínio seu ao qual o workload responde. Para criá-los, consulte [Primeiros passos com Applications](/pt-br/documentacao/plataforma/applications/primeiros-passos/).
- Um bucket privado em um endpoint compatível com S3, e uma access key e uma secret key que podem ler o bucket. Para as credenciais de Azion Object Storage, consulte [Compatibilidade com S3](/pt-br/documentacao/plataforma/object-storage/compatibilidade-s3/).
- `curl`, para verificar o resultado.

**Console**

- Acesso ao [Azion Console](https://console.azion.com/).

**CLI**

- A [Azion CLI](/pt-br/documentacao/devtools/cli/), instalada e autorizada.
- O ID da sua aplicação.

**API**

- Um personal token e o ID da sua aplicação.

---

## Crie o connector de assinatura

O connector alcança o endpoint por HTTPS e envia o próprio nome do endpoint como header `Host`. O caminho dele, `/<bucket-name>`, vai na frente de cada caminho de requisição, então uma requisição para `/hello.txt` chega ao endpoint como `/<bucket-name>/hello.txt`. Com Origin Shield ativado, HMAC assina cada uma dessas requisições com as suas credenciais, usando o tipo `aws4_hmac_sha256`.

**Console**

Para criar o connector no Azion Console:

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

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

2. **Inicie um connector**

   A página **Create Connector** abre.

3. **Nomeie o connector**

   Em **General**, informe `my-bucket-connector` como **Name**.

4. **Selecione o tipo HTTP**

   Em **Connector Type**, selecione *HTTP*.

5. **Informe o endpoint como endereço**

   Em **Address Management**, informe `s3.us-east-005.azionstorage.net` em **Address**, sem protocolo e sem porta.

6. **Envie o nome do endpoint no header Host**

   Em **Host**, informe `s3.us-east-005.azionstorage.net`.

7. **Informe o bucket como caminho**

   Em **Path**, informe `/` seguido do nome do seu bucket.

8. **Conecte somente por HTTPS**

   Em **Transport Protocol Policy**, selecione *Force HTTPS*.

9. **Ative Origin Shield**

   Em **Modules**, ative **Origin Shield**.

10. **Ative HMAC**

    Ative o switch da seção **HMAC**. **Type** mostra `aws4_hmac_sha256` e não pode ser alterado.

11. **Informe a região e o serviço**

    Em **Region**, informe `us-east-005`. Em **Service**, informe `s3`.

12. **Informe as credenciais**

    Em **Access Key** e **Secret Key**, informe as credenciais que podem ler o bucket.

13. **Selecione Create**

O connector existe na sua conta e assina cada requisição que envia ao endpoint.

**CLI**

A CLI cria um connector a partir de um arquivo JSON. Salve este corpo como `connector.json` e substitua `<bucket-name>`, `<access-key>` e `<secret-key>` pelos seus valores:

```json
{
  "name": "my-bucket-connector",
  "type": "http",
  "attributes": {
    "addresses": [{ "address": "s3.us-east-005.azionstorage.net" }],
    "connection_options": {
      "transport_policy": "force_https",
      "host": "s3.us-east-005.azionstorage.net",
      "path_prefix": "/<bucket-name>"
    },
    "modules": {
      "origin_shield": {
        "enabled": true,
        "config": {
          "origin_ip_acl": { "enabled": false },
          "hmac": {
            "enabled": true,
            "config": {
              "type": "aws4_hmac_sha256",
              "attributes": {
                "region": "us-east-005",
                "service": "s3",
                "access_key": "<access-key>",
                "secret_key": "<secret-key>"
              }
            }
          }
        }
      }
    }
  }
}
```

O arquivo contém a sua secret key. Exclua-o depois de criar o connector.

Para criar o connector com a Azion CLI, passe o arquivo e o tipo. O comando exige `--type` mesmo que o arquivo nomeie o tipo:

```bash
azion create connector --type http --file connector.json
```

A saída traz o ID do novo connector:

```text
Created Connector with ID <connector-id>
```

Anote o ID: a próxima tarefa o passa como `<connector-id>`. O connector existe na sua conta e assina cada requisição que envia ao endpoint.

**API**

A API recebe o connector como um corpo JSON. Salve este corpo como `connector.json` e substitua `<bucket-name>`, `<access-key>` e `<secret-key>` pelos seus valores:

```json
{
  "name": "my-bucket-connector",
  "type": "http",
  "attributes": {
    "addresses": [{ "address": "s3.us-east-005.azionstorage.net" }],
    "connection_options": {
      "transport_policy": "force_https",
      "host": "s3.us-east-005.azionstorage.net",
      "path_prefix": "/<bucket-name>"
    },
    "modules": {
      "origin_shield": {
        "enabled": true,
        "config": {
          "origin_ip_acl": { "enabled": false },
          "hmac": {
            "enabled": true,
            "config": {
              "type": "aws4_hmac_sha256",
              "attributes": {
                "region": "us-east-005",
                "service": "s3",
                "access_key": "<access-key>",
                "secret_key": "<secret-key>"
              }
            }
          }
        }
      }
    }
  }
}
```

O arquivo contém a sua secret key. Exclua-o depois de criar o connector.

Para criar o connector com a API, envie uma requisição `POST` ao endpoint de connectors. Substitua `[TOKEN VALUE]` pelo seu personal token:

```bash
curl --request POST \
  --url https://api.azion.com/v4/workspace/connectors \
  --header 'Accept: application/json' \
  --header 'Authorization: Token [TOKEN VALUE]' \
  --header 'Content-Type: application/json' \
  --data @connector.json
```

A API responde `202` com `"state": "pending"` e o connector armazenado, cujo `id` a próxima tarefa passa como `<connector-id>`. Na resposta, `attributes.modules.origin_shield.config.hmac.enabled` contém `true`. Com `hmac.enabled` definido como `true` e sem `hmac.config`, a API recusa a requisição com `400` e `28014` `Module configuration must be provided when 'enabled' is true.`

Desativar HMAC depois remove as credenciais armazenadas. Para ativá-lo de novo, informe outra vez a access key e a secret key.

---

## Envie requisições ao connector

Um connector não recebe tráfego até que uma regra na sua aplicação o nomeie. Esta regra corresponde a requisições para `/hello.txt` na fase de requisição, e o behavior *Set Connector* dela as envia ao connector de assinatura. Substitua `/hello.txt` pelo caminho do seu objeto. Se a sua aplicação já tem uma regra que corresponde a todos os caminhos, mantenha esta regra depois dela, para que esta regra decida o connector do objeto. Para mais informações, consulte [Set Connector](/pt-br/documentacao/plataforma/applications/rules-engine/#set-connector).

**Console**

Para criar a regra no Azion Console:

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

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

2. **Selecione a aba Rules Engine**

3. **Selecione + Rule**

4. **Nomeie a regra**

   Em **General**, informe `send-object-to-bucket` 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 `${uri}` e o operador `starts_with`, e informe `/hello.txt` como argumento.

7. **Selecione o behavior Set Connector**

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

8. **Selecione o connector de assinatura**

   Em **Connector**, selecione `my-bucket-connector`.

9. **Selecione Save**

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

**CLI**

Mantenha a regra em um arquivo: em uma linha de comando, o shell expandiria `${uri}`. Salve este corpo como `rule.json` e substitua `<connector-id>` pelo ID do connector de assinatura:

```json
{
  "name": "send-object-to-bucket",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${uri}",
        "conditional": "if",
        "operator": "starts_with",
        "argument": "/hello.txt"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_connector",
      "attributes": { "value": <connector-id> }
    }
  ]
}
```

Para criar a regra com a Azion CLI, execute este comando. Substitua `<application-id>` pelo ID da sua aplicação:

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

A saída traz o ID da nova regra:

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

A regra está ativa na sua aplicação e envia as requisições para `/hello.txt` ao connector de assinatura.

**API**

Mantenha o corpo da requisição em um arquivo: em uma linha de comando, o shell expandiria `${uri}`. Salve este corpo como `rule.json` e substitua `<connector-id>` pelo ID do connector de assinatura:

```json
{
  "name": "send-object-to-bucket",
  "active": true,
  "criteria": [
    [
      {
        "variable": "${uri}",
        "conditional": "if",
        "operator": "starts_with",
        "argument": "/hello.txt"
      }
    ]
  ],
  "behaviors": [
    {
      "type": "set_connector",
      "attributes": { "value": <connector-id> }
    }
  ]
}
```

Para criar a regra com a API, envie uma requisição `POST` às 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": "pending"`, e a resposta retorna a regra armazenada com o `id` e a `order` dela. A regra está ativa na sua aplicação e envia as requisições para `/hello.txt` ao connector de assinatura.

---

## Verifique a requisição assinada

A verificação é a mesma em qualquer interface que você usou. Um novo connector e uma nova regra levam vários minutos para chegar à infraestrutura distribuída da Azion, e os data centers os aplicam em momentos diferentes. Até lá, uma requisição ainda pode chegar ao connector de outra regra. Repita a requisição até que o endpoint responda. Para mais informações, consulte [Propagação](/pt-br/documentacao/plataforma/connectors/como-funciona/#propagacao).

Solicite o objeto pelo seu workload. Substitua `<workload-domain>` pelo workload domain ou pelo seu próprio domínio:

```bash
curl -s -D - https://<workload-domain>/hello.txt
```

O endpoint responde `200` com o conteúdo do objeto. Estes headers identificam o endpoint de storage como a origem da resposta:

```text
HTTP/2 200
…
content-type: text/plain
…
server: azion webserver
x-amz-request-id: …
…
```

Para comparar, solicite o mesmo objeto diretamente ao endpoint, sem assinatura:

```bash
curl -s -D - https://s3.us-east-005.azionstorage.net/<bucket-name>/hello.txt
```

O endpoint recusa a requisição sem assinatura com `401`, não `403`:

```text
HTTP/1.1 401
Server: azion webserver
…
<Error>
    <Code>UnauthorizedAccess</Code>
    <Message>bucket is not authorized: <bucket-name></Message>
</Error>
```

O workload retorna o mesmo `401` quando HMAC está desativado no connector. O connector assina cada requisição ao bucket privado, e o seu workload serve o objeto. Para as correções, consulte [O endpoint de storage retorna 401 UnauthorizedAccess](/pt-br/documentacao/plataforma/connectors/solucao-de-problemas/#o-endpoint-de-storage-retorna-401-unauthorizedaccess).

---

## Próximos passos

- [Origin IP ACL e HMAC](/pt-br/documentacao/plataforma/connectors/origin-shield/origin-ip-acl-e-hmac.md): Como Origin Shield protege a origem com uma allowlist dos endereços da Azion e com assinatura HMAC.
- [Configurações de connector](/pt-br/documentacao/plataforma/connectors/configuracoes.md#origin-shield): Cada campo de Origin Shield e de HMAC, o nome dele na API, o padrão e os limites.
- [Defina o Host header e o path prefix de uma origem](/pt-br/documentacao/guias/desenvolvimento-de-aplicacoes/primeiros-passos/defina-o-host-header-e-o-path-prefix.md): Escolha o header Host que um connector envia e o caminho que ele adiciona na frente de cada requisição.
- [Solucionar problemas de Connectors](/pt-br/documentacao/plataforma/connectors/solucao-de-problemas.md): Corrija um connector cuja origem recusa requisições ou responde com um erro.
