Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Aufgabenausgaben in einer HealthOmics Workflow-Definition
<a name="workflows-task-outputs"></a>

Sie geben Aufgabenausgaben in der Workflow-Definition an. Verwirft standardmäßig alle zwischengeschalteten Aufgabendateien, HealthOmics wenn der Workflow abgeschlossen ist. Um eine Zwischendatei zu exportieren, definieren Sie sie als Ausgabe. 

Wenn Sie das Aufruf-Caching verwenden, werden die Ausgaben der Aufgaben im Cache HealthOmics gespeichert, einschließlich aller Zwischendateien, die Sie als Ausgaben definieren.

Die folgenden Themen enthalten Beispiele für Aufgabendefinitionen für jede der Workflow-Definitionssprachen.

**Topics**
+ [Aufgabenausgaben für WDL](#workflow-task-outputs-wdl)
+ [Task-Ausgaben für Nextflow](#workflow-task-outputs-nextflow)
+ [Aufgabenausgaben für CWL](#workflow-task-outputs-cwl)

## Aufgabenausgaben für WDL
<a name="workflow-task-outputs-wdl"></a>

Für in WDL geschriebene Workflow-Definitionen definieren Sie Ihre Ausgaben im **outputs** Workflow-Bereich der obersten Ebene. 

HealthOmics

**Topics**
+ [Aufgabenausgabe für STDOUT](#task-outputs-wdl-stdout)
+ [Aufgabenausgabe für STDERR](#task-outputs-wdl-stderr)
+ [Ausgabe der Aufgabe in eine Datei](#task-outputs-wdl-file)
+ [Ausgabe der Aufgabe in ein Array von Dateien](#task-outputs-wdl-files)

### Aufgabenausgabe für STDOUT
<a name="task-outputs-wdl-stdout"></a>

In diesem Beispiel wird eine Aufgabe mit dem Namen erstellt`SayHello`, die den STDOUT-Inhalt in die Aufgabenausgabedatei zurückgibt. **Die **stdout** WDL-Funktion erfasst den STDOUT-Inhalt (in diesem Beispiel die Eingabezeichenfolge Hello World\$1** ) in einer Datei. **stdout\$1file** 

Da Protokolle für den gesamten STDOUT-Inhalt HealthOmics erstellt werden, wird die Ausgabe zusammen mit anderen CloudWatch STDERR-Protokollierungsinformationen für die Aufgabe auch in Logs angezeigt.

```
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()
    }
}
```

### Aufgabenausgabe für STDERR
<a name="task-outputs-wdl-stderr"></a>

In diesem Beispiel wird eine Aufgabe mit dem Namen erstellt`SayHello`, die den STDERR-Inhalt in die Aufgabenausgabedatei zurückgibt. **Die **stderr** WDL-Funktion erfasst den STDERR-Inhalt (in diesem Beispiel die Eingabezeichenfolge Hello World\$1** ) in einer Datei. **stderr\$1file** 

Da Protokolle für den gesamten STDERR-Inhalt HealthOmics erstellt werden, wird die Ausgabe zusammen mit anderen CloudWatch STDERR-Protokollierungsinformationen für die Aufgabe in Logs angezeigt.

```
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()
    }
}
```

### Ausgabe der Aufgabe in eine Datei
<a name="task-outputs-wdl-file"></a>

In diesem Beispiel erstellt die SayHello Aufgabe zwei Dateien (message.txt und info.txt) und deklariert diese Dateien explizit als die benannten Ausgaben (message\$1file und 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"
    } 
}
```

### Ausgabe der Aufgabe in ein Array von Dateien
<a name="task-outputs-wdl-files"></a>

In diesem Beispiel generiert die `GenerateGreetings` Aufgabe ein Array von Dateien als Aufgabenausgabe. Die Aufgabe generiert dynamisch eine Begrüßungsdatei für jedes Mitglied des Eingabearrays`names`. Da die Dateinamen erst zur Laufzeit bekannt sind, verwendet die Ausgabedefinition die WDL-Funktion glob (), um alle Dateien auszugeben, die dem Muster entsprechen. `*_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")
    }       
 }
```

## Task-Ausgaben für Nextflow
<a name="workflow-task-outputs-nextflow"></a>

Definieren Sie für in Nextflow geschriebene Workflow-Definitionen eine **publishDir-Direktive**, um Aufgabeninhalte in Ihren Amazon S3 S3-Ausgabe-Bucket zu exportieren. Setzen Sie den Wert **publishDir** auf. `/mnt/workflow/pubdir` 

 HealthOmics Um Dateien nach Amazon S3 exportieren zu können, müssen sich die Dateien in diesem Verzeichnis befinden.

Wenn eine Aufgabe eine Gruppe von Ausgabedateien erzeugt, die als Eingaben für eine nachfolgende Aufgabe verwendet werden sollen, empfehlen wir, diese Dateien in einem Verzeichnis zu gruppieren und das Verzeichnis als Aufgabenausgabe auszugeben. Das Aufzählen jeder einzelnen Datei kann zu einem I/O-Engpass im zugrunde liegenden Dateisystem führen. Zum Beispiel:

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

## Aufgabenausgaben für CWL
<a name="workflow-task-outputs-cwl"></a>

Bei in CWL geschriebenen Workflow-Definitionen können Sie die Aufgabenausgaben mithilfe von `CommandLineTool` Aufgaben angeben. Die folgenden Abschnitte zeigen Beispiele für `CommandLineTool` Aufgaben, die verschiedene Arten von Ausgaben definieren.

**Topics**
+ [Aufgabenausgabe für STDOUT](#task-outputs-cwl-stdout)
+ [Aufgabenausgabe für STDERR](#task-outputs-cwl-stderr)
+ [Ausgabe der Aufgabe in eine Datei](#task-outputs-cwl-file)
+ [Ausgabe der Aufgabe in ein Array von Dateien](#task-outputs-cwl-files)

### Aufgabenausgabe für STDOUT
<a name="task-outputs-cwl-stdout"></a>

In diesem Beispiel wird eine `CommandLineTool` Aufgabe erstellt, die den STDOUT-Inhalt in einer Textausgabedatei mit dem Namen wiedergibt. **output.txt** **Wenn Sie beispielsweise die folgende Eingabe angeben, lautet die resultierende Aufgabenausgabe Hello World\$1** in der **output.txt** Datei.

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

Die `outputs` Direktive gibt an, dass der Ausgabename **example\$1out** und der Typ lauten`stdout`. Damit eine Downstream-Aufgabe die Ausgabe dieser Aufgabe verarbeitet, würde sie die Ausgabe als bezeichnen`example_out`.

Da Protokolle für den gesamten STDERR- und STDOUT-Inhalt HealthOmics erstellt werden, wird die Ausgabe zusammen mit anderen CloudWatch STDERR-Protokollierungsinformationen für die Aufgabe auch in Logs angezeigt.

```
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
```

### Aufgabenausgabe für STDERR
<a name="task-outputs-cwl-stderr"></a>

In diesem Beispiel wird eine `CommandLineTool` Aufgabe erstellt, die den STDERR-Inhalt in einer Textausgabedatei mit dem Namen wiedergibt. **stderr.txt** Die Aufgabe ändert die `baseCommand` so, dass sie in STDERR (statt STDOUT) `echo` schreibt.

Die `outputs` Direktive gibt an, dass der Ausgabename **stderr\$1out** und der Typ lautet. `stderr` 

Da Protokolle für den gesamten STDERR- und STDOUT-Inhalt HealthOmics erstellt werden, wird die Ausgabe zusammen mit anderen CloudWatch STDERR-Protokollierungsinformationen für die Aufgabe in Logs angezeigt.

```
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
```

### Ausgabe der Aufgabe in eine Datei
<a name="task-outputs-cwl-file"></a>

In diesem Beispiel wird eine `CommandLineTool` Aufgabe erstellt, die aus den Eingabedateien ein komprimiertes Tar-Archiv erstellt. Sie geben den Namen des Archivs als Eingabeparameter an (archive\$1name). 

Die **outputs** Direktive gibt an, dass der `archive_file` Ausgabetyp ist`File`, und sie verwendet einen Verweis auf den Eingabeparameter`archive_name`, um eine Bindung an die Ausgabedatei herzustellen.

```
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
```

### Ausgabe der Aufgabe in ein Array von Dateien
<a name="task-outputs-cwl-files"></a>

In diesem Beispiel erstellt die `CommandLineTool` Aufgabe mithilfe des `touch` Befehls ein Array von Dateien. Der Befehl verwendet die Zeichenketten im `files-to-create` Eingabeparameter, um die Dateien zu benennen. Der Befehl gibt ein Array von Dateien aus. Das Array enthält alle Dateien im Arbeitsverzeichnis, die dem `glob` Muster entsprechen. In diesem Beispiel wird ein Platzhaltermuster („\$1“) verwendet, das allen Dateien entspricht.

```
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
```