Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Resultados de tareas en una definición de HealthOmics flujo de trabajo
Los resultados de las tareas se especifican en la definición del flujo de trabajo. De forma predeterminada, HealthOmics descarta todos los archivos de tareas intermedias cuando se completa el flujo de trabajo. Para exportar un archivo intermedio, debe definirlo como una salida.
Si utiliza el almacenamiento en caché de llamadas, HealthOmics guarda los resultados de las tareas en la memoria caché, incluidos los archivos intermedios que defina como resultados.
Los siguientes temas incluyen ejemplos de definiciones de tareas para cada uno de los lenguajes de definición de flujos de trabajo.
**Topics**
+ [Resultados de tareas para WDL](#workflow-task-outputs-wdl)
+ [Resultados de tareas para Nextflow](#workflow-task-outputs-nextflow)
+ [Resultados de tareas para CWL](#workflow-task-outputs-cwl)
## Resultados de tareas para WDL
Para las definiciones de flujo de trabajo escritas en WDL, defina los resultados en la sección de flujo **outputs** de trabajo de nivel superior.
HealthOmics
**Topics**
+ [Resultado de la tarea para STDOUT](#task-outputs-wdl-stdout)
+ [Resultado de la tarea para STDERR](#task-outputs-wdl-stderr)
+ [Salida de la tarea a un archivo](#task-outputs-wdl-file)
+ [Salida de la tarea a una matriz de archivos](#task-outputs-wdl-files)
### Resultado de la tarea para STDOUT
En este ejemplo, se crea una tarea con un nombre `SayHello` que refleja el contenido de STDOUT en el archivo de resultados de la tarea. **La **stdout** función WDL captura el contenido de STDOUT (en este ejemplo, la cadena de entrada Hello World\$1** ) en un archivo. **stdout\$1file**
Como HealthOmics crea registros para todo el contenido de STDOUT, el resultado también aparece en los CloudWatch registros, junto con otra información de registro de STDERR para la tarea.
```
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()
}
}
```
### Resultado de la tarea para STDERR
En este ejemplo, se crea una tarea con un nombre `SayHello` que refleja el contenido de STDERR en el archivo de resultados de la tarea. **La **stderr** función WDL captura el contenido STDERR (en este ejemplo, la cadena de entrada Hello World\$1** ) en un archivo. **stderr\$1file**
Como HealthOmics crea registros para todo el contenido de STDERR, el resultado aparecerá en CloudWatch Registros junto con otra información de registro de STDERR correspondiente a la tarea.
```
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()
}
}
```
### Salida de la tarea a un archivo
En este ejemplo, la SayHello tarea crea dos archivos (message.txt y info.txt) y los declara explícitamente como las salidas con nombre (message\$1file e 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"
}
}
```
### Salida de la tarea a una matriz de archivos
En este ejemplo, la `GenerateGreetings` tarea genera una matriz de archivos como resultado de la tarea. La tarea genera dinámicamente un archivo de saludo para cada miembro de la matriz de entrada`names`. Como los nombres de los archivos no se conocen hasta el momento de ejecución, la definición de salida utiliza la función WDL glob () para generar todos los archivos que coincidan con el patrón. `*_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")
}
}
```
## Resultados de tareas para Nextflow
Para las definiciones de flujo de trabajo escritas en Nextflow, defina una directiva **PublishDir** para exportar el contenido de las tareas a su bucket de Amazon S3 de salida. Establezca el valor **PublishDir** en. `/mnt/workflow/pubdir`
HealthOmics Para poder exportar archivos a Amazon S3, los archivos deben estar en este directorio.
Si una tarea genera un grupo de archivos de salida para usarlos como entradas en una tarea posterior, le recomendamos que agrupe estos archivos en un directorio y emita el directorio como resultado de la tarea. La enumeración de cada archivo individual puede provocar un cuello de botella de E/S en el sistema de archivos subyacente. Por ejemplo:
```
process my_task {
...
// recommended
output "output-folder/", emit: output
// not recommended
// output "output-folder/**", emit: output
...
}
```
## Resultados de tareas para CWL
Para las definiciones de flujo de trabajo escritas en CWL, puede especificar los resultados de las tareas mediante `CommandLineTool` tareas. En las siguientes secciones se muestran ejemplos de `CommandLineTool` tareas que definen distintos tipos de resultados.
**Topics**
+ [Resultado de la tarea para STDOUT](#task-outputs-cwl-stdout)
+ [Resultado de la tarea para STDERR](#task-outputs-cwl-stderr)
+ [Salida de la tarea a un archivo](#task-outputs-cwl-file)
+ [Salida de la tarea a una matriz de archivos](#task-outputs-cwl-files)
### Resultado de la tarea para STDOUT
En este ejemplo se crea una `CommandLineTool` tarea que reproduce el contenido de STDOUT en un archivo de salida de texto denominado. **output.txt** **Por ejemplo, si proporciona la siguiente entrada, el resultado de la tarea será ¡Hola mundo\$1** en el **output.txt** archivo.
```
{
"message": "Hello World!"
}
```
La `outputs` directiva especifica que el nombre de la salida es **example\$1out** y su tipo es`stdout`. Para que una tarea posterior consuma el resultado de esta tarea, se referirá al resultado como`example_out`.
Como HealthOmics crea registros para todo el contenido de STDERR y STDOUT, el resultado también aparece en los CloudWatch registros, junto con otra información de registro de STDERR para la tarea.
```
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
```
### Resultado de la tarea para STDERR
En este ejemplo se crea una `CommandLineTool` tarea que reproduce el contenido de STDERR en un archivo de salida de texto denominado. **stderr.txt** La tarea modifica el `baseCommand` modo que se `echo` escribe en STDERR (en lugar de en STDOUT).
La `outputs` directiva especifica que el nombre de la salida es **stderr\$1out** y su tipo es. `stderr`
Como HealthOmics crea registros para todo el contenido de STDERR y STDOUT, el resultado aparecerá en los CloudWatch registros, junto con otra información de registro de STDERR para la tarea.
```
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
```
### Salida de la tarea a un archivo
En este ejemplo se crea una `CommandLineTool` tarea que crea un archivo tar comprimido a partir de los archivos de entrada. El nombre del archivo se proporciona como parámetro de entrada (archive\$1name).
La **outputs** directiva especifica que el tipo `archive_file` de salida es `File` y utiliza una referencia al parámetro de entrada para enlazarlo `archive_name` al archivo de salida.
```
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
```
### Salida de la tarea a una matriz de archivos
En este ejemplo, la `CommandLineTool` tarea crea una matriz de archivos mediante el `touch` comando. El comando usa las cadenas del parámetro `files-to-create` de entrada para nombrar los archivos. El comando genera una matriz de archivos. La matriz incluye todos los archivos del directorio de trabajo que coincidan con el `glob` patrón. En este ejemplo se utiliza un patrón comodín («\$1») que coincide con todos los archivos.
```
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
```