Volver a actualizaciones
Nuevo releaseSep 2, 2026

vault v2.1.0

Una herramienta para la gestión de secretos, cifrado como servicio y gestión de acceso privilegiado

Compartir

Vault build ci vault enterprise

Nota importante: Nos tomamos muy en serio la seguridad de Vault y la confianza de nuestros usuarios. Si cree que ha encontrado un problema de seguridad en Vault, por favor, divulgue de manera responsable contactándonos en [email protected].

Logotipo de Vault

Vault es una herramienta para acceder de forma segura a secretos. Un secreto es cualquier cosa a la que desee controlar estrictamente el acceso, como claves de API, contraseñas, certificados y más. Vault proporciona una interfaz unificada para cualquier secreto, al tiempo que ofrece un control de acceso estricto y registra un registro de auditoría detallado.

Un sistema moderno requiere acceso a una multitud de secretos: credenciales de bases de datos, claves de API para servicios externos, credenciales para la comunicación de arquitectura orientada a servicios, etc. Entender quién está accediendo a qué secretos ya es muy difícil y específico de la plataforma. Agregar rotación de claves, almacenamiento seguro y registros de auditoría detallados es casi imposible sin una solución personalizada. Aquí es donde entra Vault.

Las características clave de Vault son:

  • Almacenamiento seguro de secretos: Vault puede almacenar pares clave/valor arbitrarios. Vault cifra los datos antes de escribirlos en el almacenamiento persistente, por lo que acceder al almacenamiento sin procesar no es suficiente para acceder a sus secretos. Vault puede escribir en disco, Consul y más.

  • Secretos dinámicos: Vault puede generar secretos bajo demanda para algunos sistemas, como AWS o bases de datos SQL. Por ejemplo, cuando una aplicación necesita acceder a un bucket de S3, le pide credenciales a Vault, y Vault generará un par de claves de AWS con permisos válidos bajo demanda. Después de crear estos secretos dinámicos, Vault también los revocará automáticamente al finalizar la concesión.

  • Cifrado de datos: Vault puede cifrar y descifrar datos sin almacenarlos. Esto permite que los equipos de seguridad definan parámetros de cifrado y que los desarrolladores almacenen datos cifrados en una ubicación como una base de datos SQL sin tener que diseñar sus propios métodos de cifrado.

  • Concesión y renovación: Vault asocia una concesión con cada secreto. Al final de la concesión, Vault revoca automáticamente el secreto. Los clientes pueden renovar las concesiones a través de las API de renovación integradas.

  • Revocación: Vault tiene soporte integrado para la revocación de secretos. Vault puede revocar no solo secretos individuales, sino un árbol de secretos, por ejemplo, todos los secretos leídos por un usuario específico, o todos los secretos de un tipo particular. La revocación ayuda tanto en la rotación de claves como en el bloqueo de sistemas en caso de una intrusión.

Documentación, Introducción y Exámenes de Certificación

La documentación está disponible en el sitio web de Vault.

Si es nuevo en Vault y desea comenzar con la automatización de la seguridad, consulte nuestras guías de introducción en la plataforma de aprendizaje de HashiCorp. También hay guías adicionales para continuar su aprendizaje.

Para ver ejemplos de cómo interactuar con Vault desde su aplicación en diferentes lenguajes de programación, consulte el repositorio vault-examples. También está disponible una aplicación de ejemplo lista para usar.

Demuestre su conocimiento de Vault aprobando un examen de certificación. Visite la página de certificación para obtener información sobre los exámenes y encuentre materiales de estudio en la plataforma de aprendizaje de HashiCorp.

Desarrollando Vault

Si desea trabajar en Vault mismo o en cualquiera de sus sistemas integrados, primero necesitará tener Go instalado en su máquina.

Para el desarrollo local, primero asegúrese de que Go esté correctamente instalado, incluyendo la configuración de un GOPATH, luego configure la variable GOBIN en $GOPATH/bin. Asegúrese de que $GOPATH/bin esté en su PATH, ya que algunas distribuciones incluyen la versión antigua de las herramientas de compilación.

