Saltar a contenido

Parte 2: Implementación de muestra única

Traducción asistida por IA - más información y sugerencias

En esta parte del curso, vamos a escribir el flujo de trabajo más simple posible que envuelva todos los comandos que ejecutamos en la Parte 1 para automatizar su ejecución, y nos enfocaremos en procesar una muestra a la vez.

Requisito previo

Debe completar la Parte 1: Descripción del método antes de comenzar esta lección. Específicamente, trabajar en la sección 1.2.3 crea el archivo de índice del genoma (data/genome_index.tar.gz) requerido para el paso de alineamiento en esta lección.

Asignación

En esta parte del curso, vamos a desarrollar un flujo de trabajo que hace lo siguiente:

  1. Ejecutar control de calidad (FastQC) en las lecturas de entrada
  2. Recortar adaptadores y ejecutar control de calidad posterior al recorte (Trim Galore)
  3. Alinear las lecturas recortadas a un genoma de referencia (HISAT2)
Raw Reads(FastQ)Genome IndexFASTQCTRIM_GALOREHISAT2_ALIGNTrimmed Reads(FastQ)QC 1QC 2Aln QCAligned Reads

Esto automatiza los pasos de la primera sección de la Parte 1: Descripción del método, donde ejecutó estos comandos manualmente en sus contenedores.

Como punto de partida, le proporcionamos un archivo de flujo de trabajo, rnaseq.nf, que describe las partes principales del flujo de trabajo, así como cuatro archivos de módulo en el directorio modules/ (fastqc.nf, trim_galore.nf, hisat2_align.nf y multiqc.nf) que describen la estructura de cada proceso.

Archivos de esqueleto
rnaseq.nf
#!/usr/bin/env nextflow

// Module INCLUDE statements

/*
 * Pipeline parameters
 */

// Primary input

workflow {

    main:
    // Create input channel

    // Call processes

    publish:
    // Declare outputs to publish
}

output {
    // Configure publish targets
}
modules/fastqc.nf
#!/usr/bin/env nextflow

/*
 * Run FastQC on input reads
 */
process FASTQC {

    container

    input:

    output:

    script:
    """

    """
}
modules/trim_galore.nf
#!/usr/bin/env nextflow

/*
 * Trim adapters and run post-trimming QC
 */
process TRIM_GALORE {

    container

    input:

    output:

    script:
    """

    """
}
modules/hisat2_align.nf
#!/usr/bin/env nextflow

/*
 * Align reads to a reference genome
 */
process HISAT2_ALIGN {

    container

    input:

    output:

    script:
    """

    """
}
modules/multiqc.nf
#!/usr/bin/env nextflow

/*
 * Aggregate QC reports with MultiQC
 */
process MULTIQC {

    container

    input:

    output:

    script:
    """

    """
}

Estos archivos no son funcionales; su propósito es solo servir como esqueletos para que los complete con las partes interesantes del código.

Plan de la lección

Para hacer el proceso de desarrollo más educativo, lo hemos dividido en tres etapas:

  1. Escribir un flujo de trabajo de una sola etapa que ejecute el paso de control de calidad inicial. Esto cubre la configuración de un parámetro CLI, la creación de un canal de entrada, la escritura de un módulo de proceso y la configuración de publicación de salida.
  2. Agregar recorte de adaptadores y control de calidad posterior al recorte. Esto introduce el encadenamiento de procesos conectando la salida de un proceso con la entrada de otro.
  3. Agregar alineamiento al genoma de referencia. Esto cubre el manejo de entradas de referencia adicionales y el trabajo con archivos comprimidos.

Cada paso se enfoca en un aspecto específico del desarrollo de flujos de trabajo.

Consejo

Asegúrese de estar en el directorio de trabajo correcto: cd /workspaces/training/nf4-science/rnaseq

1. Escribir un flujo de trabajo de una sola etapa que ejecute el control de calidad inicial

Este primer paso se enfoca en lo básico: cargar un archivo FASTQ y ejecutar control de calidad en él.

