Devops
Por Craft XP
16 de Junho de 2026

HashiCorp Vault: Gerenciamento Centralizado de Segredos para Aplicações Modernas

O Problema dos Segredos em Aplicações Modernas

Em arquiteturas modernas de software — microsserviços, containers, múltiplos ambientes (desenvolvimento, staging, produção) — o gerenciamento de senhas, chaves de API, tokens de acesso e certificados se torna um desafio crítico de segurança. Hardcodear esses "segredos" no código-fonte, em arquivos .env versionados ou em variáveis de ambiente não criptografadas é uma prática arriscada que expõe vulnerabilidades graves.

É aqui que entra o HashiCorp Vault: uma ferramenta open-source que centraliza o armazenamento, a rotação e o controle de acesso a segredos, oferecendo criptografia de ponta a ponta, auditoria completa e integração nativa com os principais provedores de nuvem e sistemas de autenticação.

O que é o HashiCorp Vault?

O Vault é uma plataforma de gerenciamento de segredos desenvolvida pela HashiCorp (mesma criadora do Terraform, Consul e Nomad). Ele permite que você armazene, acesse e distribua segredos de forma segura, automatizada e auditável. Suas principais funcionalidades incluem:

Armazenamento criptografado: todos os segredos são criptografados em repouso e em trânsito
Rotação dinâmica: geração sob demanda de credenciais temporárias para bancos de dados e serviços em nuvem
Leasing e renovação: segredos com tempo de vida limitado que expiram automaticamente
Auditoria completa: cada acesso a segredo é registrado para rastreabilidade
Múltiplos métodos de autenticação: tokens, LDAP, Kubernetes, AWS IAM, JWT/OIDC, GitHub e mais
Múltiplos backends de storage: Consul, Raft (integrado), AWS S3, bancos de dados

Arquitetura do Vault

O Vault opera com uma arquitetura de cliente-servidor. O servidor expõe uma API RESTful (porta 8200 por padrão) e gerencia o armazenamento e a distribuição de segredos. Os clientes se autenticam e solicitam segredos através da CLI, da API HTTP ou de bibliotecas específicas para cada linguagem.

Uma das características mais poderosas do Vault são os Secret Engines (mecanismos de segredos). Eles definem como os segredos são gerados e armazenados:

# Secret Engines mais comuns:
#   - kv (key-value): armazenamento estático simples
#   - database: geração dinâmica de credenciais SQL
#   - aws: geração dinâmica de chaves AWS IAM
#   - pki: geração de certificados TLS sob demanda
#   - transit: criptografia como serviço (sem expor chaves)
#   - ssh: geração de chaves SSH temporárias

Instalando e Iniciando o Vault

A instalação do Vault é simples e funciona em Linux, macOS e Windows. Abaixo, o processo para Linux:

# Baixar o binário
wget https://releases.hashicorp.com/vault/1.18.0/vault_1.18.0_linux_amd64.zip

# Extrair e mover
unzip vault_1.18.0_linux_amd64.zip
sudo mv vault /usr/local/bin/

# Verificar instalação
vault --version

# Iniciar servidor em modo dev (apenas para testes locais)
vault server -dev

# Em outro terminal, configurar o cliente
export VAULT_ADDR='http://127.0.0.1:8200'
vault status

Atenção: o modo -dev é apenas para aprendizado. Em produção, configure o Vault com tls habilitado e um backend de storage adequado como o Raft integrado ou Consul.

Operações Básicas com o Vault

Vamos explorar as operações fundamentais usando a CLI do Vault:

1. Armazenamento de Segredos Estáticos (KV)

# Habilitar o secret engine KV versão 2
vault secrets enable -path=secret kv-v2

# Escrever um segredo
vault kv put secret/api/producao \
    api_key="sk-abc123def456" \
    db_password="sup3r_s3cr3t!"

# Ler o segredo
vault kv get secret/api/producao

# Listar segredos
vault kv list secret/api/

# Deletar um segredo
vault kv delete secret/api/producao

2. Geração Dinâmica de Credenciais de Banco de Dados

Uma das funcionalidades mais impressionantes do Vault é a criação de credenciais dinâmicas e temporárias para bancos de dados:

# Habilitar o secret engine de banco de dados
vault secrets enable database

# Configurar a conexão com o PostgreSQL
vault write database/config/postgres-db \
    plugin_name=postgresql-database-plugin \
    allowed_roles="dev-role" \
    connection_url="postgresql://{{username}}:{{password}}@localhost:5432/mydb" \
    username="vault_admin" \
    password="senha_admin"

# Criar um papel que gera credenciais com TTL de 1 hora
vault write database/roles/dev-role \
    db_name=postgres-db \
    creation_statements="CREATE USER \"{{name}}\" WITH PASSWORD \"{{password}}\" VALID UNTIL \"{{expiration}}\"; GRANT SELECT ON ALL TABLES IN SCHEMA public TO \"{{name}}\";" \
    default_ttl="1h" \
    max_ttl="24h"

# Obter credenciais dinâmicas (novo usuário + senha a cada requisição!)
vault read database/creds/dev-role
# Retorna: username com prefixo v-token-dev-... e senha aleatória
# Válido por 1 hora, depois expira automaticamente!

3. Geração de Certificados TLS com PKI

# Habilitar o secret engine PKI
vault secrets enable pki

# Configurar a CA raiz (válida por 10 anos)
vault write pki/root/generate/internal \
    common_name="minhaempresa.com.br" \
    ttl="87600h"

