# Spring Cloud Vault

Spring Cloud Vault Config 为分布式系统中的外部化配置提供了客户端支持。有了[HashiCorp 的保险库](https://www.vaultproject.io)，你就有了一个中心位置来管理跨所有环境的应用程序的外部秘密属性。Vault 可以管理静态和动态秘密，例如远程应用程序/资源的用户名/密码，并为外部服务（例如 MySQL、PostgreSQL、Apache Cassandra、CouchBase、MongoDB、Consul、AWS 等）提供凭据。

## [](#new-noteworthy)[1.新的和值得注意的](#new-noteworthy)

本节简要介绍了最新版本中新的和值得注意的项目。

### [](#new-in-3.0.0)[1.1. New in Spring Cloud Vault 3.0](#new-in-3.0.0)

* 将`PropertySource`初始化从 Spring cloud 的 bootstrap 上下文迁移到 Spring boot 的[配置数据 API](#vault.configdata)。

* 支持[CouchBase 数据库](#vault.config.backends.couchbase)后端。

* 通过`spring.cloud.vault.ssl.key-store-type=…`/`spring.cloud.vault.ssl.trust-store-type=…`配置 keystore/truststore 类型，包括 PEM 支持。

* 通过配置`ReactiveVaultEndpointProvider`来支持`ReactiveDiscoveryClient`。

* 支持配置[多个数据库](#vault.config.backends.databases)。

## [](#quick-start)[2.快速启动](#quick-start)

**先决条件**

要开始使用 Vault 和本指南，你需要一个 \* 类似于 Nix 的操作系统，该操作系统提供：

* `wget`，`openssl`和`unzip`

* 至少有一个 Java8 和一个正确配置的`JAVA_HOME`环境变量

|   |本指南从 Spring Cloud Vault 的角度解释了 Vault 的设置，用于集成测试。<br/>你可以直接在 Vault 项目站点上找到入门指南：[learn.HashiCorp.com/vault](https://learn.hashicorp.com/vault)|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

**安装保险库**

```
$ wget https://releases.hashicorp.com/vault/${vault_version}/vault_${vault_version}_${platform}.zip
$ unzip vault_${vault_version}_${platform}.zip
```

|   |这些步骤可以通过下载并运行[`install_vault.sh`]（https://github.com/ Spring-cloud/ Spring-cloud-vault/blob/master/SRC/test/bash/install_vault.sh）来实现。|
|---|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

**为 Vault 创建 SSL 证书**

接下来，你需要生成一组证书：

* 根 CA

* 保险库证书（解密密钥`work/ca/private/localhost.decrypted.key.pem`和证书`work/ca/certs/localhost.cert.pem`）

确保将根证书导入到符合 Java 的信任存储库中。

实现这一点的最简单方法是使用 OpenSSL。

|   |[`create_certificates.sh`]（https://github.com/ Spring-cloud/ Spring-cloud-vault/blob/master/SRC/test/bash/）在`work/ca`和一个 JKS 信任库`work/keystore.jks`中创建证书。<br/>如果你想使用这个快速启动指南运行 Spring Cloud Vault，你需要将信任库中的`spring.cloud.vault.ssl.trust-store`属性配置为`file:work/keystore.jks`。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

**启动 Vault 服务器**

接下来，按照以下内容创建一个配置文件：

```
backend "inmem" {
}

listener "tcp" {
  address = "0.0.0.0:8200"
  tls_cert_file = "work/ca/certs/localhost.cert.pem"
  tls_key_file = "work/ca/private/localhost.decrypted.key.pem"
}

disable_mlock = true
```

|   |你可以在[`vault.conf`]（https://github.com/ Spring-clod/ Spring-cloud-vault/blob/master/SRC/test/bash/vault.conf）上找到一个示例配置文件。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------|

```
$ vault server -config=vault.conf
```

使用`inmem`存储和`https`在`0.0.0.0:8200`上开始监听 Vault。保险库是密封的，在启动时没有初始化。

|   |如果要运行测试，请保持 Vault 未初始化。<br/>测试将初始化 Vault 并创建根令牌`00000000-0000-0000-0000-000000000000`。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------|

如果你想为你的应用程序使用 Vault，或者尝试一下它，那么你需要首先对它进行初始化。

```
$ export VAULT_ADDR="https://localhost:8200"
$ export VAULT_SKIP_VERIFY=true # Don't do this for production
$ vault operator init
```

你应该看到这样的东西：

```
Key 1: 7149c6a2e16b8833f6eb1e76df03e47f6113a3288b3093faf5033d44f0e70fe701
Key 2: 901c534c7988c18c20435a85213c683bdcf0efcd82e38e2893779f152978c18c02
Key 3: 03ff3948575b1165a20c20ee7c3e6edf04f4cdbe0e82dbff5be49c63f98bc03a03
Key 4: 216ae5cc3ddaf93ceb8e1d15bb9fc3176653f5b738f5f3d1ee00cd7dccbe926e04
Key 5: b2898fc8130929d569c1677ee69dc5f3be57d7c4b494a6062693ce0b1c4d93d805
Initial Root Token: 19aefa97-cccc-bbbb-aaaa-225940e63d76

Vault initialized with 5 keys and a key threshold of 3. Please
securely distribute the above keys. When the Vault is re-sealed,
restarted, or stopped, you must provide at least 3 of these keys
to unseal it again.

Vault does not store the master key. Without at least 3 keys,
your Vault will remain permanently sealed.
```

Vault 将初始化并返回一组解封键和根令牌。挑出 3 把钥匙，打开保险库。将 Vault 令牌存储在`VAULT_TOKEN`环境变量中。

```
$ vault operator unseal (Key 1)
$ vault operator unseal (Key 2)
$ vault operator unseal (Key 3)
$ export VAULT_TOKEN=(Root token)
# Required to run Spring Cloud Vault tests after manual initialization
$ vault token create -id="00000000-0000-0000-0000-000000000000" -policy="root"
```

Spring Cloud Vault 访问不同的资源。默认情况下，秘密后台是启用的，它通过 JSON 端点访问秘密配置设置。

HTTP 服务具有以下形式的资源：

```
/secret/{application}/{profile}
/secret/{application}
/secret/{defaultContext}/{profile}
/secret/{defaultContext}
```

如果在`SpringApplication`中将“application”注入为`spring.application.name`（即在常规 Spring 引导应用程序中通常是“application”），则“profile”是一个活动配置文件（或以逗号分隔的属性列表）。从 Vault 检索到的属性将按“原样”使用，而不会对属性名称作进一步的前缀。

## [](#client-side-usage)[3.客户端使用](#client-side-usage)

要在应用程序中使用这些特性，只需将其构建为依赖于`spring-cloud-vault-config`的 Spring 引导应用程序（例如，请参见测试用例）。示例 Maven 配置：

例 1。 POM.xml

```
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.0.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-vault-config</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

<!-- repositories also needed for snapshots and milestones -->
```

然后，你可以创建一个标准的 Spring 启动应用程序，就像这个简单的 HTTP 服务器：

```
@SpringBootApplication
@RestController
public class Application {

    @RequestMapping("/")
    public String home() {
        return "Hello World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```

当它运行时，如果它正在运行，它将从端口`8200`上的默认本地 Vault 服务器获取外部配置。要修改启动行为，你可以使用`application.properties`更改 Vault 服务器的位置，例如

示例 2.application.yml

```
spring.cloud.vault:
    host: localhost
    port: 8200
    scheme: https
    uri: https://localhost:8200
    connection-timeout: 5000
    read-timeout: 15000
    config:
spring.config.import: vault://
```

* `host`设置保险库主机的主机名。主机名将用于 SSL 证书验证

* `port`设置保险库端口

* `scheme`将方案设置为`http`将使用普通的 HTTP。支持的方案是`http`和`https`。

* `uri`使用 URI 配置保险库端点。优先于主机/端口/方案配置

* `connection-timeout`以毫秒为单位设置连接超时

* `read-timeout`以毫秒为单位设置读取超时

* `spring.config.import`使用所有启用的秘密后端（默认启用键值）将 Vault 挂载为`PropertySource`

启用进一步的集成需要额外的依赖关系和配置。根据设置 Vault 的方式，你可能需要额外的配置，如[SSL](https://cloud.spring.io/spring-cloud-vault/reference/html/#vault.config.ssl)和[认证](https://cloud.spring.io/spring-cloud-vault/reference/html/#vault.config.authentication)。

如果应用程序导入`spring-boot-starter-actuator`项目，那么 Vault 服务器的状态将通过`/health`端点可用。

可以通过属性`management.health.vault.enabled`启用或禁用 Vault 健康指示器（默认为`true`）。

|   |在 Spring Cloud Vault3.0 和 Spring Boot2.4 中，对属性源的 BootStrap 上下文初始化（`bootstrap.yml`，`bootstrap.properties`）被弃用。相反， Spring Cloud Vault 支持 Spring Boot 的 Config Data API，该 API 允许从 Vault 导入配置。使用 Spring 引导配置数据方法，你需要设置`spring.config.import`属性才能绑定到 Vault。你可以在[配置数据位置部分](#vault.configdata.locations)中阅读有关它的更多信息。<br/>你可以通过设置配置属性`spring.cloud.bootstrap.enabled=true`或包括依赖项`org.springframework.cloud:spring-cloud-starter-bootstrap`来启用引导程序上下文。|
|---| |

### [](#authentication)[3.1.认证](#authentication)

Vault 需要[认证机制](https://www.vaultproject.io/docs/concepts/auth.html)到[授权客户请求](https://www.vaultproject.io/docs/concepts/tokens.html)。

Spring Cloud Vault 支持多个[认证机制](https://cloud.spring.io/spring-cloud-vault/reference/html/#vault.config.authentication)来使用 Vault 对应用程序进行身份验证。

对于快速启动，使用[保险库初始化](#quickstart.vault.start)打印的根令牌。

示例 3.application.yml

```
spring.cloud.vault:
    token: 19aefa97-cccc-bbbb-aaaa-225940e63d76
spring.config.import: vault://
```

|   |仔细考虑你的安全需求。<br/>静态令牌身份验证很好，如果你想快速地开始使用 Vault，但是静态令牌不会受到进一步的保护。<br/>向非预期的各方披露的任何信息都允许 Vault 与相关的令牌角色一起使用。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

## [](#vault.configdata)[4.配置数据 API](#vault.configdata)

Spring 自版本 2.4 起，启动提供了一个 ConfigData API，该 API 允许声明配置源并将其导入为属性源。

Spring Cloud Vault 从 3.0 版本开始使用 ConfigData API 来挂载 Vault 的秘密后端作为属性源。在以前的版本中，使用了引导程序上下文。ConfigData API 要灵活得多，因为它允许指定要导入哪些配置系统以及导入的顺序。

|   |你可以通过设置配置属性`spring.cloud.bootstrap.enabled=true`或包括依赖项`org.springframework.cloud:spring-cloud-starter-bootstrap`来启用已弃用的引导程序上下文。|
|---|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### [](#vault.configdata.locations)[4.1.配置数据位置](#vault.configdata.locations)

你可以通过从 Vault 实现的一个或多个`PropertySource`挂载 Vault 配置。 Spring Cloud Vault 支持两个配置位置：

* `vault://`（默认位置）

* `vault:///<context-path>`（上下文位置）

使用所有启用[秘密后端](#vault.config.backends)的默认位置挂载属性源。在没有进一步配置的情况下， Spring Cloud Vault 在`/secret/${spring.application.name}`处挂载键值后端。每个激活的配置文件都会在`/secret/${spring.application.name}/${profile}`表单之后添加另一个上下文路径。向 Classpath 中添加更多的模块，例如`spring-cloud-config-databases`，提供了额外的秘密后端配置选项，如果启用，这些选项将被挂载为属性源。

如果要控制从 Vault 挂载的上下文路径为`PropertySource`，则可以使用上下文位置（`vault:///my/context/path`）或配置[`VaultConfigurer`]（#vault.config.backends.configrer）。

上下文位置是单独指定和挂载的。 Spring Cloud Vault 将每个位置挂载为唯一的`PropertySource`。你可以将默认位置与上下文位置（或其他配置系统）混合，以控制属性源的顺序。如果你想禁用缺省键值路径计算并自己挂载每个键值后端，那么这种方法特别有用。

示例 4.application.yml

```
spring.config.import: vault://first/context/path, vault://other/path, vault://
```

Spring `Environment`中的属性名称必须是唯一的，以避免被遮蔽。如果你在不同的上下文路径中使用相同的秘密名称，并且希望将它们作为单独的属性公开，那么可以通过向位置添加`prefix`查询参数来区分它们。

示例 5.application.yml

```
spring.config.import: vault://my/path?prefix=foo., vault://my/other/path?prefix=bar.
secret: ${foo.secret}
other.secret: ${bar.secret}
```

|   |前缀按原样添加到 Vault 返回的所有属性名称中。如果你希望在前缀和键名之间用一个点分隔键名，请确保在前缀中添加一个尾随的点。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### [](#vault.configdata.location.optional)[4.2.有条件地启用/禁用保险库配置](#vault.configdata.location.optional)

在某些情况下，可能需要在没有 Vault 的情况下启动应用程序。你可以通过 Location 字符串表示 Vault Config 位置应该是可选的还是强制的（默认）：

* `optional:vault://`（默认位置）

* `optional:vault:///<context-path>`（上下文位置）

如果通过`spring.cloud.vault.enabled=false`禁用了 Vault 支持，则在应用程序启动期间跳过可选位置。

|   |无论配置位置是否标记为可选的，都会跳过无法找到的 Vault 上下文路径（HTTP STATUS404）。[Vault 客户端快速失败](#vault.config.fail-fast)如果由于 HTTP STATUS404 而找不到保险库上下文路径，则允许在启动时失败。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### [](#vault.configdata.customization)[4.3.基础设施定制](#vault.configdata.customization)

Spring Cloud Vault 需要基础设施类与 Vault 进行交互。当不使用 ConfigData API（这意味着你还没有指定`spring.config.import=vault://`或上下文 Vault 路径）时， Spring Cloud Vault 通过`VaultAutoConfiguration`和`VaultReactiveAutoConfiguration`定义其 bean。 Spring 在 Spring 上下文可用之前引导应用程序。因此`VaultConfigDataLoader`注册 bean 本身，以便稍后将这些内容传播到应用程序上下文中。

通过使用`Bootstrapper`API 注册自定义实例，你可以自定义 Spring Cloud Vault 使用的基础架构：

```
InstanceSupplier<RestTemplateBuilder> builderSupplier = ctx -> RestTemplateBuilder
      .builder()
      .requestFactory(ctx.get(ClientFactoryWrapper.class).getClientHttpRequestFactory())
      .defaultHeader("X-Vault-Namespace", "my-namespace");

SpringApplication application = new SpringApplication(MyApplication.class);
application.addBootstrapper(registry -> registry.register(RestTemplateBuilder.class, builderSupplier));
```

另请参见[自定义要作为 PropertySource 公开的秘密后端](#vault.config.backends.configurer)和`VaultConfigDataLoader`的自定义钩源。

## [](#vault.config.authentication)[5.认证方法](#vault.config.authentication)

不同的组织对安全性和身份验证有不同的要求。Vault 通过提供多种身份验证方法来反映这种需求。 Spring Cloud Vault 支持令牌和 APPID 身份验证。

### [](#vault.config.authentication.token)[5.1.令牌认证](#vault.config.authentication.token)

令牌是在 Vault 中进行身份验证的核心方法。令牌身份验证需要使用配置提供一个静态令牌。作为后备，也可以从`~/.vault-token`检索令牌，这是 Vault CLI 用于缓存令牌的默认位置。

|   |令牌身份验证是默认的身份验证方法。<br/>如果令牌被公开，则非预期的一方获得对 Vault 的访问权限，并可以为预期的客户端访问机密。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

示例 6.application.yml

```
spring.cloud.vault:
    authentication: TOKEN
    token: 00000000-0000-0000-0000-000000000000
```

* `authentication`将该值设置为`TOKEN`选择令牌身份验证方法

* `token`设置要使用的静态令牌。如果丢失或为空，则将尝试从 \~/.vault-token 检索令牌。

另见：

* [保险库文档：令牌](https://www.vaultproject.io/docs/concepts/tokens.html)

* [保险库文档：CLI 登录](https://www.vaultproject.io/docs/commands/login)

* [Vault 文档：CLI 默认为 \~/.vault-token](https://www.vaultproject.io/docs/commands/token-helper)

### [](#vault.config.authentication.vault-agent)[5.2.保险库代理身份验证](#vault.config.authentication.vault-agent)

Vault 自 0.11.0 版本以来，通过 Vault Agent 提供了一个 Sidecar 实用程序。Vault Agent 通过其自动验证功能实现了 Spring Vault 的`SessionManager`的功能。应用程序可以依赖运行在`localhost`上的 Vault 代理重用缓存的会话凭据。 Spring Vault 可以在没有`X-Vault-Token`头的情况下发送请求。禁用 Spring Vault 的身份验证基础设施，以禁用客户端身份验证和会话管理。

示例 7.application.yml

```
spring.cloud.vault:
    authentication: NONE
```

* `authentication`将该值设置为`NONE`将禁用`ClientAuthentication`和`SessionManager`。

另见：[保险库文档：代理](https://www.vaultproject.io/docs/agent/index.html)

### [](#vault.config.authentication.appid)[5.3.APPID 身份验证](#vault.config.authentication.appid)

Vault 支持[AppId](https://www.vaultproject.io/docs/auth/app-id.html)身份验证，该验证由两个难以猜测的令牌组成。APPID 默认为静态配置的`spring.application.name`。第二个标记是 userid，它是由应用程序决定的一部分，通常与运行时环境相关。IP 地址、MAC 地址或 Docker 容器名称都是很好的例子。 Spring Cloud Vault Config 支持 IP 地址、MAC 地址和静态用户 ID（例如，通过系统属性提供）。IP 和 MAC 地址表示为十六进制编码的 SHA256 散列。

基于 IP 地址的用户 ID 使用本地主机的 IP 地址。

示例 8.使用 SHA256IP 地址 userid 的 application.yml

```
spring.cloud.vault:
    authentication: APPID
    app-id:
        user-id: IP_ADDRESS
```

* `authentication`将该值设置为`APPID`选择 APPID 身份验证方法

* `app-id-path`设置要使用的 appid 挂载的路径

* `user-id`设置 userid 方法。可能的值是`IP_ADDRESS`、`MAC_ADDRESS`或实现自定义`AppIdUserIdMechanism`的类名

从命令行生成 IP 地址 userid 的相应命令是：

```
$ echo -n 192.168.99.1 | sha256sum
```

|   |包含`echo`的换行符会导致不同的散列值，因此请确保包含`-n`标志。|
|---|---------------------------------------------------------------------------------------------------------|

基于 MAC 地址的用户 ID 从本地主机绑定的设备获得他们的网络设备。该配置还允许指定`network-interface`提示来选择正确的设备。`network-interface`的值是可选的，可以是接口名称或接口索引（基于 0）。

示例 9.使用 SHA256MAC-Address Userid 的 application.yml

```
spring.cloud.vault:
    authentication: APPID
    app-id:
        user-id: MAC_ADDRESS
        network-interface: eth0
```

* `network-interface`设置网络接口以获取物理地址

从命令行生成 IP 地址 userid 的相应命令是：

```
$ echo -n 0AFEDE1234AC | sha256sum
```

|   |MAC 地址是大写的，不带冒号。<br/>包括`echo`的换行将导致不同的散列值，因此请确保包含`-n`标志。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

#### [](#custom-userid)[5.3.1.自定义用户 ID](#custom-userid)

用户 ID 生成是一种开放机制。你可以将`spring.cloud.vault.app-id.user-id`设置为任意字符串，并且配置的值将用作静态用户 ID。

一种更高级的方法允许你将`spring.cloud.vault.app-id.user-id`设置为类名。这个类必须位于你的 Classpath 上，并且必须实现`org.springframework.cloud.vault.AppIdUserIdMechanism`接口和`createUserId`方法。 Spring Cloud Vault 将在每次使用 APPID 进行身份验证以获得令牌时通过调用来获得用户 ID。

示例 10.application.yml

```
spring.cloud.vault:
    authentication: APPID
    app-id:
        user-id: com.examlple.MyUserIdMechanism
```

例 11。MyuseridMechanism.java

```
public class MyUserIdMechanism implements AppIdUserIdMechanism {

  @Override
  public String createUserId() {
    String userId = ...
    return userId;
  }
}
```

另见：[Vault 文档：使用应用程序 ID Auth 后台](https://www.vaultproject.io/docs/auth/app-id.html)

### [](#approle-authentication)[5.4.Approle 身份验证](#approle-authentication)

[AppRole](https://www.vaultproject.io/docs/auth/app-id.html)用于机器身份验证，就像不推荐的（因为 Vault0.6.1）[APPID 身份验证](#vault.config.authentication.appid)一样。Approle 身份验证由两个难以猜测的（秘密）令牌组成：ROLEID 和 SECTROTID。

Spring Vault 支持各种接近场景（推/拉模式和包装）。

ROLEID 和可选的 SecretID 必须通过配置提供， Spring Vault 不会查找这些或创建自定义的 SecretID。

示例 12.approle 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: APPROLE
    app-role:
        role-id: bde2076b-cccb-3cf0-d57e-bca7b1e83a52
```

根据所需的配置细节，支持以下场景：

|**方法**|**RoleId**|**SecretId**|**RoleName**|**Token**|
|---------------------------------|----------|------------|------------|---------|
|提供了 ROLEID/SECTRID| Provided |  Provided  |            |         |
|提供不带分泌物的轮状结构| Provided |            |            |         |
|提供 Roleid，pull secretid| Provided |  Provided  |  Provided  |Provided |
|拉 Roleid，提供秘密|          |  Provided  |  Provided  |Provided |
|全拉模式|          |            |  Provided  |Provided |
|包装|          |            |            |Provided |
|包裹罗雷德，提供秘密| Provided |            |            |Provided |
|提供保鲜膜，包装保鲜膜|          |  Provided  |            |Provided |

|**RoleId**|**SecretId**|**支持**|
|----------|------------|-------------|
| Provided |  Provided  |✅|
| Provided |    Pull    |✅|
| Provided |  Wrapped   |✅|
| Provided |   Absent   |✅|
|   Pull   |  Provided  |✅|
|   Pull   |    Pull    |✅|
|   Pull   |  Wrapped   |❌|
|   Pull   |   Absent   |❌|
| Wrapped  |  Provided  |✅|
| Wrapped  |    Pull    |❌|
| Wrapped  |  Wrapped   |✅|
| Wrapped  |   Absent   |❌|

|   |通过在上下文中提供已配置的`AppRoleAuthentication` Bean，仍然可以使用推/拉/包装模式的所有组合。<br/> Spring Cloud Vault 无法从配置属性中派生出所有可能的近似组合。|
|---|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|   |Approle 身份验证仅限于使用反应性基础设施的简单 pull 模式。<br/>尚未支持完全 pull 模式。<br/>使用 Spring Cloud Vault 和 Spring WebFlux 堆栈，可以通过设置`spring.cloud.vault.reactive.enabled=false`禁用 Vault 的反应性自动配置。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

示例 13.application.yml 与所有 approle 身份验证属性

```
spring.cloud.vault:
    authentication: APPROLE
    app-role:
        role-id: bde2076b-cccb-3cf0-d57e-bca7b1e83a52
        secret-id: 1696536f-1976-73b1-b241-0b4213908d39
        role: my-role
        app-role-path: approle
```

* `role-id`设置 ROLEID。

* `secret-id`设置分泌物。如果配置了 approle 而不需要 secretid，则可以省略 secretid（参见`bind_secret_id`）。

* `role`:设置 pull 模式的 approle 名称。

* `app-role-path`设置要使用的 approle 身份验证挂载的路径。

另见：[Vault 文档：使用 Approle Auth 后端](https://www.vaultproject.io/docs/auth/approle.html)

### [](#vault.config.authentication.awsec2)[5.5.AWS-EC2 身份验证](#vault.config.authentication.awsec2)

[aws-ec2](https://www.vaultproject.io/docs/auth/aws-ec2.html)Auth 后端为 AWS EC2 实例提供了一种安全的引入机制，允许自动检索保险库令牌。与大多数 Vault 身份验证后端不同，该后端不需要首次部署或提供安全敏感的凭据（令牌、用户名/密码、客户端证书等）。相反，它将 AWS 视为受信任的第三方，并使用以密码签名的动态元数据信息来唯一地表示每个 EC2 实例。

示例 14.使用 AWS-EC2 身份验证的 application.yml

```
spring.cloud.vault:
    authentication: AWS_EC2
```

在默认情况下，AWS-EC2 身份验证使 Nonce 能够遵循信任第一次使用（Tofu）原则。任何意外获得 PKCS#7 身份元数据访问权限的一方都可以对 Vault 进行身份验证。

在第一次登录期间， Spring Cloud Vault 生成一个 nonce，该 nonce 存储在实例 ID 旁边的 auth 后台。重新验证需要发送相同的 nonce。其他任何一方都没有 Nonce，可以在 Vault 中发出警报，以进行进一步的调查。

nonce 保存在内存中，并在应用程序重新启动时丢失。可以使用`spring.cloud.vault.aws-ec2.nonce`配置静态 nonce。

AWS-EC2 身份验证角色是可选的，并且是 AMI 的默认值。你可以通过设置`spring.cloud.vault.aws-ec2.role`属性来配置身份验证角色。

示例 15.已配置角色的 application.yml

```
spring.cloud.vault:
    authentication: AWS_EC2
    aws-ec2:
        role: application-server
```

示例 16.具有所有 AWS EC2 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: AWS_EC2
    aws-ec2:
        role: application-server
        aws-ec2-path: aws-ec2
        identity-document: http://...
        nonce: my-static-nonce
```

* `authentication`将该值设置为`AWS_EC2`选择 AWS EC2 身份验证方法

* `role`设置试图登录的角色的名称。

* `aws-ec2-path`设置要使用的 AWS EC2 挂载的路径

* `identity-document`设置 PKCS#7AWS EC2 身份文档的 URL

* `nonce`用于 AWS-EC2 身份验证。空的 nonce 默认为 nonce 生成

另见：[Vault 文档：使用 AWS Auth 后端](https://www.vaultproject.io/docs/auth/aws.html)

### [](#vault.config.authentication.awsiam)[5.6.AWS-IAM 身份验证](#vault.config.authentication.awsiam)

[aws](https://www.vaultproject.io/docs/auth/aws-ec2.html)后端为 AWS IAM 角色提供了一种安全的身份验证机制，允许基于正在运行的应用程序的当前 IAM 角色使用 Vault 进行自动身份验证。与大多数 Vault 身份验证后端不同，该后端不需要首次部署或提供安全敏感的凭据（令牌、用户名/密码、客户端证书等）。相反，它将 AWS 视为受信任的第三方，并使用调用者与其 IAM 凭据签署的 4 条信息来验证调用者确实在使用该 IAM 角色。

自动计算应用程序正在运行的当前 IAM 角色。如果你在 AWS ECS 上运行你的应用程序，那么应用程序将使用分配给正在运行的容器的 ECS 任务的 IAM 角色。如果你在 EC2 实例之上裸体运行你的应用程序，那么使用的 IAM 角色将是分配给 EC2 实例的角色。

当使用 AWS-IAM 身份验证时，你必须在 Vault 中创建一个角色，并将其分配给你的 IAM 角色。一个空的`role`默认为友好名称当前 IAM 角色。

示例 17.application.yml 具有所需的 AWS-IAM 身份验证属性

```
spring.cloud.vault:
    authentication: AWS_IAM
```

示例 18.具有所有 AWS-IAM 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: AWS_IAM
    aws-iam:
        role: my-dev-role
        aws-path: aws
        server-name: some.server.name
        endpoint-uri: https://sts.eu-central-1.amazonaws.com
```

* `role`设置试图登录的角色的名称。这应该与你的 IAM 角色绑定在一起。如果没有提供，那么将使用当前 IAM 用户的友好名称作为 Vault 角色。

* `aws-path`设置要使用的 AWS 挂载的路径

* `server-name`设置用于`X-Vault-AWS-IAM-Server-ID`头部的值，以防止某些类型的重播攻击。

* `endpoint-uri`设置用于`iam_request_url`参数的 AWS STS API 的值。

AWS-IAM 需要 AWS Java SDK 依赖项（`com.amazonaws:aws-java-sdk-core`），因为身份验证实现使用 AWS SDK 类型来进行凭据和请求签名。

另见：[Vault 文档：使用 AWS Auth 后端](https://www.vaultproject.io/docs/auth/aws.html)

### [](#vault.config.authentication.azuremsi)[5.7.Azure MSI 认证](#vault.config.authentication.azuremsi)

[azure](https://www.vaultproject.io/docs/auth/azure.html)Auth 后端为 Azure VM 实例提供了一种安全的引入机制，允许自动检索 Vault 令牌。与大多数 Vault 身份验证后端不同，该后端不需要首次部署或提供安全敏感的凭据（令牌、用户名/密码、客户端证书等）。相反，它将 Azure 视为可信任的第三方，并使用可绑定到 VM 实例的托管服务标识和实例元数据信息。

示例 19.application.yml 与所需的 Azure 身份验证属性

```
spring.cloud.vault:
    authentication: AZURE_MSI
    azure-msi:
        role: my-dev-role
```

示例 20.带有所有 Azure 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: AZURE_MSI
    azure-msi:
        role: my-dev-role
        azure-path: azure
        metadata-service: http://169.254.169.254/metadata/instance…
        identity-token-service: http://169.254.169.254/metadata/identity…
```

* `role`设置试图登录的角色的名称。

* `azure-path`设置要使用的 Azure mount 的路径

* `metadata-service`设置访问实例元数据服务的 URI

* `identity-token-service`设置访问身份令牌服务的 URI

Azure MSI 身份验证从实例元数据服务获得有关虚拟机的环境详细信息（订阅 ID、资源组、VM 名称）。Vault 服务器的资源 ID 默认为`[vault.hashicorp.com](https://vault.hashicorp.com)`。要改变这一点，请相应地设置`spring.cloud.vault.azure-msi.identity-token-service`。

另见：

* [Vault 文档：使用 Azure Auth 后台](https://www.vaultproject.io/docs/auth/azure.html)

* [Azure 文档：Azure 实例元数据服务](https://docs.microsoft.com/en-us/azure/virtual-machines/windows/instance-metadata-service)

### [](#vault.config.authentication.clientcert)[5.8.TLS 证书认证](#vault.config.authentication.clientcert)

`cert`Auth 后台允许使用 SSL/TLS 客户机证书进行身份验证，这些证书由 CA 签名或自签名。

要启用`cert`身份验证，你需要：

1. 使用 SSL，参见[Vault 客户端 SSL 配置](#vault.config.ssl)

2. 配置包含客户端证书和私钥的 Java`Keystore`

3. 将`spring.cloud.vault.authentication`设置为`CERT`

示例 21.application.yml

```
spring.cloud.vault:
    authentication: CERT
    ssl:
        key-store: classpath:keystore.jks
        key-store-password: changeit
        key-store-type: JKS
        cert-auth-path: cert
```

另见：[Vault 文档：使用 CERTAuth 后端](https://www.vaultproject.io/docs/auth/cert.html)

### [](#vault.config.authentication.cubbyhole)[5.9.空穴身份验证](#vault.config.authentication.cubbyhole)

Cubbyhole 身份验证使用 Vault 原语来提供一个安全的身份验证工作流。Cubbyhole 身份验证使用令牌作为主要登录方法。一个短暂的令牌用于从 Vault 的 Cubbyhole 秘密后端获得第二个登录 VaultToken。登录令牌通常寿命更长，并用于与 Vault 交互。登录令牌将从存储在`/cubbyhole/response`的包装响应中检索。

**创建一个包装好的令牌**

|   |令牌创建的响应包装需要 Vault0.6.0 或更高版本。|
|---|--------------------------------------------------------------------|

例 22。创建和存储令牌

```
$ vault token-create -wrap-ttl="10m"
Key                            Value
---                            -----
wrapping_token:                397ccb93-ff6c-b17b-9389-380b01ca2645
wrapping_token_ttl:            0h10m0s
wrapping_token_creation_time:  2016-09-18 20:29:48.652957077 +0200 CEST
wrapped_accessor:              46b6aebb-187f-932a-26d7-4f3d86a68319
```

示例 23.application.yml

```
spring.cloud.vault:
    authentication: CUBBYHOLE
    token: 397ccb93-ff6c-b17b-9389-380b01ca2645
```

另见：

* [保险库文档：令牌](https://www.vaultproject.io/docs/concepts/tokens.html)

* [Vault 文档：Cubbyhole 秘密后端](https://www.vaultproject.io/docs/secrets/cubbyhole/index.html)

* [保险库文档：响应包装](https://www.vaultproject.io/docs/concepts/response-wrapping.html)

### [](#vault.config.authentication.gcpgce)[5.10.GCP-GCE 认证](#vault.config.authentication.gcpgce)

[gcp](https://www.vaultproject.io/docs/auth/gcp.html)Auth 后端允许 Vault 通过使用现有的 GCP（Google Cloud Platform）IAM 和 GCE 凭据登录。

GCPGCE（Google Compute Engine，Google Compute Engine）身份验证以 JSON Web 令牌的形式为服务帐户创建签名。使用[实例标识](https://cloud.google.com/compute/docs/instances/verifying-instance-identity)从 GCE 元数据服务获得计算引擎实例的 JWT。该 API 创建了一个 JSON Web 令牌，该令牌可用于确认实例标识。

与大多数 Vault 身份验证后端不同，该后端不需要首次部署或提供安全敏感的凭据（令牌、用户名/密码、客户端证书等）。相反，它将 GCP 视为受信任的第三方，并使用加密签名的动态元数据信息，该信息唯一地表示每个 GCP 服务帐户。

示例 24.application.yml 与所需的 GCP-gce 身份验证属性

```
spring.cloud.vault:
    authentication: GCP_GCE
    gcp-gce:
        role: my-dev-role
```

示例 25.具有所有 GCP-GCE 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: GCP_GCE
    gcp-gce:
        gcp-path: gcp
        role: my-dev-role
        service-account: [email protected]
```

* `role`设置试图登录的角色的名称。

* `gcp-path`设置要使用的 GCP 挂载的路径

* `service-account`允许将服务帐户 ID 重写为特定值。默认设置为`default`服务帐户。

另见：

* [Vault 文档：使用 GCPAuth 后端](https://www.vaultproject.io/docs/auth/gcp.html)

* [GCP 文件：验证实例的身份](https://cloud.google.com/compute/docs/instances/verifying-instance-identity)

### [](#vault.config.authentication.gcpiam)[5.11.GCP-IAM 认证](#vault.config.authentication.gcpiam)

[gcp](https://www.vaultproject.io/docs/auth/gcp.html)Auth 后端允许 Vault 通过使用现有的 GCP（Google Cloud Platform）IAM 和 GCE 凭据登录。

GCP，IAM 身份验证以 JSON Web 令牌的形式为服务帐户创建签名。通过调用 GCPIAM 的[`projects.serviceAccounts.signJwt`]（https://cloud.google.com/iam/reference/rest/v1/projects.serviceaccounts/signjwt）API，可以获得服务帐户的 JWT。调用者针对 GCPIAM 进行身份验证，并由此证明其身份。此保险库后端将 GCP 视为受信任的第三方。

IAM 凭据可以从运行时环境，特别是[`GOOGLE_APPLICATION_CREDENTIALS`]（https://cloud.google.com/DOCS/Authentication/Production）环境变量、Google Compute 元数据服务中获得，或者从外部提供，例如 JSON 或 base64 编码。JSON 是首选的表单，因为它带有调用`projects.serviceAccounts.signJwt`所需的项目 ID 和服务帐户标识符。

示例 26.带有所需 GCP 的 application.yml-IAM 身份验证属性

```
spring.cloud.vault:
    authentication: GCP_IAM
    gcp-iam:
        role: my-dev-role
```

示例 27.具有所有 GCP-IAM 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: GCP_IAM
    gcp-iam:
        credentials:
            location: classpath:credentials.json
            encoded-key: e+KApn0=
        gcp-path: gcp
        jwt-validity: 15m
        project-id: my-project-id
        role: my-dev-role
        service-account-id: [email protected]
```

* `role`设置试图登录的角色的名称。

* `credentials.location`到包含 JSON 格式的 Google 凭据的凭据资源的路径。

* `credentials.encoded-key`以 JSON 格式编码的 OAuth2 帐户私钥的 base64 编码内容。

* `gcp-path`设置要使用的 GCP 挂载的路径

* `jwt-validity`配置 JWT 令牌有效性。默认值为 15 分钟。

* `project-id`允许将项目 ID 重写为特定值。从获得的凭据中获得的项目 ID 的默认值。

* `service-account`允许将服务帐户 ID 重写为特定值。从获得的凭据到服务帐户的默认值。

GCPIAM 身份验证需要 Google Cloud Java SDK 依赖项（`com.google.apis:google-api-services-iam`和`com.google.auth:google-auth-library-oauth2-http`），因为身份验证实现使用 Google API 进行凭据和 JWT 签名。

|   |Google 凭据需要一个 OAuth2 令牌来维护令牌生命周期。<br/>所有 API 都是同步的，因此，`GcpIamAuthentication`不支持反应性使用所需的`AuthenticationSteps`。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

另见：

* [Vault 文档：使用 GCPAuth 后端](https://www.vaultproject.io/docs/auth/gcp.html)

* [GCP 文档：projects.serviceaccounts.signjwt](https://cloud.google.com/iam/reference/rest/v1/projects.serviceAccounts/signJwt)

### [](#vault.config.authentication.kubernetes)[5.12.Kubernetes 认证](#vault.config.authentication.kubernetes)

Kubernetes 身份验证机制（从 Vault0.8.3 开始）允许使用 Kubernetes 服务帐户令牌对 Vault 进行身份验证。身份验证是基于角色的，角色绑定到服务帐户名和名称空间。

包含 POD 服务帐户的 JWT 令牌的文件将自动挂载在`/var/run/secrets/kubernetes.io/serviceaccount/token`。

示例 28.具有所有 Kubernetes 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: KUBERNETES
    kubernetes:
        role: my-dev-role
        kubernetes-path: kubernetes
        service-account-token-file: /var/run/secrets/kubernetes.io/serviceaccount/token
```

* `role`设置角色。

* `kubernetes-path`设置要使用的 Kubernetes 挂载的路径。

* `service-account-token-file`设置包含 Kubernetes 服务帐户令牌的文件的位置。默认值为`/var/run/secrets/kubernetes.io/serviceaccount/token`。

另见：

* [保险库文档：Kubernetes](https://www.vaultproject.io/docs/auth/kubernetes.html)

* [Kubernetes 文档：为 PODS 配置服务帐户](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/)

### [](#vault.config.authentication.pcf)[5.13.Pivotal CloudFoundry 认证](#vault.config.authentication.pcf)

[pcf](https://www.vaultproject.io/docs/auth/pcf.html)Auth 后端为在 Pivotal 的 CloudFoundry 实例中运行的应用程序提供了一种安全的引入机制，允许自动检索保险库令牌。与大多数 Vault 身份验证后端不同，该后端不需要首次部署或配置安全敏感凭据（令牌、用户名/密码、客户端证书等），因为身份配置由 PCF 本身处理。相反，它将 PCF 视为受信任的第三方，并使用托管实例标识。

示例 29.带有必需的 PCF 身份验证属性的 application.yml

```
spring.cloud.vault:
    authentication: PCF
    pcf:
        role: my-dev-role
```

示例 30.application.yml 具有所有 PCF 身份验证属性

```
spring.cloud.vault:
    authentication: PCF
    pcf:
        role: my-dev-role
        pcf-path: path
        instance-certificate: /etc/cf-instance-credentials/instance.crt
        instance-key: /etc/cf-instance-credentials/instance.key
```

* `role`设置试图登录的角色的名称。

* `pcf-path`设置要使用的 PCF 挂载的路径。

* `instance-certificate`设置到 PCF 实例身份证书的路径。默认值为`${CF_INSTANCE_CERT}`ENV 变量。

* `instance-key`设置到 PCF 实例标识密钥的路径。默认值为`${CF_INSTANCE_KEY}`ENV 变量。

|   |PCF 身份验证要求 BouncyCastle（BCPKIX-JDK15on）在 Classpath 上进行 RSA PSS 签名。|
|---|-----------------------------------------------------------------------------------------------------|

另见：[Vault 文档：使用 PCF Auth 后端](https://www.vaultproject.io/docs/auth/pcf.html)

## [](#vault.config.acl)[6.ACL 要求](#vault.config.acl)

本节将解释 Spring Vault 访问哪些路径，以便你可以从所需的功能派生出你的策略声明。

|Capability|关联的 HTTP 动词|
|----------|---------------------|
|  create  |`POST`/`PUT`|
|   read   |`GET`|
|  update  |`POST`/`PUT`|
|  delete  |`DELETE`|
|   list   |`LIST`(`GET`)|

另见[WWW.vaultproject.io/guides/identity/policies](https://www.vaultproject.io/guides/identity/policies)。

### [](#authentication-2)[6.1.认证](#authentication-2)

登录：`POST auth/$authMethod/login`

### [](#keyvalue-mount-discovery)[6.2.KeyValue Mount 发现](#keyvalue-mount-discovery)

`GET sys/internal/ui/mounts/$mountPath`

### [](#secretleasecontainer)[6.3.分泌物酶抑制剂](#secretleasecontainer)

`SecretLeaseContainer`根据配置的租赁端点使用不同的路径。

`LeaseEndpoints.Legacy`

* 撤销：`PUT sys/revoke`

* 续约：`PUT sys/renew`

`LeaseEndpoints.Leases`(`SysLeases`)

* 撤销：`PUT sys/leases/revoke`

* 续约：`PUT sys/leases/renew`

### [](#session-management)[6.4.会话管理](#session-management)

* 令牌查找：`GET auth/token/lookup-self`

* 续约：`POST auth/token/renew-self`

* 撤销：`POST auth/token/revoke-self`

## [](#vault.config.backends)[7.秘密后端](#vault.config.backends)

### [](#vault.config.backends.kv.versioned)[7.1.键值后端](#vault.config.backends.kv.versioned)

Spring Cloud Vault 支持两个键值秘密后端，即版本控制的（V2）和非版本控制的（V1）。键值后端允许将任意值存储为键值存储。单个上下文可以存储一个或多个键值元组。上下文可以按层次进行组织。 Spring Cloud Vault 确定一个秘密是否正在使用版本控制，并将路径映射到其适当的 URL。 Spring Cloud Vault 允许使用应用程序名称，并将默认的上下文名（`application`）与活动配置文件结合起来。

```
/secret/{application}/{profile}
/secret/{application}
/secret/{default-context}/{profile}
/secret/{default-context}
```

应用程序名称由属性决定：

* `spring.cloud.vault.kv.application-name`

* `spring.cloud.vault.application-name`

* `spring.application.name`

配置文件是由属性决定的：

* `spring.cloud.vault.kv.profiles`

* `spring.profiles.active`

秘密可以从键值后端的其他上下文中获得，方法是将它们的路径添加到应用程序名称中，并用逗号分隔。例如，给定应用程序名`usefulapp,mysql1,projectx/aws`，将使用这些文件夹中的每个文件夹：

* `/secret/usefulapp`

* `/secret/mysql1`

* `/secret/projectx/aws`

Spring Cloud Vault 将所有活动配置文件添加到可能的上下文路径列表中。任何活动配置文件都不会跳过使用配置文件名称访问上下文。

属性像存储一样公开（即没有额外的前缀）。

|   |Spring Cloud Vault 在挂载路径和实际上下文路径之间添加`data/`上下文，这取决于挂载是否使用版本控制的键值后端。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|

```
spring.cloud.vault:
    kv:
        enabled: true
        backend: secret
        profile-separator: '/'
        default-context: application
        application-name: my-app
        profiles: local, cloud
```

* `enabled`将该值设置为`false`将禁用秘密后台配置使用

* `backend`设置要使用的秘密挂载的路径

* `default-context`设置所有应用程序使用的上下文名

* `application-name`覆盖在键值后端中使用的应用程序名

* `profiles`覆盖在键值后端中使用的活动配置文件

* `profile-separator`在具有配置文件的属性源中将配置文件名与上下文分隔开

|   |键值秘密后端可以在版本控制（V2）和非版本控制（V1）模式下进行操作。|
|---|--------------------------------------------------------------------------------------------|

另见：

* [Vault 文档：使用 KV Secrets 引擎-Version1（通用秘密后端）](https://www.vaultproject.io/docs/secrets/kv/kv-v1.html)

* [Vault 文档：使用 KV Secrets 引擎-Version2（版本管理的键值后端）](https://www.vaultproject.io/docs/secrets/kv/kv-v2.html)

### [](#vault.config.backends.consul)[7.2.执政官](#vault.config.backends.consul)

Spring Cloud保险库可以获得用于 HashiCorp 领事的凭据。Consul 集成要求`spring-cloud-vault-config-consul`依赖关系。

例 31。 POM.xml

```
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-vault-config-consul</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>
```

可以通过设置`spring.cloud.vault.consul.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.consul.role=…`的角色名来启用集成。

所获得的令牌存储在`spring.cloud.consul.token`中，因此使用 Spring Cloud Consul 可以在不需要进一步配置的情况下获取生成的凭据。你可以通过设置`spring.cloud.vault.consul.token-property`来配置属性名称。

```
spring.cloud.vault:
    consul:
        enabled: true
        role: readonly
        backend: consul
        token-property: spring.cloud.consul.token
```

* `enabled`将该值设置为`true`可启用 Consul 后台配置使用

* `role`设置 consul 角色定义的角色名

* `backend`设置要使用的执政架的路径

* `token-property`设置用于存储 consul ACL 令牌的属性名称

另见：[保险库文档：与保险库建立领事关系](https://www.vaultproject.io/docs/secrets/consul/index.html)

### [](#vault.config.backends.rabbitmq)[7.3.RabbitMQ](#vault.config.backends.rabbitmq)

Spring Cloud Vault 可以获得 RabbitMQ 的凭据。

RabbitMQ 集成需要`spring-cloud-vault-config-rabbitmq`依赖项。

例 32。 POM.xml

```
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-vault-config-rabbitmq</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>
```

可以通过设置`spring.cloud.vault.rabbitmq.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.rabbitmq.role=…`的角色名来启用集成。

用户名和密码存储在`spring.rabbitmq.username`和`spring.rabbitmq.password`中，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。你可以通过设置`spring.cloud.vault.rabbitmq.username-property`和`spring.cloud.vault.rabbitmq.password-property`来配置属性名称。

```
spring.cloud.vault:
    rabbitmq:
        enabled: true
        role: readonly
        backend: rabbitmq
        username-property: spring.rabbitmq.username
        password-property: spring.rabbitmq.password
```

* `enabled`将该值设置为`true`可启用 RabbitMQ 后台配置使用

* `role`设置 RabbitMQ 角色定义的角色名

* `backend`设置要使用的 RabbitMQ 挂载的路径

* `username-property`设置存储 RabbitMQ 用户名的属性名

* `password-property`设置存储 RabbitMQ 密码的属性名

另见：[Vault 文档：使用 Vault 设置 RabbitMQ](https://www.vaultproject.io/docs/secrets/rabbitmq/index.html)

### [](#vault.config.backends.aws)[7.4. AWS](#vault.config.backends.aws)

Spring Cloud Vault 可以获得 AWS 的凭据。

AWS 集成需要`spring-cloud-vault-config-aws`依赖关系。

例 33。 POM.xml

```
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-vault-config-aws</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>
```

可以通过设置`spring.cloud.vault.aws=true`（默认`false`）并提供带有`spring.cloud.vault.aws.role=…`的角色名来启用集成。

支持的 AWS 凭据类型：

* iam\_user（默认）

* 假定 \_role

* Federation\_Token

访问密钥和密钥存储在`cloud.aws.credentials.accessKey`和`cloud.aws.credentials.secretKey`中。因此，使用 Spring Cloud AWS 将在不需要进一步配置的情况下获取生成的凭据。

可以通过设置`spring.cloud.vault.aws.access-key-property`和`spring.cloud.vault.aws.secret-key-property`来配置属性名。

对于 STS 安全令牌，你可以通过设置`spring.cloud.vault.aws.session-token-key-property`来配置属性名。安全令牌存储在`cloud.aws.credentials.sessionToken`（默认）下。

示例：iam\_user

```
spring.cloud.vault:
    aws:
        enabled: true
        role: readonly
        backend: aws
        access-key-property: cloud.aws.credentials.accessKey
        secret-key-property: cloud.aws.credentials.secretKey
```

示例：假定 \_role

```
spring.cloud.vault:
    aws:
        enabled: true
        role: sts-vault-role
        backend: aws
        credential-type: assumed_role
        access-key-property: cloud.aws.credentials.accessKey
        secret-key-property: cloud.aws.credentials.secretKey
        session-token-key-property: cloud.aws.credentials.sessionToken
        ttl: 3600s
        role-arn: arn:aws:iam::${AWS_ACCOUNT}:role/sts-app-role
```

* `enabled`将该值设置为`true`可启用 AWS 后台配置使用

* `role`设置 AWS 角色定义的角色名

* `backend`设置要使用的 AWS 挂载的路径

* `access-key-property`设置用于存储 AWS 访问密钥的属性名

* `secret-key-property`设置用于存储 AWS 密钥的属性名

* `session-token-key-property`设置用于存储 AWS STS 安全令牌的属性名称。

* `credential-type`设置用于此后端的 AWS 凭据类型。默认值为`iam_user`

* 当使用`assumed_role`或`federation_token`时，`ttl`设置 STS 令牌的 TTL。Vault 角色指定的 TTL 的默认值。最小/最大值也仅限于 AWS 对 STS 的支持。

* `role-arn`设置 IAM 角色，以假设在使用`assumed_role`时，为 Vault 角色配置了多个 IAM 角色。

另见：[Vault 文档：使用 Vault 设置 AWS](https://www.vaultproject.io/docs/secrets/aws/index.html)

## [](#vault.config.backends.database-backends)[8.数据库后端](#vault.config.backends.database-backends)

Vault 支持多个数据库秘密后端，以根据配置的角色动态生成数据库凭据。这意味着需要访问数据库的服务不再需要配置凭据：它们可以从 Vault 请求凭据，并使用 Vault 的租赁机制更容易地滚动密钥。

Spring Cloud Vault 与这些后端集成：

* [Database](#vault.config.backends.database)

* [Apache Cassandra](#vault.config.backends.cassandra)

* [CouchBase 数据库](#vault.config.backends.couchbase)

* [Elasticsearch](#vault.config.backends.elasticsearch)

* [MongoDB](#vault.config.backends.mongodb)

* [MySQL](#vault.config.backends.mysql)

* [PostgreSQL](#vault.config.backends.postgresql)

使用数据库秘密后台需要在配置中启用后台和`spring-cloud-vault-config-databases`依赖关系。

Vault 从 0.7.1 开始提供专用的`database`秘密后端，允许通过插件进行数据库集成。你可以通过使用通用数据库后端来使用该特定的后端。确保指定适当的后端路径，例如`spring.cloud.vault.mysql.role.backend=database`。

例 34。 POM.xml

```
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-vault-config-databases</artifactId>
        <version>3.1.0</version>
    </dependency>
</dependencies>
```

|   |启用多个符合 JDBC 的数据库将生成凭据，并在默认情况下将它们存储在相同的属性键中，因此需要单独配置 JDBC 秘密的属性名。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### [](#vault.config.backends.database)[8.1.数据库](#vault.config.backends.database)

Spring Cloud Vault 可以获得在[WWW.vaultproject.io/api/secret/databases/index.html](https://www.vaultproject.io/api/secret/databases/index.html)处列出的任何数据库的凭据。可以通过设置`spring.cloud.vault.database.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.database.role=…`的角色名来启用集成。

虽然数据库后端是通用的，但`spring.cloud.vault.database`专门针对 JDBC 数据库。用户名和密码可从`spring.datasource.username`和`spring.datasource.password`属性中获得，因此使用 Spring 引导将为你的`DataSource`获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.database.username-property`和`spring.cloud.vault.database.password-property`来配置属性名称。

```
spring.cloud.vault:
    database:
        enabled: true
        role: readonly
        backend: database
        username-property: spring.datasource.username
        password-property: spring.datasource.password
```

### [](#vault.config.backends.databases)[8.2.多个数据库](#vault.config.backends.databases)

有时，单个数据库的凭据是不够的，因为一个应用程序可能会连接到两个或更多个同类数据库。从版本 3.0.5 开始， Spring Vault 支持在`spring.cloud.vault.databases.*`名称空间下配置多个数据库秘密后端。

配置接受多个数据库后端，以将凭据具体化到指定的属性中。确保适当地配置`username-property`和`password-property`。

```
spring.cloud.vault:
    databases:
        primary:
            enabled: true
            role: readwrite
            backend: database
            username-property: spring.primary-datasource.username
            password-property: spring.primary-datasource.password
        other-database:
            enabled: true
            role: readonly
            backend: database
            username-property: spring.secondary-datasource.username
            password-property: spring.secondary-datasource.password
```

* `<name>`数据库配置的描述性名称。

* `<name>.enabled`将该值设置为`true`可启用数据库后台配置使用

* `<name>.role`设置数据库角色定义的角色名

* `<name>.backend`设置要使用的数据库挂载的路径

* `<name>.username-property`设置存储数据库用户名的属性名。确保使用唯一的属性名称，以避免属性跟踪。

* `<name>.password-property`设置存储数据库密码的属性名称，确保使用唯一的属性名称，以避免属性跟踪。

另见：[保险库文档：数据库秘密后端](https://www.vaultproject.io/docs/secrets/databases/index.html)

|   |Spring Cloud Vault 不支持在达到最大租赁时间时获取新的凭据并用它们配置你的`DataSource`。<br/>即，如果 Vault 中数据库角色的`max_ttl`被设置为`24h`，这意味着在你的应用程序启动 24 小时后，它将不再能够使用数据库进行身份验证。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

### [](#vault.config.backends.cassandra)[8.3.Apache Cassandra](#vault.config.backends.cassandra)

|   |`cassandra`后端在 Vault0.7.1 中已被弃用，建议使用`database`后端并将其挂载为`cassandra`。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------|

Spring Cloud Vault 可以获得 Apache Cassandra 的凭据。可以通过设置`spring.cloud.vault.cassandra.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.cassandra.role=…`的角色名来启用集成。

用户名和密码可从`spring.data.cassandra.username`和`spring.data.cassandra.password`属性中获得，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.cassandra.username-property`和`spring.cloud.vault.cassandra.password-property`来配置属性名称。

```
spring.cloud.vault:
    cassandra:
        enabled: true
        role: readonly
        backend: cassandra
        username-property: spring.data.cassandra.username
        password-property: spring.data.cassandra.password
```

* `enabled`将该值设置为`true`可启用 Cassandra 后台配置使用

* `role`设置 Cassandra 角色定义的角色名

* `backend`设置要使用的 Cassandra 坐骑的路径

* `username-property`设置存储 Cassandra 用户名的属性名

* `password-property`设置存储 Cassandra 密码的属性名

另见：[Vault 文档：使用 Vault 设置 Apache Cassandra](https://www.vaultproject.io/docs/secrets/cassandra/index.html)

### [](#vault.config.backends.couchbase)[8.4.CouchBase 数据库](#vault.config.backends.couchbase)

Spring Cloud Vault 可以获得 CouchBase 的凭据。可以通过设置`spring.cloud.vault.couchbase.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.couchbase.role=…`的角色名来启用集成。

用户名和密码可从`spring.couchbase.username`和`spring.couchbase.password`属性中获得，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.couchbase.username-property`和`spring.cloud.vault.couchbase.password-property`来配置属性名。

```
spring.cloud.vault:
    couchbase:
        enabled: true
        role: readonly
        backend: database
        username-property: spring.couchbase.username
        password-property: spring.couchbase.password
```

* `enabled`将该值设置为`true`可启用 CouchBase 后台配置使用

* `role`设置 Couchbase 角色定义的角色名

* `backend`设置要使用的 CouchBase 挂载的路径

* `username-property`设置存储 CouchBase 用户名的属性名

* `password-property`设置存储 Couchbase 密码的属性名

另见：[CouchBase 数据库插件文档](https://github.com/hashicorp/vault-plugin-database-couchbase)

### [](#vault.config.backends.elasticsearch)[8.5.Elasticsearch](#vault.config.backends.elasticsearch)

Spring Cloud Vault 可以获得自 3.0 版本以来用于 ElasticSearch 的凭据。可以通过设置`spring.cloud.vault.elasticsearch.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.elasticsearch.role=…`的角色名来启用集成。

用户名和密码可从`spring.elasticsearch.rest.username`和`spring.elasticsearch.rest.password`属性中获得，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.elasticsearch.username-property`和`spring.cloud.vault.elasticsearch.password-property`来配置属性名称。

```
spring.cloud.vault:
    elasticsearch:
        enabled: true
        role: readonly
        backend: mongodb
        username-property: spring.elasticsearch.rest.username
        password-property: spring.elasticsearch.rest.password
```

* `enabled`将该值设置为`true`可启用 ElasticSearch 数据库后台配置使用

* `role`设置 ElasticSearch 角色定义的角色名

* `backend`设置要使用的 ElasticSearch 挂载的路径

* `username-property`设置存储 ElasticSearch 用户名的属性名

* `password-property`设置存储 ElasticSearch 密码的属性名

另见：[Vault 文档：使用 Vault 设置 ElasticSearch](https://www.vaultproject.io/docs/secrets/databases/elasticdb)

### [](#vault.config.backends.mongodb)[8.6.MongoDB](#vault.config.backends.mongodb)

|   |`mongodb`后端在 Vault0.7.1 中已被弃用，建议使用`database`后端并将其挂载为`mongodb`。|
|---|---------------------------------------------------------------------------------------------------------------------------------------|

Spring Cloud Vault 可以获得 MongoDB 的凭据。可以通过设置`spring.cloud.vault.mongodb.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.mongodb.role=…`的角色名来启用集成。

用户名和密码存储在`spring.data.mongodb.username`和`spring.data.mongodb.password`中，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.mongodb.username-property`和`spring.cloud.vault.mongodb.password-property`来配置属性名。

```
spring.cloud.vault:
    mongodb:
        enabled: true
        role: readonly
        backend: mongodb
        username-property: spring.data.mongodb.username
        password-property: spring.data.mongodb.password
```

* `enabled`将该值设置为`true`可启用 MongoDB 后台配置使用

* `role`设置 MongoDB 角色定义的角色名

* `backend`设置要使用的 MongoDB mount 的路径

* `username-property`设置存储 MongoDB 用户名的属性名

* `password-property`设置存储 MongoDB 密码的属性名

另见：[Vault 文档：使用 Vault 建立 MongoDB](https://www.vaultproject.io/docs/secrets/mongodb/index.html)

### [](#vault.config.backends.mysql)[8.7. MySQL](#vault.config.backends.mysql)

|   |`mysql`后端在 Vault0.7.1 中已被弃用，建议使用`database`后端并将其挂载为`mysql`。<br/>`spring.cloud.vault.mysql`的配置将在未来的版本中删除。|
|---|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

Spring Cloud Vault 可以获得 MySQL 的凭据。可以通过设置`spring.cloud.vault.mysql.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.mysql.role=…`的角色名来启用集成。

用户名和密码可从`spring.datasource.username`和`spring.datasource.password`属性中获得，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.mysql.username-property`和`spring.cloud.vault.mysql.password-property`来配置属性名称。

```
spring.cloud.vault:
    mysql:
        enabled: true
        role: readonly
        backend: mysql
        username-property: spring.datasource.username
        password-property: spring.datasource.password
```

* `enabled`将该值设置为`true`可启用 MySQL 后台配置使用

* `role`设置 MySQL 角色定义的角色名

* `backend`设置要使用的 MySQL 挂载的路径

* `username-property`设置存储 MySQL 用户名的属性名

* `password-property`设置存储 MySQL 密码的属性名

另见：[Vault 文档：使用 Vault 设置 MySQL](https://www.vaultproject.io/docs/secrets/mysql/index.html)

### [](#vault.config.backends.postgresql)[8.8.PostgreSQL](#vault.config.backends.postgresql)

|   |`postgresql`后端在 Vault0.7.1 中已被弃用，建议使用`database`后端并将其挂载为`postgresql`。<br/>`spring.cloud.vault.postgresql`的配置将在未来的版本中删除。|
|---|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

Spring Cloud Vault 可以获得 PostgreSQL 的凭据。可以通过设置`spring.cloud.vault.postgresql.enabled=true`（默认`false`）并提供带有`spring.cloud.vault.postgresql.role=…`的角色名来启用集成。

用户名和密码可从`spring.datasource.username`和`spring.datasource.password`属性中获得，因此使用 Spring 引导将获取生成的凭据，而无需进一步配置。可以通过设置`spring.cloud.vault.postgresql.username-property`和`spring.cloud.vault.postgresql.password-property`来配置属性名称。

```
spring.cloud.vault:
    postgresql:
        enabled: true
        role: readonly
        backend: postgresql
        username-property: spring.datasource.username
        password-property: spring.datasource.password
```

* `enabled`将该值设置为`true`可启用 PostgreSQL 后台配置使用

* `role`设置 PostgreSQL 角色定义的角色名

* `backend`设置要使用的 PostgreSQL 挂载的路径

* `username-property`设置存储 PostgreSQL 用户名的属性名

* `password-property`设置存储 PostgreSQL 密码的属性名

另见：[Vault 文档：使用 Vault 设置 PostgreSQL](https://www.vaultproject.io/docs/secrets/postgresql/index.html)

## [](#vault.config.backends.configurer)[9.自定义要作为 PropertySource 公开的秘密后端](#vault.config.backends.configurer)

Spring Cloud Vault 使用基于属性的配置来为键值和已发现的秘密后台创建`PropertySource`s。

已发现的后端提供`VaultSecretBackendDescriptor`bean 来描述使用秘密后端的配置状态为`PropertySource`。需要一个`SecretBackendMetadataFactory`来创建一个`SecretBackendMetadata`对象，该对象包含路径、名称和属性转换配置。

`SecretBackendMetadata`用于支持特定的`PropertySource`。

你可以注册`VaultConfigurer`以进行定制。如果提供`VaultConfigurer`，则禁用默认的键值和已发现的后端注册。但是，你可以启用`SecretBackendConfigurer.registerDefaultKeyValueSecretBackends()`和`SecretBackendConfigurer.registerDefaultDiscoveredSecretBackends()`的默认注册。

```
public class CustomizationBean implements VaultConfigurer {

    @Override
    public void addSecretBackends(SecretBackendConfigurer configurer) {

        configurer.add("secret/my-application");

        configurer.registerDefaultKeyValueSecretBackends(false);
        configurer.registerDefaultDiscoveredSecretBackends(true);
    }
}
```

```
SpringApplication application = new SpringApplication(MyApplication.class);
application.addBootstrapper(VaultBootstrapper.fromConfigurer(new CustomizationBean()));
```

## [](#vault.config.backends.custom)[10.自定义秘密后端实现](#vault.config.backends.custom)

Spring Cloud Vault 为最常见的后端集成提供了秘密的后端支持。你可以通过提供一个实现来与任何类型的后端集成，该实现描述了如何从要使用的后端获取数据，以及如何通过提供`PropertyTransformer`来处理该后端提供的数据。

为后端添加自定义实现需要实现两个接口：

* `org.springframework.cloud.vault.config.VaultSecretBackendDescriptor`

* `org.springframework.cloud.vault.config.SecretBackendMetadataFactory`

`VaultSecretBackendDescriptor`通常是保存配置数据的对象，例如`VaultDatabaseProperties`。 Spring Cloud Vault 要求用`@ConfigurationProperties`对类型进行注释，以便从配置中实现类。

`SecretBackendMetadataFactory`接受`VaultSecretBackendDescriptor`以创建实际的`SecretBackendMetadata`对象，该对象保存 Vault 服务器内的上下文路径、解析参数化上下文路径所需的任何路径变量和`PropertyTransformer`。

`VaultSecretBackendDescriptor`和`SecretBackendMetadataFactory`类型都必须在`spring.factories`中注册，这是 Spring 提供的一种扩展机制，类似于 Java 的 ServiceLoader。

## [](#service-registry-configuration)[11.服务注册中心配置](#service-registry-configuration)

你可以使用`DiscoveryClient`（例如来自 Spring Cloud Consul）通过设置 Spring.cloud.vault.discovery.enabled=true（默认`false`）来定位 Vault 服务器。这样做的最终结果是，你的应用程序需要一个具有适当的发现配置的 application.yml（或环境变量）。好处是，只要发现服务是一个固定点，保险库就可以更改其坐标。默认的服务 ID 是`vault`，但是你可以在客户机上使用`spring.cloud.vault.discovery.serviceId`更改它。

发现客户机实现都支持某种元数据映射（例如，对于 Eureka，我们有 eureka.instance.metadatamap）。服务的一些附加属性可能需要在其服务注册元数据中进行配置，以便客户端能够正确地连接。不提供传输层安全性详细信息的服务注册中心需要提供一个`scheme`元数据条目，将其设置为`https`或`http`。如果没有配置任何方案，并且服务不作为安全服务公开，那么在未设置配置时，配置默认为`spring.cloud.vault.scheme`，即`https`。

```
spring.cloud.vault.discovery:
    enabled: true
    service-id: my-vault-service
```

## [](#vault.config.fail-fast)[12.Vault 客户端快速失败](#vault.config.fail-fast)

在某些情况下，如果服务无法连接到 Vault 服务器，则可能希望服务启动失败。如果这是所需的行为，那么设置 BootStrap 配置属性`spring.cloud.vault.fail-fast=true`，客户端将异常停止。

```
spring.cloud.vault:
    fail-fast: true
```

## [](#vault.config.namespaces)[13.Vault Enterprise 命名空间支持](#vault.config.namespaces)

Vault Enterprise 允许使用名称空间来隔离单个 Vault 服务器上的多个 Vault。在使用 vault`RestTemplate`或`WebClient`时，通过设置`spring.cloud.vault.namespace=…`来配置名称空间，可以在每个传出的 HTTP 请求上启用名称空间标头`X-Vault-Namespace`。

请注意，Vault Community Edition 不支持此功能，并且对 Vault 操作没有影响。

```
spring.cloud.vault:
    namespace: my-namespace
```

另见：[Vault Enterprise:名称空间](https://www.vaultproject.io/docs/enterprise/namespaces/index.html)

## [](#vault.config.ssl)[14.Vault 客户端 SSL 配置](#vault.config.ssl)

可以通过设置各种属性来声明性地配置 SSL。你可以设置`javax.net.ssl.trustStore`来配置 JVM 范围内的 SSL 设置，也可以设置`spring.cloud.vault.ssl.trust-store`来仅为 Spring Cloud Vault 配置设置 SSL 设置。

```
spring.cloud.vault:
    ssl:
        trust-store: classpath:keystore.jks
        trust-store-password: changeit
        trust-store-type: JKS
        enabled-protocols: TLSv1.2,TLSv1.3
        enabled-cipher-suites: TLS_AES_128_GCM_SHA256
```

* `trust-store`设置信任存储区的资源。SSL 安全的 Vault 通信将使用指定的信任存储区验证 Vault SSL 证书。

* `trust-store-password`设置信任存储密码

* `trust-store-type`设置信任存储类型。支持的值都支持`KeyStore`类型，包括`PEM`。

* `enabled-protocols`设置启用的 SSL/TLS 协议的列表（自 3.0.2 起）。

* `enabled-cipher-suites`设置启用的 SSL/TLS 密码套件的列表（自 3.0.2 起）。

请注意，配置`spring.cloud.vault.ssl.*`只能在 Apache HTTP 组件或 OKHTTP 客户机位于类路径上时才能应用。

## [](#vault-lease-renewal)[15.租赁生命周期管理（更新和撤销）](#vault-lease-renewal)

对于每个秘密，Vault 都会创建一个租约：元数据，其中包含诸如时间期限、可更新性等信息。

Vault 承诺，这些数据将在给定的持续时间或生存时间内有效。一旦租约到期，Vault 可以撤销该数据，并且该秘密的使用者不能再确定它是否有效。

Spring Cloud Vault 维护的租赁生命周期超出了登录令牌和秘密的创建。也就是说，与租赁相关的登录令牌和秘密将在租赁到期之前进行更新，直到终端到期。应用程序关闭撤销已获得的登录令牌和可更新的租约。

秘密服务和数据库后台（例如 MongoDB 或 MySQL）通常会生成可更新的租约，因此生成的凭据将在应用程序关闭时禁用。

|   |静态令牌不会更新或撤销。|
|---|-----------------------------------------|

默认情况下，租赁续订和撤销是启用的，可以通过将`spring.cloud.vault.config.lifecycle.enabled`设置为`false`来禁用。不建议这样做，因为租约可能会到期，并且 Spring Cloud Vault 无法使用生成的凭据访问 Vault 或服务，并且在应用程序关闭后，有效的凭据仍然处于活动状态。

```
spring.cloud.vault:
    config.lifecycle:
        enabled: true
        min-renewal: 10s
        expiry-threshold: 1m
        lease-endpoints: Legacy
```

* `enabled`控制与秘密相关的租赁是否被认为是续签的，过期的秘密是否被旋转。默认情况下启用。

* `min-renewal`设置续租前至少需要的期限。这种设置可以防止更新太频繁。

* `expiry-threshold`设置到期阈值。租约在到期前会在配置好的期限内续签。

* `lease-endpoints`设置更新和撤销的端点。旧版的 Vault 版本在 0.8 之前，Sysleases 版本在以后。

另见：[保险库文档：租赁、续订和撤销](https://www.vaultproject.io/docs/concepts/lease.html)

## [](#vault-session-lifecycle)[16.会话令牌生命周期管理（更新、重新登录和撤销）](#vault-session-lifecycle)

Vault 会话令牌（也称为`LoginToken`）与租赁非常相似，因为它具有 TTL，最大 TTL，并且可能会过期。一旦一个登录令牌过期，它就不能再用于与 Vault 交互。因此， Spring Vault 使用`SessionManager`API 进行命令和反应使用。

Spring 默认情况下，Cloud Vault 维护会话令牌生命周期。会话令牌是懒洋洋地获得的，因此实际的登录被推迟到 Vault 的第一次会话绑定使用时。一旦 Spring Cloud Vault 获得会话令牌，它将保留该令牌直到到期。下一次使用会话绑定活动时， Spring Cloud Vault 重新登录到 Vault 并获得一个新的会话令牌。在应用程序关闭时， Spring Cloud Vault 撤销令牌，如果它仍然处于活动状态以终止会话。

默认情况下，会话生命周期是启用的，可以通过将`spring.cloud.vault.session.lifecycle.enabled`设置为`false`来禁用。不建议禁用，因为会话令牌可能会过期，并且 Spring Cloud Vault 无法更长时间访问 Vault。

```
spring.cloud.vault:
    session.lifecycle:
        enabled: true
        refresh-before-expiry: 10s
        expiry-threshold: 20s
```

* `enabled`控制是否启用会话生命周期管理以更新会话令牌。默认情况下启用。

* `refresh-before-expiry`控制会话令牌更新的时间点。通过从令牌到期时间减去`refresh-before-expiry`来计算刷新时间。默认值为`5 seconds`。

* `expiry-threshold`设置到期阈值。该阈值表示将会话令牌视为有效的最小 TTL 持续时间。具有较短 TTL 的令牌将被视为过期，不再使用。应该大于`refresh-before-expiry`以防止令牌过期。默认值为`7 seconds`。

另见：[保险库文档：令牌更新](https://www.vaultproject.io/api-docs/auth/token#renew-a-token-self)

## [](#common-application-properties)[附录 A:通用应用程序属性](#common-application-properties)

可以在`application.properties`文件内、`application.yml`文件内或作为命令行开关指定各种属性。本附录提供了一个常见的 Spring Cloud Vault 属性的列表，以及对使用它们的基础类的引用。

|   |属性贡献可以来自你的 Classpath 上的其他 jar 文件，因此你不应将其视为详尽的列表。<br/>此外，你可以定义自己的属性。|
|---|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

|                           Name                           |                                                         Default                                                         |说明|
|----------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|          spring.cloud.vault.app-id.app-id-path           |                                                        `app-id`                                                         |安装 APPID 身份验证后端的路径。|
|       spring.cloud.vault.app-id.network-interface        |                                                                                                                         |网络接口提示为“MAC\_Address”用户 ID 机制。|
|            spring.cloud.vault.app-id.user-id             |                                                      `MAC_ADDRESS`                                                      |userid 机制。可以是“mac\_address”、“ip\_address”、字符串或类名。|
|        spring.cloud.vault.app-role.app-role-path         |                                                        `approle`                                                        |Approle 身份验证后端的挂载路径。|
|             spring.cloud.vault.app-role.role             |                                                                                                                         |角色的名称，可选的，用于拉模式.|
|           spring.cloud.vault.app-role.role-id            |                                                                                                                         |罗里德。|
|          spring.cloud.vault.app-role.secret-id           |                                                                                                                         |秘密组织。|
|           spring.cloud.vault.application-name            |                                                      `application`                                                      |用于 APPID 身份验证的应用程序名称。|
|            spring.cloud.vault.authentication             |                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                |
|         spring.cloud.vault.aws-ec2.aws-ec2-path          |                                                        `aws-ec2`                                                        |安装 AWS-EC2 身份验证后端的路径。|
|       spring.cloud.vault.aws-ec2.identity-document       |`[169.254.169.254/latest/dynamic/instance-identity/pkcs7](http://169.254.169.254/latest/dynamic/instance-identity/pkcs7)`|AWS-EC2PKCS7 身份文档的 URL。|
|             spring.cloud.vault.aws-ec2.nonce             |                                                                                                                         |once 用于 AWS-EC2 身份验证。空的 nonce 默认为 nonce 生成。|
|             spring.cloud.vault.aws-ec2.role              |                                                                                                                         |角色的名称，可选的。|
|           spring.cloud.vault.aws-iam.aws-path            |                                                          `aws`                                                          |安装 AWS 身份验证后端的路径。|
|         spring.cloud.vault.aws-iam.endpoint-uri          |                                                                                                                         |STS 服务器 URI。@ 自 2.2 起|
|             spring.cloud.vault.aws-iam.role              |                                                                                                                         |角色的名称，可选的。如果未设置，则默认为友好的 IAM 名称。|
|          spring.cloud.vault.aws-iam.server-name          |                                                                                                                         |用于在登录请求的头中设置{@code x-vault-aws-iam-server-id}头的服务器名称。|
|        spring.cloud.vault.aws.access-key-property        |                                            `cloud.aws.credentials.accessKey`                                            |获取的访问密钥的目标属性。|
|              spring.cloud.vault.aws.backend              |                                                          `aws`                                                          |AWS 后端路径。|
|          spring.cloud.vault.aws.credential-type          |                                                                                                                         |AWS 凭据类型|
|              spring.cloud.vault.aws.enabled              |                                                         `false`                                                         |启用 AWS 后端使用。|
|               spring.cloud.vault.aws.role                |                                                                                                                         |凭证的角色名。|
|             spring.cloud.vault.aws.role-arn              |                                                                                                                         |假定的 \_role 的 Role ARN 如果我们有多个与 vault 角色相关的角色。@since3.0.2|
|        spring.cloud.vault.aws.secret-key-property        |                                            `cloud.aws.credentials.secretKey`                                            |获取的密钥的目标属性。|
|    spring.cloud.vault.aws.session-token-key-property     |                                          `cloud.aws.credentials.sessionToken`                                           |获取的密钥的目标属性。|
|                spring.cloud.vault.aws.ttl                |                                                           `0`                                                           |STS 代币的 TTL。默认情况下，无论保险库角色可能对 MAX 有什么影响。也仅限于 AWS 支持的 STS 的最大值。@since3.0.2|
|         spring.cloud.vault.azure-msi.azure-path          |                                                         `azure`                                                         |安装 Azure MSI 认证后端的路径。|
|   spring.cloud.vault.azure-msi.identity-token-service    |                                                                                                                         |身份令牌服务 URI。@since3.0|
|      spring.cloud.vault.azure-msi.metadata-service       |                                                                                                                         |实例元数据服务 URI。@since3.0|
|            spring.cloud.vault.azure-msi.role             |                                                                                                                         |角色的名称。|
|           spring.cloud.vault.cassandra.backend           |                                                       `cassandra`                                                       |Cassandra 后端路径。|
|           spring.cloud.vault.cassandra.enabled           |                                                         `false`                                                         |启用 Cassandra 后端使用。|
|      spring.cloud.vault.cassandra.password-property      |                                            `spring.data.cassandra.password`                                             |获取的密码的目标属性。|
|            spring.cloud.vault.cassandra.role             |                                                                                                                         |凭证的角色名。|
|         spring.cloud.vault.cassandra.static-role         |                                                         `false`                                                         |启用静态角色用法。@ 自 2.2 起|
|      spring.cloud.vault.cassandra.username-property      |                                            `spring.data.cassandra.username`                                             |获取的用户名的目标属性。|
|       spring.cloud.vault.config.lifecycle.enabled        |                                                         `true`                                                          |启用生命周期管理。|
|   spring.cloud.vault.config.lifecycle.expiry-threshold   |                                                                                                                         |到期日门槛。{@link lease}在给定的{@link duration}到期前更新。@ 自 2.2 起|
|   spring.cloud.vault.config.lifecycle.lease-endpoints    |                                                                                                                         |将{@Link LeaseEndpoints}设置为将续订/撤销调用委托给。{@link leaseendpoints}封装了影响更新/撤销端点位置的 Vault 版本之间的差异。对于 Vault 的 0.8 或更高版本，可以使用{@Link LeaseEndpoints#sysleases}，对于较旧的版本，可以使用{@Link LeaseEndpoints#Legacy}（默认）。@ 自 2.2 起|
|     spring.cloud.vault.config.lifecycle.min-renewal      |                                                                                                                         |在续租前至少需要的时间。@ 自 2.2 起|
|             spring.cloud.vault.config.order              |                                                           `0`                                                           |用于设置{@link org.springframework.core.ENV.PropertySource}的优先级。这对于使用 Vault 作为对其他属性源的覆盖是有用的。@see org.springframework.core.priorityordered|
|          spring.cloud.vault.connection-timeout           |                                                         `5000`                                                          |连接超时。|
|            spring.cloud.vault.consul.backend             |                                                        `consul`                                                         |领事后台路径。|
|            spring.cloud.vault.consul.enabled             |                                                         `false`                                                         |启用 Consul 后端使用。|
|              spring.cloud.vault.consul.role              |                                                                                                                         |凭证的角色名。|
|         spring.cloud.vault.consul.token-property         |                                               `spring.cloud.consul.token`                                               |获取的令牌的目标属性。|
|           spring.cloud.vault.couchbase.backend           |                                                       `database`                                                        |Couchbase 后端路径。|
|           spring.cloud.vault.couchbase.enabled           |                                                         `false`                                                         |启用 CouchBase 后端使用。|
|      spring.cloud.vault.couchbase.password-property      |                                               `spring.couchbase.password`                                               |获取的密码的目标属性。|
|            spring.cloud.vault.couchbase.role             |                                                                                                                         |凭证的角色名。|
|         spring.cloud.vault.couchbase.static-role         |                                                         `false`                                                         |启用静态角色用法。|
|      spring.cloud.vault.couchbase.username-property      |                                               `spring.couchbase.username`                                               |获取的用户名的目标属性。|
|           spring.cloud.vault.database.backend            |                                                       `database`                                                        |数据库后端路径。|
|           spring.cloud.vault.database.enabled            |                                                         `false`                                                         |启用数据库后端使用。|
|      spring.cloud.vault.database.password-property       |                                              `spring.datasource.password`                                               |获取的密码的目标属性。|
|             spring.cloud.vault.database.role             |                                                                                                                         |凭证的角色名。|
|         spring.cloud.vault.database.static-role          |                                                         `false`                                                         |启用静态角色用法。|
|      spring.cloud.vault.database.username-property       |                                              `spring.datasource.username`                                               |获取的用户名的目标属性。|
|               spring.cloud.vault.databases               |                                                                                                                         |                                                                                                                                                                                                                                                                                                                                                                |
|           spring.cloud.vault.discovery.enabled           |                                                         `false`                                                         |标志，指示已启用 Vault Server Discovery（将通过 Discovery 查找 Vault Server URL）。|
|         spring.cloud.vault.discovery.service-id          |                                                         `vault`                                                         |定位保险库的服务 ID。|
|         spring.cloud.vault.elasticsearch.backend         |                                                       `database`                                                        |数据库后端路径。|
|         spring.cloud.vault.elasticsearch.enabled         |                                                         `false`                                                         |启用 ElasticSearch 后端使用。|
|    spring.cloud.vault.elasticsearch.password-property    |                                          `spring.elasticsearch.rest.password`                                           |获取的密码的目标属性。|
|          spring.cloud.vault.elasticsearch.role           |                                                                                                                         |凭证的角色名。|
|       spring.cloud.vault.elasticsearch.static-role       |                                                         `false`                                                         |启用静态角色用法。|
|    spring.cloud.vault.elasticsearch.username-property    |                                          `spring.elasticsearch.rest.username`                                           |获取的用户名的目标属性。|
|                spring.cloud.vault.enabled                |                                                         `true`                                                          |启用 Vault Config 服务器。|
|               spring.cloud.vault.fail-fast               |                                                         `false`                                                         |如果不能从保险库获取数据，则会迅速失效。|
|           spring.cloud.vault.gcp-gce.gcp-path            |                                                          `gcp`                                                          |Kubernetes 身份验证后端的挂载路径。|
|             spring.cloud.vault.gcp-gce.role              |                                                                                                                         |尝试登录所针对的角色的名称。|
|        spring.cloud.vault.gcp-gce.service-account        |                                                                                                                         |可选服务帐户 ID。如果未配置，则使用默认 ID。|
|    spring.cloud.vault.gcp-iam.credentials.encoded-key    |                                                                                                                         |base64 以 JSON 格式对 OAuth2 帐户私钥的内容进行了编码。|
|     spring.cloud.vault.gcp-iam.credentials.location      |                                                                                                                         |OAuth2 凭证私钥的位置。\<p\>由于这是一个资源，私钥可以位于多种位置，例如本地文件系统、 Classpath、URL 等。|
|           spring.cloud.vault.gcp-iam.gcp-path            |                                                          `gcp`                                                          |Kubernetes 身份验证后端的挂载路径。|
|         spring.cloud.vault.gcp-iam.jwt-validity          |                                                          `15m`                                                          |JWT 令牌的有效性。|
|          spring.cloud.vault.gcp-iam.project-id           |                                                                                                                         |重写 GCP 项目 ID。|
|             spring.cloud.vault.gcp-iam.role              |                                                                                                                         |尝试登录所针对的角色的名称。|
|      spring.cloud.vault.gcp-iam.service-account-id       |                                                                                                                         |覆盖 GCP 服务帐户 ID。|
|                 spring.cloud.vault.host                  |                                                       `localhost`                                                       |Vault 服务器主机。|
|      spring.cloud.vault.kubernetes.kubernetes-path       |                                                      `kubernetes`                                                       |Kubernetes 身份验证后端的挂载路径。|
|            spring.cloud.vault.kubernetes.role            |                                                                                                                         |尝试登录所针对的角色的名称。|
| spring.cloud.vault.kubernetes.service-account-token-file |                                  `/var/run/secrets/kubernetes.io/serviceaccount/token`                                  |服务帐户令牌文件的路径。|
|          spring.cloud.vault.kv.application-name          |                                                      `application`                                                      |用于上下文的应用程序名。|
|              spring.cloud.vault.kv.backend               |                                                        `secret`                                                         |默认后端名称。|
|          spring.cloud.vault.kv.backend-version           |                                                           `2`                                                           |键值后端版本。当前支持的版本有：\<ul\>\<li\>版本 1（未版本化键-值后端）。\</li\>\<li\>版本 2（版本化键-值后端）。\</li\>\</ul\>|
|          spring.cloud.vault.kv.default-context           |                                                      `application`                                                      |默认上下文的名称。|
|              spring.cloud.vault.kv.enabled               |                                                         `true`                                                          |启用 kev-value 后端。|
|         spring.cloud.vault.kv.profile-separator          |                                                           `/`                                                           |profile-separator 组合应用程序名和 profile。|
|              spring.cloud.vault.kv.profiles              |                                                                                                                         |活动配置文件列表。@since3.0|
|            spring.cloud.vault.mongodb.backend            |                                                        `mongodb`                                                        |MongoDB 后端路径。|
|            spring.cloud.vault.mongodb.enabled            |                                                         `false`                                                         |启用 MongoDB 后端使用。|
|       spring.cloud.vault.mongodb.password-property       |                                             `spring.data.mongodb.password`                                              |获取的密码的目标属性。|
|             spring.cloud.vault.mongodb.role              |                                                                                                                         |凭证的角色名。|
|          spring.cloud.vault.mongodb.static-role          |                                                         `false`                                                         |启用静态角色用法。@ 自 2.2 起|
|       spring.cloud.vault.mongodb.username-property       |                                             `spring.data.mongodb.username`                                              |获取的用户名的目标属性。|
|             spring.cloud.vault.mysql.backend             |                                                         `mysql`                                                         |MySQL 后端路径。|
|             spring.cloud.vault.mysql.enabled             |                                                         `false`                                                         |启用 MySQL 后端使用。|
|        spring.cloud.vault.mysql.password-property        |                                              `spring.datasource.password`                                               |获取的用户名的目标属性。|
|              spring.cloud.vault.mysql.role               |                                                                                                                         |凭证的角色名。|
|        spring.cloud.vault.mysql.username-property        |                                              `spring.datasource.username`                                               |获取的用户名的目标属性。|
|               spring.cloud.vault.namespace               |                                                                                                                         |Vault 名称空间（需要 Vault Enterprise）。|
|       spring.cloud.vault.pcf.instance-certificate        |                                                                                                                         |到实例证书的路径。默认为{@code cf\_instance\_CERT}ENV 变量。|
|           spring.cloud.vault.pcf.instance-key            |                                                                                                                         |实例键的路径。默认为{@code cf\_instance\_key}ENV 变量。|
|             spring.cloud.vault.pcf.pcf-path              |                                                          `pcf`                                                          |Kubernetes 身份验证后端的挂载路径。|
|               spring.cloud.vault.pcf.role                |                                                                                                                         |尝试登录所针对的角色的名称。|
|                 spring.cloud.vault.port                  |                                                         `8200`                                                          |Vault 服务器端口。|
|          spring.cloud.vault.postgresql.backend           |                                                      `postgresql`                                                       |PostgreSQL 后端路径。|
|          spring.cloud.vault.postgresql.enabled           |                                                         `false`                                                         |启用 PostgreSQL 后端使用。|
|     spring.cloud.vault.postgresql.password-property      |                                              `spring.datasource.password`                                               |获取的用户名的目标属性。|
|            spring.cloud.vault.postgresql.role            |                                                                                                                         |凭证的角色名。|
|     spring.cloud.vault.postgresql.username-property      |                                              `spring.datasource.username`                                               |获取的用户名的目标属性。|
|           spring.cloud.vault.rabbitmq.backend            |                                                       `rabbitmq`                                                        |RabbitMQ 后端路径。|
|           spring.cloud.vault.rabbitmq.enabled            |                                                         `false`                                                         |启用 RabbitMQ 后端使用。|
|      spring.cloud.vault.rabbitmq.password-property       |                                               `spring.rabbitmq.password`                                                |获取的密码的目标属性。|
|             spring.cloud.vault.rabbitmq.role             |                                                                                                                         |凭证的角色名。|
|      spring.cloud.vault.rabbitmq.username-property       |                                               `spring.rabbitmq.username`                                                |获取的用户名的目标属性。|
|           spring.cloud.vault.reactive.enabled            |                                                         `true`                                                          |指示激活了反应性发现的标志|
|             spring.cloud.vault.read-timeout              |                                                         `15000`                                                         |读超时。|
|                spring.cloud.vault.scheme                 |                                                         `https`                                                         |协议方案。可以是“HTTP”或“HTTPS”。|
|       spring.cloud.vault.session.lifecycle.enabled       |                                                         `true`                                                          |启用会话生命周期管理。|
|  spring.cloud.vault.session.lifecycle.expiry-threshold   |                                                          `7s`                                                           |{@link logintoken}的过期阈值。该阈值表示将登录令牌视为有效的最小 TTL 持续时间。具有较短 TTL 的令牌将被视为过期，不再使用。应该大于{@code refreshbeForexilless}以防止令牌过期。|
|spring.cloud.vault.session.lifecycle.refresh-before-expiry|                                                          `5s`                                                           |更新{@link logintoken}之前至少需要的时间段。|
|          spring.cloud.vault.ssl.cert-auth-path           |                                                         `cert`                                                          |安装路径的 TLS CERT 身份验证后端。|
|       spring.cloud.vault.ssl.enabled-cipher-suites       |                                                                                                                         |启用的 SSL/TLS 密码套件的列表。@since3.0.2|
|         spring.cloud.vault.ssl.enabled-protocols         |                                                                                                                         |启用的 SSL/TLS 协议的列表。@since3.0.2|
|             spring.cloud.vault.ssl.key-store             |                                                                                                                         |保存证书和私钥的信任存储区。|
|        spring.cloud.vault.ssl.key-store-password         |                                                                                                                         |用于访问密钥存储区的密码。|
|          spring.cloud.vault.ssl.key-store-type           |                                                                                                                         |类型的密钥存储。@since3.0|
|            spring.cloud.vault.ssl.trust-store            |                                                                                                                         |持有 SSL 证书的信任存储区。|
|       spring.cloud.vault.ssl.trust-store-password        |                                                                                                                         |用于访问信任存储区的密码。|
|         spring.cloud.vault.ssl.trust-store-type          |                                                                                                                         |信任存储的类型。@since3.0|
|                 spring.cloud.vault.token                 |                                                                                                                         |静态保险库令牌。如果{@link#authentication}是{@code token}，则需要。|
|                  spring.cloud.vault.uri                  |                                                                                                                         |Vault Uri。可以用方案、主机和端口进行设置.|

如果{{{i[’GoogleAnalyticsObject’]=r；i[r]=i[r]|function（）{q=i[r].push（参数）}，i[r].l=1\*new date（）；a=s.createElement（o），m=s.getelementsbyName（0）；a.parentsName（1）；a.A.SRC=g；m.M.analytnode（gua，m.com.com）；（google=document=’，’，’’’’’’’’），’documents’，’’.’’’’’’’’’’’，’’’’’’