Recuerde el comando fastqc de la Parte 1:

fastqc <reads>

El comando toma un archivo FASTQ como entrada y produce un informe de control de calidad como un archivo .zip y un resumen .html. El URI del contenedor era community.wave.seqera.io/library/trim-galore:0.6.10--1bf8ca4e1967cd18.

Vamos a tomar esta información y envolverla en Nextflow en tres etapas:

  1. Configurar la entrada
  2. Escribir el proceso de control de calidad y llamarlo en el flujo de trabajo
  3. Configurar el manejo de salida

1.1. Configurar la entrada

Necesitamos declarar un parámetro de entrada, crear un perfil de prueba para proporcionar un valor predeterminado conveniente y crear un canal de entrada.

1.1.1. Agregar una declaración de parámetro de entrada

En rnaseq.nf, bajo la sección Pipeline parameters, declare un parámetro llamado reads con el tipo Path.

rnaseq.nf
 5
 6
 7
 8
 9
10
11
/*
 * Pipeline parameters
 */
params {
    // Primary input
    input: Path
}
rnaseq.nf
5
6
7
8
9
/*
 * Pipeline parameters
 */

// Primary input

Eso configura el parámetro CLI, pero no queremos escribir la ruta del archivo cada vez que ejecutamos el flujo de trabajo durante el desarrollo. Hay múltiples opciones para proporcionar un valor predeterminado; aquí usamos un perfil de prueba.

1.1.2. Crear un perfil de prueba con un valor predeterminado en nextflow.config

Un perfil de prueba proporciona valores predeterminados convenientes para probar un flujo de trabajo sin especificar entradas en la línea de comandos. Esta es una convención común en el ecosistema Nextflow (consulte Hello Config para más detalles).

Agregue un bloque profiles a nextflow.config con un perfil test que establezca el parámetro reads en uno de los archivos FASTQ de prueba.

nextflow.config
1
2
3
4
5
6
7
docker.enabled = true

profiles {
    test {
        params.input = "${projectDir}/data/reads/ENCSR000COQ1_1.fastq.gz"
    }
}
nextflow.config
1
docker.enabled = true

Aquí, estamos usando ${projectDir}, una variable integrada de Nextflow que apunta al directorio donde se encuentra el script del flujo de trabajo. Esto facilita la referencia a archivos de datos y otros recursos sin codificar rutas absolutas.

El parámetro ahora tiene un valor predeterminado conveniente. A continuación, necesitamos crear un canal a partir de él.

1.1.3. Configurar el canal de entrada

En el bloque workflow, cree un canal de entrada a partir del valor del parámetro usando la fábrica de canal .fromPath (como se usa en Hello Channels).

rnaseq.nf
13
14
15
16
17
18
19
20
21
22
23
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Call processes

    publish:
    // Declare outputs to publish
}
rnaseq.nf
13
14
15
16
17
18
19
20
21
22
workflow {

    main:
    // Create input channel

    // Call processes

    publish:
    // Declare outputs to publish
}

A continuación, necesitaremos crear el proceso para ejecutar control de calidad en esta entrada.

1.2. Escribir el proceso de control de calidad y llamarlo en el flujo de trabajo

Necesitamos completar la definición del proceso en el archivo de módulo, importarlo al flujo de trabajo usando una declaración include y llamarlo en la entrada.

1.2.1. Completar el módulo para el proceso de control de calidad

Abra modules/fastqc.nf y examine el esquema de la definición del proceso. Debería reconocer los elementos estructurales principales; si no, considere leer Hello Nextflow para refrescar la memoria.

Adelante, complete la definición del proceso por su cuenta usando la información proporcionada anteriormente, luego verifique su trabajo contra la solución en la pestaña "Después" a continuación.

modules/fastqc.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env nextflow

/*
 * Run FastQC on input reads
 */
process FASTQC {

    container

    input:

    output:

    script:
    """

    """
}
modules/fastqc.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env nextflow

/*
 * Run FastQC on input reads
 */
