本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 工作 HealthOmics 流程定义中的任务输出
<a name="workflows-task-outputs"></a>

您可以在工作流定义中指定任务输出。默认情况下，当工作流程完成时，会 HealthOmics 丢弃所有中间任务文件。要导出中间文件，请将其定义为输出。

如果您使用呼叫缓存，则 HealthOmics 会将任务输出保存到缓存中，包括您定义为输出的任何中间文件。

以下主题包括每种工作流定义语言的任务定义示例。

**Topics**
+ [WDL 的任务输出](#workflow-task-outputs-wdl)
+ [下一流的任务输出](#workflow-task-outputs-nextflow)
+ [CWL 的任务输出](#workflow-task-outputs-cwl)

## WDL 的任务输出
<a name="workflow-task-outputs-wdl"></a>

对于用 WDL 编写的工作流程定义，请在顶级工作流程**outputs**部分中定义您的输出。

HealthOmics

**Topics**
+ [STDOUT 的任务输出](#task-outputs-wdl-stdout)
+ [STDERR 的任务输出](#task-outputs-wdl-stderr)
+ [任务输出到文件](#task-outputs-wdl-file)
+ [任务输出到文件数组](#task-outputs-wdl-files)

### STDOUT 的任务输出
<a name="task-outputs-wdl-stdout"></a>

此示例创建了一个名为的任务`SayHello`，该任务将 STDOUT 内容回显到任务输出文件中。**WDL **stdout** 函数捕获 STDOUT 内容（在本例中为输入字符串 Hello World！** ) 在文件中**stdout\$1file**。

由于 HealthOmics 会为所有 STDOUT 内容创建日志，因此输出也会与任务的其他 STDERR CloudWatch 日志信息一起显示在 “日志” 中。

```
version 1.0
 workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File stdout_file = SayHello.stdout_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        echo "~{message}" 
        echo "Current date: $(date)"
        echo "This message was printed to STDOUT"
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File stdout_file = stdout()
    }
}
```

### STDERR 的任务输出
<a name="task-outputs-wdl-stderr"></a>

此示例创建了一个名为的任务`SayHello`，该任务将 STDERR 内容回显到任务输出文件中。**WDL **stderr** 函数捕获 STDERR 内容（在本例中为输入字符串 Hello World！** ) 在文件中**stderr\$1file**。

由于 HealthOmics 会为所有 STDERR 内容创建日志，因此输出将与任务的其他 STDERR CloudWatch 日志信息一起显示在日志中。

```
version 1.0
 workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File stderr_file = SayHello.stderr_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        echo "~{message}" >&2
        echo "Current date: $(date)" >&2
        echo "This message was printed to STDERR" >&2
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File stderr_file = stderr()
    }
}
```

### 任务输出到文件
<a name="task-outputs-wdl-file"></a>

在此示例中，该 SayHello 任务创建了两个文件（message.txt 和 info.txt），并将这些文件明确声明为命名的输出（message\$1file 和 info\$1file）。

```
version 1.0
workflow HelloWorld {
    input {
        String message = "Hello, World!"
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call SayHello {
        input:
            message = message,
            container = ubuntu_container
    }

    output {
        File message_file = SayHello.message_file
        File info_file = SayHello.info_file
    }
}

task SayHello {
    input {
        String message
        String container
    }

    command <<<
        # Create message file
        echo "~{message}" > message.txt
        
        # Create info file with date and additional information
        echo "Current date: $(date)" > info.txt
        echo "This message was saved to a file" >> info.txt
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        File message_file = "message.txt"
        File info_file = "info.txt"
    } 
}
```

### 任务输出到文件数组
<a name="task-outputs-wdl-files"></a>

在此示例中，`GenerateGreetings`任务生成一组文件作为任务输出。该任务为输入数组的每个成员动态生成一个问候语文件`names`。由于文件名要等到运行时才知道，因此输出定义使用 WDL glob () 函数输出与该模式匹配的所有文件。`*_greeting.txt`

```
version 1.0
 workflow HelloArray {
    input {
        Array[String] names = ["World", "Friend", "Developer"]
        String ubuntu_container = "123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04"
    }

    call GenerateGreetings {
        input:
            names = names,
            container = ubuntu_container
    }

    output {
        Array[File] greeting_files = GenerateGreetings.greeting_files
    }
}

task GenerateGreetings {
    input {
        Array[String] names
        String container
    }

    command  <<<
        # Create a greeting file for each name
        for name in ~{sep=" " names}; do
            echo "Hello, $name!" > ${name}_greeting.txt
        done
    >>>

    runtime {
        docker: container
        cpu: 1
        memory: "2 GB"
    }

    output {
        Array[File] greeting_files = glob("*_greeting.txt")
    }       
 }
```

## 下一流的任务输出
<a name="workflow-task-outputs-nextflow"></a>

对于在 Nextflow 中编写的工作流程定义，请定义 P **ublishDir** 指令以将任务内容导出到您的输出 Amazon S3 存储桶。将 p **ublishDir** 值设置为。`/mnt/workflow/pubdir`

 HealthOmics 要将文件导出到 Amazon S3，文件必须位于此目录中。

如果任务生成一组输出文件作为后续任务的输入，我们建议您将这些文件分组到一个目录中，然后将该目录作为任务输出发出。枚举每个单独的文件可能会导致底层文件系统出现 I/O 瓶颈。例如：

```
process my_task {
      ...
      // recommended
      output "output-folder/", emit: output
      
      // not recommended
      // output "output-folder/**", emit: output
      ...
  }
```

## CWL 的任务输出
<a name="workflow-task-outputs-cwl"></a>

对于用 CWL 编写的工作流程定义，您可以使用任务指定任务输出。`CommandLineTool`以下各节显示了定义不同类型输出的`CommandLineTool`任务示例。

**Topics**
+ [STDOUT 的任务输出](#task-outputs-cwl-stdout)
+ [STDERR 的任务输出](#task-outputs-cwl-stderr)
+ [任务输出到文件](#task-outputs-cwl-file)
+ [任务输出到文件数组](#task-outputs-cwl-files)

### STDOUT 的任务输出
<a name="task-outputs-cwl-stdout"></a>

此示例创建了一个`CommandLineTool`任务，该任务将 STDOUT 内容回显到名为的文本输出文件中。**output.txt**例如，如果您提供以下输入，则生成的任务输出为 **Hello World！** 在**output.txt**文件中。

```
{
    "message": "Hello World!"
}
```

该`outputs`指令指定输出名称为**example\$1out**，其类型为`stdout`。要使下游任务消耗此任务的输出，它将输出称为`example_out`。

由于 HealthOmics 会为所有 STDERR 和 STDOUT 内容创建日志，因此输出也会与任务的其他 STDERR CloudWatch 日志信息一起显示在日志中。

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: echo
stdout: output.txt
inputs:
  message:
    type: string
    inputBinding:
      position: 1
outputs:
  example_out:
    type: stdout

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### STDERR 的任务输出
<a name="task-outputs-cwl-stderr"></a>

此示例创建了一个`CommandLineTool`任务，该任务将 STDERR 内容回显到名为的文本输出文件中。**stderr.txt**该任务会修改，`baseCommand`以便`echo`写入 STDERR（而不是 STDOUT）。

该`outputs`指令指定输出名称为**stderr\$1out**，其类型为`stderr`。

由于 HealthOmics 会为所有 STDERR 和 STDOUT 内容创建日志，因此输出将与任务的其他 STDERR CloudWatch 日志信息一起显示在日志中。

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: [bash, -c]
stderr: stderr.txt
inputs:
  message:
    type: string
    inputBinding:
      position: 1
      shellQuote: true
      valueFrom: "echo $(self) >&2"
outputs:
  stderr_out:
    type: stderr

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### 任务输出到文件
<a name="task-outputs-cwl-file"></a>

此示例创建了一个`CommandLineTool`任务，该任务根据输入文件创建压缩的 tar 存档。您可以将档案的名称作为输入参数 (archive\$1name) 提供。

该**outputs**指令指定`archive_file`输出类型为`File`，并使用对输入参数的引用绑定`archive_name`到输出文件。

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: [tar, cfz]
inputs:
  archive_name:
    type: string
    inputBinding:
      position: 1
  input_files:
    type: File[]
    inputBinding:
      position: 2
      
outputs:
  archive_file:
    type: File
    outputBinding:
      glob: "$(inputs.archive_name)"

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```

### 任务输出到文件数组
<a name="task-outputs-cwl-files"></a>

在此示例中，`CommandLineTool`任务使用`touch`命令创建文件数组。该命令使用`files-to-create`输入参数中的字符串来命名文件。该命令输出文件数组。该数组包括工作目录中与`glob`模式匹配的所有文件。此示例使用与所有文件匹配的通配符模式 (“\$1”)。

```
cwlVersion: v1.2
class: CommandLineTool
baseCommand: touch
inputs:
  files-to-create:
    type:
      type: array
      items: string
    inputBinding:
      position: 1
outputs:
  output-files:
    type:
      type: array
      items: File
    outputBinding:
      glob: "*"

requirements:
    DockerRequirement:
        dockerPull: 123456789012.dkr.ecr.us-east-1.amazonaws.com/dockerhub/library/ubuntu:20.04
    ResourceRequirement:
        ramMin: 2048
        coresMin: 1
```