# Configurar URLs da CA
vault write pki/config/urls \
    issuing_certificates="http://vault.minhaempresa.com.br:8200/v1/pki/ca" \
    crl_distribution_points="http://vault.minhaempresa.com.br:8200/v1/pki/crl"

# Criar um papel para certificados de servidor
vault write pki/roles/servidor \
    allowed_domains="minhaempresa.com.br" \
    allow_subdomains=true \
    max_ttl="720h"

# Gerar certificado TLS para um serviço
vault write pki/issue/servidor \
    common_name="api.minhaempresa.com.br" \
    ttl="24h"

Autenticação no Vault

O Vault suporta diversos métodos de autenticação (auth methods). Os mais utilizados em produção são:

Token: método básico, usado principalmente para bootstrap
Kubernetes: pods autenticam via Service Account — essencial para ambientes containerizados
AppRole: ideal para máquinas e aplicações, com role_id + secret_id
AWS IAM: instâncias EC2 e Lambda autenticam via IAM roles
LDAP / OIDC / JWT: integração com provedores de identidade existentes

Exemplo: Autenticação com AppRole

# Habilitar AppRole
vault auth enable approle

# Criar um papel de aplicação
vault write auth/approle/role/api-service \
    secret_id_ttl="24h" \
    token_ttl="1h" \
    policies="api-policy"

# Obter o Role ID e Secret ID
vault read auth/approle/role/api-service/role-id
vault write -f auth/approle/role/api-service/custom-secret-id

# Autenticar e obter token de acesso
vault write auth/approle/login \
    role_id="675a50e7-..." \
    secret_id="a1b2c3d4-..."

Políticas de Acesso (ACL Policies)

As políticas do Vault seguem o princípio do menor privilégio. Você define quais paths cada entidade pode ler, escrever, listar ou deletar:

# policy/api-service.hcl
path "secret/data/api/*" {
  capabilities = ["read", "list"]
}

path "database/creds/dev-role" {
  capabilities = ["read"]
}

# Aplicar a política
vault policy write api-policy policy/api-service.hcl

Integração com Docker e Kubernetes

Em ambientes containerizados, o Vault se integra diretamente com Kubernetes através do Vault Agent Injector (sidecar). Um pod que precisa de segredos simplesmente adiciona annotations, e o Vault injeta automaticamente um container sidecar que obtém e renova os segredos:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-service
spec:
  template:
    metadata:
      annotations:
        vault.hashicorp.com/agent-inject: "true"
        vault.hashicorp.com/role: "api-service"
        vault.hashicorp.com/agent-inject-secret-db-creds: "database/creds/dev-role"
    spec:
      serviceAccountName: api-sa
      containers:
        - name: app
          image: minha-app:latest
          # O Vault injector monta os segredos em /vault/secrets/
          volumeMounts:
            - name: vault-secrets
              mountPath: /vault/secrets
      volumes:
        - name: vault-secrets
          emptyDir: {}

Vault em Produção: Alta Disponibilidade

Para ambientes de produção, o Vault deve ser configurado em cluster com alta disponibilidade. Desde a versão 1.4, o Vault suporta Raft storage integrado, eliminando a dependência de Consul para HA:

# Exemplo de configuração vault.hcl para cluster Raft de 3 nós
storage "raft" {
  path = "/opt/vault/data"
  node_id = "node1"

  retry_join {
    leader_api_addr = "http://vault-2.internal:8200"
  }
  retry_join {
    leader_api_addr = "http://vault-3.internal:8200"
  }
}

listener "tcp" {
  address = "0.0.0.0:8200"
  tls_disable = true  # Desabilitar apenas em rede interna
}

api_addr = "http://vault-1.internal:8200"
cluster_addr = "http://vault-1.internal:8201"
ui = true

Com 3 nós Raft, o cluster tolera a falha de 1 nó (quorum de 3). O Vault utiliza um modelo de segurança onde o nó líder lida com todas as requisições de leitura/escrita, e os nós seguidores redirecionam para o líder ou apenas respondem leituras, dependendo da configuração.

Boas Práticas de Segurança

Nunca execute em modo dev em produção — o modo dev armazena dados em memória e desabilita TLS
Use selos (seals) para descriptografia: o Vault suporta auto-selo com AWS KMS, Azure Key Vault, GCP Cloud KMS ou HSM
Mantenha os tokens de root seguros: o token de root tem acesso irrestrito — use-o apenas para bootstrap inicial e revogue imediatamente após criar administradores
Implemente auditoria: envie logs para um sistema centralizado (Splunk, ELK) para rastrear todos os acessos
Use segredos dinâmicos sempre que possível: credenciais estáticas são frágeis; prefira geração dinâmica com TTL curto
Faça backup do storage: em cluster Raft, faça snapshots periódicos com vault operator raft snapshot save
Revogue periodicamente: implemente rotação automática de segredos via Vault Agent ou scripts CRON

Conclusão

O HashiCorp Vault é uma ferramenta indispensável no arsenal de qualquer equipe de DevOps e segurança. Ele resolve o problema crítico de gerenciamento de segredos de forma elegante, segura e escalável — seja você uma startup com alguns microsserviços ou uma grande empresa com centenas de aplicações em múltiplas nuvens.

Com seus segredos dinâmicos, rotação automática, políticas de acesso granulares e integração nativa com Kubernetes, o Vault se consolidou como o padrão de mercado para segurança de segredos em infraestrutura moderna. Comece hoje mesmo experimentando o modo dev local, explore os secret engines e leve sua maturidade de segurança ao próximo nível.

Entrar em contato

Entre em contato