全部产品
云市场

任务循环

更新时间:2019-06-27 17:36:55

Task的特殊属性Loop用来支持任务的循环。
API类action和云产品action的任务可支持循环,功能性的action(如Trigger、Sleep等)的任务不支持循环。
任务循环支持并发,不过单步模式执行下循环的任务则自动调整为依次执行无并发。

限制

Loop Items的个数限制当前最大为1000个。

语法

  • YAML语法结构
  1. ---
  2. Tasks:
  3. - Name: TaskName1 # 必填,任务名称,有效字符为[a-zA-Z0-9_-],即英文字母数字下划线中划线,长度限制200个字符。建议使用驼峰式命名,如StartInstance。
  4. Action: TaskType # 必填,任务类型(也叫动作),请参考动作相关的文档。
  5. Description: description # 可选,描述,描述当前任务的用途。
  6. Properties: # 根据所使用的动作不同,具体的属性列表不同,请参考动作相关的文档。
  7. Property1: Value1 # 动作所依赖的属性和值
  8. Property2: Value2
  9. Outputs: # 当前任务的输出参数,可以用作续任务的输入或模板的输出
  10. OutputParameterName1:
  11. Type: TypeName # 可选,输出参数类型,YAML/JSON支持的基本类型,默认为String。
  12. ValueSelector: "jq selector" # 如Task是一个OpenAPI调用时,把OpenAPI的调用结果当做一个JSON输入,应用jq从该JSON中截取所需要的值,请参考云产品动作和公共模板等具体例子。
  13. Loop:
  14. MaxErrors: MaxErrorsValue1 # 可选,允许数值或百分比的定义方式,如10或10%,默认为0
  15. Concurrency: ConcurrencyValue1 # 可选,允许数值或百分比表并发控制;以及List内含数值或百分比的方式定义表批次控制,如10、10%、[20%]、[5]。
  16. Items: ListTypeItems # 一个包含Item的List,如[i-id1,i-id2,i-id3,i-id4],Items迭代作为Loop所在Task执行的参数;或者 一个可被解析为List类型的参数名,如describeInstance.InstanceIds;Items迭代作为Loop所在Task执行的参数。
  17. Outputs:
  18. MaxMemory:
  19. AggregateType: BuiltInFunctionName1 # 选择一种内置函数方式对输出进行聚合如Fn::Sum、Fn::Max。
  20. AggregateField: OutputParameterName1 # 循环的元素执行输出的参数名称
  • JSON语法结构(请参考YAML注释说明)
  1. {
  2. "Tasks": [
  3. {
  4. "Name": "TaskName1",
  5. "Action": "TaskType",
  6. "Description": "description",
  7. "Properties": {
  8. "Property1": "Value1",
  9. "Property2": "Value2"
  10. },
  11. "Outputs": {
  12. "OutputParameterName1": {
  13. "Type": "TypeName",
  14. "ValueSelector": "jq selector"
  15. }
  16. },
  17. "Loop": {
  18. "MaxErrors": "MaxErrorsValue1",
  19. "Concurrency": "ConcurrencyValue1",
  20. "Items": "ListTypeItems1",
  21. "Outputs": {
  22. "MaxMemory": {
  23. "AggregateType": "BuiltInFunctionName1",
  24. "AggregateField": "OutputParameterName1"
  25. }
  26. }
  27. }
  28. }
  29. ]
  30. }

循环列表Items

Items接受一个List,如一个直接的List: [item1, item2, item3];
Items也可以是一个List类型的参数名,如上一个Task的List类型Outputs。

  • Items为一个 List
    • YAML
    1. Loop:
    2. Items: [item1,item2,item3,item4] # 一个包含Item的List,如[i-id1,i-id2,i-id3,i-id4],Items迭代作为Loop所在Task执行的参数。
    • JSON(请参考YAML注释说明)
    1. {
    2. "Items": [
    3. "item1",
    4. "item2",
    5. "item3",
    6. "item4"
    7. ]
    8. }

  • Items为一个List类型的参数名
    • YAML
    1. Items: '{{ParameterName1}}' # 一个可被解析为List类型的参数名,如describeInstance.InstanceIds;Items迭代作为Loop所在Task执行的参数。
    • JSON(请参考YAML注释说明)
    1. {
    2. "Items": "{{ParameterName1}}"
    3. }

