> For the complete documentation index, see [llms.txt](https://wiki.datadike.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.datadike.com/pt/pam/administration/integrations/application-to-application.md).

# Acesso aplicação para aplicação

Deixar uma ferramenta buscar a credencial no cofre em vez de guardar uma própria: registrar a aplicação, assinar a requisição e a trilha que cada retirada deixa.

## O que é isto e quando usar

A2A permite que **ferramentas**, e não pessoas, busquem credenciais no cofre. Um scanner, uma esteira, um agente de monitoração ou uma plataforma de ITSM pede a credencial no momento em que precisa dela, usa e não guarda nada.

O problema que isso resolve é a credencial que ninguém rotaciona: a senha no `config.yaml`, a chave na variável do Jenkins, a conta de serviço colada num scanner anos atrás. Essas credenciais são invisíveis para o cofre, então a rotação nunca chega nelas e nenhum relatório consegue dizer quem as usou.

{% hint style="info" %}
**A direção importa, e costuma ser mal entendida.** A solução não se conecta às suas ferramentas. Ela **publica uma API que essas ferramentas chamam**. O trabalho de integração acontece do lado de quem chama, e nada precisa ser instalado dentro da solução.
{% endhint %}

## Conceitos

| Termo                       | O que significa                                                                                                                                     |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Aplicação de integração** | A identidade com que uma ferramenta se autentica. Não é um usuário, não acessa o console e não faz nada além de buscar as credenciais do seu escopo |
| **ID e segredo**            | O par de credenciais com que a aplicação assina suas requisições                                                                                    |
| **Escopo de contas**        | O conjunto de contas que essa aplicação pode ler. O que estiver fora dele não existe para ela                                                       |
| **Grupo de IP**             | Os endereços de origem de onde a aplicação pode chamar                                                                                              |

Uma aplicação pertence a uma organização e alcança apenas as contas dessa organização.

## Antes de começar

* Um papel administrativo capaz de gerenciar aplicações de integração.
* As contas de que a ferramenta vai precisar, já gerenciadas no cofre.
* Os endereços de origem de onde a ferramenta vai chamar.

## Registrando uma aplicação

1. Abra **Configurações do Sistema › A2A** e crie uma aplicação.
2. Dê um **nome** que diga qual ferramenta é. Esse nome aparece na trilha de auditoria, então "scanner Tenable, produção" é melhor que "app1".
3. Defina as **contas** que ela pode ler. Conceda o conjunto mais estreito que permita a ferramenta funcionar.
4. Defina o **grupo de IP** com os endereços de onde a ferramenta chama.
5. Salve e revele o **segredo**. Revelar exige segundo fator, e o valor é exibido para quem chamou copiar.

{% hint style="danger" %}
**O grupo de IP permite qualquer endereço por padrão.** Uma aplicação nova é alcançável de qualquer lugar até você restringir. Definir isso é o que transforma um segredo vazado em uma chamada recusada vinda da rede errada.
{% endhint %}

Pedir o segredo de novo **substitui o anterior**. Qualquer cliente que ainda esteja com o valor antigo para de autenticar, então rotacione de propósito, e não para conferir qual era.

## Buscando uma credencial

```
GET /api/v1/accounts/integration-applications/account-secret/
```

| Parâmetro    | Uso                                                  |
| ------------ | ---------------------------------------------------- |
| `account_id` | O UUID da conta. A forma mais simples, usada sozinha |
| `account`    | O nome da conta, quando você não tem o UUID          |
| `asset`      | O nome do ativo, para desambiguar um nome de conta   |
| `asset_id`   | O UUID do ativo, com a mesma finalidade              |

A requisição é assinada com HTTP Signature, HMAC-SHA256, usando o ID da aplicação como `keyId` e o segredo dela como chave. Ela também leva `X-Source: datadike-pam`, que é o que diz à solução para autenticar uma aplicação, e não a chave de acesso de um usuário.

```
Authorization: Signature keyId="<id da aplicacao>",algorithm="hmac-sha256",
               headers="(request-target) date",signature="<base64>"
Date: Wed, 23 Sep 2026 20:44:35 GMT
X-Source: datadike-pam
X-PAM-ORG: <id da organizacao>
```

Uma chamada bem-sucedida responde com o segredo e nada mais:

```json
{ "id": "<id da aplicacao>", "secret": "<a credencial>" }
```

Para a construção exata da string de assinatura, e os três detalhes que mais costumam quebrá-la, veja [API](https://wiki.datadike.com/pt/pam/reference/api.md).

### Clientes prontos

Você não precisa implementar a assinatura. A solução serve um cliente funcional e a documentação dele para seis linguagens, na aba **SDKs** da aplicação: **Python, Java, Go, Node.js, PowerShell e curl**. Java, Go e PowerShell não precisam de biblioteca externa.

### Códigos de resposta

| Código | Significado                                                                              |
| ------ | ---------------------------------------------------------------------------------------- |
| 200    | A credencial está no corpo                                                               |
| 400    | Os parâmetros não identificam uma única conta                                            |
| 401    | Assinatura recusada, aplicação inativa, ou chamada vinda de endereço fora do grupo de IP |
| 404    | Nenhuma conta corresponde, ou a conta está fora do escopo dessa aplicação                |

## Integrando uma ferramenta que não fala essa API

Plataformas como **Aranda**, **SOTI**, **Tenable** ou **Qualys** não sabem assinar uma requisição desse jeito nativamente. Dois padrões funcionam, e os dois mantêm a credencial fora da configuração da ferramenta:

* **Uma etapa de busca antes do trabalho.** Um script curto, construído a partir de um dos clientes fornecidos, busca a credencial e a entrega à ferramenta em tempo de execução. É a escolha usual para esteiras e rotinas de varredura.
* **O mecanismo de extensão da própria plataforma**, onde houver, chamando o endpoint acima.

{% hint style="warning" %}
Não existe conector de encaixe direto para essas plataformas. A solução expõe uma API documentada e fornece clientes de referência; ligar isso a uma plataforma específica é trabalho de integração do lado dela. Planeje esse esforço em vez de supor que é um checkbox.
{% endhint %}

## Toda retirada fica registrada

Cada busca bem-sucedida grava um registro de auditoria com o nome da aplicação, a conta e o ativo a que ela pertence, o endereço de origem e o horário. Ele cai na mesma trilha de uma pessoa clicando em *ver* numa credencial, que é o que torna "quem já leu esta credencial" uma pergunta com resposta completa.

Veja [Trilha de auditoria](https://wiki.datadike.com/pt/pam/administration/audit/audit-trail.md) e [O cofre de credenciais](https://wiki.datadike.com/pt/pam/administration/accounts/vault.md).

## Como verificar que funcionou

1. **Busque uma credencial** com o cliente fornecido e confirme que o corpo traz o segredo.
2. **Chame de novo a partir de um endereço fora do grupo de IP** e confirme a recusa. Restrição de IP que ninguém testou é configuração, não controle.
3. **Peça uma conta fora do escopo da aplicação** e confirme o 404. É a checagem que prova que o escopo é real.
4. **Abra a trilha de auditoria** e confirme que tanto a chamada bem-sucedida quanto a recusada estão lá. Uma retirada que não deixa rastro não é retirada, é vazamento.

## Erros comuns

| Sintoma                                                  | Causa                                                                          | Correção                                                         |
| -------------------------------------------------------- | ------------------------------------------------------------------------------ | ---------------------------------------------------------------- |
| 401 com uma assinatura aparentemente correta             | A data foi formatada no idioma da máquina, ou o relógio está fora de hora      | Formate a data em inglês, em GMT, e sincronize o relógio do host |
| 401 a partir de um servidor, mas não da sua estação      | O grupo de IP não inclui esse servidor                                         | Acrescente o endereço                                            |
| A chamada autentica como usuário, e não como a aplicação | Falta o `X-Source: datadike-pam`                                               | Acrescente o cabeçalho                                           |
| 404 para uma conta que você vê no console                | Está fora do escopo de contas da aplicação, ou em outra organização            | Amplie o escopo, ou envie o `X-PAM-ORG` correto                  |
| Todos os clientes pararam de funcionar ao mesmo tempo    | O segredo foi revelado de novo, o que o substitui                              | Distribua o segredo novo                                         |
| 200, mas o segredo volta vazio                           | A leitura de segredo de conta está desabilitada nas configurações de segurança | Revise **Configurações do Sistema › Segurança**                  |

## Páginas relacionadas

* [API](https://wiki.datadike.com/pt/pam/reference/api.md), como assinar uma requisição e as convenções comuns a todos os endpoints
* [O cofre de credenciais](https://wiki.datadike.com/pt/pam/administration/accounts/vault.md), de onde essas chamadas leem
* [Contas gerenciadas](https://wiki.datadike.com/pt/pam/administration/accounts/managed-accounts.md), as contas com que o escopo de uma aplicação é montado
* [Rotacionar credenciais](https://wiki.datadike.com/pt/pam/administration/accounts/rotation.md), por que buscar é melhor que guardar
* [Trilha de auditoria](https://wiki.datadike.com/pt/pam/administration/audit/audit-trail.md), onde cada retirada fica registrada