process FASTQC {

    container "community.wave.seqera.io/library/trim-galore:0.6.10--1bf8ca4e1967cd18"

    input:
    path reads

    output:
    path "${reads.simpleName}_fastqc.zip", emit: zip
    path "${reads.simpleName}_fastqc.html", emit: html

    script:
    """
    fastqc ${reads}
    """
}

El accesor simpleName elimina todas las extensiones del nombre del archivo, por lo que ENCSR000COQ1_1.fastq.gz se convierte en ENCSR000COQ1_1. Usamos la sintaxis emit: para asignar nombres a cada canal de salida, lo que será útil para conectar las salidas al bloque publish.

Una vez que haya completado esto, el proceso está completo. Para usarlo en el flujo de trabajo, necesitará importar el módulo y agregar una llamada al proceso.

1.2.2. Incluir el módulo

En rnaseq.nf, agregue una declaración include para hacer que el proceso esté disponible para el flujo de trabajo:

rnaseq.nf
3
4
// Module INCLUDE statements
include { FASTQC } from './modules/fastqc.nf'
rnaseq.nf
3
// Module INCLUDE statements

El proceso ahora está disponible en el ámbito del flujo de trabajo.

1.2.3. Llamar al proceso de control de calidad en la entrada

Agregue una llamada a FASTQC en el bloque workflow, pasando el canal de entrada como argumento.

rnaseq.nf
14
15
16
17
18
19
20
21
22
23
24
25
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Initial quality control
    FASTQC(read_ch)

    publish:
    // Declare outputs to publish
}
rnaseq.nf
14
15
16
17
18
19
20
21
22
23
24
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Call processes

    publish:
    // Declare outputs to publish
}

El flujo de trabajo ahora carga la entrada y ejecuta el proceso de control de calidad en ella. A continuación, necesitamos configurar cómo se publica la salida.

1.3. Configurar el manejo de salida

Necesitamos declarar qué salidas de proceso publicar y especificar dónde deben ir.

1.3.1. Declarar salidas en la sección publish:

La sección publish: dentro del bloque workflow declara qué salidas de proceso deben publicarse. Asigne las salidas de FASTQC a destinos nombrados.

rnaseq.nf
23
24
25
26
    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
}
rnaseq.nf
23
24
25
    publish:
    // Declare outputs to publish
}

A continuación, necesitaremos decirle a Nextflow dónde poner las salidas publicadas.

1.3.2. Configurar los destinos de salida en el bloque output {}

El bloque output {} se encuentra fuera del flujo de trabajo y especifica dónde se publica cada destino nombrado. Configure ambos destinos para publicar en un subdirectorio fastqc/.

rnaseq.nf
28
29
30
31
32
33
34
35
output {
    fastqc_zip {
        path 'fastqc'
    }
    fastqc_html {
        path 'fastqc'
    }
}
rnaseq.nf
28
29
30
output {
    // Configure publish targets
}

Nota

Por defecto, Nextflow publica archivos de salida como enlaces simbólicos, lo que evita duplicación innecesaria. Aunque los archivos de datos que estamos usando aquí son muy pequeños, en genómica pueden volverse muy grandes. Los enlaces simbólicos se romperán cuando limpie su directorio work, por lo que para flujos de trabajo de producción es posible que desee anular el modo de publicación predeterminado a 'copy'.

1.4. Ejecutar el flujo de trabajo

En este punto, tenemos un flujo de trabajo de control de calidad de un paso que debería ser completamente funcional.

Ejecutamos con -profile test para usar el valor predeterminado configurado en el perfil de prueba, evitando la necesidad de escribir la ruta en la línea de comandos.

nextflow run rnaseq.nf -profile test
Salida del comando 
N E X T F L O W   ~  version 25.10.2

Launching `rnaseq.nf` [mad_lorenz] DSL2 - revision: 5846a164d2

executor >  local (1)
[7b/8ee79e] FASTQC (1) | 1 of 1 ✔

Esto debería ejecutarse muy rápidamente si trabajó en la Parte 1 y ya ha descargado el contenedor. Si la omitió, Nextflow descargará el contenedor por usted; no tiene que hacer nada para que suceda, pero es posible que deba esperar hasta un minuto.

