HashiCorp Vault 2026: Gestão de Segredos para PME

SCHEMA MARKUP JSON-LD  |  ✎ Duarte Spínola  |  Tags:

Senhas de bases de dados, API keys, certificados TLS, chaves SSH — tudo espalhado em ficheiros .env, scripts, variáveis de ambiente e post-its digitais. Quando um developer sai da empresa, quantos segredos tem acesso? A resposta, sem Vault, é sempre “não sei”. O HashiCorp Vault centraliza segredos com rotação automática, auditoria completa e controlo de acesso granular. Este artigo configura Vault para PME com armazenamento em ficheiro, policies por equipa, rotação de credenciais de BD e integração com Ansible (Vault docs).

Neste artigo

  1. Entender Vault e Gestão Centralizada de Segredos
  2. Pré-requisitos e Instalação
  3. Passo 1 — Iniciar Vault em Modo Dev e Produção
  4. Passo 2 — Habilitar Secret Engines
  5. Passo 3 — Policies de Acesso por Equipa
  6. Passo 4 — Rotação de Credenciais de Base de Dados
  7. Passo 5 — Integração com Ansible
  8. Passo 6 — Auditoria e Logs
  9. Vault vs Alternativas — Comparação
  10. Erros Comuns
  11. Checklist Rápido de Verificação

1. Entender Vault e Gestão Centralizada de Segredos

Vault é um cofre digital para segredos. Segredos são passwords, API keys, certificados, chaves privadas — qualquer informação que dê acesso a algo. O Vault guarda estes segredos encriptados, controla quem pode aceder a cada um, regista cada acesso em log, e roda rotação automática de credenciais.

Analogia: Vault é como um cofre de banco com registo de acessos. Cada segredo está numa gaveta. Cada pessoa tem uma chave que abre apenas as gavetas autorizadas. Cada vez que alguém abre uma gaveta, o cofre regista quem, quando e qual gaveta. Se uma pessoa sai da empresa, revogas a chave — sem caçar segredos espalhados por ficheiros.

Conceito Função Analogia
Secret Engine Backend de armazenamento de segredos Gaveta do cofre (KV, BD, PKI, etc.)
Policy Regra de acesso a segredos Chave que abre certas gavetas
Token Credencial de autenticação Cartão de acesso pessoal
Path Endereço do segredo no Vault Número da gaveta
Audit Device Log de todas as operações Registo do cofre
Auth Method Como autenticar (token, LDAP, AppRole) Como identificas quem é

O problema que Vault resolve: segredos espalhados. Sem Vault, uma PME típica tem:

  • 15 ficheiros .env em 10 servidores
  • 30 API keys hardcoded em scripts
  • 5 passwords de BD em ficheiros de config plain text
  • Certificados TLS em 5 sítios diferentes
  • Zero auditoria de quem acedeu ao quê

Com Vault: tudo num só sítio, encriptado, com auditoria (Vault getting started).

2. Pré-requisitos e Instalação

Requisito Detalhe
Servidor Linux Ubuntu 22.04+, Debian 12+, RHEL 9+
RAM 512 MB mínima (1 GB recomendado)
Disco 1 GB para binário + storage
TLS Recomendado para produção (auto-TLS ou cert manual)
Firewall Porta 8200 (Vault API)

Instalar Vault:

Ubuntu/Debian:

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg –dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo “deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main” | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vault

Se não tiveres wget, usar curl -fsSL URL | sudo gpg --dearmor como alternativa.

Outros OS:

# Descarregar binário directly
curl -fsSL https://releases.hashicorp.com/vault/1.18.0/vault_1.18.0_linux_amd64.zip -o vault.zip
unzip vault.zip
sudo mv vault /usr/local/bin/

Se unzip não estiver instalado: apt install unzip ou dnf install unzip.

Verificar instalação:

vault version

3. Passo 1 — Iniciar Vault em Modo Dev e Produção

Modo Dev (apenas para testes)

O modo dev é para experimentar — tudo em memória, sem persistência, sem TLS:

vault server -dev -dev-root-token-id=”root-token-dev”

O que cada flag faz:

  • -dev — modo desenvolvimento (in-memory, sem persistência)
  • -dev-root-token-id — define o token root explicitamente (apenas para dev)

⚠️ Atenção

NUNCA usar modo dev em produção. Todos os segredos perdem-se quando o Vault reinicia.

Modo Produção (com persistência em ficheiro)

Criar ficheiro de configuração:

sudo mkdir -p /etc/vault /var/lib/vault
sudo tee /etc/vault/config.hcl > /dev/null << 'EOF' storage "file" { path = "/var/lib/vault" } listener "tcp" { address = "0.0.0.0:8200" tls_disable = 1 } api_addr = "http://127.0.0.1:8200" cluster_addr = "http://127.0.0.1:8201" ui = true EOF