并发控制Concurrency

分两种情况:

  1. 并发数控制,保持这个并发数的执行速率,直到所有item执行结束。
  2. 批次控制,把item明确地分成多个批次,然后一个批次运行完再运行下一个批次,若上一个批次未全部完成的情况下,下一个批次不会开始。

并发数的控制

  • 如Items是10个item,并发是3,且会保持一直有3个item在并发,直到没有更多未执行的item。
    • YAML
    1. Concurrency: 3 # 允许数值或百分比表并发控制,如3
    • JSON(请参考YAML注释说明)
    1. {
    2. "Concurrency": 3
    3. }

  • 如Items是10个item,并发是20%,表示20% * 10 =2的并发,且会保持一直有2个item在并发,直到没有更多未执行的item。

    • YAML

    1. Concurrency: 20% # 可选,允许数值或百分比的定义方式,如20%
    • JSON(请参考YAML注释说明)
    1. {
    2. "Concurrency": "20%"
    3. }

批次的控制

  • 如Items是10个item,批次是[3],会将item分为大小为3的多个批次,结果为3,3,3,1,一共4个批次(假设item的执行结果都是成功)。
    • YAML
    1. Concurrency: [3] # 可选,允许List内含数值或百分比的方式定义表批次控制,如[3]。
    • JSON(请参考YAML注释说明)
    1. {
    2. "Concurrency": [
    3. 3
    4. ]
    5. }

  • 如Items是10个item,批次是[30%] —— 表示第一个批次是3,会将item分为大小为10*30%=3的多个批次,结果为3,3,3,1,一共4个批次(假设item的执行结果都是成功):

    • YAML

    1. Concurrency: [30%] # 可选,允许List内含数值或百分比的方式定义表批次控制,如[30%]。
    • JSON(请参考YAML注释说明)
    1. {
    2. "Concurrency": ["30%"]
    3. }

  • 如Items是10个item,批次是[3, 10%,30%] —— 表示第一个批次是3,第二个批次是总量的10%,第三个及以后批次为[30%] ,结果为3,1,3,3 一共4个批次(假设item的执行结果都是成功)
    • YAML
    1. Concurrency: [3, 10%,30%] # 可选,允许List内含多个数值或百分比的方式定义表批次控制,如[3, 10%,30%]。
    • JSON(请参考YAML注释说明)
    1. {
    2. "Concurrency": [3,"10%","30%"]
    3. }

100%并发或批次

当并发或批次设置为100%时,即并发为”100%”,或批次为[“100%”]。执行的结果一致,即同时执行所有的item。

  • YAML
  1. Concurrency: 100% # 可选,允许List内含数值或百分比的方式定义表批次控制,如100%,[100%]。
  • JSON(请参考YAML注释说明)
  1. {
  2. "Concurrency": "100%"
  3. }

错误控制MaxErrors

在Loop中,您也可以定义MaxErrors,其意义如下:

  1. 允许数值或百分比(表现为Items乘以百分比)的定义方式,如10,或10%。默认为0,即任何错误都会暴露到loop-task级别。
  2. Loop里面的第一个Item,总会被执行。
  3. 是否能够执行到第二个Item或后续的Item取决于实际MaxErrors和ErrorCount的关系。
    • 当实际ErrorCount > MaxErrors时,后续的Item停止执行,且当前Loop所在任务标记为失败。
    • 当实际的ErrorCount <= MaxErrors时,则持续向下执行。
  4. 根据 ErrorCount > MaxErrorsLoop判定Loop所在任务的执行状态,如果大于则是Failed,否则是Success。
  • 数值方式定义
    • YAML
    1. MaxErrors: 2 # 可选,允许数值或百分比的定义方式,如2,表示允许最大ErrorCount为2
    • JSON(请参考YAML注释说明)
    1. {
    2. "MaxErrors": 2
    3. }

  • 百分比方式定义
    • YAML
    1. MaxErrors: 25% # 可选,允许数值或百分比的定义方式,如25%,共4个Item则表示允许最大ErrorCount为25%*4=1。
    • JSON(请参考YAML注释说明)
    1. {
    2. "MaxErrors": "25%"
    3. }