Puede verificar las salidas en el directorio de resultados.

ls results/fastqc
Salida
ENCSR000COQ1_1_fastqc.html  ENCSR000COQ1_1_fastqc.zip

Los informes de control de calidad para la muestra ahora están publicados en el subdirectorio fastqc/.

Conclusión

Sabe cómo crear un módulo que contiene un proceso, importarlo a un flujo de trabajo, llamarlo con un canal de entrada y publicar los resultados usando el bloque de salida a nivel de flujo de trabajo.

¿Qué sigue?

Agregue recorte de adaptadores con control de calidad posterior al recorte como un segundo paso en el flujo de trabajo.

2. Agregar recorte de adaptadores y control de calidad posterior al recorte

Ahora que tenemos el control de calidad inicial en su lugar, podemos agregar el paso de recorte de adaptadores con su control de calidad posterior al recorte integrado.

Recuerde el comando trim_galore de la Parte 1:

trim_galore --fastqc <reads>

El comando recorta adaptadores de un archivo FASTQ y ejecuta FastQC en la salida recortada. Produce lecturas recortadas, un informe de recorte e informes FastQC para las lecturas recortadas. El URI del contenedor era community.wave.seqera.io/library/trim-galore:0.6.10--1bf8ca4e1967cd18.

Solo necesitamos escribir la definición del proceso, importarlo, llamarlo en el flujo de trabajo y actualizar el manejo de salida.

2.1. Escribir el proceso de recorte y llamarlo en el flujo de trabajo

Como antes, necesitamos completar la definición del proceso, importar el módulo y agregar la llamada al proceso.

2.1.1. Completar el módulo para el proceso de recorte

Abra modules/trim_galore.nf y examine el esquema de la definición del proceso.

Adelante, complete la definición del proceso por su cuenta usando la información proporcionada anteriormente, luego verifique su trabajo contra la solución en la pestaña "Después" a continuación.

modules/trim_galore.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env nextflow

/*
 * Trim adapters and run post-trimming QC
 */
process TRIM_GALORE {

    container

    input:

    output:

    script:
    """

    """
}
modules/trim_galore.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env nextflow

/*
 * Trim adapters and run post-trimming QC
 */
process TRIM_GALORE {

    container "community.wave.seqera.io/library/trim-galore:0.6.10--1bf8ca4e1967cd18"

    input:
    path reads

    output:
    path "${reads.simpleName}_trimmed.fq.gz", emit: trimmed_reads
    path "${reads}_trimming_report.txt", emit: trimming_reports
    path "${reads.simpleName}_trimmed_fastqc.{zip,html}", emit: fastqc_reports

    script:
    """
    trim_galore --fastqc ${reads}
    """
}

Este proceso tiene tres salidas nombradas: las lecturas recortadas que alimentan el paso de alineamiento, el informe de recorte y los informes FastQC posteriores al recorte. La bandera --fastqc le dice a Trim Galore que ejecute automáticamente FastQC en la salida recortada.

2.1.2. Incluir el módulo

Actualice rnaseq.nf para importar el nuevo módulo:

rnaseq.nf
3
4
5
// Module INCLUDE statements
include { FASTQC } from './modules/fastqc.nf'
include { TRIM_GALORE } from './modules/trim_galore.nf'
rnaseq.nf
3
4
// Module INCLUDE statements
include { FASTQC } from './modules/fastqc.nf'

A continuación, agregaremos la llamada al proceso al flujo de trabajo.

2.1.3. Llamar al proceso de recorte en la entrada

Agregue la llamada al proceso en el bloque workflow:

rnaseq.nf
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Initial quality control
    FASTQC(read_ch)

    // Adapter trimming and post-trimming QC
    TRIM_GALORE(read_ch)

    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
}
rnaseq.nf
15
16
17
18
19
20
21
22
23
24
25
26
27
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Initial quality control
    FASTQC(read_ch)

    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
}