O que cada bloco faz:

  • storage "file" — guarda segredos encriptados em /var/lib/vault. Para HA, usar Raft ou Consul
  • listener "tcp" — escuta na porta 8200. tls_disable = 1 para lab — em produção usar TLS
  • ui = true — ativa interface web em http://servidor:8200/ui

Iniciar Vault:

sudo vault server -config=/etc/vault/config.hcl

Inicializar o Vault (apenas na primeira vez):

export VAULT_ADDR=’http://127.0.0.1:8200′
vault operator init -key-shares=3 -key-threshold=2

O que cada parâmetro faz:

  • -key-shares=3 — gera 3 unseal keys (chaves para destrancar o Vault)
  • -key-threshold=2 — precisa de 2 das 3 chaves para destrancar

Guardar as unseal keys e o root token em local seguro (password manager, cofre físico). Depois destrancar:

vault operator unseal
vault operator unseal

O Vault precisa de 2 chaves (threshold) para destrancar. Nenhuma pessoa sozinha tem todas as chaves — separação de poderes (Vault init).

4. Passo 2 — Habilitar Secret Engines

O Vault tem múltiplas “secret engines” — cada uma gere um tipo de segredo:

# KV v2 — segredos estáticos (API keys, passwords)
vault secrets enable -path=secret kv-v2

# Database — rotação automática de credenciais BD
vault secrets enable database

# PKI — certificados TLS dinâmicos
vault secrets enable pki

# SSH — chaves SSH assinadas
vault secrets enable -path=ssh-client-signer ssh

O que cada engine faz:

  • kv-v2 — key-value store versionado. Guarda pares chave-valor encriptados com histórico de versões
  • database — gere credenciais de BD dinâmicas. Cria users na BD com TTL, roda rotação automática
  • pki — autoridade certificadora interna. Emite certificados TLS com TTL curto
  • ssh-client-signer — assina chaves SSH públicas. Clientes usam a chave assinada para SSH sem passwords

Guardar um segredo no KV:

vault kv put secret/empresa/api-stripe key=”sk_live_abc123″ environment=”production”

Ler um segredo:

vault kv get secret/empresa/api-stripe

5. Passo 3 — Policies de Acesso por Equipa

As policies controlam quem pode aceder a quê. Cada policy é um ficheiro HCL:

