SpringCloudDataFlow遇到问题？我们愿意提供帮助！
管道由使用SpringCloudStream或SpringCloudTask微服务框架构建的SpringBoot应用程序组成。这使得SpringCloudDataFlow适用于从导入导出到事件流和预测分析的一系列数据处理用例。
该项目支持使用带有Kubernetes的SpringCloudDataFlow作为这些管道的运行时，并将应用程序打包为Docker映像。
本节介绍如何自定义应用程序的部署。您可以使用许多属性来影响已部署应用程序的设置。可以基于每个应用程序或在所有已部署应用程序的适当服务器配置中应用属性。
要应用于所有已部署任务的属性在src/kubernetes/server/server-config-[binder].yaml文件中定义，对于Streams在src/kubernetes/skipper/skipper-config-[binder].yaml.替换[binder]为您正在使用的消息传递中间件-例如，rabbit或kafka.
应用程序使用默认内存和CPU设置进行部署。如果需要，您可以调整这些值。以下示例显示了如何设置Limits为1000mforCPUand1024Miformemory以及Requeststo800mforforCPUand640Miformemory：
deployer.
Limits:cpu:1memory:1GiRequests:cpu:800mmemory:640Mi您还可以控制全局设置cpu和的默认值。memory
以下示例显示了如何为流设置CPU和内存：
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:limits:memory:640micpu:500m以下示例显示了如何为任务设置CPU和内存：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:limits:memory:640micpu:500m到目前为止我们使用的设置只影响容器的设置。它们不会影响容器中JVM进程的内存设置。如果您想设置JVM内存设置，您可以设置一个环境变量来执行此操作。有关详细信息，请参阅下一节。
要影响给定应用程序的环境设置，您可以使用spring.cloud.deployer.kubernetes.environmentVariablesdeployer属性。例如，生产设置中的一个常见要求是影响JVM内存参数。您可以使用JAVA_TOOL_OPTIONS环境变量来执行此操作，如以下示例所示：
deployer.
liveness和探针分别使用称为和的readiness路径。他们分别使用aof和aofand。您可以在使用部署程序属性部署流时更改这些默认值。liveness和readiness探针仅适用于流。/health/infodelay10period6010
以下示例通过设置部署程序属性来更改liveness探测（替换为您的应用程序的名称）：
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:livenessProbePath:/healthlivenessProbeDelay:120livenessProbePeriod:20同样，您可以交换liveness以readiness覆盖默认readiness设置。
默认情况下，端口8080用作探测端口。liveness您可以使用部署程序属性更改这两个端口和探测端口的默认值readiness，如以下示例所示：
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:readinessProbePort:7000livenessProbePort:7000默认情况下，liveness和readiness探测路径使用SpringBoot2.x+执行器端点。要使用SpringBoot1.x执行器端点路径，您必须调整liveness和readiness值，如以下示例所示（替换
deployer.
要创建新密钥：
您可以使用SPRING_APPLICATION_JSON环境变量来设置在所有数据流服务器实现中通用的数据流服务器属性（包括Maven存储库设置的配置）。env这些设置位于部署YAML的容器部分的服务器级别。以下示例显示了如何执行此操作：
创建密钥后，您可以使用该imagePullSecret属性设置要使用的密钥，如以下示例所示：
deployer.
您还可以在全局服务器级别配置图像拉取密钥。
以下示例显示了如何对流执行此操作：
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:imagePullSecret:mysecret以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:imagePullSecret:mysecret替换mysecret为您之前创建的密钥的名称。
以下示例显示了如何配置应用程序以使用注释：
deployer.
入口点样式会影响应用程序属性如何传递到要部署的容器。目前支持三种样式：
您可以按如下方式配置应用程序：
deployer.
您还可以在全局服务器级别配置入口点样式。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:entryPointStyle:entryPointStyle以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:entryPointStyle:entryPointStyle替换entryPointStyle为所需的入口点样式。
使用boot入口点样式对应于使用exec样式ENTRYPOINT。来自部署请求的命令行参数被传递给容器，添加的应用程序属性被映射到SPRING_APPLICATION_JSON环境变量而不是命令行参数。
您可以通过属性为应用程序部署配置自定义服务帐户。您可以使用现有服务帐户或创建一个新帐户。创建服务帐户的一种方法是使用kubectl，如以下示例所示：
$kubectlcreateserviceaccountmyserviceaccountnameserviceaccount"myserviceaccountname"created然后，您可以按如下方式配置各个应用程序：
deployer.
您还可以在全局服务器级别配置服务帐户名称。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:deploymentServiceAccountName:myserviceaccountname以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:deploymentServiceAccountName:myserviceaccountname替换myserviceaccountname为要应用于所有部署的服务帐户名称。
镜像拉取策略定义了何时应该将Docker镜像拉取到本地注册表。目前支持三种策略：
以下示例显示了如何单独配置应用程序：
deployer.
您可以在全局服务器级别配置图像拉取策略。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:imagePullPolicy:Always以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:imagePullPolicy:Always替换Always为您想要的图像拉取策略。
deployer.
此外，您可以应用多个标签，如以下示例所示：
deployer.
您也可以在全局服务器级别配置容限。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:tolerations:-key:mykeyoperator:Equalvalue:myvalueeffect:NoSchedule以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:tolerations:-key:mykeyoperator:Equalvalue:myvalueeffect:NoSchedule根据您所需的容错配置替换tolerations键值对。
deployer.
deployer.
您也可以在全局服务器级别配置秘密引用。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:secretRefs:-testsecret-anothersecret以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:secretRefs:-testsecret-anothersecretsecretRefs用一个或多个秘密名称替换的项目。
deployer.
您也可以在全局服务器级别配置密钥引用。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:secretKeyRefs:-envVarName:MY_SECRETsecretName:testsecretdataKey:password以下示例显示了如何对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:secretKeyRefs:-envVarName:MY_SECRETsecretName:testsecretdataKey:password将envVarName、secretName和dataKey属性替换为您的密钥的适当值。
deployer.
deployer.
您也可以在全局服务器级别配置ConfigMap引用。
以下示例显示了如何对流执行此操作。编辑适当的skipper-config-(binder).yaml，替换(binder)为使用中的相应活页夹：
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:configMapRefs:-testcm-anothercm以下示例显示如何通过编辑server-config.yaml文件对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:configMapRefs:-testcm-anothercmconfigMapRefs用一个或多个秘密名称替换的项目。
deployer.
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:configMapKeyRefs:-envVarName:MY_CMconfigMapName:testcmdataKey:platform以下示例显示如何通过编辑server-config.yaml文件对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:configMapKeyRefs:-envVarName:MY_CMconfigMapName:testcmdataKey:platform将envVarName、configMapName和dataKey属性替换为ConfigMap的适当值。
以下示例显示了如何单独配置应用程序pod：
deployer.
您也可以在全局服务器级别配置pod安全上下文。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:podSecurityContext:runAsUser:65534fsGroup:65534以下示例显示如何通过编辑server-config.yaml文件对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:podSecurityContext:runAsUser:65534fsGroup:65534将runAsUserand/orfsGroup属性替换为适合您的容器环境的值。
部署应用程序时，会创建一个KubernetesService对象，其默认端口为8080.如果server.port设置了该属性，它将覆盖默认端口值。您可以基于每个应用程序向Service对象添加其他端口。您可以使用逗号分隔符添加多个端口。
以下示例显示了如何在应用程序的服务对象上配置其他端口：
deployer.
使用StatefulSet部署应用程序时，会使用InitContainer来设置Pod中的实例索引。默认情况下，使用的图像是busybox，您可以自定义。
deployer.
您也可以在全局服务器级别配置StatefulSetInitContainer。
data:application.yaml:|-spring:cloud:skipper:server:platform:kubernetes:accounts:default:statefulSetInitContainerImageName:myimage:mylabel以下示例显示如何通过编辑server-config.yaml文件对任务执行此操作：
data:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:statefulSetInitContainerImageName:myimage:mylabel将statefulSetInitContainerImageName属性替换为适合您环境的值。
以下示例显示了如何为应用程序配置Init容器：
deployer.
deployer.
以下示例显示了如何为应用程序配置其他容器：
SpringCloudDataFlow简化了专注于数据处理用例的应用程序的开发和部署。
如果要覆盖特定的Maven配置属性（远程存储库、代理和其他）或在代理后运行数据流服务器，则需要在启动数据流服务器时将这些属性指定为命令行参数，如以下示例：
$java-jarspring-cloud-dataflow-server-2.9.4.jar--spring.config.additional-location=/home/joe/maven.yml上述命令假定maven.yaml类似于以下内容：
您可以为每个远程存储库配置指定存储库策略，如前面的示例所示。该密钥policy适用于存储库策略snapshot和release存储库策略。
由于这些是SpringBoot@ConfigurationProperties，您需要通过将它们添加到SPRING_APPLICATION_JSON环境变量中来指定它们。以下示例显示了JSON的结构：
默认情况下，REST端点（管理、管理和运行状况）以及仪表板UI不需要经过身份验证的访问。
UAAOpenID不仅经过认证并被CloudFoundry使用，您还可以在本地单机部署场景中使用它。此外，UAA不仅提供自己的用户存储，还提供全面的LDAP集成。
默认情况下，仪表板、管理和运行状况端点使用HTTP作为传输。您可以通过在配置中添加证书来切换到HTTPSapplication.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，您可以选择将端口更改为更常见的HTTPs典型端口。2密钥存储在密钥库中的别名（或名称）。3密钥库文件的路径。您还可以通过使用类路径前缀来指定类路径资源-例如：classpath:path/to/keystore.4密钥库的密码。5密钥的密码。6信任库文件的路径。您还可以使用类路径前缀指定类路径资源-例如：classpath:path/to/trust-store7信任库的密码。如果启用HTTPS，它将完全取代HTTP作为REST端点和数据流仪表板交互的协议。普通HTTP请求失败。因此，请确保相应地配置您的Shell。使用自签名证书出于测试目的或在开发过程中，创建自签名证书可能会很方便。首先，执行以下命令来创建证书：
$keytool-genkey-aliasdataflow-keyalgRSA-keystoredataflow.keystore\-validity3650-storetypeJKS\-dname"CN=localhost,OU=Spring,O=Pivotal,L=Kailua-Kona,ST=HI,C=US"(1)-keypassdataflow-storepassdataflow1CN是这里的重要参数。它应该与您尝试访问的域匹配-例如，localhost.然后将以下行添加到您的application.yml文件中：
默认情况下，自签名证书是shell的一个问题，需要额外的步骤才能使shell与自签名证书一起工作。有两种选择：
为了使用JVM信任库选项，您需要从密钥库中导出之前创建的证书，如下所示：
$keytool-export-aliasdataflow-keystoredataflow.keystore-filedataflow_cert-storepassdataflow接下来，您需要创建一个shell可以使用的信任库，如下所示：
$keytool-importcert-keystoredataflow.truststore-aliasdataflow-storepassdataflow-filedataflow_cert-noprompt现在您可以使用以下JVM参数启动DataFlowShell：
$java-Djavax.net.ssl.trustStorePassword=dataflow\-Djavax.net.ssl.trustStore=/path/to/dataflow.truststore\-Djavax.net.ssl.trustStoreType=jks\-jarspring-cloud-dataflow-shell-2.9.4.jar如果您在通过SSL建立连接时遇到问题，您可以通过使用javax.net.debugJVM参数并将其设置为ssl.
不要忘记使用以下命令定位数据流服务器：
如果设置此命令行参数，shell将接受任何（自签名）SSL证书。
如果可能，您应该避免使用此选项。禁用信任管理器会破坏SSL的目的，并使您的应用程序容易受到中间人攻击。
您可以通过两种方式访问REST端点：
除了基本身份验证之外，您还可以提供访问令牌来访问RESTAPI。为此，请从您的OAuth2提供程序检索OAuth2访问令牌，并使用AuthorizationHTTP标头将该访问令牌传递给RESTApi，如下所示：
由于安全角色的确定是特定于环境的，因此SpringCloudDataFlow默认将所有角色分配给经过身份验证的OAuth2用户。该类DefaultDataflowAuthoritiesExtractor用于此目的。
map-oauth-scopes或者，您可以通过将您的提供者的布尔属性设置为true（默认值为false），让SpringCloudDataFlow将OAuth2范围映射到DataFlow角色。例如，如果您的提供商的ID为uaa，则属性将为spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes。
您还可以通过提供您自己的扩展SpringCloudDataFlowAuthorityMapper接口的Springbean定义来自定义角色映射行为。在这种情况下，自定义bean定义优先于SpringCloudDataFlow提供的默认定义。
默认规则如下：
HTTP_METHODURL_PATTERN'=>'SECURITY_ATTRIBUTE在哪里：
请注意，上面是一个YAML列表，而不是位于键下的映射（因此在每行的开头使用“-”破折号）spring.cloud.dataflow.security.authorization.rules。
启用安全性后，仪表板和外壳可以识别角色，这意味着根据分配的角色，并非所有功能都可见。
例如，用户没有必要角色的shell命令被标记为不可用。
中的默认配置dataflow-server-defaults.yml如下：
您需要检查、构建和运行UAA。为此，请确保您：
如果您在安装uaac时遇到问题，您可能需要设置GEM_HOME环境变量：
exportGEM_HOME="$HOME/.gem"您还应该确保~/.gem/gems/cf-uaac-4.2.0/bin已将其添加到您的路径中。
由于UAA是一个OpenID提供者并使用JSONWeb令牌(JWT)，因此它需要一个私钥来签署这些JWT：
要下载并安装UAA，请运行以下命令：
添加后，您可以快速仔细检查UAA是否已创建用户：
SpringCloudDataFlowServer提供了一组特定的功能，可以在启动时启用/禁用。这些功能包括所有生命周期操作和REST端点（服务器和客户端实现，包括shell和UI），用于：
在启动数据流服务器时，可以通过设置以下布尔属性来启用和禁用这些功能：
默认情况下，流（需要Skipper）和任务是启用的，而任务计划程序默认是禁用的。
REST/about端点提供有关已启用和禁用的功能的信息。
关系数据库用于存储流和任务定义以及已执行任务的状态。SpringCloudDataFlow为H2、MySQL、Oracle、PostgreSQL、Db2和SQLServer提供模式。服务器启动时会自动创建模式。
默认情况下，SpringCloudDataFlow提供了H2数据库的嵌入式实例。H2数据库适用于开发目的，但不建议用于生产用途。
MySQL（通过MariaDB驱动程序）、PostgreSQL、SQLServer和嵌入式H2的JDBC驱动程序无需额外配置即可使用。如果您使用任何其他数据库，则需要将相应的JDBC驱动程序jar放在服务器的类路径中。
数据库属性可以作为环境变量或命令行参数传递给数据流服务器。
以下示例显示如何使用MariaDB驱动程序定义MySQL数据库连接。
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.jar\--spring.datasource.url=jdbc:mysql://localhost:3306/mydb\--spring.datasource.username=\--spring.datasource.password=\--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver最高5.7的MySQL版本可以与MariaDB驱动程序一起使用。从版本8.0开始，必须使用MySQL自己的驱动程序。
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.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数据库连接
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.jar\--spring.datasource.url=jdbc:mariadb://localhost:3306/mydbuseMysqlMetadata=true\--spring.datasource.username=\--spring.datasource.password=\--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver从MariaDBv2.4.1连接器版本开始，还需要添加useMysqlMetadata=true到JDBCURL。在MySQL和MariaDB完全切换为两个不同的数据库之前，这是一个必需的解决方法。
MariaDB10.3版引入了对真实数据库序列的支持，这是另一个重大变化，而围绕这些数据库的工具完全支持MySQL和MariaDB作为单独的数据库类型。解决方法是使用不尝试使用序列的较旧的休眠方言。
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.jar\--spring.datasource.url=jdbc:mariadb://localhost:3306/mydbuseMysqlMetadata=true\--spring.datasource.username=\--spring.datasource.password=\--spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDB102Dialect\--spring.datasource.driver-class-name=org.mariadb.jdbc.Driver10.2.3.PostgreSQL以下示例显示如何使用命令行参数定义PostgreSQL数据库连接：
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.jar\--spring.datasource.url=jdbc:postgresql://localhost:5432/mydb\--spring.datasource.username=\--spring.datasource.password=\--spring.datasource.driver-class-name=org.postgresql.Driver10.2.4.SQL服务器以下示例显示如何使用命令行参数定义SQLServer数据库连接：
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.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.SQLServerDriver10.2.5。数据库2以下示例显示如何使用命令行参数定义Db2数据库连接：
java-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.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-jarspring-cloud-dataflow-server/target/spring-cloud-dataflow-server-2.9.4.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-serverGitHub存储库中有GA发布标签，因此您可以切换到所需的GA标签以在生产就绪代码库中添加驱动程序。
为SpringCloudDataFlow服务器添加自定义JDBC驱动程序依赖项：
spring:datasource:url:jdbc:postgresql://localhost:5432/mydbusername:myuserpassword:mypassdriver-class-name:org.postgresql.Driver10.2.8.模式处理默认数据库模式由Flyway管理，如果可以为数据库用户提供足够的权限，这很方便。
以下是Skipper服务器启动时发生的情况的描述：
以下是启动Dataflow服务器时发生的情况的描述：
工作目录根
所有创建的进程将在其中运行并创建日志文件的目录。
java.io.tmpdir
envVarsToInherit
传递给已启动应用程序的环境变量的正则表达式模式数组。
<"TMP","LANG","LANGUAGE","LC_.*","PATH","SPRING_APPLICATION_JSON">和<"TMP","LANG","LANGUAGE","LC_.*","Unix上的PATH">
deleteFilesOnExit
是否在JVM退出时删除创建的文件和目录。
真的
javaCmd
运行java的命令
java
关机超时
等待应用关闭的最大秒数。
30
javaOpts
传递给JVM的Java选项，例如-Dtest=foo
<无>
继承记录
允许将日志记录重定向到触发子进程的进程的输出流。
错误的
调试端口
远程调试端口
dataflow:>streamcreate--nameticktock--definition"time--server.port=9000|log"dataflow:>streamdeploy--nameticktock--properties"deployer.time.local.javaOpts=-Xmx2048m-Dtest=foo"为方便起见，您可以设置deployer.memory属性来设置Java选项-Xmx，如下例所示：
dataflow:>streamdeploy--nameticktock--properties"deployer.time.memory=2048m"在部署时，如果您-Xmx在deployer.
SpringCloudDataFlowlocal服务器自动配置为RollingFileAppender用于日志记录。日志记录配置位于名为logback-spring.xml.
默认情况下，日志文件配置为使用：
<附加程序名称="文件" class="ch.qos.logback.core.rolling.RollingFileAppender">
jinfo
DataFlowServer将Stream生命周期的管理委托给Skipper服务器。将配置属性设置spring.cloud.skipper.client.serverUri为Skipper的位置，例如
要为本地平台配置新平台帐户，spring.cloud.dataflow.task.platform.local请在文件中的部分下提供一个条目，application.yaml以通过另一个SpringBoot支持的机制。在以下示例中，创建了两个名为localDev和localDevDebug的本地平台帐户。shutdownTimeout和等键javaOpts是本地部署程序属性。
spring:cloud:dataflow:task:platform:local:accounts:localDev:shutdownTimeout:60javaOpts:"-Dtest=foo-Xmx1024m"localDevDebug:javaOpts:"-Xdebug-Xmx2048m"通过将一个平台定义为default允许您跳过platformName在其他情况下需要使用它的地方。启动任务时，使用任务启动选项传递平台帐户名称的值--platformName如果不传递的值，将使用platformName该值。default
最后启动SpringCloudDataFlow：
spring.cloud.dataflow.security.authorization.provider-role-mappings.uaa.map-oauth-scopes:true
这将指示底层DefaultAuthoritiesExtractor将OAuth范围映射到相应的权限。支持以下范围：
此外，您还可以将任意范围映射到每个数据流角色：
虽然您可以使用自己的OAuth2身份验证服务器，但此处记录的LDAP支持需要使用UAA作为身份验证服务器。对于任何其他提供商，请查阅该特定提供商的文档。
UAA支持使用以下模式对LDAP（轻量级目录访问协议）服务器进行身份验证：
存在以下选项：
这些值是通过配置属性指定的ldap.groups.filecontrols。在幕后，这些值引用了SpringXML配置文件。
这只是一个演示/示例应用程序，不得用于生产。
设置包括：
最后，作为本示例的一部分，您将学习如何使用此安全设置配置和启动组合任务。
克隆项目并使用各自的ClientID和ClientSecret配置SpringCloudDataFlow：
成功定位后，您应该会看到以下输出：
使用credentials-provider命令时，请注意您指定的命令必须返回一个Bearer令牌（AccessToken前缀为Bearer）。例如，在Unix环境中，可以使用以下简单命令：
默认情况下，不显示shell依赖项的校验和值。如果您需要启用此功能，请将spring.cloud.dataflow.version-info.dependency-fetch.enabled属性设置为true。
您可以将保留值（用大括号括起来）插入到URL中，以确保链接是最新的：
本节介绍如何配置SpringCloudDataFlow服务器的功能，例如安全性和使用哪个关系数据库。它还描述了如何配置SpringCloudDataFlowshell的功能。
数据流服务器提供了一组特定的功能，您可以在启动时启用或禁用这些功能。这些功能包括所有生命周期操作和REST端点（服务器、客户端实现，包括Shell和UI）：
您可以在启动数据流服务器时通过设置以下布尔属性来启用或禁用这些功能：
默认情况下，所有功能都已启用。
REST端点(/features)提供有关启用和禁用功能的信息。
服务
要绑定到已部署应用程序的服务的名称。
主持人
用作路由一部分的主机名。
由CloudFoundry派生的主机名
领域
为应用程序映射路由时要使用的域。
路线
应用程序应绑定到的路由列表。与主机和域互斥。
构建包
用于部署应用程序的buildpack。不推荐使用构建包。
用于部署应用程序的构建包列表。
记忆
要分配的内存量。默认单位是兆字节，支持“M”和“G”后缀
1024米
磁盘
要分配的磁盘空间量。默认单位是兆字节，支持“M”和“G”后缀。
健康检查
对部署的应用程序执行的健康检查类型。值可以是HTTP、NONE、PROCESS和PORT
港口
健康检查HttpEndpoint
/健康
健康检查超时
运行状况检查的超时值（以秒为单位）。
120
实例
要运行的实例数。
1
enableRandomAppNamePrefix
标记以启用使用随机前缀为应用程序名称添加前缀。
api超时
360
状态超时
5000
使用SpringApplicationJson
标志以指示应用程序属性是馈入SPRING_APPLICATION_JSON还是作为单独的环境变量。
暂存超时
为暂存应用程序分配的超时。
15分钟
启动超时
为启动应用程序分配的超时。
5分钟
应用名称前缀
用作已部署应用程序名称前缀的字符串
spring.application.name使用部署库的应用程序的SpringBoot属性。
删除路由
取消部署应用程序时是否也删除路由。
pushTasksEnabled
是推送任务应用程序还是假设应用程序在启动时已经存在。
autoDeleteMavenArtifacts
部署时是否自动从本地存储库中删除Maven工件。
环境。<键>
以下是一些使用CloudFoundry部署属性的示例：
cfset-envdataflow-serverSPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_BUILDPACKSjava_buildpack_offline您还可以设置环境变量，分别指定基于HTTP的健康检查端点和timeout: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（SpringBoot默认位置）和120秒。
例如，如果要禁用随机化，可以使用以下命令覆盖它：
cfset-envdataflow-serverSPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_ENABLE_RANDOM_APP_NAME_PREFIXfalse11.5。自定义路线作为随机名称的替代方案，或者为了更好地控制已部署应用程序使用的主机名，您可以使用自定义部署属性，如以下示例所示：
从1.2版开始，可以使用DataFlowforCloudFoundry将基于Docker的应用程序注册和部署为流和任务的一部分。
如果你使用SpringBoot和基于RabbitMQ的Docker镜像，你可以提供一个通用的部署属性来方便将应用绑定到RabbitMQ服务。假设您的RabbitMQ服务名为rabbit，您可以提供以下内容：
cfset-envdataflow-serverSPRING_APPLICATION_JSON'{"spring.cloud.dataflow.applicationProperties.stream.spring.rabbitmq.addresses":"${vcap.services.rabbit.credentials.protocols.amqp.uris}"}'对于SpringCloudTask应用程序，如果您使用名为的数据库服务实例，则可以使用类似于以下内容的内容mysql：
cfset-envSPRING_DATASOURCE_URL'${vcap.services.mysql.credentials.jdbcUrl}'cfset-envSPRING_DATASOURCE_USERNAME'${vcap.services.mysql.credentials.username}'cfset-envSPRING_DATASOURCE_PASSWORD'${vcap.services.mysql.credentials.password}'cfset-envSPRING_DATASOURCE_DRIVER_CLASS_NAME'org.mariadb.jdbc.Driver'对于非Java或非Boot应用程序，您的Docker应用程序必须解析VCAP_SERVICES变量才能绑定到任何可用服务。
使用非引导应用程序时，您可能希望通过使用传统环境变量而不是使用特殊SPRING_APPLICATION_JSON变量来传递应用程序属性。为此，请分别为流和任务设置以下变量：
SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_USE_SPRING_APPLICATION_JSON=false11.7。应用程序级服务绑定在CloudFoundry中部署流时，您可以利用特定于应用程序的服务绑定，因此并非所有服务都是为SpringCloudDataFlow编排的所有应用程序全局配置的。
例如，如果您只想为以下流定义中mysql的应用程序提供服务绑定jdbc，则可以将服务绑定作为部署属性传递：
如果您有多个要绑定的服务，它们可以作为逗号分隔的项目传递（例如：deployer.jdbc.cloudfoundry.services=mysqlService,someService）。
cfbind-servicemy-appnfs_service_instance-c'{"uid":"1000","gid":"1000","mount":"/var/volume1","readonly":true}'从2.0版开始，DataFlowforCloudFoundry允许您提供绑定配置参数，这些参数可以在应用程序级别或服务器级别cloudfoundry.services部署属性中提供。例如，要绑定到nfs服务，如上：
dataflow:>streamdeploy--namemystream--properties"deployer.
现在我们回顾一个从UPS提取和提供连接凭证的示例。
以下示例显示了ApacheKafka的示例UPS设置：
cfcreate-user-provided-servicekafkacups-p'{”brokers":"HOST:PORT","zkNodes":"HOST:PORT"}'UPS凭证包含在VCAP_SERVICES中，它们可以直接在流定义中提供，如下例所示。
默认情况下，CloudFoundry中的每个应用程序都以1G磁盘配额开始，并且可以将其调整为默认最大值2G。使用PivotalCloudFoundry(PCF)OpsManagerGUI也可以覆盖默认最大值，最高可达10G。
从PCF的OpsManager中，选择“PivotalElasticRuntime”磁贴并导航到“ApplicationDeveloperControls”选项卡。将“每个应用程序的最大磁盘配额(MB)”设置从2048(2G)更改为10240(10G)。保存磁盘配额更新并单击“应用更改”以完成配置覆盖。
→cfscaledataflow-server-k10GBScalingappdataflow-serverinorgORG/spaceSPACEasuser...OK................statesincecpumemorydiskdetails#0running2016-10-3103:07:23PM1.8%497.9Mof1.1G193.9Mof10G然后，您可以列出应用程序并查看新的最大磁盘空间，如以下示例所示：
SpringCloudDataFlow可以与PivotalSingleSign-OnService（例如，在PWS上）或CloudFoundry用户帐户和身份验证(UAA)服务器集成。
为此，请将PivotalSingleSign-OnService绑定到您的DataFlowServer应用程序并提供以下属性：
由于角色的配置在不同环境中可能会有很大差异，我们默认将所有SpringCloudDataFlow角色分配给用户。
以下示例显示了在上设置自定义AuthoritiesExtractor的一种可能方法UserInfoTokenServices：
@BeanpublicBeanPostProcessormyUserInfoTokenServicesPostProcessor(){BeanPostProcessorpostProcessor==newMyUserInfoTokenServicesPostProcessor();returnpostProcessor;}CloudFoundryUAACloudFoundry用户帐户和身份验证(UAA)的可用性取决于CloudFoundry环境。为了提供UAA集成，您必须提供必要的OAuth2配置属性（例如，通过设置SPRING_APPLICATION_JSON属性）。
以下JSON示例展示了如何创建安全配置：
如果您不使用CloudFoundryUAA，则应设置spring.cloud.dataflow.security.cf-use-uaa为false.
如果经过身份验证的用户被验证为SpaceDeveloper，则分配所有角色。
您必须提供几项配置。这些是SpringBoot@ConfigurationProperties，因此您可以将它们设置为环境变量或通过SpringBoot支持的任何其他方式。以下清单采用环境变量格式，因为这是开始在CloudFoundry中配置引导应用程序的简单方法。请注意，将来您将能够将任务部署到多个平台，但对于2.0.0.M1，您只能部署到单个平台，并且名称必须是default.
部署流时，还可以JAVA_OPTS作为部署属性传递，如以下示例所示：
streamdeploy--nameticktock--properties"deployer.time.cloudfoundry.javaOpts=-Duser.timezone=America/New_York"11.17。调试如果您想更好地了解部署流和任务时发生的情况，您可能需要打开以下功能：
spring.cloud.dataflow.server.cloudfoundry.debugReactor==truelogging.level.cloudfoundry-client==DEBUG11.18。SpringCloud配置服务器您可以使用SpringCloudConfigServer来集中SpringBoot应用程序的配置属性。同样，SpringCloudDataFlow和SpringCloudDataFlow编排的应用程序都可以与配置服务器集成以使用相同的功能。
以下SCDF和Skippermanifest.yml模板包括Skipper和SpringCloudDataFlow服务器所需的环境变量以及部署的应用程序和任务，以便在CloudFoundry上成功运行并my-config-server在运行时自动解析集中属性：
通过将服务分别绑定到SpringCloudDataFlow服务器、SpringCloudTask和通过Skipper到所有SpringCloudStream应用程序，我们现在可以解析由该服务支持的集中属性。
通常，在开发环境中，我们可能没有有效的证书来启用客户端和后端服务之间的SSL通信。但是，PivotalCloudFoundry的配置服务器使用HTTPS进行所有客户端到服务的通信，因此我们需要在没有有效证书的环境中添加自签名SSL证书。
通过使用manifest.yml上一节中列出的用于服务器的相同模板，我们可以通过设置来提供自签名SSL证书TRUST_CERTS:
但是，部署的应用程序还需要TRUST_CERTS一个平面环境变量（而不是被包裹在里面SPRING_APPLICATION_JSON），所以我们必须用另一组令牌（SPRING_CLOUD_DATAFLOW_TASK_PLATFORM_CLOUDFOUNDRY_ACCOUNTS[default]_DEPLOYMENT_USE_SPRING_APPLICATION_JSON:false）来指示服务器执行任务。通过此设置，应用程序将其应用程序属性作为常规环境变量接收。
以下清单显示了manifest.yml所需更改的更新。DataFlow服务器和部署的应用程序都从my-config-serverCloudConfig服务器（部署为CloudFoundry服务）获取配置。
在遵循这些说明之前，请确保在您的CloudFoundry空间中运行PCF-Scheduler服务的实例。要在您的空间中创建PCF调度程序（假设它在您的市场中），请从CFCLI执行以下命令cfcreate-servicescheduler-for-pcfstandard
对于调度，您必须在您的环境中添加（或更新）以下环境变量：
创建上述配置后，您必须创建任何需要调度的任务定义。
以下示例清单显示了已配置的两个环境属性（假设您有一个可用的PCF-Scheduler服务，名称为myscheduler）：
本节介绍如何配置SpringCloudDataFlow特性，例如部署者属性、任务以及使用哪个关系数据库。
数据流服务器提供了一组特定的功能，可以在启动时启用或禁用。这些功能包括所有生命周期操作、REST端点（服务器和客户端实现，包括Shell和UI）：
您可以通过在启动数据流服务器时设置以下布尔环境变量来启用或禁用这些功能：
/featuresREST端点提供有关已启用和禁用的功能的信息。
命名空间
要使用的命名空间
环境变量KUBERNETES_NAMESPACE，否则default
部署.nodeSelector
key:value以格式应用于部署的节点选择器。多个节点选择器以逗号分隔。
imagePullSecret
访问私有注册表以提取图像的秘密。
imagePullPolicy
拉取图像时应用的图像拉取策略。有效选项是Always、IfNotPresent和Never。
如果不存在
livenessProbeDelay
应用程序容器的Kubernetes活性检查应开始检查其健康状态时的延迟（以秒为单位）。
10
livenessProbePeriod
执行应用程序容器的Kubernetes活性检查的周期（以秒为单位）。
60
livenessProbeTimeout
2
livenessProbePath
应用程序容器必须响应以进行活性检查的路径。
livenessProbePort
应用程序容器必须响应以进行活动检查的端口。
就绪探测延迟
应用程序容器的就绪检查应开始检查模块是否完全启动并运行时的延迟（以秒为单位）。
准备调查期
就绪探测超时
应用程序容器在就绪检查期间必须响应其健康状态的超时（以秒为单位）。
就绪探测路径
应用程序容器必须响应以进行就绪检查的路径。
就绪探针端口
应用程序容器必须响应的端口以进行就绪检查。
probeCredentialsSecret
包含访问安全探测端点时要使用的凭据的密钥名称。
限制.内存
内存限制，分配Pod所需的最大值，默认单位是兆字节，支持“M”和“G”后缀
限制.cpu
CPU限制，分配pod所需的最大值
请求.内存
内存请求，保证分配pod所需的值。
请求.cpu
CPU请求，保证分配pod所需的值。
statefulSet.volumeClaimTemplate.storageClassName
有状态集的存储类的名称
statefulSet.volumeClaimTemplate.storage
存储量。默认单位是兆字节，支持“M”和“G”后缀
环境变量
为任何已部署的应用程序容器设置的环境变量列表
入口点样式
用于Docker映像的入口点样式。用于确定如何传入属性。可以是exec,shell和boot
exec
创建负载均衡器
为为每个应用程序创建的服务创建一个“LoadBalancer”。这有助于将外部IP分配给应用程序。
服务注解
为每个应用程序创建的服务设置的服务注释。格式字符串annotation1:value1,annotation2:value2
pod注解
为每个部署创建的pod设置的pod注释。格式字符串annotation1:value1,annotation2:value2
工作注释
为pod或为作业创建的作业设置作业注释。格式字符串annotation1:value1,annotation2:value2
minutesToWaitForLoadBalancer
5
maxTerminatedErrorRestarts
由于错误或资源使用过多而失败的应用程序允许的最大重启次数。
maxCrashLoopBackOffRestarts
CrashLoopBackOff中的应用程序允许的最大重启次数。值为Always,IfNotPresent,Never
IfNotPresent
卷装
以YAML格式表示的卷挂载。例如[{name:'testhostpath',mountPath:'/test/hostPath'},{name:'testpvc',mountPath:'/test/pvc'},{name:'testnfs',mountPath:'/test/nfs'}]
卷
Kubernetes实例支持的卷以YAML格式指定。例如[{name:testhostpath,hostPath:{path:'/test/override/hostPath'}},{name:'testpvc',persistentVolumeClaim:{claimName:'testClaim',readOnly:'true'}},{name:'testnfs',nfs:{server:'10.0.0.1:111',path:'/test/nfs'}}]
主机网络
创建部署
使用“副本集”而不是“复制控制器”创建“部署”。
创建工作
在启动任务时创建一个“作业”而不是仅仅一个“Pod”。
容器命令
使用提供的命令和参数覆盖默认入口点命令。
容器端口
添加其他端口以在容器上公开。
创建节点端口
要使用的显式端口whenNodePort是Service类型。
部署服务帐户名称
应用部署中使用的服务帐户名称。注意：用于应用程序部署的服务帐户名称派生自数据流服务器部署。
部署标签
key:value以格式添加到部署的其他标签。多个标签以逗号分隔。
bootMajor版本
要使用的SpringBoot主要版本。目前仅用于自动配置SpringBoot版本特定的探测路径。有效选项是1或2。
tolerations.key
用于容忍的关键。
容忍度.效果
tolerations.operator
tolerations.tolerationSeconds
容差值
要应用的容差值，与operator选择适当的一起使用effect。
秘密参考
将整个数据内容加载到各个环境变量中的密钥名称。多个秘密可以用逗号分隔。
secretKeyRefs.envVarName
保存秘密数据的环境变量名称
secretKeyRefs.secretName
要访问的秘密名称
secretKeyRefs.dataKey
从中获取秘密数据的密钥名称
configMapRefs
将整个数据内容加载到各个环境变量中的ConfigMap(s)的名称。多个ConfigMap用逗号分隔。
configMapKeyRefs.envVarName
保存ConfigMap数据的环境变量名称
configMapKeyRefs.configMapName
要访问的ConfigMap名称
configMapKeyRefs.dataKey
获取ConfigMap数据的键名
最大并发任务数
此平台实例允许的最大并发任务数。
20
podSecurityContext.runAsUser
运行pod容器进程的数字用户ID
podSecurityContext.fsGroup
运行pod容器进程的数字组ID
亲和力.nodeAffinity
以YAML格式表示的节点亲和性。例如{requiredDuringSchedulingIgnoredDuringExecution:{nodeSelectorTerms:[{matchExpressions:[{key:'kubernetes.io/e2e-az-name',operator:'In',values:['e2e-az1','e2e-az2']}]}]},preferredDuringSchedulingIgnoredDuringExecution:[{weight:1,preference:{matchExpressions:[{key:'another-node-label-key',operator:'In',values:['another-node-label-value']}]}}]}
亲和力.podAffinity
以YAML格式表示的pod亲和性。例如{requiredDuringSchedulingIgnoredDuringExecution:{labelSelector:[{matchExpressions:[{key:'app',operator:'In',values:['store']}]}],topologyKey:'kubernetes.io/hostnam'},preferredDuringSchedulingIgnoredDuringExecution:[{weight:1,podAffinityTerm:{labelSelector:{matchExpressions:[{key:'security',operator:'In',values:['S2']}]},topologyKey:'failure-domain.beta.kubernetes.io/zone'}}]}
亲和力.podAntiAffinity
以YAML格式表示的pod反亲和性。例如{requiredDuringSchedulingIgnoredDuringExecution:{labelSelector:{matchExpressions:[{key:'app',operator:'In',values:['store']}]}],topologyKey:'kubernetes.io/hostname'},preferredDuringSchedulingIgnoredDuringExecution:[{weight:1,podAffinityTerm:{labelSelector:{matchExpressions:[{key:'security',operator:'In',values:['S2']}]},topologyKey:'failure-domain.beta.kubernetes.io/zone'}}]}
statefulSetInitContainerImageName
用于StatefulSetInitContainer的自定义图像名称
初始化容器
一个以YAML格式表示的InitContainer，将应用于pod。例如{containerName:'test',imageName:'busybox:latest',commands:['sh','-c','echohello']}
附加容器
以YAML格式表示的附加容器，以应用于pod。例如[{name:'c1',image:'busybox:latest',command:['sh','-c','echohello1'],volumeMounts:[{name:'test-volume',mountPath:'/tmp',readOnly:true}]},{name:'c2',image:'busybox:1.26.1',command:['sh','-c','echohello2']}]
spring:cloud:dataflow:task:platform:kubernetes:accounts:dev:namespace:devNamespaceimagePullPolicy:AlwaysentryPointStyle:execlimits:cpu:4qa:namespace:qaNamespaceimagePullPolicy:IfNotPresententryPointStyle:bootlimits:memory:2048m通过将一个平台定义为default允许您跳过platformName在其他情况下需要使用它的地方。启动任务时，使用任务启动选项传递平台帐户名称的值--platformName如果不传递的值，将使用platformName该值。default
以下示例显示了一种可能的配置，它启用MySQL并设置内存限制：
apiVersion:v1kind:ConfigMapmetadata:name:scdf-serverlabels:app:scdf-serverdata:application.yaml:|-spring:cloud:dataflow:task:platform:kubernetes:accounts:default:limits:memory:1024Midatasource:url:jdbc:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/mysqlusername:rootpassword:${mysql-root-password}driverClassName:org.mariadb.jdbc.DrivertestOnBorrow:truevalidationQuery:"SELECT1"前面的示例假设MySQL被部署mysql为服务名称。Kubernetes将这些服务的主机和端口值发布为环境变量，我们可以在配置我们部署的应用程序时使用它们。
我们更喜欢在Secrets文件中提供MySQL连接密码，如以下示例所示：
apiVersion:v1kind:Secretmetadata:name:mysqllabels:app:mysqldata:mysql-root-password:eW91cnBhc3N3b3Jk密码是base64编码的值。
SpringCloudDataFlow为H2、HSQLDB、MySQL、Oracle、PostgreSQL、DB2和SQLServer提供模式。如果正确的数据库驱动程序和适当的凭据位于类路径中，则会在服务器启动时自动创建适当的模式。
MySQL的JDBC驱动程序（通过MariaDB驱动程序）、HSQLDB、PostgreSQL和嵌入式H2都是开箱即用的。如果您使用任何其他数据库，则需要将相应的JDBC驱动程序jar放在服务器的类路径中。
例如，如果您使用MySQL和secrets文件中的密码，您可以在ConfigMap中提供以下属性：
data:application.yaml:|-spring:datasource:url:jdbc:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/mysqlusername:rootpassword:${mysql-root-password}driverClassName:org.mariadb.jdbc.Driverurl:jdbc:mysql://${MYSQL_SERVICE_HOST}:${MYSQL_SERVICE_PORT}/testdriverClassName:org.mariadb.jdbc.Driver对于PostgreSQL，您可以使用以下配置：
data:application.yaml:|-spring:datasource:url:jdbc:postgresql://${PGSQL_SERVICE_HOST}:${PGSQL_SERVICE_PORT}/databaseusername:rootpassword:${postgres-password}driverClassName:org.postgresql.Driver对于HSQLDB，您可以使用以下配置：
data:application.yaml:|-spring:datasource:url:jdbc:hsqldb:hsql://${HSQLDB_SERVICE_HOST}:${HSQLDB_SERVICE_PORT}/databaseusername:sadriverClassName:org.hsqldb.jdbc.JDBCDriver以下来自Deployment的YAML片段是安装ConfigMap的示例，application.yaml在/configSpringBoot将处理它的位置加上Secret安装在其中，由于环境变量设置为/etc/secrets，它将被spring-cloud-kubernetes库拾取。SPRING_CLOUD_KUBERNETES_SECRETS_PATHS/etc/secrets
我们建议使用该kubectl命令对流和任务进行故障排除。
您可以使用以下命令列出所有使用的工件和资源：
kubectlgetall,cm,secrets,pvc您可以通过使用标签选择资源来列出特定应用程序或服务使用的所有资源。以下命令列出了mysql服务使用的所有资源：
kubectlgetall-lapp=mysql您可以通过发出以下命令来获取特定pod的日志：
kubectllogspod
kubectllogs-f
kubectldescribepodticktock-log-0-qnk7212.6.1.检查服务器日志您可以使用以下命令访问服务器日志：
kubectlgetpod-lapp=scdf=serverkubectllogs
要查看SpringCloudDataFlow服务器部署的所有Pod，可以指定role=spring-app标签，如下所示：
kubectlgetpod-lrole=spring-app要查看特定应用程序部署的详细信息，您可以使用以下命令：
kubectldescribepod
kubectllogs
kubectllogs-f
要查看特定任务的所有pod，请使用以下命令：
kubectlgetpod-ltask-name=
kubectllogs
要手动删除任务pod，请使用以下命令：
kubectldeletepod
dataflow:>taskexecutionlist╔═════════╤══╤════════════════════════════╤════════════════════════════╤═════════╗║TaskName│ID│StartTime│EndTime│ExitCode║╠═════════╪══╪════════════════════════════╪════════════════════════════╪═════════╣║task1│1│FriMay0518:12:05EDT2017│FriMay0518:12:05EDT2017│0║╚═════════╧══╧════════════════════════════╧════════════════════════════╧═════════╝获得ID后，您可以发出命令来清理执行工件（已完成的pod），如以下示例所示：
dataflow:>taskexecutioncleanup--id1Requesttocleanupresourcesfortaskexecution1hasbeensubmitted任务的数据库凭证默认情况下，SpringCloudDataFlow在任务启动时将数据库凭据作为属性传递给pod。如果使用exec或shell入口点样式，如果用户kubectldescribe在任务的pod上执行操作，则可以查看数据库凭据。要将SpringCloudDataFlow配置为使用KubernetesSecrets：将spring.cloud.dataflow.task.use.kubernetes.secrets.for.db.credentials属性设置为true.如果使用SpringCloudDataFlow提供的yaml文件，请更新`src/kubernetes/server/server-deployment.yaml以添加以下环境变量：
-name:SPRING_CLOUD_DATAFLOW_TASK_USE_KUBERNETES_SECRETS_FOR_DB_CREDENTIALSvalue:'true'如果从以前版本的SCDF升级，请务必验证server-config.yaml中spring.datasource.username是否spring.datasource.password存在环境变量。secretKeyRefs如果没有，请按照以下示例添加它：
本节介绍如何配置计划任务的自定义。SpringCloudDataFlowKubernetesServer中默认启用任务调度。属性用于影响计划任务的设置，并且可以在全局或每个计划的基础上进行配置。
入口点样式会影响应用程序属性如何传递到要部署的任务容器。目前支持三种样式：
您可以按如下方式配置入口点样式：
deployer.kubernetes.entryPointStyle=
您还可以在env部署YAML的容器部分中的服务器级别配置入口点样式，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_ENTRY_POINT_STYLEvalue:entryPointStyle替换entryPointStyle为所需的入口点样式。
使用boot入口点样式对应于使用exec样式ENTRYPOINT。来自部署请求的命令行参数被传递给容器，并添加了映射到SPRING_APPLICATION_JSON环境变量中的应用程序属性，而不是命令行参数。
要影响给定应用程序的环境设置，您可以利用该spring.cloud.deployer.kubernetes.environmentVariables属性。例如，生产设置中的一个常见要求是影响JVM内存参数。您可以通过使用JAVA_TOOL_OPTIONS环境变量来实现这一点，如以下示例所示：
deployer.kubernetes.environmentVariables=JAVA_TOOL_OPTIONS=-Xmx1024m在部署流应用程序或启动某些属性可能包含敏感信息的任务应用程序时，使用shell或boot作为entryPointStyle.这是因为exec（默认）将所有属性转换为命令行参数，因此在某些环境中可能不安全。此外，您可以在部署YAML的容器部分中的服务器级别配置环境变量env，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_ENVIRONMENT_VARIABLESvalue:myVar=myVal替换myVar=myVal为您想要的环境变量。
以下示例显示了如何单独配置容器：
deployer.kubernetes.imagePullPolicy=Always替换Always为您想要的图像拉取策略。
env您可以在部署YAML的容器部分中在服务器级别配置图像拉取策略，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_POLICYvalue:Always替换Always为您想要的图像拉取策略。
创建密钥后，使用该imagePullSecret属性设置要使用的密钥，如以下示例所示：
deployer.kubernetes.imagePullSecret=mysecret替换mysecret为您之前创建的密钥的名称。
您还可以在env部署YAML的容器部分中的服务器级别配置图像拉取密钥，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_IMAGE_PULL_SECRETvalue:mysecret替换mysecret为您之前创建的密钥的名称。
默认情况下，用于计划任务的命名空间是default.该值可以在env部署YAML的容器部分的服务器级别配置中设置，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_NAMESPACEvalue:mynamespace12.7.6。服务帐号您可以通过属性为计划任务配置自定义服务帐户。可以使用现有服务帐户或创建新服务帐户。创建服务帐户的一种方法是使用kubectl，如以下示例所示：
$kubectlcreateserviceaccountmyserviceaccountnameserviceaccount"myserviceaccountname"created然后，您可以将服务帐户配置为按计划使用，如下所示：
deployer.kubernetes.taskServiceAccountName=myserviceaccountname替换myserviceaccountname为您的服务帐户名称。
您还可以在env部署YAML的容器部分中的服务器级别配置服务帐户名称，如以下示例所示：
env:-name:SPRING_CLOUD_SCHEDULER_KUBERNETES_TASK_SERVICE_ACCOUNT_NAMEvalue:myserviceaccountname替换myserviceaccountname为要应用于所有部署的服务帐户名称。
spec:...template:...spec:containers:-name:scdf-server...ports:...-containerPort:5005env:-name:JAVA_TOOL_OPTIONSvalue:'-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005'前面的示例使用端口5005，但它可以是不与另一个端口冲突的任何数字。containerPort所选择的端口号对于添加的值和标志的address参数也必须相同JAVA_TOOL_OPTIONS-agentlib，如前面的示例所示。您现在可以启动SpringCloudDataFlowKubernetesServer。服务器启动后，您可以验证scdf-server部署上的配置更改，如以下示例（带有输出）所示：
$kubectlgetpod-lapp=scdf-serverNAMEREADYSTATUSRESTARTSAGEscdf-server-5b7cfd86f7-d8mj41/1Running010m$kubectlport-forwardscdf-server-5b7cfd86f7-d8mj45005:5005Forwardingfrom127.0.0.1:5005->5005Forwardingfrom[::1]:5005->5005您现在可以通过将调试器指向127.0.0.1主机和5005端口来附加调试器。子命令一直运行直到停止（例如，port-forward通过按CTRL+c）。
您可以通过将更改还原为src/kubernetes/server/server-deployment.yaml.恢复的更改将在SpringCloudDataFlowKubernetes服务器的下一次部署中获取。当每次部署服务器时都应默认启用调试时，手动向配置添加调试支持很有用。
与其手动更改server-deployment.yamlKubernetes对象，不如就地“打补丁”。为方便起见，包含提供与手动方法相同配置的补丁文件。要通过修补启用调试，请使用以下命令：
kubectlpatchdeploymentscdf-server-p"$(catsrc/kubernetes/server/server-deployment-debug.yaml)"运行上述命令会自动添加containerPort属性和JAVA_TOOL_OPTIONS环境变量。以下示例（带有输出）显示了如何验证对scdf-server部署的更改：
$kubectldescribedeployment/scdf-server......PodTemplate:...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-serverKubernetes服务对象。您必须首先确保scdf-serverKubernetes服务对象具有正确的配置。以下示例（带输出）显示了如何执行此操作：
kubectldescribeservice/scdf-serverPort:
$kubectlpatchservicescdf-server-p"$(catsrc/kubernetes/server/server-svc.yaml)"只有在添加调试功能之前已创建目标集群时，才应缺少端口名称。由于向scdf-serverKubernetes服务对象添加了多个端口，因此每个端口都需要有自己的名称。现在您可以添加调试端口，如以下示例所示：
kubectlpatchservicescdf-server-p"$(catsrc/kubernetes/server/server-svc-debug.yaml)"以下示例（带输出）显示了如何验证映射：
$kubectldescribeservicescdf-serverName:scdf-server......Port:scdf-server-jdwp5005/TCPTargetPort:5005/TCPNodePort:scdf-server-jdwp31339/TCP......Port:scdf-server80/TCPTargetPort:80/TCPNodePort:scdf-server30883/TCP......输出显示容器端口5005已映射到31339的NodePort。以下示例（带输出）显示了如何获取Minikube节点的IP地址：
$minikubeip192.168.99.100使用此信息，您可以使用主机192.168.99.100和端口31339创建调试连接。
以下示例显示了如何禁用JDWP：
$kubectlrolloutundodeployment/scdf-server$kubectlpatchservicescdf-server--typejson-p='[{"op":"remove","path":"/spec/ports/0"}]'Kubernetes部署对象会回滚到修补之前的状态。然后使用从列表remove中删除端口5005的操作修补Kubernetes服务对象。containerPorts
--spring.shell.commandFile=file1.txt,file2.txt
此选项在创建一些脚本以帮助自动部署时很有用。
此外，以下shell命令有助于将复杂脚本模块化为多个独立文件：
dataflow:>script--file
在命令提示符下键入help会列出所有可用命令。大多数命令用于数据流功能，但少数是通用命令。以下清单显示了help命令的输出：
dataflow:>streamcreate--streamcreate--definitionstreamcreate--name如果您键入--de然后按Tab，则会--definition展开。
Tab补全也可在流或组合任务DSL表达式中用于应用程序或任务属性。您还可以使用TAB在流DSL表达式中获取您可以使用的可用源、处理器或接收器的提示。
仅当参数值包含空格或|字符时，才需要引用它们。以下示例将SpEL表达式（应用于它遇到的任何数据）传递给转换处理器：
transform--expression='newStringBuilder(payload).reverse()'如果参数值需要嵌入单引号，使用两个单引号，如下：
//Queryis:Select*from/Customerswherename='Smith'scan--query='Select*from/Customerswherename=''Smith'''16.1.报价和转义有一个基于SpringShell的客户端与数据流服务器对话并负责解析DSL。反过来，应用程序可能具有依赖于嵌入式语言的应用程序属性，例如Spring表达式语言。
Shell、DataFlowDSL解析器和SpEL对它们如何处理引号以及语法转义如何工作都有规则。当组合在一起时，可能会出现混乱。本节解释了适用的规则，并提供了涉及所有三个组件时可能遇到的最复杂情况的示例。
如果您不使用DataFlowShell（例如，如果您直接使用RESTAPI）或者如果应用程序属性不是SpEL表达式，则转义规则会更简单。
可以说，当涉及到引号时，最复杂的组件是Shell。不过，规则可以很简单地列出：
例如，shell支持!执行本机shell命令的命令。!接受单个无键参数。这就是以下示例有效的原因：
dataflow:>!rmsomething这里的参数是整个rmsomething字符串，它按原样传递给底层shell。
再举一个例子，以下命令是严格等价的，参数值为something（不带引号）：
dataflow:>streamdestroysomethingdataflow:>streamdestroy--namesomethingdataflow:>streamdestroy"something"dataflow:>streamdestroy--name"something"16.1.2.属性文件规则从文件加载属性时，规则会放宽。
在解析器级别（即在流或任务定义的主体内部），规则如下：
因此，--expression过滤器应用程序的选项值在以下示例中在语义上是等效的：
filter--expression=payload>5filter--expression="payload>5"filter--expression='payload>5'filter--expression='payload>5'可以说，最后一个更具可读性。由于周围的报价，这成为可能。实际的表达是payload>5。
现在，假设我们要针对字符串消息进行测试。如果我们想将有效负载与SpEL文字字符串进行比较"something"，我们可以使用以下内容：
filter--expression=payload=='something'(1)filter--expression='payload==''something'''(2)filter--expression='payload=="something"'(3)1这是有效的，因为没有空格。但是，它不是很清晰。2这使用单引号来保护整个论点。因此，实际的单引号需要加倍。3SpEL可以识别带有单引号或双引号的字符串文字，因此最后一种方法可以说是最易读的。请注意，前面的示例要在shell之外考虑（例如，当直接调用RESTAPI时）。当在shell中输入时，很可能整个流定义本身就在双引号内，这需要被转义。整个例子就变成了下面这样：
重要的是要理解以下语句是等效的：
transform--expression=payloadtransform--expression='payload'但是，它们不同于以下（以及它们的变体）：
transform--expression="'payload'"transform--expression='''payload'''第一个系列评估为消息有效负载，而后面的示例评估为文字字符串payload.
作为最后一个完整的示例，考虑如何helloworld通过在DataFlowshell的上下文中创建流来强制将所有消息转换为字符串文字:
Stream的一般生命周期是：
此外，您可以配置Skipper以将应用程序部署到一个或多个CloudFoundry组织和空间、Kubernetes集群上的一个或多个命名空间或本地计算机。在DataFlow中部署流时，您可以指定在部署时使用哪个平台。Skipper还为DataFlow提供了对已部署的流执行更新的能力。可以通过多种方式更新流中的应用程序，但最常见的示例之一是使用新的自定义业务逻辑升级处理器应用程序，同时保留现有的源和接收器应用程序。
作为一个简单的示例，考虑从HTTP源收集数据并写入文件接收器。使用DSL，流描述为：
涉及某些处理的流将表示为：
可以使用shell的streamcreate命令创建流定义，如下例所示：
StreamDSL被传递给--definition命令选项。
流定义的部署是通过Shell的streamdeploy命令完成的，如下：
dataflow:>streamdeploy--nameticktock
考虑下面的Java接口，它定义了一个输入方法和两个输出方法：
publicinterfaceBarista{@InputSubscribableChannelorders();@OutputMessageChannelhotDrinks();@OutputMessageChannelcoldDrinks();}进一步考虑以下Java接口，它是创建KafkaStreams应用程序的典型接口：
interfaceKStreamKTableBinding{@InputKStream<,>inputStream();@InputKTable<,>inputTable();}在这些具有多个输入和输出绑定的情况下，数据流无法对从一个应用程序到另一个应用程序的数据流做出任何假设。因此，您需要设置绑定属性以“连接”应用程序。StreamApplicationDSL使用“双管道”而不是“管道符号”来指示数据流不应配置应用程序的绑定属性。认为||是“并行”的意思。以下示例显示了这样一个“并行”定义：
dataflow:>streamcreate--definition"orderGeneratorApp||baristaApp||hotDrinkDeliveryApp||coldDrinkDeliveryApp"--namemyCafeStream颠覆性变化！SCDFLocal、CloudFoundry1.7.0到1.7.2和SCDFKubernetes1.7.0到1.7.1的版本使用comma字符作为应用程序之间的分隔符。这导致了传统StreamDSL的重大变化。虽然并不理想，但人们认为更改分隔符是对现有用户影响最小的最佳解决方案。此流有四个应用程序。baristaApp有两个输出目的地hotDrinks和，分别coldDrinks由hotDrinkDeliveryApp和使用coldDrinkDeliveryApp。部署此流时，您需要设置绑定属性，以便baristaApp将热饮消息发送到hotDrinkDeliveryApp目的地，将冷饮消息发送到coldDrinkDeliveryApp目的地。下面的清单就是这样做的：
app.baristaApp.spring.cloud.stream.bindings.hotDrinks.destination=hotDrinksDestapp.baristaApp.spring.cloud.stream.bindings.coldDrinks.destination=coldDrinksDestapp.hotDrinkDeliveryApp.spring.cloud.stream.bindings.input.destination=hotDrinksDestapp.coldDrinkDeliveryApp.spring.cloud.stream.bindings.input.destination=coldDrinksDest如果要使用消费者组，则需要分别在生产者和消费者应用程序上设置SpringCloudStream应用程序属性，spring.cloud.stream.bindings.
StreamApplicationDSL的另一个常见用例是部署一个HTTP网关应用程序，该应用程序向Kafka或RabbitMQ应用程序发送同步请求或回复消息。在这种情况下，HTTP网关应用程序和Kafka或RabbitMQ应用程序都可以是不使用SpringCloudStream库的SpringIntegration应用程序。
也可以使用Stream应用程序DSL仅部署单个应用程序。
shell为应用程序属性提供选项卡补全。appinfo--name
流的生命周期经历以下阶段：
Skipper中的应用程序捆绑为包含应用程序资源位置、应用程序属性和部署属性的包。您可以将Skipper包视为类似于工具中的包，例如apt-get或brew.
当DataFlow部署Stream时，它会生成一个包并将其上传到Skipper，该包代表Stream中的应用程序。用于升级或回滚Stream中的应用程序的后续命令将传递给Skipper。另外，Stream定义是从包逆向工程的，Stream的状态也委托给Skipper。
您可以使用该appregister命令注册版本化流应用程序。您必须提供唯一名称、应用程序类型和可解析为应用程序工件的URI。对于类型，请指定source、processor或sink。版本是从URI解析的。这里有一些例子：
您可以注册相同应用程序的多个版本（例如，相同的名称和类型），但您只能将一个版本设置为默认值。默认版本用于部署Streams。
首次注册应用程序时，将其标记为默认值。可以使用以下appdefault命令更改默认应用程序版本：
dataflow:>appdefault--idsource:mysource--version0.0.2dataflow:>applist--idsource:mysource╔═══╤══════════════════╤═════════╤════╤════╗║app│source│processor│sink│task║╠═══╪══════════════════╪═════════╪════╪════╣║│mysource-0.0.1│││║║│>mysource-0.0.2<│││║║│mysource-0.0.3│││║╚═══╧══════════════════╧═════════╧════╧════╝该applist--id
该appunregister命令有一个可选--version参数来指定要注销的应用程序版本：
dataflow:>appunregister--namemysource--typesource--version0.0.1dataflow:>applist--idsource:mysource╔═══╤══════════════════╤═════════╤════╤════╗║app│source│processor│sink│task║╠═══╪══════════════════╪═════════╪════╪════╣║│>mysource-0.0.2<│││║║│mysource-0.0.3│││║╚═══╧══════════════════╧═════════╧════╧════╝如果--version未指定，则默认版本未注册。
流中的所有应用程序都应为要部署的流设置默认版本。否则，在部署期间它们将被视为未注册的应用程序。使用appdefault命令设置默认值。
appdefault--idsource:mysource--version0.0.3dataflow:>applist--idsource:mysource╔═══╤══════════════════╤═════════╤════╤════╗║app│source│processor│sink│task║╠═══╪══════════════════╪═════════╪════╪════╣║│mysource-0.0.2│││║║│>mysource-0.0.3<│││║╚═══╧══════════════════╧═════════╧════╧════╝这streamdeploy需要设置默认应用程序版本。但是，streamupdateandstreamrollback命令可以使用所有（默认和非默认）注册的应用程序版本。
以下命令创建一个使用默认mysource版本(0.0.3)的流：
dataflow:>streamcreatefoo--definition"mysource|log"然后我们可以将版本更新到0.0.2：
dataflow:>streamupdatefoo--propertiesversion.mysource=0.0.2只有预先注册的应用程序才能用于deploy、update或rollbackStream。尝试更新mysource版本0.0.1（未注册）失败。
为方便起见，我们为所有开箱即用的流和任务或批处理应用程序启动器提供了带有应用程序URI（适用于Maven和Docker）的静态文件。您可以指向此文件并批量导入所有应用程序URI。否则，如前所述，您可以单独注册它们或拥有自己的自定义属性文件，其中仅包含所需的应用程序URI。但是，我们建议在自定义属性文件中包含所需应用程序URI的“集中”列表。
下表包含dataflow.spring.io基于SpringCloudStream2.1.x和SpringBoot2.1.x的可用StreamApplicationStarter的链接：
RabbitMQ+Maven
RabbitMQ+Docker
阿帕奇卡夫卡+Maven
阿帕奇卡夫卡+码头工人
下表包括基于SpringCloudTask2.1.x和SpringBoot2.1.x的可用任务应用程序启动器：
Maven
码头工人
例如，如果您想批量注册使用Kafkabinder构建的所有开箱即用的流应用程序，可以使用以下命令：
当您使用appregisterorappimport时，如果应用程序已使用提供的名称、类型和版本注册，则默认情况下不会被覆盖。如果您想覆盖预先存在的应用程序uri或metadata-uri坐标，请包含该--force选项。
但是请注意，一旦下载，应用程序可能会根据资源位置在数据流服务器上本地缓存。如果资源位置没有改变（即使实际的资源字节可能不同），也不会重新下载。maven://另一方面，在使用资源时，使用恒定位置可能仍会绕过缓存（如果使用-SNAPSHOT版本）。
此外，如果流已经部署并使用某个版本的注册应用程序，那么（强制）重新注册不同的应用程序在再次部署流之前无效。
为了支持允许属性，在SpringCloudDataFlow中运行的SpringCloudStream应用程序可以包含SpringBootconfiguration-processor作为可选依赖项，如下例所示：
新流是在流定义的帮助下创建的。这些定义是从一个简单的DSL构建的。例如，考虑如果我们运行以下shell命令会发生什么：
dataflow:>streamcreate--definition"time|log"--nameticktockticktock这定义了一个基于DSL表达式命名的流time|log。DSL使用“管道”符号(|)将源连接到接收器。
该streaminfo命令显示有关流的有用信息，如以下示例中所示（及其输出）：
dataflow:>streaminfoticktock╔═══════════╤═════════════════╤══════════╗║StreamName│StreamDefinition│Status║╠═══════════╪═════════════════╪══════════╣║ticktock│time|log│undeployed║╚═══════════╧═════════════════╧══════════╝18.2.1.流应用程序属性应用程序属性是与流中的每个应用程序关联的属性。部署应用程序时，应用程序属性通过命令行参数或环境变量应用于应用程序，具体取决于底层部署实现。
以下流可以在创建流时定义应用程序属性：
以下清单显示了time应用程序的公开属性：
dataflow:>streamcreate--definition"time--fixed-delay=5|log--level=WARN"--nameticktock请注意，在前面的示例中，为and应用程序定义的fixed-delayand属性是shell完成提供的“短格式”属性名称。这些“短格式”属性名称仅适用于公开的属性。在所有其他情况下，您应该只使用完全限定的属性名称。leveltimelog
除了通过DSL进行配置之外，SpringCloudDataFlow还提供了一种机制，可以为它启动的所有流式应用程序设置公共属性。这可以通过spring.cloud.dataflow.applicationProperties.stream在启动服务器时添加前缀为的属性来完成。这样做时，服务器会将所有属性（不带前缀）传递给它启动的实例。
例如，通过使用以下选项启动DataFlow服务器，可以将所有启动的应用程序配置为使用特定的Kafka代理：
--spring.cloud.dataflow.applicationProperties.stream.spring.cloud.stream.kafka.binder.brokers=192.168.1.100:9092--spring.cloud.dataflow.applicationProperties.stream.spring.cloud.stream.kafka.binder.zkNodes=192.168.1.100:2181这样做会导致spring.cloud.stream.kafka.binder.brokers和spring.cloud.stream.kafka.binder.zkNodes属性传递给所有启动的应用程序。
本节介绍在SpringCloudDataFlow服务器负责部署流时如何部署流。它涵盖了使用Skipper服务部署和升级Streams。如何设置部署属性的描述适用于Stream部署的两种方法。
考虑ticktock流定义：
dataflow:>streamcreate--definition"time|log"--nameticktock要部署流，请使用以下shell命令：
dataflow:>streamdeploy--nameticktocktime数据流服务器将应用程序的解析和部署委托给Skipperlog。
该streaminfo命令显示有关流的有用信息，包括部署属性：
$tail-f/var/folders/wn/8jxm_tbd1vj28c8vj37n900m0000gn/T/spring-cloud-dataflow-912434582726479179/ticktock-1464788481708/ticktock.log/stdout_0.log2016-06-0109:45:11.250INFO79194---[kafka-binder-]log.sink:06/01/1609:45:112016-06-0109:45:12.250INFO79194---[kafka-binder-]log.sink:06/01/1609:45:122016-06-0109:45:13.251INFO79194---[kafka-binder-]log.sink:06/01/1609:45:13您还可以通过在创建流时传递标志来一步创建和部署--deploy流，如下所示：
dataflow:>streamcreate--definition"time|log"--nameticktock--deploy但是，在实际用例中，一步创建和部署流并不常见。原因是当你使用streamdeploy命令时，你可以传入定义如何将应用程序映射到平台上的属性（例如，要使用的容器的内存大小是多少，每个应用程序要运行的数量，以及是否启用数据分区功能）。属性还可以覆盖创建流时设置的应用程序属性。下一节将详细介绍此功能。
您可以通过从shell发出streamdestroy命令来删除流，如下所示：
dataflow:>streamdestroy--nameticktock如果流已部署，则在删除流定义之前取消部署。
通常，您希望停止流但保留名称和定义以供将来使用。在这种情况下，您可以undeploy按名称流：
dataflow:>streamundeploy--nameticktockdataflow:>streamdeploy--nameticktock您可以deploy稍后发出命令以重新启动它：
dataflow:>streamdeploy--nameticktock18.6。验证流有时，流定义中包含的应用程序在其注册中包含无效的URI。这可能是由于在应用程序注册时输入了无效的URI，或者应用程序从要从中提取它的存储库中删除。要验证流中包含的所有应用程序是否可解析，用户可以使用以下validate命令：
dataflow:>streamvalidateticktock╔═══════════╤═════════════════╗║StreamName│StreamDefinition║╠═══════════╪═════════════════╣║ticktock│time|log║╚═══════════╧═════════════════╝ticktockisavalidstream.╔═══════════╤═════════════════╗║AppName│ValidationStatus║╠═══════════╪═════════════════╣║source:time│valid║║sink:log│valid║╚═══════════╧═════════════════╝在前面的示例中，用户验证了他们的ticktock流。source:time和都sink:log有效。现在我们可以看到如果我们有一个带有无效URI的注册应用程序的流定义会发生什么：
dataflow:>appregister--namelog--typesink--urimaven://org.springframework.cloud.stream.app:log-sink-rabbit:1.2.0.RELEASESuccessfullyregisteredapplication'sink:log'然后我们可以更新应用程序：
Skipper保留已部署的流的历史记录。更新流后，有第二个版本的流。streamhistory--name
streammanifest--name
以下示例显示了清单的使用：
streamrollback您可以使用以下命令回滚到流的先前版本：
Skipper有一个简单的“红/黑”升级策略。它使用与当前运行版本一样多的实例部署新版本的应用程序，并检查/health应用程序的端点。如果新应用程序的运行状况良好，则取消部署之前的应用程序。如果新应用程序的健康状况不佳，则取消部署所有新应用程序，并认为升级不成功。
升级策略不是滚动升级，因此，如果应用程序的五个实例正在运行，那么在晴天场景中，在取消部署旧版本之前，还有五个新应用程序也在运行。
在某些情况下，当需要连接到不同的消息中间件配置时，流可以将其应用程序绑定到多个SpringCloud流绑定器。在这些情况下，您应该确保应用程序使用它们的活页夹配置进行了适当的配置。例如，支持Kafka和Rabbit绑定器的多绑定器转换器是以下流中的处理器：
这里，rabbit1和kafka1是SpringCloudStream应用程序属性中给出的绑定器名称。基于此设置，应用程序在其类路径中具有以下具有适当配置的绑定器：
spring-cloud-streambinder可以在应用程序本身内设置配置属性。如果没有，它们可以在deployment部署流时通过属性传递：
本章包括以下示例：
作为一个简单处理步骤的示例，我们可以使用以下流定义将HTTP发布数据的负载转换为大写：
2016-06-0109:54:37.749INFO80083---[kafka-binder-]log.sink:HELLO24.2.有状态的流处理为了演示数据分区功能，以下清单部署了一个使用Kafka作为绑定器的流：
2016-06-0518:35:47.047INFO58638---[kafka-binder-]log.sink:How2016-06-0518:35:47.066INFO58638---[kafka-binder-]log.sink:chuck2016-06-0518:35:47.066INFO58638---[kafka-binder-]log.sink:chuck查看words.log-v1-1日志时，您应该看到以下内容：
2016-06-0518:35:47.047INFO58639---[kafka-binder-]log.sink:much2016-06-0518:35:47.066INFO58639---[kafka-binder-]log.sink:wood2016-06-0518:35:47.066INFO58639---[kafka-binder-]log.sink:would2016-06-0518:35:47.066INFO58639---[kafka-binder-]log.sink:a2016-06-0518:35:47.066INFO58639---[kafka-binder-]log.sink:woodchuck2016-06-0518:35:47.067INFO58639---[kafka-binder-]log.sink:if2016-06-0518:35:47.067INFO58639---[kafka-binder-]log.sink:a2016-06-0518:35:47.067INFO58639---[kafka-binder-]log.sink:woodchuck2016-06-0518:35:47.067INFO58639---[kafka-binder-]log.sink:could2016-06-0518:35:47.067INFO58639---[kafka-binder-]log.sink:wood此示例表明，包含相同单词的有效负载拆分被路由到相同的应用程序实例。
2016-06-0109:50:22.121INFO79654---[kafka-binder-]log.sink:hello2016-06-0109:50:26.810INFO79654---[kafka-binder-]log.sink:goodbye我们还可以更改接收器的实现。您可以将输出通过管道传输到文件(file)、hadoop(hdfs)或任何其他可用的接收器应用程序。您还可以定义自己的应用程序。
任务应用程序是短暂的，这意味着它会故意停止运行，并且可以按需运行或安排在以后运行。一个用例可能是抓取网页并写入数据库。
在深入了解创建任务的细节之前，您应该了解SpringCloudDataFlow上下文中任务的典型生命周期：
您可以使用SpringCloudDataFlowShellappregister命令向AppRegistry注册Task应用程序。您必须提供一个唯一的名称和一个可以解析为应用程序工件的URI。对于类型，请指定task。以下清单显示了三个示例：
maven://
task.cat=file:///tmp/cat-1.2.1.BUILD-SNAPSHOT.jartask.hat=file:///tmp/hat-1.2.1.BUILD-SNAPSHOT.jar然后您可以使用该appimport命令并使用选项提供属性文件的位置--uri，如下所示：
appimport--urifile:///tmp/task-apps.properties例如，如果您想在单个操作中注册所有随DataFlow一起提供的任务应用程序，您可以使用以下命令来完成：
使用appregister或appimport时，如果任务应用程序已使用提供的名称和版本注册，则默认情况下不会覆盖它。如果您想用不同的uri或uri-metadata位置覆盖预先存在的任务应用程序，请包含该--force选项。
您可以通过提供定义名称以及适用于任务执行的属性，从任务应用程序创建任务定义。您可以通过RESTfulAPI或shell创建任务定义。要使用shell创建任务定义，请使用taskcreate命令创建任务定义，如下例所示：
dataflow:>taskcreatemytask--definition"timestamp--format=\"yyyy\""Creatednewtask'mytask'您可以通过RESTfulAPI或shell获取当前任务定义的列表。要使用shell获取任务定义列表，请使用tasklist命令。
任务定义名称的最大字符长度取决于平台。
63
52
255
从2.3.0版开始，您可以将数据流服务器配置为自动创建任务定义，方法是设置spring.cloud.dataflow.task.autocreate-task-definitions为true.这不是默认行为，而是为了方便而提供的。启用此属性后，任务启动请求可以将注册的任务应用程序名称指定为任务名称。如果任务应用程序已注册，则服务器会根据需要创建一个仅指定应用程序名称的基本任务定义。这消除了类似于以下的手动步骤：
dataflow:>taskcreatemytask--definition"mytask"您仍然可以为每个任务启动请求指定命令行参数和部署属性。
可以通过RESTfulAPI或shell启动临时任务。要通过shell启动临时任务，请使用tasklaunch命令，如以下示例所示：
dataflow:>tasklaunchmytaskLaunchedtask'mytask'启动任务时，您可以设置任何需要在启动任务时作为命令行参数传递给任务应用程序的属性，如下所示：
dataflow:>tasklaunchmytask--arguments"--server.port=8080--custom=value"参数需要作为空格分隔的值传递。您可以通过使用该选项传递用于aTaskLauncher本身的其他属性。--properties此选项的格式是以逗号分隔的属性字符串，前缀为app.
dataflow:>tasklaunchmytask--properties"deployer.timestamp.custom1=value1,app.timestamp.custom2=value2"26.4.1.应用程序属性每个应用程序都使用属性来自定义其行为。例如，timestamp任务format设置建立了不同于默认值的输出格式。
shell为应用程序属性提供选项卡补全。appinfo--name
在启动某些属性可能包含敏感信息的任务应用程序时，使用shell或boot作为entryPointStyle.这是因为exec（默认）将所有属性转换为命令行参数，因此在某些环境中可能不安全。
除了通过DSL进行配置之外，SpringCloudDataFlow还提供了一种机制来设置由它启动的所有任务应用程序共有的属性。您可以通过spring.cloud.dataflow.applicationProperties.task在启动服务器时添加前缀为的属性来做到这一点。然后，服务器将所有属性（不带前缀）传递给它启动的实例。
例如，您可以通过使用以下选项启动数据流服务器来配置所有已启动的应用程序以使用prop1和属性：prop2
--spring.cloud.dataflow.applicationProperties.task.prop1=value1--spring.cloud.dataflow.applicationProperties.task.prop2=value2这会导致prop1=value1和prop2=value2属性传递给所有启动的应用程序。
SpringCloudDataFlow允许用户限制每个已配置平台的最大并发运行任务数，以防止IaaS或硬件资源饱和。默认情况下，20所有受支持平台的限制都设置为。如果平台实例上同时运行的任务数大于或等于限制，则下一个任务启动请求失败，并通过RESTfulAPI、Shell或UI返回错误信息。您可以通过设置相应的部署者属性为平台实例配置此限制spring.cloud.dataflow.task.platform.
如果可能，每个受支持平台的TaskLauncher实现通过查询底层平台的运行时状态来确定当前正在运行的任务的数量。识别方法task因平台而异。例如，在本地主机上启动任务使用LocalTaskLauncher.LocalTaskLauncher为每个启动请求运行一个进程并在内存中跟踪这些进程。在这种情况下，我们不查询底层操作系统，因为以这种方式识别任务是不切实际的。对于CloudFoundry，任务是其部署模型支持的核心概念。所有任务的状态）可直接通过API获得。这意味着帐户的组织和空间中的每个正在运行的任务容器都包含在运行执行计数中，无论它是使用SpringCloudDataFlow启动还是CloudFoundryTaskLauncher直接调用。对于Kubernetes，通过KubernetesTaskLauncher，如果成功，会产生一个正在运行的pod，我们预计它最终会完成或失败。在这种环境中，通常没有简单的方法来识别对应于任务的pod。因此，我们只计算由KubernetesTaskLauncher.由于任务启动器task-name在pod的元数据中提供了标签，因此我们通过该标签的存在来过滤所有正在运行的pod。
启动任务后，任务的状态将存储在关系数据库中。该州包括：
您可以通过RESTfulAPI或shell检查任务执行的状态。要通过shell显示最新的任务执行，请使用taskexecutionlist命令。
要获取仅一个任务定义的任务执行列表，请添加--name任务定义名称-例如，taskexecutionlist--namefoo.要检索任务执行的完整详细信息，请使用taskexecutionstatus带有任务执行ID的命令，例如taskexecutionstatus--id549.
销毁任务定义会从定义存储库中删除该定义。这可以通过RESTfulAPI或shell来完成。要通过shell销毁任务，请使用taskdestroy命令，如下例所示：
dataflow:>taskdestroymytaskDestroyedtask'mytask'该taskdestroy命令还有一个选项来cleanup执行被销毁的任务，如以下示例所示：
dataflow:>taskdestroymytask--cleanupDestroyedtask'mytask'默认情况下，该cleanup选项设置为false（即默认情况下，任务销毁时不会清理任务执行）。
要通过shell销毁所有任务，请使用taskalldestroy如下示例所示的命令：
dataflow:>taskalldestroyReallydestroyalltasks[y,n]:yAlltasksdestroyed如果需要，您可以使用强制开关：
dataflow:>taskalldestroy--forceAlltasksdestroyed先前为定义启动的任务的任务执行信息保留在任务存储库中。
taskdestroy
+.使用cfapps命令获取应用列表。.识别要删除的任务应用程序并运行cfdelete
有时，任务定义中包含的应用程序在其注册中具有无效的URI。这可能是由于在应用程序注册时输入了无效的URI，或者应用程序从要从中提取它的存储库中删除。要验证任务中包含的所有应用程序是否可解析，请使用以下validate命令：
在某些情况下，在平台上运行的任务可能不会因为平台或应用程序业务逻辑本身的问题而停止。对于这种情况，SpringCloudDataFlow提供了向平台发送请求以结束任务的能力。为此，请taskexecutionstop为给定的一组任务执行提交一个，如下所示：
taskexecutionstop--ids5Requesttostopthetaskexecutionwithid(s):5hasbeensubmitted使用前面的命令，停止执行的触发器id=5被提交给底层部署器实现。因此，该操作会停止该任务。当我们查看任务执行的结果时，我们看到任务执行以0退出代码完成：
dataflow:>taskexecutionlist╔══════════╤══╤════════════════════════════╤════════════════════════════╤═════════╗║TaskName│ID│StartTime│EndTime│ExitCode║╠══════════╪══╪════════════════════════════╪════════════════════════════╪═════════╣║batch-demo│5│MonJul1513:58:41EDT2019│MonJul1513:58:55EDT2019│0║║timestamp│1│MonJul1509:26:41EDT2019│MonJul1509:26:41EDT2019│0║╚══════════╧══╧════════════════════════════╧════════════════════════════╧═════════╝如果您为具有与其关联的子任务执行的任务执行提交停止，例如组合任务，则会为每个子任务执行发送停止请求。
您可能希望停止在SpringCloudDataFlow之外启动的任务。这方面的一个例子是远程批处理分区应用程序启动的工作应用程序。在这种情况下，远程批处理分区应用程序存储external-execution-id每个工作应用程序的数据。但是，不存储平台信息。所以当SpringCloudDataFlow不得不停止一个远程批量分区应用程序及其工作应用程序时，需要指定平台名称，如下所示：
dataflow:>taskexecutionstop--ids1--platformmyplatformRequesttostopthetaskexecutionwithid(s):1forplatformmyplatformhasbeensubmitted27.订阅任务和批处理事件您还可以在任务启动时点击各种任务和批处理事件。如果启用任务以生成任务或批处理事件（具有的附加依赖项spring-cloud-task-stream，在Kafka作为活页夹的情况下spring-cloud-stream-binder-kafka，这些事件将在任务生命周期中发布。默认情况下，代理上发布的事件（Rabbit、Kafka等）的目标名称是事件名称本身（例如：task-events、、job-execution-events等）。
dataflow:>taskcreatemyTask--definition"myBatchJob"dataflow:>streamcreatetask-event-subscriber1--definition":task-events>log"--deploydataflow:>tasklaunchmyTask您可以通过在启动任务时指定显式名称来控制这些事件的目标名称，如下所示：
dataflow:>streamcreatetask-event-subscriber2--definition":myTaskEvents>log"--deploydataflow:>tasklaunchmyTask--properties"app.myBatchJob.spring.cloud.stream.bindings.task-events.destination=myTaskEvents"下表列出了代理上的默认任务和批处理事件以及目标名称：
事件
目的地
任务事件
task-events
作业执行事件
job-execution-events
步骤执行事件
step-execution-events
项目读取事件
item-read-events
项目流程事件
item-process-events
项目写入事件
item-write-events
跳过事件
skip-events
SpringCloudDataFlow允许您创建有向图，其中图的每个节点都是一个任务应用程序。这是通过将DSL用于组合任务来完成的。您可以通过RESTfulAPI、SpringCloudDataFlowShell或SpringCloudDataFlowUI创建组合任务。
组合任务通过称为组合任务运行器的任务应用程序运行。SpringCloudDataFlow服务器在启动组合任务时会自动部署组合任务运行器。
该ComposedTaskRunner任务具有以下选项：
要为ComposedTaskRunner设置属性，您需要在属性前加上app.composed-task-runner..例如要设置dataflow-server-uri属性，该属性将如下所示app.composed-task-runner.dataflow-server-uri。
组合任务的生命周期包含三个部分：
通过taskcreate命令创建任务定义时使用组合任务的DSL，如下例所示：
但在我们启动my-composed-task定义之前，我们可以查看SpringCloudDataFlow为我们生成了什么。这可以通过使用任务列表命令来完成，如下例所示（包括其输出）：
dataflow:>tasklist╔══════════════════════════╤══════════════════════╤═══════════╗║TaskName│TaskDefinition│TaskStatus║╠══════════════════════════╪══════════════════════╪═══════════╣║my-composed-task│mytaskapp&×tamp│unknown║║my-composed-task-mytaskapp│mytaskapp│unknown║║my-composed-task-timestamp│timestamp│unknown║╚══════════════════════════╧══════════════════════╧═══════════╝在示例中，SpringCloudDataFlow创建了三个任务定义，一个用于构成我们的组合任务(my-composed-task-mytaskapp和my-composed-task-timestamp)以及组合任务(my-composed-task)定义的每个应用程序。我们还看到，为子任务生成的每个名称都由组合任务的名称和应用程序的名称组成，并用连字符分隔-（如在my-composed-task-mytaskapp中）。
构成组合任务定义的任务应用程序也可以包含参数，如下例所示：
dataflow:>taskcreatemy-composed-task--definition"mytaskapp--displayMessage=hello&×tamp--format=YYYY"28.2.2.启动组合任务启动组合任务的方式与启动独立任务的方式相同，如下所示：
tasklaunchmy-composed-task启动任务后，假设所有任务都成功完成，您可以在运行a时看到三个任务执行taskexecutionlist，如下例所示：
要在任务启动时为组合任务图中的子任务设置属性，请使用以下格式：app.
tasklaunchmy-composed-task--properties"app.my-composed-task.mytaskapp.displayMessage=HELLO,app.my-composed-task.mytimestamp.timestamp.format=YYYY"与应用程序属性类似，您还可以deployer使用以下格式设置子任务的属性deployer.
tasklaunchmy-composed-task--properties"deployer.my-composed-task.mytaskapp.memory=2048m,app.my-composed-task.mytimestamp.timestamp.format=HH:mm:ss"Launchedtask'a1'将参数传递给组合任务运行器您可以使用以下--arguments选项为组合任务运行程序传递命令行参数：
dataflow:>taskcreatemy-composed-task--definition"
用于销毁独立任务的命令与用于销毁组合任务的命令相同。唯一的区别是销毁组合任务也会销毁与其关联的子任务。以下示例显示了使用该destroy命令之前和之后的任务列表：
dataflow:>tasklist╔══════════════════════════╤══════════════════════╤═══════════╗║TaskName│TaskDefinition│TaskStatus║╠══════════════════════════╪══════════════════════╪═══════════╣║my-composed-task│mytaskapp&×tamp│COMPLETED║║my-composed-task-mytaskapp│mytaskapp│COMPLETED║║my-composed-task-timestamp│timestamp│COMPLETED║╚══════════════════════════╧══════════════════════╧═══════════╝...dataflow:>taskdestroymy-composed-taskdataflow:>tasklist╔═════════╤═══════════════╤═══════════╗║TaskName│TaskDefinition│TaskStatus║╚═════════╧═══════════════╧═══════════╝28.2.4.停止组合任务在需要停止组合任务执行的情况下，您可以通过以下方式完成：
要通过仪表板停止组合任务，请选择作业选项卡并单击要停止的作业执行旁边的*Stop()按钮。
当当前运行的子任务完成时，组合任务的运行将停止。与在组合任务停止时正在运行的子任务关联的步骤STOPPED以及组合任务作业执行被标记。
如果组合任务在执行过程中失败并且组合任务的状态为FAILED，则可以重新启动该任务。您可以通过以下方式做到这一点：
要通过shell重新启动组合任务，请使用相同的参数启动任务。要通过仪表板重新启动组合任务，请选择作业选项卡，然后单击要重新启动的作业执行旁边的重新启动按钮。
组合任务可以通过三种方式运行：
条件执行使用双&符号(&&)表示。这使得序列中的每个任务仅在前一个任务成功完成时才启动，如以下示例所示：
taskcreatemy-composed-task--definition"task1&&task2"当被调用的组合任务my-composed-task启动时，它会启动被调用的任务task1，如果task1成功完成，则启动被调用的任务task2。如果task1失败，task2则不启动。
您还可以使用SpringCloudDataFlowDashboard创建条件执行，方法是使用设计器拖放所需的应用程序并将它们连接在一起以创建有向图，如下图所示：
上图是使用SpringCloudDataFlowDashboard创建的有向图的屏幕截图。您可以看到图中的四个组件组成了一个条件执行：
DSL支持对有向图执行期间进行的转换进行细粒度控制。通过提供基于前一个任务的退出状态的相等条件来指定转换。任务转换由以下符号表示->。
基本转换如下所示：
taskcreatemy-transition-composed-task--definition"foo'FAILED'->bar'COMPLETED'->baz"在前面的示例中，foo将启动，如果它的退出状态为FAILED，则bar任务将启动。如果退出状态foo为COMPLETED，baz将启动。返回的所有其他状态cat均无效，任务将正常结束。
使用SpringCloudDataFlowDashboard创建相同的“基本转换”将类似于下图：
上图是在SpringCloudDataFlowDashboard中创建的有向图的屏幕截图。请注意，有两种不同类型的连接器：
要创建过渡连接器：
DSL的转换支持通配符，如下例所示：
taskcreatemy-transition-composed-task--definition"foo'FAILED'->bar'*'->baz"在前面的示例中，foo将启动，如果它的退出状态为FAILED，则bar任务将启动。对于cat除之外的任何退出状态FAILED，baz将启动。
使用SpringCloudDataFlowDashboard创建相同的“使用通配符的转换”将类似于下图：
只要不使用通配符，转换之后就可以进行条件执行，如下例所示：
taskcreatemy-transition-conditional-execution-task--definition"foo'FAILED'->bar'UNKNOWN'->baz&&qux&&quux"在前面的示例中，foo将启动，如果它的退出状态为FAILED，则bar任务将启动。如果foo退出状态为UNKNOWN，baz将启动。对于除orfoo以外的任何退出状态，将启动，并在成功完成后启动。FAILEDUNKNOWNquxquux
使用SpringCloudDataFlowDashboard创建相同的“带条件执行的转换”将类似于下图：
拆分让组合任务中的多个任务并行运行。它通过使用尖括号(<>)对要并行运行的任务和流进行分组来表示。这些任务和流由双竖线||符号分隔，如下例所示：
taskcreatemy-split-task--definition"
使用SpringCloudDataFlowDashboard创建相同的“拆分执行”将类似于下图：
使用任务DSL，您还可以连续运行多个拆分组，如下例所示：
taskcreatemy-split-task--definition"
使用SpringCloudDataFlowDashboard创建相同的“多组拆分”将类似于下图：
请注意，SYNC在连接两个连续拆分时，设计人员会插入一个控制节点。
拆分也可以在尖括号内进行条件执行，如下例所示：
taskcreatemy-split-task--definition"
使用SpringCloudDataFlowDashboard创建相同的“splitcontainingconditionalexecution”类似于下图：
拆分中包含的每个子任务都需要一个线程才能运行。要正确设置它，您需要查看图表并找到具有最多子任务数量的拆分。该拆分中的子任务数是您需要的线程数。要设置线程数，请使用split-thread-core-pool-sizeproperty（默认为1）。因此，例如，诸如
streamcreate--nametask-every-minute--definition"time-tlr--trigger.fixed-delay=60--spring.cloud.stream.function.definition=taskLaunchRequest--task.launch.request.task-name=timestamp-task|task-launcher-dataflow"--deploy前面的流每分钟产生一个任务启动请求。该请求提供要启动的任务的名称：{"name":"timestamp-task"}。
以下流定义说明了命令行参数的使用。它生成消息，例如为{"args":["foo=bar","time=12/03/1817:44:12"],"deploymentProps":{},"name":"timestamp-task"}任务提供命令行参数：
streamcreate--nametask-every-second--definition"time-tlr--spring.cloud.stream.function.definition=taskLaunchRequest--task.launch.request.task-name=timestamp-task--task.launch.request.args=foo=bar--task.launch.request.arg-expressions=time=payload|task-launcher-dataflow"--deploy请注意使用SpEL表达式将每个消息负载映射到time命令行参数以及静态参数(foo=bar)。
然后，您可以使用shell命令查看任务执行列表taskexecutionlist，如以下示例中所示（及其输出）：
流应类似于以下内容：
streamcreatectr-stream--definition"time--fixed-delay=30--task.launch.request.task-name=composed-task-launcher--task.launch.request.args=--graph=AAA&&BBB,--increment-instance-enabled=true|task-launcher-dataflow"现在，我们专注于启动所需的配置ComposedTaskRunner：
SpringCloudDataFlow和您的任务应用程序必须访问相同的数据存储实例。这样一来，SpringCloudDataFlow可以读取任务应用程序记录的任务执行情况，以在Shell和Dashboard视图中列出它们。此外，任务应用程序必须对SpringCloudDataFlow使用的任务数据表具有读写权限。
鉴于对Task应用程序和SpringCloudDataFlow之间的数据源依赖关系的理解，您现在可以查看如何在各种Task编排场景中应用它们。
从SpringCloudDataFlow启动任务时，DataFlow会将其数据源属性（spring.datasource.url、spring.datasource.driverClassName、spring.datasource.username、spring.datasource.password）添加到正在启动的任务的应用程序属性中。因此，任务应用程序将其任务执行信息记录到SpringCloudDataFlow存储库中。
SpringCloudDataFlow允许您使用cron表达式安排任务的执行。您可以通过RESTfulAPI或SpringCloudDataFlowUI创建计划。
默认情况下，SpringCloudDataFlow禁用调度功能。要启用调度功能，请将以下功能属性设置为true：
计划的生命周期包含三个部分：
您可以通过以下方式安排任务执行：
要使用shell计划任务，请使用taskschedulecreate命令创建计划，如以下示例所示：
dataflow:>taskschedulecreate--definitionNamemytask--namemytaskschedule--expression'*/1****'Createdschedule'mytaskschedule'在前面的示例中，我们为名为mytaskschedule的任务定义创建了一个调度mytask。此计划每分钟启动mytask一次。
计划名称的最大字符长度取决于平台。
不适用
您可以使用以下命令删除计划：
要使用shell删除任务计划，请使用taskscheduledestroy命令，如以下示例所示：
要从shell查看您的计划，请使用taskschedulelist命令，如以下示例所示：
一个应用程序的版本是通过注册多个具有相同名称和坐标的应用程序来管理的，除了版本。例如，如果您要使用以下值注册一个应用程序，您将获得一个注册了两个版本（2.1.0.RELEASE和2.1.1.RELEASE）的应用程序：
除了有多个版本之外，SpringCloudDataFlow还需要知道下次启动时要运行哪个版本。这通过将版本设置为默认版本来指示。无论任务应用程序的哪个版本被配置为默认版本，都将在下一个启动请求上运行。您可以在UI中查看默认版本，如下图所示：
在以前的SpringCloudDataFlow版本中，当收到启动任务的请求时，SpringCloudDataFlow将部署应用程序（如果需要）并运行它。如果应用程序在不需要每次都部署应用程序的平台上运行（例如CloudFoundry），则使用之前部署的应用程序。此流程在2.3中已更改。下图显示了现在收到任务启动请求时会发生什么：
上图中需要考虑三个主要流程。第一次启动或不更改启动是其中之一。另外两个在有更改但应用程序当前未启动时启动，并在有更改且应用程序正在运行时启动。我们首先查看没有变化的流程。
此流程是默认行为，如果没有任何更改，则在每次请求进入时发生。请注意，这与DataFlow始终用于启动任务的流程相同。
启动任务时要考虑的第二个流程是任务未运行但任务应用程序版本、应用程序属性或部署属性中的任何一个发生更改时。在这种情况下，将执行以下流程：
这个流程从根本上实现了SpringCloudDataFlow的持续部署。
最后一个主要流程是当启动请求来到SpringCloudDataFlow进行升级但任务定义当前正在运行时。在这种情况下，由于需要删除当前应用程序，启动被阻止。在某些平台上（CloudFoundry，在撰写本文时），删除应用程序会导致所有当前正在运行的应用程序被关闭。此功能可防止这种情况发生。以下过程描述了在另一个实例运行时任务更改时会发生什么：
本节介绍如何使用SpringCloudDataFlow的仪表板。
SpringCloudDataFlow提供了一个名为Dashboard的基于浏览器的GUI来管理以下信息：
启动SpringCloudDataFlow后，仪表板位于：
下图显示了SpringCloudDataFlow仪表板的打开页面：
仪表板的应用程序选项卡列出了所有可用的应用程序，并提供了注册和注销它们的控件（如果适用）。您可以使用批量导入应用程序操作一次导入多个应用程序。
下图显示了仪表板中可用应用程序的典型列表：
可以通过“应用程序”页面上提供的多种方式导入应用程序。对于批量导入，应用程序定义应以属性样式表示，如下所示：
task.timestamp=maven://org.springframework.cloud.task.app:timestamp-task:1.2.0.RELEASEprocessor.transform=maven://org.springframework.cloud.stream.app:transform-processor-rabbit:1.2.0.RELEASE在“从HTTPURI位置导入应用程序坐标”部分中，您可以指定一个指向存储在其他地方的属性文件的URI，它应该包含格式如上例所示的属性。或者，通过使用“从属性文件导入应用程序坐标”部分中的应用程序作为属性文本框，您可以直接列出每个属性字符串。最后，如果属性存储在本地文件中，“导入文件”选项将打开本地文件浏览器以选择文件。通过这些途径之一设置您的定义后，单击ImportApplication(s)。
下图显示了批量导入应用程序的一种方法的示例页面：
仪表板应用程序的运行时选项卡显示所有正在运行的应用程序的列表。对于每个运行时应用程序，会显示部署状态和已部署实例的数量。单击应用程序ID可获得所用部署属性的列表。
下图显示了正在使用的运行时选项卡的示例：
Streams选项卡有两个子选项卡：Definitions和CreateStream。以下主题描述了如何使用每个主题：
仪表板的Streams部分包括提供流定义列表的Definitions选项卡。您可以选择部署或取消部署这些流定义。此外，您可以通过单击Destroy删除定义。每行左侧都有一个箭头，您可以单击该箭头来查看定义的可视化表示。将鼠标悬停在可视化表示中的框上会显示有关应用程序的更多详细信息，包括传递给它们的任何选项。
在以下屏幕截图中，timer流已被扩展以显示视觉表示：
在此选项卡中，您可以：
下图显示了正在使用的Flo设计器：
流部署页面包括提供不同方法来设置部署属性和部署流的选项卡。以下屏幕截图显示了foobar(time|log)的流部署页面。
您可以使用以下方法定义部署属性：
您可以在两个视图之间切换。
部署流应用程序后，可以从Streamsummary页面访问其日志，如下图所示：
在此示例中，我们有来自HTTP源和JDBC源的数据，它们被发送到sharedData通道，这代表了一个扇入用例。在另一端，我们有一个CassandraSink和一个订阅sharedData通道的FileSink，这代表了一个扇出用例。
使用仪表板创建水龙头非常简单。假设您有一个由HTTPSource和FileSink组成的流，并且您希望利用该流也将数据发送到JDBCSink。要创建点击流，请将HTTPSource的输出连接器连接到JDBCSink。连接显示为虚线，表示您创建了一个分流流。
主要流（HTTPSourcetoFileSink）将被自动命名，以防您尚未提供流的名称。创建分流流时，必须始终明确命名主要流。在上图中，主要流被命名为HTTP_INGEST。
通过使用仪表板，您还可以切换主要流，使其成为次要分流流。
将鼠标悬停在现有的主流上，即HTTPSource和FileSink之间的线。出现几个控制图标，通过单击标有Switchto/fromtap的图标，您可以将主要流更改为点击流。对分流流执行相同操作并将其切换到主流。
仪表板的导入/导出选项卡包含一个页面，该页面提供导入和导出流的选项。
下图显示了流导出页面：
导入流时，您必须从有效的JSON文件导入。您可以手动起草文件或从流导出页面导出文件。
导入文件后，您将确认操作是否成功完成。
仪表板的任务选项卡当前具有三个选项卡：
每个应用程序都将一个工作单元封装到一个可重用的组件中。在DataFlow运行时环境中，应用程序允许您为流和任务创建定义。因此，任务选项卡中的应用程序选项卡允许您创建任务定义。
下图显示了任务应用程序的典型列表：
在此屏幕上，您可以执行以下操作：
在此页面上，您可以查看所选任务应用程序的详细信息，包括该应用程序的可用选项（属性）列表。
此页面列出数据流任务定义并提供启动或销毁这些任务的操作。
下图显示了定义页面：
在此页面上，您还可以指定在应用程序部署期间使用的各种属性。一旦您对任务定义感到满意，您可以单击CREATETASK按钮。然后会出现一个对话框，询问任务定义名称和描述。至少，您必须为新定义提供一个名称。
仪表板包括“创建组合任务”选项卡，它提供了用于创建组合任务的交互式图形界面。
在创建组合任务屏幕上，您可以通过输入参数键和参数值来定义一个或多个任务参数。
下图显示了组合的任务设计器：
创建任务定义后，您可以通过仪表板启动任务。为此，请单击任务选项卡，然后按选择要启动的任务Launch。下图显示了任务启动页面：
导入/导出页面提供导入和导出任务的选项。这是通过单击页面左侧的导入/导出选项来完成的。在此处，单击导出任务：使用所选任务创建JSON文件选项。ExportTasks(s)页面出现。
下图显示了任务导出页面：
同样，您可以导入任务定义。为此，请单击页面左侧的导入/导出选项。在此处，单击导入任务：从JSON文件导入任务选项以显示导入任务页面。在ImportTasks页面上，您必须从有效的JSON文件导入。您可以手动起草文件或从“任务导出”页面导出文件。
任务执行选项卡显示当前正在运行和已完成的任务执行。在此页面中，您可以深入了解“任务执行详细信息”页面。此外，您可以重新启动任务执行或停止正在运行的执行。
最后，您可以清理一个或多个任务执行。此操作从底层持久性存储中删除任何关联的任务或批处理作业。此操作只能在父任务执行时触发，并级联到子任务执行（如果有的话）。
下图显示了执行选项卡：
对于“任务执行”选项卡上的每个任务执行，您可以通过单击任务执行的执行ID来检索有关特定执行的详细信息。
在此屏幕上，您不仅可以查看来自任务执行页面的信息，还可以查看：
此外，您还可以触发以下操作：
要向平台提交停止任务执行请求，请单击需要停止的任务执行旁边的下拉按钮。现在单击停止任务选项。仪表板显示一个对话框，询问您是否确定要停止任务执行。如果是，请单击StopTaskExecution(s)。
Dashboard的JobExecutions选项卡允许您检查批处理作业。屏幕的主要部分提供作业执行列表。批处理作业是每个执行一个或多个批处理作业的任务。每个作业执行都有一个对任务执行ID的引用（在任务ID列中）。
作业执行列表还显示了底层作业定义的状态。因此，如果基础定义已被删除，“未找到定义”会出现在“状态”列中。
您可以对每个作业执行以下操作：
下图显示了“作业”选项卡：
启动批处理作业后，作业执行详细信息页面会显示有关作业的信息。
下图显示了作业执行详细信息页面：
JobExecutionDetails页面包含已执行步骤的列表。您可以通过单击放大镜图标进一步深入了解每个步骤的执行细节。
“步骤执行详细信息”页面提供有关作业中单个步骤的信息。
下图显示了StepExecutionDetails页面：
StepExecutionDetails屏幕提供了所有StepExecutionContext键值对的完整列表。
仪表板的审核页面使您可以访问记录的审核事件。记录审计事件：
下图显示了审核记录页面：
通过单击显示详细信息图标（右侧圆圈中的“i”），您可以获得有关审计详细信息的更多详细信息：
通常，审计提供以下信息：
审计数据属性的写入值取决于执行的审计操作和操作类型。例如，在创建计划时，任务定义的名称、任务定义属性、部署属性和命令行参数将被写入持久性存储。
在保存审计记录之前，我们会尽最大努力对敏感信息进行清理。正在检测以下任何键，并且它们的敏感值被屏蔽：
本节显示可用的示例。
提供以下示例：
本节介绍SpringCloudDataFlowRESTAPI。
SpringCloudDataFlow提供了一个RESTAPI，让您可以访问服务器的所有方面。事实上，SpringCloudDataFlowshell是该API的一流使用者。
SpringCloudDataFlow在使用HTTP动词时尝试尽可能地遵守标准HTTP和REST约定，如下表所述：
GET
用于检索资源。
POST
用于创建新资源。
PUT
用于更新现有资源，包括部分更新。也用于暗示的概念的资源restarts，例如任务。
DELETE
用于删除现有资源。
SpringCloudDataFlow在使用HTTP状态码时尽量遵循标准HTTP和REST约定，如下表所示：
200OK
请求成功完成。
201Created
已成功创建新资源。资源的URI可从响应的Location标头中获得。
204NoContent
已成功应用对现有资源的更新。
400BadRequest
请求格式不正确。响应正文包括提供更多信息的错误描述。
404NotFound
请求的资源不存在。
409Conflict
请求的资源已经存在。例如，任务已存在或流已被部署
422UnprocessableEntity
在无法停止或重新启动作业执行的情况下返回。
每个响应都有以下标头：
Content-Type
有效负载的Content-Type，例如application/hal+json
error
String
发生的HTTP错误，例如BadRequest
message
错误原因的描述
path
发出请求的路径
status
Number
HTTP状态码，例如400
timestamp
API包括以下资源：
该索引提供了SpringCloudDataFlow的RESTAPI的入口点。以下主题提供了更多详细信息：
使用GET请求访问索引。
Object
其他资源的链接
['api.revision']
每次在此RESTAPI中实现更改时递增
链接到审计记录
链接到仪表板
链接到流/定义
链接到流/定义/定义
_links.streams/definitions/definition.templated
Boolean
链接流/定义/定义是模板化的
链接到运行时/应用程序
链接到运行时/apps/{appId}
_links.runtime/apps/{appId}.templated
链接运行时/应用程序是模板化的
链接到运行时/apps/{appId}/instances
_links.runtime/apps/{appId}/instances.templated
链接runtime/apps/{appId}/instances是模板化的
链接到运行时/apps/{appId}/instances/{instanceId}
_links.runtime/apps/{appId}/instances/{instanceId}.templated
链接runtime/apps/{appId}/instances/{instanceId}是模板化的
链接到运行时/流
_links.runtime/streams.templated
链接运行时/流是模板化的
链接到运行时/流/{streamNames}
_links.runtime/streams/{streamNames}.templated
链接runtime/streams/{streamNames}是模板化的
链接到流/日志
链接到流/日志/{streamName}
链接到流/日志/{streamName}/{appName}
_links.streams/logs/{streamName}.templated
链接流/日志/{streamName}已模板化
_links.streams/logs/{streamName}/{appName}.templated
链接流/日志/{streamName}/{appName}已模板化
_links.streams/deployments
链接到流/部署
_links.streams/deployments/{name}
链接流/部署/{name}已模板化
_links.streams/deployments/{name}.templated
_links.streams/deployments/{name}{reuse-deployment-properties}.templated
链接到流/部署/部署
_links.streams/deployments/deployment.templated
链接流/部署/部署是模板化的
链接到流/部署/清单/{name}/{version}
_links.streams/deployments/manifest/{name}/{version}.templated
链接流/部署/清单/{name}/{version}已模板化
链接到流/部署/历史/{name}
_links.streams/deployments/history/{name}.templated
链接流/部署/历史是模板化的
链接到流/部署/回滚/{name}/{version}
_links.streams/deployments/rollback/{name}/{version}.templated
链接流/部署/回滚/{name}/{version}已模板化
链接到流/部署/更新/{name}
_links.streams/deployments/update/{name}.templated
链接流/部署/更新/{name}已模板化
链接到流/部署/平台/列表
链接到流/部署/规模/{streamName}/{appName}/instances/{count}
_links.streams/deployments/scale/{streamName}/{appName}/instances/{count}.templated
链接流/部署/规模/{streamName}/{appName}/instances/{count}是模板化的
链接到流/验证
_links.streams/validation.templated
链接流/验证是模板化的
链接到任务/平台
链接到任务/定义
链接到任务/定义/定义
_links.tasks/definitions/definition.templated
链接任务/定义/定义是模板化的
链接到任务/执行
链接到任务/执行/名称
_links.tasks/executions/name.templated
链接任务/执行/名称是模板化的
链接到任务/执行/当前
链接到任务/执行/执行
_links.tasks/executions/execution.templated
链接任务/执行/执行是模板化的
链接到任务/信息/执行
_links.tasks/info/executions.templated
链接任务/信息是模板化的
链接到任务/日志
_links.tasks/logs.templated
链接任务/日志是模板化的
链接到任务/计划/实例
_links.tasks/schedules/instances.templated
链接任务/计划/实例是模板化的
链接到任务/验证
_links.tasks/validation.templated
链接任务/验证是模板化的
链接到工作/执行
链接到工作/精简执行
链接到工作/执行/名称
_links.jobs/executions/name.templated
链接作业/执行/名称是模板化的
链接到工作/执行/状态
_links.jobs/executions/status.templated
链接作业/执行/状态是模板化的
链接到工作/精简执行/名称
_links.jobs/thinexecutions/name.templated
链接到作业/瘦执行/jobInstanceId
_links.jobs/thinexecutions/jobInstanceId.templated
链接作业/执行/jobInstanceId是模板化的
链接到jobs/thinexecutions/taskExecutionId
_links.jobs/thinexecutions/taskExecutionId.templated
链接作业/执行/taskExecutionId是模板化的
链接到作业/执行/执行
_links.jobs/executions/execution.templated
链接作业/执行/执行是模板化的
链接到作业/执行/执行/步骤
_links.jobs/executions/execution/steps.templated
链接作业/执行/执行/步骤是模板化的
链接到作业/执行/执行/步骤/步骤
_links.jobs/executions/execution/steps/step.templated
链接作业/执行/执行/步骤/步骤是模板化的
链接到作业/执行/执行/步骤/步骤/进度
_links.jobs/executions/execution/steps/step/progress.templated
链接作业/执行/执行/步骤/步骤/进度是模板化的
链接到工作/实例/名称
_links.jobs/instances/name.templated
链接作业/实例/名称已模板化
链接到作业/实例/实例
_links.jobs/instances/instance.templated
链接作业/实例/实例是模板化的
链接到工具/parseTaskTextToGraph
链接到工具/convertTaskGraphToText
链接到应用程序
链接到关于
链接到完成/流
_links.completions/stream.templated
链接完成/流是模板化的
链接到完成/任务
_links.completions/task.templated
链接完成/任务是模板化的
about
访问元信息，包括启用的功能、安全信息、版本信息
dashboard
访问仪表板UI
audit-records
提供审计跟踪信息
apps
处理已注册的申请
completions/stream
公开Stream的DSL完成功能
completions/task
公开Task的DSL完成功能
jobs/executions
提供JobExecution资源
jobs/thinexecutions
提供不包含步骤执行的JobExecution精简资源
jobs/executions/execution
提供特定JobExecution的详细信息
jobs/executions/execution/steps
提供JobExecution的步骤
jobs/executions/execution/steps/step
返回特定步骤的详细信息
jobs/executions/execution/steps/step/progress
提供特定步骤的进度信息
jobs/executions/name
按作业名称检索作业执行
jobs/executions/status
按作业状态检索作业执行
jobs/thinexecutions/name
按作业名称检索作业执行，不包括步骤执行
jobs/thinexecutions/jobInstanceId
按作业实例ID检索作业执行，不包括步骤执行
jobs/thinexecutions/taskExecutionId
按任务执行ID检索作业执行，不包括步骤执行
jobs/instances/instance
为特定作业实例提供作业实例资源
jobs/instances/name
为特定作业名称提供作业实例资源
runtime/streams
公开流运行时状态
runtime/streams/{streamNames}
公开给定流名称的流运行时状态
runtime/apps
提供运行时应用程序资源
runtime/apps/{appId}
公开特定应用程序的运行时状态
runtime/apps/{appId}/instances
提供应用实例的状态
runtime/apps/{appId}/instances/{instanceId}
提供特定应用实例的状态
tasks/definitions
提供任务定义资源
tasks/definitions/definition
提供特定任务定义的详细信息
tasks/validation
为任务定义提供验证
tasks/executions
返回任务执行并允许启动任务
tasks/executions/current
提供当前正在运行的任务数
tasks/info/executions
提供任务执行信息
tasks/schedules
提供任务的计划信息
tasks/schedules/instances
提供特定任务的计划信息
tasks/executions/name
返回给定任务名称的所有任务执行
tasks/executions/execution
提供特定任务执行的详细信息
tasks/platforms
提供用于启动任务的平台帐户。可以通过添加请求参数'schedulesEnabled=true过滤结果以显示支持调度的平台
tasks/logs
检索任务应用程序日志
streams/definitions
公开Streams资源
streams/definitions/definition
处理特定的Stream定义
streams/validation
提供流定义的验证
streams/deployments
提供Stream部署操作
streams/deployments/{name}
请求流定义的部署信息
streams/deployments/{name}{reuse-deployment-properties}
streams/deployments/deployment
请求（取消）部署现有流定义
streams/deployments/manifest/{name}/{version}
返回发布版本的清单信息
streams/deployments/history/{name}
获取流的部署历史作为此版本的列表或版本
streams/deployments/rollback/{name}/{version}
将流回滚到流的先前版本或特定版本
streams/deployments/update/{name}
更新流。
streams/deployments/platform/list
支持的部署平台列表
streams/deployments/scale/{streamName}/{appName}/instances/{count}
为选定的流增加或减少应用程序实例的数量
streams/logs
检索流的应用程序日志
streams/logs/{streamName}
streams/logs/{streamName}/{appName}
检索流的特定应用程序日志
tools/parseTaskTextToGraph
将任务定义解析为图结构
tools/convertTaskGraphToText
将图形格式转换为DSL文本格式
服务器元信息端点提供有关服务器本身的更多信息。以下主题提供了更多详细信息：
一个GET请求返回SpringCloudDataFlow的元信息，包括：
GET请求列出SpringCloudDataFlow已知的所有应用程序。以下主题提供了更多详细信息：
对名称执行的搜索字符串（可选）
type
将返回的应用程序限制为应用程序的类型。[应用程序，源，处理器，接收器，任务]之一
defaultVersion
设置为仅检索默认版本的应用程序的布尔标志（可选）
page
从零开始的页码（可选）
sort
列表上的排序（可选）
size
请求的页面大小（可选）
返回所有应用程序属性，包括常见的SpringBoot属性
/apps/{类型}/{名称}
要查询的应用程序类型。[应用程序，源，处理器，接收器，任务]之一
name
要查询的应用程序的名称
应用程序位所在的URI
metadata-uri
可以找到应用程序元数据jar的URI
force
如果已经存在同名同类型的注册必须为真，否则会报错
要注册的应用程序类型。[应用程序，源，处理器，接收器，任务]之一
要注册的应用程序的名称
/apps/{type}/{name}/{version:.+}
要注册的应用程序类型。[app,source,processor,sink,task]之一（可选）
version
要注册的应用程序版本
可以获取包含注册的属性文件的URI。与apps.
内联注册集。与uri.
以下主题提供了更多详细信息：
应用程序的类型。[应用程序，源，处理器，接收器，任务]之一
应用程序的名称
应用程序的版本
要注销的应用程序类型。[应用程序，源，处理器，接收器，任务]之一
要注销的应用程序的名称
要注销的应用程序版本（可选）
审计记录端点允许您检索审计跟踪信息。
operations
逗号分隔的审计操作列表（可选）
actions
fromDate
从日期过滤器（例如：2019-02-03T00:00:30）（可选）
toDate
迄今为止的过滤器（例如：2019-02-03T00:00:30）（可选）
id
要查询的审计记录的id（必填）
创建流定义是通过创建对流定义端点的POST请求来实现的。对流的curl请求ticktock可能类似于以下内容：
创建的任务定义的名称
definition
流的定义，使用DataFlowDSL
description
流定义的描述
deploy
如果为true，则在创建时部署流（默认为false）
search
要查询的流定义的名称（必填）
要验证的流定义的名称（必需）
流定义端点允许您部署单个流定义。或者，您可以将应用程序参数作为请求正文中的属性传递。以下主题提供了更多详细信息：
timelog
现有流定义的名称（必需）
此端点没有请求参数。
timelog1
回滚到的版本
流的版本
streamName
appName
在流应用程序名称中进行缩放
count
所选流应用程序的实例数（必需）
任务定义端点允许您创建新的任务定义。以下主题提供了更多详细信息：
任务的定义，使用DataFlowDSL
任务定义说明
manifest
将任务清单包含到最新任务执行中的标志（可选）
my-task
现有任务定义的名称（必填）
任务计划端点允许您创建新的任务计划。以下主题提供了更多详细信息：
创建的计划的名称
taskDefinitionName
要计划的任务定义的名称
properties
计划和启动任务所需的属性
arguments
用于启动任务的命令行参数
task-definition-name
根据指定的任务定义过滤计划（必需）
scheduleName
现有计划的名称（必填）
要验证的任务定义的名称（必填）
启动任务是通过请求创建新的任务执行来完成的。以下主题提供了更多详细信息：
要启动的任务定义的名称
启动时使用的应用程序和部署程序属性
传递给任务的命令行参数
现有任务执行的ID（必需）
platform
与任务执行关联的平台（可选）
与任务执行关联的名称
现有任务执行的id（必需）
ids
提供2个逗号分隔的任务执行ID值。
您必须提供实际存在的任务执行ID。否则，404返回（未找到）HTTP状态。在提交多个任务执行ID的情况下，单个任务执行ID无效导致整个请求失败，不执行任何操作。
此端点支持一个名为action的可选请求参数。它是一个枚举并支持以下值：
action
同时使用两个动作CLEANUP和REMOVE_DATA。
以下示例说明了如何使用多个任务执行ID和多个操作发出请求：
任务执行当前端点允许您检索当前正在运行的执行次数。以下主题提供了更多详细信息：
api-guide.adoc中未解析的指令-包括::/home/runner/work/spring-cloud-dataflow/spring-cloud-dataflow/spring-cloud-dataflow-docs/../spring-cloud-dataflow-classic-docs/target/generated-snippets/task-executions-documentation/launch-task-current-count/curl-request.adoc[]
作业执行端点提供有关向SpringCloudDataFlow服务器注册的作业执行的信息。以下主题提供了更多详细信息：
作业执行端点允许您列出所有作业执行。以下主题提供了更多详细信息：
与作业执行关联的名称
从开始日期过滤结果，格式为'yyyy-MM-dd'T'HH:mm:ss,SSS'
to以'yyyy-MM-dd'T'HH:mm:ss,SSS'格式过滤截至日期的结果
jobInstanceId
按作业实例ID过滤结果
taskExecutionId
按任务执行id过滤结果
现有作业执行的ID（必需）
stop
如果设置为true，则发送信号以停止作业
restart
如果设置为true，则发送信号以重新启动作业
作业实例端点允许您列出所有作业实例。以下主题提供了更多详细信息：
与作业实例关联的名称
现有作业实例的ID（必填）
作业步骤执行端点允许您列出所有作业步骤执行。以下主题提供了更多详细信息：
stepid
特定作业执行的现有步骤执行的ID（必需）
要检索有关所有应用程序的所有实例的信息，请/runtime/apps使用查询端点GET。以下主题提供了更多详细信息：
使用带有REST端点的HTTPGET方法/streams/logs/
要检索任务执行的日志，请/tasks/logs/
启动任务的平台名称。
如API指南章节所述，SpringCloudDataFlow的功能完全通过REST端点公开。虽然您可以直接使用这些端点，但SpringCloudDataFlow还提供了基于Java的API，这使得使用这些REST端点更加容易。
中心入口点是包中的DataFlowTemplate类org.springframework.cloud.dataflow.rest.client。
此类实现DataFlowOperations接口并委托给以下子模板，这些子模板为每个功能集提供特定功能：
StreamOperations
用于流操作的REST客户端
CounterOperations
用于计数器操作的REST客户端
FieldValueCounterOperations
用于字段值计数器操作的REST客户端
AggregateCounterOperations
用于聚合计数器操作的REST客户端
TaskOperations
用于任务操作的REST客户端
JobOperations
用于作业操作的REST客户端
AppRegistryOperations
用于应用注册表操作的REST客户端
CompletionOperations
用于完成操作的REST客户端
RuntimeOperations
用于运行时操作的REST客户端
在DataFlowTemplate初始化时，可以通过HATEOAS（HypermediaastheEngineofApplicationState）提供的REST关系发现子模板。
当您使用DataFlowTemplate时，唯一需要的DataFlow依赖项是SpringCloudDataFlowRestClient，如以下Maven片段所示：
要配置BasicAuthentication，需要进行以下设置：
本节提供了人们在使用SpringCloudDataFlow时经常出现的一些常见问题的答案。
您可以在启动数据流服务器时通过命令行属性设置Maven属性，例如本地Maven存储库位置、远程Maven存储库、身份验证凭据和代理服务器属性。或者，您可以通过设置SPRING_APPLICATION_JSON数据流服务器的环境属性来设置属性。
要将属性作为命令行选项传递，请使用类似于以下的命令运行服务器：
本附录描述了如何构建SpringCloudDataFlow。
要构建源代码，您需要安装JDK1.8。
该构建使用Maven包装器，因此您不必安装特定版本的Maven。
主要构建命令如下：
$./mvnwcleaninstall为了加快构建速度，您可以添加-DskipTests以避免运行测试。
有一个full生成文档的配置文件。您可以使用以下命令仅构建文档：
如果您不想使用m2eclipse，可以使用以下命令生成Eclipse项目元数据：
$./mvnweclipse:eclipse您可以通过从File菜单中选择Importexistingprojects来导入生成的Eclipse项目。
SpringCloud在非限制性Apache2.0许可下发布，并遵循非常标准的Github开发流程，使用Github跟踪器处理问题并将拉取请求合并到主分支。如果您想贡献一些微不足道的东西，请不要犹豫，但请遵循本附录中的指南。
以下指南对于拉取请求都不是必不可少的，但它们都可以帮助您的开发人员同事理解和使用您的代码。它们也可以在原始拉取请求之后但在合并之前添加。
本附录包含如何设置特定提供程序以使用数据流安全性的信息。
在撰写本文时，Azure是唯一的身份提供者。
在本节中，我们将介绍如何为AD和SpringCloudDataFlow完成OAuth2设置。
首先，创建一个新的ActiveDirectory环境。选择一种类型作为AzureActiveDirectory（不是b2c类型），然后选择您的组织名称和初始域。下图显示了设置：
应用程序注册是创建OAuth客户端以供OAuth应用程序使用的地方。至少，您需要创建两个客户端，一个用于DataFlow和Skipper服务器，一个用于DataFlowshell，因为这两个客户端的配置略有不同。服务器应用程序可以被认为是受信任的应用程序，而shell不受信任（因为用户可以看到它的完整配置）。
注意：我们建议对DataFlow和Skipper服务器使用相同的OAuth客户端。虽然您可以使用不同的客户端，但它目前不会提供任何价值，因为配置需要相同。
下图显示了创建新应用注册的设置：
要准备OAuth范围，请为每个数据流安全角色创建一个。在这个例子中，那些将是
下图显示了要公开的API：
之前创建的范围需要添加为API权限，如下图所示：
下图显示了特权设置：
公共客户端基本上是没有客户端密码且类型设置为公共的客户端。