El proceso de recorte ahora está conectado al flujo de trabajo.

2.2. Actualizar el manejo de salida

Necesitamos agregar las salidas de recorte a la declaración de publicación y configurar dónde van.

2.2.1. Agregar destinos de publicación para las salidas de recorte

Agregue las salidas de recorte a la sección publish::

rnaseq.nf
27
28
29
30
31
32
33
    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
    trimmed_reads = TRIM_GALORE.out.trimmed_reads
    trimming_reports = TRIM_GALORE.out.trimming_reports
    trimming_fastqc = TRIM_GALORE.out.fastqc_reports
}
rnaseq.nf
27
28
29
30
    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
}

A continuación, necesitaremos decirle a Nextflow dónde poner estas salidas.

2.2.2. Configurar los nuevos destinos de salida

Agregue entradas para los destinos de recorte en el bloque output {}, publicándolos en un subdirectorio trimming/:

rnaseq.nf
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
output {
    fastqc_zip {
        path 'fastqc'
    }
    fastqc_html {
        path 'fastqc'
    }
    trimmed_reads {
        path 'trimming'
    }
    trimming_reports {
        path 'trimming'
    }
    trimming_fastqc {
        path 'trimming'
    }
}
rnaseq.nf
35
36
37
38
39
40
41
42
output {
    fastqc_zip {
        path 'fastqc'
    }
    fastqc_html {
        path 'fastqc'
    }
}

La configuración de salida está completa.

2.3. Ejecutar el flujo de trabajo

El flujo de trabajo ahora incluye tanto el control de calidad inicial como el recorte de adaptadores.

nextflow run rnaseq.nf -profile test
Salida del comando 
N E X T F L O W   ~  version 25.10.2

Launching `rnaseq.nf` [gloomy_becquerel] DSL2 - revision: bb11055736

executor >  local (2)
[f6/c8ef2e] FASTQC (1)      | 1 of 1 ✔
[58/c58d8a] TRIM_GALORE (1) | 1 of 1 ✔

Esto también debería ejecutarse muy rápidamente, ya que estamos ejecutando en un archivo de entrada tan pequeño.

Puede encontrar las salidas de recorte en el directorio de resultados.

ls results/trimming
Salida
ENCSR000COQ1_1.fastq.gz_trimming_report.txt  ENCSR000COQ1_1_trimmed_fastqc.zip
ENCSR000COQ1_1_trimmed_fastqc.html           ENCSR000COQ1_1_trimmed.fq.gz

Las salidas de recorte y los informes de control de calidad posterior al recorte ahora están en el subdirectorio trimming/.

Conclusión

Sabe cómo agregar un segundo paso de procesamiento que se ejecuta independientemente en la misma entrada, produciendo múltiples salidas nombradas.

¿Qué sigue?

Agregue el paso de alineamiento que se encadena a partir de la salida de lecturas recortadas.

3. Agregar alineamiento al genoma de referencia

Finalmente podemos agregar el paso de alineamiento del genoma usando HISAT2.

Recuerde el comando de alineamiento de la Parte 1:

hisat2 -x <genome_index> -U <reads> \
    --new-summary --summary-file <reads>.hisat2.log | \
    samtools view -bS -o <reads>.bam

El comando alinea lecturas a un genoma de referencia y convierte la salida a formato BAM. Requiere un archivo de índice del genoma preconstruido y produce un archivo BAM y un registro de resumen de alineamiento. El URI del contenedor era community.wave.seqera.io/library/hisat2_samtools:5e49f68a37dc010e.

Este proceso requiere una entrada adicional (el archivo de índice del genoma), por lo que necesitamos configurar eso primero, luego escribir y conectar el proceso.

3.1. Configurar las entradas

Necesitamos declarar un parámetro para el archivo de índice del genoma.

3.1.1. Agregar un parámetro para el índice del genoma

Agregue una declaración de parámetro para el archivo de índice del genoma en rnaseq.nf:

rnaseq.nf
11
12
13
14
15
16
17
params {
    // Primary input
    input: Path

    // Reference genome archive
    hisat2_index_zip: Path
}
rnaseq.nf
11
12
13
14
params {
    // Primary input
    input: Path
}

3.1.2. Agregar el índice del genoma predeterminado al perfil de prueba

Tal como hicimos para reads en la sección 1.1.2, agregue un valor predeterminado para el índice del genoma al perfil de prueba en nextflow.config:

nextflow.config
1
2
3
4
5
6
7
8
docker.enabled = true

profiles {
    test {
        params.input = "${projectDir}/data/reads/ENCSR000COQ1_1.fastq.gz"
        params.hisat2_index_zip = "${projectDir}/data/genome_index.tar.gz"
    }
}
nextflow.config
1
2
3
4
5
6
7
docker.enabled = true

profiles {
    test {
        params.input = "${projectDir}/data/reads/ENCSR000COQ1_1.fastq.gz"
    }
}

El parámetro está listo; ahora podemos crear el proceso de alineamiento.

3.2. Escribir el proceso de alineamiento y llamarlo en el flujo de trabajo

Como antes, necesitamos completar la definición del proceso, importar el módulo y agregar la llamada al proceso.

3.2.1. Completar el módulo para el proceso de alineamiento

Abra modules/hisat2_align.nf y examine el esquema de la definición del proceso.

Adelante, complete la definición del proceso por su cuenta usando la información proporcionada anteriormente, luego verifique su trabajo contra la solución en la pestaña "Después" a continuación.

modules/hisat2_align.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env nextflow

/*
 * Align reads to a reference genome
 */
process HISAT2_ALIGN {

    container

    input:

    output:

    script:
    """

    """
}
modules/hisat2_align.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/env nextflow

/*
 * Align reads to a reference genome
 */
process HISAT2_ALIGN {

    container "community.wave.seqera.io/library/hisat2_samtools:5e49f68a37dc010e"

    input:
    path reads
    path index_zip

    output:
    path "${reads.simpleName}.bam", emit: bam
    path "${reads.simpleName}.hisat2.log", emit: log

    script:
    """
    tar -xzvf ${index_zip}
    hisat2 -x ${index_zip.simpleName} -U ${reads} \
        --new-summary --summary-file ${reads.simpleName}.hisat2.log | \
        samtools view -bS -o ${reads.simpleName}.bam
    """
}

Este proceso toma dos entradas: las lecturas y el archivo de índice del genoma. El bloque script primero extrae el índice del archivo, luego ejecuta el alineamiento HISAT2 canalizado a samtools view para convertir la salida a formato BAM. El accesor simpleName en index_zip extrae el nombre base del archivo (genome_index) para usar como prefijo del índice.

3.2.2. Incluir el módulo

Actualice rnaseq.nf para importar el nuevo módulo:

rnaseq.nf
3
4
5
6
// Module INCLUDE statements
include { FASTQC } from './modules/fastqc.nf'
include { TRIM_GALORE } from './modules/trim_galore.nf'
include { HISAT2_ALIGN } from './modules/hisat2_align.nf'
rnaseq.nf
3
4
5
// Module INCLUDE statements
include { FASTQC } from './modules/fastqc.nf'
include { TRIM_GALORE } from './modules/trim_galore.nf'

A continuación, agregaremos la llamada al proceso al flujo de trabajo.

3.2.3. Llamar al proceso de alineamiento

Las lecturas recortadas están en el canal TRIM_GALORE.out.trimmed_reads de salida del paso anterior. Usamos file(params.hisat2_index_zip) para proporcionar el archivo de índice del genoma.

rnaseq.nf
19
20
21
22
23
24
25
26
27
28
29
30
31
32
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Initial quality control
    FASTQC(read_ch)

    // Adapter trimming and post-trimming QC
    TRIM_GALORE(read_ch)

    // Alignment to a reference genome
    HISAT2_ALIGN(TRIM_GALORE.out.trimmed_reads, file(params.hisat2_index_zip))