tee /tmp/dev-team.hcl > /dev/null << 'EOF' # Equipa de desenvolvimento: acesso apenas a segredos de dev
path “secret/data/empresa/dev/*” {
capabilities = [“read”, “list”]
}

# Sem acesso a produção
path “secret/data/empresa/production/*” {
capabilities = [“deny”]
}
EOF

tee /tmp/ops-team.hcl > /dev/null << 'EOF' # Equipa de ops: acesso a tudo
path “secret/data/empresa/*” {
capabilities = [“read”, “list”, “create”, “update”, “delete”]
}

# Database engine
path “database/creds/*” {
capabilities = [“read”]
}
EOF

O que cada regra faz:

  • path — endereço do segredo no Vault (wildcard * suportado)
  • capabilities — read, list, create, update, delete, deny. deny sobrepõe-se a tudo
  • secret/data/ — prefixo do KV v2 (a engine KV v2 usa /data/ internamente)

Aplicar as policies:

vault policy write dev-team /tmp/dev-team.hcl
vault policy write ops-team /tmp/ops-team.hcl

Criar tokens para cada equipa:

vault token create -policy=dev-team -ttl=24h
vault token create -policy=ops-team -ttl=24h

O -ttl=24h define que o token expira em 24 horas — boa prática para limitar exposição (Vault policies).

6. Passo 4 — Rotação de Credenciais de Base de Dados

A killer feature do Vault é a rotação automática de credenciais de BD. Em vez de uma password estática partilhada por 10 aplicações, o Vault cria credenciais únicas por aplicação com TTL.

Configurar conexão PostgreSQL:

vault write database/config/empresa-postgres \
plugin_name=postgresql-database-plugin \
connection_url=”postgresql://{{username}}:{{password}}@db.empresa.pt:5432/empresa?sslmode=disable” \
allowed_roles=”app-prod” \
username=”vault_admin” \
password=”password-do-admin-bd”

O que cada parâmetro faz:

  • plugin_name — driver da BD (PostgreSQL, MySQL, MSSQL, etc.)
  • connection_url — string de conexão com placeholders {{username}} e {{password}}
  • allowed_roles — quais roles podem usar esta conexão
  • username/password — credenciais admin que o Vault usa para criar/revogar users na BD

Criar uma role que gera credenciais dinâmicas:

vault write database/roles/app-prod \
db_name=empresa-postgres \
creation_statements=”CREATE ROLE \”{{name}}\” WITH LOGIN PASSWORD ‘{{password}}’ VALID UNTIL ‘{{expiration}}’; GRANT SELECT ON ALL TABLES IN SCHEMA public TO \”{{name}}\”;” \
default_ttl=”1h” \
max_ttl=”24h”

O que cada parâmetro faz:

  • creation_statements — SQL que cria o user na BD. {{name}} e {{password}} são gerados pelo Vault
  • default_ttl="1h" — credencial válida por 1 hora. Renovada automaticamente se a app pedir renew
  • max_ttl="24h" — máximo 24h, depois é revogada automaticamente

Quando a aplicação precisa de uma credencial:

vault read database/creds/app-prod

Output:

Key Value
— —–
lease_id database/creds/app-prod/abc123
lease_duration 1h
password A1b2C3d4E5f6-g7h8
username v-token-app-prod-xyz789

A aplicação usa este user/password. Ao fim de 1h, o Vault revoga o user na BD automaticamente (Vault database secrets).

7. Passo 5 — Integração com Ansible

O Ansible pode obter segredos do Vault em runtime em vez de os ter hardcoded em group_vars:

Instalar a collection do Vault:

ansible-galaxy collection install community.hashi_vault

No playbook, obter segredos do Vault:

– name: Deploy aplicação com segredos do Vault
hosts: webservers
tasks:
– name: Obter API key do Vault
community.hashi_vault.vault_read:
path: secret/empresa/api-stripe
url: http://vault.empresa.pt:8200
auth_method: token
token: “{{ vault_token }}”
register: stripe_key
no_log: true

– name: Deploy app com API key
template:
src: app.env.j2
dest: /opt/app/.env
vars:
stripe_api_key: “{{ stripe_key.secret.data.key }}”
no_log: true

O que cada parâmetro faz:

  • vault_read — lê um segredo do Vault via API
  • auth_method: token — autentica com token (alternativas: AppRole, LDAP)
  • no_log: true — CRÍTICO: impede que o Ansible mostre o segredo no output
  • stripe_key.secret.data.key — navega na estrutura de resposta do Vault

8. Passo 6 — Auditoria e Logs

ativar audit log em ficheiro:

vault audit enable file file_path=/var/log/vault/audit.log

A partir de agora, todas as operações são registadas:

{
“time”: “2026-06-23T14:32:01Z”,
“type”: “request”,
“auth”: {
“client_token”: “hvs.ABC123…”,
“token_type”: “batch”,
“entity_id”: “dev-team-entity”
},
“request”: {
“operation”: “read”,
“path”: “secret/data/empresa/dev/api-key”,
“remote_address”: “10.0.1.50”
}
}

O log mostra: quando, quem (entity), o quê (path), de onde (IP). O conteúdo dos segredos é hmac-only — o log regista o hash, não o valor real. Isto permite auditoria sem expor segredos (Vault audit).

Para procurar acessos a um segredo específico:

grep “secret/data/empresa/api-stripe” /var/log/vault/audit.log | jq .

9. Vault vs Alternativas — Comparação

Feature Vault AWS Secrets Manager Doppler .env files
Rotação automática BD Sim Sim Não Não
PKI interna Sim Não Não Não
Auditoria Completa CloudTrail Sim Nenhuma
Self-hosted Sim Não Não Sim
Custo (PME 25) Gratuito (OSS) ~€20/mês ~€30/mês €0
Multi-cloud Sim AWS only Sim Sim
UI web Sim AWS Console Sim Não
Integração Ansible Sim Via AWS CLI Via API Manual

Recomendação para PME: Vault OSS (gratuito) se tens infra própria e queres controlo total. AWS Secrets Manager se estás 100% em AWS. Doppler se queres simplicidade SaaS sem gerir infra.

10. Erros Comuns

Problema Causa Solução
Vault sealed após restart Esperado — precisa de unseal vault operator unseal com 2 das 3 keys
permission denied ao ler segredo Policy não permite o path Verificar policy: vault policy read <name>
Credencial BD não roda Plugin BD não instalado ou SQL errado Verificar vault write database/config/... — testar SQL manualmente
Token expirado TTL do token passou Renovar com vault token renew ou criar novo
connection refused na porta 8200 Vault não está a correr systemctl status vault e journalctl -u vault
Audit log vazio Audit device não activado vault audit enable file file_path=...
Ansible mostra segredos no output no_log: true em falta Adicionar no_log: true a todas as tasks que lidam com segredos
Unseal keys perdidas Guardadas em local inacessível Sem recovery — reinicializar Vault e re-adicionar segredos

11. Checklist Rápido de Verificação

  • [ ] Vault instalado e a correr em modo produção (systemctl status vault)
  • [ ] Vault inicializado com 3 unseal keys guardadas em local seguro
  • [ ] Vault destrancado (unsealed)
  • [ ] Secret engine KV v2 habilitada em secret/
  • [ ] Secret engine Database habilitada (se usas rotação BD)
  • [ ] Policies criadas por equipa (dev-team, ops-team)
  • [ ] Tokens com TTL curto (24h ou menos)
  • [ ] Rotação de credenciais BD testada (vault read database/creds/...)
  • [ ] Audit log ativo em ficheiro
  • [ ] Integração Ansible com no_log: true em todas as tasks de segredos

Artigos Relacionados

← Voltar ao Índice