循环输出Loop Outputs

Task或template的Loop也支持outputs,由于Loop的实际outputs中包含多个Item的outputs,因此Loop最终的outputs需要把多个子任务outputs进行聚合,您可通过定义AggreateType来选择不同内置函数的聚合方式。

  • 定义AggreateType
    • YAML
    1. AggregateType: Fn::Max # 选择一种内置函数对Loop输出进行聚合,如Fn::Max,表示把所有子任务输出的Numer类型的最大的OutputParameterName1作为Loop的输出值。
    • JSON(请参考YAML注释说明)
    1. {
    2. "AggregateType": "Fn::Max"
    3. }

示例

  • YAML格式
  1. ---
  2. FormatVersion: OOS-2019-06-01
  3. Description: Example of loop
  4. Parameters:
  5. status:
  6. Description: Instance status
  7. Type: String
  8. Tasks:
  9. - Name: calculateMaxMemory
  10. Action: ACS::ExecuteApi
  11. Description: Example of loop
  12. Properties:
  13. Service: ECS
  14. API: DescribeInstances
  15. Parameters:
  16. InstanceType: '{{ ACS::TaskLoopItem }}'
  17. Status: '{{ status }}'
  18. Loop:
  19. Concurrency: 1
  20. Items:
  21. - ecs.n1.tiny
  22. - ecs.t1.small
  23. - ecs.m2.xlarge
  24. MaxErrors: 1
  25. Outputs:
  26. MaxMemory:
  27. AggregateField: Memory
  28. AggregateType: Fn::Max
  29. Outputs:
  30. memory:
  31. Type: Number
  32. ValueSelector: Instances.Instance[].Memory
  33. Outputs:
  34. MaxMemory:
  35. Value: ' {{ calculateMaxMemory.MaxMemory }} '
  36. Type: Number
  • JSON格式
  1. {
  2. "FormatVersion": "OOS-2019-06-01",
  3. "Parameters": {
  4. "Status": {
  5. "Type": "String",
  6. "Description": "Instance status"
  7. }
  8. },
  9. "Tasks": [
  10. {
  11. "Name": "calculateMaxMemory",
  12. "Action": "ACS::ExecuteApi",
  13. "Properties": {
  14. "Service": "Ecs",
  15. "API": "DescribeInstances",
  16. "Parameters": {
  17. "Status": "{{ Status }}",
  18. "InstanceType": "{{ ACS::TaskLoopItem }}"
  19. }
  20. },
  21. "Outputs": {
  22. "Memory": {
  23. "ValueSelector": "Instances.Instance[].Memory",
  24. "Type": "Number"
  25. }
  26. },
  27. "Loop": {
  28. "Items": ["ecs.n1.tiny", "ecs.t1.small", "ecs.m2.xlarge"],
  29. "MaxErrors": 1,
  30. "Concurrency": 1,
  31. "Outputs": {
  32. "MaxMemory": {
  33. "AggregateType": "Fn::Max",
  34. "AggregateField": "Memory"
  35. }
  36. }
  37. }
  38. }
  39. ],
  40. "Outputs": {
  41. "MaxMemory": {
  42. "Value": " {{ calculateMaxMemory.MaxMemory }} ",
  43. "Type": "Number"
  44. }
  45. }
  46. }