A continuación, clone este repositorio. Vault usa Go Modules, por lo que se recomienda clonar el repositorio fuera del GOPATH. Luego puede descargar las herramientas de compilación necesarias iniciando su entorno:

$ make bootstrap
...

Para compilar una versión de desarrollo de Vault, ejecute make o make dev. Esto colocará el binario de Vault en las carpetas bin y $GOPATH/bin:

$ make dev
...
$ bin/vault
...

Para compilar una versión de desarrollo de Vault con la interfaz de usuario, ejecute make static-dist dev-ui. Esto colocará el binario de Vault en las carpetas bin y $GOPATH/bin:

$ make static-dist dev-ui
...
$ bin/vault
...

Para ejecutar las pruebas, escriba make test. Nota: esto requiere que Docker esté instalado. Si termina con un estado de salida 0, ¡entonces todo funciona!

$ make test
...

Si está desarrollando un paquete específico, puede ejecutar pruebas solo para ese paquete especificando la variable TEST. Por ejemplo, a continuación solo se ejecutarán las pruebas del paquete vault.

$ make test TEST=./vault
...

Solución de problemas

Si encuentra un error como could not read Username for 'https://github.com' es posible que deba ajustar su configuración de git de la siguiente manera:

$ git config --global --add url."[email protected]:".insteadOf "https://github.com/"

Importando Vault

Este repositorio publica dos librerías que pueden ser importadas por otros proyectos: github.com/hashicorp/vault/api y github.com/hashicorp/vault/sdk.

Tenga en cuenta que este repositorio también contiene Vault (el producto), y como con la mayoría de los proyectos Go, Vault usa módulos Go para gestionar sus dependencias. El mecanismo para hacerlo es el archivo go.mod. Como sucede, la presencia de ese archivo también hace que sea teóricamente posible importar Vault como dependencia en otros proyectos. Algunos otros proyectos han adoptado la práctica de hacerlo para aprovechar las herramientas de prueba que fueron desarrolladas para probar Vault mismo. Esto no es, y nunca ha sido, una forma compatible de usar el proyecto Vault. Es poco probable que corrijamos errores relacionados con la falla al importar github.com/hashicorp/vault en su proyecto.

Vea también la sección "Pruebas basadas en Docker" a continuación.

Pruebas de aceptación

Vault tiene pruebas de aceptación exhaustivas que cubren la mayoría de las características de los métodos de secreto y autenticación.

Si está trabajando en una característica de un método de secreto o autenticación y desea verificar que funciona (y que no ha roto nada más), recomendamos ejecutar las pruebas de aceptación.

Advertencia: Las pruebas de aceptación crean/destruyen/modifican recursos reales, lo que puede generar costos reales en algunos casos. En presencia de un error, es técnicamente posible que backends rotos dejen datos huérfanos. Por lo tanto, ejecute las pruebas de aceptación bajo su propio riesgo. Como mínimo, recomendamos ejecutarlas en una cuenta privada separada para cualquier backend que esté probando.

Para ejecutar las pruebas de aceptación, invoque make testacc:

$ make testacc TEST=./builtin/logical/consul
...

La variable TEST es obligatoria, y debe especificar la carpeta donde se encuentra el backend. La variable TESTARGS se recomienda para filtrar un recurso específico a probar, ya que probar todos a la vez puede llevar mucho tiempo.

Las pruebas de aceptación generalmente requieren que se establezcan otras variables de entorno para elementos como las claves de acceso. La prueba en sí debería fallar temprano y decirle qué configurar, por lo que no se documenta aquí.

Para obtener más información sobre las características de Vault Enterprise, visite el sitio de Vault Enterprise.

Pruebas basadas en Docker

Hemos creado un mecanismo de prueba experimental nuevo inspirado en NewTestCluster. Un ejemplo de cómo usarlo:

import (
  "testing"
  "github.com/hashicorp/vault/sdk/helper/testcluster/docker"
)

func Test_Something_With_Docker(t *testing.T) {
  opts := &docker.DockerClusterOptions{
    ImageRepo: "hashicorp/vault", // o "hashicorp/vault-enterprise"
    ImageTag:    "latest",
  }
  cluster := docker.NewTestDockerCluster(t, opts)
  
  client := cluster.Nodes()[0].APIClient()
  _, err := client.Logical().Read("sys/storage/raft/configuration")
  if err != nil {
    t.Fatal(err)
  }
}

O para Enterprise:

import (
  "testing"
  "github.com/hashicorp/vault/sdk/helper/testcluster/docker"
)

func Test_Something_With_Docker(t *testing.T) {
  opts := &docker.DockerClusterOptions{
    ImageRepo: "hashicorp/vault-enterprise",
    ImageTag:  "latest",
	VaultLicense: licenseString, // no es una ruta, son los bytes reales de la licencia
  }
  cluster := docker.NewTestDockerCluster(t, opts)
}

Aquí hay un ejemplo más realista de cómo lo usamos en la práctica. DefaultOptions utiliza hashicorp/vault:latest como repositorio y etiqueta, pero también mira la variable de entorno VAULT_BINARY. Si está poblada, copiará el archivo local referenciado por VAULT_BINARY dentro del contenedor. Esto es útil al probar cambios locales.

En lugar de configurar la opción VaultLicense, puede configurar la variable de entorno VAULT_LICENSE_CI, que es mejor que comprometer una licencia en el control de versiones.

Opcionalmente, puede configurar COMMIT_SHA, que se añadirá al nombre de la imagen que construimos como una conveniencia de depuración.

func Test_Custom_Build_With_Docker(t *testing.T) {
  opts := docker.DefaultOptions(t)
  cluster := docker.NewTestDockerCluster(t, opts)
}

Hay una variedad de ayudantes en el paquete github.com/hashicorp/vault/sdk/helper/testcluster, por ejemplo, estas pruebas a continuación crearán un par de clústeres de 3 nodos y los enlazarán usando replicación PR o DR respectivamente, y fallarán si el estado de replicación no se vuelve saludable antes de que expire el contexto pasado.

Nuevamente, como están escritas, dependen de tener un binario de Vault Enterprise localmente y la variable de entorno VAULT_BINARY configurada para apuntar a él, así como tener VAULT_LICENSE_CI configurada.

func TestStandardPerfReplication_Docker(t *testing.T) {
  opts := docker.DefaultOptions(t)
  r, err := docker.NewReplicationSetDocker(t, opts)
  if err != nil {
      t.Fatal(err)
  }
  defer r.Cleanup()

  ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
  defer cancel()
  err = r.StandardPerfReplication(ctx)
  if err != nil {
    t.Fatal(err)
  }
}

func TestStandardDRReplication_Docker(t *testing.T) {
  opts := docker.DefaultOptions(t)
  r, err := docker.NewReplicationSetDocker(t, opts)
  if err != nil {
    t.Fatal(err)
  }
  defer r.Cleanup()

  ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
  defer cancel()
  err = r.StandardDRReplication(ctx)
  if err != nil {
    t.Fatal(err)
  }
}

Finalmente, aquí hay un ejemplo de cómo ejecutar una prueba Docker OSS existente con un binario personalizado:

$ GOOS=linux make dev
$ VAULT_BINARY=$(pwd)/bin/vault go test -run 'TestRaft_Configuration_Docker' ./vault/external_tests/raft/raft_binary
ok      github.com/hashicorp/vault/vault/external_tests/raft/raft_binary        20.960s
Leer más

Categorías

Autenticación y AutorizaciónHerramientas de Cifrado/DescifradoGestión de IdentidadesSeguridad en la NubeDevSecOpsDetección de SecretosGestión de Identidad y Acceso (IAM)Autenticación