AWS Data Pipeline 不再向新客户提供。的现有客户 AWS Data Pipeline 可以继续照常使用该服务。[了解详情](https://aws.amazon.com/blogs/big-data/migrate-workloads-from-aws-data-pipeline/)
本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 管道对象引用
您可在管道定义文件中使用以下管道对象和组件。
**Topics**
+ [数据节点](dp-object-datanodes.md)
+ [活动](dp-object-activities.md)
+ [资源](dp-object-resources.md)
+ [先决条件](dp-object-preconditions.md)
+ [数据库](dp-object-databases.md)
+ [数据格式](dp-object-dataformats.md)
+ [操作](dp-object-actions.md)
+ [Schedule](dp-object-schedule.md)
+ [公用事业机构](dp-object-utilities.md)
**注意**
有关使用 AWS Data Pipeline Java SDK 的示例应用程序，请参阅上的 D [ata Pipeline DynamoDB 导出](https://github.com/awslabs/data-pipeline-samples/tree/master/samples/DynamoDBExportJava) Java 示例。 GitHub
以下是的对象层次结构 AWS Data Pipeline。
![\[AWS Data Pipeline 对象层次结构\]](http://docs.aws.amazon.com/zh_cn/datapipeline/latest/DeveloperGuide/images/object_hierarchy.png)
# 数据节点
以下是 AWS Data Pipeline 数据节点对象：
**Topics**
+ [Dynamo 节点 DBData](dp-object-dynamodbdatanode.md)
+ [MySqlDataNode](dp-object-mysqldatanode.md)
+ [RedshiftDataNode](dp-object-redshiftdatanode.md)
+ [S3 DataNode](dp-object-s3datanode.md)
+ [SqlDataNode](dp-object-sqldatanode.md)
# Dynamo 节点 DBData
使用 DynamoDB 定义一个数据节点，该节点指定为 `HiveActivity` 或 `EMRActivity` 对象的输入。
**注意**
`DynamoDBDataNode` 对象不支持 `Exists` 先决条件。
## 示例
以下是该对象类型的示例。该对象引用您在同一管道定义文件中定义的其他两个对象。`CopyPeriod` 为 `Schedule` 对象，`Ready` 为先决条件对象。
```
{
"id" : "MyDynamoDBTable",
"type" : "DynamoDBDataNode",
"schedule" : { "ref" : "CopyPeriod" },
"tableName" : "adEvents",
"precondition" : { "ref" : "Ready" }
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| tableName | DynamoDB 表。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅[计划](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如，“日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置该字段，则可能会重试未在设置的开始时间内完成的远程活动。 | 周期 |
| dataFormat | DataFormat 用于此数据节点描述的数据。目前支持 HiveActivity 和 HiveCopyActivity。 | 参考对象，“dataFormat”：\$1“ref”: “myDynamo” DBDataFormatId\$1 |
| dependsOn | 指定与另一个可运行对象的依赖关系 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| readThroughputPercent | 设置读取操作的速率，将 DynamoDB 预配的吞吐速率保持在为您的表分配的范围内。该值为介于 0.1 到 1.0 之间的双精度值 (包含端点)。 | 双精度 |
| region | DynamoDB 表所在区域的代码。例如，us-east-1。 HiveActivity 当它在 Hive 中为 DynamoDB 表执行暂存操作时会使用它。 | 枚举 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
| writeThroughputPercent | 设置写入操作的速率，将 DynamoDB 预配的吞吐速率保持在为您的表分配的范围内。该值为介于 0.1 到 1.0 之间的双精度值 (包含端点)。 | 双精度 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# MySqlDataNode
使用 MySQL 定义数据节点。
**注意**
`MySqlDataNode` 类型已被弃用。建议您改用 [SqlDataNode](dp-object-sqldatanode.md)。
## 示例
以下是该对象类型的示例。该对象引用您在同一管道定义文件中定义的其他两个对象。`CopyPeriod` 为 `Schedule` 对象，`Ready` 为先决条件对象。
```
{
"id" : "Sql Table",
"type" : "MySqlDataNode",
"schedule" : { "ref" : "CopyPeriod" },
"table" : "adEvents",
"username": "user_name",
"*password": "my_password",
"connectionString": "jdbc:mysql://mysqlinstance-rds.example.us-east-1.rds.amazonaws.com:3306/database_name",
"selectQuery" : "select * from #{table} where eventTime >= '#{@scheduledStartTime.format('YYYY-MM-dd HH:mm:ss')}' and eventTime < '#{@scheduledEndTime.format('YYYY-MM-dd HH:mm:ss')}'",
"precondition" : { "ref" : "Ready" }
}
```
### 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 表 | MySQL 数据库中的表的名称。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| createTableSql | SQL 创建表表达式，该表达式创建表。 | 字符串 |
| database | 数据库的名称。 | 参考对象，例如 “数据库”：\$1"ref”:” myDatabaseId “\$1 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| insertQuery | 将数据插入到表中的 SQL 语句。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| schemaName | 保存表的架构的名称 | 字符串 |
| selectQuery | 从表中提取数据的 SQL 语句。 | 字符串 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [S3 DataNode](dp-object-s3datanode.md)
# RedshiftDataNode
使用 Amazon Redshift 定义一个数据节点。`RedshiftDataNode` 表示由管道使用的数据库中的数据（如数据表）的属性。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyRedshiftDataNode",
"type" : "RedshiftDataNode",
"database": { "ref": "MyRedshiftDatabase" },
"tableName": "adEvents",
"schedule": { "ref": "Hour" }
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| database | 表所在的数据库。 | 参考对象，例如 “数据库”：\$1"ref”:” myRedshiftDatabase Id "\$1 |
| tableName | Amazon Redshift 表的名称。如果该表尚不存在且您已提供，则会创建该表 createTableSql。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| createTableSql | 用于在数据库中创建表的 SQL 表达式。我们建议你指定创建表的架构，例如：CREATE TABLE myschema.myTable（bestColumn varchar (25) 主键 distkey，整数 sortKey）。 numberOfWins AWS Data Pipeline 如果由 TableName 指定的表不存在于 SchemaName createTableSql 字段指定的架构中，则在字段中运行脚本。例如，如果您将 SchemaName 指定为 mySchema，但未在 createTableSql 字段中包含 mySchema，则该表是在错误的架构中创建的（默认情况下，它将在 PUBLIC 中创建）。由于 AWS Data Pipeline 无法分析您的 CREATE TABLE 语句，因此将发生此情况。 | 字符串 |
| dependsOn | 指定与另一个可运行对象的依赖关系 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| primaryKeys | 如果您未在 RedShiftCopyActivity 中为目标表指定 primaryKeys，则可使用将用作 mergeKey 的 primaryKeys 指定列的列表。不过，如果您现已在 Amazon Redshift 表中定义一个 primaryKey，此设置将覆盖现有密钥。 | 字符串 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| schemaName | 此可选字段指定 Amazon Redshift 表的架构的名称。如果未指定架构名称，则架构名称为 PUBLIC，这是在 Amazon Redshift 中的默认架构。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》。 | 字符串 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# S3 DataNode
使用 Amazon S3 定义数据节点。默认情况下，S3 DataNode 使用服务器端加密。如果您想禁用此功能，请将 s3 设置EncryptionType 为 NONE。
**注意**
在使用 `S3DataNode` 作为 `CopyActivity` 的输入时，仅 CSV 和 TSV 数据格式受支持。
## 示例
以下是该对象类型的示例。该对象引用您在同一管道定义文件中定义的另一个对象。`CopyPeriod` 为 `Schedule` 对象。
```
{
"id" : "OutputData",
"type" : "S3DataNode",
"schedule" : { "ref" : "CopyPeriod" },
"filePath" : "s3://amzn-s3-demo-bucket/#{@scheduledStartTime}.csv"
}
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| 压缩 | S3 描述的数据的压缩类型DataNode。 “无” 表示不压缩，“gzip” 是使用 gzip 算法压缩的。只有在 Amazon Redshift 中使用以及将 S3 DataNode 与一起使用时，才支持使用此字段。 CopyActivity | 枚举 |
| dataFormat | DataFormat 用于此 S3 描述的数据DataNode。 | 参考对象，例如 “dataFormat”：\$1"ref”:” myDataFormat Id "\$1 |
| dependsOn | 指定与另一个可运行对象的依赖关系 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| directoryPath | 作为 URI 的 Amazon S3 目录路径：s3://my-bucket/ my-key-for-directory。您必须提供 filePath 或 directoryPath 值。 | 字符串 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| filePath | 在 Amazon S3 中以 URI 形式指向该对象的路径，例如：s3://my-bucket/ my-key-for-file。您必须提供 filePath 或 directoryPath 值。它们表示一个文件夹和文件名。使用 directoryPath 值适应目录中的多个文件。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| manifestFilePath | 亚马逊 S3 指向亚马逊 Redshift 支持的格式的清单文件路径。 AWS Data Pipeline 使用清单文件将指定的 Amazon S3 文件复制到表中。仅当 RedShiftCopyActivity 引用 S3 时，此字段才有效DataNode。 | 字符串 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| s3 EncryptionType | 覆盖 Amazon S3 加密类型。值为 SERVER\$1SIDE\$1ENCRYPTION 或 NONE。默认情况下启用服务器端加密。 | 枚举 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [MySqlDataNode](dp-object-mysqldatanode.md)
# SqlDataNode
使用 SQL 定义数据节点。
## 示例
以下是该对象类型的示例。该对象引用您在同一管道定义文件中定义的其他两个对象。`CopyPeriod` 为 `Schedule` 对象，`Ready` 为先决条件对象。
```
{
"id" : "Sql Table",
"type" : "SqlDataNode",
"schedule" : { "ref" : "CopyPeriod" },
"table" : "adEvents",
"database":"myDataBaseName",
"selectQuery" : "select * from #{table} where eventTime >= '#{@scheduledStartTime.format('YYYY-MM-dd HH:mm:ss')}' and eventTime < '#{@scheduledEndTime.format('YYYY-MM-dd HH:mm:ss')}'",
"precondition" : { "ref" : "Ready" }
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 表 | SQL 数据库中的表的名称。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| createTableSql | SQL 创建表表达式，该表达式创建表。 | 字符串 |
| database | 数据库的名称。 | 参考对象，例如 “数据库”：\$1"ref”:” myDatabaseId “\$1 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| insertQuery | 将数据插入到表中的 SQL 语句。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| schemaName | 保存表的架构的名称 | 字符串 |
| selectQuery | 从表中提取数据的 SQL 语句。 | 字符串 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [S3 DataNode](dp-object-s3datanode.md)
# 活动
以下是 AWS Data Pipeline 活动对象：
**Topics**
+ [CopyActivity](dp-object-copyactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
+ [HadoopActivity](dp-object-hadoopactivity.md)
+ [HiveActivity](dp-object-hiveactivity.md)
+ [HiveCopyActivity](dp-object-hivecopyactivity.md)
+ [PigActivity](dp-object-pigactivity.md)
+ [RedshiftCopyActivity](dp-object-redshiftcopyactivity.md)
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [SqlActivity](dp-object-sqlactivity.md)
# CopyActivity
将数据从一个位置复制到另一个位置。 `CopyActivity`支持[S3 DataNode](dp-object-s3datanode.md)和[SqlDataNode](dp-object-sqldatanode.md)作为输入和输出，通常执行复制操作 record-by-record。不过，当满足以下条件时，`CopyActivity` 可提供高性能的 Amazon S3 到 Amazon S3 复制：
+ 输入和输出均为 S3 DataNodes
+ 对于输入和输出，`dataFormat` 字段是相同的
如果您提供压缩的数据文件作为输入，并且不使用 S3 数据节点上的 `compression` 字段指示这一点，则 `CopyActivity` 可能会失败。在此情况下，`CopyActivity` 无法正确检测记录结束字符，并且操作会失败。此外，还`CopyActivity`支持从一个目录复制到另一个目录以及将文件复制到一个目录，但是在 record-by-record将目录复制到文件时会发生复制。最后，`CopyActivity` 不支持复制多部分 Amazon S3 文件。
`CopyActivity` 对其 CSV 支持有特定的限制。当您使用 S3 DataNode 作为输入时`CopyActivity`，只能对 Amazon S3 的输入和输出字段使用 CSV 数据文件格式的 Unix/Linux 变体。该 Unix/Linux 变体需要以下内容：
+ 分隔符必须是“,”(逗号) 字符。
+ 记录未用引号引起来。
+ 默认转义字符是 ASCII 值 92 (反斜杠)。
+ 记录结束标识符是 ASCII 值 10 (或“\$1n”)。
基于 Windows 的系统通常使用不同的 end-of-record字符序列：回车符和换行在一起（ASCII 值 13 和 ASCII 值 10）。您必须使用其他机制来适应此差异 (例如，使用预先复制脚本修改输入数据) 以确保 `CopyActivity` 能够正确检测到记录结尾；否则，`CopyActivity` 将反复失败。
在使用 `CopyActivity` 从 PostgreSQL RDS 对象导出到 TSV 数据格式时，默认 NULL 字符为 \$1n。
## 示例
以下是该对象类型的示例。该对象引用您将在同一管道定义文件中定义的其他三个对象。`CopyPeriod` 为 `Schedule` 对象，`InputData` 和 `OutputData` 为数据节点对象。
```
{
"id" : "S3ToS3Copy",
"type" : "CopyActivity",
"schedule" : { "ref" : "CopyPeriod" },
"input" : { "ref" : "InputData" },
"output" : { "ref" : "OutputData" },
"runsOn" : { "ref" : "MyEc2Resource" }
}
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据源。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据源。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
+ [使用将 MySQL 数据导出到亚马逊 S3 AWS Data Pipeline](dp-copydata-mysql.md)
# EmrActivity
运行 EMR 集群。
AWS Data Pipeline 使用与 Amazon EMR 不同的步骤格式；例如，在步骤字段的 JAR 名称后 AWS Data Pipeline 使用逗号分隔的参数。`EmrActivity`以下示例显示格式适合 Amazon EMR 的步骤，后跟其 AWS Data Pipeline 等效步骤：
```
s3://amzn-s3-demo-bucket/MyWork.jar arg1 arg2 arg3
```
```
"s3://amzn-s3-demo-bucket/MyWork.jar,arg1,arg2,arg3"
```
## 示例
以下是该对象类型的示例。该示例使用较旧版本的 Amazon EMR。验证该示例是否适合您使用的 Amazon EMR 集群版本。
该对象引用您将在同一管道定义文件中定义的其他三个对象。`MyEmrCluster` 为 `EmrCluster` 对象，`MyS3Input` 和 `MyS3Output` 为 `S3DataNode` 对象。
**注意**
在此示例中，您可以将 `step` 字段替换为所需集群字符串，它可以是 Pig 脚本、Hadoop 流式集群、您自己的自定义 JAR (包括其参数) 等。
Hadoop 2.x (AMI 3.x)
```
{
"id" : "MyEmrActivity",
"type" : "EmrActivity",
"runsOn" : { "ref" : "MyEmrCluster" },
"preStepCommand" : "scp remoteFiles localFiles",
"step" : ["s3://amzn-s3-demo-bucket/myPath/myStep.jar,firstArg,secondArg,-files,s3://amzn-s3-demo-bucket/myPath/myFile.py,-input,s3://myinputbucket/path,-output,s3://myoutputbucket/path,-mapper,myFile.py,-reducer,reducerName","s3://amzn-s3-demo-bucket/myPath/myotherStep.jar,..."],
"postStepCommand" : "scp localFiles remoteFiles",
"input" : { "ref" : "MyS3Input" },
"output" : { "ref" : "MyS3Output" }
}
```
**注意**
要通过一个步骤将参数传递给应用程序，您需要在脚本路径中指定区域，如以下示例所示：此外，您可能需要对传递的参数进行转义。例如，如果您使用 `script-runner.jar` 运行一个 Shell 脚本，并且需要将参数传递给该脚本，则必须对用于分隔参数的逗号进行转义。以下步骤槽介绍了如何执行此操作：
```
"step" : "s3://eu-west-1.elasticmapreduce/libs/script-runner/script-runner.jar,s3://datapipeline/echo.sh,a\\\\,b\\\\,c"
```
此步骤使用 `script-runner.jar` 运行 `echo.sh` Shell 脚本，并将 `a`、`b` 和 `c` 作为单个参数传递给此脚本。由于将从生成的参数中删除第一个转义字符，因此，您可能需要重新转义。例如，如果您将 `File\.gz` 作为参数 (用 JSON 表示)，则可使用 `File\\\\.gz` 对其进行转义。但由于已丢弃第一个转义，因此，您必须使用 `File\\\\\\\\.gz `。
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。您可以明确设置针对该对象的计划以满足该要求，例如，指定 "schedule": \$1"ref": "DefaultSchedule"\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道具有一个计划树 (计划位于主计划中)，您可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如，“日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 在其中运行该作业的 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myEmrCluster Id "\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据的位置。 | 参考对象，例如，“输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如，“onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 参考对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据的位置。 | 参考对象，例如，“输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI，例如 's3: BucketName ///Prefix/ '。 | 字符串 |
| postStepCommand | 所有步骤完成之后运行的 Shell 脚本。要指定多个脚本 (最多 255 个)，请添加多个 postStepCommand 字段。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如，“前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| preStepCommand | 在任意步骤运行之前运行的 Shell 脚本。要指定多个脚本 (最多 255 个)，请添加多个 preStepCommand 字段。 | 字符串 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| resizeClusterBefore正在跑步 | 在执行此活动前，重新调整集群的大小，以适应指定为输入或输出的 DynamoDB 表。 如果您`EmrActivity`使用`DynamoDBDataNode`作为输入或输出数据节点，并且将设置为`TRUE`，则 AWS Data Pipeline 开始使用`m3.xlarge`实例类型。`resizeClusterBeforeRunning`这将使用 `m3.xlarge` 覆盖您的实例类型，从而可能会增加您的月度成本。 | 布尔值 |
| resizeClusterMax实例 | 调整大小算法可以请求的最大实例数的限制。 | 整数 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 您可以通过计划类型指定应在间隔开头还是结尾计划管道定义中的对象。值包括：cron、ondemand 和 timeseries。timeseries 计划表示在每个间隔结尾计划实例。cron 计划表示在每个间隔开头计划实例。ondemand 计划让您可以在每次激活时运行一次管道。您不需要克隆或重新创建管道以再次运行它。如果您使用 ondemand 计划，则必须在默认对象中指定它，并且该计划必须是在管道中为对象指定的唯一 scheduleType。要使用 ondemand 管道，请为每个后续运行调用 ActivatePipeline 操作。 | 枚举 |
| step | 集群要运行的一个或多个步骤。要指定多个步骤 (最多 255 个)，请添加多个步骤字段。请在 JAR 名称后面使用以逗号分隔的参数，例如，“s3://amzn-s3-demo-bucket/MyWork.jar,arg1,arg2,arg3”。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 参考对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 Amazon EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用于创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1“ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [CopyActivity](dp-object-copyactivity.md)
+ [EmrCluster](dp-object-emrcluster.md)
# HadoopActivity
在集群上运行 MapReduce 作业。集群可以是管理的 EMR 集群， AWS Data Pipeline 也可以是其他资源（如果您使用）。 TaskRunner HadoopActivity 当你想并行运行工作时使用。这允许您使用 YARN 框架的调度资源或 Hadoop 1 中的 MapReduce 资源协商器。如果您想使用 Amazon EMR 步骤操作来按顺序运行工作，您仍可使用 [EmrActivity](dp-object-emractivity.md)。
## 示例
**HadoopActivity 使用由管理的 EMR 集群 AWS Data Pipeline**
以下 HadoopActivity 对象使用 EmrCluster 资源来运行程序：
```
{
"name": "MyHadoopActivity",
"schedule": {"ref": "ResourcePeriod"},
"runsOn": {"ref": “MyEmrCluster”},
"type": "HadoopActivity",
"preActivityTaskConfig":{"ref":"preTaskScriptConfig”},
"jarUri": "/home/hadoop/contrib/streaming/hadoop-streaming.jar",
"argument": [
"-files",
“s3://elasticmapreduce/samples/wordcount/wordSplitter.py“,
"-mapper",
"wordSplitter.py",
"-reducer",
"aggregate",
"-input",
"s3://elasticmapreduce/samples/wordcount/input/",
"-output",
“s3://amzn-s3-demo-bucket/MyHadoopActivity/#{@pipelineId}/#{format(@scheduledStartTime,'YYYY-MM-dd')}"
],
"maximumRetries": "0",
"postActivityTaskConfig":{"ref":"postTaskScriptConfig”},
"hadoopQueue" : “high”
}
```
以下是相应的*MyEmrCluster*，它在 YARN 中为基于 Hadoop FairScheduler 2 的和队列配置了和队列： AMIs
```
{
"id" : "MyEmrCluster",
"type" : "EmrCluster",
"hadoopSchedulerType" : "PARALLEL_FAIR_SCHEDULING",
“amiVersion” : “3.7.0”,
"bootstrapAction" : ["s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop,-z,yarn.scheduler.capacity.root.queues=low\,high\,default,-z,yarn.scheduler.capacity.root.high.capacity=50,-z,yarn.scheduler.capacity.root.low.capacity=10,-z,yarn.scheduler.capacity.root.default.capacity=30”]
}
```
这是 EmrCluster 你在 Hadoop 1 FairScheduler 中用来配置的：
```
{
"id": "MyEmrCluster",
"type": "EmrCluster",
"hadoopSchedulerType": "PARALLEL_FAIR_SCHEDULING",
"amiVersion": "2.4.8",
"bootstrapAction": "s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop,-m,mapred.queue.names=low\\\\,high\\\\,default,-m,mapred.fairscheduler.poolnameproperty=mapred.job.queue.name"
}
```
以下是基 CapacityScheduler 于 Hadoop 2 的 EmrCluster 配置： AMIs
```
{
"id": "MyEmrCluster",
"type": "EmrCluster",
"hadoopSchedulerType": "PARALLEL_CAPACITY_SCHEDULING",
"amiVersion": "3.7.0",
"bootstrapAction": "s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop,-z,yarn.scheduler.capacity.root.queues=low\\\\,high,-z,yarn.scheduler.capacity.root.high.capacity=40,-z,yarn.scheduler.capacity.root.low.capacity=60"
}
```
**HadoopActivity 使用现有 EMR 集群**
在此示例中，您使用工作组和在现有 TaskRunner EMR 集群上运行程序。以下管道定义用 HadoopActivity 于：
+ 仅在*myWorkerGroup*资源上运行 MapReduce 程序。有关工作线程组的更多信息，请参阅[使用任务运行程序在现有资源上执行工作](dp-how-task-runner-user-managed.md)。
+ 运行 preActivityTask Config and Con postActivityTask fig
```
{
"objects": [
{
"argument": [
"-files",
"s3://elasticmapreduce/samples/wordcount/wordSplitter.py",
"-mapper",
"wordSplitter.py",
"-reducer",
"aggregate",
"-input",
"s3://elasticmapreduce/samples/wordcount/input/",
"-output",
"s3://amzn-s3-demo-bucket/MyHadoopActivity/#{@pipelineId}/#{format(@scheduledStartTime,'YYYY-MM-dd')}"
],
"id": "MyHadoopActivity",
"jarUri": "/home/hadoop/contrib/streaming/hadoop-streaming.jar",
"name": "MyHadoopActivity",
"type": "HadoopActivity"
},
{
"id": "SchedulePeriod",
"startDateTime": "start_datetime",
"name": "SchedulePeriod",
"period": "1 day",
"type": "Schedule",
"endDateTime": "end_datetime"
},
{
"id": "ShellScriptConfig",
"scriptUri": "s3://amzn-s3-demo-bucket/scripts/preTaskScript.sh",
"name": "preTaskScriptConfig",
"scriptArgument": [
"test",
"argument"
],
"type": "ShellScriptConfig"
},
{
"id": "ShellScriptConfig",
"scriptUri": "s3://amzn-s3-demo-bucket/scripts/postTaskScript.sh",
"name": "postTaskScriptConfig",
"scriptArgument": [
"test",
"argument"
],
"type": "ShellScriptConfig"
},
{
"id": "Default",
"scheduleType": "cron",
"schedule": {
"ref": "SchedulePeriod"
},
"name": "Default",
"pipelineLogUri": "s3://amzn-s3-demo-bucket/logs/2015-05-22T18:02:00.343Z642f3fe415",
"maximumRetries": "0",
"workerGroup": "myWorkerGroup",
"preActivityTaskConfig": {
"ref": "preTaskScriptConfig"
},
"postActivityTaskConfig": {
"ref": "postTaskScriptConfig"
}
}
]
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| jarUri | JAR 在 Amazon S3 中的位置或要运行的集群的本地文件系统 HadoopActivity。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行此作业的 EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myEmrCluster Id "\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| argument | 要传递给 JAR 的参数。 | 字符串 |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| hadoopQueue | 将在其上提交活动的 Hadoop 计划程序队列名。 | 字符串 |
| input | 输入数据的位置。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| mainClass | 你正在执行的 JAR 的主类 HadoopActivity。 | 字符串 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据的位置。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| postActivityTaskConfig | 要运行的活动后配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “postActivityTaskConfig”：\$1“ref”:” myShellScript ConfigId “\$1 |
| preActivityTaskConfig | 要运行的活动前配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “preActivityTaskConfig”：\$1“ref”:” myShellScript ConfigId “\$1 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [CopyActivity](dp-object-copyactivity.md)
+ [EmrCluster](dp-object-emrcluster.md)
# HiveActivity
在 EMR 集群上运行 Hive 查询。`HiveActivity` 使您能够更轻松地设置 Amazon EMR 活动，并且将自动基于来自 Amazon S3 或 Amazon RDS 的输入数据创建 Hive 表。您只需要指定要在源数据上运行的 HiveQL 即可。 AWS Data Pipeline 根据`HiveActivity`对象中的输入字段自动创建带有`${input1}``${input2}`、等的 Hive 表。
对于 Amazon S3 输入，`dataFormat` 字段用于创建 Hive 列名。
对于 MySQL（Amazon RDS）输入，SQL 查询的列名用于创建 Hive 列名。
**注意**
此活动使用 Hive [CSV Serde](https://cwiki.apache.org/confluence/display/Hive/CSV+Serde)。
## 示例
以下是该对象类型的示例。该对象引用您在同一管道定义文件中定义的三个其他对象。`MySchedule` 为 `Schedule` 对象，`MyS3Input` 和 `MyS3Output` 为数据节点对象。
```
{
"name" : "ProcessLogData",
"id" : "MyHiveActivity",
"type" : "HiveActivity",
"schedule" : { "ref": "MySchedule" },
"hiveScript" : "INSERT OVERWRITE TABLE ${output1} select host,user,time,request,status,size from ${input1};",
"input" : { "ref": "MyS3Input" },
"output" : { "ref": "MyS3Output" },
"runsOn" : { "ref": "MyEmrCluster" }
}
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。您可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道具有一个计划树 (计划位于主计划中)，您可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| hiveScript | 要运行的 Hive 脚本。 | 字符串 |
| scriptUri | 要运行 Hive 脚本的位置 (例如，s3://scriptLocation)。 | 字符串 |
****
| 所需的组 | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 在其中运行该 HiveActivity 的 EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myEmrCluster Id "\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
| input | 输入数据源。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| output | 输出数据源。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| hadoopQueue | 将在其上提交作业的 Hadoop 计划程序队列名。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| postActivityTaskConfig | 要运行的活动后配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “postActivityTaskConfig”: \$1“ref”:” myShellScript ConfigId “\$1 |
| preActivityTaskConfig | 要运行的活动前配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “preActivityTaskConfig”: \$1“ref”:” myShellScript ConfigId “\$1 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| resizeClusterBefore正在跑步 | 在执行此活动前，重新调整集群的大小，以适应指定为输入或输出的 DynamoDB 数据节点。 如果您的活动使用`DynamoDBDataNode`作为输入或输出数据节点，并且将设置`resizeClusterBeforeRunning`为`TRUE`，则 AWS Data Pipeline 开始使用`m3.xlarge`实例类型。这将使用 `m3.xlarge` 覆盖您的实例类型，从而可能会增加您的月度成本。 | 布尔值 |
| resizeClusterMax实例 | 调整大小算法可以请求的最大实例数的限制。 | 整数 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| scriptVariable | 指定在运行脚本时要传递给 Hive 的 Amazon EMR 的脚本变量。例如，以下示例脚本变量将 SAMPLE 和 FILTER\$1DATE 变量传递到 Hive：SAMPLE=s3://elasticmapreduce/samples/hive-ads 和 FILTER\$1DATE=\$1\$1format(@scheduledStartTime,'YYYY-MM-dd')\$1%。此字段接受多个值，可与 script 和 scriptUri 字段结合使用。此外，scriptVariable 将起作用，不管 stage 设置为 true 还是 false。在使用 AWS Data Pipeline 表达式和函数将动态值发送到 Hive 时，此字段特别有用。 | 字符串 |
| stage | 确定是在运行脚本之前还是之后启用暂存。不可对 Hive 11 使用，因此，请使用 Amazon EMR AMI 版本 3.2.0 或更高版本。 | 布尔值 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 Amazon EMR 步骤日志。 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
# HiveCopyActivity
在 EMR 集群上运行 Hive 查询。`HiveCopyActivity` 可让您更轻松地在 DynamoDB 表之间复制数据。`HiveCopyActivity` 接受 HiveQL 语句以在列和行级别筛选来自 DynamoDB 的输入数据。
## 示例
以下示例说明如何使用 `HiveCopyActivity` 和 `DynamoDBExportDataFormat` 将数据从一个 `DynamoDBDataNode` 复制到另一个 DynamoDBDataNode，并基于时间戳筛选数据。
```
{
"objects": [
{
"id" : "DataFormat.1",
"name" : "DataFormat.1",
"type" : "DynamoDBExportDataFormat",
"column" : "timeStamp BIGINT"
},
{
"id" : "DataFormat.2",
"name" : "DataFormat.2",
"type" : "DynamoDBExportDataFormat"
},
{
"id" : "DynamoDBDataNode.1",
"name" : "DynamoDBDataNode.1",
"type" : "DynamoDBDataNode",
"tableName" : "item_mapped_table_restore_temp",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.1" }
},
{
"id" : "DynamoDBDataNode.2",
"name" : "DynamoDBDataNode.2",
"type" : "DynamoDBDataNode",
"tableName" : "restore_table",
"region" : "us_west_1",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.2" }
},
{
"id" : "EmrCluster.1",
"name" : "EmrCluster.1",
"type" : "EmrCluster",
"schedule" : { "ref" : "ResourcePeriod" },
"masterInstanceType" : "m1.xlarge",
"coreInstanceCount" : "4"
},
{
"id" : "HiveTransform.1",
"name" : "Hive Copy Transform.1",
"type" : "HiveCopyActivity",
"input" : { "ref" : "DynamoDBDataNode.1" },
"output" : { "ref" : "DynamoDBDataNode.2" },
"schedule" :{ "ref" : "ResourcePeriod" },
"runsOn" : { "ref" : "EmrCluster.1" },
"filterSql" : "`timeStamp` > unix_timestamp(\"#{@scheduledStartTime}\", \"yyyy-MM-dd'T'HH:mm:ss\")"
},
{
"id" : "ResourcePeriod",
"name" : "ResourcePeriod",
"type" : "Schedule",
"period" : "1 Hour",
"startDateTime" : "2013-06-04T00:00:00",
"endDateTime" : "2013-06-04T01:00:00"
}
]
}
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 指定在其上运行的集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| filterSql | Hive SQL 语句片段，用于筛选要复制的 DynamoDB 或 Amazon S3 数据的子集。过滤器应仅包含谓词，不能以WHERE子句开头，因为它是自动 AWS Data Pipeline 添加的。 | 字符串 |
| input | 输入数据源。这必须是 S3DataNode 或 DynamoDBDataNode。如果您使用 DynamoDBNode，请指定 DynamoDBExportDataFormat。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据源。如果输入是 S3DataNode，则这必须是 DynamoDBDataNode。否则，这可以是 S3DataNode 或 DynamoDBDataNode。如果您使用 DynamoDBNode，请指定 DynamoDBExportDataFormat。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI，例如 's3://BucketName/Key/'。 | 字符串 |
| postActivityTaskConfig | 要运行的活动后配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “postActivityTaskConfig”：\$1“ref”:” myShellScript ConfigId “\$1 |
| preActivityTaskConfig | 要运行的活动前配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如 “preActivityTaskConfig”：\$1“ref”:” myShellScript ConfigId “\$1 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| resizeClusterBefore正在跑步 | 在执行此活动前，重新调整集群的大小，以适应指定为输入或输出的 DynamoDB 数据节点。 如果您的活动使用`DynamoDBDataNode`作为输入或输出数据节点，并且将设置`resizeClusterBeforeRunning`为`TRUE`，则 AWS Data Pipeline 开始使用`m3.xlarge`实例类型。这将使用 `m3.xlarge` 覆盖您的实例类型，从而可能会增加您的月度成本。 | 布尔值 |
| resizeClusterMax实例 | 调整大小算法可以请求的最大实例数的限制 | 整数 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 Amazon EMR 步骤日志。 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
# PigActivity
PigActivity 为中的 Pig 脚本提供原生支持， AWS Data Pipeline 无需使用`ShellCommandActivity`或`EmrActivity`。此外，还 PigActivity 支持数据暂存。在将 stage 字段设置为 true 时， AWS Data Pipeline 会在 Pig 中将输入数据暂存为架构，而无需用户编写其他代码。
## 示例
以下示例管道说明如何使用 `PigActivity`。该示例管道执行以下步骤：
+ MyPigActivity1 从 Amazon S3 加载数据并运行一个 Pig 脚本，该脚本选择几列数据并将其上传到 Amazon S3。
+ MyPigActivity2 加载第一个输出，选择几列三行数据，然后将其作为第二个输出上传到 Amazon S3。
+ MyPigActivity3 加载第二个输出数据，在 Amazon RDS 中插入两行数据，仅插入名为 “第五行” 的列。
+ MyPigActivity4 加载亚马逊 RDS 数据，选择第一行数据，然后将其上传到 Amazon S3。
```
{
"objects": [
{
"id": "MyInputData1",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"directoryPath": "s3://amzn-s3-demo-bucket/pigTestInput",
"name": "MyInputData1",
"dataFormat": {
"ref": "MyInputDataType1"
},
"type": "S3DataNode"
},
{
"id": "MyPigActivity4",
"scheduleType": "CRON",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"input": {
"ref": "MyOutputData3"
},
"pipelineLogUri": "s3://amzn-s3-demo-bucket/path/",
"name": "MyPigActivity4",
"runsOn": {
"ref": "MyEmrResource"
},
"type": "PigActivity",
"dependsOn": {
"ref": "MyPigActivity3"
},
"output": {
"ref": "MyOutputData4"
},
"script": "B = LIMIT ${input1} 1; ${output1} = FOREACH B GENERATE one;",
"stage": "true"
},
{
"id": "MyPigActivity3",
"scheduleType": "CRON",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"input": {
"ref": "MyOutputData2"
},
"pipelineLogUri": "s3://amzn-s3-demo-bucket/path",
"name": "MyPigActivity3",
"runsOn": {
"ref": "MyEmrResource"
},
"script": "B = LIMIT ${input1} 2; ${output1} = FOREACH B GENERATE Fifth;",
"type": "PigActivity",
"dependsOn": {
"ref": "MyPigActivity2"
},
"output": {
"ref": "MyOutputData3"
},
"stage": "true"
},
{
"id": "MyOutputData2",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"name": "MyOutputData2",
"directoryPath": "s3://amzn-s3-demo-bucket/PigActivityOutput2",
"dataFormat": {
"ref": "MyOutputDataType2"
},
"type": "S3DataNode"
},
{
"id": "MyOutputData1",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"name": "MyOutputData1",
"directoryPath": "s3://amzn-s3-demo-bucket/PigActivityOutput1",
"dataFormat": {
"ref": "MyOutputDataType1"
},
"type": "S3DataNode"
},
{
"id": "MyInputDataType1",
"name": "MyInputDataType1",
"column": [
"First STRING",
"Second STRING",
"Third STRING",
"Fourth STRING",
"Fifth STRING",
"Sixth STRING",
"Seventh STRING",
"Eighth STRING",
"Ninth STRING",
"Tenth STRING"
],
"inputRegEx": "^(\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+)",
"type": "RegEx"
},
{
"id": "MyEmrResource",
"region": "us-east-1",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"keyPair": "example-keypair",
"masterInstanceType": "m1.small",
"enableDebugging": "true",
"name": "MyEmrResource",
"actionOnTaskFailure": "continue",
"type": "EmrCluster"
},
{
"id": "MyOutputDataType4",
"name": "MyOutputDataType4",
"column": "one STRING",
"type": "CSV"
},
{
"id": "MyOutputData4",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"directoryPath": "s3://amzn-s3-demo-bucket/PigActivityOutput3",
"name": "MyOutputData4",
"dataFormat": {
"ref": "MyOutputDataType4"
},
"type": "S3DataNode"
},
{
"id": "MyOutputDataType1",
"name": "MyOutputDataType1",
"column": [
"First STRING",
"Second STRING",
"Third STRING",
"Fourth STRING",
"Fifth STRING",
"Sixth STRING",
"Seventh STRING",
"Eighth STRING"
],
"columnSeparator": "*",
"type": "Custom"
},
{
"id": "MyOutputData3",
"username": "___",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"insertQuery": "insert into #{table} (one) values (?)",
"name": "MyOutputData3",
"*password": "___",
"runsOn": {
"ref": "MyEmrResource"
},
"connectionString": "jdbc:mysql://example-database-instance:3306/example-database",
"selectQuery": "select * from #{table}",
"table": "example-table-name",
"type": "MySqlDataNode"
},
{
"id": "MyOutputDataType2",
"name": "MyOutputDataType2",
"column": [
"Third STRING",
"Fourth STRING",
"Fifth STRING",
"Sixth STRING",
"Seventh STRING",
"Eighth STRING"
],
"type": "TSV"
},
{
"id": "MyPigActivity2",
"scheduleType": "CRON",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"input": {
"ref": "MyOutputData1"
},
"pipelineLogUri": "s3://amzn-s3-demo-bucket/path",
"name": "MyPigActivity2",
"runsOn": {
"ref": "MyEmrResource"
},
"dependsOn": {
"ref": "MyPigActivity1"
},
"type": "PigActivity",
"script": "B = LIMIT ${input1} 3; ${output1} = FOREACH B GENERATE Third, Fourth, Fifth, Sixth, Seventh, Eighth;",
"output": {
"ref": "MyOutputData2"
},
"stage": "true"
},
{
"id": "MyEmrResourcePeriod",
"startDateTime": "2013-05-20T00:00:00",
"name": "MyEmrResourcePeriod",
"period": "1 day",
"type": "Schedule",
"endDateTime": "2013-05-21T00:00:00"
},
{
"id": "MyPigActivity1",
"scheduleType": "CRON",
"schedule": {
"ref": "MyEmrResourcePeriod"
},
"input": {
"ref": "MyInputData1"
},
"pipelineLogUri": "s3://amzn-s3-demo-bucket/path",
"scriptUri": "s3://amzn-s3-demo-bucket/script/pigTestScipt.q",
"name": "MyPigActivity1",
"runsOn": {
"ref": "MyEmrResource"
},
"scriptVariable": [
"column1=First",
"column2=Second",
"three=3"
],
"type": "PigActivity",
"output": {
"ref": "MyOutputData1"
},
"stage": "true"
}
]
}
```
`pigTestScript.q` 的内容如下所示。
```
B = LIMIT ${input1} $three; ${output1} = FOREACH B GENERATE $column1, $column2, Third, Fourth, Fifth, Sixth, Seventh, Eighth;
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。用户必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。用户可以通过在对象上显式设置时间表来满足此要求，例如，指定 “schedule”: \$1"ref”: "DefaultSchedule“\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道有一个计划树 (计划位于主计划中)，用户可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如，“日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| script | 要运行的 Pig 脚本。 | 字符串 |
| scriptUri | 要运行的 Pig 脚本的位置 (例如，s3://scriptLocation)。 | 字符串 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行它的 EMR 集群。 PigActivity | 参考对象，例如 “runson”：\$1“ref”:” myEmrCluster Id "\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据源。 | 参考对象，例如，“输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如，“onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 参考对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据源。 | 参考对象，例如，“输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| postActivityTaskConfig | 要运行的活动后配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如，“postActivityTaskConfig”: \$1“ref”:” myShellScript ConfigId “\$1 |
| preActivityTaskConfig | 要运行的活动前配置脚本。这由 Amazon S3 中 Shell 脚本的 URI 和参数列表组成。 | 参考对象，例如，“preActivityTaskConfig”: \$1“ref”:” myShellScript ConfigId “\$1 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如，“前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| resizeClusterBefore正在跑步 | 在执行此活动前，重新调整集群的大小，以适应指定为输入或输出的 DynamoDB 数据节点。 如果您的活动使用`DynamoDBDataNode`作为输入或输出数据节点，并且将设置`resizeClusterBeforeRunning`为`TRUE`，则 AWS Data Pipeline 开始使用`m3.xlarge`实例类型。这将使用 `m3.xlarge` 覆盖您的实例类型，从而可能会增加您的月度成本。 | 布尔值 |
| resizeClusterMax实例 | 调整大小算法可以请求的最大实例数的限制。 | 整数 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。时间序列风格计划表示在每次间隔的结尾计划实例，而 Cron 风格计划表示应在每次间隔的开头计划实例。按需计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用按需计划，则必须在默认对象中指定它，并且必须是在管道中为对象指定的唯一 scheduleType。要使用按需管道，您只需为后续每次运行调用该 ActivatePipeline 操作即可。值包括：cron、ondemand 和 timeseries。 | 枚举 |
| scriptVariable | 要传递到 Pig 脚本的参数。您可以将 scriptVariable 与 script 或 scriptUri 一起使用。 | 字符串 |
| stage | 确定是否启用暂存功能并允许您的 Pig 脚本访问分阶段数据表，例如 \$1 \$1INPUT1\$1 和 \$1 \$1\$1。OUTPUT1 | 布尔值 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如，“ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 参考对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 Amazon EMR 步骤日志。 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用于创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1“ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
# RedshiftCopyActivity
将数据从 DynamoDB 或 Amazon S3 复制到 Amazon Redshift。您可以将数据加载到新表中，或轻松地将数据并入现有表中。
下面概括了使用 `RedshiftCopyActivity` 的使用案例：
1. 首先使用 AWS Data Pipeline 在 Amazon S3 中暂存您的数据。
1. 使用 `RedshiftCopyActivity` 将数据从 Amazon RDS 和 Amazon EMR 移动到 Amazon Redshift。
这可让您将数据加载到 Amazon Redshift 中，您可以在此处对数据进行分析。
1. 使用 [SqlActivity](dp-object-sqlactivity.md) 可以对已加载到 Amazon Redshift 中的数据执行 SQL 查询。
此外，借助 `RedshiftCopyActivity`，您可以使用 `S3DataNode`，因为它支持清单文件。有关更多信息，请参阅 [S3 DataNode](dp-object-s3datanode.md)。
## 示例
以下是该对象类型的示例。
为了确保格式转换，本示例在 `commandOptions` 中使用 [EMPTYASNULL](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html#copy-emptyasnull) 和 [IGNOREBLANKLINES](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html#copy-ignoreblanklines) 特殊转换参数。有关信息，请参阅 *Amazon Redshift 数据库开发人员指南*中的[数据转换参数](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html)。
```
{
"id" : "S3ToRedshiftCopyActivity",
"type" : "RedshiftCopyActivity",
"input" : { "ref": "MyS3DataNode" },
"output" : { "ref": "MyRedshiftDataNode" },
"insertMode" : "KEEP_EXISTING",
"schedule" : { "ref": "Hour" },
"runsOn" : { "ref": "MyEc2Resource" },
"commandOptions": ["EMPTYASNULL", "IGNOREBLANKLINES"]
}
```
以下示例管道定义说明了一个使用 `APPEND` 插入模式的活动：
```
{
"objects": [
{
"id": "CSVId1",
"name": "DefaultCSV1",
"type": "CSV"
},
{
"id": "RedshiftDatabaseId1",
"databaseName": "dbname",
"username": "user",
"name": "DefaultRedshiftDatabase1",
"*password": "password",
"type": "RedshiftDatabase",
"clusterId": "redshiftclusterId"
},
{
"id": "Default",
"scheduleType": "timeseries",
"failureAndRerunMode": "CASCADE",
"name": "Default",
"role": "DataPipelineDefaultRole",
"resourceRole": "DataPipelineDefaultResourceRole"
},
{
"id": "RedshiftDataNodeId1",
"schedule": {
"ref": "ScheduleId1"
},
"tableName": "orders",
"name": "DefaultRedshiftDataNode1",
"createTableSql": "create table StructuredLogs (requestBeginTime CHAR(30) PRIMARY KEY DISTKEY SORTKEY, requestEndTime CHAR(30), hostname CHAR(100), requestDate varchar(20));",
"type": "RedshiftDataNode",
"database": {
"ref": "RedshiftDatabaseId1"
}
},
{
"id": "Ec2ResourceId1",
"schedule": {
"ref": "ScheduleId1"
},
"securityGroups": "MySecurityGroup",
"name": "DefaultEc2Resource1",
"role": "DataPipelineDefaultRole",
"logUri": "s3://myLogs",
"resourceRole": "DataPipelineDefaultResourceRole",
"type": "Ec2Resource"
},
{
"id": "ScheduleId1",
"startDateTime": "yyyy-mm-ddT00:00:00",
"name": "DefaultSchedule1",
"type": "Schedule",
"period": "period",
"endDateTime": "yyyy-mm-ddT00:00:00"
},
{
"id": "S3DataNodeId1",
"schedule": {
"ref": "ScheduleId1"
},
"filePath": "s3://datapipeline-us-east-1/samples/hive-ads-samples.csv",
"name": "DefaultS3DataNode1",
"dataFormat": {
"ref": "CSVId1"
},
"type": "S3DataNode"
},
{
"id": "RedshiftCopyActivityId1",
"input": {
"ref": "S3DataNodeId1"
},
"schedule": {
"ref": "ScheduleId1"
},
"insertMode": "APPEND",
"name": "DefaultRedshiftCopyActivity1",
"runsOn": {
"ref": "Ec2ResourceId1"
},
"type": "RedshiftCopyActivity",
"output": {
"ref": "RedshiftDataNodeId1"
}
}
]
}
```
`APPEND` 操作向表中添加项，无论主键或排序键如何。例如，如果您有以下表，则可追加具有相同的 ID 和用户值的记录。
```
ID(PK) USER
1 aaa
2 bbb
```
您可以追加具有相同的 ID 和用户值的记录：
```
ID(PK) USER
1 aaa
2 bbb
1 aaa
```
**注意**
如果 `APPEND` 操作中断并重试，生成的重新运行管道可能会从开始位置追加。这可能会导致进一步复制，因此，您应了解此行为，尤其是当您有任何计算行数的逻辑时。
有关教程，请参阅 [使用将数据复制到亚马逊 Redshift AWS Data Pipeline](dp-copydata-redshift.md)。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| insertMode | 确定 AWS Data Pipeline 如何处理目标表中与要加载的数据中的行重叠的预先存在的数据。 有效值包括：`KEEP_EXISTING`、`OVERWRITE_EXISTING`、`TRUNCATE` 和 `APPEND`。 `KEEP_EXISTING` 添加新行到表中，同时保留任何现有的行不变。 `KEEP_EXISTING` 和 ` OVERWRITE_EXISTING` 使用主键、排序键和分配键来识别哪些传入行与现有行匹配。请参阅 Amazon Redshift *数据库开发人员指南*中的[更新和插入新数据](https://docs.aws.amazon.com/redshift/latest/dg/t_updating-inserting-using-staging-tables-.html)。 `TRUNCATE` 先删除目标表中的所有数据，然后写入新数据。 `APPEND` 会将所有记录添加到 Redshift 表的结尾。`APPEND` 不需要主键、分配键或排序键，因此会附加可能存在重复的项。 | 枚举 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。 指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。 在大多数情况下，我们建议将计划引用放在默认管道对象上，以便所有对象继承该计划。例如，您可以通过指定 `"schedule": {"ref": "DefaultSchedule"}`，明确地针对该对象设置计划。 如果您的管道中的主计划包含嵌套计划，则可以创建具有计划引用的父对象。 有关示例可选计划配置的更多信息，请参阅[计划](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 引用对象，例如： "schedule":\$1"ref":"myScheduleId"\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| commandOptions | 获取在 `COPY` 操作期间传递到 Amazon Redshift 数据节点的参数。有关更多信息，请参阅 Amazon Redshift *数据库开发人员指南*中的 [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html)。 在加载表时，`COPY` 会尝试将字符串隐式转换为目标列的数据类型。如果您收到错误或有其他转换需求，则除了自动发生的默认数据转换之外，您还可以指定其他转换参数。有关信息，请参阅 Amazon Redshift *数据库开发人员指南*中的[数据转换参数](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html)。 如果数据格式与输入或输出数据节点关联，则忽略提供的参数。 由于复制操作首先使用 `COPY` 将数据插入暂存表，然后使用 `INSERT` 命令将数据从暂存表复制到目标表中，一些 `COPY` 参数不适用，例如 `COPY` 命令启用表上自动压缩的功能。如果需要压缩，请向 `CREATE TABLE` 语句添加列编码详细信息。 此外，在某些需要从 Amazon Redshift 集群卸载数据和在 Amazon S3 中创建文件的情况下，`RedshiftCopyActivity` 依赖 Amazon Redshift 的 `UNLOAD` 操作。 为提高复制和卸载过程中的性能，请从 `UNLOAD` 命令指定 `PARALLEL OFF` 参数。有关更多信息，请参阅 Amazon Redshift *数据库开发人员指南*中的 [UNLOAD](https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html)。 | 字符串 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 引用对象："dependsOn":\$1"ref":"myActivityId"\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据节点。数据源可以是 Amazon S3、DynamoDB 或 Amazon Redshift。 | 引用对象： "input":\$1"ref":"myDataNodeId"\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 引用对象："onFail":\$1"ref":"myActionId"\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象： "onLateAction":\$1"ref":"myActionId"\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 引用对象： "onSuccess":\$1"ref":"myActionId"\$1 |
| output | 输出数据节点。输出位置可以是 Amazon S3 或 Amazon Redshift。 | 引用对象： "output":\$1"ref":"myDataNodeId"\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象："parent":\$1"ref":"myBaseObjectId"\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 引用对象："precondition":\$1"ref":"myPreconditionId"\$1 |
| 队列 | 对应于 Amazon Redshift 中的 `query_group ` 设置，这允许您根据放置在队列中的位置分配并优先处理并发活动。 Amazon Redshift 将同时连接的数量限制为 15。有关更多信息，请参阅 Amazon RDS *数据库开发人员指南*中的[向队列分配查询](https://docs.aws.amazon.com/AmazonRDS/latest/DeveloperGuide/cm-c-executing-queries.html)。 | 字符串 |
| reportProgressTimeout | 远程工作对 `reportProgress` 的连续调用的超时时间。 如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 允许您指定是否计划管道中的对象。值包括：`cron`、`ondemand` 和 `timeseries`。 `timeseries` 计划表示在每个间隔结束时计划实例。 `Cron` 计划表示在每个间隔开始时计划实例。 `ondemand` 计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。 要使用 `ondemand` 管道，请为每个后续运行调用 `ActivatePipeline` 操作。 如果您使用 `ondemand` 计划，您必须在默认对象中指定它，并且该计划必须是在管道中为对象指定的唯一 `scheduleType`。 | 枚举 |
| transformSql | 用于转换输入数据的 `SQL SELECT` 表达式。 在名为 `staging` 的表上运行 `transformSql` 表达式。 当您从 DynamoDB 或 Amazon S3 复制数据时， AWS Data Pipeline 会创建一个名为“staging”的表，并且最初在该表中加载数据。此表中的数据用于更新目标表。 `transformSql` 的输出架构必须与最终目标表的架构匹配。 如果您指定了 `transformSql` 选项，则会从指定的 SQL 语句创建第二个暂存表。然后，来自这第二个暂存表的数据更新到最终的目标表中。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 引用对象："activeInstances":\$1"ref":"myRunnableObjectId"\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象： "cascadeFailedOn":\$1"ref":"myRunnableObjectId"\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 引用对象： "waitingOn":\$1"ref":"myRunnableObjectId"\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的球体。表示对象在生命周期中的位置。例如，组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# ShellCommandActivity
运行命令或脚本。您可以使用 `ShellCommandActivity` 运行时间序列或类似 Cron 的计划任务。
当 `stage` 字段设置为 true 并与 `S3DataNode` 结合使用时，`ShellCommandActivity` 支持暂存数据概念，这意味着，您可以将数据从 Amazon S3 移至暂存位置（如 Amazon EC2）或您的本地环境，使用脚本和 `ShellCommandActivity` 对数据执行工作，并将数据移回 Amazon S3。
在这种情况下，当 Shell 命令连接到输入 `S3DataNode` 时，Shell 脚本使用 `${INPUT1_STAGING_DIR}`、`${INPUT2_STAGING_DIR}` 及其他字段 (请参阅 `ShellCommandActivity` 输入字段) 直接操作数据。
同样，shell 命令输出可暂存到一个输出目录中，以便通过 `${OUTPUT1_STAGING_DIR}`、 `${OUTPUT2_STAGING_DIR}` 等引用的方式自动推送到 Amazon S3。
这些表达式可作为命令行参数传递到 shell 命令，以供您在数据转换逻辑中使用。
`ShellCommandActivity` 返回 Linux 样式的错误代码和字符串。如果 `ShellCommandActivity` 生成错误，则返回的 `error` 为非零值。
## 示例
以下是该对象类型的示例。
```
{
"id" : "CreateDirectory",
"type" : "ShellCommandActivity",
"command" : "mkdir new-directory"
}
```
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在 `schedule` 间隔的执行中调用。 要设置该对象的依赖项执行顺序，请指定对另一个对象的 `schedule` 引用。 为满足此要求，可在对象上明确设置 `schedule`，例如，指定 `"schedule": {"ref": "DefaultSchedule"}`。 在大多数情况下，最好将 `schedule` 引用放在默认管道对象上，以便所有对象继承该计划。如果管道包含计划树 (计划位于主计划中)，可以创建具有计划引用的父对象。 为了分散负载， AWS Data Pipeline 可以稍微提前创建物理对象，但要按计划运行它们。 有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| 命令 | 要运行的命令。使用 \$1 引用位置参数，使用 scriptArgument 指定命令的参数。此值与任何关联参数必须在从中运行任务运行程序的环境中起作用。 | 字符串 |
| scriptUri | 要下载并作为 shell 命令运行的文件的 Amazon S3 URI 路径。仅指定一个 scriptUri 或 command 字段。scriptUri 不能使用参数，请使用 command。 | 字符串 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行活动或命令的计算资源，例如 Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| workerGroup | 用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在指定开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据的位置。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据的位置。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI，例如 's3://BucketName/Key/'。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| reportProgressTimeout | 远程活动对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 允许您指定应在间隔的开头还是结尾计划您管道定义中的对象。 值为 `cron`、`ondemand` 和 `timeseries`。 如果设置为 `timeseries`，则在每个间隔结束时计划实例。 如果设置为 `Cron`，则在每个间隔开始时计划实例。 如果设置为 `ondemand`，您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果使用 `ondemand` 计划，则在默认对象中指定它，并且该计划必须是在管道中为对象指定的唯一 `scheduleType`。要使用 `ondemand` 管道，请为每个后续运行调用 `ActivatePipeline` 操作。 | 枚举 |
| scriptArgument | 传递到命令所指定命令的 JSON 格式的字符串数组。例如，如果命令是 echo \$11 \$12，请将 scriptArgument 指定为 "param1", "param2"。对于多个自变量和参数，按如下方式传递 scriptArgument： "scriptArgument":"arg1","scriptArgument":"param1","scriptArgument":"arg2","scriptArgument":"param2"。scriptArgument 只能与 command 一起使用；将其与 scriptUri 一起使用会导致错误。 | 字符串 |
| stage | 确定是否启用了暂存并且 Shell 命令有权访问暂存数据变量，例如 \$1\$1INPUT1\$1STAGING\$1DIR\$1 和 \$1\$1OUTPUT1\$1STAGING\$1DIR\$1。 | 布尔值 |
| stderr | 接收来自命令的重定向系统错误消息的 路径。如果您使用 runsOn 字段，则由于运行活动的资源的短期性质，该字段必须为 Amazon S3 路径。不过，如果指定 workerGroup 字段，则允许使用本地文件路径。 | 字符串 |
| stdout | 接收来自命令的重定向输出的 Amazon S3 路径。如果您使用 runsOn 字段，则由于运行活动的资源的短期性质，该字段必须为 Amazon S3 路径。不过，如果指定 workerGroup 字段，则允许使用本地文件路径。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 导致对象失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 Amazon EMR 活动时可用的 Amazon EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 Amazon EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 对象的状态。 | 字符串 |
| @version | 用于创建对象的 AWS Data Pipeline 版本。 | 字符串 |
| @waitingOn | 该对象等待的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象在生命周期中的位置。组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [CopyActivity](dp-object-copyactivity.md)
+ [EmrActivity](dp-object-emractivity.md)
# SqlActivity
在数据库上运行 SQL 查询 (脚本)。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MySqlActivity",
"type" : "SqlActivity",
"database" : { "ref": "MyDatabaseID" },
"script" : "SQLQuery" | "scriptUri" : s3://scriptBucket/query.sql,
"schedule" : { "ref": "MyScheduleID" },
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| database | 要在其上运行提供的 SQL 脚本的数据库。 | 参考对象，例如 “数据库”：\$1"ref”:” myDatabaseId “\$1 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。您必须指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。您可以明确地针对该对象设置计划，例如通过指定 `"schedule": {"ref": "DefaultSchedule"}`。 在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。 如果管道有一个嵌套在主计划中的计划树，则可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 参考对象，例如 “日程安排”：\$1“ref”:” myScheduleId “\$1 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| script | 要运行的 SQL 脚本。您必须指定 script 或 scriptUri。在将脚本存储在 Amazon S3 中时，脚本不会计算为表达式。在将脚本存储在 Amazon S3 中时，为 scriptArgument 指定多个值会很有用。 | 字符串 |
| scriptUri | 一个 URI，指定要在此活动中执行的 SQL 脚本的位置。 | 字符串 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| runsOn | 运行活动或命令的计算资源。例如，Amazon EC2 实例或 Amazon EMR 集群。 | 参考对象，例如 “runson”：\$1“ref”:” myResourceId “\$1 |
| workerGroup | 工作线程组。这可用于路由任务。如果您提供 runsOn 值并且存在 workerGroup，则将忽略 workerGroup | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| dependsOn | 指定与另一个可运行对象的依赖关系。 | 参考对象，例如 “dependSon”：\$1“ref”:” myActivityId “\$1 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| input | 输入数据的位置。 | 参考对象，例如 “输入”：\$1"ref”:” myDataNode Id "\$1 |
| lateAfterTimeout | 自管道的计划开始时间后的时段，对象运行必须在该时段内开始。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 如果在管道预定启动后的时间段内，某个对象尚未计划或仍未完成，则应触发的操作（由 “lateAfterTimeout” 指定）。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| output | 输出数据的位置。这仅适用于从脚本内部进行引用（例如\$1\$1output.tablename\$1），以及通过在输出数据节点中设置 “createTableSql” 来创建输出表。SQL 查询的输出不会写入输出数据节点。 | 参考对象，例如 “输出”：\$1"ref”:” myDataNode Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| pipelineLogUri | 用于上传管道日志的 S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| precondition | (可选) 定义先决条件。在满足所有先决条件之前，数据节点不会标记为“READY”。 | 参考对象，例如 “前提条件”：\$1“ref”:” myPreconditionId “\$1 |
| 队列 | [仅 Amazon Redshift] 对应于 Amazon Redshift 中的 query\$1group 设置，允许您根据在队列中的放置位置来分配并发活动以及确定它们的优先级。Amazon Redshift 将同时连接的数量限制为 15。有关更多信息，请参阅《Amazon Redshift 数据库开发人员指南》中的[向队列分配查询](https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html)。 | 字符串 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scheduleType | 计划类型允许您指定应在间隔的结尾还是开头计划您管道定义中的对象。值包括：`cron`、`ondemand` 和 `timeseries`。 `timeseries` 计划表示在每个间隔结束时计划实例。 `cron` 计划表示在每个间隔开始时计划实例。 `ondemand` 计划让您可以在每次激活时运行一次管道。这意味着，您不需要克隆或重新创建管道以再次运行它。如果您使用 `ondemand` 计划，则必须在默认对象中指定它，并且该计划必须是在管道中为对象指定的唯一 `scheduleType`。要使用 `ondemand` 管道，请为每个后续运行调用 `ActivatePipeline` 操作。 | 枚举 |
| scriptArgument | 脚本的变量列表。或者，您可以直接在脚本字段中放置表达式。在将脚本存储在 Amazon S3 中时，scriptArgument 的多个值会很有用。示例：\$1 \$1format (@ scheduledStartTime、“YY-MM-DD HH: MM: SS”\$1\$1 n \$1 \$1format (plusPeriod (@，“1 天”) scheduledStartTime、“HH: MM: SS”\$1 YY-MM-DD | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 资源
以下是 AWS Data Pipeline 资源对象：
**Topics**
+ [Ec2Resource](dp-object-ec2resource.md)
+ [EmrCluster](dp-object-emrcluster.md)
+ [HttpProxy](dp-object-httpproxy.md)
# Ec2Resource
执行管道活动定义的工作的 Amazon EC2 实例。
AWS Data Pipeline 现在支持 Amazon EC2 实例的 imdsv2，当从实例检索元数据信息时，它使用面向会话的方法来更好地处理身份验证。会话会开始和结束一系列请求，Amazon EC2 实例上运行的软件使用这些请求访问本地存储的 Amazon EC2 实例元数据和凭证。该软件通过向 imdsv2 发出简单的 HTTP PUT 请求来开始会话。IMDSv2 会向 Amazon EC2 实例上运行的软件返回一个秘密令牌，该软件将使用该令牌作为密码来请求元数据 IMDSv2 和证书。
**注意**
要将 IMDSv2 用于您的 Amazon EC2 实例，您需要修改设置，因为默认 AMI 与不兼容。 IMDSv2您可以指定一个新的 AMI 版本，您可以通过以下 SSM 参数检索该版本：`/aws/service/ami-amazon-linux-latest/amzn-ami-hvm-x86_64-ebs`。
有关在您未指定实例的情况下 AWS Data Pipeline 创建的默认 Amazon EC2 实例的信息，请参阅[Amazon Web Services Region 的默认 Amazon EC2 实例](dp-ec2-default-instance-types.md)。
## 示例
**EC2-Classic**
**重要**
只有 2013 年 12 月 4 日之前创建的 AWS 账户支持 EC2-Classic 平台。如果您拥有其中一个账户，则可以选择为 EC2-Classic 网络（而不是 VPC）中的管道创建 EC2Resource 对象。我们强烈建议为您在 VPC 中的所有管道创建资源。此外，如果您在 EC2-Classic 有现有资源，建议您把这些资源迁移到 VPC。
以下示例对象在 EC2-Classic 中启动 EC2 实例（带一些可选字段集）。
```
{
"id" : "MyEC2Resource",
"type" : "Ec2Resource",
"actionOnTaskFailure" : "terminate",
"actionOnResourceFailure" : "retryAll",
"maximumRetries" : "1",
"instanceType" : "m5.large",
"securityGroups" : [
"test-group",
"default"
],
"keyPair" : "my-key-pair"
}
```
**EC2-VPC**
以下示例对象在非默认 VPC 中启动 EC2 实例 (设置了一些可选字段)。
```
{
"id" : "MyEC2Resource",
"type" : "Ec2Resource",
"actionOnTaskFailure" : "terminate",
"actionOnResourceFailure" : "retryAll",
"maximumRetries" : "1",
"instanceType" : "m5.large",
"securityGroupIds" : [
"sg-12345678",
"sg-12345678"
],
"subnetId": "subnet-12345678",
"associatePublicIpAddress": "true",
"keyPair" : "my-key-pair"
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| resourceRole | 控制 Amazon EC2 实例可访问的资源的 IAM 角色。 | 字符串 |
| 角色 | AWS Data Pipeline 用于创建 EC2 实例的 IAM 角色。 | 字符串 |
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。 要设置此对象的依赖项执行顺序，请指定对另一个对象的计划引用。您可以通过下列方式之一来执行该操作： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/datapipeline/latest/DeveloperGuide/dp-object-ec2resource.html) | 引用对象，例如，"schedule":\$1"ref":"myScheduleId"\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| actionOnResource失败 | 在此资源发生资源失败后执行的操作。有效值为 "retryall" 和 "retrynone"。 | 字符串 |
| actionOnTask失败 | 在此资源发生任务失败后执行的操作。有效值为 "continue" 或 "terminate"。 | 字符串 |
| associatePublicIp地址 | 指示是否向实例分配公有 IP 地址。如果实例位于 Amazon EC2 或 Amazon VPC 中，则默认值为 true。否则，默认值为 false。 | 布尔值 |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在指定开始时间内完成的远程活动。 | 周期 |
| availabilityZone | 要在其中启动 Amazon EC2 实例的可用区。 | 字符串 |
| 禁用 IMDSv1 | 默认值为 false，同时启用 IMDSv1 和 IMDSv2。如果你将其设置为 true 那么它就会禁用 IMDSv1 并且只提供 IMDSv2s | 布尔值 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| httpProxy | 客户端用来连接 AWS 服务的代理主机。 | 引用对象，例如， "httpProxy":\$1"ref":"myHttpProxyId"\$1 |
| imageId | 要用于实例的 AMI 的 ID。默认情况下， AWS Data Pipeline 使用 HVM AMI 虚拟化类型。 IDs 使用的特定 AMI 基于区域。您可以通过指定自己选择的 HVM AMI 来覆盖默认 AMI。有关 AMI 类型的更多信息，请参阅《Amazon EC2 用户指南》**中的 [Linux AMI 虚拟化类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/virtualization_types.html)和[查找 Linux AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html)。 | 字符串 |
| initTimeout | 资源启动前要等待的时间长度。 | 周期 |
| instanceCount | 已淘汰。 | 整数 |
| instanceType | 要启动的 Amazon EC2 实例的类型。 | 字符串 |
| keyPair | 密钥对的名称。如果您在未指定密钥对的情况下启动 Amazon EC2 实例，则无法登录该实例。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| minInstanceCount | 已淘汰。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 引用对象，例如， "onFail":\$1"ref":"myActionId"\$1 |
| onLateAction | 在尚未计划对象或对象仍在运行的情况下将触发的操作。 | 引用对象，例如，"onLateAction":\$1"ref":"myActionId"\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 引用对象，例如， "onSuccess":\$1"ref":"myActionId"\$1 |
| parent | 作为槽继承源的当前对象的父项。 | 引用对象，例如， "parent":\$1"ref":"myBaseObjectId"\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI，例如 's3://BucketName/Key/'。 | 字符串 |
| region | 应在其中运行 Amazon EC2 实例的区域的代码。默认情况下，该实例在管道所在的区域中运行。您可以在从属数据集所在的区域中运行实例。 | 枚举 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞并且将进行重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| runAsUser | 要运行的用户 TaskRunner。 | 字符串 |
| runsOn | 禁止在该对象上使用此字段。 | 引用对象，例如，"runsOn":\$1"ref":"myResourceId"\$1 |
| scheduleType | 您可以通过计划类型指定应在间隔开始时、间隔结束时还是按需计划管道定义中的对象。 值为： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/datapipeline/latest/DeveloperGuide/dp-object-ec2resource.html) | 枚举 |
| securityGroupIds | 要用于资源池中的实例的一个或多个 Amazon EC2 安全组的 ID。 | 字符串 |
| securityGroups | 要用于资源池中的实例的一个或多个 Amazon EC2 安全组。 | 字符串 |
| spotBidPrice | 每小时您的 Spot 实例的最高价 (美元)，是一个介于 0 和 20.00 (不含) 的小数值。 | 字符串 |
| subnetId | 要在其中启动实例的 Amazon EC2 子网的 ID。 | 字符串 |
| terminateAfter | 小时数，经过此时间后将终止资源。 | 周期 |
| useOnDemandOnLastAttempt | 在最后一次尝试请求 Spot 实例时，请求的是按需实例而不是 Spot 实例。这可确保如果所有之前的尝试都失败，则最后一次尝试不中断。 | 布尔值 |
| workerGroup | 禁止在该对象上使用此字段。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 引用对象，例如，"activeInstances":\$1"ref":"myRunnableObjectId"\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如，"cascadeFailedOn":\$1"ref":"myRunnableObjectId"\$1 |
| emrStepLog | 仅在尝试 Amazon EMR 活动时可用的步骤日志。 | 字符串 |
| errorId | 该对象失败时显示的错误 ID。 | 字符串 |
| errorMessage | 该对象失败时显示的错误消息。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @failureReason | 资源失败的原因。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试 Amazon EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 此对象在其上处于等待状态的依赖项列表的描述。 | 引用对象，例如， "waitingOn":\$1"ref":"myRunnableObjectId"\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象在生命周期中的位置。组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# EmrCluster
表示 Amazon EMR 集群的配置。[EmrActivity](dp-object-emractivity.md) 和 [HadoopActivity](dp-object-hadoopactivity.md) 使用此对象来启动集群。
**Topics**
+ [调度器](#emrcluster-schedulers)
+ [Amazon EMR 发行版](#dp-emrcluster-release-versions)
+ [Amazon EMR 权限](#w2aac52c17b9c11)
+ [语法](#emrcluster-syntax)
+ [示例](emrcluster-example.md)
+ [另请参阅](#emrcluster-seealso)
## 调度器
计划程序提供了一种方法来在 Hadoop 集群中指定资源分配和作业优先级。管理员或用户可以为各类用户和应用程序选择一个计划程序。计划程序可能使用队列来向用户和应用程序分配资源。您在创建集群时会设置这些队列。随后，您可以将特定类型的工作和用户设为优先于其他工作和用户。这样可以高效地使用集群资源，并允许多个用户将工作提交到集群。有以下三类计划程序可用：
+ [FairScheduler](https://hadoop.apache.org/docs/stable/hadoop-yarn/hadoop-yarn-site/FairScheduler.html)— 尝试在相当长的一段时间内均匀地安排资源。
+ [CapacityScheduler](https://hadoop.apache.org/docs/stable/hadoop-yarn/hadoop-yarn-site/CapacityScheduler.html)— 使用队列允许群集管理员将用户分配到不同优先级和资源分配的队列。
+ Default - 由集群使用 (可由您的站点配置)。
## Amazon EMR 发行版
Amazon EMR 发行版是一组来自大数据生态系统的开源应用程序。每个发行版由您在创建集群时选择让 Amazon EMR 安装和配置的各个大数据应用程序、组件和功能组成。可使用发行版标注指定版本。版本标签的格式是 `emr-x.x.x`。例如 `emr-5.30.0`。基于版本标签 `emr-4.0.0` 及更高版本的 Amazon EMR 集群使用 `releaseLabel` 属性指定 `EmrCluster` 对象的版本标签。早期版本使用 `amiVersion` 属性。
**重要**
使用发布版本 5.22.0 或更高版本创建的所有 Amazon EMR 集群都使用[签名版本 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) 向 Amazon S3 验证请求。某些早期发布版本使用签名版本 2。对签名版本 2 的支持即将停止。有关更多信息，请参阅 [Amazon S3 更新 — SIGv2 弃用期延长并修改](https://aws.amazon.com/blogs/aws/amazon-s3-update-sigv2-deprecation-period-extended-modified/)。我们强烈建议您使用支持签名版本 4 的 Amazon EMR 发布版本。对于早期发布版本，从 EMR 4.7.x 开始，系列中的最新版本已更新为支持签名版本 4。使用较早版本的 EMR 时，建议您使用系列中的最新版本。此外，请避免早于 EMR 4.7.0 的版本。
### 注意事项和限制
#### 使用最新版本的任务运行程序
如果您将自管理的 `EmrCluster` 对象与版本标签结合使用，请使用最新的任务运行程序。有关任务运行程序的更多信息，请参阅[使用任务运行程序](dp-using-task-runner.md)。您可以为所有 Amazon EMR 配置分类配置属性值。有关更多信息，请参阅 *Amazon EMR 版本指南*中的[配置应用程序](https://docs.aws.amazon.com/ElasticMapReduce/latest/ReleaseGuide/emr-configure-apps.html)以及 [EmrConfiguration](dp-object-emrconfiguration.md) 和 [属性](dp-object-property.md) 对象引用。
#### Support IMDSv2
此前，仅 AWS Data Pipeline 支持 IMDSv1。现在， AWS Data Pipeline 支持 IMDSv2 亚马逊 EMR 5.23.1、5.27.1 和 5.32 或更高版本，以及亚马逊 EMR 6.2 或更高版本。 IMDSv2 在从实例检索元数据信息时，使用面向会话的方法来更好地处理身份验证。您应使用 TaskRunner -2.0 创建用户管理的资源，将您的实例配置为进行 IMDSv2 调用。
#### Amazon EMR 5.32 或更高版本以及 Amazon EMR 6.x
Amazon EMR 5.32 或更高版本和 6.x 版本系列使用 Hadoop 3.x 版本。Hadoop 3.x 版本与 Hadoop 2.x 版本相比，引入了对 Hadoop 类路径的评估方式的重大变更。像 Joda-Time 这样的常见库已从类路径中删除。
如果 [EmrActivity](dp-object-emractivity.md) 或 [HadoopActivity](dp-object-hadoopactivity.md) 运行的 Jar 文件依赖于 Hadoop 3.x 中已删除的库，则该步骤将失败，并显示错误 `java.lang.NoClassDefFoundError` 或 `java.lang.ClassNotFoundException`。对于使用 Amazon EMR 5.x 发行版运行时不会出现问题的 Jar 文件，可能会发生这种情况。
要解决此问题，在启动 `EmrActivity` 或 `HadoopActivity` 之前，必须将 Jar 文件依赖关系复制到 `EmrCluster` 对象上的 Hadoop 类路径中。我们提供 bash 脚本来执行此操作。bash 脚本可在以下位置找到，例如`us-west-2`，该位置*MyRegion*是您的`EmrCluster`对象运行的 AWS 区域。
```
s3://datapipeline-MyRegion/MyRegion/bootstrap-actions/latest/TaskRunner/copy-jars-to-hadoop-classpath.sh
```
脚本的运行方式取决于`EmrActivity`或是在由 AWS Data Pipeline 自我管理的资源管理的资源上`HadoopActivity`运行还是在自管理的资源上运行。
如果您使用由管理的资源 AWS Data Pipeline，请`bootstrapAction`向`EmrCluster`对象添加。`bootstrapAction` 指定要复制作为参数的脚本和 Jar 文件。每个 `EmrCluster` 对象最多可以添加 255 个 `bootstrapAction` 字段，也可以向已有引导操作的 `EmrCluster` 对象添加 `bootstrapAction` 字段。
要将此脚本指定为引导操作，请使用以下语法，其中`JarFileRegion`是保存 Jar 文件的区域，每个*MyJarFile*n**区域都是 Amazon S3 中要复制到 Hadoop 类路径的 Jar 文件的绝对路径。请勿指定默认位于 Hadoop 类路径中的 Jar 文件。
```
s3://datapipeline-MyRegion/MyRegion/bootstrap-actions/latest/TaskRunner/copy-jars-to-hadoop-classpath.sh,JarFileRegion,MyJarFile1,MyJarFile2[, ...]
```
以下示例指定了一个引导操作，该操作将复制 Amazon S3 中的两个 Jar 文件：`my-jar-file.jar` 和 `emr-dynamodb-tool-4.14.0-jar-with-dependencies.jar`。此示例使用 us-west-2 区域。
```
{
"id" : "MyEmrCluster",
"type" : "EmrCluster",
"keyPair" : "my-key-pair",
"masterInstanceType" : "m5.xlarge",
"coreInstanceType" : "m5.xlarge",
"coreInstanceCount" : "2",
"taskInstanceType" : "m5.xlarge",
"taskInstanceCount": "2",
"bootstrapAction" : ["s3://datapipeline-us-west-2/us-west-2/bootstrap-actions/latest/TaskRunner/copy-jars-to-hadoop-classpath.sh,us-west-2,s3://path/to/my-jar-file.jar,s3://dynamodb-dpl-us-west-2/emr-ddb-storage-handler/4.14.0/emr-dynamodb-tools-4.14.0-jar-with-dependencies.jar"]
}
```
我们强烈建议保存并激活管道，以便对新 `bootstrapAction` 的更改生效。
如果您使用自管理资源，则可以将脚本下载到集群实例，然后使用 SSH 从命令行运行该脚本。该脚本将在该目录中创建一个名为 `/etc/hadoop/conf/shellprofile.d` 的目录和一个名为 `datapipeline-jars.sh` 的文件。作为命令行参数提供的 jar 文件被复制到脚本创建的名为 `/home/hadoop/datapipeline_jars` 的目录中。如果您的集群设置不同，请在下载脚本后对脚本进行相应的修改。
在命令行上运行脚本的语法与使用前一个示例中所示的 `bootstrapAction` 略有不同。参数之间应使用空格而不是逗号，如以下示例所示。
```
./copy-jars-to-hadoop-classpath.sh us-west-2 s3://path/to/my-jar-file.jar s3://dynamodb-dpl-us-west-2/emr-ddb-storage-handler/4.14.0/emr-dynamodb-tools-4.14.0-jar-with-dependencies.jar
```
## Amazon EMR 权限
当您创建自定义 IAM 角色时，请仔细考虑您的集群执行其工作所需的最小权限。请务必授予对所需资源的访问权，例如文件（在 Amazon S3 中）或数据（在 Amazon RDS、Amazon Redshift 或 DynamoDB 中）。如果您希望将 `visibleToAllUsers` 设置为 False，您的角色必须具有适当的权限才能执行此操作。请注意，`DataPipelineDefaultRole` 没有这些权限。您必须提供 `DefaultDataPipelineResourceRole` 和 `DataPipelineDefaultRole` 角色的联合作为 `EmrCluster` 对象角色或创建您自己的角色来实现此目的。
## 语法
****
| 对象调用字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 计划 | 该对象在计划间隔的执行中调用。指定对另一个对象的计划引用，以便设置该对象的依赖项执行顺序。您可以明确设置针对该对象的计划以满足该要求，例如，指定 "schedule": \$1"ref": "DefaultSchedule"\$1。在大多数情况下，最好将计划引用放在默认管道对象上，以便所有对象继承该计划。或者，如果管道具有一个计划树 (计划位于主计划中)，您可以创建具有计划引用的父对象。有关示例可选计划配置的更多信息，请参阅 [https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-object-schedule.html)。 | 引用对象，例如， "schedule":\$1"ref":"myScheduleId"\$1 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| actionOnResource失败 | 在此资源发生资源失败后执行的操作。有效值为“retryall”(在指定的持续时间内对集群重试所有任务) 和“retrynone”。 | 字符串 |
| actionOnTask失败 | 在此资源发生任务失败后执行的操作。有效值为“continue”(意味着不终止集群) 和“terminate”。 | 字符串 |
| additionalMasterSecurityGroupIds | EMR 集群中其他主安全组的标识符，格式为 sg-01。XXXX6a有关更多信息，请参阅 Amazon EMR 管理指南中的 [Amazon EMR 其他安全组](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-additional-sec-groups.html)。 | 字符串 |
| additionalSlaveSecurityGroupIds | EMR 集群的其他从属安全组的标识符，其形式为 sg-01XXXX6a。 | 字符串 |
| amiVersion | Amazon EMR 用来安装集群节点的 Amazon Machine Image（AMI）版本。有关更多信息，请参阅 [Amazon EMR 管理指南](https://docs.aws.amazon.com/emr/latest/ManagementGuide/)。 | 字符串 |
| 应用程序 | 要安装在集群中的应用程序，带逗号分隔的参数。默认情况下，安装 Hive 和 Pig。该参数仅适用于 Amazon EMR 4.0 和更高版本。 | 字符串 |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| availabilityZone | 用于运行集群的可用区。 | 字符串 |
| bootstrapAction | 在集群启动时要运行的操作。您可以指定逗号分隔的参数。要指定多个操作 (最多 255 个)，请添加多个 bootstrapAction 字段。默认行为是启动集群，而不执行任何引导操作。 | 字符串 |
| 配置 | Amazon EMR 集群的配置。该参数仅适用于 Amazon EMR 4.0 和更高版本。 | 引用对象，例如，"configuration":\$1"ref":"myEmrConfigurationId"\$1 |
| coreInstanceBid价格 | 您愿意为 Amazon EC2 实例支付的最高 Spot 价格。如果指定了出价，Amazon EMR 将为实例组使用 Spot 实例。以 USD 为单位指定。 | 字符串 |
| coreInstanceCount | 要用于集群的核心节点的数目。 | 整数 |
| coreInstanceType | 要用于核心节点的 Amazon EC2 实例的类型。请参阅[Amazon EMR 集群支持的 Amazon EC2 实例](dp-emr-supported-instance-types.md)。 | 字符串 |
| coreGroupConfiguration | Amazon EMR 集群核心实例组的配置。该参数仅适用于 Amazon EMR 4.0 和更高版本。 | 引用对象，例如，“configuration”: \$1“ref”: “myEmrConfigurationId”\$1 |
| coreEbsConfiguration | 将附加到 Amazon EMR 集群的核心组中的每个核心节点的 Amazon EBS 卷的配置。有关更多信息，请参阅《Amazon EC2 用户指南》中的[支持 EBS 优化的实例类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSOptimized.html)。 | 引用对象，例如，“coreEbsConfiguration”: \$1“ref”: “myEbsConfiguration”\$1 |
| customAmiId | 仅适用于 Amazon EMR 版本 5.7.0 及更高版本。指定当 Amazon EMR 预置 Amazon EC2 实例时要使用的自定义 AMI 的 AMI ID。也可以使用它来代替引导操作以自定义集群节点配置。有关更多信息，请参阅《Amazon EMR 管理指南》中的以下主题：[使用自定义 AMI](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-custom-ami.html) | 字符串 |
| EbsBlockDeviceConfig | 请求的与实例组关联的 Amazon EBS 块设备的配置。包含指定数量的卷，这些卷将与实例组中的每个实例相关联。包括 `volumesPerInstance` 和 `volumeSpecification`，其中： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/datapipeline/latest/DeveloperGuide/dp-object-emrcluster.html) | 引用对象，例如，“EbsBlockDeviceConfig”: \$1“ref”: “myEbsBlockDeviceConfig”\$1 |
| emrManagedMasterSecurityGroupId | Amazon EMR 集群的主安全组的标识符，它采用 sg-01XXXX6a 格式。有关更多信息，请参阅 Amazon EMR 管理指南中的[配置安全组](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-groups.html)。 | 字符串 |
| emrManagedSlaveSecurityGroupId | Amazon EMR 集群的从属安全组的标识符，它采用 sg-01XXXX6a 格式。 | 字符串 |
| enableDebugging | 在 Amazon EMR 集群上启用调试。 | 字符串 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| hadoopSchedulerType | 集群的计划程序类型。有效类型为： PARALLEL\$1FAIR\$1SCHEDULING、 PARALLEL\$1CAPACITY\$1SCHEDULING 和 DEFAULT\$1SCHEDULER。 | 枚举 |
| httpProxy | 客户端用来连接到 Amazon Web Services 的代理主机。 | 参考对象，例如，“HttpProxy”：\$1“ref”:” myHttpProxy Id "\$1 |
| initTimeout | 资源启动前要等待的时间长度。 | 周期 |
| keyPair | 要用于登录 Amazon EMR 集群的主节点的 Amazon EC2 密钥对。 | 字符串 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| masterInstanceBid价格 | 您愿意为 Amazon EC2 实例支付的最高 Spot 价格。它是一个介于 0 和 20.00 之间（不含）的数字。以 USD 为单位指定。设置此值将为 Amazon EMR 集群主节点启用 Spot 实例。如果指定了出价，Amazon EMR 将为实例组使用 Spot 实例。 | 字符串 |
| masterInstanceType | 要用于主节点的 Amazon EC2 实例的类型。请参阅[Amazon EMR 集群支持的 Amazon EC2 实例](dp-emr-supported-instance-types.md)。 | 字符串 |
| masterGroupConfiguration | Amazon EMR 集群主实例组的配置。该参数仅适用于 Amazon EMR 4.0 和更高版本。 | 引用对象，例如，“configuration”: \$1“ref”: “myEmrConfigurationId”\$1 |
| masterEbsConfiguration | 将附加到 Amazon EMR 集群的主组中的每个主节点的 Amazon EBS 卷的配置。有关更多信息，请参阅《Amazon EC2 用户指南》中的[支持 EBS 优化的实例类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSOptimized.html)。 | 引用对象，例如，“masterEbsConfiguration”: \$1“ref”: “myEbsConfiguration”\$1 |
| maxActiveInstances | 组件的并发活动实例的最大数量。重新运行不计入活动实例数中。 | 整数 |
| maximumRetries | 失败后的最大重试次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 引用对象，例如，"onFail":\$1"ref":"myActionId"\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如，"onLateAction":\$1"ref":"myActionId"\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 引用对象，例如，"onSuccess":\$1"ref":"myActionId"\$1 |
| parent | 作为槽继承源的当前对象的父项。 | 引用对象，例如，"parent":\$1"ref":"myBaseObjectId"\$1 |
| pipelineLogUri | 用于上传管道日志的 Amazon S3 URI（例如 's3: BucketName ///Key/ '）。 | 字符串 |
| region | Amazon EMR 集群应在其中运行的区域的代码。默认情况下，该集群在管道所在的区域中运行。您可以在从属数据集所在的区域中运行集群。 | 枚举 |
| releaseLabel | EMR 集群的版本标签。 | 字符串 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| resourceRole | AWS Data Pipeline 用于创建 Amazon EMR 集群的 IAM 角色。默认角色是 DataPipelineDefaultRole。 | 字符串 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| 角色 | 传递到 Amazon EMR 以创建 EC2 节点的 IAM 角色。 | 字符串 |
| runsOn | 禁止在该对象上使用此字段。 | 引用对象，例如，"runsOn":\$1"ref":"myResourceId"\$1 |
| securityConfiguration | 应用于集群的 EMR 安全配置的标识符。该参数仅适用于 Amazon EMR 4.8.0 和更高版本。 | 字符串 |
| serviceAccessSecurityGroupId | Amazon EMR 集群的服务访问安全组的标识符。 | 字符串。它采用 sg-01XXXX6a 格式，例如，sg-1234abcd。 |
| scheduleType | 您可以通过计划类型指定应在间隔开头还是结尾计划管道定义中的对象。值包括：cron、ondemand 和 timeseries。timeseries 计划表示在每个间隔结尾计划实例。cron 计划表示在每个间隔开头计划实例。ondemand 计划让您可以在每次激活时运行一次管道。您不需要克隆或重新创建管道以再次运行它。如果您使用 ondemand 计划，则必须在默认对象中指定它，并且该计划必须是在管道中为对象指定的唯一 scheduleType。要使用 ondemand 管道，请为每个后续运行调用 ActivatePipeline 操作。 | 枚举 |
| subnetId | 要在其中启动 Amazon EMR 集群的子网的标识符。 | 字符串 |
| supportedProducts | 在 Amazon EMR 集群上安装第三方软件的参数，例如，安装第三方 Hadoop 分发版本。 | 字符串 |
| taskInstanceBid价格 | 您愿意为 EC2 实例支付的最高 Spot 价格。一个介于 0 和 20.00 之间（不含）的数字。以 USD 为单位指定。如果指定了出价，Amazon EMR 将为实例组使用 Spot 实例。 | 字符串 |
| taskInstanceCount | 要用于 Amazon EMR 集群的任务节点数。 | 整数 |
| taskInstanceType | 要用于任务节点的 Amazon EC2 实例的类型。 | 字符串 |
| taskGroupConfiguration | Amazon EMR 集群任务实例组的配置。该参数仅适用于 Amazon EMR 4.0 和更高版本。 | 引用对象，例如，“configuration”: \$1“ref”: “myEmrConfigurationId”\$1 |
| taskEbsConfiguration | 将附加到 Amazon EMR 集群的任务组中的每个任务节点的 Amazon EBS 卷的配置。有关更多信息，请参阅《Amazon EC2 用户指南》中的[支持 EBS 优化的实例类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSOptimized.html)。 | 引用对象，例如，“taskEbsConfiguration”: \$1“ref”: “myEbsConfiguration”\$1 |
| terminateAfter | 终止资源之前经过的小时数。 | 整数 |
| VolumeSpecification | Amazon EBS 卷规格，例如，为附加到 Amazon EMR 集群中的 Amazon EC2 实例的 Amazon EBS 卷请求的卷类型、IOPS 和大小（GiB）。节点可以是核心节点、主节点或任务节点。 `VolumeSpecification` 包括： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/datapipeline/latest/DeveloperGuide/dp-object-emrcluster.html) | 引用对象，例如，“VolumeSpecification”: \$1“ref”: “myVolumeSpecification”\$1 |
| useOnDemandOnLastAttempt | 在最后一次尝试请求资源时，请求的是按需实例而不是 Spot 实例。这可确保如果所有之前的尝试都失败，则最后一次尝试不中断。 | 布尔值 |
| workerGroup | 禁止在该对象中使用该字段。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如，“ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 参考对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 Amazon EMR 活动时可用的步骤日志。 | 字符串 |
| errorId | 该对象失败时显示的错误 ID。 | 字符串 |
| errorMessage | 该对象失败时显示的错误消息。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| @failureReason | 资源失败的原因。 | 字符串 |
| @finishedTime | 该对象完成其执行的时间。 | DateTime |
| hadoopJobLog | 在尝试 Amazon EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| @healthStatus | 对象的运行状况，反映进入终止状态的上个对象实例成功还是失败。 | 字符串 |
| @healthStatusFromInstanceId | 进入终止状态的上个实例对象的 ID。 | 字符串 |
| @ T healthStatusUpdated ime | 上次更新运行状况的时间。 | DateTime |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| @lastDeactivatedTime | 上次停用该对象的时间。 | DateTime |
| @ T latestCompletedRun ime | 已完成执行的最新运行的时间。 | DateTime |
| @latestRunTime | 已计划执行的最新运行的时间。 | DateTime |
| @nextRunTime | 计划下次运行的时间。 | DateTime |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 此对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1“ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象在生命周期中的位置。组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 示例
下面是该对象类型的示例。
**Topics**
+ [使用 hadoopVersion 启动 Amazon EMR 集群](emrcluster-example-launch.md)
+ [启动具有版本标签 emr-4.x 或更高版本的 Amazon EMR 集群](emrcluster-example-release-label.md)
+ [在您的 Amazon EMR 集群上安装额外的软件](emrcluster-example-install-software.md)
+ [在 3.x 版本上禁用服务器端加密](emrcluster-example1-disable-encryption.md)
+ [在 4.x 版本上禁用服务器端加密](emrcluster-example2-disable-encryption.md)
+ [配置 Hadoop KMS ACLs 并在 HDFS 中创建加密区域](emrcluster-example-hadoop-kms.md)
+ [指定自定义 IAM 角色](emrcluster-example-custom-iam-roles.md)
+ [使用适用于 Java 的 AWS 开发工具包中的 EmrCluster 资源](emrcluster-example-java.md)
+ [在私有子网中配置 Amazon EMR 集群](emrcluster-example-private-subnet.md)
+ [将 EBS 卷附加到集群节点](emrcluster-example-ebs.md)
# 使用 hadoopVersion 启动 Amazon EMR 集群
**Example**
以下示例使用 AMI 1.0 版和 Hadoop 0.20 启动 Amazon EMR 集群。
```
{
"id" : "MyEmrCluster",
"type" : "EmrCluster",
"hadoopVersion" : "0.20",
"keyPair" : "my-key-pair",
"masterInstanceType" : "m3.xlarge",
"coreInstanceType" : "m3.xlarge",
"coreInstanceCount" : "10",
"taskInstanceType" : "m3.xlarge",
"taskInstanceCount": "10",
"bootstrapAction" : ["s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop,arg1,arg2,arg3","s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop/configure-other-stuff,arg1,arg2"]
}
```
# 启动具有版本标签 emr-4.x 或更高版本的 Amazon EMR 集群
**Example**
以下示例使用较新的 `releaseLabel` 字段启动 Amazon EMR 集群：
```
{
"id" : "MyEmrCluster",
"type" : "EmrCluster",
"keyPair" : "my-key-pair",
"masterInstanceType" : "m3.xlarge",
"coreInstanceType" : "m3.xlarge",
"coreInstanceCount" : "10",
"taskInstanceType" : "m3.xlarge",
"taskInstanceCount": "10",
"releaseLabel": "emr-4.1.0",
"applications": ["spark", "hive", "pig"],
"configuration": {"ref":"myConfiguration"}
}
```
# 在您的 Amazon EMR 集群上安装额外的软件
**Example**
`EmrCluster` 提供了 `supportedProducts` 字段，它在 Amazon EMR 集群上安装第三方软件，例如，它用于安装 Hadoop 自定义分发版本（如 MapR）。它接受适用于第三方软件读取和处理的参数的逗号分隔列表。以下示例说明如何使用 `EmrCluster` 的 `supportedProducts` 字段来创建已安装 Karmasphere Analytics 的自定义 MapR M3 版本集群，并在该集群上运行 `EmrActivity` 对象。
```
{
"id": "MyEmrActivity",
"type": "EmrActivity",
"schedule": {"ref": "ResourcePeriod"},
"runsOn": {"ref": "MyEmrCluster"},
"postStepCommand": "echo Ending job >> /mnt/var/log/stepCommand.txt",
"preStepCommand": "echo Starting job > /mnt/var/log/stepCommand.txt",
"step": "/home/hadoop/contrib/streaming/hadoop-streaming.jar,-input,s3n://elasticmapreduce/samples/wordcount/input,-output, \
hdfs:///output32113/,-mapper,s3n://elasticmapreduce/samples/wordcount/wordSplitter.py,-reducer,aggregate"
},
{
"id": "MyEmrCluster",
"type": "EmrCluster",
"schedule": {"ref": "ResourcePeriod"},
"supportedProducts": ["mapr,--edition,m3,--version,1.2,--key1,value1","karmasphere-enterprise-utility"],
"masterInstanceType": "m3.xlarge",
"taskInstanceType": "m3.xlarge"
}
```
# 在 3.x 版本上禁用服务器端加密
**Example**
默认情况下，由 Hadoop 2.x 版本创建的`EmrCluster`活动 AWS Data Pipeline 启用服务器端加密。如果您想禁用服务器端加密，则必须在集群对象定义中指定引导操作。
以下示例创建一个已禁用服务器端加密的 `EmrCluster` 活动：
```
{
"id":"NoSSEEmrCluster",
"type":"EmrCluster",
"hadoopVersion":"2.x",
"keyPair":"my-key-pair",
"masterInstanceType":"m3.xlarge",
"coreInstanceType":"m3.large",
"coreInstanceCount":"10",
"taskInstanceType":"m3.large",
"taskInstanceCount":"10",
"bootstrapAction":["s3://Region.elasticmapreduce/bootstrap-actions/configure-hadoop,-e, fs.s3.enableServerSideEncryption=false"]
}
```
# 在 4.x 版本上禁用服务器端加密
**Example**
您必须使用 `EmrConfiguration` 对象禁用服务器端加密。
以下示例创建一个已禁用服务器端加密的 `EmrCluster` 活动：
```
{
"name": "ReleaseLabelCluster",
"releaseLabel": "emr-4.1.0",
"applications": ["spark", "hive", "pig"],
"id": "myResourceId",
"type": "EmrCluster",
"configuration": {
"ref": "disableSSE"
}
},
{
"name": "disableSSE",
"id": "disableSSE",
"type": "EmrConfiguration",
"classification": "emrfs-site",
"property": [{
"ref": "enableServerSideEncryption"
}
]
},
{
"name": "enableServerSideEncryption",
"id": "enableServerSideEncryption",
"type": "Property",
"key": "fs.s3.enableServerSideEncryption",
"value": "false"
}
```
# 配置 Hadoop KMS ACLs 并在 HDFS 中创建加密区域
**Example**
以下对象是 ACLs 为 Hadoop KMS 创建的，并在 HDFS 中创建加密区域和相应的加密密钥：
```
{
"name": "kmsAcls",
"id": "kmsAcls",
"type": "EmrConfiguration",
"classification": "hadoop-kms-acls",
"property": [
{"ref":"kmsBlacklist"},
{"ref":"kmsAcl"}
]
},
{
"name": "hdfsEncryptionZone",
"id": "hdfsEncryptionZone",
"type": "EmrConfiguration",
"classification": "hdfs-encryption-zones",
"property": [
{"ref":"hdfsPath1"},
{"ref":"hdfsPath2"}
]
},
{
"name": "kmsBlacklist",
"id": "kmsBlacklist",
"type": "Property",
"key": "hadoop.kms.blacklist.CREATE",
"value": "foo,myBannedUser"
},
{
"name": "kmsAcl",
"id": "kmsAcl",
"type": "Property",
"key": "hadoop.kms.acl.ROLLOVER",
"value": "myAllowedUser"
},
{
"name": "hdfsPath1",
"id": "hdfsPath1",
"type": "Property",
"key": "/myHDFSPath1",
"value": "path1_key"
},
{
"name": "hdfsPath2",
"id": "hdfsPath2",
"type": "Property",
"key": "/myHDFSPath2",
"value": "path2_key"
}
```
# 指定自定义 IAM 角色
**Example**
默认情况下，`DataPipelineDefaultRole`作`DataPipelineDefaultResourceRole`为 Amazon EMR 服务角色和 Amazon EC2 实例配置文件 AWS Data Pipeline 传递以代表您创建资源。但是，您可以创建自定义 Amazon EMR 服务角色和自定义实例配置文件，然后改为使用它们。 AWS Data Pipeline 应有足够的权限使用自定义角色创建集群，并且必须添加 AWS Data Pipeline 为可信实体。
以下示例对象指定 Amazon EMR 集群的自定义角色：
```
{
"id":"MyEmrCluster",
"type":"EmrCluster",
"hadoopVersion":"2.x",
"keyPair":"my-key-pair",
"masterInstanceType":"m3.xlarge",
"coreInstanceType":"m3.large",
"coreInstanceCount":"10",
"taskInstanceType":"m3.large",
"taskInstanceCount":"10",
"role":"emrServiceRole",
"resourceRole":"emrInstanceProfile"
}
```
# 使用适用于 Java 的 AWS 开发工具包中的 EmrCluster 资源
**Example**
以下示例说明了如何使用 `EmrCluster` 和 `EmrActivity` 创建 Amazon EMR 4.x 集群以通过 Java 软件开发工具包运行 Spark 步骤：
```
public class dataPipelineEmr4 {
public static void main(String[] args) {
AWSCredentials credentials = null;
credentials = new ProfileCredentialsProvider("/path/to/AwsCredentials.properties","default").getCredentials();
DataPipelineClient dp = new DataPipelineClient(credentials);
CreatePipelineRequest createPipeline = new CreatePipelineRequest().withName("EMR4SDK").withUniqueId("unique");
CreatePipelineResult createPipelineResult = dp.createPipeline(createPipeline);
String pipelineId = createPipelineResult.getPipelineId();
PipelineObject emrCluster = new PipelineObject()
.withName("EmrClusterObj")
.withId("EmrClusterObj")
.withFields(
new Field().withKey("releaseLabel").withStringValue("emr-4.1.0"),
new Field().withKey("coreInstanceCount").withStringValue("3"),
new Field().withKey("applications").withStringValue("spark"),
new Field().withKey("applications").withStringValue("Presto-Sandbox"),
new Field().withKey("type").withStringValue("EmrCluster"),
new Field().withKey("keyPair").withStringValue("myKeyName"),
new Field().withKey("masterInstanceType").withStringValue("m3.xlarge"),
new Field().withKey("coreInstanceType").withStringValue("m3.xlarge")
);
PipelineObject emrActivity = new PipelineObject()
.withName("EmrActivityObj")
.withId("EmrActivityObj")
.withFields(
new Field().withKey("step").withStringValue("command-runner.jar,spark-submit,--executor-memory,1g,--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/lib/spark-examples.jar,10"),
new Field().withKey("runsOn").withRefValue("EmrClusterObj"),
new Field().withKey("type").withStringValue("EmrActivity")
);
PipelineObject schedule = new PipelineObject()
.withName("Every 15 Minutes")
.withId("DefaultSchedule")
.withFields(
new Field().withKey("type").withStringValue("Schedule"),
new Field().withKey("period").withStringValue("15 Minutes"),
new Field().withKey("startAt").withStringValue("FIRST_ACTIVATION_DATE_TIME")
);
PipelineObject defaultObject = new PipelineObject()
.withName("Default")
.withId("Default")
.withFields(
new Field().withKey("failureAndRerunMode").withStringValue("CASCADE"),
new Field().withKey("schedule").withRefValue("DefaultSchedule"),
new Field().withKey("resourceRole").withStringValue("DataPipelineDefaultResourceRole"),
new Field().withKey("role").withStringValue("DataPipelineDefaultRole"),
new Field().withKey("pipelineLogUri").withStringValue("s3://myLogUri"),
new Field().withKey("scheduleType").withStringValue("cron")
);
List pipelineObjects = new ArrayList();
pipelineObjects.add(emrActivity);
pipelineObjects.add(emrCluster);
pipelineObjects.add(defaultObject);
pipelineObjects.add(schedule);
PutPipelineDefinitionRequest putPipelineDefintion = new PutPipelineDefinitionRequest()
.withPipelineId(pipelineId)
.withPipelineObjects(pipelineObjects);
PutPipelineDefinitionResult putPipelineResult = dp.putPipelineDefinition(putPipelineDefintion);
System.out.println(putPipelineResult);
ActivatePipelineRequest activatePipelineReq = new ActivatePipelineRequest()
.withPipelineId(pipelineId);
ActivatePipelineResult activatePipelineRes = dp.activatePipeline(activatePipelineReq);
System.out.println(activatePipelineRes);
System.out.println(pipelineId);
}
}
```
# 在私有子网中配置 Amazon EMR 集群
**Example**
该示例包括在 VPC 的私有子网中启动集群的配置。有关更多信息，请参阅 *Amazon EMR 管理指南*中的[在 VPC 中启动 Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-vpc-launching-job-flows.html)。此配置为可选配置。您可以在使用 `EmrCluster` 对象的任何管道中使用它。
要在私有子网中启动 Amazon EMR 集群，请在您的 `SubnetId` 配置中指定 `emrManagedMasterSecurityGroupId`、`emrManagedSlaveSecurityGroupId`、`serviceAccessSecurityGroupId`、和 `EmrCluster`。
```
{
"objects": [
{
"output": {
"ref": "S3BackupLocation"
},
"input": {
"ref": "DDBSourceTable"
},
"maximumRetries": "2",
"name": "TableBackupActivity",
"step": "s3://dynamodb-emr-#{myDDBRegion}/emr-ddb-storage-handler/2.1.0/emr-ddb-2.1.0.jar,org.apache.hadoop.dynamodb.tools.DynamoDbExport,#{output.directoryPath},#{input.tableName},#{input.readThroughputPercent}",
"id": "TableBackupActivity",
"runsOn": {
"ref": "EmrClusterForBackup"
},
"type": "EmrActivity",
"resizeClusterBeforeRunning": "false"
},
{
"readThroughputPercent": "#{myDDBReadThroughputRatio}",
"name": "DDBSourceTable",
"id": "DDBSourceTable",
"type": "DynamoDBDataNode",
"tableName": "#{myDDBTableName}"
},
{
"directoryPath": "#{myOutputS3Loc}/#{format(@scheduledStartTime, 'YYYY-MM-dd-HH-mm-ss')}",
"name": "S3BackupLocation",
"id": "S3BackupLocation",
"type": "S3DataNode"
},
{
"name": "EmrClusterForBackup",
"coreInstanceCount": "1",
"taskInstanceCount": "1",
"taskInstanceType": "m4.xlarge",
"coreInstanceType": "m4.xlarge",
"releaseLabel": "emr-4.7.0",
"masterInstanceType": "m4.xlarge",
"id": "EmrClusterForBackup",
"subnetId": "#{mySubnetId}",
"emrManagedMasterSecurityGroupId": "#{myMasterSecurityGroup}",
"emrManagedSlaveSecurityGroupId": "#{mySlaveSecurityGroup}",
"serviceAccessSecurityGroupId": "#{myServiceAccessSecurityGroup}",
"region": "#{myDDBRegion}",
"type": "EmrCluster",
"keyPair": "user-key-pair"
},
{
"failureAndRerunMode": "CASCADE",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"pipelineLogUri": "#{myPipelineLogUri}",
"scheduleType": "ONDEMAND",
"name": "Default",
"id": "Default"
}
],
"parameters": [
{
"description": "Output S3 folder",
"id": "myOutputS3Loc",
"type": "AWS::S3::ObjectKey"
},
{
"description": "Source DynamoDB table name",
"id": "myDDBTableName",
"type": "String"
},
{
"default": "0.25",
"watermark": "Enter value between 0.1-1.0",
"description": "DynamoDB read throughput ratio",
"id": "myDDBReadThroughputRatio",
"type": "Double"
},
{
"default": "us-east-1",
"watermark": "us-east-1",
"description": "Region of the DynamoDB table",
"id": "myDDBRegion",
"type": "String"
}
],
"values": {
"myDDBRegion": "us-east-1",
"myDDBTableName": "ddb_table",
"myDDBReadThroughputRatio": "0.25",
"myOutputS3Loc": "s3://s3_path",
"mySubnetId": "subnet_id",
"myServiceAccessSecurityGroup": "service access security group",
"mySlaveSecurityGroup": "slave security group",
"myMasterSecurityGroup": "master security group",
"myPipelineLogUri": "s3://s3_path"
}
}
```
# 将 EBS 卷附加到集群节点
**Example**
您可以将 EBS 卷附加到您的管道内的 EMR 集群中的任何类型的节点。要将 EBS 卷附加到节点，请在您的 `EmrCluster` 配置中使用 `coreEbsConfiguration`、`masterEbsConfiguration` 和 `TaskEbsConfiguration`。
该 Amazon EMR 集群示例使用 Amazon EBS 卷作为其主节点、任务节点和核心节点。有关更多信息，请参阅 *Amazon EMR 管理指南*中的 [Amazon EMR 中的 Amazon EBS 卷](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-storage.html)。
这些配置是可选的。您可以在使用 `EmrCluster` 对象的任何管道中使用它们。
在管道中，单击 `EmrCluster` 对象配置，选择**主 EBS 配置**、**核心 EBS 配置**或**任务 EBS 配置**，然后输入类似于以下示例的配置详细信息。
```
{
"objects": [
{
"output": {
"ref": "S3BackupLocation"
},
"input": {
"ref": "DDBSourceTable"
},
"maximumRetries": "2",
"name": "TableBackupActivity",
"step": "s3://dynamodb-emr-#{myDDBRegion}/emr-ddb-storage-handler/2.1.0/emr-ddb-2.1.0.jar,org.apache.hadoop.dynamodb.tools.DynamoDbExport,#{output.directoryPath},#{input.tableName},#{input.readThroughputPercent}",
"id": "TableBackupActivity",
"runsOn": {
"ref": "EmrClusterForBackup"
},
"type": "EmrActivity",
"resizeClusterBeforeRunning": "false"
},
{
"readThroughputPercent": "#{myDDBReadThroughputRatio}",
"name": "DDBSourceTable",
"id": "DDBSourceTable",
"type": "DynamoDBDataNode",
"tableName": "#{myDDBTableName}"
},
{
"directoryPath": "#{myOutputS3Loc}/#{format(@scheduledStartTime, 'YYYY-MM-dd-HH-mm-ss')}",
"name": "S3BackupLocation",
"id": "S3BackupLocation",
"type": "S3DataNode"
},
{
"name": "EmrClusterForBackup",
"coreInstanceCount": "1",
"taskInstanceCount": "1",
"taskInstanceType": "m4.xlarge",
"coreInstanceType": "m4.xlarge",
"releaseLabel": "emr-4.7.0",
"masterInstanceType": "m4.xlarge",
"id": "EmrClusterForBackup",
"subnetId": "#{mySubnetId}",
"emrManagedMasterSecurityGroupId": "#{myMasterSecurityGroup}",
"emrManagedSlaveSecurityGroupId": "#{mySlaveSecurityGroup}",
"region": "#{myDDBRegion}",
"type": "EmrCluster",
"coreEbsConfiguration": {
"ref": "EBSConfiguration"
},
"masterEbsConfiguration": {
"ref": "EBSConfiguration"
},
"taskEbsConfiguration": {
"ref": "EBSConfiguration"
},
"keyPair": "user-key-pair"
},
{
"name": "EBSConfiguration",
"id": "EBSConfiguration",
"ebsOptimized": "true",
"ebsBlockDeviceConfig" : [
{ "ref": "EbsBlockDeviceConfig" }
],
"type": "EbsConfiguration"
},
{
"name": "EbsBlockDeviceConfig",
"id": "EbsBlockDeviceConfig",
"type": "EbsBlockDeviceConfig",
"volumesPerInstance" : "2",
"volumeSpecification" : {
"ref": "VolumeSpecification"
}
},
{
"name": "VolumeSpecification",
"id": "VolumeSpecification",
"type": "VolumeSpecification",
"sizeInGB": "500",
"volumeType": "io1",
"iops": "1000"
},
{
"failureAndRerunMode": "CASCADE",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"pipelineLogUri": "#{myPipelineLogUri}",
"scheduleType": "ONDEMAND",
"name": "Default",
"id": "Default"
}
],
"parameters": [
{
"description": "Output S3 folder",
"id": "myOutputS3Loc",
"type": "AWS::S3::ObjectKey"
},
{
"description": "Source DynamoDB table name",
"id": "myDDBTableName",
"type": "String"
},
{
"default": "0.25",
"watermark": "Enter value between 0.1-1.0",
"description": "DynamoDB read throughput ratio",
"id": "myDDBReadThroughputRatio",
"type": "Double"
},
{
"default": "us-east-1",
"watermark": "us-east-1",
"description": "Region of the DynamoDB table",
"id": "myDDBRegion",
"type": "String"
}
],
"values": {
"myDDBRegion": "us-east-1",
"myDDBTableName": "ddb_table",
"myDDBReadThroughputRatio": "0.25",
"myOutputS3Loc": "s3://s3_path",
"mySubnetId": "subnet_id",
"mySlaveSecurityGroup": "slave security group",
"myMasterSecurityGroup": "master security group",
"myPipelineLogUri": "s3://s3_path"
}
}
```
## 另请参阅
+ [EmrActivity](dp-object-emractivity.md)
# HttpProxy
HttpProxy 允许您配置自己的代理并让 Task Runner 通过它访问 AWS Data Pipeline 服务。您不需要使用此信息配置正在运行的任务运行程序。
## in 的示 HttpProxy 例 TaskRunner
以下管道定义显示一个 `HttpProxy` 对象：
```
{
"objects": [
{
"schedule": {
"ref": "Once"
},
"pipelineLogUri": "s3://myDPLogUri/path",
"name": "Default",
"id": "Default"
},
{
"name": "test_proxy",
"hostname": "hostname",
"port": "port",
"username": "username",
"*password": "password",
"windowsDomain": "windowsDomain",
"type": "HttpProxy",
"id": "test_proxy",
},
{
"name": "ShellCommand",
"id": "ShellCommand",
"runsOn": {
"ref": "Resource"
},
"type": "ShellCommandActivity",
"command": "echo 'hello world' "
},
{
"period": "1 day",
"startDateTime": "2013-03-09T00:00:00",
"name": "Once",
"id": "Once",
"endDateTime": "2013-03-10T00:00:00",
"type": "Schedule"
},
{
"role": "dataPipelineRole",
"httpProxy": {
"ref": "test_proxy"
},
"actionOnResourceFailure": "retrynone",
"maximumRetries": "0",
"type": "Ec2Resource",
"terminateAfter": "10 minutes",
"resourceRole": "resourceRole",
"name": "Resource",
"actionOnTaskFailure": "terminate",
"securityGroups": "securityGroups",
"keyPair": "keyPair",
"id": "Resource",
"region": "us-east-1"
}
],
"parameters": []
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| hostname | 客户端将用来连接到 Amazon Web Services 的代理的主机。 | 字符串 |
| 端口 | 客户端将用来连接到 Amazon Web Services 的代理主机的端口。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| \$1password | 代理的密码。 | 字符串 |
| s3 NoProxy | 在连接到 Amazon S3 时禁用 HTTP 代理 | 布尔值 |
| username | 代理的用户名。 | 字符串 |
| windowsDomain | NTLM 代理的 Windows 域名。 | 字符串 |
| windowsWorkgroup | NTLM 代理的 Windows 工作组名。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 先决条件
以下是 AWS Data Pipeline 前提条件对象：
**Topics**
+ [Dynamo 存在 DBData](dp-dynamodbdataexists.md)
+ [Dynamo 存在 DBTable](dp-dynamodbtableexists.md)
+ [存在](dp-object-exists.md)
+ [S3 KeyExists](dp-object-S3KeyExists.md)
+ [S3 PrefixNotEmpty](dp-object-s3prefixnotempty.md)
+ [ShellCommandPrecondition](dp-object-shellcommandprecondition.md)
# Dynamo 存在 DBData
一个用于检查 DynamoDB 表中是否有数据的先决条件。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 角色 | 指定用于执行先决条件的角色。 | 字符串 |
| tableName | 要检查的 DynamoDB 表。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| currentRetryCount | 在此尝试中已经重试先决条件的次数。 | 字符串 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| lastRetryTime | 在此尝试中上次重试先决条件的时间。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# Dynamo 存在 DBTable
一个用于检查 DynamoDB 表是否存在的先决条件。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 角色 | 指定用于执行先决条件的角色。 | 字符串 |
| tableName | 要检查的 DynamoDB 表。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| currentRetryCount | 在此尝试中已经重试先决条件的次数。 | 字符串 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| lastRetryTime | 在此尝试中上次重试先决条件的时间。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# 存在
检查数据节点对象是否存在。
**注意**
我们建议您改用系统管理的先决条件。有关更多信息，请参阅 [先决条件](dp-concepts-preconditions.md)。
## 示例
以下是该对象类型的示例。`InputData` 对象引用该对象（即 `Ready`）以及您在同一管道定义文件中定义的另一个对象。`CopyPeriod` 为 `Schedule` 对象。
```
{
"id" : "InputData",
"type" : "S3DataNode",
"schedule" : { "ref" : "CopyPeriod" },
"filePath" : "s3://amzn-s3-demo-bucket/InputData/#{@scheduledStartTime.format('YYYY-MM-dd-hh:mm')}.csv",
"precondition" : { "ref" : "Ready" }
},
{
"id" : "Ready",
"type" : "Exists"
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [ShellCommandPrecondition](dp-object-shellcommandprecondition.md)
# S3 KeyExists
检查 Amazon S3 数据节点中是否存在键。
## 示例
以下是该对象类型的示例。如果 `s3Key` 参数引用的密钥 `s3://amzn-s3-demo-bucket/mykey` 已存在，则触发先决条件。
```
{
"id" : "InputReady",
"type" : "S3KeyExists",
"role" : "test-role",
"s3Key" : "s3://amzn-s3-demo-bucket/mykey"
}
```
您还可以使用 `S3KeyExists` 作为第二个管道的先决条件，该先决条件等待第一个管道完成。为此，请执行以下操作：
1. 当第一个管道完成后，将一个文件写入到 Amazon S3。
1. 在第二个管道上创建 `S3KeyExists` 先决条件。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 角色 | 指定用于执行先决条件的角色。 | 字符串 |
| s3Key | Amazon S3 密钥。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 再次尝试完成远程工作之前的超时时间。如果设置此字段，则可能会再次尝试未在启动后的设定时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败时启动尝试的最大次数。 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次连续尝试之间的超时时间。 | 周期 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| currentRetryCount | 在此尝试中已经重试先决条件的次数。 | 字符串 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| lastRetryTime | 在此尝试中上次重试先决条件的时间。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [ShellCommandPrecondition](dp-object-shellcommandprecondition.md)
# S3 PrefixNotEmpty
一个用于检查是否存在带给定前缀（表示为 URI）的 Amazon S3 对象的先决条件。
## 示例
以下是使用必填字段、可选字段和表达式字段的该对象类型的示例。
```
{
"id" : "InputReady",
"type" : "S3PrefixNotEmpty",
"role" : "test-role",
"s3Prefix" : "#{node.filePath}"
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 角色 | 指定用于执行先决条件的角色。 | 字符串 |
| s3Prefix | 用于检查对象是否存在的 Amazon S3 前缀。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| currentRetryCount | 在此尝试中已经重试先决条件的次数。 | 字符串 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| lastRetryTime | 在此尝试中上次重试先决条件的时间。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [ShellCommandPrecondition](dp-object-shellcommandprecondition.md)
# ShellCommandPrecondition
可以作为先决条件运行的 Unix/Linux shell 命令。
## 示例
以下是该对象类型的示例。
```
{
"id" : "VerifyDataReadiness",
"type" : "ShellCommandPrecondition",
"command" : "perl check-data-ready.pl"
}
```
## 语法
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| 命令 | 要运行的命令。此值与任何关联参数必须在从中运行任务运行程序的环境中起作用。 | 字符串 |
| scriptUri | 要下载并作为 shell 命令运行的文件的 Amazon S3 URI 路径。只应出现一个 scriptUri 或命令字段。scriptUri 无法使用参数，请使用命令。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| attemptStatus | 来自远程活动的最近报告的状态。 | 字符串 |
| attemptTimeout | 远程工作完成的超时时间。如果设置此字段，则可能会重试未在设定的开始时间内完成的远程活动。 | 周期 |
| failureAndRerun模式 | 描述依赖项失败或重新运行时的使用者节点行为。 | 枚举 |
| lateAfterTimeout | 管道启动后经过的时间，在此时间内，对象必须完成。仅当计划类型未设置为 ondemand 时才会触发。 | 周期 |
| maximumRetries | 失败后的最大重试次数 | 整数 |
| onFail | 当前对象失败时要运行的操作。 | 参考对象，例如 “onFail”：\$1“ref”:” myActionId “\$1 |
| onLateAction | 在尚未计划对象或对象仍未完成的情况下将触发的操作。 | 引用对象，例如 onLateAction ““: \$1" ref”:” myActionId “\$1 |
| onSuccess | 当前对象成功时要运行的操作。 | 参考对象，例如 “onSuccess”：\$1“ref”:” myActionId “\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| preconditionTimeout | 从开始算起的时段，在该时段后，如果仍未满足先决条件，则会将先决条件标记为失败。 | 周期 |
| reportProgressTimeout | 远程工作对 reportProgress 的连续调用的超时时间。如果设置此字段，则未报告指定时段的进度的远程活动可能会被视为停滞且已重试。 | 周期 |
| retryDelay | 两次重试之间的超时时间。 | 周期 |
| scriptArgument | 要传递到 shell 脚本的参数。 | 字符串 |
| stderr | 接收来自命令的重定向系统错误消息的 Amazon S3 路径。如果您使用 runsOn 字段，则由于运行活动的资源的短期性质，该字段必须为 Amazon S3 路径。不过，如果指定 workerGroup 字段，则允许使用本地文件路径。 | 字符串 |
| stdout | 接收来自命令的重定向输出的 Amazon S3 路径。如果您使用 runsOn 字段，则由于运行活动的资源的短期性质，该字段必须为 Amazon S3 路径。不过，如果指定 workerGroup 字段，则允许使用本地文件路径。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @activeInstances | 当前计划的有效实例对象的列表。 | 参考对象，例如 “ActiveInstances”：\$1"ref”:” myRunnableObject Id "\$1 |
| @actualEndTime | 该对象的执行完成时间。 | DateTime |
| @actualStartTime | 该对象的执行开始时间。 | DateTime |
| cancellationReason | 该对象被取消时显示的 cancellationReason。 | 字符串 |
| @cascadeFailedOn | 对象在其上失败的依赖项链的描述。 | 引用对象，例如 cascadeFailedOn ““: \$1" ref”:” myRunnableObject Id "\$1 |
| emrStepLog | 仅在尝试 EMR 活动时可用的 EMR 步骤日志 | 字符串 |
| errorId | 该对象失败时显示的 errorId。 | 字符串 |
| errorMessage | 该对象失败时显示的 errorMessage。 | 字符串 |
| errorStackTrace | 该对象失败时显示的错误堆栈跟踪。 | 字符串 |
| hadoopJobLog | 在尝试基于 EMR 的活动时可用的 Hadoop 任务日志。 | 字符串 |
| hostname | 已执行任务尝试的客户端的主机名。 | 字符串 |
| 节点 | 将为其执行此先决条件的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| reportProgressTime | 远程活动报告进度的最近时间。 | DateTime |
| @scheduledEndTime | 对象的计划结束时间。 | DateTime |
| @scheduledStartTime | 对象的计划开始时间。 | DateTime |
| @status | 该对象的状态。 | 字符串 |
| @version | 用来创建对象的管道版本。 | 字符串 |
| @waitingOn | 该对象在其上处于等待状态的依赖项列表的描述。 | 参考对象，例如 “waitingOn”：\$1"ref”:” myRunnableObject Id "\$1 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [ShellCommandActivity](dp-object-shellcommandactivity.md)
+ [存在](dp-object-exists.md)
# 数据库
以下是 AWS Data Pipeline 数据库对象：
**Topics**
+ [JdbcDatabase](dp-object-jdbcdatabase.md)
+ [RdsDatabase](dp-object-rdsdatabase.md)
+ [RedshiftDatabase](dp-object-redshiftdatabase.md)
# JdbcDatabase
定义 JDBC 数据库。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyJdbcDatabase",
"type" : "JdbcDatabase",
"connectionString" : "jdbc:redshift://hostname:portnumber/dbname",
"jdbcDriverClass" : "com.amazon.redshift.jdbc41.Driver",
"jdbcDriverJarUri" : "s3://redshift-downloads/drivers/RedshiftJDBC41-1.1.6.1006.jar",
"username" : "user_name",
"*password" : "my_password"
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| connectionString | 用于访问数据库的 JDBC 连接字符串。 | 字符串 |
| jdbcDriverClass | 建立 JDBC 连接之前要加载的驱动程序类。 | 字符串 |
| \$1password | 提供的密码。 | 字符串 |
| username | 连接到数据库时提供的用户名。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| databaseName | 要附加到的逻辑数据库的名称 | 字符串 |
| jdbcDriverJarUri | 连接到数据库所用 JDBC 驱动程序 JAR 文件在 Amazon S3 中的位置。AWS Data Pipeline 必须具有读取此 JAR 文件的权限。 | 字符串 |
| jdbcProperties | 格式为 A=B 的一对值，设置作为此数据库的 JDBC 连接上的属性。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# RdsDatabase
定义 Amazon RDS 数据库。
**注意**
RdsDatabase 不支持 Aurora。把 [JdbcDatabase](dp-object-jdbcdatabase.md) 用于 Aurora。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyRdsDatabase",
"type" : "RdsDatabase",
"region" : "us-east-1",
"username" : "user_name",
"*password" : "my_password",
"rdsInstanceId" : "my_db_instance_identifier"
}
```
对于 Oracle 引擎，`jdbcDriverJarUri` 字段是必填的，并且您可以指定以下驱动程序：`http://www.oracle.com/technetwork/database/features/jdbc/jdbc-drivers-12c-download-1958347.html`。对于 SQL Server 引擎，`jdbcDriverJarUri` 字段是必填的，并且您可以指定以下驱动程序：`https://www.microsoft.com/en-us/download/details.aspx?displaylang=en&id=11774`。对于 MySQL 和 PostgreSQL 引擎，`jdbcDriverJarUri` 字段是可选的。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| \$1password | 提供的密码。 | 字符串 |
| rdsInstanceId | DB 实例的 DBInstanceIdentifier 属性。 | 字符串 |
| username | 连接到数据库时提供的用户名。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| databaseName | 要附加到的逻辑数据库的名称 | 字符串 |
| jdbcDriverJarUri | 连接到数据库所用 JDBC 驱动程序 JAR 文件在 Amazon S3 中的位置。AWS Data Pipeline 必须具有读取此 JAR 文件的权限。对于 MySQL 和 PostgreSQL 引擎，如果未指定此字段则使用默认的驱动程序，但您可以使用此字段覆盖默认值。对于 Oracle 和 SQL Server 引擎，此字段为必填字段。 | 字符串 |
| jdbcProperties | 格式为 A=B 的一对值，设置作为此数据库的 JDBC 连接上的属性。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| region | 数据库所在区域的代码。例如，us-east-1。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# RedshiftDatabase
定义 Amazon Redshift 数据库。`RedshiftDatabase` 表示由您的管道使用的数据库的属性。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyRedshiftDatabase",
"type" : "RedshiftDatabase",
"clusterId" : "myRedshiftClusterId",
"username" : "user_name",
"*password" : "my_password",
"databaseName" : "database_name"
}
```
默认情况下，此对象将使用 Postgres 驱动程序，这将需要 `clusterId` 字段。要使用 Amazon Redshift 驱动程序，请改为在 `connectionString` 字段中指定来自 Amazon Redshift 控制台的 Amazon Redshift 数据库连接字符串（以“jdbc:redshift:”开头）。
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| \$1password | 提供的密码。 | 字符串 |
| username | 连接到数据库时提供的用户名。 | 字符串 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| clusterId | 创建 Amazon Redshift 集群时用户提供的标识符。例如，如果您的 Amazon Redshift 集群的端点是 mydb.example.us-east-1.redshift.amazonaws.com，正确的标识符是 mydb。在 Amazon Redshift 控制台中，您可以从“Cluster Identifier”或“Cluster Name”获取此值。 | 字符串 |
| connectionString | 用于连接到由账户拥有的不同于管道的 Amazon Redshift 实例的 JDBC 端点。您不能同时指定 connectionString 和 clusterId。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| databaseName | 要附加到的逻辑数据库的名称。 | 字符串 |
| jdbcProperties | 格式为 A=B 的一对值，设置为该数据库的 JDBC 连接上的属性。 | 字符串 |
| parent | 作为槽继承源的当前对象的父项。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| region | 数据库所在区域的代码。例如，us-east-1。 | 枚举 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 数据格式
以下是 AWS Data Pipeline 数据格式对象：
**Topics**
+ [CSV 数据格式](dp-object-csv.md)
+ [自定义数据格式](dp-object-custom.md)
+ [Dynamo 格式 DBData](dp-object-dynamodbdataformat.md)
+ [迪纳摩 DBExport DataFormat](dp-object-dynamodbexportdataformat.md)
+ [RegEx 数据格式](dp-object-regex.md)
+ [TSV 数据格式](dp-object-tsv.md)
# CSV 数据格式
一种逗号分隔的数据格式，其中列分隔符是逗号，记录分隔符是换行符。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyOutputDataType",
"type" : "CSV",
"column" : [
"Name STRING",
"Score INT",
"DateOfBirth TIMESTAMP"
]
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 具有该数据节点描述的数据的各个字段指定的数据类型的列名。例如：hostname STRING。对于多个值，使用空格分隔的列名和数据类型。 | 字符串 |
| escapeChar | 一个字符，例如“\$1”，指示分析器忽略下一个字符。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# 自定义数据格式
由特定的列分隔符、记录分隔符和转义字符组合定义的自定义数据格式。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyOutputDataType",
"type" : "Custom",
"columnSeparator" : ",",
"recordSeparator" : "\n",
"column" : [
"Name STRING",
"Score INT",
"DateOfBirth TIMESTAMP"
]
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| columnSeparator | 一个指示数据文件中的列结尾的字符。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 具有该数据节点描述的数据的各个字段指定的数据类型的列名。例如：hostname STRING。对于多个值，使用空格分隔的列名和数据类型。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| recordSeparator | 一个指示数据文件中的行结尾的字符，例如“\$1n”。仅支持单个字符。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# Dynamo 格式 DBData
将架构应用于 DynamoDB 表以使其可供 Hive 查询访问。`DynamoDBDataFormat` 与 `HiveActivity` 对象以及 `DynamoDBDataNode` 输入和输出一起使用。`DynamoDBDataFormat` 要求您在 Hive 查询中指定所有列。要更灵活地在 Hive 查询或 Amazon S3 支持中指定特定列，请参阅 [迪纳摩 DBExport DataFormat](dp-object-dynamodbexportdataformat.md)。
**注意**
DynamoDB 布尔类型不会映射到 Hive 布尔类型。不过，可以将 DynamoDB 整数值 0 或 1 映射到 Hive 布尔类型。
## 示例
以下示例说明如何使用 `DynamoDBDataFormat` 将架构分配给 `DynamoDBDataNode` 输入，这将允许 `HiveActivity` 对象按命名的列访问数据并将数据复制到 `DynamoDBDataNode` 输出。
```
{
"objects": [
{
"id" : "Exists.1",
"name" : "Exists.1",
"type" : "Exists"
},
{
"id" : "DataFormat.1",
"name" : "DataFormat.1",
"type" : "DynamoDBDataFormat",
"column" : [
"hash STRING",
"range STRING"
]
},
{
"id" : "DynamoDBDataNode.1",
"name" : "DynamoDBDataNode.1",
"type" : "DynamoDBDataNode",
"tableName" : "$INPUT_TABLE_NAME",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.1" }
},
{
"id" : "DynamoDBDataNode.2",
"name" : "DynamoDBDataNode.2",
"type" : "DynamoDBDataNode",
"tableName" : "$OUTPUT_TABLE_NAME",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.1" }
},
{
"id" : "EmrCluster.1",
"name" : "EmrCluster.1",
"type" : "EmrCluster",
"schedule" : { "ref" : "ResourcePeriod" },
"masterInstanceType" : "m1.small",
"keyPair" : "$KEYPAIR"
},
{
"id" : "HiveActivity.1",
"name" : "HiveActivity.1",
"type" : "HiveActivity",
"input" : { "ref" : "DynamoDBDataNode.1" },
"output" : { "ref" : "DynamoDBDataNode.2" },
"schedule" : { "ref" : "ResourcePeriod" },
"runsOn" : { "ref" : "EmrCluster.1" },
"hiveScript" : "insert overwrite table ${output1} select * from ${input1} ;"
},
{
"id" : "ResourcePeriod",
"name" : "ResourcePeriod",
"type" : "Schedule",
"period" : "1 day",
"startDateTime" : "2012-05-04T00:00:00",
"endDateTime" : "2012-05-05T00:00:00"
}
]
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 具有该数据节点描述的数据的各个字段指定的数据类型的列名。例如 hostname STRING。对于多个值，请使用以空格分隔的列名和数据类型。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 迪纳摩 DBExport DataFormat
将架构应用于 DynamoDB 表以使其可供 Hive 查询访问。将 `DynamoDBExportDataFormat` 与 `HiveCopyActivity` 对象和 `DynamoDBDataNode` 或 `S3DataNode` 输入和输出一起使用。`DynamoDBExportDataFormat` 具有以下优势：
+ 提供 DynamoDB 和 Amazon S3 支持
+ 允许您在 Hive 查询中按特定列筛选数据
+ 导出 DynamoDB 中的所有属性（即使您有一个稀疏架构）
**注意**
DynamoDB 布尔类型不会映射到 Hive 布尔类型。不过，可以将 DynamoDB 整数值 0 或 1 映射到 Hive 布尔类型。
## 示例
以下示例说明如何使用 `HiveCopyActivity` 和 `DynamoDBExportDataFormat` 将数据从一个 `DynamoDBDataNode` 复制到另一个 DynamoDBDataNode，并基于时间戳进行筛选。
```
{
"objects": [
{
"id" : "DataFormat.1",
"name" : "DataFormat.1",
"type" : "DynamoDBExportDataFormat",
"column" : "timeStamp BIGINT"
},
{
"id" : "DataFormat.2",
"name" : "DataFormat.2",
"type" : "DynamoDBExportDataFormat"
},
{
"id" : "DynamoDBDataNode.1",
"name" : "DynamoDBDataNode.1",
"type" : "DynamoDBDataNode",
"tableName" : "item_mapped_table_restore_temp",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.1" }
},
{
"id" : "DynamoDBDataNode.2",
"name" : "DynamoDBDataNode.2",
"type" : "DynamoDBDataNode",
"tableName" : "restore_table",
"region" : "us_west_1",
"schedule" : { "ref" : "ResourcePeriod" },
"dataFormat" : { "ref" : "DataFormat.2" }
},
{
"id" : "EmrCluster.1",
"name" : "EmrCluster.1",
"type" : "EmrCluster",
"schedule" : { "ref" : "ResourcePeriod" },
"masterInstanceType" : "m1.xlarge",
"coreInstanceCount" : "4"
},
{
"id" : "HiveTransform.1",
"name" : "Hive Copy Transform.1",
"type" : "HiveCopyActivity",
"input" : { "ref" : "DynamoDBDataNode.1" },
"output" : { "ref" : "DynamoDBDataNode.2" },
"schedule" : { "ref" : "ResourcePeriod" },
"runsOn" : { "ref" : "EmrCluster.1" },
"filterSql" : "`timeStamp` > unix_timestamp(\"#{@scheduledStartTime}\", \"yyyy-MM-dd'T'HH:mm:ss\")"
},
{
"id" : "ResourcePeriod",
"name" : "ResourcePeriod",
"type" : "Schedule",
"period" : "1 Hour",
"startDateTime" : "2013-06-04T00:00:00",
"endDateTime" : "2013-06-04T01:00:00"
}
]
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 具有该数据节点描述的数据的各个字段指定的数据类型的列名。例如：hostname STRING | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# RegEx 数据格式
由正则表达式定义的自定义数据格式。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyInputDataType",
"type" : "RegEx",
"inputRegEx" : "([^ ]*) ([^ ]*) ([^ ]*) (-|\\[[^\\]]*\\]) ([^ \"]*|\"[^\"]*\") (-|[0-9]*) (-|[0-9]*)(?: ([^ \"]*|\"[^\"]*\") ([^ \"]*|\"[^\"]*\"))?",
"outputFormat" : "%1$s %2$s %3$s %4$s %5$s %6$s %7$s %8$s %9$s",
"column" : [
"host STRING",
"identity STRING",
"user STRING",
"time STRING",
"request STRING",
"status STRING",
"size STRING",
"referer STRING",
"agent STRING"
]
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 具有该数据节点描述的数据的各个字段指定的数据类型的列名。例如：hostname STRING。对于多个值，使用空格分隔的列名和数据类型。 | 字符串 |
| inputRegEx | 用于解析 S3 输入文件的正则表达式。 inputRegEx 提供了一种从文件中相对非结构化的数据中检索列的方法。 | 字符串 |
| outputFormat | 由 Java 格式化程序语法 inputRegEx检索但引用为 %1\$1s %2\$1s 的列字段。 | 字符串 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# TSV 数据格式
一种逗号分隔的数据格式，其中列分隔符是制表符，记录分隔符是换行符。
## 示例
以下是该对象类型的示例。
```
{
"id" : "MyOutputDataType",
"type" : "TSV",
"column" : [
"Name STRING",
"Score INT",
"DateOfBirth TIMESTAMP"
]
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| column | 该数据节点描述的数据的列名和数据类型。例如，"Name STRING" 表示名为 Name 的列，其字段的数据类型为 STRING。请使用逗号分隔多个列名和数据类型对 (如示例中所示)。 | 字符串 |
| columnSeparator | 将一列中的字段与下一列中字段分隔的字符。默认为“\$1t”。 | 字符串 |
| escapeChar | 一个字符，例如“\$1”，指示分析器忽略下一个字符。 | 字符串 |
| parent | 作为槽继承源的当前对象的父项。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| recordSeparator | 分隔记录的字符。默认为“\$1n”。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 操作
以下是 AWS Data Pipeline 操作对象：
**Topics**
+ [SnsAlarm](dp-object-snsalarm.md)
+ [终止](dp-object-terminate.md)
# SnsAlarm
在活动失败或成功完成时发送 Amazon SNS 通知消息。
## 示例
以下是该对象类型的示例。`node.input` 和 `node.output` 的值来自在其 `onSuccess` 字段中引用该对象的数据节点或活动。
```
{
"id" : "SuccessNotify",
"name" : "SuccessNotify",
"type" : "SnsAlarm",
"topicArn" : "arn:aws:sns:us-east-1:28619EXAMPLE:ExampleTopic",
"subject" : "COPY SUCCESS: #{node.@scheduledStartTime}",
"message" : "Files were copied from #{node.input} to #{node.output}."
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| message | Amazon SNS 通知的正文文本。 | 字符串 |
| 角色 | 创建 Amazon SNS 警报所用的 IAM 角色。 | 字符串 |
| subject | Amazon SNS 通知消息的主题行。 | 字符串 |
| topicArn | 消息的目标 Amazon SNS 主题 ARN。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 节点 | 将为其执行此操作的节点。 | 引用对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# 终止
触发取消待处理或未完成的活动、资源或数据节点的操作。 AWS Data Pipeline 如果活动、资源或数据节点不是以该`lateAfterTimeout`值开头，则尝试将其置于 “已取消” 状态。
您不能终止包含 `onSuccess`、`OnFail` 或 `onLateAction` 资源的操作。
## 示例
以下是该对象类型的示例。在此示例中，`MyActivity` 的 `onLateAction` 字段包含对操作 `DefaultAction1` 的引用。当您提供针对 `onLateAction` 的操作时，您还必须提供 `lateAfterTimeout` 值以指示自管道的计划开始后经过的时间段，在该时间段后，活动将被视为延迟。
```
{
"name" : "MyActivity",
"id" : "DefaultActivity1",
"schedule" : {
"ref" : "MySchedule"
},
"runsOn" : {
"ref" : "MyEmrCluster"
},
"lateAfterTimeout" : "1 Hours",
"type" : "EmrActivity",
"onLateAction" : {
"ref" : "DefaultAction1"
},
"step" : [
"s3://amzn-s3-demo-bucket/myPath/myStep.jar,firstArg,secondArg",
"s3://amzn-s3-demo-bucket/myPath/myOtherStep.jar,anotherArg"
]
},
{
"name" : "TerminateTasks",
"id" : "DefaultAction1",
"type" : "Terminate"
}
```
## 语法
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| parent | 作为槽继承源的当前对象的父项。 | 参考对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 节点 | 将为其执行此操作的节点。 | 参考对象，例如 “节点”：\$1"ref”:” myRunnableObject Id "\$1 |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# Schedule
定义已计划事件的发生时间，例如何时活动运行。
**注意**
如果计划的开始时间已过去，则 AWS Data Pipeline 回填您的管道并立即开始计划运行，从指定的开始时间开始。出于测试/开发目的，请使用一个相对较短的时间间隔。否则， AWS Data Pipeline 会尝试在该时间间隔内对管道的所有运行进行排队和计划。 AWS Data Pipeline 如果管道组件早于 1 天前，`scheduledStartTime`则尝试通过阻止管道激活来防止意外回填。
## 示例
以下是该对象类型的示例。它定义了一个每小时计划，开始时间为 2012-09-01 的 00:00:00，结束时间为 2012-10-01 的 00:00:00。第一个时段的结束时间为 2012-09-01 的 01:00:00。
```
{
"id" : "Hourly",
"type" : "Schedule",
"period" : "1 hours",
"startDateTime" : "2012-09-01T00:00:00",
"endDateTime" : "2012-10-01T00:00:00"
}
```
以下管道将在 `FIRST_ACTIVATION_DATE_TIME` 启动，并每小时运行一次，直至 2014-04-25 的 22:00:00。
```
{
"id": "SchedulePeriod",
"name": "SchedulePeriod",
"startAt": "FIRST_ACTIVATION_DATE_TIME",
"period": "1 hours",
"type": "Schedule",
"endDateTime": "2014-04-25T22:00:00"
}
```
以下管道将在 `FIRST_ACTIVATION_DATE_TIME` 启动，每小时运行一次，并在运行三次后完成。
```
{
"id": "SchedulePeriod",
"name": "SchedulePeriod",
"startAt": "FIRST_ACTIVATION_DATE_TIME",
"period": "1 hours",
"type": "Schedule",
"occurrences": "3"
}
```
以下管道将在 2014-04-25 的 22:00:00 启动，每小时运行一次，并在运行三次后结束。
```
{
"id": "SchedulePeriod",
"name": "SchedulePeriod",
"startDateTime": "2014-04-25T22:00:00",
"period": "1 hours",
"type": "Schedule",
"occurrences": "3"
}
```
按需 (使用默认对象)
```
{
"name": "Default",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"scheduleType": "ondemand"
}
```
按需 (使用显式计划对象)
```
{
"name": "Default",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"scheduleType": "ondemand"
},
{
"name": "DefaultSchedule",
"type": "Schedule",
"id": "DefaultSchedule",
"period": "ONDEMAND_PERIOD",
"startAt": "ONDEMAND_ACTIVATION_TIME"
},
```
以下示例说明如何从默认对象继承计划、为该对象明确设置计划或通过父引用提供计划：
继承自默认对象的计划
```
{
"objects": [
{
"id": "Default",
"failureAndRerunMode":"cascade",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"pipelineLogUri": "s3://myLogsbucket",
"scheduleType": "cron",
"schedule": {
"ref": "DefaultSchedule"
}
},
{
"type": "Schedule",
"id": "DefaultSchedule",
"occurrences": "1",
"period": "1 Day",
"startAt": "FIRST_ACTIVATION_DATE_TIME"
},
{
"id": "A_Fresh_NewEC2Instance",
"type": "Ec2Resource",
"terminateAfter": "1 Hour"
},
{
"id": "ShellCommandActivity_HelloWorld",
"runsOn": {
"ref": "A_Fresh_NewEC2Instance"
},
"type": "ShellCommandActivity",
"command": "echo 'Hello World!'"
}
]
}
```
对象上的显式计划
```
{
"objects": [
{
"id": "Default",
"failureAndRerunMode":"cascade",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"pipelineLogUri": "s3://myLogsbucket",
"scheduleType": "cron"
},
{
"type": "Schedule",
"id": "DefaultSchedule",
"occurrences": "1",
"period": "1 Day",
"startAt": "FIRST_ACTIVATION_DATE_TIME"
},
{
"id": "A_Fresh_NewEC2Instance",
"type": "Ec2Resource",
"terminateAfter": "1 Hour"
},
{
"id": "ShellCommandActivity_HelloWorld",
"runsOn": {
"ref": "A_Fresh_NewEC2Instance"
},
"schedule": {
"ref": "DefaultSchedule"
},
"type": "ShellCommandActivity",
"command": "echo 'Hello World!'"
}
]
}
```
来自父引用的计划
```
{
"objects": [
{
"id": "Default",
"failureAndRerunMode":"cascade",
"resourceRole": "DataPipelineDefaultResourceRole",
"role": "DataPipelineDefaultRole",
"pipelineLogUri": "s3://myLogsbucket",
"scheduleType": "cron"
},
{
"id": "parent1",
"schedule": {
"ref": "DefaultSchedule"
}
},
{
"type": "Schedule",
"id": "DefaultSchedule",
"occurrences": "1",
"period": "1 Day",
"startAt": "FIRST_ACTIVATION_DATE_TIME"
},
{
"id": "A_Fresh_NewEC2Instance",
"type": "Ec2Resource",
"terminateAfter": "1 Hour"
},
{
"id": "ShellCommandActivity_HelloWorld",
"runsOn": {
"ref": "A_Fresh_NewEC2Instance"
},
"parent": {
"ref": "parent1"
},
"type": "ShellCommandActivity",
"command": "echo 'Hello World!'"
}
]
}
```
## 语法
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 时段 | 管道应运行的频率。格式为“N [minutes\$1hours\$1days\$1weeks\$1months]”，其中 N 是一个数字，后跟其中一个时间说明符。例如，“15 minutes”表示每 15 分钟运行一次管道。最短时段为 15 分钟，最长时段为 3 年。 | 周期 |
****
| 所需的组 (下列选项之一是必需的) | 说明 | 槽位类型 |
| --- | --- | --- |
| startAt | 计划的管道运行的开始日期和时间。有效值为 FIRST\$1ACTIVATION\$1DATE\$1TIME，已弃用此值以支持创建按需管道。 | 枚举 |
| startDateTime | 计划运行的开始日期和时间。您必须使用其中一个 startDateTime 或 startAt，但不能同时使用两者。 | DateTime |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| endDateTime | 计划运行的结束日期和时间。日期和时间必须晚于 startDateTime 或 startAt 的值。默认行为是计划运行，直至管道关闭。 | DateTime |
| occurrences | 在管道激活后执行管道的次数。你不能将具体值与一起使用。 endDateTime | 整数 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @firstActivationTime | 对象创建时间。 | DateTime |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
# 公用事业机构
以下实用程序对象配置其他管道对象：
**Topics**
+ [ShellScriptConfig](dp-object-shellscriptconfig.md)
+ [EmrConfiguration](dp-object-emrconfiguration.md)
+ [属性](dp-object-property.md)
# ShellScriptConfig
与 Activity 一起使用，运行 preActivityTask Config 和 postActivityTask Config 的 shell 脚本。此对象可用于[HadoopActivity](dp-object-hadoopactivity.md)、[HiveActivity[HiveCopyActivity](dp-object-hivecopyactivity.md)](dp-object-hiveactivity.md)、和[PigActivity](dp-object-pigactivity.md)。您为该脚本指定一个 S3 URI 和一个参数列表。
## 示例
ShellScriptConfig 带参数的 A：
```
{
"id" : "ShellScriptConfig_1”,
"name" : “prescript”,
"type" : "ShellScriptConfig",
"scriptUri": “s3://my-bucket/shell-cleanup.sh”,
"scriptArgument" : ["arg1","arg2"]
}
```
## 语法
该对象包含以下字段。
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| parent | 作为槽继承源的当前对象的父项。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| scriptArgument | 用于 Shell 脚本的参数列表。 | 字符串 |
| scriptUri | Amazon S3 中需要下载并运行的脚本 URI。 | 字符串 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
# EmrConfiguration
EmrConfiguration 对象是用于 4.0.0 或更高版本的 EMR 集群的配置。配置（作为列表）是 RunJobFlow API 调用的一个参数。Amazon EMR 的配置 API 采用分类和属性。 AWS Data Pipeline EmrConfiguration 与相应的属性对象一起使用，在管道执行中启动的 EMR 集群上配置[EmrCluster](dp-object-emrcluster.md)应用程序，例如 Hadoop、Hive、Spark 或 Pig。由于只能更改新集群的配置，因此您无法为现有资源提供 EmrConfiguration 对象。有关更多信息，请参阅 [https://docs.aws.amazon.com/ElasticMapReduce/latest/ReleaseGuide/](https://docs.aws.amazon.com/ElasticMapReduce/latest/ReleaseGuide/)。
## 示例
以下配置对象在 `core-site.xml` 中设置 `io.file.buffer.size` 和 `fs.s3.block.size` 属性：
```
[
{
"classification":"core-site",
"properties":
{
"io.file.buffer.size": "4096",
"fs.s3.block.size": "67108864"
}
}
]
```
相应的管道对象定义在 EmrConfiguration `property`字段中使用对象和属性对象列表：
```
{
"objects": [
{
"name": "ReleaseLabelCluster",
"releaseLabel": "emr-4.1.0",
"applications": ["spark", "hive", "pig"],
"id": "ResourceId_I1mCc",
"type": "EmrCluster",
"configuration": {
"ref": "coresite"
}
},
{
"name": "coresite",
"id": "coresite",
"type": "EmrConfiguration",
"classification": "core-site",
"property": [{
"ref": "io-file-buffer-size"
},
{
"ref": "fs-s3-block-size"
}
]
},
{
"name": "io-file-buffer-size",
"id": "io-file-buffer-size",
"type": "Property",
"key": "io.file.buffer.size",
"value": "4096"
},
{
"name": "fs-s3-block-size",
"id": "fs-s3-block-size",
"type": "Property",
"key": "fs.s3.block.size",
"value": "67108864"
}
]
}
```
以下示例是一个嵌套配置，用于通过 `hadoop-env` 分类设置 Hadoop 环境：
```
[
{
"classification": "hadoop-env",
"properties": {},
"configurations": [
{
"classification": "export",
"properties": {
"YARN_PROXYSERVER_HEAPSIZE": "2396"
}
}
]
}
]
```
以下是使用此配置的相应管道定义对象：
```
{
"objects": [
{
"name": "ReleaseLabelCluster",
"releaseLabel": "emr-4.0.0",
"applications": ["spark", "hive", "pig"],
"id": "ResourceId_I1mCc",
"type": "EmrCluster",
"configuration": {
"ref": "hadoop-env"
}
},
{
"name": "hadoop-env",
"id": "hadoop-env",
"type": "EmrConfiguration",
"classification": "hadoop-env",
"configuration": {
"ref": "export"
}
},
{
"name": "export",
"id": "export",
"type": "EmrConfiguration",
"classification": "export",
"property": {
"ref": "yarn-proxyserver-heapsize"
}
},
{
"name": "yarn-proxyserver-heapsize",
"id": "yarn-proxyserver-heapsize",
"type": "Property",
"key": "YARN_PROXYSERVER_HEAPSIZE",
"value": "2396"
},
]
}
```
以下示例修改了 EMR 集群的 Hive 特定属性：
```
{
"objects": [
{
"name": "hivesite",
"id": "hivesite",
"type": "EmrConfiguration",
"classification": "hive-site",
"property": [
{
"ref": "hive-client-timeout"
}
]
},
{
"name": "hive-client-timeout",
"id": "hive-client-timeout",
"type": "Property",
"key": "hive.metastore.client.socket.timeout",
"value": "2400s"
}
]
}
```
## 语法
该对象包含以下字段。
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 分类 | 配置的分类。 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 配置 | 此配置的子配置。 | 参考对象，例如 “配置”：\$1"ref”:” myEmrConfiguration Id "\$1 |
| parent | 槽将继承自的当前对象的父级。 | 引用对象，例如 “父对象”：\$1"ref”:” myBaseObject Id "\$1 |
| property | 配置属性。 | 引用对象，例如 “属性”：\$1“ref”:” myPropertyId “\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用来创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象 | 字符串 |
## 另请参阅
+ [EmrCluster](dp-object-emrcluster.md)
+ [属性](dp-object-property.md)
+ [Amazon EMR 版本指南](https://docs.aws.amazon.com/ElasticMapReduce/latest/ReleaseGuide/)
# 属性
用于对象的单个键值属性。 EmrConfiguration
## 示例
以下管道定义显示了用于启动的 EmrConfiguration 对象和相应的 Property 对象 EmrCluster：
```
{
"objects": [
{
"name": "ReleaseLabelCluster",
"releaseLabel": "emr-4.1.0",
"applications": ["spark", "hive", "pig"],
"id": "ResourceId_I1mCc",
"type": "EmrCluster",
"configuration": {
"ref": "coresite"
}
},
{
"name": "coresite",
"id": "coresite",
"type": "EmrConfiguration",
"classification": "core-site",
"property": [{
"ref": "io-file-buffer-size"
},
{
"ref": "fs-s3-block-size"
}
]
},
{
"name": "io-file-buffer-size",
"id": "io-file-buffer-size",
"type": "Property",
"key": "io.file.buffer.size",
"value": "4096"
},
{
"name": "fs-s3-block-size",
"id": "fs-s3-block-size",
"type": "Property",
"key": "fs.s3.block.size",
"value": "67108864"
}
]
}
```
## 语法
该对象包含以下字段。
****
| 必填字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| 键 | 键 | 字符串 |
| 值 | 值 | 字符串 |
****
| 可选字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| parent | 作为槽继承源的当前对象的父项。 | 参考对象，例如，“父对象”：\$1"ref”:” myBaseObject Id "\$1 |
****
| 运行时字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @version | 用于创建对象的管道版本。 | 字符串 |
****
| 系统字段 | 说明 | 槽位类型 |
| --- | --- | --- |
| @error | 用于描述格式不正确的对象的错误消息。 | 字符串 |
| @pipelineId | 该对象所属的管道的 ID。 | 字符串 |
| @sphere | 对象的范围指明对象在生命周期中的位置：组件对象产生实例对象，后者执行尝试对象。 | 字符串 |
## 另请参阅
+ [EmrCluster](dp-object-emrcluster.md)
+ [EmrConfiguration](dp-object-emrconfiguration.md)
+ [Amazon EMR 版本指南](https://docs.aws.amazon.com/ElasticMapReduce/latest/ReleaseGuide/)