配置
8. 梅文
如果要覆盖特定的 Maven 配置属性(远程存储库、代理等)或在代理后面运行 Data Flow Server, 在启动 Data Flow Server 时,需要将这些属性指定为命令行参数,如以下示例所示:
$ java -jar spring-cloud-dataflow-server-2.9.7-SNAPSHOT.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 设置为 。
如前面的示例所示,您可以指定远程存储库及其身份验证(如果需要)。如果远程存储库位于代理后面,则可以指定代理属性,如前面的示例所示。http
localRepository
${user.home}/.m2/repository/
您可以为每个远程存储库配置指定存储库策略,如前面的示例所示。
该密钥适用于 和 存储库策略。policy
snapshot
release
请参阅 存储库策略 主题以获取 支持的存储库策略。
由于这些是 Spring Boot,因此您需要将它们添加到环境变量中来指定。以下示例显示了 JSON 的结构:@ConfigurationProperties
SPRING_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"
}
}
}
}
'
8.1. 货车
对 Maven 使用传输的支持有限。目前,这个
存在以支持使用基于 的存储库进行抢占式身份验证
,需要手动启用。Wagon
http
通过设置属性
自。然后,您可以为每个远程启用抢占式身份验证
存储 库。配置大致遵循 HttpClient HTTP Wagon 中的类似模式。
在撰写本文时,Maven 自己站点中的文档略有误导性
以及缺少大多数可能的配置选项。http
maven.use-wagon
true
命名空间包含所有与 Wagon 相关的设置,其正下方的键映射到支持的方法 — 即 、 和 ,如 Maven 自己的配置中所示。
在这些方法配置下,您可以设置各种选项,例如 .用于发送身份验证的简单抢占式配置
标头将类似于以下示例:maven.remote-repositories.<repo>.wagon.http
http
http
all
put
get
head
use-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 的设置,而不是配置方法,如下所示:all
get
head
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-headers
connection-timeout
read-timeout
headers
params
9. 安全
默认情况下,数据流服务器不安全,并在未加密的 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 集成。
9.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.9.7-SNAPSHOT.jar
如果您在通过 SSL 建立连接时遇到问题,您可以启用其他
logging 的 . |
不要忘记使用以下命令将 Data Flow Server 作为目标:
dataflow:> dataflow config server https://localhost:8443/
跳过证书验证
或者,您也可以通过提供
可选的命令行参数。--dataflow.skip-ssl-validation=true
如果设置此命令行参数,则 shell 接受任何(自签名)SSL 证书。
如果可能,您应该避免使用此选项。禁用信任管理器 违背了 SSL 的用途,并使应用程序容易受到中间人攻击。 |
9.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/json Accept Accept |
除了基本身份验证之外,您还可以提供访问令牌,以便 访问 REST API。为此,请检索 OAuth2 访问令牌,并将该访问令牌传递给 使用 Authorization HTTP 标头的 REST API,如下所示:
$ curl -H "Authorization: Bearer <ACCESS_TOKEN>" http://localhost:9393/ -H 'Accept: application/json'
9.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-scopes
true
false
uaa
spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes
有关更多详细信息,请参阅有关角色映射的章节。
您还可以通过提供自己的 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.yml
application.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')
# 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 角色下可用。/management
MANAGEMENT
默认配置如下:dataflow-server-defaults.yml
management:
endpoints:
web:
base-path: /management
security:
roles: MANAGE
目前,您不应自定义默认管理路径。 |
9.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 中的是主机名。uaa uaa: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.jar
UAA 的配置由 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.view
sample.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
10. 配置 - 本地
10.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
10.2. 数据库
关系数据库用于存储流和任务定义以及已执行任务的状态。 Spring Cloud Data Flow 为 H2、MySQL、Oracle、PostgreSQL、Db2 和 SQL Server 提供架构。架构是在服务器启动时自动创建的。
默认情况下, Spring Cloud Data Flow 提供 H2 数据库的嵌入式实例。H2 数据库很好 用于开发目的,但不建议用于生产用途。
不支持将 H2 数据库作为外部模式。 |
无需额外配置即可使用适用于 MySQL(通过 MariaDB 驱动程序)、PostgreSQL、SQL Server 和嵌入式 H2 的 JDBC 驱动程序。 如果你正在使用任何其他数据库,那么你需要将相应的 JDBC 驱动程序 jar 放在服务器的 Classpath 上。
数据库属性可以作为环境变量或命令行参数传递给 Data Flow Server。
10.2.1. MySQL
以下示例显示如何使用 MariaDB 驱动程序定义 MySQL 数据库连接。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:mysql://localhost:3306/mydb \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
MySQL 版本最高 5.7 可与 MariaDB 驱动程序一起使用。从版本 8.0 开始,必须使用 MySQL 自己的驱动程序。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:mysql://localhost:3306/mydb \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=com.mysql.jdbc.Driver
由于许可限制,我们无法捆绑 MySQL 驱动程序。您需要将其添加到 server 的 classpath 中。 |
10.2.2. MariaDB
以下示例显示了如何使用命令行参数定义 MariaDB 数据库连接
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:mariadb://localhost:3306/mydb?useMysqlMetadata=true \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
从 MariaDB v2.4.1 连接器版本开始,还需要添加到 JDBC URL。在 MySQL 和 MariaDB 完全切换为两个之前,这是必需的解决方法
不同的数据库。useMysqlMetadata=true
MariaDB 10.3 版引入了对真实数据库序列的支持,这是另一个突破 更改,而围绕这些数据库的工具完全支持 MySQL 和 MariaDB 作为单独的数据库 类型。解决方法是使用较旧的 Hibernate dialect,它不尝试使用序列。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:mariadb://localhost:3306/mydb?useMysqlMetadata=true \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDB102Dialect \
--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
10.2.3. PostgreSQL 浏览器
以下示例显示如何使用命令行参数定义 PostgreSQL 数据库连接:
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:postgresql://localhost:5432/mydb \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=org.postgresql.Driver
10.2.4. SQL 服务器
以下示例演示如何使用命令行参数定义 SQL Server 数据库连接:
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url='jdbc:sqlserver://localhost:1433;databaseName=mydb' \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
10.2.5. Db2
以下示例显示如何使用命令行参数定义 Db2 数据库连接:
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:db2://localhost:50000/mydb \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=com.ibm.db2.jcc.DB2Driver
由于许可限制,我们无法捆绑 Db2 驱动程序。您需要将其添加到 server 的 classpath 中。 |
10.2.6. 甲骨文
以下示例显示如何使用命令行参数定义 Oracle 数据库连接:
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar \
--spring.datasource.url=jdbc:oracle:thin:@localhost:1521/MYDB \
--spring.datasource.username= \
--spring.datasource.password= \
--spring.datasource.driver-class-name=oracle.jdbc.OracleDriver
由于许可限制,我们无法捆绑 Oracle 驱动程序。您需要将其添加到 server 的 classpath 中。 |
10.2.7. 添加自定义 JDBC 驱动程序
若要为数据库添加自定义驱动程序(例如 Oracle),应重新生成 Data Flow Server 并将依赖项添加到 Maven 文件。
您需要修改 module 的 maven。
GitHub 存储库中有 GA 发布标签,因此您可以切换到所需的 GA 标签,以在生产就绪代码库中添加驱动程序。pom.xml
pom.xml
spring-cloud-dataflow-server
要为 Spring Cloud Data Flow 服务器添加自定义 JDBC 驱动程序依赖项,请执行以下操作:
-
选择与要重建的服务器版本相对应的标记,并克隆 github 存储库。
-
编辑 spring-cloud-dataflow-server/pom.xml 并在该部分中添加所需数据库驱动程序的依赖项。在以下示例中,已选择 Oracle 驱动程序:
dependencies
<dependencies>
...
<dependency>
<groupId>com.oracle.jdbc</groupId>
<artifactId>ojdbc8</artifactId>
<version>12.2.0.1</version>
</dependency>
...
</dependencies>
-
按照构建 Spring Cloud 数据流中所述构建应用程序
您还可以在重建服务器时通过向 dataflow-server.yml 文件添加必要的属性来提供默认值。 如下面的 PostgreSQL 示例所示:
spring:
datasource:
url: jdbc:postgresql://localhost:5432/mydb
username: myuser
password: mypass
driver-class-name:org.postgresql.Driver
-
或者,您可以使用构建文件构建自定义 Spring Cloud Data Flow 服务器。 如果需要添加驱动程序 jars,我们的 samples repo 中提供了自定义服务器构建的示例。
10.2.8. 模式处理
默认情况下,数据库 schema 使用 Flyway 进行管理,如果 可以向数据库用户提供足够的权限。
以下是 Skipper 服务器启动时发生的情况说明:
-
Flyway 检查表是否存在。
flyway_schema_history
-
如果 schema 不为空,则执行基线(到版本 1)作为 Dataflow 表 如果使用共享数据库,则可能已就位。
-
如果 schema 为空,则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
以下是 Dataflow 服务器启动时发生的情况说明:
-
Flyway 检查表是否存在。
flyway_schema_history_dataflow
-
如果 schema 不为空,则执行基线(到版本 1),因为 Skipper 表 如果使用共享数据库,则可能已就位。
-
如果 schema 为空,则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
-
由于历史原因,如果我们检测到 schema 来自 1.7.x 行 从 2.0.x 开始,我们将这些转换为 2.0.x 及以上所需的结构,并完全 继续沿 Flyway 行驶。
我们的源代码架构中有架构 ddl,如果使用 configuration 禁用了 Flyway,则可以手动使用这些 ddl 。如果公司的数据库
受到限制,即应用程序本身无法创建 schema。 |
10.3. 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 |
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 的属性。-Xmx
deployer.<app>.local.javaOpts
deployer.<app>.local.memory
javaOpts
javaOpts
spring.cloud.deployer.local.javaOpts
10.4. 日志记录
Spring Cloud Data Flow 服务器会自动配置为用于日志记录。
日志记录配置位于名为 的文件中包含的类路径上。local
RollingFileAppender
logback-spring.xml
默认情况下,日志文件配置为使用:
<property name="LOG_FILE" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}}/spring-cloud-dataflow-server}"/>
使用 logback 配置的 :RollingPolicy
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> <file>${LOG_FILE}.log</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.tmpdir
local
jinfo <pid> | grep "java.io.tmpdir"
如果要更改或覆盖任何属性 、 、 、 和 ,请将它们设置为系统属性。LOG_FILE
LOG_PATH
LOG_TEMP
LOG_FILE_MAX_SIZE
LOG_FILE_MAX_HISTORY
LOG_FILE_TOTAL_SIZE_CAP
10.5. 流
Data Flow Server 将 Stream 生命周期的管理委托给 Skipper 服务器。将 configuration 属性设置为 Skipper 的位置,例如spring.cloud.skipper.client.serverUri
$ java -jar spring-cloud-dataflow-server-2.9.7-SNAPSHOT.jar --spring.cloud.skipper.client.serverUri=https://192.51.100.1:7577/api
show streams 的配置以及部署到哪些平台,是通过在 Skipper 服务器上配置 来完成的。
有关更多信息,请参阅有关平台的文档。platform accounts
10.6. 任务
数据流服务器负责部署 Task。
由 Data Flow 启动的任务会将其状态写入 Data Flow 服务器使用的同一数据库。
对于作为 Spring Batch 作业的任务,作业和步骤执行数据也存储在此数据库中。
与 Skipper 启动的流一样,任务可以启动到多个平台。
如果未定义平台,则使用类 LocalDeployerProperties 的默认值创建一个名为 的平台,该值汇总在 Local Deployer Properties 表中default
要为本地平台配置新的平台帐户,请在文件中的 section 下提供一个条目,以通过另一个 Spring Boot 支持的机制。
在以下示例中,创建了两个名为 和 的本地平台账户。
和 等键是本地部署程序属性。spring.cloud.dataflow.task.platform.local
application.yaml
localDev
localDevDebug
shutdownTimeout
javaOpts
spring:
cloud:
dataflow:
task:
platform:
local:
accounts:
localDev:
shutdownTimeout: 60
javaOpts: "-Dtest=foo -Xmx1024m"
localDevDebug:
javaOpts: "-Xdebug -Xmx2048m"
通过定义一个平台,您可以跳过 使用,否则需要使用它。default platformName |
启动任务时,使用任务启动选项传递平台帐户名称的值 如果未传递值 ,则将使用该值。--platformName
platformName
default
将任务部署到多个平台时,任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置在本地运行的数据流服务器,以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息,请参阅 Cloud Foundry Task Platform Configuration 和 Kubernetes Task Platform Configuration 部分。
有关跨多个平台启动和计划任务的详细示例,请参阅本节 dataflow.spring.io 上的任务的多平台支持。
启动 Skipper
git clone https://github.com/spring-cloud/spring-cloud-skipper.git
cd spring-cloud/spring-cloud-skipper
./mvnw clean package -DskipTests=true
java -jar spring-cloud-skipper-server/target/spring-cloud-skipper-server-2.2.0.BUILD-SNAPSHOT.jar
启动 Spring Cloud 数据流
git clone https://github.com/spring-cloud/spring-cloud-dataflow.git
cd spring-cloud-dataflow
./mvnw clean package -DskipTests=true
cd ..
创建一个包含以下内容的 yaml 文件scdf.yml:
spring:
cloud:
dataflow:
security:
authorization:
provider-role-mappings:
uaa:
map-oauth-scopes: true
role-mappings:
ROLE_CREATE: foo.create
ROLE_DEPLOY: foo.create
ROLE_DESTROY: foo.create
ROLE_MANAGE: foo.create
ROLE_MODIFY: foo.create
ROLE_SCHEDULE: foo.create
ROLE_VIEW: foo.view
security:
oauth2:
client:
registration:
uaa:
redirect-uri: '{baseUrl}/login/oauth2/code/{registrationId}'
authorization-grant-type: authorization_code
client-id: dataflow
client-secret: dataflow
scope: (1)
- openid
- foo.create
- foo.view
provider:
uaa:
jwk-set-uri: http://uaa:8080/uaa/token_keys
token-uri: http://uaa:8080/uaa/oauth/token
user-info-uri: http://uaa:8080/uaa/userinfo (2)
user-name-attribute: user_name
authorization-uri: http://uaa:8080/uaa/oauth/authorize
resourceserver:
opaquetoken: (3)
introspection-uri: http://uaa:8080/uaa/introspect
client-id: dataflow
client-secret: dataflow
1 | 如果您使用 scopes 来标识角色,请确保同时请求
相关的范围,例如 ,并且不要忘记请求范围dataflow.view dataflow.create openid |
2 | 用于检索用户档案信息,例如用于显示目的的用户名(必填) |
3 | 用于令牌内省和验证(强制性) |
在传递外部检索的 (opaque) 时,该属性尤其重要
Spring Cloud Data Flow 的 OAuth 访问令牌。在这种情况下,Spring Cloud Data Flow 将采用 OAuth 访问权限,
并使用 UAA 的 Introspect 令牌端点不仅检查令牌的有效性,还从 UAA 检索关联的 OAuth 范围introspection-uri
最后启动 Spring Cloud Data Flow:
java -jar spring-cloud-dataflow/spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.4.0.BUILD-SNAPSHOT.jar --spring.config.additional-location=scdf.yml
角色映射
默认情况下,所有角色都分配给登录到 Spring Cloud Data Flow 的用户。 但是,您可以设置以下属性:
spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes: true
这将指示底层将
OAuth 范围限定为相应的颁发机构。支持以下范围:DefaultAuthoritiesExtractor
-
范围映射到角色
dataflow.create
CREATE
-
范围映射到角色
dataflow.deploy
DEPLOY
-
范围映射到角色
dataflow.destroy
DESTROY
-
范围映射到角色
dataflow.manage
MANAGE
-
范围映射到角色
dataflow.modify
MODIFY
-
范围映射到角色
dataflow.schedule
SCHEDULE
-
范围映射到角色
dataflow.view
VIEW
此外,您还可以将任意范围映射到每个数据流角色:
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 角色,从而灵活地选择授权配置的粒度。 |
10.6.4. 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 中。但是,用户 信息在登录期间缓存。以下脚本 有助于快速检索更新的信息:
|
LDAP 安全性和 UAA 示例应用程序
为了快速启动和运行并帮助您了解安全架构,我们 在 GitHub 上提供 LDAP 安全性和 UAA 示例。
这只是一个演示/示例应用程序,不得在生产中使用。 |
设置包括:
-
Spring Cloud 数据流服务器
-
Skipper 服务器
-
CloudFoundry 用户帐户和身份验证 (UAA) 服务器
-
轻量级目录访问协议 (LDAP) 服务器(由 Apache Directory Server (ApacheDS) 提供)
最后,作为此示例的一部分,您将学习如何配置和启动 使用此安全设置的 Composed Task。
10.6.5. Spring Security OAuth2 资源/授权服务器示例
对于本地测试和开发,您还可以使用 Resource and Authorization 服务器支持由 Spring Security OAuth 提供。它 允许您使用以下简单注释轻松创建自己的(非常基本的)OAuth2 服务器:
-
@EnableResourceServer
-
@EnableAuthorizationServer
事实上,UAA 在幕后使用 Spring Security OAuth2,因此基本端点 都是一样的。 |
可以在以下位置找到一个工作示例应用程序:https://github.com/ghillert/oauth-test-server/
克隆项目并使用相应的客户端 ID 和客户端密钥配置 Spring Cloud Data Flow:
security:
oauth2:
client:
client-id: myclient
client-secret: mysecret
access-token-uri: http://127.0.0.1:9999/oauth/token
user-authorization-uri: http://127.0.0.1:9999/oauth/authorize
resource:
user-info-uri: http://127.0.0.1:9999/me
token-info-uri: http://127.0.0.1:9999/oauth/check_token
此示例应用程序不用于生产用途 |
10.6.6. 数据流 Shell 身份验证
使用 Shell 时,可以通过用户名和密码提供凭据 或通过指定 credentials-provider 命令。如果您的 OAuth2 提供商支持 密码授权类型,您可以使用以下方法启动数据流 Shell:
$ java -jar spring-cloud-dataflow-shell-2.9.7-SNAPSHOT.jar \
--dataflow.uri=http://localhost:9393 \ (1)
--dataflow.username=my_username \ (2)
--dataflow.password=my_password \ (3)
--skip-ssl-validation true \ (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 true \ (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 环境中,可以使用以下简单的命令:
|
10.7. 关于配置
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: 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: name 用于实现。
-
spring.cloud.dataflow.version-info.spring-cloud-dataflow-implementation.version: 用于实现的版本。
-
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.name: 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:sha1 checksum 值。
-
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: 如果未指定,则 SCDF 将使用此 URL 中指定的文件内容进行校验和。
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha1
-
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256-url: 如果未指定,则 SCDF 将使用此 URL 中指定的文件内容进行校验和。
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256
10.7.1. 启用 Shell 校验和值
默认情况下,不会显示 shell 依赖项的校验和值。如果
您需要启用此功能,请将 Property 设置为 True。spring.cloud.dataflow.version-info.dependency-fetch.enabled
10.7.2. URL 的保留值
有一些保留值(用大括号括起来)可以插入 确保链接是最新的 URL:
-
repository:如果使用 build-snapshot、milestone 或 Data Flow,存储库是指 repo-spring-io 存储库。否则,它会 指 Maven Central。
-
version:插入 jar/pom 的版本。
11. 配置 - Cloud Foundry
本节介绍如何配置 Spring Cloud Data Flow 服务器的功能,例如安全性以及使用哪种关系数据库。 它还介绍了如何配置 Spring Cloud Data Flow shell 的功能。
11.1. 功能切换
数据流服务器提供了一组特定的功能,您可以在启动时启用或禁用这些功能。这些功能包括所有生命周期操作和 REST 端点(服务器、客户端实现,包括 Shell 和 UI):
-
流
-
任务
可以通过在启动数据流服务器时设置以下布尔属性来启用或禁用这些功能:
-
spring.cloud.dataflow.features.streams-enabled
-
spring.cloud.dataflow.features.tasks-enabled
默认情况下,所有功能都处于启用状态。
REST 端点 () 提供有关已启用和已禁用功能的信息。/features
11.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 的工作原理。
buildpack
buildpacks
-
您可以自定义 Cloud Foundry 使用的运行状况检查机制,以使用环境变量来断言应用程序是否正在运行。当前支持的选项 are(默认值)、 和 .
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK
http
port
none
您还可以设置环境变量,分别指定基于 HTTP 的运行状况检查终端节点和 timeout:和 。这些默认为 (Spring Boot 默认位置) 和 seconds。SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK_ENDPOINT
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK_TIMEOUT
/health
120
-
您还可以使用 DSL 指定部署属性。例如,如果要将应用程序分配的内存设置为 512m,并将 mysql 服务绑定到应用程序,则可以运行以下命令:
http
jdbc
dataflow:> stream create --name mysqlstream --definition "http | jdbc --tableName=names --columns=name"
dataflow:> stream deploy --name mysqlstream --properties "deployer.http.memory=512, deployer.jdbc.cloudfoundry.services=mysql"
您可以为流和任务应用程序单独配置这些设置。要更改任务的设置,
替换 for,如下例所示:
|
11.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.cloudfoundry
application.yaml
dev
qa
memory
disk
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,mysql
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,mysqlQA
appNamePrefix: qa1
通过定义一个平台,您可以跳过 使用,否则需要使用它。default platformName |
启动任务时,使用任务启动选项传递平台帐户名称的值 如果未传递值 ,则将使用该值。--platformName
platformName
default
将任务部署到多个平台时,任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置 Cloud Foundry 上的 Data Flow 服务器,以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息,请参阅 Kubernetes Task Platform 配置部分。
有关跨多个平台启动和计划任务的详细示例,请参阅本节 dataflow.spring.io 上的任务的多平台支持。
11.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 false
11.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 显示所有可用的自定义选项。在实践中,您只能使用这三者中的一两个。http
myhost.mydomain.com/my-path
11.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 应用程序,如果您使用名为 :mysql
cf set-env SPRING_DATASOURCE_URL '${vcap.services.mysql.credentials.jdbcUrl}'
cf set-env SPRING_DATASOURCE_USERNAME '${vcap.services.mysql.credentials.username}'
cf set-env SPRING_DATASOURCE_PASSWORD '${vcap.services.mysql.credentials.password}'
cf set-env SPRING_DATASOURCE_DRIVER_CLASS_NAME 'org.mariadb.jdbc.Driver'
对于非 Java 或非 Boot 应用程序,您的 Docker 应用程序必须解析变量才能绑定到任何可用服务。VCAP_SERVICES
传递应用程序属性
使用非引导应用程序时,您可能希望使用传统的
环境变量,而不是使用特殊变量。为此,请将
以下变量分别用于 Streams 和 Task:
|
11.7. 应用程序级服务绑定
在 Cloud Foundry 中部署流时,您可以利用特定于应用程序的服务绑定,因此并非所有 为 Spring Cloud Data Flow 编排的所有应用程序全局配置服务。
例如,如果您只想为以中的应用程序提供服务绑定
定义,你可以将服务绑定作为 deployment 属性传递:mysql
jdbc
dataflow:>stream create --name httptojdbc --definition "http | jdbc"
dataflow:>stream deploy --name httptojdbc --properties "deployer.jdbc.cloudfoundry.services=mysqlService"
其中 是专门绑定到应用程序的服务名称,并且应用程序没有通过该方法获取到绑定。mysqlService
jdbc
http
如果要绑定多个服务,则可以将它们作为逗号分隔的项目传递
(例如:)。deployer.jdbc.cloudfoundry.services=mysqlService,someService
11.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',mysql,'my-google-bigquery-example role:bigquery.user'
单引号中允许使用空格,并且可以代替键值对分隔。= : |
11.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}"
11.10. 数据库连接池
从 Data Flow 2.0 开始,Spring Cloud 连接器库不再用于创建 DataSource。 现在使用库 java-cfenv,它允许您设置 Spring Boot 属性以配置连接池。
11.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。让我们回顾一下 更改默认最大磁盘配额分配的步骤。
11.11.1. PCF 的运营管理器
在 PCF 的 Ops Manager 中,选择“Pivotal Elastic Runtime”磁贴,然后导航到“Application Developer Controls”选项卡。 将“每个应用程序的最大磁盘配额 (MB)”设置从 2048 (2G) 更改为 10240 (10G)。保存磁盘配额更新,然后单击 “Apply Changes” 完成配置覆盖。
11.12. Scale 应用程序
成功应用磁盘配额更改后,假设您有一个正在运行的应用程序,
您可以通过 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.io
11.13. 管理磁盘使用
即使将 Data Flow 服务器配置为使用 10G 空间,也有可能耗尽
本地磁盘上的可用空间。为防止这种情况,无论部署请求是否成功,只要部署应用程序,都会自动删除从外部源(即注册为或资源的应用程序)下载的项目。
此行为最适合容器运行时稳定性比部署期间产生的 I/O 延迟更关键的生产环境。
在开发环境中,部署会更频繁地进行。此外,工件(或更轻的 jar)包含描述应用程序配置属性的元数据
它由与应用程序配置相关的各种操作使用,在预生产活动期间更频繁地执行(有关详细信息,请参阅 应用程序元数据)。
为了在预生产环境中使用更多的磁盘,以牺牲更多的磁盘使用为代价,提供响应速度更快的交互式开发人员体验,您可以将 CloudFoundry deployer 属性设置为。jar
http
maven
jar
metadata
autoDeleteMavenArtifacts
false
如果使用默认运行状况检查类型部署 Data Flow 服务器,则必须显式监视服务器上的磁盘空间,以避免空间不足。
如果使用运行状况检查类型部署服务器(请参阅下一个示例),则当磁盘空间不足时,数据流服务器将重新启动。
这是由于 Spring Boot 的磁盘空间健康指示器。
您可以使用具有前缀的属性来配置 Disk Space Health Indicator 的设置。port
http
management.health.diskspace
对于版本 1.7,我们正在研究使用 Data Flow 服务器的卷服务来存储构件,然后再将其推送到 Cloud Foundry。.jar
以下示例显示如何将运行状况检查类型部署到名为 :http
/management/health
---
...
health-check-type: http
health-check-http-endpoint: /management/health
11.14. 应用程序解析替代方案
虽然我们建议使用 Maven Artifactory for application 注册 Stream Application, 在某些情况下,以下替代方法之一可能有意义。
-
我们已经定制构建并维护了一个 SCDF APP 工具,该工具可以在 Cloud Foundry 中作为常规 Spring Boot 应用程序运行,但它反过来将托管和服务于应用程序 运行时 SCDF 的 JAR。
-
在 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
11.15. 安全性
默认情况下,数据流服务器不安全,并在未加密的 HTTP 连接上运行。您可以保护您的 REST 终端节点
(以及 Data Flow Dashboard)通过启用 HTTPS 并要求客户端进行身份验证。
有关保护
REST 端点并配置为针对 OAUTH 后端(在 Cloud Foundry 上运行的 UAA 和 SSO)进行身份验证,
请参阅核心 [configuration-local-security] 中的 security 部分。您可以在安全详细信息中配置安全详细信息,也可以通过命令将其作为环境变量传递。dataflow-server.yml
cf set-env
11.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-uaa false |
非 Cloud Foundry 安全场景同样支持授权。 请参阅核心数据流 [configuration-local-security] 中的安全部分。
由于不同环境中的角色配置可能差异很大,因此我们通过以下方式 default 将所有 Spring Cloud Data Flow 角色分配给用户。
您可以通过提供自己的 AuthoritiesExtractor
来自定义此行为。
以下示例显示了在 上设置 custom 的一种方法 :AuthoritiesExtractor
UserInfoTokenServices
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-uaa
true
CloudFoundryDataflowAuthoritiesExtractor
如果不使用 CloudFoundry UAA,则应设置为 。spring.cloud.dataflow.security.cf-use-uaa
false
在幕后,这呼唤了 Cloud Foundry
Apps API 并确保用户实际上是 Space 开发人员。AuthoritiesExtractor
如果已验证的用户被验证为 Space Developer,则会分配所有角色。
11.16. 配置参考
您必须提供几项配置。这些是 Spring Boot ,因此您可以设置
它们作为环境变量或通过 Spring Boot 支持的任何其他方式。以下清单位于 environment 中
变量格式,因为这是开始在 Cloud Foundry 中配置 Boot 应用程序的一种简单方法。
请注意,将来您将能够将任务部署到多个平台,但对于 2.0.0.M1,您只能部署到单个平台,并且名称必须为 。@ConfigurationProperties
default
# 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.services
spring.cloud.deployer.cloudfoundry.buildpacks
spring.cloud.deployer.memory
spring.cloud.deployer.disk
deployer.<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"
11.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 == DEBUG
11.18. Spring Cloud 配置服务器
您可以使用 Spring Cloud Config Server 集中 Spring Boot 应用程序的配置属性。同样 Spring Cloud Data Flow 和由 Spring Cloud Data Flow 编排的应用程序都可以与 配置服务器以使用相同的功能。
11.18.1. Stream、Task 和 Spring Cloud Config Server
与 Spring Cloud Data Flow 服务器类似,您可以配置 stream 和 task 应用程序,以解析来自配置服务器的集中属性。
为已部署的应用程序设置属性是绑定到配置服务器的常用方法。
有关更多信息,请参阅 Spring Cloud Config Client 参考指南。
由于此属性可能用于数据流服务器部署的所有应用程序,因此数据流服务器的流应用程序属性和任务应用程序属性可用于将 Config Server 的 传递到每个已部署的流或任务应用程序。请参阅 通用应用程序属性 以了解更多信息。spring.cloud.config.uri
spring.cloud.dataflow.applicationProperties.stream
spring.cloud.dataflow.applicationProperties.task
uri
请注意,如果您使用 App Starters 项目中的应用程序,则这些应用程序已经嵌入了依赖项。
如果您从头开始构建应用程序并希望添加对 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 /health SPRING_CLOUD_CONFIG_ENABLED false |
11.18.2. 示例 Manifest 模板
以下 SCDF 和 Skipper 模板包括 Skipper 和 Spring Cloud Data Flow 服务器以及部署的应用程序和任务所需的环境变量,以便在 Cloud Foundry 上成功运行并在运行时自动解析集中式属性:manifest.yml
my-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_REMOTE_REPOSITORIES_REPO1_URL: https://repo.spring.io/libs-snapshot
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: mysql
SPRING_CLOUD_SKIPPER_CLIENT_SERVER_URI: https://<skipper-host-name>/api
services:
- mysql
- 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: 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:
- mysql
my-config-server
其中 是在 Cloud Foundry 上运行的 Spring Cloud Config Service 实例的名称。my-config-server
通过将服务分别绑定到 Spring Cloud Data Flow 服务器、Spring Cloud Task 和通过 Skipper 绑定到所有 Spring Cloud Stream 应用程序,我们现在可以解析由此服务支持的集中式属性。
11.18.3. 自签名 SSL 证书和 Spring Cloud Config Server
通常,在开发环境中,我们可能没有有效的证书来启用客户端和后端服务之间的 SSL 通信。 但是,Pivotal Cloud Foundry 的配置服务器使用 HTTPS 进行所有客户端到服务的通信,因此我们需要在没有有效证书的环境中添加自签名 SSL 证书。
通过使用上一节中列出的相同模板,我们可以通过设置 来提供自签名 SSL 证书。manifest.yml
TRUST_CERTS: <API_ENDPOINT>
但是,部署的应用程序还需要作为平面环境变量(而不是包装在 Inner),因此我们必须使用另一组令牌 () 来指示服务器执行任务。
通过此设置,应用程序将接收其应用程序属性作为常规环境变量。TRUST_CERTS
SPRING_APPLICATION_JSON
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_USE_SPRING_APPLICATION_JSON: false
以下清单显示了包含所需更改的更新。数据流服务器和已部署的应用程序
从 Cloud Config 服务器(部署为 Cloud Foundry 服务)获取其配置。manifest.yml
my-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_REMOTE_REPOSITORIES_REPO1_URL: https://repo.spring.io/libs-snapshot
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: mysql, 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:
- mysql
- 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:
- mysql
my-config-server
11.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-enabled
true
-
通过将 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:
- mysql
其中 的格式如下:scheduler.<Domain-Name>
(对于
示例,scheduler.local.pcfdev.io
)。检查您的 _PCF 环境中的实际地址。SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]SCHEDULER_SCHEDULER_URL
有关跨多个平台启动和计划任务的详细示例,请参阅本节 dataflow.spring.io 上的任务的多平台支持。 |
12. 配置 - Kubernetes
本节介绍如何配置 Spring Cloud Data Flow 功能,例如部署程序属性、任务以及要使用的关系数据库。
12.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
12.2. 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 |
应用程序容器必须响应以进行活动性检查的端口。 |
<没有> |
readinessProbeDelay |
应用程序容器的就绪情况检查应开始检查模块是否已完全启动并运行时的延迟(以秒为单位)。 |
10 |
readinessProbePeriod (就绪探针周期) |
执行应用程序容器就绪情况检查的时间段(以秒为单位)。 |
10 |
readinessProbeTimeout (准备探测超时) |
应用程序容器在就绪情况检查期间必须响应其运行状况的超时(以秒为单位)。 |
2 |
readinessProbePath (就绪探针路径) |
应用程序容器必须响应以进行就绪情况检查的路径。 |
<没有> |
就绪探针端口 |
应用程序容器必须响应以进行就绪情况检查的端口。 |
<没有> |
探针凭据密钥 |
包含访问安全探测终端节点时使用的凭证的密钥名称。 |
<没有> |
limits.memory |
内存限制,分配 Pod 所需的最大值,默认单位为 MB,支持“M”和“G”后缀 |
<没有> |
limits.cpu 的 |
CPU 限制,分配 Pod 所需的最大值 |
<没有> |
requests.memory (请求内存) |
内存请求,保证分配 Pod 所需的值。 |
<没有> |
requests.cpu 的 |
CPU 请求,保证分配 Pod 所需的值。 |
<没有> |
statefulSet.volumeClaimTemplate.storageClassName |
有状态集的存储类的名称 |
<没有> |
statefulSet.volumeClaimTemplate.storage |
仓储量。默认单位为 MB,支持“M”和“G”后缀 |
<没有> |
环境变量 |
要为任何已部署的应用程序容器设置的环境变量列表 |
<没有> |
entryPointStyle |
用于 Docker 镜像的入口点样式。用于确定如何传入属性。可以是 、 和 |
|
创建负载均衡器 |
为每个应用程序创建的服务创建一个 “LoadBalancer”。这有助于将外部 IP 分配给应用程序。 |
假 |
serviceAnnotations |
要为每个应用程序创建的服务设置的服务注释。格式的字符串 |
<没有> |
pod注解 |
要为每个部署创建的 Pod 设置的 Pod 注释。格式的字符串 |
<没有> |
jobAnnotations |
要为作业创建的 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.runAsUser |
用于运行 Pod 容器进程的数字用户 ID |
<没有> |
podSecurityContext.fsGroup |
用于运行 Pod 容器进程的数字组 ID |
<没有> |
affinity.nodeAffinity |
以 YAML 格式表示的节点关联性。例如 |
<没有> |
affinity.podAffinity |
以 YAML 格式表示的 Pod 亲和性。例如 |
<没有> |
affinity.podAntiAffinity |
以 YAML 格式表示的 Pod 反亲和性。例如 |
<没有> |
statefulSetInitContainerImageName |
用于 StatefulSet Init Container 的自定义镜像名称 |
<没有> |
initContainer (初始化容器) |
以 YAML 格式表示的 Init Container,可应用于 Pod。例如 |
<没有> |
additionalContainers |
以 YAML 格式表示的其他容器,以应用于 Pod。例如 |
<没有> |
12.3. 任务
数据流服务器负责部署 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.kubernetes
application.yaml
dev
qa
memory
disk
spring:
cloud:
dataflow:
task:
platform:
kubernetes:
accounts:
dev:
namespace: devNamespace
imagePullPolicy: Always
entryPointStyle: exec
limits:
cpu: 4
qa:
namespace: qaNamespace
imagePullPolicy: IfNotPresent
entryPointStyle: boot
limits:
memory: 2048m
通过定义一个平台,您可以跳过 使用,否则需要使用它。default platformName |
启动任务时,使用任务启动选项传递平台帐户名称的值 如果未传递值 ,则将使用该值。--platformName
platformName
default
将任务部署到多个平台时,任务的配置需要连接到与 Data Flow Server 相同的数据库。 |
您可以配置 Kubernetes 上的 Data Flow 服务器,以将任务部署到 Cloud Foundry 和 Kubernetes。有关更多信息,请参阅 Cloud Foundry Task Platform 配置部分。
有关跨多个平台启动和计划任务的详细示例,请参阅本节 dataflow.spring.io 上的任务的多平台支持。
12.4. 通用配置
适用于 Kubernetes 的 Spring Cloud Data Flow 服务器使用 spring-cloud-kubernetes
模块来处理挂载在 .ConfigMap 必须挂载在 Spring Boot 处理的目录中。为避免访问 Kubernetes API 服务器,请将 和 设置为 ./etc/secrets
application.yaml
/config
SPRING_CLOUD_KUBERNETES_CONFIG_ENABLE_API
SPRING_CLOUD_KUBERNETES_SECRETS_ENABLE_API
false
12.4.1. 使用 ConfigMap 和 Secret
以下示例显示了一种可能的配置,该配置启用 MySQL 并设置内存限制:
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:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/mysql
username: root
password: ${mysql-root-password}
driverClassName: org.mariadb.jdbc.Driver
testOnBorrow: true
validationQuery: "SELECT 1"
前面的示例假设 MySQL 部署时将服务名称作为 。Kubernetes 将这些服务的 host 和 port 值发布为环境变量,我们可以在配置部署的应用程序时使用它们。mysql
我们更喜欢在 Secrets 文件中提供 MySQL 连接密码,如下例所示:
apiVersion: v1
kind: Secret
metadata:
name: mysql
labels:
app: mysql
data:
mysql-root-password: eW91cnBhc3N3b3Jk
密码是 base64 编码的值。
12.5. 数据库配置
Spring Cloud Data Flow 为 H2、HSQLDB、MySQL、Oracle、PostgreSQL、DB2 和 SQL Server 提供架构。如果 Classpath 中有正确的数据库驱动程序和适当的凭据,则在服务器启动时会自动创建适当的模式。
适用于 MySQL(通过 MariaDB 驱动程序)、HSQLDB、PostgreSQL 和嵌入式 H2 的 JDBC 驱动程序是开箱即用的。 如果使用任何其他数据库,则需要将相应的 JDBC 驱动程序 jar 放在服务器的 Classpath 上。
例如,如果除了 secrets 文件中的密码之外,还使用 MySQL,则可以在 ConfigMap 中提供以下属性:
data:
application.yaml: |-
spring:
datasource:
url: jdbc:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/mysql
username: root
password: ${mysql-root-password}
driverClassName: org.mariadb.jdbc.Driver
url: jdbc:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/test
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
对于 HSQLDB,您可以使用以下配置:
data:
application.yaml: |-
spring:
datasource:
url: jdbc:hsqldb:hsql://${HSQLDB_SERVICE_HOST}:${HSQLDB_SERVICE_PORT}/database
username: sa
driverClassName: org.hsqldb.jdbc.JDBCDriver
以下来自 Deployment 的 YAML 代码片段是挂载 ConfigMap 的示例,因为 Spring Boot 将处理它,并且由于环境变量设置为 ,因此 Secret 将被 spring-cloud-kubernetes 库拾取。application.yaml
/config
/etc/secrets
SPRING_CLOUD_KUBERNETES_SECRETS_PATHS
/etc/secrets
...
containers:
- name: scdf-server
image: springcloud/spring-cloud-dataflow-server:2.5.0.BUILD-SNAPSHOT
imagePullPolicy: Always
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: mysql
你可以在spring-cloud-task存储库中找到特定数据库类型的迁移脚本。
12.6. 监控和管理
我们建议使用该命令对流和任务进行故障排除。kubectl
您可以使用以下命令列出使用的所有对象和资源:
kubectl get all,cm,secrets,pvc
您可以通过使用标签选择资源来列出特定应用程序或服务使用的所有资源。以下命令列出了服务使用的所有资源:mysql
kubectl get all -l app=mysql
您可以通过发出以下命令来获取特定 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-qnk72
12.6.1. 检查 Server 日志
您可以使用以下命令访问服务器日志:
kubectl get pod -l app=scdf=server
kubectl logs <scdf-server-pod-name>
12.6.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>
12.6.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 cleanup
ID
task 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 以添加以下环境变量:exec
shell
kubectl describe
spring.cloud.dataflow.task.use.kubernetes.secrets.for.db.credentials
true
- name: SPRING_CLOUD_DATAFLOW_TASK_USE_KUBERNETES_SECRETS_FOR_DB_CREDENTIALS
value: 'true'
如果从以前版本的 SCDF 升级,请务必验证 和 环境变量是否存在于 server-config.yaml 中。如果没有,请按照以下示例所示添加它:spring.datasource.username
spring.datasource.password
secretKeyRefs
...
task:
platform:
kubernetes:
accounts:
default:
secretKeyRefs:
- envVarName: "spring.datasource.password"
secretName: mysql
dataKey: mysql-root-password
- envVarName: "spring.datasource.username"
secretName: mysql
dataKey: mysql-root-username
...
此外,验证关联的 secret(dataKey) 在 secrets 中是否也可用。SCDF 在此处为 MySql 提供了一个示例:。src/kubernetes/mysql/mysql-svc.yaml
默认情况下,通过 properties 传递 DB 凭证是为了保持向后兼容性。此功能将在将来的发行版中删除。 |
12.7. 调度
本节介绍计划任务配置方式的自定义。默认情况下,在 Spring Cloud Data Flow Kubernetes Server 中启用任务计划。属性用于影响计划任务的设置,可以全局配置或按计划配置。
除非另有说明,否则按计划设置的属性始终优先于设置为服务器配置的属性。这种安排允许覆盖特定计划的全局服务器级别属性。 |
有关支持的选项的更多信息,请参阅 KubernetesSchedulerProperties
。
12.7.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_SCHEDULER_KUBERNETES_ENTRY_POINT_STYLE
value: entryPointStyle
替换为所需的 Entry Point Style。entryPointStyle
您应该选择 或 的入口点样式,以对应于在容器的 .有关 vs 的更多信息和使用案例,请参阅 Docker 文档的 ENTRYPOINT 部分。exec
shell
ENTRYPOINT
Dockerfile
exec
shell
使用 Entry Point Style 对应于使用样式 。部署请求中的命令行参数将传递到容器,并添加映射到环境变量中的应用程序属性,而不是命令行参数。boot
exec
ENTRYPOINT
SPRING_APPLICATION_JSON
12.7.2. 环境变量
要影响给定应用程序的环境设置,您可以利用该属性。
例如,生产环境中的常见要求是影响 JVM 内存参数。
您可以使用环境变量来实现此目的,如下例所示:spring.cloud.deployer.kubernetes.environmentVariables
JAVA_TOOL_OPTIONS
deployer.kubernetes.environmentVariables=JAVA_TOOL_OPTIONS=-Xmx1024m
在部署流应用程序或启动某些属性可能包含敏感信息的任务应用程序时,请使用 或 作为 .这是因为 (default) 将所有属性转换为命令行参数,因此在某些环境中可能不安全。shell boot entryPointStyle exec |
此外,您还可以在部署 YAML 的 container 部分的服务器级别配置环境变量,如下例所示:env
在 Server 配置中按计划指定环境变量时,将合并环境变量。这允许在 Server 配置中设置通用环境变量,并在特定计划级别设置更具体。 |
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_ENVIRONMENT_VARIABLES
value: myVar=myVal
替换为所需的环境变量。myVar=myVal
12.7.3. 镜像拉取策略
镜像拉取策略定义何时应将 Docker 镜像拉取到本地注册表。目前支持三种策略:
-
IfNotPresent
:(默认)如果镜像已存在,则不拉取该镜像。 -
Always
:始终拉取图像,无论它是否已经存在。 -
Never
:从不拉取图像。仅使用已存在的映像。
以下示例显示了如何单独配置容器:
deployer.kubernetes.imagePullPolicy=Always
替换为所需的映像提取策略。Always
您可以在部署 YAML 的 container 部分的服务器级别配置镜像拉取策略,如下例所示:env
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_POLICY
value: Always
替换为所需的映像提取策略。Always
12.7.4. 私有 Docker 注册表
私有且需要身份验证的 Docker 镜像可以通过配置 Secret 来拉取。首先,您必须在集群中创建一个 Secret。按照 从私有注册表拉取映像 指南创建密钥。
创建密钥后,使用该属性设置要使用的密钥,如下例所示:imagePullSecret
deployer.kubernetes.imagePullSecret=mysecret
替换为您之前创建的密钥的名称。mysecret
您还可以在部署 YAML 的 container 部分的服务器级别配置镜像拉取密钥,如下例所示:env
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_SECRET
value: mysecret
替换为您之前创建的密钥的名称。mysecret
12.7.5. 命名空间
默认情况下,用于计划任务的命名空间为 。可以在部署 YAML 的 container 部分的服务器级别配置中设置此值,如下例所示:default
env
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_NAMESPACE
value: mynamespace
12.7.6. 服务账户
您可以通过属性为计划任务配置自定义服务账户。可以使用现有服务帐户或创建新服务帐户。创建服务账户的一种方法是使用 ,如下例所示:kubectl
$ kubectl create serviceaccount myserviceaccountname
serviceaccount "myserviceaccountname" created
然后,您可以将服务账户配置为按计划使用,如下所示:
deployer.kubernetes.taskServiceAccountName=myserviceaccountname
替换为您的服务账户名称。myserviceaccountname
您还可以在部署 YAML 的 container 部分的服务器级别配置服务帐户名称,如下例所示:env
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_TASK_SERVICE_ACCOUNT_NAME
value: myserviceaccountname
替换为要应用于所有部署的服务帐户名称。myserviceaccountname
有关计划任务的更多信息,请参阅计划任务。
12.8. 调试支持
通过 Java 调试线协议 (JDWP) 支持调试 Spring Cloud Data Flow Kubernetes Server 和包含的组件(例如 Spring Cloud Kubernetes Deployer)。本节概述了一种手动启用调试的方法,以及另一种使用 Spring Cloud Data Flow Server Kubernetes 提供的配置文件来“修补”正在运行的部署的方法。
JDWP 本身不使用任何身份验证。本节假设在本地开发环境(如 Minikube)上进行调试,因此未提供有关保护调试端口的指导。 |
12.8.1. 手动启用调试
要手动启用 JDWP,请先在 下编辑并添加一个值为 .此外,在下面添加 JAVA_TOOL_OPTIONS
环境变量,如下例所示:src/kubernetes/server/server-deployment.yaml
containerPort
spec.template.spec.containers.ports
5005
spec.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 相同,如前面的示例所示。containerPort address JAVA_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)显示了如何使用 :kubectl
port-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.1
5005
port-forward
CTRL+c
您可以通过将更改还原到来删除调试支持。还原的更改将在 Spring Cloud Data Flow Kubernetes Server 的下一次部署中选取。在每次部署服务器时都应默认启用调试时,手动将调试支持添加到配置中非常有用。src/kubernetes/server/server-deployment.yaml
12.8.2. 启用带修补的调试
无需手动更改 ,Kubernetes 对象可以就地“修补”。为方便起见,还包含了提供与手动方法相同配置的补丁文件。要通过修补启用调试,请使用以下命令:server-deployment.yaml
kubectl patch deployment scdf-server -p "$(cat src/kubernetes/server/server-deployment-debug.yaml)"
运行上述命令会自动添加属性和环境变量。以下示例(含输出)显示如何验证对部署的更改:containerPort
JAVA_TOOL_OPTIONS
scdf-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-forward
kubectl
scdf-server
scdf-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 服务对象。remove
containerPorts
kubectl rollout undo 强制 Pod 重启。修补 Kubernetes 服务对象不会重新创建服务,并且到部署的端口映射保持不变。scdf-server |
有关部署回滚的更多信息,包括管理历史记录和使用 kubectl Patch 就地更新 API 对象,请参阅回滚部署。