配置
7. Maven 资源
Spring Cloud Dataflow 支持通过 Maven （） 引用工件。
如果要覆盖特定的 Maven 配置属性（远程存储库、代理等）或在代理后面运行 Data Flow Server，
在启动 Data Flow Server 时，需要将这些属性指定为命令行参数，如以下示例所示：maven:
$ java -jar spring-cloud-dataflow-server-2.11.5.jar --spring.config.additional-location=/home/joe/maven.yml上述命令假定与以下内容类似：maven.yaml
maven:
localRepository: mylocal
remote-repositories:
repo1:
url: https://repo1
auth:
username: user1
password: pass1
snapshot-policy:
update-policy: daily
checksum-policy: warn
release-policy:
update-policy: never
checksum-policy: fail
repo2:
url: https://repo2
policy:
update-policy: always
checksum-policy: fail
proxy:
host: proxy1
port: "9010"
auth:
username: proxyuser1
password: proxypass1默认情况下，协议设置为 。如果代理不需要用户名和密码，则可以省略 auth 属性。此外，默认情况下，maven 设置为 。
如前面的示例所示，您可以指定远程存储库及其身份验证（如果需要）。如果远程存储库位于代理后面，则可以指定代理属性，如前面的示例所示。httplocalRepository${user.home}/.m2/repository/
您可以为每个远程存储库配置指定存储库策略，如前面的示例所示。
该密钥适用于 和 存储库策略。policysnapshotrelease
请参阅 存储库策略 主题以获取 支持的存储库策略。
由于这些是 Spring Boot，因此您需要将它们添加到环境变量中来指定。以下示例显示了 JSON 的结构：@ConfigurationPropertiesSPRING_APPLICATION_JSON
$ SPRING_APPLICATION_JSON='
{
"maven": {
"local-repository": null,
"remote-repositories": {
"repo1": {
"url": "https://repo1",
"auth": {
"username": "repo1user",
"password": "repo1pass"
}
},
"repo2": {
"url": "https://repo2"
}
},
"proxy": {
"host": "proxyhost",
"port": 9018,
"auth": {
"username": "proxyuser",
"password": "proxypass"
}
}
}
}
'7.1. 货车
对 Maven 使用传输的支持有限。目前，这个
存在以支持使用基于 的存储库进行抢占式身份验证
，需要手动启用。Wagonhttp
通过设置属性
自。然后，您可以为每个远程启用抢占式身份验证
存储 库。配置大致遵循 HttpClient HTTP Wagon 中的类似模式。
在撰写本文时，Maven 自己站点中的文档略有误导性
以及缺少大多数可能的配置选项。httpmaven.use-wagontrue
命名空间包含所有与 Wagon 相关的设置，其正下方的键映射到支持的方法 — 即 、 和 ，如 Maven 自己的配置中所示。
在这些方法配置下，您可以设置各种选项，例如 .用于发送身份验证的简单抢占式配置
标头将类似于以下示例：maven.remote-repositories.<repo>.wagon.httphttphttpallputgetheaduse-preemptive
maven:
use-wagon: true
remote-repositories:
springRepo:
url: https://repo.example.org
wagon:
http:
all:
use-preemptive: true
auth:
username: user
password: password您可以仅调整 和 requests 的设置，而不是配置方法，如下所示：allgethead
maven:
use-wagon: true
remote-repositories:
springRepo:
url: https://repo.example.org
wagon:
http:
get:
use-preemptive: true
head:
use-preemptive: true
use-default-headers: true
connection-timeout: 1000
read-timeout: 1000
headers:
sample1: sample2
params:
http.socket.timeout: 1000
http.connection.stalecheck: true
auth:
username: user
password: password有 、 request 和 HttpClient 的设置 。有关参数的更多信息，
请参阅 Wagon ConfigurationUtils。use-default-headersconnection-timeoutread-timeoutheadersparams
8. 安全性
默认情况下，数据流服务器不安全，并在未加密的 HTTP 连接上运行。 您可以通过启用 HTTPS 来保护 REST 终端节点以及数据流控制面板 以及要求客户端使用 OAuth 2.0 进行身份验证。
|
附录 Azure 包含有关如何 设置 Azure Active Directory 集成。 |
|
默认情况下，REST 终端节点（管理、管理和运行状况）以及 Dashboard UI 不需要经过身份验证的访问。 |
虽然理论上您可以选择任何 OAuth 提供程序，但 Spring Cloud Data Flow，我们建议使用 CloudFoundry 用户帐户和身份验证 （UAA） 服务器。
UAA OpenID 不仅经过认证并被 Cloud Foundry 使用，而且您可以 还可以在本地独立部署方案中使用它。此外，UAA 没有 它只提供自己的用户存储，但也提供全面的 LDAP 集成。
8.1. 启用 HTTPS
默认情况下，控制面板、管理和运行状况终端节点使用 HTTP 作为传输。
您可以通过在 中将证书添加到您的配置中来切换到 HTTPS，如以下示例所示：application.yml
server:
port: 8443 (1)
ssl:
key-alias: yourKeyAlias (2)
key-store: path/to/keystore (3)
key-store-password: yourKeyStorePassword (4)
key-password: yourKeyPassword (5)
trust-store: path/to/trust-store (6)
trust-store-password: yourTrustStorePassword (7)| 1 | 由于默认端口为 ，您可以选择将端口更改为更常见的 HTTPS 典型端口。9393 |
| 2 | 密钥存储在密钥库中的别名（或名称）。 |
| 3 | 密钥库文件的路径。您还可以使用 classpath 前缀指定 classpath 资源 - 例如：.classpath:path/to/keystore |
| 4 | 密钥库的密码。 |
| 5 | 密钥的密码。 |
| 6 | 信任库文件的路径。您还可以使用 Classpath 前缀指定 Classpath 资源 - 例如：classpath:path/to/trust-store |
| 7 | 信任存储的密码。 |
| 如果启用了 HTTPS，它将完全替换 HTTP 作为协议 REST 终端节点和数据流控制面板进行交互。普通 HTTP 请求 失败。因此，请确保相应地配置 Shell。 |
使用自签名证书
出于测试目的或在开发过程中，创建自签名证书可能很方便。 要开始使用，请执行以下命令来创建证书：
$ keytool -genkey -alias dataflow -keyalg RSA -keystore dataflow.keystore \
-validity 3650 -storetype JKS \
-dname "CN=localhost, OU=Spring, O=Pivotal, L=Kailua-Kona, ST=HI, C=US" (1)
-keypass dataflow -storepass dataflow| 1 | CN是这里的重要参数。它应与您尝试访问的域匹配 - 例如 .localhost |
然后将以下行添加到您的文件中：application.yml
server:
port: 8443
ssl:
enabled: true
key-alias: dataflow
key-store: "/your/path/to/dataflow.keystore"
key-store-type: jks
key-store-password: dataflow
key-password: dataflow这就是您需要为 Data Flow Server 执行的全部操作。启动服务器后，
您应该能够在 中访问它。
由于这是自签名证书，因此您应该在浏览器中看到一条警告，该警告
你需要忽略。localhost:8443/
| 切勿在生产中使用自签名证书。 |
自签名证书和 Shell
默认情况下，自签名证书是 shell 的一个问题，其他步骤 是使 shell 使用自签名证书所必需的。两种选择 可用：
-
将自签名证书添加到 JVM 信任库。
-
跳过证书验证。
将自签名证书添加到 JVM 信任库
要使用 JVM truststore 选项，您需要 从密钥库中导出之前创建的证书，如下所示：
$ keytool -export -alias dataflow -keystore dataflow.keystore -file dataflow_cert -storepass dataflow接下来，您需要创建一个 shell 可以使用的信任库，如下所示：
$ keytool -importcert -keystore dataflow.truststore -alias dataflow -storepass dataflow -file dataflow_cert -noprompt现在，您已准备好使用以下 JVM 参数启动 Data Flow Shell：
$ java -Djavax.net.ssl.trustStorePassword=dataflow \
-Djavax.net.ssl.trustStore=/path/to/dataflow.truststore \
-Djavax.net.ssl.trustStoreType=jks \
-jar spring-cloud-dataflow-shell-2.11.5.jar|
如果您在通过 SSL 建立连接时遇到问题，您可以启用其他
logging 的 . |
不要忘记使用以下命令将 Data Flow Server 作为目标：
dataflow:> dataflow config server --uri https://localhost:8443/8.2. 使用 OAuth 2.0 进行身份验证
为了支持身份验证和授权，Spring Cloud Data Flow 使用 OAuth 2.0。 它允许您将 Spring Cloud Data Flow 集成到单点登录 （SSO） 中 环境。
| 从 Spring Cloud Data Flow 2.0 开始，OAuth2 是唯一的机制 用于提供身份验证和授权。 |
使用以下 OAuth2 授权类型：
-
授权码：用于 GUI（浏览器）集成。访客将被重定向到您的 OAuth 服务进行身份验证
-
密码：由 shell（和 REST 集成）使用，因此访问者可以使用用户名和密码登录
-
客户端凭据：直接从 OAuth 提供程序检索访问令牌，并使用授权 HTTP 标头将其传递给数据流服务器
| 目前，Spring Cloud Data Flow 使用不透明的令牌，而不是透明的 令牌 （JWT） 的 API API 的 API API 的 API |
您可以通过两种方式访问 REST 终端节点：
-
基本身份验证，它使用密码授权类型对您的 OAuth2 服务进行身份验证
-
访问令牌，它使用 Client Credentials Grant Type
| 设置身份验证时，您确实应该启用 HTTPS 以及，尤其是在生产环境中。 |
您可以通过将以下内容添加到或设置
环境变量。以下示例显示了 CloudFoundry 用户帐户和身份验证 （UAA） 服务器所需的最小设置：application.yml
spring:
security:
oauth2: (1)
client:
registration:
uaa: (2)
client-id: myclient
client-secret: mysecret
redirect-uri: '{baseUrl}/login/oauth2/code/{registrationId}'
authorization-grant-type: authorization_code
scope:
- openid (3)
provider:
uaa:
jwk-set-uri: http://uaa.local:8080/uaa/token_keys
token-uri: http://uaa.local:8080/uaa/oauth/token
user-info-uri: http://uaa.local:8080/uaa/userinfo (4)
user-name-attribute: user_name (5)
authorization-uri: http://uaa.local:8080/uaa/oauth/authorize
resourceserver:
opaquetoken:
introspection-uri: http://uaa.local:8080/uaa/introspect (6)
client-id: dataflow
client-secret: dataflow| 1 | 提供此属性将激活 OAuth2 安全性。 |
| 2 | 提供商 ID。您可以指定多个提供商。 |
| 3 | 由于 UAA 是 OpenID 提供程序，因此您至少必须指定范围。
如果您的提供程序还提供了其他范围来控制角色分配，则
您还必须在此处指定这些范围。openid |
| 4 | OpenID 终端节点。用于检索用户名等用户信息。命令的。 |
| 5 | 包含用户名的响应的 JSON 属性。 |
| 6 | 用于内省和验证直接传入的令牌。命令的。 |
您可以使用 curl 验证基本身份验证是否正常工作，如下所示：
curl -u myusername:mypassword http://localhost:9393/ -H 'Accept: application/json'因此，您应该会看到可用 REST 终端节点的列表。
当您使用 Web 浏览器访问 Root URL 并且
security enabled，您将被重定向到 Dashboard UI。要查看
REST 端点列表，指定标头。还要确保
使用 Postman （Chrome） 等工具添加标头
或 RESTClient （Firefox） 的 RESTClient 浏览器。application/jsonAcceptAccept |
除了基本身份验证之外，您还可以提供访问令牌，以便 访问 REST API。为此，请检索 OAuth2 访问令牌，并将该访问令牌传递给 使用 Authorization HTTP 标头的 REST API，如下所示：
$ curl -H "Authorization: Bearer <ACCESS_TOKEN>" http://localhost:9393/ -H 'Accept: application/json'8.3. 自定义授权
前面的内容主要涉及身份验证，即如何评估 用户的身份。在本节中，我们将讨论可用的授权选项 — 即，谁可以执行哪些操作。
授权规则在 （部分
Spring Cloud Data Flow Core 模块）。dataflow-server-defaults.yml
由于安全角色的确定是特定于环境的，
默认情况下， Spring Cloud Data Flow 将所有角色分配给经过身份验证的 OAuth2
用户。该类用于此目的。DefaultDataflowAuthoritiesExtractor
或者，您可以让 Spring Cloud Data Flow 通过以下方式将 OAuth2 范围映射到数据流角色
将提供程序的 boolean 属性设置为（默认值为 ）。
例如，如果提供商的 ID 为 ，则属性将为 。map-oauth-scopestruefalseuaaspring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes
角色映射
默认情况下，所有角色都分配给登录到 Spring Cloud Data Flow 的用户。 但是，您可以设置以下属性：
spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes: true
这将指示底层将
OAuth 范围限定为相应的颁发机构。支持以下范围：DefaultAuthoritiesExtractor
-
范围映射到角色
dataflow.createCREATE -
范围映射到角色
dataflow.deployDEPLOY -
范围映射到角色
dataflow.destroyDESTROY -
范围映射到角色
dataflow.manageMANAGE -
范围映射到角色
dataflow.modifyMODIFY -
范围映射到角色
dataflow.scheduleSCHEDULE -
范围映射到角色
dataflow.viewVIEW
此外，您还可以将任意范围映射到每个数据流角色：
spring:
cloud:
dataflow:
security:
authorization:
provider-role-mappings:
uaa:
map-oauth-scopes: true (1)
role-mappings:
ROLE_CREATE: dataflow.create (2)
ROLE_DEPLOY: dataflow.deploy
ROLE_DESTROY: dataflow.destoy
ROLE_MANAGE: dataflow.manage
ROLE_MODIFY: dataflow.modify
ROLE_SCHEDULE: dataflow.schedule
ROLE_VIEW: dataflow.view| 1 | 启用从 OAuth 范围到数据流角色的显式映射支持 |
| 2 | 启用角色映射支持后，您必须为 所有 7 个 Spring Cloud Data Flow 角色 ROLE_CREATE、 ROLE_DEPLOY、 ROLE_DESTROY、 ROLE_MANAGE、 ROLE_MODIFY、 ROLE_SCHEDULE ROLE_VIEW。 |
|
您可以将 OAuth 范围分配给多个 Spring Cloud Data Flow 角色，从而灵活地选择授权配置的粒度。 |
组映射
从范围映射角色有其自身的问题，因为它可能并不总是可行的 以更改给定身份提供者中的这些值。如果可以定义组声明 在从身份提供商返回的令牌中，这些 Cookie 还可用于 映射到服务器角色。
spring:
cloud:
dataflow:
security:
authorization:
provider-role-mappings:
uaa:
map-oauth-scopes: false
map-group-claims: true
group-claim: roles
group-mappings:
ROLE_CREATE: my-group-id
ROLE_DEPLOY: my-group-id
ROLE_DESTROY: my-group-id
ROLE_MANAGE: my-group-id
ROLE_MODIFY: my-group-id
ROLE_SCHEDULE: my-group-id
ROLE_VIEW: my-group-id您还可以通过提供自己的 Spring bean 定义来自定义角色映射行为，该定义
扩展了 Spring Cloud Data Flow 的接口。在这种情况下，
自定义 Bean 定义优先于
Spring Cloud 数据流。AuthorityMapper
默认方案使用七个角色来保护 Spring Cloud Data Flow 公开的 REST 端点：
-
ROLE_CREATE：用于创建任何内容，例如创建流或任务
-
ROLE_DEPLOY：用于部署流或启动任务
-
ROLE_DESTROY：用于涉及删除流、任务等的任何内容。
-
ROLE_MANAGE：对于引导管理终端节点
-
ROLE_MODIFY：对于涉及更改系统状态的任何内容
-
ROLE_SCHEDULE：用于计划相关操作（如计划任务）
-
ROLE_VIEW：对于与检索状态相关的任何内容
如本节前面所述，指定了所有与授权相关的默认设置
in 中，它是 Spring Cloud Data Flow Core 的一部分
模块。尽管如此，如果需要，您可以覆盖这些设置，例如，
在。该配置采用 YAML 列表的形式（作为一些
规则可能优先于其他规则）。因此，您需要复制和粘贴
整个列表并根据您的需要进行定制（因为无法合并列表）。dataflow-server-defaults.ymlapplication.yml
请始终引用您的文件版本，因为以下代码段可能已过时。application.yml |
默认规则如下：
spring:
cloud:
dataflow:
security:
authorization:
enabled: true
loginUrl: "/"
permit-all-paths: "/authenticate,/security/info,/assets/**,/dashboard/logout-success-oauth.html,/favicon.ico"
rules:
# About
- GET /about => hasRole('ROLE_VIEW')
# Audit
- GET /audit-records => hasRole('ROLE_VIEW')
- GET /audit-records/** => hasRole('ROLE_VIEW')
# Boot Endpoints
- GET /management/** => hasRole('ROLE_MANAGE')
# Apps
- GET /apps => hasRole('ROLE_VIEW')
- GET /apps/** => hasRole('ROLE_VIEW')
- DELETE /apps/** => hasRole('ROLE_DESTROY')
- POST /apps => hasRole('ROLE_CREATE')
- POST /apps/** => hasRole('ROLE_CREATE')
- PUT /apps/** => hasRole('ROLE_MODIFY')
# Completions
- GET /completions/** => hasRole('ROLE_VIEW')
# Job Executions & Batch Job Execution Steps && Job Step Execution Progress
- GET /jobs/executions => hasRole('ROLE_VIEW')
- PUT /jobs/executions/** => hasRole('ROLE_MODIFY')
- GET /jobs/executions/** => hasRole('ROLE_VIEW')
- GET /jobs/thinexecutions => hasRole('ROLE_VIEW')
# Batch Job Instances
- GET /jobs/instances => hasRole('ROLE_VIEW')
- GET /jobs/instances/* => hasRole('ROLE_VIEW')
# Running Applications
- GET /runtime/streams => hasRole('ROLE_VIEW')
- GET /runtime/streams/** => hasRole('ROLE_VIEW')
- GET /runtime/apps => hasRole('ROLE_VIEW')
- GET /runtime/apps/** => hasRole('ROLE_VIEW')
# Stream Definitions
- GET /streams/definitions => hasRole('ROLE_VIEW')
- GET /streams/definitions/* => hasRole('ROLE_VIEW')
- GET /streams/definitions/*/related => hasRole('ROLE_VIEW')
- POST /streams/definitions => hasRole('ROLE_CREATE')
- DELETE /streams/definitions/* => hasRole('ROLE_DESTROY')
- DELETE /streams/definitions => hasRole('ROLE_DESTROY')
# Stream Deployments
- DELETE /streams/deployments/* => hasRole('ROLE_DEPLOY')
- DELETE /streams/deployments => hasRole('ROLE_DEPLOY')
- POST /streams/deployments/** => hasRole('ROLE_MODIFY')
- GET /streams/deployments/** => hasRole('ROLE_VIEW')
# Stream Validations
- GET /streams/validation/ => hasRole('ROLE_VIEW')
- GET /streams/validation/* => hasRole('ROLE_VIEW')
# Stream Logs
- GET /streams/logs/* => hasRole('ROLE_VIEW')
# Task Definitions
- POST /tasks/definitions => hasRole('ROLE_CREATE')
- DELETE /tasks/definitions/* => hasRole('ROLE_DESTROY')
- GET /tasks/definitions => hasRole('ROLE_VIEW')
- GET /tasks/definitions/* => hasRole('ROLE_VIEW')
# Task Executions
- GET /tasks/executions => hasRole('ROLE_VIEW')
- GET /tasks/executions/* => hasRole('ROLE_VIEW')
- POST /tasks/executions => hasRole('ROLE_DEPLOY')
- POST /tasks/executions/* => hasRole('ROLE_DEPLOY')
- DELETE /tasks/executions/* => hasRole('ROLE_DESTROY')
- GET /tasks/thinexecutions => hasRole('ROLE_VIEW')
# Task Schedules
- GET /tasks/schedules => hasRole('ROLE_VIEW')
- GET /tasks/schedules/* => hasRole('ROLE_VIEW')
- GET /tasks/schedules/instances => hasRole('ROLE_VIEW')
- GET /tasks/schedules/instances/* => hasRole('ROLE_VIEW')
- POST /tasks/schedules => hasRole('ROLE_SCHEDULE')
- DELETE /tasks/schedules/* => hasRole('ROLE_SCHEDULE')
# Task Platform Account List */
- GET /tasks/platforms => hasRole('ROLE_VIEW')
# Task Validations
- GET /tasks/validation/ => hasRole('ROLE_VIEW')
- GET /tasks/validation/* => hasRole('ROLE_VIEW')
# Task Logs
- GET /tasks/logs/* => hasRole('ROLE_VIEW')
# Tools
- POST /tools/** => hasRole('ROLE_VIEW')每行的格式如下：
HTTP_METHOD URL_PATTERN '=>' SECURITY_ATTRIBUTE
哪里：
-
HTTP_METHOD 是一种 HTTP 方法（如 PUT 或 GET），大写。
-
URL_PATTERN 是一种 Ant 样式的 URL 模式。
-
SECURITY_ATTRIBUTE 是一个 SPEL 表达式。请参阅基于表达式的访问控制。
-
其中每个字符都由一个或空白字符（空格、制表符等）分隔。
请注意，以上是 YAML 列表，而不是映射（因此使用了 '-' 破折号
位于每行的开头）位于 Key 下。spring.cloud.dataflow.security.authorization.rules
授权 — Shell 和 Dashboard 行为
启用安全性后，仪表板和 shell 是角色感知的。 这意味着，根据分配的角色，并非所有功能都可见。
例如，用户没有必要角色的 shell 命令 标记为不可用。
|
目前，shell 的命令列出了不可用的命令。
请跟踪以下问题：github.com/spring-projects/spring-shell/issues/115 |
相反，对于 Dashboard，UI 不会显示 用户未获得授权。
保护 Spring Boot Management 端点
启用安全性后， Spring Boot HTTP Management Endpoints 的保护方式与其他 REST Endpoint 相同。管理 REST 端点
在 和 requires 角色下可用。/managementMANAGEMENT
默认配置如下：dataflow-server-defaults.yml
management:
endpoints:
web:
base-path: /management
security:
roles: MANAGE| 目前，您不应自定义默认管理路径。 |
8.4. 设置 UAA 身份验证
对于本地部署场景，我们建议使用 CloudFoundry User 帐户和身份验证 （UAA） 服务器，已通过 OpenID 认证。 虽然 UAA 由 Cloud Foundry 使用， 它也是一个功能齐全的独立 OAuth2 服务器，具有企业功能，例如 LDAP 集成。
要求
您需要签出、构建并运行 UAA。为此，请确保您：
如果您在安装 uaac 时遇到问题，则可能需要设置环境
变量：GEM_HOME
export GEM_HOME="$HOME/.gem"您还应确保已将其添加到您的路径中。~/.gem/gems/cf-uaac-4.2.0/bin
为 JWT 准备 UAA
由于 UAA 是 OpenID 提供程序并使用 JSON Web 令牌 （JWT），因此它需要具有 用于对这些 JWT 进行签名的私有密钥：
openssl genrsa -out signingkey.pem 2048
openssl rsa -in signingkey.pem -pubout -out verificationkey.pem
export JWT_TOKEN_SIGNING_KEY=$(cat signingkey.pem)
export JWT_TOKEN_VERIFICATION_KEY=$(cat verificationkey.pem)稍后，启动 UAA 后，您可以在访问 时看到密钥。uaa:8080/uaa/token_keys
此处，URL 中的是主机名。uaauaa:8080/uaa/token_keys |
下载并启动 UAA
要下载并安装 UAA，请运行以下命令：
git clone https://github.com/pivotal/uaa-bundled.git
cd uaa-bundled
./mvnw clean install
java -jar target/uaa-bundled-1.0.0.BUILD-SNAPSHOT.jarUAA 的配置由 YAML file 驱动，或者您可以编写配置脚本
使用 UAA 命令行客户端：uaa.yml
uaac target http://uaa:8080/uaa
uaac token client get admin -s adminsecret
uaac client add dataflow \
--name dataflow \
--secret dataflow \
--scope cloud_controller.read,cloud_controller.write,openid,password.write,scim.userids,sample.create,sample.view,dataflow.create,dataflow.deploy,dataflow.destroy,dataflow.manage,dataflow.modify,dataflow.schedule,dataflow.view \
--authorized_grant_types password,authorization_code,client_credentials,refresh_token \
--authorities uaa.resource,dataflow.create,dataflow.deploy,dataflow.destroy,dataflow.manage,dataflow.modify,dataflow.schedule,dataflow.view,sample.view,sample.create\
--redirect_uri http://localhost:9393/login \
--autoapprove openid
uaac group add "sample.view"
uaac group add "sample.create"
uaac group add "dataflow.view"
uaac group add "dataflow.create"
uaac user add springrocks -p mysecret --emails [email protected]
uaac user add vieweronly -p mysecret --emails [email protected]
uaac member add "sample.view" springrocks
uaac member add "sample.create" springrocks
uaac member add "dataflow.view" springrocks
uaac member add "dataflow.create" springrocks
uaac member add "sample.view" vieweronly前面的脚本设置了 dataflow 客户端以及两个用户：
-
用户 springrocks has 同时具有 scopes： 和 .
sample.viewsample.create -
User vieweronly 只有一个范围：。
sample.view
添加后，您可以快速仔细检查 UAA 是否已创建用户：
curl -v -d"username=springrocks&password=mysecret&client_id=dataflow&grant_type=password" -u "dataflow:dataflow" http://uaa:8080/uaa/oauth/token -d 'token_format=opaque'前面的命令应生成类似于以下内容的输出：
* Trying 127.0.0.1...
* TCP_NODELAY set
* Connected to uaa (127.0.0.1) port 8080 (#0)
* Server auth using Basic with user 'dataflow'
> POST /uaa/oauth/token HTTP/1.1
> Host: uaa:8080
> Authorization: Basic ZGF0YWZsb3c6ZGF0YWZsb3c=
> User-Agent: curl/7.54.0
> Accept: */*
> Content-Length: 97
> Content-Type: application/x-www-form-urlencoded
>
* upload completely sent off: 97 out of 97 bytes
< HTTP/1.1 200
< Cache-Control: no-store
< Pragma: no-cache
< X-XSS-Protection: 1; mode=block
< X-Frame-Options: DENY
< X-Content-Type-Options: nosniff
< Content-Type: application/json;charset=UTF-8
< Transfer-Encoding: chunked
< Date: Thu, 31 Oct 2019 21:22:59 GMT
<
* Connection #0 to host uaa left intact
{"access_token":"0329c8ecdf594ee78c271e022138be9d","token_type":"bearer","id_token":"eyJhbGciOiJSUzI1NiIsImprdSI6Imh0dHBzOi8vbG9jYWxob3N0OjgwODAvdWFhL3Rva2VuX2tleXMiLCJraWQiOiJsZWdhY3ktdG9rZW4ta2V5IiwidHlwIjoiSldUIn0.eyJzdWIiOiJlZTg4MDg4Ny00MWM2LTRkMWQtYjcyZC1hOTQ4MmFmNGViYTQiLCJhdWQiOlsiZGF0YWZsb3ciXSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo4MDkwL3VhYS9vYXV0aC90b2tlbiIsImV4cCI6MTU3MjYwMDE3OSwiaWF0IjoxNTcyNTU2OTc5LCJhbXIiOlsicHdkIl0sImF6cCI6ImRhdGFmbG93Iiwic2NvcGUiOlsib3BlbmlkIl0sImVtYWlsIjoic3ByaW5ncm9ja3NAc29tZXBsYWNlLmNvbSIsInppZCI6InVhYSIsIm9yaWdpbiI6InVhYSIsImp0aSI6IjAzMjljOGVjZGY1OTRlZTc4YzI3MWUwMjIxMzhiZTlkIiwiZW1haWxfdmVyaWZpZWQiOnRydWUsImNsaWVudF9pZCI6ImRhdGFmbG93IiwiY2lkIjoiZGF0YWZsb3ciLCJncmFudF90eXBlIjoicGFzc3dvcmQiLCJ1c2VyX25hbWUiOiJzcHJpbmdyb2NrcyIsInJldl9zaWciOiJlOTkyMDQxNSIsInVzZXJfaWQiOiJlZTg4MDg4Ny00MWM2LTRkMWQtYjcyZC1hOTQ4MmFmNGViYTQiLCJhdXRoX3RpbWUiOjE1NzI1NTY5Nzl9.bqYvicyCPB5cIIu_2HEe5_c7nSGXKw7B8-reTvyYjOQ2qXSMq7gzS4LCCQ-CMcb4IirlDaFlQtZJSDE-_UsM33-ThmtFdx--TujvTR1u2nzot4Pq5A_ThmhhcCB21x6-RNNAJl9X9uUcT3gKfKVs3gjE0tm2K1vZfOkiGhjseIbwht2vBx0MnHteJpVW6U0pyCWG_tpBjrNBSj9yLoQZcqrtxYrWvPHaa9ljxfvaIsOnCZBGT7I552O1VRHWMj1lwNmRNZy5koJFPF7SbhiTM8eLkZVNdR3GEiofpzLCfoQXrr52YbiqjkYT94t3wz5C6u1JtBtgc2vq60HmR45bvg","refresh_token":"6ee95d017ada408697f2d19b04f7aa6c-r","expires_in":43199,"scope":"scim.userids openid sample.create cloud_controller.read password.write cloud_controller.write sample.view","jti":"0329c8ecdf594ee78c271e022138be9d"}通过使用该参数，您可以请求令牌为：token_format
-
不透明
-
JWT
9. 配置 - 本地
9.1. 功能切换
Spring Cloud Data Flow Server 提供了一组特定的功能，这些功能可以在启动时启用/禁用。这些功能包括以下各项的所有生命周期操作和 REST 端点（服务器和客户端实现，包括 shell 和 UI）：
-
流（需要 Skipper）
-
任务
-
任务计划程序
在启动数据流服务器时，可以通过设置以下布尔属性来启用和禁用这些功能：
-
spring.cloud.dataflow.features.streams-enabled -
spring.cloud.dataflow.features.tasks-enabled -
spring.cloud.dataflow.features.schedules-enabled
默认情况下，stream（需要 Skipper）和 tasks 处于启用状态，Task Scheduler 默认处于禁用状态。
REST 端点提供有关已启用和已禁用的功能的信息。/about
9.2. Java 主页
启动 Spring Cloud Data Flow 或 Skipper Server 时，他们可能需要知道 Java 17 home 的位置，以便成功启动 Spring Boot 3 应用程序。
通过传递以下属性，您可以提供路径。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-{project-version}.jar \
--spring.cloud.dataflow.defaults.boot3.local.javaHomePath=/usr/lib/jvm/java-17 \
--spring.cloud.dataflow.defaults.boot2.local.javaHomePath=/usr/lib/jvm/java-1.89.3. 数据库
关系数据库用于存储流和任务定义以及已执行任务的状态。 Spring Cloud Data Flow 为 MariaDB、MySQL、Oracle、PostgreSQL、Db2、SQL Server 和 H2 提供架构。架构是在服务器启动时自动创建的。
| 无需额外配置即可使用适用于 MariaDB、MySQL（通过 MariaDB 驱动程序）、PostgreSQL、SQL Server 的 JDBC 驱动程序。要使用任何其他数据库，您需要将相应的 JDBC 驱动程序 jar 放在服务器的 Classpath 上，如此处所述。 |
要配置数据库，必须设置以下属性：
-
spring.datasource.url -
spring.datasource.username -
spring.datasource.password -
spring.datasource.driver-class-name -
spring.jpa.database-platform
无论数据库如何，和 都是相同的。但是，每个数据库的 and 会有所不同，如下所示。usernamepasswordurldriver-class-name
| 数据库 | spring.datasource.url | spring.datasource.driver-class-name | spring.jpa.database-platform | 包括驱动程序 |
|---|---|---|---|---|
MariaDB 10.0 - 10.1 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB10Dialect |
是的 |
玛丽亚数据库 10.2 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB102Dialect |
是的 |
MariaDB 10.3 - 10.5 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB103Dialect |
是的 |
MariaDB 10.6+ |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB106Dialect[1] |
是的 |
MySQL 5.7 版本 |
jdbc：mysql：//${db-hostname}：${db-port}/${db-name}？permitMysqlScheme |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MySQL57方言 |
是的 |
MySQL 8.0+ 版本 |
jdbc：mysql：//${db-hostname}：${db-port}/${db-name}？allowPublicKeyRetrieval=true&useSSL=false&autoReconnect=true&permitMysqlScheme[2] |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MySQL8Dialect |
是的 |
PostgresSQL |
jdbc：postgres：//${db-hostname}：${db-port}/${db-name} |
org.postgresql.驱动程序 |
对于 Hibernate 默认，Remove |
是的 |
SQL 服务器 |
jdbc：sqlserver：//${db-hostname}：${db-port};数据库名称=${数据库名称}&encrypt=false |
com.microsoft.sqlserver.jdbc.SQLServerDriver |
对于 Hibernate 默认，Remove |
是的 |
DB2 |
jdbc：db2：//${db-hostname}：${db-port}/{db-name} |
com.ibm.db2.jcc.DB2Driver |
对于 Hibernate 默认，Remove |
不 |
神谕 |
jdbc：oracle：thin：@${db-hostname}：${db-port}/{db-name} |
oracle.jdbc.Oracle驱动程序 |
对于 Hibernate 默认，Remove |
不 |
9.3.1. H2
如果未配置其他数据库，则 Spring Cloud Data Flow 使用 H2 数据库的嵌入式实例作为默认实例。
| H2 适用于开发目的，但不建议用于生产，也不支持作为外部模式。 |
9.3.2. 数据库配置
在本地运行时，数据库属性可以作为环境变量或命令行参数传递给 Data Flow Server。例如，要使用命令行参数通过 MariaDB 启动服务器，请执行以下命令：
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.11.5.jar \
--spring.datasource.url=jdbc:mariadb://localhost:3306/mydb \
--spring.datasource.username=user \
--spring.datasource.password=pass \
--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver同样，要使用环境变量通过 MariaDB 启动服务器，请执行以下命令：
SPRING_DATASOURCE_URL=jdbc:mariadb://localhost:3306/mydb
SPRING_DATASOURCE_USERNAME=user
SPRING_DATASOURCE_PASSWORD=pass
SPRING_DATASOURCE_DRIVER_CLASS_NAME=org.mariadb.jdbc.Driver
SPRING_JPA_DATABASE_PLATFORM=org.hibernate.dialect.MariaDB106Dialect
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.11.5.jar9.3.3. 模式处理
默认情况下，数据库 schema 使用 Flyway 进行管理，如果 可以向数据库用户提供足够的权限。
以下是 Skipper 服务器启动时发生的情况说明：
-
Flyway 检查表是否存在。
flyway_schema_history -
如果 schema 不为空，则执行基线（到版本 1）作为 Dataflow 表 如果使用共享数据库，则可能已就位。
-
如果 schema 为空，则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
以下是 Dataflow 服务器启动时发生的情况说明：
-
Flyway 检查表是否存在。
flyway_schema_history_dataflow -
如果 schema 不为空，则执行基线（到版本 1），因为 Skipper 表 如果使用共享数据库，则可能已就位。
-
如果 schema 为空，则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
|
我们的源代码架构中有架构 ddl，如果使用 configuration 禁用了 Flyway，则可以手动使用这些 ddl 。如果公司的数据库
受到限制，即应用程序本身无法创建 schema。 |
9.4. Deployer 属性
您可以使用 Local Deployer 的以下配置属性来自定义 Streams 和 Task 的部署方式。
使用 Data Flow shell 进行部署时，可以使用语法 .有关 shell 用法的示例，请参见下文。
在数据流服务器中配置本地任务平台和 Skipper 中的本地平台以部署流时，也会使用这些属性。deployer.<appName>.local.<deployerPropertyName>
| Deployer 属性名称 | 描述 | 默认值 |
|---|---|---|
workingDirectoriesRoot |
所有创建的进程都将在其中运行并创建日志文件的目录。 |
java.io.tmpdir |
envVarsToInherit |
传递给已启动应用程序的环境变量的正则表达式模式数组。 |
<“TMP”， “LANG”， “LANGUAGE”， “LC_.*”， “PATH”， “SPRING_APPLICATION_JSON”> 在 UNIX 上<“TMP”， “LANG”， “LANGUAGE”， “LC_.*”， “PATH”> |
deleteFilesOnExit |
是否在 JVM 退出时删除已创建的文件和目录。 |
真 |
javaCmd 命令 |
运行 java 的命令 |
Java |
javaHomePath.<bootVersion 的 > |
用于启动应用程序的 JDK 安装路径，具体取决于其注册的 Boot 版本。 应为 或 。 |
系统属性 |
shutdownTimeout 超时 |
等待应用程序关闭的最大秒数。 |
30 |
javaOpts |
要传递给 JVM 的 Java 选项，例如 -Dtest=foo |
<没有> |
inheritLogging 的 |
允许将日志记录重定向到触发子进程的进程的输出流。 |
假 |
调试端口 |
用于远程调试的端口 |
<没有> |
例如，要为流中的时间应用程序设置 Java 选项，请使用以部署属性。ticktock
dataflow:> stream create --name ticktock --definition "time --server.port=9000 | log"
dataflow:> stream deploy --name ticktock --properties "deployer.time.local.javaOpts=-Xmx2048m -Dtest=foo"为方便起见，您可以设置该属性以设置 Java option ，如以下示例所示：deployer.memory-Xmx
dataflow:> stream deploy --name ticktock --properties "deployer.time.memory=2048m"在部署时，如果除了 option 的值之外，还在 property 中指定了一个选项，则该属性中的值具有优先权。此外，部署应用程序时设置的属性优先于 Data Flow Server 的属性。-Xmxdeployer.<app>.local.javaOptsdeployer.<app>.local.memoryjavaOptsjavaOptsspring.cloud.deployer.local.javaOpts
9.5. 日志记录
Spring Cloud Data Flow 服务器会自动配置为用于日志记录。
日志记录配置位于名为 的文件中包含的类路径上。localRollingFileAppenderlogback-spring.xml
默认情况下，日志文件配置为使用：
<property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}}/spring-cloud-dataflow-server-local.log}"/>使用 logback 配置的 ：RollingPolicy
<appender name="FILE"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${LOG_FILE}</file>
<rollingPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!-- daily rolling -->
<fileNamePattern>${LOG_FILE}.${LOG_FILE_ROLLING_FILE_NAME_PATTERN:-%d{yyyy-MM-dd}}.%i.gz</fileNamePattern>
<maxFileSize>${LOG_FILE_MAX_SIZE:-100MB}</maxFileSize>
<maxHistory>${LOG_FILE_MAX_HISTORY:-30}</maxHistory>
<totalSizeCap>${LOG_FILE_TOTAL_SIZE_CAP:-500MB}</totalSizeCap>
</rollingPolicy>
<encoder>
<pattern>${FILE_LOG_PATTERN}</pattern>
</encoder>
</appender>要检查当前 Spring Cloud Data Flow Server 服务器的 ，java.io.tmpdirlocal
jinfo <pid> | grep "java.io.tmpdir"如果要更改或覆盖任何属性 、 、 、 和 ，请将它们设置为系统属性。LOG_FILELOG_PATHLOG_TEMPLOG_FILE_MAX_SIZELOG_FILE_MAX_HISTORYLOG_FILE_TOTAL_SIZE_CAP
9.6. 流
Data Flow Server 将 Stream 生命周期的管理委托给 Skipper 服务器。将 configuration 属性设置为 Skipper 的位置，例如spring.cloud.skipper.client.serverUri
$ java -jar spring-cloud-dataflow-server-2.11.5.jar --spring.cloud.skipper.client.serverUri=https://192.51.100.1:7577/api流的部署方式和平台的配置是通过 Skipper 服务器上的配置来完成的。
有关更多信息，请参阅有关平台的文档。platform accounts
9.7. 任务
数据流服务器负责部署 Task。
由 Data Flow 启动的任务会将其状态写入 Data Flow 服务器使用的同一数据库。
对于作为 Spring Batch 作业的任务，作业和步骤执行数据也存储在此数据库中。
与 Skipper 启动的流一样，任务可以启动到多个平台。
如果未定义平台，则使用类 LocalDeployerProperties 的默认值创建一个名为 的平台，该值汇总在 Local Deployer Properties 表中default
要为本地平台配置新的平台帐户，请在文件中的部分下或通过其他 Spring Boot 支持的机制提供一个条目。
在以下示例中，创建了两个名为 和 的本地平台账户。
和 等键是本地部署程序属性。spring.cloud.dataflow.task.platform.localapplication.yamllocalDevlocalDevDebugshutdownTimeoutjavaOpts
spring:
cloud:
dataflow:
task:
platform:
local:
accounts:
localDev:
shutdownTimeout: 60
javaOpts: "-Dtest=foo -Xmx1024m"
localDevDebug:
javaOpts: "-Xdebug -Xmx2048m"通过定义一个平台，您可以跳过 使用，否则需要使用它。defaultplatformName |
启动任务时，使用任务启动选项传递平台帐户名称的值 如果未传递值 ，则将使用该值。--platformNameplatformNamedefault
| 将任务部署到多个平台时，任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置在本地运行的数据流服务器，以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息，请参阅 Cloud Foundry Task Platform Configuration 和 Kubernetes Task Platform Configuration 部分。
有关跨多个平台启动和计划任务的详细示例，请参阅本节 dataflow.spring.io 上的任务的多平台支持。
9.8. 安全配置
9.8.1. CloudFoundry 用户帐户和身份验证 （UAA） 服务器
请参阅 CloudFoundry 用户帐户和身份验证 （UAA） 服务器配置 部分，以了解有关如何配置本地测试和开发的详细信息。
9.8.2. LDAP 身份验证
LDAP 身份验证（轻量级目录访问协议）是间接的 由 Spring Cloud Data Flow 使用 UAA 提供。UAA 本身提供了全面的 LDAP 支持。
|
虽然您可以使用自己的 OAuth2 身份验证服务器，但 LDAP 支持 此处记录的需要使用 UAA 作为身份验证服务器。对于任何 其他提供商，请查阅该特定提供商的文档。 |
UAA 支持针对 LDAP（轻量级目录访问协议）的身份验证 server 使用以下模式：
|
与外部身份提供程序（如 LDAP）集成时，身份验证 在 UAA 中被链接。UAA 首先尝试使用 在外部提供程序之前针对 UAA 用户存储的用户凭据， LDAP 的 LDAP。有关更多信息，请参阅用户帐户和身份验证 LDAP 集成 GitHub 文档中的链式身份验证。 |
LDAP 角色映射
OAuth2 身份验证服务器 （UAA） 提供全面支持 用于将 LDAP 组映射到 OAuth 范围。
存在以下选项：
-
ldap/ldap-groups-null.xml不会映射任何组 -
ldap/ldap-groups-as-scopes.xml将从 LDAP 属性中检索组名称。例如CN -
ldap/ldap-groups-map-to-scopes.xml将使用 external_group_mapping 表将组映射到 UAA 组
这些值通过 configuration property 指定。幕后
这些值引用 Spring XML 配置文件。ldap.groups.file controls
|
在测试和开发过程中，可能需要频繁进行更改 添加到 LDAP 组和用户，并查看它们反映在 UAA 中。但是，用户 信息在登录期间缓存。以下脚本 有助于快速检索更新的信息： |
9.8.3. Spring Security OAuth2 资源/授权服务器示例
对于本地测试和开发，您还可以使用 Resource and Authorization Spring Security 提供的服务器支持。它 允许您通过配置 SecurityFilterChain 轻松创建自己的 OAuth2 服务器。
示例可以在以下位置找到：Spring Security 示例
9.8.4. 数据流 Shell 身份验证
使用 Shell 时，可以通过用户名和密码提供凭据 或通过指定 credentials-provider 命令。如果您的 OAuth2 提供商支持 密码授权类型，您可以使用以下方法启动数据流 Shell：
$ java -jar spring-cloud-dataflow-shell-2.11.5.jar \
--dataflow.uri=http://localhost:9393 \ (1)
--dataflow.username=my_username \ (2)
--dataflow.password=my_password \ (3)
--skip-ssl-validation \ (4)| 1 | 可选，默认为 localhost：9393。 |
| 2 | 命令的。 |
| 3 | 如果未提供密码，系统会提示用户输入密码。 |
| 4 | 可选，默认为 ，忽略证书错误（使用自签名证书时）。请谨慎使用！false |
| 请记住，启用 Spring Cloud Data Flow 的身份验证后， 底层 OAuth2 提供者必须支持密码 OAuth2 授权类型 如果您想通过用户名/密码身份验证来使用 Shell。 |
在 Data Flow Shell 中，您还可以使用以下命令提供凭据：
server-unknown:>dataflow config server \
--uri http://localhost:9393 \ (1)
--username myuser \ (2)
--password mysecret \ (3)
--skip-ssl-validation \ (4)| 1 | 可选，默认为 localhost：9393。 |
| 2 | 命令的。。 |
| 3 | 如果启用了安全性，但未提供密码，则系统会提示用户输入密码。 |
| 4 | 可选，忽略证书错误（使用自签名证书时）。请谨慎使用！ |
下图显示了用于连接和验证 Data 的典型 shell 命令 流服务器：
成功定位后，您应该会看到以下输出：
dataflow:>dataflow config info
dataflow config info
╔═══════════╤═══════════════════════════════════════╗
║Credentials│[username='my_username, password=****']║
╠═══════════╪═══════════════════════════════════════╣
║Result │ ║
║Target │http://localhost:9393 ║
╚═══════════╧═══════════════════════════════════════╝或者，您可以指定 credentials-provider 命令以
直接传入 Bearer Token，而不是提供用户名和密码。
这在 shell 中工作，或者在启动 Shell 时提供命令行参数。--dataflow.credentials-provider-command
|
使用 credentials-provider 命令时，请注意，您的 指定的命令必须返回 Bearer 令牌（以 Bearer 为前缀的 Access Token）。 例如，在 Unix 环境中，可以使用以下简单的命令： |
9.9. 关于 API 配置
Spring Cloud Data Flow About Restful API 结果包含显示名称 version，以及每个主要依赖项的 URL（如果指定） 包含 Spring Cloud Data Flow。结果（如果启用）还包含 sha1 和/或 sha256 校验和值。信息 ，可以通过设置以下内容来配置 性能：
| 属性名称 | 描述 |
|---|---|
spring.cloud.dataflow.version-info.spring-cloud-dataflow-core.name |
用于核心的名称 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-core.version |
用于核心的版本 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-dashboard.name |
要用于控制面板的名称 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-dashboard.version |
用于控制面板的版本 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-implementation.name |
用于实现的名称 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-implementation.version |
用于实现的版本 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.name |
要用于 shell 的名称 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.version |
用于 shell 的版本 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.url |
用于下载 shell 依赖项的 URL |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha1 |
与 shell 依赖项信息一起返回的 Sha1 校验和值 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256 |
与 shell 依赖项信息一起返回的 sha256 校验和值 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha1-url |
如果未指定 |
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256-url |
如果未指定 |
9.9.1. 启用 Shell 校验和值
默认情况下，不会显示 shell 依赖项的校验和值。如果
您需要启用此功能，请将 Property 设置为 True。spring.cloud.dataflow.version-info.dependency-fetch.enabled
9.9.2. URL 的保留值
有一些保留值（用大括号括起来）可以插入 确保链接是最新的 URL：
-
repository：如果使用 build-snapshot、milestone 或 Data Flow，存储库是指 repo-spring-io 存储库。否则，它会 指 Maven Central。 -
version：插入 jar/pom 的版本。
例如
https://myrepository/org/springframework/cloud/spring-cloud-dataflow-shell/{version}/spring-cloud-dataflow-shell-\{version}.jar生产
https://myrepository/org/springframework/cloud/spring-cloud-dataflow-shell/2.1.4/spring-cloud-dataflow-shell-2.11.0.jar如果您使用的是 Spring Cloud Data Flow Shell 的版本。2.11.0
10. 配置 - Cloud Foundry
本节介绍如何配置 Spring Cloud Data Flow 服务器的功能，例如安全性以及使用哪种关系数据库。 它还介绍了如何配置 Spring Cloud Data Flow shell 的功能。
10.1. 功能切换
数据流服务器提供了一组特定的功能，您可以在启动时启用或禁用这些功能。这些功能包括所有生命周期操作和 REST 端点（服务器、客户端实现，包括 Shell 和 UI）：
-
流
-
任务
可以通过在启动数据流服务器时设置以下布尔属性来启用或禁用这些功能：
-
spring.cloud.dataflow.features.streams-enabled -
spring.cloud.dataflow.features.tasks-enabled
默认情况下，所有功能都处于启用状态。
REST 端点 （） 提供有关已启用和已禁用功能的信息。/features
10.2. Deployer 属性
您可以使用 Data Flow 服务器的 Cloud Foundry 部署程序的以下配置属性来自定义应用程序的部署方式。
使用 Data Flow shell 进行部署时，可以使用语法 .有关 shell 用法的示例，请参见下文。
在 Data Flow 服务器中配置 Cloud Foundry 任务平台以及在 Skipper 中配置 Kubernetes 平台以部署 Streams 时，也会使用这些属性。deployer.<appName>.cloudfoundry.<deployerPropertyName>
| Deployer 属性名称 | 描述 | 默认值 |
|---|---|---|
服务业 |
要绑定到已部署应用程序的服务的名称。 |
<没有> |
主机 |
要用作路由一部分的主机名。 |
由 Cloud Foundry 派生的主机名 |
域 |
映射应用程序的路由时使用的域。 |
<没有> |
路线 |
应用程序应绑定到的路由列表。与 host 和 domain 互斥。 |
<没有> |
buildpack 构建包 |
用于部署应用程序的 buildpack。已弃用的 use buildpacks。 |
|
构建包 |
用于部署应用程序的 buildpack 列表。 |
|
记忆 |
要分配的内存量。默认单位为 MB，支持“M”和“G”后缀 |
1024 米 |
磁盘 |
要分配的磁盘空间量。默认单位为 MB，支持 'M' 和 'G' 后缀。 |
1024 米 |
健康检查 |
要对已部署的应用程序执行的运行状况检查的类型。值可以是 HTTP、NONE、PROCESS 和 PORT |
港口 |
healthCheckHttpEndpoint |
http 运行状况检查将使用的路径， |
/健康 |
healthCheckTimeout （健康检查超时） |
运行状况检查的超时值（以秒为单位）。 |
120 |
实例 |
要运行的实例数。 |
1 |
enableRandomAppNamePrefix |
Flag 启用使用随机前缀作为应用程序名称的前缀。 |
真 |
apiTimeout （api超时） |
阻止 API 调用的超时时间（以秒为单位）。 |
360 |
statusTimeout （状态超时） |
状态 API 操作的超时时间（以毫秒为单位） |
5000 |
使用 SpringApplicationJson |
用于指示应用程序属性是馈送到单独的环境变量中还是作为单独的环境变量馈送的标志。 |
真 |
暂存超时 |
为暂存应用程序分配的超时。 |
15 分钟 |
startupTimeout （启动超时） |
为启动应用程序分配的超时。 |
5 分钟 |
appName前缀 |
用作已部署应用程序名称前缀的字符串 |
使用 deployer 库的应用程序的 Spring Boot 属性。 |
删除路由 |
是否在取消部署应用程序时也删除路由。 |
真 |
javaOpts |
要传递给 JVM 的 Java 选项，例如 -Dtest=foo |
<没有> |
pushTasks已启用 |
是推送任务应用程序，还是假定应用程序在启动时已存在。 |
真 |
autoDeleteMavenArtifacts |
是否在部署时自动从本地存储库中删除 Maven 对象。 |
真 |
env.<key > |
定义顶级环境变量。这对于自定义 Java 构建包配置非常有用，该配置必须作为顶级环境变量包含在应用程序清单中，因为 Java 构建包无法识别。 |
部署程序确定应用程序的类路径中是否包含 Java CfEnv。如果是这样，它将应用所需的配置。 |
以下是使用 Cloud Foundry 部署属性的一些示例：
-
您可以设置用于部署每个应用程序的 buildpack。例如，要使用 Java 离线构建， 设置以下环境变量：
cf set-env dataflow-server SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_BUILDPACKS java_buildpack_offline-
setting 现在已弃用，取而代之的是 which 允许您根据需要传递多个。有关更多信息，请参阅 Buildpacks 的工作原理。
buildpackbuildpacks -
您可以自定义 Cloud Foundry 使用的运行状况检查机制，以使用环境变量来断言应用程序是否正在运行。当前支持的选项 are（默认值）、 和 .
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECKhttpportnone
您还可以设置环境变量，分别指定基于 HTTP 的运行状况检查终端节点和 timeout：和 。这些默认为 （Spring Boot 默认位置） 和 seconds。SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK_ENDPOINTSPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK_TIMEOUT/health120
-
您还可以使用 DSL 指定部署属性。例如，如果要将应用程序分配的内存设置为 512m，并将 postgres 服务绑定到应用程序，则可以运行以下命令：
httpjdbc
dataflow:> stream create --name postgresstream --definition "http | jdbc --tableName=names --columns=name"
dataflow:> stream deploy --name postgresstream --properties "deployer.http.memory=512, deployer.jdbc.cloudfoundry.services=postgres"|
您可以为流和任务应用程序单独配置这些设置。要更改任务的设置，
替换 for，如下例所示： |
10.3. 任务
数据流服务器负责部署 Task。
由 Data Flow 启动的任务会将其状态写入 Data Flow 服务器使用的同一数据库。
对于作为 Spring Batch 作业的任务，作业和步骤执行数据也存储在此数据库中。
与 Skipper 一样，任务可以启动到多个平台。
当 Data Flow 在 Cloud Foundry 上运行时，必须定义一个 Task 平台。
要配置面向 Cloud Foundry 的新平台帐户，请在文件中的 section for via another Spring Boot supported mechanism下提供一个条目。
在以下示例中，创建了两个名为 和 的 Cloud Foundry 平台帐户。
和 等键是 Cloud Foundry Deployer 属性。spring.cloud.dataflow.task.platform.cloudfoundryapplication.yamldevqamemorydisk
spring:
cloud:
dataflow:
task:
platform:
cloudfoundry:
accounts:
dev:
connection:
url: https://api.run.pivotal.io
org: myOrg
space: mySpace
domain: cfapps.io
username: [email protected]
password: drowssap
skipSslValidation: false
deployment:
memory: 512m
disk: 2048m
instances: 4
services: rabbit,postgres
appNamePrefix: dev1
qa:
connection:
url: https://api.run.pivotal.io
org: myOrgQA
space: mySpaceQA
domain: cfapps.io
username: [email protected]
password: drowssap
skipSslValidation: true
deployment:
memory: 756m
disk: 724m
instances: 2
services: rabbitQA,postgresQA
appNamePrefix: qa1通过定义一个平台，您可以跳过 使用，否则需要使用它。defaultplatformName |
启动任务时，使用任务启动选项传递平台帐户名称的值 如果未传递值 ，则将使用该值。--platformNameplatformNamedefault
| 将任务部署到多个平台时，任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置 Cloud Foundry 上的 Data Flow 服务器，以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息，请参阅 Kubernetes Task Platform 配置部分。
有关跨多个平台启动和计划任务的详细示例，请参阅本节 dataflow.spring.io 上的任务的多平台支持。
10.4. 应用程序名称和前缀
为了帮助避免与 Cloud Foundry 中跨空间的路由发生冲突，为
deployed application 可用，并且默认处于启用状态。您可以使用命令覆盖默认配置并设置相应的属性。cf set-env
例如，如果要禁用随机化，可以使用以下命令覆盖它：
cf set-env dataflow-server SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_ENABLE_RANDOM_APP_NAME_PREFIX false10.5. 自定义路由
作为随机名称的替代方法，或者为了更好地控制已部署应用程序使用的主机名，您可以使用 自定义部署属性，如下例所示：
dataflow:>stream create foo --definition "http | log"
sdataflow:>stream deploy foo --properties "deployer.http.cloudfoundry.domain=mydomain.com,
deployer.http.cloudfoundry.host=myhost,
deployer.http.cloudfoundry.route-path=my-path"前面的示例将应用程序绑定到 URL。请注意，此
example 显示所有可用的自定义选项。在实践中，您只能使用这三者中的一两个。httpmyhost.mydomain.com/my-path
10.6. Docker 应用程序
从版本 1.2 开始，可以使用 Cloud Foundry 的数据流。
如果使用 Spring Boot 和基于 RabbitMQ 的 Docker 镜像，则可以提供通用的部署属性
以方便将 App 绑定到 RabbitMQ 服务。假设您的 RabbitMQ 服务名为 ，您可以提供以下内容：rabbit
cf set-env dataflow-server SPRING_APPLICATION_JSON '{"spring.cloud.dataflow.applicationProperties.stream.spring.rabbitmq.addresses": "${vcap.services.rabbit.credentials.protocols.amqp.uris}"}'对于 Spring Cloud Task 应用程序，如果您使用名为 ：postgres
cf set-env SPRING_DATASOURCE_URL '${vcap.services.postgres.credentials.jdbcUrl}'
cf set-env SPRING_DATASOURCE_USERNAME '${vcap.services.postgres.credentials.username}'
cf set-env SPRING_DATASOURCE_PASSWORD '${vcap.services.postgres.credentials.password}'
cf set-env SPRING_DATASOURCE_DRIVER_CLASS_NAME 'org.mariadb.jdbc.Driver'
cf set-env SPRING_JPA_DATABASE_PLATFORM 'org.hibernate.dialect.MariaDB106Dialect'对于非 Java 或非 Boot 应用程序，您的 Docker 应用程序必须解析变量才能绑定到任何可用服务。VCAP_SERVICES
|
传递应用程序属性
使用非引导应用程序时，您可能希望使用传统的
环境变量，而不是使用特殊变量。为此，请将
以下变量分别用于 Streams 和 Task： |
10.7. 应用程序级服务绑定
在 Cloud Foundry 中部署流时，您可以利用特定于应用程序的服务绑定，因此并非所有 为 Spring Cloud Data Flow 编排的所有应用程序全局配置服务。
例如，如果您只想为以中的应用程序提供服务绑定
定义，你可以将服务绑定作为 deployment 属性传递：postgresjdbc
dataflow:>stream create --name httptojdbc --definition "http | jdbc"
dataflow:>stream deploy --name httptojdbc --properties "deployer.jdbc.cloudfoundry.services=postgresService"其中 是专门绑定到应用程序的服务名称，并且应用程序没有通过该方法获取到绑定。postgresServicejdbchttp
如果要绑定多个服务，则可以将它们作为逗号分隔的项目传递
（例如：）。deployer.jdbc.cloudfoundry.services=postgresService,someService
10.8. 配置 Service binding 参数
CloudFoundry API 支持在绑定服务实例时提供配置参数。某些 Service Broker 需要 或 推荐绑定配置。 例如，使用 CF CLI 绑定 Google Cloud Platform 服务如下所示：
cf bind-service my-app my-google-bigquery-example -c '{"role":"bigquery.user"}'同样，NFS 卷服务支持绑定配置，例如：
cf bind-service my-app nfs_service_instance -c '{"uid":"1000","gid":"1000","mount":"/var/volume1","readonly":true}'从版本 2.0 开始，Data Flow for Cloud Foundry 允许您提供绑定配置参数，这些参数可以在应用程序级别或服务器级别部署属性中提供。例如，要绑定到 nfs 服务，如上所述：cloudfoundry.services
dataflow:> stream deploy --name mystream --properties "deployer.<app>.cloudfoundry.services='nfs_service_instance uid:1000,gid:1000,mount:/var/volume1,readonly:true'"该格式旨在与 Data Flow DSL 解析器兼容。
通常，部署属性接受逗号分隔的值。
由于逗号也用于分隔配置参数，并且为了避免空格问题，因此包括配置参数在内的任何项目都必须用单引号括起来。有效值包括：cloudfoundry.services
rabbitmq,'nfs_service_instance uid:1000,gid:1000,mount:/var/volume1,readonly:true',postgres,'my-google-bigquery-example role:bigquery.user'单引号中允许使用空格，并且可以代替键值对分隔。=: |
10.9. 用户提供的服务
除了市场服务之外，Cloud Foundry 还支持用户提供的服务 （UPS）。在本参考手册中， 已经提到了常规服务，但没有什么可以排除使用用户提供的服务，无论是用作 消息传递中间件（例如，如果您想使用外部 Apache Kafka 安装）或供某些 流应用程序（例如，Oracle Database）的 Bean Database。
现在，我们回顾从 UPS 提取和提供连接凭证的示例。
以下示例显示了 Apache Kafka 的 UPS 设置示例：
cf create-user-provided-service kafkacups -p '{”brokers":"HOST:PORT","zkNodes":"HOST:PORT"}'UPS 凭证包装在 中，可以直接在流定义中提供，如
以下示例显示。VCAP_SERVICES
stream create fooz --definition "time | log"
stream deploy fooz --properties "app.time.spring.cloud.stream.kafka.binder.brokers=${vcap.services.kafkacups.credentials.brokers},app.time.spring.cloud.stream.kafka.binder.zkNodes=${vcap.services.kafkacups.credentials.zkNodes},app.log.spring.cloud.stream.kafka.binder.brokers=${vcap.services.kafkacups.credentials.brokers},app.log.spring.cloud.stream.kafka.binder.zkNodes=${vcap.services.kafkacups.credentials.zkNodes}"10.10. 数据库连接池
从 Data Flow 2.0 开始，Spring Cloud 连接器库不再用于创建 DataSource。 现在使用库 java-cfenv，它允许您设置 Spring Boot 属性以配置连接池。
10.11. 最大磁盘配额
默认情况下，Cloud Foundry 中的每个应用程序都以 1G 磁盘配额开始，这可以调整为默认的最大值 2G 的。通过使用 Pivotal Cloud Foundry （PCF） Ops Manager GUI，默认最大值也可以覆盖高达 10G。
此配置与 Spring Cloud Data Flow 相关，因为每个任务部署都由应用程序组成 （通常是 Spring Boot uber-jar 的），并且这些应用程序是从远程 maven 存储库解析的。解决后， 应用程序构件将下载到本地 Maven 存储库以进行缓存和重用。在后台发生此事后， 默认磁盘配额 （1G） 可能会迅速填满，尤其是当我们试验 由独特的应用程序组成。为了克服这个磁盘限制并依赖于 根据您的扩展要求，您可能希望将默认最大值从 2G 更改为 10G。让我们回顾一下 更改默认最大磁盘配额分配的步骤。
10.12. 扩展应用程序
成功应用磁盘配额更改后，假设您有一个正在运行的应用程序，
您可以通过 CF CLI 使用新的应用程序进行扩展，如下例所示：disk_limit
→ cf scale dataflow-server -k 10GB
Scaling app dataflow-server in org ORG / space SPACE as user...
OK
....
....
....
....
state since cpu memory disk details
#0 running 2016-10-31 03:07:23 PM 1.8% 497.9M of 1.1G 193.9M of 10G然后，您可以列出应用程序并查看新的最大磁盘空间，如下例所示：
→ cf apps
Getting apps in org ORG / space SPACE as user...
OK
name requested state instances memory disk urls
dataflow-server started 1/1 1.1G 10G dataflow-server.apps.io10.13. 管理磁盘使用
即使将 Data Flow 服务器配置为使用 10G 空间，也有可能耗尽
本地磁盘上的可用空间。为防止这种情况，无论部署请求是否成功，只要部署应用程序，都会自动删除从外部源（即注册为或资源的应用程序）下载的项目。
此行为最适合容器运行时稳定性比部署期间产生的 I/O 延迟更关键的生产环境。
在开发环境中，部署会更频繁地进行。此外，工件（或更轻的 jar）包含描述应用程序配置属性的元数据
它由与应用程序配置相关的各种操作使用，在预生产活动期间更频繁地执行（有关详细信息，请参阅 应用程序元数据）。
为了在预生产环境中使用更多的磁盘，以牺牲更多的磁盘使用为代价，提供响应速度更快的交互式开发人员体验，您可以将 CloudFoundry deployer 属性设置为。jarhttpmavenjarmetadataautoDeleteMavenArtifactsfalse
如果使用默认运行状况检查类型部署 Data Flow 服务器，则必须显式监视服务器上的磁盘空间，以避免空间不足。
如果使用运行状况检查类型部署服务器（请参阅下一个示例），则当磁盘空间不足时，数据流服务器将重新启动。
这是由于 Spring Boot 的磁盘空间健康指示器。
您可以使用具有前缀的属性来配置 Disk Space Health Indicator 的设置。porthttpmanagement.health.diskspace
对于版本 1.7，我们正在研究使用 Data Flow 服务器的卷服务来存储构件，然后再将其推送到 Cloud Foundry。.jar
以下示例显示如何将运行状况检查类型部署到名为 ：http/management/health
---
...
health-check-type: http
health-check-http-endpoint: /management/health10.14. 应用程序解析替代方案
虽然我们建议使用 Maven Artifactory for application 注册 Stream Application， 在某些情况下，以下替代方法之一可能有意义。
-
在 Spring Boot 的帮助下，我们可以在 Cloud Foundry 中提供静态内容。一个简单的 Spring Boot 应用程序可以捆绑所有必需的 stream 和 task 应用程序。通过拥有它 在 Cloud Foundry 上运行，然后静态应用程序可以为 über-jar 的 .例如，您可以从 shell 中注册 application 的名称为 。
http-source.jar--uri=http://<Route-To-StaticApp>/http-source.jar -
über-jar 可以托管在任何可通过 HTTP 访问的外部服务器上。它们可以从原始 GitHub URI 中解析 也。例如，在 shell 中，您可以使用 .
http-source.jar--uri=http://<Raw_GitHub_URI>/http-source.jar -
Cloud Foundry 中的静态 Buildpack 支持是另一个 选择。类似的 HTTP 解析也适用于此模型。
-
Volume Services 是另一个不错的选择。 所需的 über-jar 可以托管在外部文件系统中。在 volume-services 的帮助下，您可以 示例，使用 Name 注册应用程序。
http-source.jar--uri=file://<Path-To-FileSystem>/http-source.jar
10.15. 安全性
默认情况下，数据流服务器不安全，并在未加密的 HTTP 连接上运行。您可以保护您的 REST 终端节点
（以及 Data Flow Dashboard）通过启用 HTTPS 并要求客户端进行身份验证。
有关保护
REST 端点并配置为针对 OAUTH 后端（在 Cloud Foundry 上运行的 UAA 和 SSO）进行身份验证，
请参阅核心 Security Configuration 中的 security 部分。您可以在安全详细信息中配置安全详细信息，也可以通过命令将其作为环境变量传递。dataflow-server.ymlcf set-env
10.15.1. 身份验证
Spring Cloud Data Flow 可以与 Pivotal Single Sign-On Service 集成 （例如，在 PWS 上）或 Cloud Foundry 用户帐户和身份验证 （UAA） 服务器。
Pivotal Single Sign-On 服务
将 Spring Cloud Data Flow 部署到 Cloud Foundry 时，您可以将 应用程序添加到 Pivotal Single Sign-On 服务。通过这样做，Spring Cloud Data Flow 利用了 Java CFEnv、 它为 OAuth 2.0 提供特定于 Cloud Foundry 的自动配置支持。
为此，请将 Pivotal Single Sign-On 服务绑定到 Data Flow Server 应用程序，然后 提供以下属性：
SPRING_CLOUD_DATAFLOW_SECURITY_CFUSEUAA: false (1)
SECURITY_OAUTH2_CLIENT_CLIENTID: "${security.oauth2.client.clientId}"
SECURITY_OAUTH2_CLIENT_CLIENTSECRET: "${security.oauth2.client.clientSecret}"
SECURITY_OAUTH2_CLIENT_ACCESSTOKENURI: "${security.oauth2.client.accessTokenUri}"
SECURITY_OAUTH2_CLIENT_USERAUTHORIZATIONURI: "${security.oauth2.client.userAuthorizationUri}"
SECURITY_OAUTH2_RESOURCE_USERINFOURI: "${security.oauth2.resource.userInfoUri}"| 1 | 请务必将属性设置为spring.cloud.dataflow.security.cf-use-uaafalse |
非 Cloud Foundry 安全场景同样支持授权。 请参阅核心 Data Flow 安全配置中的安全部分。
由于不同环境中的角色配置可能差异很大，因此我们通过以下方式 default 将所有 Spring Cloud Data Flow 角色分配给用户。
您可以通过提供自己的 AuthoritiesExtractor 来自定义此行为。
以下示例显示了在 上设置 custom 的一种方法 ：AuthoritiesExtractorUserInfoTokenServices
public class MyUserInfoTokenServicesPostProcessor
implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
if (bean instanceof UserInfoTokenServices) {
final UserInfoTokenServices userInfoTokenServices == (UserInfoTokenServices) bean;
userInfoTokenServices.setAuthoritiesExtractor(ctx.getBean(AuthoritiesExtractor.class));
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
然后，您可以在 configuration 类中声明它，如下所示：
@Bean
public BeanPostProcessor myUserInfoTokenServicesPostProcessor() {
BeanPostProcessor postProcessor == new MyUserInfoTokenServicesPostProcessor();
return postProcessor;
}
Cloud Foundry UAA
Cloud Foundry 用户帐户和身份验证 （UAA） 的可用性取决于 Cloud Foundry 环境。
为了提供 UAA 集成，您必须提供必要的
OAuth2 配置属性（例如，通过设置属性）。SPRING_APPLICATION_JSON
以下 JSON 示例显示如何创建安全配置：
{
"security.oauth2.client.client-id": "scdf",
"security.oauth2.client.client-secret": "scdf-secret",
"security.oauth2.client.access-token-uri": "https://login.cf.myhost.com/oauth/token",
"security.oauth2.client.user-authorization-uri": "https://login.cf.myhost.com/oauth/authorize",
"security.oauth2.resource.user-info-uri": "https://login.cf.myhost.com/userinfo"
}默认情况下，该属性设置为 。此属性将激活一个名为 的特殊 AuthoritiesExtractor 。spring.cloud.dataflow.security.cf-use-uaatrueCloudFoundryDataflowAuthoritiesExtractor
如果不使用 CloudFoundry UAA，则应设置为 。spring.cloud.dataflow.security.cf-use-uaafalse
在幕后，这呼唤了 Cloud Foundry
Apps API 并确保用户实际上是 Space 开发人员。AuthoritiesExtractor
如果已验证的用户被验证为 Space Developer，则会分配所有角色。
10.16. 配置参考
您必须提供几项配置。这些是 Spring Boot ，因此您可以设置
它们作为环境变量或通过 Spring Boot 支持的任何其他方式。以下清单位于 environment 中
变量格式，因为这是开始在 Cloud Foundry 中配置 Boot 应用程序的一种简单方法。
请注意，将来您将能够将任务部署到多个平台，但对于 2.0.0.M1，您只能部署到单个平台，并且名称必须为 。@ConfigurationPropertiesdefault
# Default values appear after the equal signs.
# Example values, typical for Pivotal Web Services, are included as comments.
# URL of the CF API (used when using cf login -a for example) - for example, https://api.run.pivotal.io
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL=
# The name of the organization that owns the space above - for example, youruser-org
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG=
# The name of the space into which modules will be deployed - for example, development
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE=
# The root domain to use when mapping routes - for example, cfapps.io
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_DOMAIN=
# The user name and password of the user to use to create applications
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME=
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD
# The identity provider to be used when accessing the Cloud Foundry API (optional).
# The passed string has to be a URL-Encoded JSON Object, containing the field origin with value as origin_key of an identity provider - for example, {"origin":"uaa"}
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_LOGIN_HINT=
# Whether to allow self-signed certificates during SSL validation (you should NOT do so in production)
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SKIP_SSL_VALIDATION
# A comma-separated set of service instance names to bind to every deployed task application.
# Among other things, this should include an RDBMS service that is used
# for Spring Cloud Task execution reporting, such as my_postgres
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES
spring.cloud.deployer.cloudfoundry.task.services=
# Timeout, in seconds, to use when doing blocking API calls to Cloud Foundry
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_API_TIMEOUT=
# Timeout, in milliseconds, to use when querying the Cloud Foundry API to compute app status
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_STATUS_TIMEOUT请注意，您可以使用快捷方式设置 、 或 Spring Cloud Deployer-standard，并将其作为单个部署请求的一部分，如下例所示：spring.cloud.deployer.cloudfoundry.servicesspring.cloud.deployer.cloudfoundry.buildpacksspring.cloud.deployer.memoryspring.cloud.deployer.diskdeployer.<app-name>
stream create --name ticktock --definition "time | log"
stream deploy --name ticktock --properties "deployer.time.memory=2g"前面示例中的命令部署具有 2048MB 内存的时间源，而日志接收器使用默认的 1024MB。
在部署流时，您还可以作为部署属性传递，如下例所示：JAVA_OPTS
stream deploy --name ticktock --properties "deployer.time.cloudfoundry.javaOpts=-Duser.timezone=America/New_York"10.17. 调试
如果您想更好地了解部署流和任务时发生的情况，您可能需要 以打开以下功能：
-
Reactor “stacktraces”，显示在错误发生之前涉及哪些 Operator。此功能非常有用，因为部署程序 依赖于 Project Reactor 和常规的 StackTrace 可能并不总是允许在错误发生之前理解流程。 请注意，这会带来性能损失，因此默认情况下处于禁用状态。
spring.cloud.dataflow.server.cloudfoundry.debugReactor == true-
Deployer 和 Cloud Foundry 客户端库请求和响应日志。此功能允许查看 Data Flow 服务器和 Cloud Foundry Cloud Controller。
logging.level.cloudfoundry-client == DEBUG10.18. Spring Cloud 配置服务器
您可以使用 Spring Cloud Config Server 集中 Spring Boot 应用程序的配置属性。 同样，Spring Cloud Data Flow 和由 Spring Cloud Data Flow 编排的应用程序都可以与配置服务器集成，以使用相同的功能。
10.18.1. Stream、Task 和 Spring Cloud Config Server
与 Spring Cloud Data Flow 服务器类似，您可以配置 stream 和 task 应用程序，以解析来自配置服务器的集中属性。
为已部署的应用程序设置属性是绑定到配置服务器的常用方法。
有关更多信息，请参阅 Spring Cloud Config Client 参考指南。spring.cloud.config.uri
由于此属性可能用于所有已部署的应用程序，因此数据流服务器的流应用程序属性和任务应用程序属性可用于将 Config Server 的 传递到每个已部署的流或任务应用程序。请参阅 通用应用程序属性 以了解更多信息。spring.cloud.dataflow.applicationProperties.streamspring.cloud.dataflow.applicationProperties.taskuri
请注意，如果您使用开箱即用的 Stream Applications，则这些应用程序已经嵌入了依赖项。
如果您从头开始构建应用程序并希望添加对 config server 的客户端支持，则可以向 config server 客户端库添加依赖项引用。以下代码段显示了一个 Maven 示例：spring-cloud-services-starter-config-client
...
<dependency>
<groupId>io.pivotal.spring.cloud</groupId>
<artifactId>spring-cloud-services-starter-config-client</artifactId>
<version>CONFIG_CLIENT_VERSION</version>
</dependency>
...其中可以是 Pivotal Cloud Foundry 的 Spring Cloud Config Server 客户端的最新版本。CONFIG_CLIENT_VERSION
如果使用此库的应用程序无法连接到配置，您可能会看到一条日志记录消息
server （应用程序启动时以及访问端点时）。
如果您知道您没有使用配置服务器功能，则可以通过将环境变量设置为 来禁用客户端库。WARN/healthSPRING_CLOUD_CONFIG_ENABLEDfalse |
10.18.2. 示例 Manifest 模板
以下 SCDF 和 Skipper 模板包括 Skipper 和 Spring Cloud Data Flow 服务器以及部署的应用程序和任务所需的环境变量，以便在 Cloud Foundry 上成功运行并在运行时自动解析集中式属性：manifest.ymlmy-config-server
applications:
- name: data-flow-server
host: data-flow-server
memory: 2G
disk_quota: 2G
instances: 1
path: {PATH TO SERVER UBER-JAR}
env:
SPRING_APPLICATION_NAME: data-flow-server
MAVEN_REMOTEREPOSITORIES_REPO1_URL: https://my.custom.repo/prod-repo
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL: https://api.sys.huron.cf-app.com
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG: sabby20
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE: sabby20
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_DOMAIN: apps.huron.cf-app.com
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME: admin
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD: ***
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SKIP_SSL_VALIDATION: true
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES: postgres
SPRING_CLOUD_SKIPPER_CLIENT_SERVER_URI: https://<skipper-host-name>/api
services:
- postgres
- my-config-serverapplications:
- name: skipper-server
host: skipper-server
memory: 1G
disk_quota: 1G
instances: 1
timeout: 180
buildpack: java_buildpack
path: <PATH TO THE DOWNLOADED SKIPPER SERVER UBER-JAR>
env:
SPRING_APPLICATION_NAME: skipper-server
SPRING_CLOUD_SKIPPER_SERVER_ENABLE_LOCAL_PLATFORM: false
SPRING_CLOUD_SKIPPER_SERVER_STRATEGIES_HEALTHCHECK_TIMEOUTINMILLIS: 300000
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL: https://api.local.pcfdev.io
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG: pcfdev-org
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE: pcfdev-space
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_DOMAIN: cfapps.io
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME: admin
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD: admin
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SKIP_SSL_VALIDATION: false
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_DELETE_ROUTES: false
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES: rabbit,my-config-server
services:
- postgres
my-config-server其中 是在 Cloud Foundry 上运行的 Spring Cloud Config Service 实例的名称。my-config-server
通过将服务分别绑定到 Spring Cloud Data Flow 服务器、Spring Cloud Task 和通过 Skipper 绑定到所有 Spring Cloud Stream 应用程序，我们现在可以解析由此服务支持的集中式属性。
10.18.3. 自签名 SSL 证书和 Spring Cloud Config Server
通常，在开发环境中，我们可能没有有效的证书来启用客户端和后端服务之间的 SSL 通信。 但是，Pivotal Cloud Foundry 的配置服务器使用 HTTPS 进行所有客户端到服务的通信，因此我们需要在没有有效证书的环境中添加自签名 SSL 证书。
通过使用上一节中列出的相同模板，我们可以通过设置 来提供自签名 SSL 证书。manifest.ymlTRUST_CERTS: <API_ENDPOINT>
但是，部署的应用程序还需要作为平面环境变量（而不是包装在 Inner），因此我们必须使用另一组令牌 （） 来指示服务器执行任务。
通过此设置，应用程序将接收其应用程序属性作为常规环境变量。TRUST_CERTSSPRING_APPLICATION_JSONSPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_USE_SPRING_APPLICATION_JSON: false
以下清单显示了包含所需更改的更新。数据流服务器和已部署的应用程序
从 Cloud Config 服务器（部署为 Cloud Foundry 服务）获取其配置。manifest.ymlmy-config-server
applications:
- name: test-server
host: test-server
memory: 1G
disk_quota: 1G
instances: 1
path: spring-cloud-dataflow-server-VERSION.jar
env:
SPRING_APPLICATION_NAME: test-server
MAVEN_REMOTEREPOSITORIES_REPO1_URL: https://my.custom.repo/prod-repo
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL: https://api.sys.huron.cf-app.com
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG: sabby20
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE: sabby20
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_DOMAIN: apps.huron.cf-app.com
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME: admin
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD: ***
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SKIP_SSL_VALIDATION: true
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES: postgres, config-server
SPRING_CLOUD_SKIPPER_CLIENT_SERVER_URI: https://<skipper-host-name>/api
TRUST_CERTS: <API_ENDPOINT> #this is for the server
SPRING_CLOUD_DATAFLOW_APPLICATION_PROPERTIES_TASK_TRUST_CERTS: <API_ENDPOINT> #this propagates to all tasks
services:
- postgres
- my-config-server #this is for the server此外，将服务添加到 Skipper 的清单环境中my-config-server
applications:
- name: skipper-server
host: skipper-server
memory: 1G
disk_quota: 1G
instances: 1
timeout: 180
buildpack: java_buildpack
path: <PATH TO THE DOWNLOADED SKIPPER SERVER UBER-JAR>
env:
SPRING_APPLICATION_NAME: skipper-server
SPRING_CLOUD_SKIPPER_SERVER_ENABLE_LOCAL_PLATFORM: false
SPRING_CLOUD_SKIPPER_SERVER_STRATEGIES_HEALTHCHECK_TIMEOUTINMILLIS: 300000
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL: <URL>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG: <ORG>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE: <SPACE>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_DOMAIN: <DOMAIN>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME: <USER>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD: <PASSWORD>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES: rabbit, my-config-server #this is so all stream applications bind to my-config-server
services:
- postgres
my-config-server10.19. 配置 Scheduling
本节讨论如何配置 Spring Cloud Data Flow 以连接到 PCF-Scheduler 作为其代理来执行任务。
|
在按照这些说明操作之前，请确保在 Cloud Foundry 空间中运行 PCF-Scheduler 服务的实例。
要在您的空间中创建 PCF-Scheduler（假设它位于 Market Place 中），请从 CF CLI 执行以下命令：.
服务名称稍后用于在 PCF 中绑定正在运行的应用程序。 |
对于计划，您必须在环境中添加（或更新）以下环境变量：
-
通过设置为 来启用 Spring Cloud 数据流的调度。
spring.cloud.dataflow.features.schedules-enabledtrue -
通过将 PCF-Scheduler 服务名称添加到环境变量，将 Task Deployer 绑定到您的 PCF-Scheduler 实例。
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES -
通过设置环境变量建立 PCF-Scheduler 的 URL。
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_SCHEDULER_SCHEDULER_URL
|
创建上述配置后，您必须创建需要计划的所有任务定义。 |
以下示例清单显示了已配置的两个环境属性（假设您有名为 的 PCF-Scheduler 服务）：myscheduler
applications:
- name: data-flow-server
host: data-flow-server
memory: 2G
disk_quota: 2G
instances: 1
path: {PATH TO SERVER UBER-JAR}
env:
SPRING_APPLICATION_NAME: data-flow-server
SPRING_CLOUD_SKIPPER_SERVER_ENABLE_LOCAL_PLATFORM: false
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_URL: <URL>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_ORG: <ORG>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_SPACE: <SPACE>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_DOMAIN: <DOMAIN>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_USERNAME: <USER>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_CONNECTION_PASSWORD: <PASSWORD>
SPRING_CLOUD_SKIPPER_SERVER_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES: rabbit, myscheduler
SPRING_CLOUD_DATAFLOW_FEATURES_SCHEDULES_ENABLED: true
SPRING_CLOUD_SKIPPER_CLIENT_SERVER_URI: https://<skipper-host-name>/api
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_SCHEDULER_SCHEDULER_URL: https://scheduler.local.pcfdev.io
services:
- postgres其中 的格式如下：scheduler.<Domain-Name> （对于
示例，scheduler.local.pcfdev.io）。检查您的 _PCF 环境中的实际地址。SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]SCHEDULER_SCHEDULER_URL
| 有关跨多个平台启动和计划任务的详细示例，请参阅本节 dataflow.spring.io 上的任务的多平台支持。 |
11. 配置 - Kubernetes
本节介绍如何配置 Spring Cloud Data Flow 功能，例如部署程序属性、任务以及要使用的关系数据库。
11.1. 功能切换
数据流服务器提供了一组特定的功能，这些功能可以在启动时启用或禁用。这些功能包括所有生命周期操作、REST 端点（服务器和客户端实现，包括 Shell 和 UI）：
-
流
-
任务
-
附表
您可以通过在启动 Data Flow 服务器时设置以下布尔环境变量来启用或禁用这些功能：
-
SPRING_CLOUD_DATAFLOW_FEATURES_STREAMS_ENABLED -
SPRING_CLOUD_DATAFLOW_FEATURES_TASKS_ENABLED -
SPRING_CLOUD_DATAFLOW_FEATURES_SCHEDULES_ENABLED
默认情况下，所有功能都处于启用状态。
REST 端点提供有关已启用和已禁用的功能的信息。/features
11.2. 应用程序和服务器属性
本节介绍如何自定义应用程序的部署。您可以使用许多属性来影响已部署应用程序的设置。属性可以基于每个应用程序应用，也可以应用于所有已部署应用程序的相应服务器配置中。
| 基于每个应用程序设置的属性始终优先于设置为服务器配置的属性。这种安排允许您基于每个应用程序覆盖全局服务器级别属性。 |
要应用于所有已部署任务的属性在文件中定义，而 Streams 的属性在 中定义。替换为您正在使用的消息传递中间件 — 例如，或 .src/kubernetes/server/server-config-[binder].yamlsrc/kubernetes/skipper/skipper-config-[binder].yaml[binder]rabbitkafka
11.2.1. 内存和 CPU 设置
应用程序使用默认内存和 CPU 设置进行部署。如果需要，您可以调整这些值。以下示例演示如何设置为 for 和 for memory，以及 to for CPU 和 for memory：Limits1000mCPU1024MiRequests800m640Mi
deployer.<application>.kubernetes.limits.cpu=1000m
deployer.<application>.kubernetes.limits.memory=1024Mi
deployer.<application>.kubernetes.requests.cpu=800m
deployer.<application>.kubernetes.requests.memory=640Mi这些值将导致使用以下容器设置：
Limits:
cpu: 1
memory: 1Gi
Requests:
cpu: 800m
memory: 640Mi您还可以控制将 和 全局设置为的默认值。cpumemory
以下示例显示如何设置流的 CPU 和内存：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
limits:
memory: 640mi
cpu: 500m以下示例说明如何设置任务的 CPU 和内存：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
limits:
memory: 640mi
cpu: 500m到目前为止，我们使用的设置仅影响容器的设置。它们不会影响容器中 JVM 进程的内存设置。如果要设置 JVM 内存设置，可以设置环境变量来执行此操作。有关详细信息，请参阅下一节。
11.2.2. 环境变量
要影响给定应用程序的环境设置，您可以使用 deployer 属性。
例如，生产环境中的常见要求是影响 JVM 内存参数。
您可以使用环境变量来执行此操作，如下例所示：spring.cloud.deployer.kubernetes.environmentVariablesJAVA_TOOL_OPTIONS
deployer.<application>.kubernetes.environmentVariables=JAVA_TOOL_OPTIONS=-Xmx1024m该属性接受逗号分隔的字符串。如果环境变量包含值
这也是一个逗号分隔的字符串，它必须用单引号引起来——例如，environmentVariablesspring.cloud.deployer.kubernetes.environmentVariables=spring.cloud.stream.kafka.binder.brokers='somehost:9092,
anotherhost:9093'
|
这将覆盖所需 JVM 内存设置（替换为应用程序的名称）。<application><application>
11.2.3. 活跃度、就绪性和启动探针
和 探测器分别使用称为 和 的路径。它们分别对 和 a of 和 and 使用 a of 。您可以在部署流时使用 Deployer 属性更改这些默认值。liveness 和 readiness 探测仅适用于流。livenessreadiness/health/liveness/health/readinessdelay1period6010
在容器重新启动应用程序之前，探测器将使用 path 和 delay 30 和 period for 3，故障阈值为 20 次。startup/health
以下示例通过设置 deployer 属性来更改 and 探针（替换为应用程序的名称）：livenessstartup<application>
deployer.<application>.kubernetes.livenessProbePath=/health/livesness
deployer.<application>.kubernetes.livenessProbeDelay=1
deployer.<application>.kubernetes.livenessProbePeriod=60
deployer.<application>.kubernetes.livenessProbeSuccess=1
deployer.<application>.kubernetes.livenessProbeFailure=3
deployer.<application>.kubernetes.readinessProbePath=/health/readiness
deployer.<application>.kubernetes.readinessProbeDelay=1
deployer.<application>.kubernetes.readinessProbePeriod=60
deployer.<application>.kubernetes.readinessProbeSuccess=1
deployer.<application>.kubernetes.readinessProbeFailure=3
deployer.<application>.kubernetes.startupHttpProbePath=/health
deployer.<application>.kubernetes.startupProbeDelay=20
deployer.<application>.kubernetes.startupProbeSuccess=1
deployer.<application>.kubernetes.startupProbeFailure=30
deployer.<application>.kubernetes.startupProbePeriod=5
deployer.<application>.kubernetes.startupProbeTimeout=3您可以声明 Same as the part of the server global configuration for streams，如下例所示：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
livenessHttpProbePath: /health/liveness
livenessProbeDelay: 1
livenessProbePeriod: 60
livenessProbeSuccess: 1
livenessProbeFailure: 3
startupHttpProbePath: /health
startupProbeDelay: 20
startupProbeSuccess: 1
startupProbeFailure: 30
startupProbePeriod: 5
startupProbeTimeout: 3同样，您可以 swap for 覆盖默认设置。livenessreadinessreadiness
默认情况下，端口 8080 用作探测端口。您可以使用 deployer 属性更改 和 probe ports 的默认值，如下例所示：livenessreadiness
deployer.<application>.kubernetes.readinessProbePort=7000
deployer.<application>.kubernetes.livenessProbePort=7000
deployer.<application>.kubernetes.startupProbePort=7000您可以将 SAME 声明为 AS the PART of the global configuration for streams，如下例所示：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
readinessProbePort: 7000
livenessProbePort: 7000
startupProbePort: 7000|
默认情况下，和 probe 路径使用 Spring Boot 2.x+ 执行器端点。要使用 Spring Boot 1.x 执行器端点路径，必须调整and值，如下例所示（替换为应用程序的名称）： 探测路径将默认为管理路径，但可以根据需要进行修改。 要基于每个应用程序自动将 both 和 endpoints 设置为默认的 Spring Boot 1.x 路径，可以设置以下属性： |
您可以使用存储在 Kubernetes 密钥中的凭证访问安全的探测终端节点。您可以使用现有密钥，前提是凭证包含在密钥块的密钥名称下。您可以按应用程序配置探测身份验证。启用后，它将使用相同的凭证和身份验证类型应用于探测终端节点。目前仅支持身份验证。credentialsdatalivenessreadinessBasic
要创建新密钥，请执行以下操作：
-
使用用于访问安全探测端点的凭证生成 base64 字符串。
基本身份验证将用户名和密码编码为 base64 字符串，格式为 .
username:password以下示例（包括输出，您应该在其中替换 and 替换为您的值）显示了如何生成 base64 字符串：
userpass$ echo -n "user:pass" | base64 dXNlcjpwYXNz -
使用编码的凭据，创建包含以下内容的文件（例如 ）：
myprobesecret.ymlapiVersion: v1 kind: Secret metadata: name: myprobesecret type: Opaque data: credentials: GENERATED_BASE64_STRING -
替换为之前生成的 base64 编码值。
GENERATED_BASE64_STRING -
使用 创建 密钥，如下例所示：
kubectl$ kubectl create -f ./myprobesecret.yml secret "myprobesecret" created -
将以下 Deployer 属性设置为在访问探测端点时使用身份验证，如下例所示：
deployer.<application>.kubernetes.probeCredentialsSecret=myprobesecret替换为要应用身份验证的应用程序的名称。
<application>
11.2.4. 使用SPRING_APPLICATION_JSON
可以使用环境变量来设置数据流服务器属性（包括 Maven 存储库设置的配置），这些属性在所有数据流服务器实现中都是通用的。这些设置位于部署 YAML 的 container 部分的服务器级别。以下示例显示了如何执行此操作：SPRING_APPLICATION_JSONenv
env:
- name: SPRING_APPLICATION_JSON
value: "{ \"maven\": { \"local-repository\": null, \"remote-repositories\": { \"repo1\": { \"url\": \"https://my.custom.repo/prod-repo\"} } } }"11.2.5. 私有 Docker 注册表
您可以按应用程序从私有注册表中提取 Docker 镜像。首先，您必须在集群中创建一个密钥。按照 从私有注册表拉取映像 指南创建密钥。
创建密钥后，您可以使用该属性设置要使用的密钥，如下例所示：imagePullSecret
deployer.<application>.kubernetes.imagePullSecret=mysecret替换为您的应用程序的名称和您之前创建的密钥的名称。<application>mysecret
您还可以在全局服务器级别配置映像拉取密钥。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
imagePullSecret: mysecret以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
imagePullSecret: mysecret替换为您之前创建的密钥的名称。mysecret
11.2.6. 注解
您可以按应用程序向 Kubernetes 对象添加注释。支持的对象类型包括 pod 、 和 。注释以某种格式定义，允许使用多个注释以逗号分隔。有关注释的更多信息和使用案例，请参阅注释。DeploymentServiceJobkey:value
以下示例显示如何配置应用程序以使用注释：
deployer.<application>.kubernetes.podAnnotations=annotationName:annotationValue
deployer.<application>.kubernetes.serviceAnnotations=annotationName:annotationValue,annotationName2:annotationValue2
deployer.<application>.kubernetes.jobAnnotations=annotationName:annotationValue替换为应用程序的名称和注释的值。<application>
11.2.7. 入口点样式
入口点样式会影响将应用程序属性传递到要部署的容器的方式。目前支持三种样式：
-
exec（默认）：将部署请求中的所有应用程序属性和命令行参数作为容器参数传递。应用程序属性将转换为 .--key=value -
shell：将所有应用程序属性和命令行参数作为环境变量传递。每个 applicationor 命令行参数属性都转换为大写字符串，并且字符将替换为 。._ -
boot：创建一个环境变量，该变量包含所有应用程序属性的 JSON 表示形式。部署请求中的命令行参数设置为 container args。SPRING_APPLICATION_JSON
| 在所有情况下，在服务器级配置和基于每个应用程序定义的环境变量都会按原样发送到容器。 |
您可以按如下方式配置应用程序：
deployer.<application>.kubernetes.entryPointStyle=<Entry Point Style>替换为您的应用程序名称和所需的入口点样式。<application><Entry Point Style>
您还可以在 Global Server 级别配置入口点样式。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
entryPointStyle: entryPointStyle以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
entryPointStyle: entryPointStyle替换为所需的入口点样式。entryPointStyle
您应该选择 或 的入口点样式，以对应于在容器的 .有关更多信息和用例 versus ，请参阅 Docker 文档的 ENTRYPOINT 部分。execshellENTRYPOINTDockerfileexecshell
使用入口点样式对应于使用样式 .来自部署请求的命令行参数将传递到容器，并添加应用程序属性映射到环境变量中，而不是命令行参数。bootexecENTRYPOINTSPRING_APPLICATION_JSON
使用入口点样式时，该属性不得包含 .bootdeployer.<application>.kubernetes.environmentVariablesSPRING_APPLICATION_JSON |
11.2.8. 部署服务帐户
您可以通过属性为应用程序部署配置自定义服务账户。您可以使用现有服务账户或创建新账户。创建服务账户的一种方法是使用 ，如下例所示：kubectl
$ kubectl create serviceaccount myserviceaccountname
serviceaccount "myserviceaccountname" created然后，您可以按如下方式配置各个应用程序：
deployer.<application>.kubernetes.deploymentServiceAccountName=myserviceaccountname替换为您的应用程序名称和您的服务账户名称。<application>myserviceaccountname
您还可以在全局服务器级别配置服务帐户名称。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
deploymentServiceAccountName: myserviceaccountname以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
deploymentServiceAccountName: myserviceaccountname替换为要应用于所有部署的服务帐户名称。myserviceaccountname
11.2.9. 镜像拉取策略
镜像拉取策略定义何时应将 Docker 镜像拉取到本地注册表。目前支持三种策略：
-
IfNotPresent（默认）：如果镜像已存在，则不拉取该镜像。 -
Always：始终拉取图像，无论它是否已经存在。 -
Never：从不拉取图像。仅使用已存在的映像。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.imagePullPolicy=IfNotPresent替换为您的应用程序名称和所需的映像提取策略。<application>Always
您可以在全局服务器级别配置镜像拉取策略。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
imagePullPolicy: IfNotPresent以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
imagePullPolicy: Always替换为所需的映像提取策略。Always
11.2.10. 部署标签
您可以为与 Deployment 相关的对象设置自定义标签。有关标签的更多信息，请参阅标签。标签以 format 指定。key:value
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.deploymentLabels=myLabelName:myLabelValue替换为您的应用程序名称、您的标签名称和标签的值。<application>myLabelNamemyLabelValue
此外，您还可以应用多个标签，如下例所示：
deployer.<application>.kubernetes.deploymentLabels=myLabelName:myLabelValue,myLabelName2:myLabelValue211.2.11. 容忍度
容忍度与污点一起工作，以确保 Pod 不会被调度到特定节点上。 容忍度被设置到 Pod 配置中，而污点被设置到节点上。 有关更多信息，请参阅 Kubernetes 参考的污点和容忍度部分。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.tolerations=[{key: 'mykey', operator: 'Equal', value: 'myvalue', effect: 'NoSchedule'}]根据所需的容忍度配置，替换为您的应用程序名称和键值对。<application>
您也可以在 Global Server 级别配置容忍度。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
tolerations:
- key: mykey
operator: Equal
value: myvalue
effect: NoSchedule以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
tolerations:
- key: mykey
operator: Equal
value: myvalue
effect: NoSchedule根据所需的容忍度配置替换键值对。tolerations
11.2.12. 秘密引用
可以引用 Secret，并且可以解码其整个数据内容，并将其作为单个变量插入 Pod 环境中。 有关更多信息，请参阅 Kubernetes 参考的将密钥中的所有键值对配置为容器环境变量部分。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.secretRefs=testsecret您还可以指定多个密钥，如下所示：
deployer.<application>.kubernetes.secretRefs=[testsecret,anothersecret]替换为您的应用程序的名称，并将属性替换为适用于您的应用程序环境和密钥的值。<application>secretRefs
您也可以在全局服务器级别配置 secret 引用。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
secretRefs:
- testsecret
- anothersecret以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
secretRefs:
- testsecret
- anothersecret将 的项替换为一个或多个密钥名称。secretRefs
11.2.13. 密钥引用
可以引用 Secret，并且可以将其解码值插入到 Pod 环境中。 有关更多信息，请参阅 Kubernetes 参考的 Using Secrets as Environment Variables 部分。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.secretKeyRefs=[{envVarName: 'MY_SECRET', secretName: 'testsecret', dataKey: 'password'}]替换为您的应用程序的名称，并将 、 和 属性替换为适用于您的应用程序环境和密钥的值。<application>envVarNamesecretNamedataKey
您还可以在 Global Server 级别配置密钥引用。
以下示例显示如何对流执行此操作：
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
secretKeyRefs:
- envVarName: MY_SECRET
secretName: testsecret
dataKey: password以下示例说明如何对任务执行此操作：
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
secretKeyRefs:
- envVarName: MY_SECRET
secretName: testsecret
dataKey: password将 、 和 属性替换为密钥的适当值。envVarNamesecretNamedataKey
11.2.14. ConfigMap 引用
可以引用 ConfigMap，并且可以解码其整个数据内容，并将其作为单个变量插入到 Pod 环境中。 有关更多信息，请参阅 Kubernetes 参考的将 ConfigMap 中的所有键值对配置为容器环境变量部分。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.configMapRefs=testcm您还可以指定多个 ConfigMap 实例，如下所示：
deployer.<application>.kubernetes.configMapRefs=[testcm,anothercm]替换为您的应用程序名称，并将属性替换为适用于您的应用程序环境和 ConfigMap 的值。<application>configMapRefs
您也可以在全局服务器级别配置 ConfigMap 引用。
以下示例演示如何对流执行此操作。编辑相应的 ，替换为正在使用的相应活页夹：skipper-config-(binder).yaml(binder)
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
configMapRefs:
- testcm
- anothercm以下示例显示了如何通过编辑文件对任务执行此操作：server-config.yaml
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
configMapRefs:
- testcm
- anothercm将 的项替换为一个或多个密钥名称。configMapRefs
11.2.15. ConfigMap 键引用
可以引用 ConfigMap，并将其关联的键值插入到 Pod 环境中。 有关更多信息，请参阅 Kubernetes 参考的使用 ConfigMap 数据定义容器环境变量部分。
以下示例显示了如何单独配置应用程序：
deployer.<application>.kubernetes.configMapKeyRefs=[{envVarName: 'MY_CM', configMapName: 'testcm', dataKey: 'platform'}]替换为应用程序的名称，将 、 和 属性替换为适用于您的应用程序环境和 ConfigMap 的值。<application>envVarNameconfigMapNamedataKey
您也可以在全局服务器级别配置 ConfigMap 引用。
以下示例演示如何对流执行此操作。编辑相应的 ，替换为正在使用的相应活页夹：skipper-config-(binder).yaml(binder)
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
configMapKeyRefs:
- envVarName: MY_CM
configMapName: testcm
dataKey: platform以下示例显示了如何通过编辑文件对任务执行此操作：server-config.yaml
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
configMapKeyRefs:
- envVarName: MY_CM
configMapName: testcm
dataKey: platform将 、 和 属性替换为 ConfigMap 的相应值。envVarNameconfigMapNamedataKey
11.2.16. Pod 安全上下文
Pod 安全上下文指定 Pod 及其容器的安全设置。
以下示例显示了如何为单个应用程序 Pod 配置安全上下文：
deployer.<application>.kubernetes.podSecurityContext={runAsUser: 65534, fsGroup: 65534, supplementalGroups: [65534, 65535], seccompProfile: { type: 'RuntimeDefault' }}替换为您的应用程序名称，并将任何属性替换为适用于您的容器环境的值。<application>
你也可以在全局服务器级别配置 Pod 安全上下文。
以下示例演示如何对流执行此操作。编辑相应的 ，替换为正在使用的相应活页夹：skipper-config-(binder).yaml(binder)
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
podSecurityContext:
runAsUser: 65534
fsGroup: 65534
supplementalGroups: [65534,65535]
seccompProfile:
type: Localhost
localhostProfile: my-profiles/profile-allow.json以下示例显示了如何通过编辑文件对任务执行此操作：server-config.yaml
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
podSecurityContext:
runAsUser: 65534
fsGroup: 65534
supplementalGroups: [65534,65535]
seccompProfile:
type: Localhost
localhostProfile: my-profiles/profile-allow.json使用适合您的容器环境的值调整属性。podSecurityContext
11.2.17. 容器安全上下文
容器安全上下文指定单个容器的安全设置。
| 容器安全上下文将应用于部署中的所有容器，除非它们已经明确定义了自己的安全性，包括常规 init 容器、有状态集 init 容器和其他容器。 |
以下示例显示了如何为单个应用程序 Pod 中的容器配置安全上下文：
deployer.<application>.kubernetes.containerSecurityContext={allowPrivilegeEscalation: true, runAsUser: 65534}替换为您的应用程序名称，并将任何属性替换为适用于您的容器环境的值。<application>
您也可以在全局服务器级别配置容器安全上下文。
以下示例演示如何对流执行此操作。编辑相应的 ，替换为正在使用的相应活页夹：skipper-config-(binder).yaml(binder)
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
containerSecurityContext:
allowPrivilegeEscalation: true
runAsUser: 65534以下示例显示了如何通过编辑文件对任务执行此操作：server-config.yaml
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
containerSecurityContext:
allowPrivilegeEscalation: true
runAsUser: 65534使用适合您的容器环境的值调整属性。containerSecurityContext
11.2.18. 服务端口
部署应用程序时，将创建一个默认端口为 .如果设置了该属性，它将覆盖默认端口值。您可以基于每个应用程序向 Service 对象添加其他端口。您可以使用逗号分隔符添加多个端口。8080server.port
以下示例显示了如何在应用程序的 Service 对象上配置其他端口：
deployer.<application>.kubernetes.servicePorts=5000
deployer.<application>.kubernetes.servicePorts=5000,9000替换为您的应用程序名称和端口的值。<application>
11.2.19. StatefulSet 初始化容器
使用 StatefulSet 部署应用程序时，使用 Init Container 在 Pod 中设置实例索引。
默认情况下，使用的图像是 ，您可以对其进行自定义。busybox
以下示例显示了如何单独配置应用程序 Pod：
deployer.<application>.kubernetes.statefulSetInitContainerImageName=myimage:mylabel替换为您的应用程序的名称，并将 attribute 替换为适合您的环境的值。<application>statefulSetInitContainerImageName
您也可以在全局服务器级别配置 StatefulSet Init Container。
以下示例演示如何对流执行此操作。编辑相应的 ，替换为正在使用的相应活页夹：skipper-config-(binder).yaml(binder)
data:
application.yaml: |-
spring:
cloud:
skipper:
server:
platform:
kubernetes:
accounts:
default:
statefulSetInitContainerImageName: myimage:mylabel以下示例显示了如何通过编辑文件对任务执行此操作：server-config.yaml
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
statefulSetInitContainerImageName: myimage:mylabel将属性替换为适合您环境的值。statefulSetInitContainerImageName
11.2.20. 初始化容器
部署应用程序时，您可以基于每个应用程序设置自定义 Init Container。 有关更多信息，请参阅 Kubernetes 参考的 Init Containers 部分。
以下示例显示了如何为应用程序配置一个 Init Container 或多个 Init Containers：
deployer.<application>.kubernetes.initContainer={containerName: 'test', imageName: 'busybox:latest', commands: ['sh', '-c', 'echo hello']}
# alternative for multiple init containers
deployer.<application>.kubernetes.initContainers=[{containerName:'test', imageName: 'busybox:latest', commands: ['sh', '-c', 'echo hello']}, {containerName:'test2', imageName:'busybox:latest', commands:['sh', '-c', 'echo world']}]
# multiple containers can be created inidividually
deployer.<application>.kubernetes.initContainers[0]={containerName:'test', imageName:'busybox:latest', commands:['sh', '-c', 'echo hello']}
deployer.<application>.kubernetes.initContainers[1]={containerName:'test2', imageName:'busybox:latest', commands:['sh', '-c', 'echo world']}替换为应用程序的名称，并设置适用于您的 Init Container 的属性值。<application>initContainer
11.2.21. 生命周期支持
在部署应用程序时，您可以附加 和 Lifecycle 处理程序来执行命令。
Kubernetes API 支持除 之外的其他类型的处理程序。此功能可能会扩展以支持未来版本中的其他操作。
要配置生命周期处理程序，如上面的链接页面所示，请使用以下属性键将每个命令指定为逗号分隔的列表：postStartpreStopexec
deployer.<application>.kubernetes.lifecycle.postStart.exec.command=/bin/sh,-c,'echo Hello from the postStart handler > /usr/share/message'
deployer.<application>.kubernetes.lifecycle.preStop.exec.command=/bin/sh,-c,'nginx -s quit; while killall -0 nginx; do sleep 1; done'11.2.22. 其他容器
部署应用程序时，可能需要将一个或多个容器与主容器一起部署。 这将允许您调整一些部署模式，例如 sidecar、适配器（在多容器 pod 设置的情况下）。
以下示例显示了如何为应用程序配置其他容器：
deployer.<application>.kubernetes.additionalContainers=[{name: 'c1', image: 'busybox:1', command: ['sh', '-c', 'echo hello1'], volumeMounts: [{name: 'test-volume', mountPath: '/tmp', readOnly: true}]},{name: 'c2', image: 'busybox:1.26.1', command: ['sh', '-c', 'echo hello2']}]11.3. Deployer 属性
您可以使用 Kubernetes 部署程序的以下配置属性来自定义 Streams 和 Task 的部署方式。
使用 Data Flow shell 进行部署时，可以使用语法 .
在 Data Flow 服务器和 Skipper 中的 Kubernetes 平台中配置 Kubernetes 任务平台以部署 Streams 时，也会使用这些属性。deployer.<appName>.kubernetes.<deployerPropertyName>
| Deployer 属性名称 | 描述 | 默认值 |
|---|---|---|
Namespace |
要使用的命名空间 |
环境变量，否则 |
deployment.nodeSelector |
要应用于 Deployment 的节点选择器格式。多个节点选择器以逗号分隔。 |
<没有> |
imagePullSecret |
用于访问私有注册表以拉取镜像的 Secret。 |
<没有> |
imagePullPolicy |
拉取镜像时要应用的镜像拉取策略。有效选项包括 、 和 。 |
IfNotPresent |
livenessProbeDelay |
应用程序容器的 Kubernetes 活动性检查应开始检查其运行状况时的延迟（以秒为单位）。 |
10 |
livenessProbePeriod |
执行应用程序容器的 Kubernetes 活动检查的周期（以秒为单位）。 |
60 |
livenessProbeTimeout |
应用程序容器的 Kubernetes 活动性检查超时（以秒为单位）。如果运行状况检查返回的时间超过此值，则假定其为“不可用”。 |
2 |
livenessProbePath |
应用程序容器必须响应以进行活动检查的路径。 |
<没有> |
livenessProbePort |
应用程序容器必须响应以进行活动性检查的端口。 |
<没有> |
startupProbeDelay |
应用程序容器的 Kubernetes 启动检查应开始检查其运行状况时的延迟（以秒为单位）。 |
30 |
startupProbePeriod |
执行应用程序容器的 Kubernetes 启动检查的周期（以秒为单位）。 |
3 |
startupProbeFailure |
在 Pod 重启之前允许的启动探测失败次数。 |
20 |
startupHttpProbePath |
应用程序容器必须响应启动检查的路径。 |
<没有> |
startupProbePort |
应用程序容器必须响应以进行启动检查的端口。 |
<没有> |
readinessProbeDelay |
应用程序容器的就绪情况检查应开始检查模块是否已完全启动并运行时的延迟（以秒为单位）。 |
10 |
readinessProbePeriod （就绪探针周期） |
执行应用程序容器就绪情况检查的时间段（以秒为单位）。 |
10 |
readinessProbeTimeout （准备探测超时） |
应用程序容器在就绪情况检查期间必须响应其运行状况的超时（以秒为单位）。 |
2 |
readinessProbePath （就绪探针路径） |
应用程序容器必须响应以进行就绪情况检查的路径。 |
<没有> |
就绪探针端口 |
应用程序容器必须响应以进行就绪情况检查的端口。 |
<没有> |
探针凭据密钥 |
包含访问安全探测终端节点时使用的凭证的密钥名称。 |
<没有> |
limits.memory |
内存限制，分配 Pod 所需的最大值，默认单位为 MB，支持“M”和“G”后缀 |
<没有> |
limits.cpu 的 |
CPU 限制，分配 Pod 所需的最大值 |
<没有> |
limits.ephemeral-storage |
ephemeral-storage 限制，分配 Pod 所需的最大值。 |
<没有> |
limits.hugepages-2Mi |
hugepages-2Mi 限制，分配 Pod 所需的最大值。 |
<没有> |
limits.hugepages-1Gi |
hugepages-1Gi 限制，分配 Pod 所需的最大值。 |
<没有> |
requests.memory （请求内存） |
内存请求，保证分配 Pod 所需的值。 |
<没有> |
requests.cpu 的 |
CPU 请求，保证分配 Pod 所需的值。 |
<没有> |
requests.ephemeral-storage |
ephemeral-storage 请求，保证分配 Pod 所需的值。 |
<没有> |
requests.hugepages-2Mi |
hugepages-2Mi 请求，保证分配 Pod 所需的值。 |
<没有> |
requests.hugepages-1Gi |
hugepages-1Gi 请求，保证分配 Pod 所需的值。 |
<没有> |
affinity.nodeAffinity |
以 YAML 格式表示的节点关联性。例如 |
<没有> |
affinity.podAffinity |
以 YAML 格式表示的 Pod 亲和性。例如 |
<没有> |
affinity.podAntiAffinity |
以 YAML 格式表示的 Pod 反亲和性。例如 |
<没有> |
statefulSet.volumeClaimTemplate.storageClassName |
有状态集的存储类的名称 |
<没有> |
statefulSet.volumeClaimTemplate.storage |
仓储量。默认单位为 MB，支持“M”和“G”后缀 |
<没有> |
环境变量 |
要为任何已部署的应用程序容器设置的环境变量列表 |
<没有> |
entryPointStyle |
用于 Docker 镜像的入口点样式。用于确定如何传入属性。可以是 、 和 |
|
创建负载均衡器 |
为每个应用程序创建的服务创建一个 “LoadBalancer”。这有助于将外部 IP 分配给应用程序。 |
假 |
serviceAnnotations |
要为每个应用程序创建的服务设置的服务注释。格式的字符串 |
<没有> |
pod注解 |
要为每个部署创建的 Pod 设置的 Pod 注释。格式的字符串 |
<没有> |
jobAnnotations |
要为作业创建的 Pod 或作业设置的作业注释。格式的字符串 |
<没有> |
priorityClassName |
Pod Spec priorityClassName 的 Pod Spec priorityClassName 中。在使用此属性之前，请在 Kubernetes 中创建一个 PriorityClass。参见 Pod 优先级和抢占 |
<没有> |
shareProcess命名空间 |
将为 Pod.spec.shareProcessNamespace 赋值。参见 在 Pod 中的容器之间共享进程命名空间 |
<没有> |
minutesToWaitForLoadBalancer |
在尝试删除服务之前等待负载均衡器可用的时间（以分钟为单位）。 |
5 |
maxTerminatedErrorRestarts |
由于错误或过度使用资源而失败的应用程序允许的最大重启次数。 |
2 |
maxCrashLoopBackOffRestarts |
CrashLoopBackOff 中的应用允许的最大重启次数。值为 、 、 |
|
volumeMounts |
以 YAML 格式表示的卷挂载。例如 |
<没有> |
卷 |
Kubernetes 实例支持的卷以 YAML 格式指定。例如 |
<没有> |
主机网络 |
部署的 hostNetwork 设置，请参阅 kubernetes.io/docs/api-reference/v1/definitions/#_v1_podspec |
假 |
createDeployment |
使用 “Replica Set” 而不是 “Replication Controller” 创建 “Deployment”。 |
真 |
createJob |
在启动任务时创建一个 “Job” 而不仅仅是一个 “Pod”。 |
假 |
containerCommand |
使用提供的命令和参数覆盖默认入口点命令。 |
<没有> |
容器端口 |
添加要在容器上公开的其他端口。 |
<没有> |
createNodePort |
要使用的显式端口 when 是类型。 |
<没有> |
deploymentServiceAccountName |
应用程序部署中使用的服务帐户名称。注意：用于应用程序部署的服务帐户名称派生自 Data Flow 服务器部署。 |
<没有> |
deploymentLabels |
要以格式添加到部署的其他标签。多个标签以逗号分隔。 |
<没有> |
bootMajorVersion |
要使用的 Spring Boot 主要版本。目前仅用于自动配置 Spring Boot 版本特定的探测路径。有效选项为 或 。 |
2 |
tolerations.key |
用于 tolement 的键。 |
<没有> |
tolerations.effect |
容忍效应。有关有效选项，请参阅 kubernetes.io/docs/concepts/configuration/taint-and-toleration。 |
<没有> |
tolerations.operator |
容忍运算符。请参阅 kubernetes.io/docs/concepts/configuration/taint-and-toleration/ 以获取有效选项。 |
<没有> |
tolerations.tolerationSeconds |
定义添加污点后 Pod 将保持绑定到节点的时间的秒数。 |
<没有> |
tolerations.value |
要应用的 toleration 值，与 to select to appropriate 结合使用。 |
<没有> |
secretRefs |
用于将整个数据内容加载到单个环境变量中的密钥的名称。多个密钥可以用逗号分隔。 |
<没有> |
secretKeyRefs.envVarName |
用于保存密钥数据的环境变量名称 |
<没有> |
secretKeyRefs.secretName |
要访问的密钥名称 |
<没有> |
secretKeyRefs.dataKey |
要从中获取 secret 数据的密钥名称 |
<没有> |
configMapRefs |
用于将整个数据内容加载到单个环境变量中的 ConfigMap 的名称。多个 ConfigMap 以逗号分隔。 |
<没有> |
configMapKeyRefs.envVarName |
用于保存 ConfigMap 数据的环境变量名称 |
<没有> |
configMapKeyRefs.configMapName |
要访问的 ConfigMap 名称 |
<没有> |
configMapKeyRefs.dataKey |
要从中获取 ConfigMap 数据的键名称 |
<没有> |
maximumConcurrentTasks |
此平台实例允许的最大并发任务数 |
20 |
podSecurityContext |
应用于 Pod 的安全上下文，以 YAML 格式表示。例如 .请注意，这定义了整个 Pod 安全上下文 - 安全上下文的较小部分可以通过以下属性进行配置。 |
<没有> |
podSecurityContext.runAsUser |
用于运行 Pod 容器进程的数字用户 ID |
<没有> |
podSecurityContext.runAsGroup |
用于运行容器进程入口点的数字组 ID |
<没有> |
podSecurityContext.runAsNonRoot |
指示容器必须以非 root 用户身份运行 |
<没有> |
podSecurityContext.fsGroup |
Pod 卷的数字组 ID |
<没有> |
podSecurityContext.fsGroupChangePolicy |
定义在 Pod 中公开卷之前更改卷的所有权和权限的行为（仅适用于支持基于 fsGroup 的所有权和权限的卷类型）- 可能的值为 “OnRootMismatch”、“Always” |
<没有> |
podSecurityContext.supplementalGroups |
除了容器的主组 ID 外，应用于 Pod 容器进程的数字组 ID |
<没有> |
podSecurityContext.seccomp配置文件 |
用于以 YAML 格式表示的 Pod 容器的 seccomp 选项。例如 |
<没有> |
podSecurityContext.seLinuxOptions |
要应用于以 YAML 格式表示的 Pod 容器的 SELinux 上下文。例如 （当 spec.os.name 为 Windows 时不使用）。 |
<没有> |
podSecurityContext.sysctls |
用于 Pod 的命名空间 sysctl 列表，以 YAML 格式表示。例如 （当 spec.os.name 为 Windows 时不使用）。 |
<没有> |
podSecurityContext.windowsOptions |
应用于以 YAML 格式表示的所有容器的 Windows 特定设置。例如 （仅在 spec.os.name 为 Windows 时使用）。 |
<没有> |
containerSecurityContext |
应用于以 YAML 格式表示的容器的安全上下文。例如 .请注意，这定义了整个容器安全上下文 - 安全上下文的较小部分可以通过以下属性进行配置。 |
<没有> |
containerSecurityContext.allowPrivilegeEscalation |
进程是否可以获得比其父进程更多的权限 |
<没有> |
containerSecurityContext.capabilities |
以 YAML 格式表示的容器运行时的添加/删除功能。例如 （仅在 spec.os.name 不是 Windows 时使用） |
<没有> |
containerSecurityContext.privileged |
在特权模式下运行容器。 |
<没有> |
containerSecurityContext.procMount |
用于容器的 proc 挂载类型（仅在 spec.os.name 不是 Windows 时使用） |
<没有> |
containerSecurityContext.readOnlyRootFile系统 |
将容器的根文件系统挂载为只读 |
<没有> |
containerSecurityContext.runAsUser |
用于运行 Pod 容器进程的数字用户 ID |
<没有> |
containerSecurityContext.runAsGroup |
用于运行容器进程入口点的数字组 ID |
<没有> |
containerSecurityContext.runAsNonRoot |
指示容器必须以非 root 用户身份运行 |
<没有> |
containerSecurityContext.seccomp配置文件 |
用于以 YAML 格式表示的 Pod 容器的 seccomp 选项。例如 |
<没有> |
containerSecurityContext.seLinux选项 |
要应用于以 YAML 格式表示的 Pod 容器的 SELinux 上下文。例如 （当 spec.os.name 为 Windows 时不使用）。 |
<没有> |
containerSecurityContext.sysctls |
用于 Pod 的命名空间 sysctl 列表，以 YAML 格式表示。例如 （当 spec.os.name 为 Windows 时不使用）。 |
<没有> |
containerSecurityContext.windowsOptions |
应用于以 YAML 格式表示的所有容器的 Windows 特定设置。例如 （仅在 spec.os.name 为 Windows 时使用）。 |
<没有> |
statefulSetInitContainerImageName |
用于 StatefulSet Init Container 的自定义镜像名称 |
<没有> |
initContainer （初始化容器） |
以 YAML 格式表示的 Init Container，可应用于 Pod。例如 |
<没有> |
additionalContainers |
以 YAML 格式表示的其他容器，以应用于 Pod。例如 |
<没有> |
11.4. 任务
数据流服务器负责部署 Task。
由 Data Flow 启动的任务会将其状态写入 Data Flow 服务器使用的同一数据库。
对于作为 Spring Batch 作业的任务，作业和步骤执行数据也存储在此数据库中。
与 Skipper 一样，任务可以启动到多个平台。
当 Data Flow 在 Kubernetes 上运行时，必须定义 Task 平台。
要配置面向 Kubernetes 的新平台帐户，请在文件中的 section for via another Spring Boot supported mechanism下提供一个条目。
在以下示例中，创建了两个名为 和 的 Kubernetes 平台账户。
和 等键是 Cloud Foundry Deployer 属性。spring.cloud.dataflow.task.platform.kubernetesapplication.yamldevqamemorydisk
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
dev:
namespace: devNamespace
imagePullPolicy: IfNotPresent
entryPointStyle: exec
limits:
cpu: 4
qa:
namespace: qaNamespace
imagePullPolicy: IfNotPresent
entryPointStyle: boot
limits:
memory: 2048m通过定义一个平台，您可以跳过 使用，否则需要使用它。defaultplatformName |
启动任务时，使用任务启动选项传递平台帐户名称的值 如果未传递值 ，则将使用该值。--platformNameplatformNamedefault
| 将任务部署到多个平台时，任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置 Kubernetes 上的 Data Flow 服务器，以将任务部署到 Cloud Foundry 和 Kubernetes。有关更多信息，请参阅 Cloud Foundry Task Platform 配置部分。
有关跨多个平台启动和计划任务的详细示例，请参阅本节 dataflow.spring.io 上的任务的多平台支持。
11.5. 通用配置
适用于 Kubernetes 的 Spring Cloud Data Flow 服务器使用 spring-cloud-kubernetes 模块来处理挂载在 .ConfigMap 必须挂载在 Spring Boot 处理的目录中。为避免访问 Kubernetes API 服务器，请将 和 设置为 ./etc/secretsapplication.yaml/configSPRING_CLOUD_KUBERNETES_CONFIG_ENABLE_APISPRING_CLOUD_KUBERNETES_SECRETS_ENABLE_APIfalse
11.5.1. 使用 ConfigMap 和 Secret
以下示例显示了一种可能的配置，该配置启用 MariaDB 并设置内存限制：
apiVersion: v1
kind: ConfigMap
metadata:
name: scdf-server
labels:
app: scdf-server
data:
application.yaml: |-
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
default:
limits:
memory: 1024Mi
datasource:
url: jdbc:mariadb://${MARIADB_SERVICE_HOST}:${MARIADB_SERVICE_PORT}/database
username: root
password: ${database-password}
driverClassName: org.mariadb.jdbc.Driver
testOnBorrow: true
validationQuery: "SELECT 1"前面的示例假定 MariaDB 部署时将服务名称作为服务名称。Kubernetes 将这些服务的 host 和 port 值发布为环境变量，我们可以在配置部署的应用程序时使用它们。mariadb
我们更喜欢在 Secrets 文件中提供 MariaDB 连接密码，如下例所示：
apiVersion: v1
kind: Secret
metadata:
name: mariadb
labels:
app: mariadb
data:
database-password: eW91cnBhc3N3b3Jk密码是 base64 编码的值。
11.6. 数据库
关系数据库用于存储流和任务定义以及已执行任务的状态。 Spring Cloud Data Flow 为 MariaDB、MySQL、Oracle、PostgreSQL、Db2、SQL Server 和 H2 提供架构。架构是在服务器启动时自动创建的。
| 无需额外配置即可使用适用于 MariaDB、MySQL（通过 MariaDB 驱动程序）、PostgreSQL、SQL Server 的 JDBC 驱动程序。要使用任何其他数据库，您需要将相应的 JDBC 驱动程序 jar 放在服务器的 Classpath 上，如此处所述。 |
要配置数据库，必须设置以下属性：
-
spring.datasource.url -
spring.datasource.username -
spring.datasource.password -
spring.datasource.driver-class-name -
spring.jpa.database-platform
无论数据库如何，和 都是相同的。但是，每个数据库的 and 会有所不同，如下所示。usernamepasswordurldriver-class-name
| 数据库 | spring.datasource.url | spring.datasource.driver-class-name | spring.jpa.database-platform | 包括驱动程序 |
|---|---|---|---|---|
MariaDB 10.0 - 10.1 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB10Dialect |
是的 |
玛丽亚数据库 10.2 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB102Dialect |
是的 |
MariaDB 10.3 - 10.5 |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB103Dialect |
是的 |
MariaDB 10.6+ |
jdbc：mariadb：//${db-hostname}：${db-port}/${db-name} |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MariaDB106Dialect[3] |
是的 |
MySQL 5.7 版本 |
jdbc：mysql：//${db-hostname}：${db-port}/${db-name}？permitMysqlScheme |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MySQL57方言 |
是的 |
MySQL 8.0+ 版本 |
jdbc：mysql：//${db-hostname}：${db-port}/${db-name}？allowPublicKeyRetrieval=true&useSSL=false&autoReconnect=true&permitMysqlScheme[4] |
org.mariadb.jdbc.驱动程序 |
org.hibernate.dialect.MySQL8Dialect |
是的 |
PostgresSQL |
jdbc：postgres：//${db-hostname}：${db-port}/${db-name} |
org.postgresql.驱动程序 |
对于 Hibernate 默认，Remove |
是的 |
SQL 服务器 |
jdbc：sqlserver：//${db-hostname}：${db-port};数据库名称=${数据库名称}&encrypt=false |
com.microsoft.sqlserver.jdbc.SQLServerDriver |
对于 Hibernate 默认，Remove |
是的 |
DB2 |
jdbc：db2：//${db-hostname}：${db-port}/{db-name} |
com.ibm.db2.jcc.DB2Driver |
对于 Hibernate 默认，Remove |
不 |
神谕 |
jdbc：oracle：thin：@${db-hostname}：${db-port}/{db-name} |
oracle.jdbc.Oracle驱动程序 |
对于 Hibernate 默认，Remove |
不 |
11.6.1. H2
如果未配置其他数据库，则 Spring Cloud Data Flow 使用 H2 数据库的嵌入式实例作为默认实例。
| H2 适用于开发目的，但不建议用于生产，也不支持作为外部模式。 |
11.6.2. 数据库配置
在 Kubernetes 中运行时，数据库属性通常在 ConfigMap 中设置。例如，如果除了 secrets 文件中的密码之外，您还可以使用 MariaDB，则可以在 ConfigMap 中提供以下属性：
data:
application.yaml: |-
spring:
datasource:
url: jdbc:mariadb://${MARIADB_SERVICE_HOST}:${MARIADB_SERVICE_PORT}/database
username: root
password: ${database-password}
driverClassName: org.mariadb.jdbc.Driver同样，对于 PostgreSQL，您可以使用以下配置：
data:
application.yaml: |-
spring:
datasource:
url: jdbc:postgresql://${PGSQL_SERVICE_HOST}:${PGSQL_SERVICE_PORT}/database
username: root
password: ${postgres-password}
driverClassName: org.postgresql.Driver以下来自 Deployment 的 YAML 代码片段是挂载 ConfigMap 的示例，因为 Spring Boot 将处理它，并且由于环境变量设置为 ，因此 Secret 将被 spring-cloud-kubernetes 库拾取。application.yaml/config/etc/secretsSPRING_CLOUD_KUBERNETES_SECRETS_PATHS/etc/secrets
...
containers:
- name: scdf-server
image: springcloud/spring-cloud-dataflow-server:2.11.3-SNAPSHOT
imagePullPolicy: IfNotPresent
volumeMounts:
- name: config
mountPath: /config
readOnly: true
- name: database
mountPath: /etc/secrets/database
readOnly: true
ports:
...
volumes:
- name: config
configMap:
name: scdf-server
items:
- key: application.yaml
path: application.yaml
- name: database
secret:
secretName: mariadb你可以在spring-cloud-task存储库中找到特定数据库类型的迁移脚本。
11.7. 监控和管理
我们建议使用该命令对流和任务进行故障排除。kubectl
您可以使用以下命令列出使用的所有对象和资源：
kubectl get all,cm,secrets,pvc您可以通过使用标签选择资源来列出特定应用程序或服务使用的所有资源。以下命令列出了服务使用的所有资源：mariadb
kubectl get all -l app=mariadb您可以通过发出以下命令来获取特定 Pod 的日志：
kubectl logs pod <pod-name>如果 Pod 不断重启，您可以添加为选项以查看之前的日志，如下所示：-p
kubectl logs -p <pod-name>您还可以通过添加选项来跟踪或跟踪日志，如下所示：-f
kubectl logs -f <pod-name>帮助排查问题（例如容器在启动时出现致命错误）的有用命令是使用该命令，如下例所示：describe
kubectl describe pod ticktock-log-0-qnk7211.7.1. 检查 Server 日志
您可以使用以下命令访问服务器日志：
kubectl get pod -l app=scdf=server
kubectl logs <scdf-server-pod-name>11.7.2. 流
流应用程序在部署时，流名称后跟应用程序的名称。对于处理器和接收器，还会附加实例索引。
要查看 Spring Cloud Data Flow 服务器部署的所有 Pod，您可以指定标签，如下所示：role=spring-app
kubectl get pod -l role=spring-app要查看特定应用程序部署的详细信息，您可以使用以下命令：
kubectl describe pod <app-pod-name>要查看应用程序日志，您可以使用以下命令：
kubectl logs <app-pod-name>如果您想对日志进行跟踪，可以使用以下命令：
kubectl logs -f <app-pod-name>11.7.3. 任务
任务作为裸 Pod 启动，没有复制控制器。任务完成后，Pod 仍然存在，这使您有机会查看日志。
要查看特定任务的所有 Pod，请使用以下命令：
kubectl get pod -l task-name=<task-name>要查看任务日志，请使用以下命令：
kubectl logs <task-pod-name>您有两个选项可以删除已完成的 Pod。您可以在不再需要它们时手动删除它们，也可以使用数据流 shell 命令删除已完成的 Pod 以执行任务。task execution cleanup
要手动删除任务 Pod，请使用以下命令：
kubectl delete pod <task-pod-name>要使用该命令，您必须首先确定任务执行的 。为此，请使用以下命令，如以下示例（含 output）所示：task execution cleanupIDtask execution list
dataflow:>task execution list
╔═════════╤══╤════════════════════════════╤════════════════════════════╤═════════╗
║Task Name│ID│ Start Time │ End Time │Exit Code║
╠═════════╪══╪════════════════════════════╪════════════════════════════╪═════════╣
║task1 │1 │Fri May 05 18:12:05 EDT 2017│Fri May 05 18:12:05 EDT 2017│0 ║
╚═════════╧══╧════════════════════════════╧════════════════════════════╧═════════╝获得 ID 后，您可以发出命令来清理执行工件（已完成的 Pod），如下例所示：
dataflow:>task execution cleanup --id 1
Request to clean up resources for task execution 1 has been submitted任务的数据库凭证
默认情况下，Spring Cloud Data Flow 在任务启动时将数据库凭证作为属性传递给 Pod。
如果使用 or 入口点样式，则当用户对任务的 Pod 执行 操作时，将可以看到数据库凭证。
要将 Spring Cloud Data Flow 配置为使用 Kubernetes 密钥，请执行以下操作：将 property 设置为 。如果使用 Spring Cloud Data Flow 提供的 yaml 文件，请更新 'src/kubernetes/server/server-deployment.yaml 以添加以下环境变量：execshellkubectl describespring.cloud.dataflow.task.use.kubernetes.secrets.for.db.credentialstrue
- name: SPRING_CLOUD_DATAFLOW_TASK_USE_KUBERNETES_SECRETS_FOR_DB_CREDENTIALS
value: 'true'如果从以前版本的 SCDF 升级，请务必验证 和 环境变量是否存在于 server-config.yaml 中。如果没有，请按照以下示例所示添加它：spring.datasource.usernamespring.datasource.passwordsecretKeyRefs
...
task:
platform:
kubernetes:
accounts:
default:
secretKeyRefs:
- envVarName: "spring.datasource.password"
secretName: mariadb
dataKey: database-password
- envVarName: "spring.datasource.username"
secretName: mariadb
dataKey: database-username
...此外，验证关联的 secret（dataKey） 在 secrets 中是否也可用。SCDF 在此处为 MariaDB 提供了一个示例：.src/kubernetes/mariadb/mariadb-svc.yaml
| 默认情况下，通过 properties 传递 DB 凭证是为了保持向后兼容性。此功能将在将来的发行版中删除。 |
11.8. 调度
本节介绍计划任务配置方式的自定义。默认情况下，在 Spring Cloud Data Flow Kubernetes Server 中启用任务计划。属性用于影响计划任务的设置，可以全局配置或按计划配置。
| 除非另有说明，否则按计划设置的属性始终优先于设置为服务器配置的属性。这种安排允许覆盖特定计划的全局服务器级别属性。 |
11.8.1. 入口点样式
入口点样式会影响将应用程序属性传递到要部署的任务容器的方式。目前支持三种样式：
-
exec： （默认） 将所有应用程序属性作为命令行参数传递。 -
shell：将所有应用程序属性作为环境变量传递。 -
boot：创建一个环境变量，该变量包含所有应用程序属性的 JSON 表示形式。SPRING_APPLICATION_JSON
您可以按如下方式配置入口点样式：
deployer.kubernetes.entryPointStyle=<Entry Point Style>替换为所需的 Entry Point Style（入口点样式）。<Entry Point Style>
您还可以在部署 YAML 的 container 部分的服务器级别配置 Entry Point Style，如下例所示：env
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_ENTRY_POINT_STYLE
value: entryPointStyle替换为所需的 Entry Point Style。entryPointStyle
您应该选择 或 的入口点样式，以对应于在容器的 .有关 vs 的更多信息和使用案例，请参阅 Docker 文档的 ENTRYPOINT 部分。execshellENTRYPOINTDockerfileexecshell
使用 Entry Point Style 对应于使用样式 。部署请求中的命令行参数将传递到容器，并添加映射到环境变量中的应用程序属性，而不是命令行参数。bootexecENTRYPOINTSPRING_APPLICATION_JSON
ttlSecondsAfterFinished 完成
在计划应用程序时，您可以通过指定值来自动清理已完成的作业（完成或失败）。ttlSecondsAfterFinished
以下示例显示了如何配置计划的应用程序作业：
deployer.<application>.kubernetes.cron.ttlSecondsAfterFinished=86400以下示例显示了如何单独配置应用程序作业：
deployer.<application>.kubernetes.ttlSecondsAfterFinished=86400替换为应用程序的名称，并将属性替换为用于清理已完成作业的适当值。<application>ttlSecondsAfterFinished
您也可以在全局服务器级别进行配置。ttlSecondsAfterFinished
以下示例说明如何对任务执行此操作：
您可以在部署 YAML 的 container 部分的服务器级别配置镜像拉取策略，如下例所示：env
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_TTL_SECONDS_AFTER_FINISHED
value: 8640011.8.2. 环境变量
要影响给定应用程序的环境设置，您可以利用该属性。
例如，生产环境中的常见要求是影响 JVM 内存参数。
您可以使用环境变量来实现此目的，如下例所示：spring.cloud.deployer.kubernetes.environmentVariablesJAVA_TOOL_OPTIONS
deployer.kubernetes.environmentVariables=JAVA_TOOL_OPTIONS=-Xmx1024m在部署流应用程序或启动某些属性可能包含敏感信息的任务应用程序时，请使用 或 作为 .这是因为 （default） 将所有属性转换为命令行参数，因此在某些环境中可能不安全。shellbootentryPointStyleexec |
此外，您还可以在部署 YAML 的 container 部分的服务器级别配置环境变量，如下例所示：env
| 在 Server 配置中按计划指定环境变量时，将合并环境变量。这允许在 Server 配置中设置通用环境变量，并在特定计划级别设置更具体。 |
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_ENVIRONMENT_VARIABLES
value: myVar=myVal替换为所需的环境变量。myVar=myVal
11.8.3. 镜像拉取策略
镜像拉取策略定义何时应将 Docker 镜像拉取到本地注册表。目前支持三种策略：
-
IfNotPresent：（默认）如果镜像已存在，则不拉取该镜像。 -
Always：始终拉取图像，无论它是否已经存在。 -
Never：从不拉取图像。仅使用已存在的映像。
以下示例显示了如何单独配置容器：
deployer.kubernetes.imagePullPolicy=IfNotPresent替换为所需的映像提取策略。Always
您可以在部署 YAML 的 container 部分的服务器级别配置镜像拉取策略，如下例所示：env
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_IMAGE_PULL_POLICY
value: Always替换为所需的映像提取策略。Always
11.8.4. 私有 Docker 注册表
私有且需要身份验证的 Docker 镜像可以通过配置 Secret 来拉取。首先，您必须在集群中创建一个 Secret。按照 从私有注册表拉取映像 指南创建密钥。
创建密钥后，使用该属性设置要使用的密钥，如下例所示：imagePullSecret
deployer.kubernetes.imagePullSecret=mysecret替换为您之前创建的密钥的名称。mysecret
您还可以在部署 YAML 的 container 部分的服务器级别配置镜像拉取密钥，如下例所示：env
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_IMAGE_PULL_SECRET
value: mysecret替换为您之前创建的密钥的名称。mysecret
11.8.5. 命名空间
默认情况下，用于计划任务的命名空间为 。可以在部署 YAML 的 container 部分的服务器级别配置中设置此值，如下例所示：defaultenv
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_NAMESPACE
value: mynamespace11.8.6. 服务账户
您可以通过属性为计划任务配置自定义服务账户。可以使用现有服务帐户或创建新服务帐户。创建服务账户的一种方法是使用 ，如下例所示：kubectl
$ kubectl create serviceaccount myserviceaccountname
serviceaccount "myserviceaccountname" created然后，您可以将服务账户配置为按计划使用，如下所示：
deployer.kubernetes.taskServiceAccountName=myserviceaccountname替换为您的服务账户名称。myserviceaccountname
您还可以在部署 YAML 的 container 部分的服务器级别配置服务帐户名称，如下例所示：env
env:
- name: SPRING_CLOUD_DEPLOYER_KUBERNETES_TASK_SERVICE_ACCOUNT_NAME
value: myserviceaccountname替换为要应用于所有部署的服务帐户名称。myserviceaccountname
有关计划任务的更多信息，请参阅计划任务。
11.9. 调试支持
通过 Java 调试线协议 （JDWP） 支持调试 Spring Cloud Data Flow Kubernetes Server 和包含的组件（例如 Spring Cloud Kubernetes Deployer）。本节概述了一种手动启用调试的方法，以及另一种使用 Spring Cloud Data Flow Server Kubernetes 提供的配置文件来“修补”正在运行的部署的方法。
| JDWP 本身不使用任何身份验证。本节假设在本地开发环境（如 Minikube）上进行调试，因此未提供有关保护调试端口的指导。 |
11.9.1. 手动启用调试
要手动启用 JDWP，请先在 下编辑并添加一个值为 .此外，在下面添加 JAVA_TOOL_OPTIONS 环境变量，如下例所示：src/kubernetes/server/server-deployment.yamlcontainerPortspec.template.spec.containers.ports5005spec.template.spec.containers.env
spec:
...
template:
...
spec:
containers:
- name: scdf-server
...
ports:
...
- containerPort: 5005
env:
- name: JAVA_TOOL_OPTIONS
value: '-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005'前面的示例使用端口 5005，但它可以是不与其他端口冲突的任何数字。所选端口号也必须与 flag 的 added value 和 parameter 相同，如前面的示例所示。containerPortaddressJAVA_TOOL_OPTIONS-agentlib |
您现在可以启动 Spring Cloud Data Flow Kubernetes Server。服务器启动后，您可以验证部署上的配置更改，如以下示例（含输出）所示：scdf-server
kubectl describe deployment/scdf-server
...
...
Pod Template:
...
Containers:
scdf-server:
...
Ports: 80/TCP, 5005/TCP
...
Environment:
JAVA_TOOL_OPTIONS: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005
...启动服务器并启用 JDWP 后，您需要配置对端口的访问。在本例中，我们使用 的 port-forward 子命令。以下示例（含 output）显示了如何使用 ：kubectlport-forward
$ kubectl get pod -l app=scdf-server
NAME READY STATUS RESTARTS AGE
scdf-server-5b7cfd86f7-d8mj4 1/1 Running 0 10m
$ kubectl port-forward scdf-server-5b7cfd86f7-d8mj4 5005:5005
Forwarding from 127.0.0.1:5005 -> 5005
Forwarding from [::1]:5005 -> 5005现在，您可以通过将调试器指向主机和端口来附加调试器。子命令一直运行直到停止（例如按 ， ）。127.0.0.15005port-forwardCTRL+c
您可以通过将更改还原到来删除调试支持。还原的更改将在 Spring Cloud Data Flow Kubernetes Server 的下一次部署中选取。在每次部署服务器时都应默认启用调试时，手动将调试支持添加到配置中非常有用。src/kubernetes/server/server-deployment.yaml
11.9.2. 启用带修补的调试
无需手动更改 ，Kubernetes 对象可以就地“修补”。为方便起见，还包含了提供与手动方法相同配置的补丁文件。要通过修补启用调试，请使用以下命令：server-deployment.yaml
kubectl patch deployment scdf-server -p "$(cat src/kubernetes/server/server-deployment-debug.yaml)"运行上述命令会自动添加属性和环境变量。以下示例（含输出）显示如何验证对部署的更改：containerPortJAVA_TOOL_OPTIONSscdf-server
$ kubectl describe deployment/scdf-server
...
...
Pod Template:
...
Containers:
scdf-server:
...
Ports: 5005/TCP, 80/TCP
...
Environment:
JAVA_TOOL_OPTIONS: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005
...要启用对调试端口的访问，而不是使用 的子命令，您可以修补 Kubernetes 服务对象。您必须首先确保 Kubernetes 服务对象具有正确的配置。以下示例（含 output）显示了如何执行此操作：port-forwardkubectlscdf-serverscdf-server
kubectl describe service/scdf-server
Port: <unset> 80/TCP
TargetPort: 80/TCP
NodePort: <unset> 30784/TCP如果输出包含 ，则必须修补服务以为此端口添加名称。以下示例显示了如何执行此操作：<unset>
$ kubectl patch service scdf-server -p "$(cat src/kubernetes/server/server-svc.yaml)"只有在添加调试功能之前创建了目标集群时，才应缺少端口名称。由于将多个端口添加到 Kubernetes 服务对象中，因此每个端口都需要有自己的名称。scdf-server |
现在，您可以添加调试端口，如下例所示：
kubectl patch service scdf-server -p "$(cat src/kubernetes/server/server-svc-debug.yaml)"以下示例（含输出）显示了如何验证映射：
$ kubectl describe service scdf-server
Name: scdf-server
...
...
Port: scdf-server-jdwp 5005/TCP
TargetPort: 5005/TCP
NodePort: scdf-server-jdwp 31339/TCP
...
...
Port: scdf-server 80/TCP
TargetPort: 80/TCP
NodePort: scdf-server 30883/TCP
...
...输出显示容器端口 5005 已映射到 NodePort 31339。以下示例（含输出）显示了如何获取 Minikube 节点的 IP 地址：
$ minikube ip
192.168.99.100利用此信息，您可以使用主机 192.168.99.100 和端口 31339 创建调试连接。
以下示例显示如何禁用 JDWP：
$ kubectl rollout undo deployment/scdf-server
$ kubectl patch service scdf-server --type json -p='[{"op": "remove", "path": "/spec/ports/0"}]'Kubernetes 部署对象在修补之前回滚到其状态。然后，使用从列表中删除端口 5005 的操作修补 Kubernetes 服务对象。removecontainerPorts
kubectl rollout undo强制 Pod 重启。修补 Kubernetes 服务对象不会重新创建服务，并且到部署的端口映射保持不变。scdf-server |
有关部署回滚的更多信息，包括管理历史记录和使用 kubectl Patch 就地更新 API 对象，请参阅回滚部署。
12. 使用 Carvel 进行部署
部署 carvel 包需要安装工具和特定的 Kubernetes 控制器。然后，您将软件包存储库添加到集群并安装应用程序。
对于本地 minikube 或 kind 集群，您可以使用：配置 Kubernetes 以进行本地开发或测试，并按照说明进行操作，直到部署 Spring Cloud 数据流部分
12.1. 所需工具
-
kubectl- Kubernetes CLI（使用brew install kubectl) -
carvel- 打包和部署工具
Carvel CLI 可以通过以下方式安装：
wget -O- https://carvel.dev/install.sh | bash
# or with curl...
curl -L https://carvel.dev/install.sh | bash或者按照主页底部的说明进行操作，网址为 carvel.dev
脚本使用以下工具。
-
jq- 轻量级 JSON 解析器 -
yq- 轻量级 YAML 解析器 -
wget- 调用 http 请求。 -
dirname提供文件名的 directory 部分。 -
readlink提供相对链接的绝对路径。
| 默认情况下，其中一些实用程序未安装在 macOS 或 *nix 中，但可以从 MacPorts 或 HomeBrew 获得。 |
12.2. 脚本
这些脚本假定您已连接到 Kubernetes 集群并且可用。kubectl
| 名字 | 参数 | 描述 |
|---|---|---|
|
<broker> [scdf-type] [命名空间] [release|snapshot] |
配置其余脚本的环境变量需求。，并已设置。默认值为 .如果命名空间不存在，则将由 创建命名空间。默认值为 .release|snapshot 和 scdf-type 将决定 set 的值。 |
|
不适用 |
安装 cert-manager、secretgen-controller 和 kapp-controller |
|
[SCDF 型]（OSS、专业版） |
根据 或 在当前目录中创建 |
|
<秘密名称> <命名空间> [秘密命名空间] [--import|--占位符] |
使用 secretgen-controller 创建导入密钥、占位符或导入。 |
|
[SCDF 型]（OSS、专业版） |
创建命名空间并安装相关的 Carvel 包和凭据。如果未提供可选的 scdf-type，则将使用环境变量。 |
|
<host> <port> [步骤] |
为 Data Flow、Skipper、Streams 和 Tasks 配置 Spring Boot Actuator 属性。默认值为 10 秒 |
|
<app> <database> <url> <username/secret-name> [password/secret-username-key] [secret-password-key] [秘密密码-key] |
如果仅提供 secret-name，则 secret-username-key 默认为 ，secret-password-key 默认为 。 url 后允许以下 3 种组合：
|
|
[应用名称] |
使用包在当前目录中部署应用程序。
默认 app-name 为 . |
|
[应用名称] |
使用修改后的值文件更新了已部署的应用程序。
默认 app-name 为 . |
|
不适用 |
将打印 URL 以访问数据流。如果您使用它，它将导出以供使用 |
|
<代理> [流应用程序版本] |
broker 必须是 rabbit 或 Kafka 之一。stream-application-version 是可选的，它将安装最新版本。最新版本为 2021.1.2 |
| 请注意，在 pro 版本中注册应用程序可能需要几分钟时间，因为它会预先检索所有版本信息和元数据。 |
12.3. 准备
您需要准备一个名为 scdf-values.yml 的值文件 以下步骤将提供帮助。
12.3.1. 准备配置参数
执行以下脚本将配置所需的环境变量。
source ./carvel/start-deploy.sh <broker> <namespace> [scdf-type] [release|snapshot]哪里：
-
broker是 RabbitMQ 或 Kafka 之一 -
namespace除default -
scdf-typeoss 或 pro 之一。oss 是默认值。 -
release|snapshot，并将确定 的值。scdf-typePACKAGE_VERSION
*确保使用预期包的类型和版本的最佳选择是修改 deploy/versions.yaml*
也可以手动配置环境变量以覆盖这些值。
| 名字 | 描述 | 违约 |
|---|---|---|
|
Carvel 包的版本。 |
发布版本 |
|
Spring Cloud 数据流的版本 |
2.11.2 |
|
Spring Cloud Data Flow Pro 版本 |
1.6.1 |
|
Spring Cloud Skipper 的版本 |
2.11.2 |
|
包注册表的 URL 和存储库。格式。这将用于为 carvel 存储库和软件包添加前缀。 |
|
|
或 |
|
|
或 .默认值为 .这仅适用于您 |
|
|
除 . |
|
|
或 . |
|
仅当与deploy/versions.yaml
|
12.4. 准备集群并添加仓库
登录到 docker，并可选择 registry.tanzu.vmware.com Spring Cloud Data Flow Pro。
# When deploying SCDF Pro.
export TANZU_DOCKER_USERNAME="<tanzu-net-username>"
export TANZU_DOCKER_PASSWORD="<tanzu-net-password>"
docker login --username $TANZU_DOCKER_USERNAME --password $TANZU_DOCKER_PASSWORD registry.packages.broadcom.com
# Always required to ensure you don't experience rate limiting with Docker HUB
export DOCKER_HUB_USERNAME="<docker-hub-username>"
export DOCKER_HUB_PASSWORD="<docker-hub-password>"
docker login --username $DOCKER_HUB_USERNAME --password $DOCKER_HUB_PASSWORD index.docker.io安装 carvel kapp-controller、secretgen-controller 和 certmanager
./carvel/prepare-cluster.sh加载 scdf 类型的 scdf 存储库包
./carvel/setup-scdf-repo.sh12.5. 安装支持服务
在生产环境中，您应该使用支持的数据库和代理服务或运算符以及共享的可观测性工具。
对于本地开发或演示，可以使用以下内容来安装 database、broker 和 prometheus。
12.6. 配置 Prometheus 代理
在部署了现有 prometheus 和 prometheus 代理的情况下，可以使用以下方法配置代理：
./carvel/configure-prometheus-proxy.sh <host> <port> [step]12.7. 部署 Spring Cloud Data Flow
您可以在 之前配置 ：register-apps.sh
-
STREAM_APPS_RT_VERSIONStream Apps 发布 Train 版本。默认值为 2022.0.0。 -
STREAM_APPS_VERSION流应用程序版本。默认值为 4.0.0。
./carvel/deploy-scdf.sh
source ./carvel/export-dataflow-ip.sh
# expected output: Dataflow URL: <url-to-access-dataflow>
./carvel/register-apps.sh