配置
8. 专家
如果要覆盖特定的 Maven 配置属性(远程存储库、代理等)或在代理后面运行数据流服务器, 启动数据流服务器时,需要将这些属性指定为命令行参数,如以下示例所示:
$ java -jar spring-cloud-dataflow-server-2.8.3.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
默认情况下,协议设置为http
.如果代理不需要用户名和密码,则可以省略身份验证属性。此外,默认情况下,mavenlocalRepository
设置为${user.home}/.m2/repository/
.
如前面的示例所示,您可以指定远程存储库及其身份验证(如果需要)。如果远程存储库位于代理后面,则可以指定代理属性,如前面的示例所示。
您可以为每个远程存储库配置指定存储库策略,如前面的示例所示。
关键policy
适用于snapshot
和release
存储库策略。
因为这些是 Spring Boot@ConfigurationProperties
您需要通过将它们添加到SPRING_APPLICATION_JSON
环境变量。以下示例显示了 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. 马车
对使用Wagon
使用 Maven 传输。目前,这个
存在以支持http
基于存储库
并且需要手动启用。
基于货车http
通过设置maven.use-wagon
财产
自true
.然后,您可以为每个远程启用抢占式身份验证
存储 库。配置松散地遵循 HttpClient HTTP Wagon 中的类似模式。
在撰写本文时,Maven 自己网站上的文档略有误导性
并且缺少大多数可能的配置选项。
这maven.remote-repositories.<repo>.wagon.http
命名空间包含所有 Wagonhttp
相关设置,其正下方的键映射到 Supportedhttp
方法 — 即all
,put
,get
和head
,就像在 Maven 自己的配置中一样。
在这些方法配置下,您可以设置各种选项,例如use-preemptive
.用于发送身份验证的简单抢占式配置
header 包含对指定远程存储库的所有请求,如下所示:
maven:
use-wagon: true
remote-repositories:
springRepo:
url: https://repo.example.org
wagon:
http:
all:
use-preemptive: true
auth:
username: user
password: password
而不是配置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
有设置use-default-headers
,connection-timeout
,read-timeout
请求headers
和 HttpClientparams
.有关参数的更多信息,
请参阅 Wagon ConfigurationUtils。
9. 安全
默认情况下,数据流服务器不安全,并在未加密的 HTTP 连接上运行。 您可以通过启用 HTTPS 来保护 REST 端点以及数据流仪表板 并要求客户端使用 OAuth 2.0 进行身份验证。
附录 Azure 包含详细信息,如何 设置 Azure Active Directory 集成。 |
默认情况下,REST 端点(管理、管理和运行状况)以及仪表板 UI 不需要经过身份验证的访问权限。 |
虽然理论上你可以选择任何 OAuth 提供程序与 Spring Cloud Data Flow,我们建议使用 CloudFoundry 用户帐户和身份验证 (UAA) 服务器。
UAA OpenID 不仅经过认证并被 Cloud Foundry 使用,而且您可以 也可以在本地独立部署方案中使用它。此外,UAA 不是 只提供自己的用户存储,但也提供了全面的LDAP集成。
9.1. 启用 HTTPS
默认情况下,仪表板、管理和运行状况终结点使用 HTTP 作为传输。
您可以通过在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 | 由于默认端口是9393 ,您可以选择将端口更改为更常见的 HTTP 典型端口。 |
2 | 密钥存储在密钥库中的别名(或名称)。 |
3 | 密钥库文件的路径。您还可以使用类路径前缀指定类路径资源 - 例如:classpath:path/to/keystore . |
4 | 密钥库的密码。 |
5 | 密钥的密码。 |
6 | 信任库文件的路径。您还可以使用类路径前缀指定类路径资源 - 例如: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
这就是您需要为数据流服务器执行的所有作。启动服务器后,
您应该能够在localhost:8443/
.
由于这是一个自签名证书,您应该在浏览器中点击警告,该警告
你需要忽略。
切勿在生产中使用自签名证书。 |
自签名证书和 Shell
默认情况下,自签名证书是 shell 的问题,其他步骤 是使 shell 使用自签名证书所必需的。两种选择 可用:
-
将自签名证书添加到 JVM 信任库。
-
跳过证书验证。
将自签名证书添加到 JVM 信任库
为了使用 JVM 信任库选项,您需要 从密钥库导出先前创建的证书,如下所示:
$ 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.8.3.jar
如果您在通过 SSL 建立连接时遇到问题,您可以启用其他
通过使用和设置 |
不要忘记使用以下命令以数据流服务器为目标:
dataflow:> dataflow config server https://localhost:8443/
跳过证书验证
或者,您也可以通过提供
自选--dataflow.skip-ssl-validation=true
命令行参数。
如果设置此命令行参数,则 shell 接受任何(自签名)SSL 证书。
如果可能,应避免使用此选项。禁用信任管理器 违背了 SSL 的目的,并使您的应用程序容易受到中间人攻击。 |
9.2. 使用 OAuth 2.0 进行身份验证
为了支持身份验证和授权,Spring Cloud DataFlow 使用 OAuth 2.0。它允许您将 Spring Cloud Data Flow 集成到单点登录 (SSO) 中 环境。
从 Spring Cloud Data Flow 2.0 开始,OAuth2 是唯一的机制 用于提供身份验证和授权。 |
使用以下 OAuth2 授权类型:
-
授权码:用于 GUI(浏览器)集成。访问者将重定向到您的 OAuth 服务进行身份验证
-
密码:由 shell(和 REST 集成)使用,因此访问者可以使用用户名和密码登录
-
客户端凭据:直接从 OAuth 提供程序检索访问Tokens,并使用 Authorization HTTP 标头将其传递给数据流服务器
目前,Spring Cloud Data Flow 使用不透明的Tokens,不透明 Tokens (JWT)。 |
您可以通过两种方式访问 REST 终结点:
-
基本身份验证,它使用密码授予类型向 OAuth2 服务进行身份验证
-
访问Tokens,它使用客户端凭据授予类型
设置身份验证时,您确实应该启用 HTTPS 同样,尤其是在生产环境中。 |
您可以通过将以下内容添加到application.yml
或通过设置
环境变量。以下示例显示了CloudFoundry用户帐户和身份验证(UAA)服务器所需的最低设置:
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 | 用于自省和验证直接传入的Tokens。命令的。 |
您可以使用 curl 验证基本身份验证是否正常工作,如下所示:
curl -u myusername:mypassword http://localhost:9393/ -H 'Accept: application/json'
因此,您应该会看到可用 REST 终结点的列表。
当您使用 Web 浏览器访问根 URL 时,并且
启用安全性,则将您重定向到仪表板 UI。要查看
REST 端点列表,请指定application/json Accept 页眉。还要确定
添加Accept 标头,使用 Postman (Chrome) 等工具
或 RESTClient (Firefox)。 |
除了基本身份验证之外,您还可以提供访问Tokens,以 访问 REST API。为此,请检索 OAuth2 访问Tokens,并将该访问Tokens传递给 REST API 使用授权 HTTP 标头,如下所示:
$ curl -H "Authorization: Bearer <ACCESS_TOKEN>" http://localhost:9393/ -H 'Accept: application/json'
9.3. 自定义授权
前面的内容主要涉及身份验证,即如何评估 用户的身份。在本节中,我们将讨论可用的授权选项,即谁可以做什么。
授权规则在dataflow-server-defaults.yml
(部分
Spring Cloud Data Flow Core 模块)。
由于安全角色的确定是特定于环境的,默认情况下,Spring Cloud Data Flow 将所有角色分配给经过身份验证的 OAuth2 用户。 这DefaultDataflowAuthoritiesExtractor
class 用于此目的。
或者,您可以让 Spring Cloud Data Flow 通过以下方式将 OAuth2 范围映射到数据流角色
设置布尔属性map-oauth-scopes
让您的提供者true
(默认值为false
).
例如,如果您的提供商的 ID 是uaa
,则属性将为spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes
.
有关更多详细信息,请参阅有关角色映射的章节。
您还可以通过提供自己的 Spring bean 定义来自定义角色映射行为,该定义
扩展了 Spring Cloud Data Flow 的AuthorityMapper
接口。在这种情况下,
自定义 Bean 定义优先于
Spring Cloud 数据流。
默认方案使用七个角色来保护 Spring Cloud Data Flow 公开的 REST 端点:
-
ROLE_CREATE:用于任何涉及创建的内容,例如创建流或任务
-
ROLE_DEPLOY:用于部署流或启动任务
-
ROLE_DESTROY:用于涉及删除流、任务等的任何内容。
-
ROLE_MANAGE:对于启动管理终结点
-
ROLE_MODIFY:对于任何涉及改变系统状态的事情
-
ROLE_SCHEDULE:用于计划相关作(例如计划任务)
-
ROLE_VIEW:对于与检索状态相关的任何内容
如本节前面所述,指定了所有与授权相关的默认设置
在dataflow-server-defaults.yml
,它是 Spring Cloud Data Flow Core 的一部分
模块。不过,如果需要,您可以覆盖这些设置,例如
在application.yml
.配置采用 YAML 列表的形式(如一些
规则可能优先于其他规则)。因此,您需要复制和粘贴
整个列表并根据您的需要进行定制(因为无法合并列表)。
始终参考您的版本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 列表,而不是地图(因此使用 '-' 破折号
在每行的开头)位于spring.cloud.dataflow.security.authorization.rules
钥匙。
授权 — Shell 和仪表板行为
启用安全性后,仪表板和 shell 是角色感知的, 这意味着,根据分配的角色,并非所有功能都可见。
例如,用户没有必要角色的 shell 命令 标记为不可用。
目前,shell 的 |
相反,对于仪表板,UI 不显示页面或页面元素 用户未获得授权。
保护 Spring Boot 管理端点
启用安全性后,Spring Boot HTTP 管理端点的保护方式与其他 REST 端点相同。管理 REST 端点
可在以下位置找到/management
并要求MANAGEMENT
角色。
中的默认配置dataflow-server-defaults.yml
如下:
management:
endpoints:
web:
base-path: /management
security:
roles: MANAGE
目前,您不应自定义默认管理路径。 |
9.4. 设置 UAA 身份验证
对于本地部署场景,我们建议使用 CloudFoundry 用户 帐户和身份验证 (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 Tokens (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
.
在这里,uaa 在 URL 中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 文件驱动uaa.yml
,或者您可以编写配置脚本
使用 UAA 命令行客户端:
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
上述脚本设置数据流客户端以及两个用户:
-
用户 springrocks 有两个作用域:
sample.view
和sample.create
. -
用户查看器只有一个范围:
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
参数,您可以请求Tokens为:
-
不透明
-
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
默认情况(需要 Skipper)和任务处于启用状态,并且默认情况下禁用任务计划程序。
其余的/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 放在服务器的类路径上。
数据库属性可以作为环境变量或命令行参数传递给数据流服务器。
10.2.1. MySQL
以下示例显示如何使用 MariaDB 驱动程序定义 MySQL 数据库连接。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.8.3.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.8.3.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 驱动程序。您需要将其添加到 服务器的类路径。 |
10.2.2. MariaDB
以下示例显示如何使用命令行参数定义 MariaDB 数据库连接
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.8.3.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 连接器版本开始,还需要添加useMysqlMetadata=true
到 JDBC URL。这是必需的解决方法,直到 MySQL 和 MariaDB 完全切换为两个
不同的数据库。
MariaDB 10.3 版引入了对真实数据库序列的支持,这是另一个突破性事件 更改,而围绕这些数据库的工具完全支持 MySQL 和 MariaDB 作为单独的数据库 类型。解决方法是使用较旧的休眠方言,它不会尝试使用序列。
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.8.3.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.8.3.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.8.3.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.8.3.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 驱动程序。您需要将其添加到 服务器的类路径。 |
10.2.6. 预言机
以下示例显示如何使用命令行参数定义 Oracle 数据库连接:
java -jar spring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.8.3.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 驱动程序。您需要将其添加到 服务器的类路径。 |
10.2.7. 添加自定义 JDBC 驱动程序
要为数据库添加自定义驱动程序(例如,Oracle),您应该重新构建数据流服务器并将依赖项添加到 Mavenpom.xml
文件。
您需要修改 Mavenpom.xml
之spring-cloud-dataflow-server
模块。
GitHub 存储库中有 GA 发布标签,因此您可以切换到所需的 GA 标签,以在生产就绪代码库上添加驱动程序。
要为 Spring Cloud Data Flow 服务器添加自定义 JDBC 驱动程序依赖项:
-
选择与要重建的服务器版本相对应的标签,并克隆 github 存储库。
-
编辑 spring-cloud-dataflow-server/pom.xml,并在
dependencies
部分,添加所需数据库驱动程序的依赖项。在以下示例中,选择了 Oracle 驱动程序:
<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,我们的示例存储库中有自定义服务器构建的示例。
10.2.8. 模式处理
在默认情况下,数据库模式是使用 Flyway 管理的,如果它是 可以向数据库用户授予足够的权限。
以下是启动 Skipper 服务器时发生的情况的描述:
-
Flyway 检查是否
flyway_schema_history
table 存在。 -
如果架构不为空,则执行基线(到版本 1)作为数据流表 如果使用共享数据库,则可能已到位。
-
如果模式为空,则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
下面是启动 Dataflow 服务器时发生的情况说明:
-
Flyway 检查是否
flyway_schema_history_dataflow
table 存在。 -
如果模式不为空,则执行基线(到版本 1)作为 Skipper 表 如果使用共享数据库,则可能已到位。
-
如果模式为空,则 flyway 假定从头开始。
-
完成所有需要的架构迁移。
-
由于历史原因,如果我们检测到该模式来自 1.7.x 行 我们将这些转换为 2.0.x 及更高版本所需的结构,并完全转换为 继续飞行路线。
我们的源代码模式中有模式 ddl,如果使用配置禁用 Flyway,则可以手动使用 |
10.3. Deployer 属性
您可以使用本地部署程序的以下配置属性来自定义流和任务的部署方式。
使用数据流 shell 进行部署时,可以使用语法deployer.<appName>.local.<deployerPropertyName>
.有关 shell 用法示例,请参见下文。
在数据流服务器中配置本地任务平台和在 Skipper 中配置本地平台以部署流时,也会使用这些属性。
部署程序属性名称 | 描述 | 默认值 |
---|---|---|
workingDirectoriesRoot |
所有创建的进程将在其中运行并创建日志文件的目录。 |
java.io.tmpdir |
envVarsTo 继承 |
传递给已启动应用程序的环境变量的正则表达式模式数组。 |
<WINDOWS 上的“TMP”、“LANG”、“LANGUAGE”、“LC_.*”、“PATH”、“SPRING_APPLICATION_JSON”>和 Unix 上的 <“TMP”、“LANG”、“LANGUAGE”、“LC_.*”、“PATH”> |
deleteFilesOnExit |
是否在 JVM 出口上删除已创建的文件和目录。 |
true |
javaCmd |
运行 java 的命令 |
Java |
shutdown超时 |
等待应用关闭的最大秒数。 |
30 |
java选项 |
要传递给 JVM 的 Java 选项,例如 -Dtest=foo |
<无> |
inheritLogging |
允许将日志重定向到触发子进程的进程的输出流。 |
false |
调试端口 |
用于远程调试的端口 |
<无> |
例如,要在ticktock
stream,请使用以部署属性。
dataflow:> stream create --name ticktock --definition "time --server.port=9000 | log"
dataflow:> stream deploy --name ticktock --properties "deployer.time.local.javaOpts=-Xmx2048m -Dtest=foo"
为方便起见,您可以将deployer.memory
属性来设置 Java 选项-Xmx
,如以下示例所示:
dataflow:> stream deploy --name ticktock --properties "deployer.time.memory=2048m"
在部署时,如果将-Xmx
选项中的deployer.<app>.local.javaOpts
属性,以及deployer.<app>.local.memory
选项,则javaOpts
属性具有优先权。此外,javaOpts
部署应用程序时设置的属性优先于数据流服务器的spring.cloud.deployer.local.javaOpts
财产。
10.4. 日志记录
Spring Cloud 数据流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>
要检查java.io.tmpdir
对于当前的 Spring Cloud Data Flow Serverlocal
服务器
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. 流
数据流服务器将流生命周期的管理委托给 Skipper 服务器。设置配置属性spring.cloud.skipper.client.serverUri
到 Skipper 的位置,例如
$ java -jar spring-cloud-dataflow-server-2.8.3.jar --spring.cloud.skipper.client.serverUri=https://192.51.100.1:7577/api
show streams的配置以及部署到哪些平台,通过配置platform accounts
在 Skipper 服务器上。
有关更多信息,请参阅有关平台的文档。
10.6. 任务
数据流服务器负责部署任务。
数据流启动的任务将其状态写入数据流服务器使用的同一数据库。
对于 Spring Batch Jobs 的任务,作业和步骤执行数据也存储在此数据库中。
与 Skipper 启动的流一样,任务可以启动到多个平台。
如果未定义平台,则名为default
使用 LocalDeployerProperties 类的默认值创建,该值汇总在表 Local Deployer Properties 中
要为本地平台配置新的平台帐户,请在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
将被使用。
将任务部署到多个平台时,任务的配置需要连接到与数据流服务器相同的数据库。 |
您可以配置在本地运行的数据流服务器,以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息,请参阅有关 Cloud Foundry 任务平台配置和 Kubernetes 任务平台配置的部分。
有关跨多个平台启动和计划任务的详细示例,请参阅此部分 dataflow.spring.io 上任务的多平台支持。
启动船长
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 | 如果使用作用域来标识角色,请确保同时请求
相关范围,例如dataflow.view ,dataflow.create 并且不要忘记请求openid 范围 |
2 | 用于检索个人资料信息,例如用于显示目的的用户名(必填) |
3 | 用于Tokens内省和验证(必填) |
这introspection-uri
当传递外部检索(不透明)时,属性尤为重要
OAuth 访问Tokens到 Spring Cloud 数据流。在这种情况下,Spring Cloud Data Flow 将采用 OAuth 访问权限,
并使用 UAA 的 Introspect Tokens端点不仅可以检查Tokens的有效性,还可以从 UAA 检索关联的 OAuth 范围
终于启动了 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
这将指示底层DefaultAuthoritiesExtractor
到地图
OAuth 范围到相应的机构。支持以下范围:
-
范围
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 数据流角色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(轻量级目录访问协议)进行身份验证 服务器使用以下模式:
与外部身份提供程序(如 LDAP)集成时,身份验证 在 UAA 内变得被链接。UAA 首先尝试使用 用户对 UAA 用户存储在外部提供程序之前的凭据, 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 组
这些值通过配置属性指定ldap.groups.file controls
.在被窝里
这些值引用 Spring XML 配置文件。
在测试和开发期间,可能需要进行频繁的更改 LDAP 组和用户,并查看 UAA 中反映的内容。但是,用户 信息在登录期间被缓存。以下脚本 有助于快速检索更新的信息:
|
LDAP 安全和 UAA 示例应用程序
为了快速启动和运行并帮助您了解安全架构,我们 在 GitHub 上提供 LDAP 安全和 UAA 示例。
这只是一个演示/示例应用程序,不得在生产中使用。 |
设置包括:
-
Spring Cloud 数据流服务器
-
船长服务器
-
CloudFoundry 用户帐户和身份验证 (UAA) 服务器
-
轻量级目录访问协议 (LDAP) 服务器(由 Apache Directory Server (ApacheDS) 提供)
最终,作为本示例的一部分,您将学习如何配置和启动 使用此安全设置的组合任务。
10.6.5. Spring Security OAuth2 资源/授权服务器示例
对于本地测试和开发,您还可以使用资源和授权 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.8.3.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。 |
在数据流 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 | 可选,忽略证书错误(使用自签名证书时)。谨慎使用! |
下图显示了用于连接和验证数据的典型 shell 命令 流服务器:

成功定位后,应看到以下输出:
dataflow:>dataflow config info
dataflow config info
╔═══════════╤═══════════════════════════════════════╗
║Credentials│[username='my_username, password=****']║
╠═══════════╪═══════════════════════════════════════╣
║Result │ ║
║Target │http://localhost:9393 ║
╚═══════════╧═══════════════════════════════════════╝
或者,您可以指定 credentials-provider 命令,以便
直接传入持有者Tokens,而不是提供用户名和密码。
这可以在 shell 内部工作,或者通过提供--dataflow.credentials-provider-command
command-line 参数。
使用 credentials-provider 命令时,请注意您的 指定的命令必须返回 Bearer Tokens(以 Bearer 为前缀的访问Tokens)。 例如,在 Unix 环境中,可以使用以下简单命令:
|
10.7. 关于配置
Spring Cloud Data Flow About Restful API 结果包含显示名称 版本,如果指定了,则为每个主要依赖项提供 URL 包括 Spring Cloud Data Flow。结果(如果启用)还包含 shell 依赖项的 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:sha1 与 shell 依赖项信息一起返回的校验和值。
-
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-sha1
未指定,则 SCDF 将使用此 URL 中指定的文件的内容作为校验和。 -
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256-url: 如果
spring.cloud.dataflow.version-info.spring-cloud-dataflow-shell.checksum-sha256
未指定,则 SCDF 将使用此 URL 中指定的文件的内容作为校验和。
10.7.1. 启用 Shell 校验和值
默认情况下,不显示 shell 依赖项的校验和值。如果
您需要启用此功能,请将spring.cloud.dataflow.version-info.dependency-fetch.enabled
属性设置为 true。
10.7.2. URL 的保留值
您可以插入保留值(用大括号括起来) 确保链接是最新的 URL:
-
存储库:如果使用 Data Flow,存储库是指 repo-spring-io 存储库。否则,它 指的是 Maven Central。
-
version:插入 jar/pom 的版本。
例如myrepository/org/springframework/cloud/spring-cloud-dataflow-shell/{version}/spring-cloud-dataflow-shell-{version}.jar
生产myrepository/org/springframework/cloud/spring-cloud-dataflow-shell/1.2.3.RELEASE/spring-cloud-dataflow-shell-1.2.3.RELEASE.jar
如果您使用的是 Spring Cloud Data Flow Shell 的 1.2.3.RELEASE 版本
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 属性
您可以使用数据流服务器的 Cloud Foundry 部署程序的以下配置属性来自定义应用程序的部署方式。
使用数据流 shell 进行部署时,可以使用语法deployer.<appName>.cloudfoundry.<deployerPropertyName>
.有关 shell 用法示例,请参见下文。
在 Data Flow 服务器中配置 Cloud Foundry Task 平台和 Skipper 中的 Kubernetes 平台以部署 Streams 时,也会使用这些属性。
部署程序属性名称 | 描述 | 默认值 |
---|---|---|
服务业 |
要绑定到已部署应用程序的服务的名称。 |
<无> |
主机 |
要用作路由一部分的主机名。 |
由 Cloud Foundry 派生的主机名 |
域 |
映射应用程序路由时要使用的域。 |
<无> |
路线 |
应用程序应绑定到的路由列表。与主机和域互斥。 |
<无> |
构建包 |
用于部署应用程序的 buildpack。已弃用的 buildpack。 |
|
构建包 |
用于部署应用程序的 buildpack 列表。 |
|
存储 |
要分配的内存量。默认单位为兆字节,支持“M”和“G”后缀 |
1024米 |
磁盘 |
要分配的磁盘空间量。默认单位为兆字节,支持“M”和“G”后缀。 |
1024米 |
健康检查 |
要对已部署的应用程序执行的运行状况检查类型。值可以是 HTTP、NONE、PROCESS 和 PORT |
端口 |
healthCheckHttp端点 |
http 运行状况检查将使用的路径, |
/健康 |
健康检查超时 |
运行状况检查的超时值(以秒为单位)。 |
120 |
实例 |
要运行的实例数。 |
1 |
enableRandomAppNamePrefix |
标志以启用为应用名称添加随机前缀的前缀。 |
true |
api超时 |
阻止 API 调用的超时(以秒为单位)。 |
360 |
状态超时 |
状态 API作超时(以毫秒为单位) |
5000 |
使用SpringApplicationJson |
指示应用程序属性是否馈送到 |
true |
暂存超时 |
为暂存应用程序分配的超时。 |
15分钟 |
启动超时 |
为启动应用程序分配的超时。 |
5分钟 |
appName前缀 |
用作已部署应用程序名称前缀的字符串 |
Spring Boot 属性 |
删除路由 |
取消部署应用程序时是否同时删除路由。 |
true |
java选项 |
要传递给 JVM 的 Java 选项,例如 -Dtest=foo |
<无> |
pushTasks启用 |
是推送任务应用程序还是假设应用程序在启动时已经存在。 |
true |
autoDeleteMavenArtifacts |
是否在部署时自动从本地存储库中删除 Maven 工件。 |
true |
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
-
设置
buildpack
现在已被弃用,取而代之的是buildpacks
如果需要,这允许您传递多个。有关这方面的更多信息,请参阅 Buildpack 的工作原理。 -
您可以自定义 Cloud Foundry 使用的运行状况检查机制,以使用
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_HEALTH_CHECK
环境变量。当前支持的选项 是http
(默认值),port
和none
.
您还可以设置环境变量来指定基于 HTTP 的运行状况检查端点和超时: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
(Spring Boot 默认位置)和120
秒。
-
还可以使用 DSL 指定部署属性。例如,如果您想为
http
应用程序绑定到 512m,并将 MySQL 服务绑定到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"
可以为流应用和任务应用分别配置这些设置。要更改任务的设置,
替代
|
11.3. 任务
数据流服务器负责部署任务。
数据流启动的任务将其状态写入数据流服务器使用的同一数据库。
对于 Spring Batch Jobs 的任务,作业和步骤执行数据也存储在此数据库中。
与 Skipper 一样,任务可以启动到多个平台。
当数据流在 Cloud Foundry 上运行时,必须定义任务平台。
要配置面向 Cloud Foundry 的新平台帐户,请在spring.cloud.dataflow.task.platform.cloudfoundry
部分在您的application.yaml
文件。
在以下示例中,两个名为dev
和qa
被创建。
键,例如memory
和disk
是 Cloud Foundry Deployer 属性。
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
将被使用。
将任务部署到多个平台时,任务的配置需要连接到与数据流服务器相同的数据库。 |
您可以配置 Cloud Foundry 上的数据流服务器,以将任务部署到 Cloud Foundry 或 Kubernetes。有关更多信息,请参阅有关 Kubernetes 任务平台配置的部分。
有关跨多个平台启动和计划任务的详细示例,请参阅此部分 dataflow.spring.io 上任务的多平台支持。
11.4. 应用程序名称和前缀
为了帮助避免与 Cloud Foundry 中跨空间的路由发生冲突,一种命名策略为
已部署的应用程序可用,并且默认启用。您可以使用以下命令覆盖默认配置并设置相应的属性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"
前面的示例绑定了http
app 到myhost.mydomain.com/my-path
网址。请注意,这个
示例显示了所有可用的自定义选项。在实践中,您只能使用三者中的一两个。
11.6. Docker 应用程序
从版本 1.2 开始,可以使用以下命令将基于 Docker 的应用程序注册和部署为流和任务的一部分 Cloud Foundry 的数据流。
如果您使用 Spring Boot 和基于 RabbitMQ 的 Docker 镜像,则可以提供通用的部署属性
以方便将应用程序绑定到 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 或非启动应用程序,您的 Docker 应用程序必须解析VCAP_SERVICES
变量,以便绑定到任何可用的服务。
传递应用程序属性
使用非引导应用程序时,您很可能希望使用传统的
环境变量,而不是使用 special
|
11.7. 应用程序级服务绑定
在 Cloud Foundry 中部署流时,您可以利用特定于应用程序的服务绑定,因此并非所有 服务是为 Spring Cloud Data Flow 编排的所有应用程序全局配置的。
例如,如果您想提供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. 配置服务绑定参数
CloudFoundry API 支持在绑定服务实例时提供配置参数。某些服务代理需要或 建议绑定配置。 例如,使用 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 版开始,Cloud Foundry 的数据流允许您提供绑定配置参数,这些参数可以在应用程序级别或服务器级别提供cloudfoundry.services
deployment 属性。例如,要绑定到 nfs 服务,如上所示:
dataflow:> stream deploy --name mystream --properties "deployer.<app>.cloudfoundry.services='nfs_service_instance uid:1000,gid:1000,mount:/var/volume1,readonly:true'"
该格式旨在与数据流 DSL 解析器兼容。
通常,cloudfoundry.services
deployment 属性接受逗号分隔值。
由于逗号也用于分隔配置参数,并避免空格问题,因此包含配置参数的任何项目都必须用单引号括起来。有效值包括以下内容:
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 数据库)。
现在,我们回顾一下从 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 Connector 库来创建 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”磁贴,然后导航到“应用程序开发人员控件”选项卡。 将“每个应用程序的最大磁盘配额 (MB)”设置从 2048 (2G) 更改为 10240 (10G)。保存磁盘配额更新,然后单击 “应用更改”以完成配置覆盖。
11.12. 规模应用
成功应用磁盘配额更改后,假设您有一个正在运行的应用程序,
您可以使用新的disk_limit
通过 CF CLI,如以下示例所示:
→ 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. 管理磁盘使用
即使将数据流服务器配置为使用 10G 的空间,也有可能耗尽
本地磁盘上的可用空间。为了防止这种情况,jar
从外部源下载的工件,即注册为http
或maven
资源,无论部署请求是否成功,每当部署应用程序时都会自动删除。
此行为最适合容器运行时稳定性比部署期间产生的 I/O 延迟更重要的生产环境。
在开发环境中,部署更频繁地发生。此外,jar
工件(或打火机metadata
jar) 包含描述应用程序配置属性的元数据
它由与应用程序配置相关的各种作使用,在预生产活动期间更频繁地执行(有关详细信息,请参阅应用程序元数据)。
为了提供响应速度更快的交互式开发人员体验,但代价是预生产环境中的磁盘使用量增加,您可以设置 CloudFoundry 部署程序属性autoDeleteMavenArtifacts
自false
.
如果使用默认的port
运行状况检查类型,则必须显式监控服务器上的磁盘空间,以避免空间不足。
如果使用http
运行状况检查类型(请参阅下一个示例),如果磁盘空间不足,则会重新启动数据流服务器。
这是由于 Spring Boot 的磁盘空间健康指示器。
您可以使用具有management.health.diskspace
前缀。
对于 1.7 版,我们正在研究使用卷服务来存储数据流服务器.jar
工件,然后再将它们推送到 Cloud Foundry。
以下示例演示如何部署http
运行状况检查类型添加到名为/management/health
:
---
...
health-check-type: http
health-check-http-endpoint: /management/health
11.14. 应用程序解析替代方案
尽管我们建议将 Maven Artifactory 用于应用程序注册流应用程序, 在某些情况下,以下替代方法之一可能是有意义的。
-
我们定制并维护了一个 SCDF APP 工具,该工具可以在 Cloud Foundry 中作为常规 Spring Boot 应用程序运行,但它反过来将托管和服务该应用程序 运行时 SCDF 的 JAR。
-
借助 Spring Boot,我们可以在 Cloud Foundry 中提供静态内容。一个简单的 Spring Boot 应用程序可以捆绑所有必需的流和任务应用程序。通过拥有它 在 Cloud Foundry 上运行,静态应用程序就可以为 über-jar 提供服务。例如,从 shell 中,您可以注册 应用程序名称为
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 解析也适用于此模型。
-
卷服务是另一个不错的选择。所需的 über-jar 可以托管在外部文件系统中。在卷服务的帮助下,您可以例如,使用
http-source.jar
通过使用--uri=file://<Path-To-FileSystem>/http-source.jar
.
11.15. 安全性
默认情况下,数据流服务器不安全,并在未加密的 HTTP 连接上运行。您可以通过启用 HTTPS 并要求客户端进行身份验证来保护 REST 端点(以及数据流仪表板)。有关保护REST 端点并配置为针对 OAUTH 后端(在 Cloud Foundry 上运行的 UAA 和 SSO)进行身份验证的更多详细信息,请参阅核心 [configuration-local-security] 中的安全部分。您可以在dataflow-server.yml
或将它们作为环境变量传递给cf set-env
命令。
11.15.1. 身份验证
Spring Cloud Data Flow 可以与 Pivotal Single Sign-On Service 集成 (例如,在 PWS 上)或 Cloud Foundry 用户帐户和身份验证 (UAA) 服务器。
Pivotal 单点登录服务
将 Spring Cloud Data Flow 部署到 Cloud Foundry 时,可以绑定 应用程序添加到 Pivotal 单点登录服务。通过这样做,Spring Cloud 数据流利用 Java CFEnv, 它为 OAuth 2.0 提供特定于 Cloud Foundry 的自动配置支持。
为此,请将 Pivotal 单点登录服务绑定到数据流服务器应用程序,并 提供以下属性:
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] 中的安全部分。
由于角色的配置可能因环境而异,因此我们通过 默认将所有 Spring Cloud Data Flow 角色分配给用户。
您可以通过提供自己的行为来自定义此行为AuthoritiesExtractor
.
以下示例显示了一种可能的方法,用于设置自定义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;
}
}
然后您可以在配置类中声明它,如下所示:
@Bean
public BeanPostProcessor myUserInfoTokenServicesPostProcessor() {
BeanPostProcessor postProcessor == new MyUserInfoTokenServicesPostProcessor();
return postProcessor;
}
云代工 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"
}
默认情况下,spring.cloud.dataflow.security.cf-use-uaa
属性设置为true
.此属性激活特殊的AuthoritiesExtractor
叫CloudFoundryDataflowAuthoritiesExtractor
.
如果您不使用 CloudFoundry UAA,您应该将spring.cloud.dataflow.security.cf-use-uaa
自false
.
在被窝里,这个AuthoritiesExtractor
调用 Cloud FoundryApps API,并确保用户实际上是 Space 开发人员。
如果经过身份验证的用户被验证为空间开发人员,则分配所有角色。
11.16. 配置参考
您必须提供几项配置。这些是 Spring Boot@ConfigurationProperties
,以便您可以将它们设置为它们作为环境变量或通过 Spring Boot 支持的任何其他方式。以下列表位于环境变量格式中,因为这是开始在 Cloud Foundry 中配置 Boot 应用程序的简单方法。请注意,将来您将能够将任务部署到多个平台,但对于 2.0.0.M1,您只能部署到单个平台,并且名称必须是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.cloudfoundry.services
,spring.cloud.deployer.cloudfoundry.buildpacks
,或 Spring Cloud Deployer-standardspring.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”,显示在错误发生之前涉及哪些运算符。此功能很有帮助,因为部署者 依赖于 Project Reactor 和常规堆栈跟踪可能并不总是允许在错误发生之前了解流。 请注意,这会带来性能损失,因此默认情况下处于禁用状态。
spring.cloud.dataflow.server.cloudfoundry.debugReactor == true
-
Deployer 和 Cloud Foundry 客户端库请求和响应日志。此功能允许查看之间的详细对话 数据流服务器和 Cloud Foundry 云控制器。
logging.level.cloudfoundry-client == DEBUG
11.18. Spring Cloud Config 服务器
您可以使用 Spring Cloud Config Server 集中 Spring Boot 应用程序的配置属性。 同样 Spring Cloud Data Flow 和由 Spring Cloud Data Flow 编排的应用程序都可以与配置服务器集成以使用相同的功能。
11.18.1. Stream、Task 和 Spring Cloud Config 服务器
与 Spring Cloud Data Flow 服务器类似,您可以配置流和任务应用程序以解析来自配置服务器的集中式属性。
设置spring.cloud.config.uri
属性是绑定到配置服务器的常用方法。
有关更多信息,请参阅 Spring Cloud Config 客户端参考指南。
由于此属性可能用于数据流服务器部署的所有应用程序,因此数据流服务器的spring.cloud.dataflow.applicationProperties.stream
流应用程序的属性和spring.cloud.dataflow.applicationProperties.task
任务应用程序的属性可用于传递uri
配置服务器的 Config Server 发送到每个已部署的流或任务应用程序。有关详细信息,请参阅有关通用应用程序属性的部分。
请注意,如果您使用 App Starters 项目中的应用程序,这些应用程序已经嵌入了spring-cloud-services-starter-config-client
Dependency。
如果您从头开始构建应用程序并希望添加对配置服务器的客户端支持,则可以添加对配置服务器客户端库的依赖引用。以下代码片段显示了一个 Maven 示例:
...
<dependency>
<groupId>io.pivotal.spring.cloud</groupId>
<artifactId>spring-cloud-services-starter-config-client</artifactId>
<version>CONFIG_CLIENT_VERSION</version>
</dependency>
...
哪里CONFIG_CLIENT_VERSION
可以是 Pivotal Cloud Foundry 的 Spring Cloud Config Server 客户端的最新版本。
您可能会看到一个WARN 如果使用此库的应用程序无法连接到配置,则会记录消息
服务器 当应用程序启动时以及每当/health 端点被访问。
如果您知道自己没有使用配置服务器功能,则可以通过将SPRING_CLOUD_CONFIG_ENABLED 环境变量设置为false . |
11.18.2. 示例清单模板
以下 SCDF 和 Skippermanifest.yml
模板包括 Skipper 和 Spring Cloud Data Flow 服务器所需的环境变量,以及部署的应用程序和任务,以便在 Cloud Foundry 上成功运行并自动解析来自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
哪里my-config-server
是在 Cloud Foundry 上运行的 Spring Cloud Config Service 实例的名称。
通过将服务分别绑定到 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 证书。
通过使用相同的manifest.yml
上一节中列出的服务器模板,我们可以通过设置TRUST_CERTS: <API_ENDPOINT>
.
但是,部署的应用程序还需要TRUST_CERTS
作为平面环境变量(而不是包装在SPRING_APPLICATION_JSON
),因此我们必须使用另一组Tokens (SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_USE_SPRING_APPLICATION_JSON: false
) 用于任务。
通过此设置,应用程序将其应用程序属性作为常规环境变量接收。
以下列表显示了更新的manifest.yml
进行所需的更改。数据流服务器和已部署的应用程序
从my-config-server
Cloud Config 服务器(部署为 Cloud Foundry 服务)。
---
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
此外,将my-config-server
服务到 Skipper 的清单环境
---
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. 配置调度
本节讨论如何配置 Spring Cloud Data Flow 以连接到 PCF-Scheduler 作为其代理来执行任务。
在遵循这些说明之前,请确保在 Cloud Foundry 空间中运行 PCF-Scheduler 服务的实例。
要在您的空间中创建 PCF-Scheduler(假设它位于您的 Market Place 中),请从 CF CLI 执行以下作: |
对于计划,您必须在环境中添加(或更新)以下环境变量:
-
通过设置
spring.cloud.dataflow.features.schedules-enabled
自true
. -
通过将 PCF-Scheduler 服务名称添加到
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_SERVICES
环境变量。 -
通过设置
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_SCHEDULER_SCHEDULER_URL
环境变量。
创建上述配置后,必须创建需要计划的所有任务定义。 |
以下示例清单显示了配置的两个环境属性(假设你有一个名为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
其中SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]SCHEDULER_SCHEDULER_URL
具有以下格式:scheduler.<Domain-Name>
(对于
例scheduler.local.pcfdev.io
).从您的_PCF中查看实际地址环境。
有关跨多个平台启动和计划任务的详细示例,请参阅此部分 dataflow.spring.io 上任务的多平台支持。 |
12. 配置 - Kubernetes
本节介绍如何配置 Spring Cloud Data Flow 功能,例如部署器属性、任务以及要使用的关系数据库。
12.1. 功能切换
数据流服务器提供了一组特定的功能,可以在启动时启用或禁用这些功能。这些功能包括所有生命周期作、REST 终结点(服务器和客户端实现,包括 Shell 和 UI),用于:
-
流
-
任务
-
附表
您可以通过在启动数据流服务器时设置以下布尔环境变量来启用或禁用这些功能:
-
SPRING_CLOUD_DATAFLOW_FEATURES_STREAMS_ENABLED
-
SPRING_CLOUD_DATAFLOW_FEATURES_TASKS_ENABLED
-
SPRING_CLOUD_DATAFLOW_FEATURES_SCHEDULES_ENABLED
默认情况下,所有功能都处于启用状态。
这/features
REST 终结点提供有关已启用和禁用的功能的信息。
12.2. Deployer 属性
您可以使用 Kubernetes 部署程序的以下配置属性来自定义 Streams 和 Tasks 的部署方式。
使用数据流 shell 进行部署时,可以使用语法deployer.<appName>.kubernetes.<deployerPropertyName>
.
在数据流服务器中配置 Kubernetes 任务平台和 Skipper 中的 Kubernetes 平台以部署 Streams 时,也会使用这些属性。
部署程序属性名称 | 描述 | 默认值 |
---|---|---|
Namespace |
要使用的命名空间 |
环境变量 |
deployment.nodeSelector |
要应用于部署的节点选择器 |
<无> |
imagePullSecret (图像拉取秘密) |
访问私有注册表以拉取映像的机密。 |
<无> |
imagePullPolicy |
拉取映像时要应用的映像拉取策略。有效选项包括 |
如果不存在 |
livenessProbeDelay |
应用容器的 Kubernetes 活跃度检查应开始检查其运行状况时的延迟(以秒为单位)。 |
10 |
livenessProbe周期 |
对应用容器执行 Kubernetes 活动性检查的时间段(以秒为单位)。 |
60 |
livenessProbeTimeout |
应用容器的 Kubernetes 活动性检查的超时(以秒为单位)。如果运行状况检查返回的时间超过此值,则假定为“不可用”。 |
2 |
liveness探针路径 |
应用容器必须响应的路径才能进行活动性检查。 |
<无> |
livenessProbePort |
应用容器必须响应以进行活动性检查的端口。 |
<无> |
准备情况ProbeDelay |
当应用容器的就绪性检查应开始检查模块是否完全启动并运行时,延迟(以秒为单位)。 |
10 |
准备情况探针周期 |
执行应用容器就绪情况检查的时间段(以秒为单位)。 |
10 |
readinessProbeTimeout |
应用容器在就绪情况检查期间必须响应其运行状况的超时(以秒为单位)。 |
2 |
准备情况探针路径 |
应用容器必须响应以进行就绪情况检查的路径。 |
<无> |
准备就绪ProbePort |
应用容器必须响应以进行就绪检查的端口。 |
<无> |
probeCredentialsSecret |
包含访问安全探测终结点时要使用的凭据的密钥名称。 |
<无> |
limits.memory |
内存限制,分配 Pod 所需的最大值,默认单位为 mebibytes,支持 'M' 和 'G' 后缀 |
<无> |
limits.cpu |
CPU 限制,分配 Pod 所需的最大值 |
<无> |
请求.memory |
内存请求,保证分配 Pod 所需的值。 |
<无> |
请求.cpu |
CPU 请求,保证分配 Pod 所需的值。 |
<无> |
statefulSet.volumeClaimTemplate.storageClassName |
有状态集的存储类的名称 |
<无> |
statefulSet.volumeClaimTemplate.storage |
存储量。默认单位为兆字节,支持“M”和“G”后缀 |
<无> |
环境变量 |
要为任何已部署的应用容器设置的环境变量列表 |
<无> |
入口点样式 |
用于 Docker 映像的入口点样式。用于确定如何传入属性。可以 |
|
createLoadBalancer |
为为每个应用程序创建的服务创建一个“LoadBalancer”。这有助于将外部 IP 分配给应用程序。 |
false |
服务注释 |
为为每个应用程序创建的服务设置的服务注释。格式的字符串 |
<无> |
pod注释 |
要为为每个部署创建的 Pod 设置的 Pod 注释。格式的字符串 |
<无> |
job注释 |
要为为作业创建的容器或作业设置的作业注释。格式的字符串 |
<无> |
分钟等待负载均衡器 |
在尝试删除服务之前等待负载均衡器可用的时间(以分钟为单位)。 |
5 |
maxTerminatedErrorRestarts (最大终止错误重启) |
由于错误或资源使用过多而失败的应用允许重启的最大值。 |
2 |
maxCrashLoopBackOffRestarts |
CrashLoopBackOff 中的应用允许的最大重启。值是 |
|
volumeMounts |
以 YAML 格式表示的卷挂载。例如 |
<无> |
卷 |
Kubernetes 实例支持的卷以 YAML 格式指定。例如 |
<无> |
主机网络 |
部署的 hostNetwork 设置,请参阅 kubernetes.io/docs/api-reference/v1/definitions/#_v1_podspec |
false |
创建部署 |
使用“副本集”而不是“复制控制器”创建“部署”。 |
true |
创建作业 |
在启动任务时创建一个“作业”,而不仅仅是一个“Pod”。 |
false |
container命令 |
使用提供的命令和参数覆盖默认入口点命令。 |
<无> |
容器端口 |
添加要在容器上公开的其他端口。 |
<无> |
创建节点端口 |
在以下情况下使用的显式端口 |
<无> |
部署服务帐户名称 |
应用部署中使用的服务帐户名称。注意:用于应用部署的服务帐户名称派生自数据流服务器部署。 |
<无> |
部署标签 |
要添加到部署的其他标签 |
<无> |
bootMajor版本 |
要使用的 Spring Boot 主要版本。目前仅用于自动配置 Spring Boot 版本特定的探针路径。有效选项包括 |
2 |
tolerations.key |
用于容忍的关键。 |
<无> |
容忍度.效果 |
容忍效应。有关有效选项,请参阅 kubernetes.io/docs/concepts/configuration/taint-and-toleration。 |
<无> |
容忍.运算符 |
容差运算符。有关有效选项,请参阅 kubernetes.io/docs/concepts/configuration/taint-and-toleration/。 |
<无> |
tolerations.toleration秒 |
定义添加污点后 Pod 与节点绑定多长时间的秒数。 |
<无> |
容忍度.值 |
要应用的容忍值,与 |
<无> |
secretRefs |
将整个数据内容加载到各个环境变量中的密钥的名称。多个机密可以用逗号分隔。 |
<无> |
secretKeyRefs.envVarName |
用于保存机密数据的环境变量名称 |
<无> |
secretKeyRefs.secretName |
要访问的机密名称 |
<无> |
secretKeyRefs.dataKey |
要从中获取密钥数据的密钥名称 |
<无> |
配置映射引用 |
用于将整个数据内容加载到各个环境变量中的 ConfigMap 的名称。多个 ConfigMap 以逗号分隔。 |
<无> |
configMapKeyRefs.envVarName |
用于保存 ConfigMap 数据的环境变量名称 |
<无> |
configMapKeyRefs.configMapName |
要访问的 ConfigMap 名称 |
<无> |
configMapKeyRefs.dataKey |
从中获取 ConfigMap 数据的键名称 |
<无> |
最大并发任务 |
此平台实例允许的最大并发任务。 |
20 |
podSecurityContext.runAs用户 |
用于在 |
<无> |
podSecurityContext.fs组 |
用于在 |
<无> |
affinity.node亲和力 |
以 YAML 格式表示的节点亲和性。例如 |
<无> |
affinity.pod亲和力 |
以 YAML 格式表示的 Pod 亲和力。例如 |
<无> |
affinity.pod反亲和力 |
以YAML格式表示的pod反亲和力。例如 |
<无> |
statefulSetInitContainerImageName |
用于 StatefulSet 初始化容器的自定义镜像名称 |
<无> |
初始容器 |
以 YAML 格式表示的 Init 容器,要应用于 Pod。例如 |
<无> |
additional容器 |
以 YAML 格式表示的要应用于 Pod 的其他容器。例如 |
<无> |
12.3. 任务
数据流服务器负责部署任务。
数据流启动的任务将其状态写入数据流服务器使用的同一数据库。
对于 Spring Batch Jobs 的任务,作业和步骤执行数据也存储在此数据库中。
与 Skipper 一样,任务可以启动到多个平台。
当数据流在 Kubernetes 上运行时,必须定义任务平台。
要配置面向 Kubernetes 的新平台帐户,请在spring.cloud.dataflow.task.platform.kubernetes
部分在您的application.yaml
文件。
在以下示例中,两个名为dev
和qa
被创建。
键,例如memory
和disk
是 Cloud Foundry Deployer 属性。
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
将被使用。
将任务部署到多个平台时,任务的配置需要连接到与数据流服务器相同的数据库。 |
您可以配置 Kubernetes 上的数据流服务器,以将任务部署到 Cloud Foundry 和 Kubernetes。有关更多信息,请参阅有关 Cloud Foundry 任务平台配置的部分。
有关跨多个平台启动和计划任务的详细示例,请参阅此部分 dataflow.spring.io 上任务的多平台支持。
12.4. 常规配置
适用于 Kubernetes 的 Spring Cloud Data Flow 服务器使用spring-cloud-kubernetes
模块来处理挂载在/etc/secrets
.ConfigMap 必须挂载为application.yaml
在/config
由 Spring Boot 处理的目录。为了避免访问 Kubernetes API 服务器,SPRING_CLOUD_KUBERNETES_CONFIG_ENABLE_API
和SPRING_CLOUD_KUBERNETES_SECRETS_ENABLE_API
设置为false
.
12.4.1. 使用 ConfigMap 和密钥
以下示例显示了一种可能的配置,它启用 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 部署时使用mysql
作为服务名称。Kubernetes 将这些服务的主机和端口值发布为环境变量,我们可以在配置部署的应用程序时使用这些变量。
我们更愿意在 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 提供模式。如果类路径中存在正确的数据库驱动程序和适当的凭据,则在服务器启动时会自动创建适当的模式。
MySQL(通过 MariaDB 驱动程序)、HSQLDB、PostgreSQL 和嵌入式 H2 的 JDBC 驱动程序开箱即用。 如果您使用任何其他数据库,则需要将相应的 JDBC 驱动程序 jar 放在服务器的类路径上。
例如,如果您在 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 挂载为application.yaml
下/config
Spring Boot 将处理它以及挂载在/etc/secrets
由于环境变量,它将被 spring-cloud-kubernetes 库拾取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>
如果容器持续重新启动,您可以将-p
作为查看上一个日志的选项,如下所示:
kubectl logs -p <pod-name>
您还可以通过添加-f
选项,如下所示:
kubectl logs -f <pod-name>
帮助解决问题(例如容器在启动时出现致命错误)的一个有用命令是使用describe
命令,如以下示例所示:
kubectl describe pod ticktock-log-0-qnk72
12.6.1. 检查服务器日志
您可以使用以下命令访问服务器日志:
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. 任务
任务作为裸容器启动,没有复制控制器。任务完成后,容器仍会保留,这使您有机会查看日志。
要查看特定任务的所有容器,请使用以下命令:
kubectl get pod -l task-name=<task-name>
若要查看任务日志,请使用以下命令:
kubectl logs <task-pod-name>
您有两个选项可以删除已完成的容器。一旦不再需要它们,您可以手动删除它们,也可以使用数据流 shelltask execution cleanup
命令以删除已完成的 Pod 以执行任务。
要手动删除任务 Pod,请使用以下命令:
kubectl delete pod <task-pod-name>
要使用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。
如果使用exec
或shell
入口点样式,如果用户执行kubectl describe
在任务的 Pod 上。
要将 Spring Cloud Data Flow 配置为使用 Kubernetes Secrets:将spring.cloud.dataflow.task.use.kubernetes.secrets.for.db.credentials
属性设置为true
.如果使用 Spring Cloud Data Flow 提供的 yaml 文件,请更新 'src/kubernetes/server/server-deployment.yaml 以添加以下环境变量:
- name: SPRING_CLOUD_DATAFLOW_TASK_USE_KUBERNETES_SECRETS_FOR_DB_CREDENTIALS
value: 'true'
如果从以前版本的 SCDF 升级,请务必验证spring.datasource.username
和spring.datasource.password
环境变量存在于secretKeyRefs
在 server-config.yaml 中。如果没有,请按以下示例所示添加它:
...
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
...
此外,请验证关联的密钥 (dataKey) 是否在密钥中也可用。SCDF 在这里为 MySQL 提供了一个示例:src/kubernetes/mysql/mysql-svc.yaml
.
默认情况下,通过属性传递数据库凭据是为了保持向后兼容性。此功能将在将来的版本中删除。 |
12.7. 调度
本节介绍如何配置计划任务的自定义。默认情况下,任务调度在 Spring Cloud Data Flow Kubernetes Server 中启用。属性用于影响计划任务的设置,并且可以全局或按计划进行配置。
除非另有说明,否则按计划设置的属性始终优先于设置为服务器配置的属性。这种安排允许覆盖特定计划的全局服务器级别属性。 |
看KubernetesSchedulerProperties
有关支持选项的更多信息。
12.7.1. 入口点样式
入口点样式会影响应用程序属性传递到要部署的任务容器的方式。目前,支持三种样式:
-
exec
:(默认)将所有应用程序属性作为命令行参数传递。 -
shell
:将所有应用程序属性作为环境变量传递。 -
boot
:创建一个名为SPRING_APPLICATION_JSON
包含所有应用程序属性的 JSON 表示形式。
您可以按如下方式配置入口点样式:
deployer.kubernetes.entryPointStyle=<Entry Point Style>
取代<Entry Point Style>
替换为所需的入口点样式。
您还可以在容器中的服务器级别配置入口点样式env
部分,如以下示例所示:
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_ENTRY_POINT_STYLE
value: entryPointStyle
取代entryPointStyle
替换为所需的入口点样式。
您应该选择 入口点样式exec
或shell
,以对应于ENTRYPOINT
语法在容器的Dockerfile
.有关更多信息和用例exec
与shell
,请参阅 Docker 文档的 ENTRYPOINT 部分。
使用boot
入口点样式对应于使用exec
风格ENTRYPOINT
.部署请求中的命令行参数将传递到容器,并添加映射到SPRING_APPLICATION_JSON
环境变量而不是命令行参数。
12.7.2. 环境变量
要影响给定应用程序的环境设置,您可以利用spring.cloud.deployer.kubernetes.environmentVariables
财产。
例如,生产环境中的一个常见要求是影响 JVM 内存参数。
您可以通过使用JAVA_TOOL_OPTIONS
环境变量,如以下示例所示:
deployer.kubernetes.environmentVariables=JAVA_TOOL_OPTIONS=-Xmx1024m
在部署流应用程序或启动某些属性可能包含敏感信息的任务应用程序时,请使用shell 或boot 作为entryPointStyle .这是因为exec (默认)将所有属性转换为命令行参数,因此在某些环境中可能不安全。 |
此外,您可以在容器中的服务器级别配置环境变量env
部分,如以下示例所示:
在服务器配置中指定环境变量并按计划指定环境变量时,环境变量将被合并。这允许在服务器配置中设置通用环境变量,并在特定计划级别设置更具体的环境变量。 |
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
使用所需的映像拉取策略。
您可以在容器中的服务器级别配置镜像拉取策略env
部分,如以下示例所示:
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_POLICY
value: Always
取代Always
使用所需的映像拉取策略。
12.7.4. 私有 Docker 注册表
可以通过配置 Secret 来提取私有且需要身份验证的 Docker 镜像。首先,您必须在集群中创建一个密钥。按照从私有注册表拉取映像指南创建密钥。
创建密钥后,使用imagePullSecret
属性来设置要使用的密钥,如以下示例所示:
deployer.kubernetes.imagePullSecret=mysecret
取代mysecret
替换为您之前创建的密钥的名称。
您还可以在容器中的服务器级别配置镜像拉取密钥env
部分,如以下示例所示:
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_SECRET
value: mysecret
取代mysecret
替换为您之前创建的密钥的名称。
12.7.5. 命名空间
默认情况下,用于计划任务的命名空间为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
替换为您的服务帐户名称。
您还可以在容器中的服务器级别配置服务帐户名称env
部分,如以下示例所示:
env:
- name: SPRING_CLOUD_SCHEDULER_KUBERNETES_TASK_SERVICE_ACCOUNT_NAME
value: myserviceaccountname
取代myserviceaccountname
替换为要应用于所有部署的服务帐户名称。
有关计划任务的详细信息,请参阅计划任务。
12.8. 调试支持
通过 Java Debug Wire Protocol (JDWP) 支持调试 Spring Cloud Data Flow Kubernetes Server 和包含的组件(例如 Spring Cloud Kubernetes Deployer)。本节概述了一种手动启用调试的方法,以及另一种使用 Spring Cloud Data Flow Server Kubernetes 提供的配置文件来“修补”正在运行的部署的方法。
JDWP 本身不使用任何身份验证。本节假设调试是在本地开发环境(例如 Minikube)上完成的,因此不提供有关保护调试端口的指南。 |
12.8.1. 手动启用调试
要手动启用 JDWP,请先编辑src/kubernetes/server/server-deployment.yaml
,然后添加额外的containerPort
在spec.template.spec.containers.ports
值为5005
.此外,将JAVA_TOOL_OPTIONS
环境变量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,但它可以是与另一个端口不冲突的任何数字。所选的端口号也必须与添加的containerPort value 和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
子命令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
,例如)。
可以通过将更改还原为src/kubernetes/server/server-deployment.yaml
.恢复的更改将在 Spring Cloud Data Flow Kubernetes Server 的下一次部署中选取。当每次部署服务器时都应默认启用调试时,手动向配置添加调试支持非常有用。
12.8.2. 使用修补启用调试
而不是手动更改server-deployment.yaml
,Kubernetes 对象可以就地“修补”。为方便起见,包括提供与手动方法相同配置的补丁文件。要通过修补启用调试,请使用以下命令:
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
...
要启用对调试端口的访问,而不是使用port-forward
子命令kubectl
,您可以修补scdf-server
Kubernetes 服务对象。您必须首先确保scdf-server
Kubernetes 服务对象具有正确的配置。以下示例(带输出)显示了如何执行此作:
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)"
仅当在添加调试功能之前创建了目标集群时,才应缺少端口名称。由于正在将多个端口添加到scdf-server Kubernetes 服务对象,每个对象都需要有自己的名称。 |
现在,您可以添加调试端口,如以下示例所示:
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 已映射到 31339 的 NodePort。以下示例(带输出)显示了如何获取 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 部署对象在修补之前回滚到其状态。然后,Kubernetes 服务对象将使用remove
从containerPorts
列表。
kubectl rollout undo 强制 Pod 重新启动。修补 Kubernetes 服务对象不会重新创建服务,并且端口映射到scdf-server 部署保持不变。 |
有关部署回滚的更多信息,请参阅回滚部署,包括管理历史记录和使用 kubectl 补丁就地更新 API 对象。