rnaseq.nf
19
20
21
22
23
24
25
26
27
28
29
workflow {

    main:
    // Create input channel from a file path
    read_ch = channel.fromPath(params.input)

    // Initial quality control
    FASTQC(read_ch)

    // Adapter trimming and post-trimming QC
    TRIM_GALORE(read_ch)

El proceso de alineamiento ahora está conectado al flujo de trabajo.

3.3. Actualizar el manejo de salida

Necesitamos agregar las salidas de alineamiento a la declaración de publicación y configurar dónde van.

3.3.1. Agregar destinos de publicación para las salidas de alineamiento

Agregue las salidas de alineamiento a la sección publish::

rnaseq.nf
34
35
36
37
38
39
40
41
42
    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
    trimmed_reads = TRIM_GALORE.out.trimmed_reads
    trimming_reports = TRIM_GALORE.out.trimming_reports
    trimming_fastqc = TRIM_GALORE.out.fastqc_reports
    bam = HISAT2_ALIGN.out.bam
    align_log = HISAT2_ALIGN.out.log
}
rnaseq.nf
34
35
36
37
38
39
40
    publish:
    fastqc_zip = FASTQC.out.zip
    fastqc_html = FASTQC.out.html
    trimmed_reads = TRIM_GALORE.out.trimmed_reads
    trimming_reports = TRIM_GALORE.out.trimming_reports
    trimming_fastqc = TRIM_GALORE.out.fastqc_reports
}

A continuación, necesitaremos decirle a Nextflow dónde poner estas salidas.

3.3.2. Configurar los nuevos destinos de salida

Agregue entradas para los destinos de alineamiento en el bloque output {}, publicándolos en un subdirectorio align/:

rnaseq.nf
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
output {
    fastqc_zip {
        path 'fastqc'
    }
    fastqc_html {
        path 'fastqc'
    }
    trimmed_reads {
        path 'trimming'
    }
    trimming_reports {
        path 'trimming'
    }
    trimming_fastqc {
        path 'trimming'
    }
    bam {
        path 'align'
    }
    align_log {
        path 'align'
    }
}
rnaseq.nf
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
output {
    fastqc_zip {
        path 'fastqc'
    }
    fastqc_html {
        path 'fastqc'
    }
    trimmed_reads {
        path 'trimming'
    }
    trimming_reports {
        path 'trimming'
    }
    trimming_fastqc {
        path 'trimming'
    }
}

La configuración de salida está completa.

3.4. Ejecutar el flujo de trabajo

El flujo de trabajo ahora incluye los tres pasos de procesamiento: control de calidad, recorte y alineamiento.

nextflow run rnaseq.nf -profile test
Salida del comando 
N E X T F L O W   ~  version 25.10.2

Launching `rnaseq.nf` [elated_stonebraker] DSL2 - revision: e8e57d0cdd

executor >  local (3)
[e8/fa29d6] FASTQC (1)       | 1 of 1 ✔
[ca/ffdde2] TRIM_GALORE (1)  | 1 of 1 ✔
[b6/1c6ca3] HISAT2_ALIGN (1) | 1 of 1 ✔

Puede encontrar las salidas de alineamiento en el directorio de resultados.

ls results/align
Salida
ENCSR000COQ1_1_trimmed.bam  ENCSR000COQ1_1_trimmed.hisat2.log

Esto completa el procesamiento básico que necesitamos aplicar a cada muestra.

Agregaremos la agregación de informes MultiQC en la Parte 3, después de que hayamos modificado el flujo de trabajo para aceptar múltiples muestras a la vez.

Conclusión

Sabe cómo envolver todos los pasos principales para procesar muestras de RNAseq de extremo simple individualmente.

¿Qué sigue?

¡Tome un descanso! Eso fue mucho.

Cuando se sienta renovado, diríjase a la Parte 3, donde aprenderá cómo modificar el flujo de trabajo para procesar múltiples muestras en paralelo, agregar informes de control de calidad en todos los pasos para todas las muestras y habilitar la ejecución del flujo de trabajo en datos de RNAseq de extremo pareado.