Vai al contenuto

Flussi di Lavoro di Flussi di Lavoro

Traduzione assistita da IA - scopri di più e suggerisci miglioramenti

Quando si sviluppa una pipeline, spesso ci si ritrova a creare sequenze simili di processi per diversi tipi di dati o fasi di analisi. Si potrebbe finire per copiare e incollare queste sequenze di processi, portando a codice duplicato difficile da mantenere; oppure si potrebbe creare un unico flusso di lavoro massiccio difficile da comprendere e modificare.

Una delle funzionalità più potenti di Nextflow è la sua capacità di comporre pipeline complesse da moduli di flusso di lavoro più piccoli e riutilizzabili. Questo approccio modulare rende le pipeline più facili da sviluppare, testare e mantenere.

Obiettivi di apprendimento

In questa side quest, esploreremo come sviluppare moduli di flusso di lavoro che possono essere testati e utilizzati separatamente, come comporre questi moduli in una pipeline più grande e come gestire il flusso di dati tra i moduli.

Al termine di questa side quest, sarete in grado di:

  • Suddividere pipeline complesse in unità logiche e riutilizzabili
  • Testare ogni modulo di flusso di lavoro in modo indipendente
  • Combinare flussi di lavoro per creare nuove pipeline
  • Condividere moduli di flusso di lavoro comuni tra diverse pipeline
  • Rendere il codice più manutenibile e facile da comprendere

Queste competenze vi aiuteranno a costruire pipeline complesse mantenendo una struttura del codice pulita e manutenibile.

Prerequisiti

Prima di affrontare questa side quest dovreste:

  • Aver completato il tutorial Hello Nextflow o un corso equivalente per principianti.
  • Essere a proprio agio con i concetti e i meccanismi di base di Nextflow (processi, canali, operatori, moduli)

0. Iniziamo

Aprite il codespace di formazione

Se non l'avete ancora fatto, assicuratevi di aprire l'ambiente di formazione come descritto nella sezione Configurazione dell'Ambiente.

Open in GitHub Codespaces

Spostatevi nella directory del progetto

Spostatevi nella directory dove si trovano i file per questo tutorial.

cd side-quests/workflows_of_workflows

Potete impostare VSCode per concentrarsi su questa directory:

code .

L'editor si apre con la directory del progetto in primo piano.

Esaminate i materiali

Troverete una directory modules con le definizioni dei processi, una directory workflows con due script di flusso di lavoro già scritti, e un file main.nf che aggiornerete progressivamente:

Directory contents
├── main.nf
├── workflows/
│   ├── greeting.nf              # Standalone greeting workflow (to be made composable)
│   └── transform.nf             # Standalone transform workflow (to be made composable)
└── modules/
    ├── say_hello.nf             # Creates a greeting (from Hello Nextflow)
    ├── say_hello_upper.nf       # Converts to uppercase (from Hello Nextflow)
    ├── timestamp_greeting.nf    # Adds timestamps to greetings
    ├── validate_name.nf         # Validates input names
    └── reverse_text.nf          # Reverses text content

La directory modules/ contiene le definizioni dei singoli processi, e la directory workflows/ contiene i due script di flusso di lavoro già scritti con cui lavorerete in questa side quest.

Esaminate il compito

La vostra sfida è assemblare questi moduli in due flussi di lavoro separati che comporremo poi in un flusso di lavoro principale:

  • Un GREETING_WORKFLOW che valida i nomi, crea saluti e aggiunge timestamp
  • Un TRANSFORM_WORKFLOW che converte il testo in maiuscolo e lo inverte

La pipeline completata collega entrambi i flussi di lavoro in un unico flusso di dati:

  1. Validate: verifica che ogni nome sia ben formato
  2. Greet: genera un saluto per ogni nome valido
  3. Timestamp: registra quando ogni saluto è stato creato
  4. Uppercase: converte il saluto con timestamp in maiuscolo
  5. Reverse: inverte il testo in maiuscolo

I primi tre passaggi appartengono a GREETING_WORKFLOW, e gli ultimi due appartengono a TRANSFORM_WORKFLOW. Costruirli come flussi di lavoro separati e componibili vi permette di sviluppare e testare ogni fase in modo indipendente prima di collegarle insieme.

Lista di controllo per la preparazione

Pensate di essere pronti a tuffarvi?

  • Comprendo l'obiettivo di questo corso e i suoi prerequisiti
  • Il mio codespace è attivo e funzionante
  • Ho impostato correttamente la mia directory di lavoro
  • Comprendo il compito assegnato

Se potete spuntare tutte le caselle, siete pronti a partire.

1. Aggiungere il greeting workflow alla pipeline

Il greeting workflow valida i nomi e genera saluti con timestamp.

1.1. Esaminare ed eseguire il greeting workflow

Aprite workflows/greeting.nf e date un'occhiata al codice:

workflows/greeting.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
26
#!/usr/bin/env nextflow

include { VALIDATE_NAME } from '../modules/validate_name'
include { SAY_HELLO } from '../modules/say_hello'
include { TIMESTAMP_GREETING } from '../modules/timestamp_greeting'

workflow {
    main:
    names_ch = channel.of('Alice', 'Bob', 'Charlie')

    // Concatena i processi: valida -> crea saluto -> aggiungi timestamp
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

    publish:
    greetings = greetings_ch
    timestamped = timestamped_ch
}

output {
    greetings {
    }
    timestamped {
    }
}

Questo è un flusso di lavoro completo e autonomo con la stessa struttura vista nel tutorial 'Hello Nextflow'. I nomi di input sono hardcoded, tre processi vengono concatenati e due output vengono pubblicati.

Eseguitelo per verificare che tutto funzioni:

nextflow run workflows/greeting.nf
Output del comando 
N E X T F L O W   ~  version 26.04.4
Launching `workflows/greeting.nf` [sharp_kirch] revision: 04c0a33f79
executor >  local (9)
[c5/9df3c8] VAL…TE_NAME (validating Alice) | 3 of 3 ✔
[e0/243874] SAY_HELLO (greeting Alice)     | 3 of 3 ✔
[c5/e40c8d] TIM…ing timestamp to greeting) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - Charlie-output.txt
    - Bob-output.txt
    - Alice-output.txt

  timestamped:
    - timestamped_Bob-output.txt
    - timestamped_Charlie-output.txt
    - timestamped_Alice-output.txt

Per renderlo componibile con altri flussi di lavoro, alcune cose devono cambiare.

1.2. Rendere il flusso di lavoro componibile

Per rendere un flusso di lavoro componibile, tre cose devono cambiare: il flusso di lavoro riceve un nome, gli input si spostano in un blocco take: e gli output si spostano in un blocco emit: (sostituendo i blocchi standalone publish:/output {}, che appartengono invece all'entry workflow).

Le sezioni seguenti illustrano queste modifiche una per una.

1.2.1. Nominare il flusso di lavoro

Assegnate un nome al flusso di lavoro in modo che possa essere importato da un flusso di lavoro padre.

workflows/greeting.nf
5
workflow GREETING_WORKFLOW {
workflows/greeting.nf
5
workflow {

Con un nome, il flusso di lavoro può essere importato in altri script.

1.2.2. Dichiarare gli input con take:

Sostituite la dichiarazione hardcoded del canale con un blocco take: che dichiara quali input il flusso di lavoro si aspetta. Il blocco take: va prima di main:, e la riga names_ch = channel.of(...) viene rimossa.

workflows/greeting.nf
 5
 6
 7
 8
 9
10
11
12
13
workflow GREETING_WORKFLOW {
    take:
    names_ch // Canale di input con i nomi

    main:
    // Concatena i processi: valida -> crea saluto -> aggiungi timestamp
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)
workflows/greeting.nf
 5
 6
 7
 8
 9
10
11
12
workflow GREETING_WORKFLOW {
    main:
    names_ch = channel.of('Alice', 'Bob', 'Charlie')

    // Concatena i processi: valida -> crea saluto -> aggiungi timestamp
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

Il blocco take: dichiara il canale solo per nome. Il flusso di lavoro padre definisce cosa vi entra.

1.2.3. Dichiarare gli output con emit:

Sostituite la sezione publish: e rimuovete il blocco output {}, sostituendoli con un blocco emit: che nomina gli output.

workflows/greeting.nf
14
15
16
17
    emit:
    greetings = greetings_ch // Saluti originali
    timestamped = timestamped_ch // Saluti con timestamp
}
workflows/greeting.nf
14
15
16
17
18
19
20
21
22
23
24
    publish:
    greetings = greetings_ch
    timestamped = timestamped_ch
}

output {
    greetings {
    }
    timestamped {
    }
}

Il blocco emit: espone output nominati a cui i flussi di lavoro padre possono accedere tramite GREETING_WORKFLOW.out.greetings e GREETING_WORKFLOW.out.timestamped.

1.2.4. Verificare il risultato e testarlo

Dopo tutte e tre le modifiche, il file completo dovrebbe apparire così:

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

include { VALIDATE_NAME } from '../modules/validate_name'
include { SAY_HELLO } from '../modules/say_hello'
include { TIMESTAMP_GREETING } from '../modules/timestamp_greeting'

workflow GREETING_WORKFLOW {
    take:
    names_ch // Canale di input con i nomi

    main:
    // Concatena i processi: valida -> crea saluto -> aggiungi timestamp
    validated_ch = VALIDATE_NAME(names_ch)
    greetings_ch = SAY_HELLO(validated_ch)
    timestamped_ch = TIMESTAMP_GREETING(greetings_ch)

    emit:
    greetings = greetings_ch // Saluti originali
    timestamped = timestamped_ch // Saluti con timestamp
}

Ora provate ad eseguirlo direttamente:

nextflow run workflows/greeting.nf
Output del comando 
N E X T F L O W   ~  version 26.04.4
Launching `workflows/greeting.nf` [intergalactic_leavitt] revision: 89ac88c6c2
No entry workflow specified

Questo introduce un concetto chiave: l'entry workflow. Nextflow utilizza un blocco workflow {} senza nome come punto di ingresso quando si esegue uno script direttamente. GREETING_WORKFLOW è nominato, quindi Nextflow non sa come eseguirlo da solo.

Questo è intenzionale. I flussi di lavoro componibili sono progettati per essere chiamati da un entry workflow, non eseguiti direttamente. La soluzione è un entry workflow in main.nf che importa e chiama GREETING_WORKFLOW.

1.3. Aggiornare e testare il flusso di lavoro principale

Aggiornate ora il flusso di lavoro principale per chiamare il greeting workflow.

1.3.1. Includere il greeting workflow e chiamarlo

Aggiungete l'istruzione include, aggiornate il corpo del flusso di lavoro per chiamare GREETING_WORKFLOW e sostituite il segnaposto channel.empty() in publish::

main.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#!/usr/bin/env nextflow

include { GREETING_WORKFLOW } from './workflows/greeting'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // Esegui il greeting workflow
    GREETING_WORKFLOW(names)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
}
main.nf
1
2
3
4
5
6
7
8
9
#!/usr/bin/env nextflow

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    publish:
    greetings = channel.empty()
}

L'entry workflow rimane senza nome in modo che Nextflow lo utilizzi come punto di ingresso della pipeline.

1.3.2. Aggiornare il blocco output

Aggiungete una direttiva path per instradare i saluti pubblicati in una sottodirectory greetings/:

main.nf
14
15
16
17
18
output {
    greetings {
        path 'greetings'
    }
}
main.nf
14
15
16
17
output {
    greetings {
    }
}

1.3.3. Eseguire il flusso di lavoro

Eseguite il flusso di lavoro per verificare che funzioni:

nextflow run main.nf
Output del comando 
N E X T F L O W   ~  version 26.04.4
Launching `main.nf` [agitated_jones] revision: 6b0e98dd05
executor >  local (9)
[00/5ac4ce] GRE…DATE_NAME (validating Bob) | 3 of 3 ✔
[7d/dde45c] GRE…SAY_HELLO (greeting Alice) | 3 of 3 ✔
[fd/a044cc] GRE…ing timestamp to greeting) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - greetings/Bob-output.txt
    - greetings/Charlie-output.txt
    - greetings/Alice-output.txt
Nuovo contenuto aggiunto in results/ 
results/
└── greetings
    ├── Alice-output.txt
    ├── Bob-output.txt
    └── Charlie-output.txt

I sei file dell'esecuzione standalone nella sezione 1.1 (Alice-output.txt, timestamped_Alice-output.txt, e così via) si trovano ancora in results/ accanto alla nuova sottodirectory greetings/. È normale: nulla in questa lezione li elimina, e la sezione 2.1 li legge direttamente come input.

Contenuto del file
results/greetings/Alice-output.txt
Hello, Alice!

I file dei saluti vengono pubblicati in results/greetings/. Il flusso di lavoro principale chiama GREETING_WORKFLOW e collega il suo output direttamente alla sezione publish:.

GREETING_WORKFLOW.out.timestamped non è collegato a publish: qui. A partire dalla sezione 2, quel canale diventa l'input di TRANSFORM_WORKFLOW invece di un output pubblicato a sé stante. A differenza dell'esecuzione standalone nella sezione 1.1, dove timestamped non aveva altro a cui alimentarsi, quindi veniva pubblicato direttamente.

Takeaway

In questa sezione, avete appreso diversi concetti importanti:

  • Flussi di lavoro nominati: Creare un flusso di lavoro nominato (GREETING_WORKFLOW) che può essere importato e riutilizzato
  • Interfacce del flusso di lavoro: Definire input chiari con take: e output con emit: per creare un flusso di lavoro componibile
  • Entry point: Capire che Nextflow ha bisogno di un entry workflow senza nome per eseguire uno script
  • Composizione del flusso di lavoro: Importare e utilizzare un flusso di lavoro nominato all'interno di un altro flusso di lavoro
  • Namespace del flusso di lavoro: Accedere agli output del flusso di lavoro usando il namespace .out (GREETING_WORKFLOW.out.greetings)

Avete ora un greeting workflow funzionante che:

  • Riceve un canale di nomi come input
  • Valida ogni nome
  • Crea un saluto per ogni nome valido
  • Aggiunge timestamp ai saluti
  • Emette sia i saluti originali che quelli con timestamp, anche se solo i saluti originali vengono pubblicati in results/ in questa fase

Questo approccio modulare vi permette di testare il greeting workflow in modo indipendente o di utilizzarlo come componente in pipeline più grandi.

2. Aggiungere il transform workflow alla pipeline

Il transform workflow applica trasformazioni di testo ai saluti con timestamp.

2.1. Esaminare ed eseguire il flusso di lavoro

Aprite workflows/transform.nf e date un'occhiata al codice:

workflows/transform.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
#!/usr/bin/env nextflow

include { SAY_HELLO_UPPER } from '../modules/say_hello_upper'
include { REVERSE_TEXT } from '../modules/reverse_text'

workflow {
    main:
    input_ch = channel.fromPath('results/timestamped_*.txt')

    // Applica le trasformazioni in sequenza
    upper_ch = SAY_HELLO_UPPER(input_ch)
    reversed_ch = REVERSE_TEXT(upper_ch)

    publish:
    upper = upper_ch
    reversed = reversed_ch
}

output {
    upper {
    }
    reversed {
    }
}

Questo flusso di lavoro autonomo legge i file dei saluti con timestamp dalla directory results/ prodotta da greeting.nf, li converte in maiuscolo e poi inverte il testo.

Eseguitelo per verificare che funzioni con i risultati del greeting dalla sezione 1.1:

nextflow run workflows/transform.nf
Output del comando 
N E X T F L O W   ~  version 26.04.4
Launching `workflows/transform.nf` [evil_meninsky] revision: 4e35790d32
executor >  local (6)
[7d/4ed7de] SAY…estamped_Alice-output.txt) | 3 of 3 ✔
[70/ddaafa] REV…imestamped_Bob-output.txt) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  upper:
    - UPPER-timestamped_Bob-output.txt
    - UPPER-timestamped_Charlie-output.txt
    - UPPER-timestamped_Alice-output.txt

  reversed:
    - REVERSED-UPPER-timestamped_Charlie-output.txt
    - REVERSED-UPPER-timestamped_Alice-output.txt
    - REVERSED-UPPER-timestamped_Bob-output.txt

Per renderlo componibile con GREETING_WORKFLOW, si applicano le stesse tre modifiche della sezione 1.2.

2.2. Renderlo componibile

Applicate le stesse tre modifiche della sezione 1.2: nominate il flusso di lavoro, sostituite l'input hardcoded con take:, e sostituite publish:/output {} con emit:.

Il file completato dovrebbe apparire così:

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

include { SAY_HELLO_UPPER } from '../modules/say_hello_upper'
include { REVERSE_TEXT } from '../modules/reverse_text'

workflow TRANSFORM_WORKFLOW {
    take:
    input_ch // Canale di input con i messaggi

    main:
    // Applica le trasformazioni in sequenza
    upper_ch = SAY_HELLO_UPPER(input_ch)
    reversed_ch = REVERSE_TEXT(upper_ch)

    emit:
    upper = upper_ch // Saluti in maiuscolo
    reversed = reversed_ch // Saluti in maiuscolo invertiti
}

Il transform workflow è ora componibile e pronto per essere importato nel flusso di lavoro principale.

2.3. Aggiornare e testare il flusso di lavoro principale

Aggiornate ora il flusso di lavoro principale per chiamare il transform workflow.

2.3.1. Includere il transform workflow e chiamarlo

Aggiungete l'istruzione include, una chiamata a TRANSFORM_WORKFLOW collegata ai saluti con timestamp, e le due nuove voci publish::

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

include { GREETING_WORKFLOW } from './workflows/greeting'
include { TRANSFORM_WORKFLOW } from './workflows/transform'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // Esegui il greeting workflow
    GREETING_WORKFLOW(names)

    // Esegui il transform workflow
    TRANSFORM_WORKFLOW(GREETING_WORKFLOW.out.timestamped)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
    upper = TRANSFORM_WORKFLOW.out.upper
    reversed = TRANSFORM_WORKFLOW.out.reversed
}
main.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#!/usr/bin/env nextflow

include { GREETING_WORKFLOW } from './workflows/greeting'

workflow {
    main:
    names = channel.of('Alice', 'Bob', 'Charlie')

    // Esegui il greeting workflow
    GREETING_WORKFLOW(names)

    publish:
    greetings = GREETING_WORKFLOW.out.greetings
}

Questo eseguirà il transform workflow sui saluti con timestamp.

2.3.2. Aggiornare il blocco output

Aggiungete le voci upper e reversed al blocco output {}, ciascuna con una direttiva path per la sua sottodirectory:

main.nf
20
21
22
23
24
25
26
27
28
29
30
output {
    greetings {
        path 'greetings'
    }
    upper {
        path 'upper'
    }
    reversed {
        path 'reversed'
    }
}
main.nf
20
21
22
23
24
output {
    greetings {
        path 'greetings'
    }
}

Questo pubblicherà gli output finali nelle directory appropriate.

2.3.3. Eseguire la pipeline completa

Eseguite la pipeline per verificare che tutto funzioni:

nextflow run main.nf
Output del comando 
N E X T F L O W   ~  version 26.04.4
Launching `main.nf` [special_magritte] revision: 2a0e54fecd
executor >  local (15)
[e7/e051a5] GRE…TE_NAME (validating Alice) | 3 of 3 ✔
[ca/cf1b18] GRE…SAY_HELLO (greeting Alice) | 3 of 3 ✔
[e5/aa6be2] GRE…ing timestamp to greeting) | 3 of 3 ✔
[d2/7afc88] TRA…imestamped_Bob-output.txt) | 3 of 3 ✔
[5b/70f190] TRA…estamped_Alice-output.txt) | 3 of 3 ✔

Outputs:

  /workspaces/training/side-quests/workflows_of_workflows/results

  greetings:
    - greetings/Bob-output.txt
    - greetings/Charlie-output.txt
    - greetings/Alice-output.txt

  upper:
    - upper/UPPER-timestamped_Charlie-output.txt
    - upper/UPPER-timestamped_Bob-output.txt
    - upper/UPPER-timestamped_Alice-output.txt

  reversed:
    - reversed/REVERSED-UPPER-timestamped_Charlie-output.txt
    - reversed/REVERSED-UPPER-timestamped_Bob-output.txt
    - reversed/REVERSED-UPPER-timestamped_Alice-output.txt
Nuovo contenuto aggiunto in results/ 
results/
├── greetings
│   ├── Alice-output.txt
│   ├── Bob-output.txt
│   └── Charlie-output.txt
├── reversed
│   ├── REVERSED-UPPER-timestamped_Alice-output.txt
│   ├── REVERSED-UPPER-timestamped_Bob-output.txt
│   └── REVERSED-UPPER-timestamped_Charlie-output.txt
└── upper
    ├── UPPER-timestamped_Alice-output.txt
    ├── UPPER-timestamped_Bob-output.txt
    └── UPPER-timestamped_Charlie-output.txt

La root di results/ contiene ancora i file residui delle esecuzioni standalone nelle sezioni 1.1 e 2.1 (Alice-output.txt, timestamped_Alice-output.txt, UPPER-timestamped_Alice-output.txt, e così via). È normale: questa lezione non vi istruisce mai a eliminarli.

Contenuto del file
results/reversed/REVERSED-UPPER-timestamped_Alice-output.txt
!ECILA ,OLLEH ]54:84:81 31-90-6202[

La pipeline funziona dall'inizio alla fine: il saluto è stato convertito in maiuscolo e invertito.

Takeaway

Dovreste ora avere una pipeline completa che:

  • Elabora i nomi attraverso il greeting workflow
  • Invia i saluti con timestamp al transform workflow
  • Produce versioni sia in maiuscolo che invertite dei saluti

In questa side quest, abbiamo esplorato il potente concetto di composizione di flussi di lavoro in Nextflow, che ci permette di costruire pipeline complesse da componenti più piccoli e riutilizzabili.

Questo approccio modulare offre diversi vantaggi rispetto alle pipeline monolitiche:

  • Ogni flusso di lavoro può essere sviluppato, testato e debuggato in modo indipendente
  • I flussi di lavoro possono essere riutilizzati in diverse pipeline
  • La struttura complessiva della pipeline diventa più leggibile e manutenibile
  • Le modifiche a un flusso di lavoro non influenzano necessariamente gli altri se le interfacce rimangono coerenti
  • Gli entry point possono essere configurati per eseguire diverse parti della pipeline secondo le necessità

Chiamare un flusso di lavoro è simile a chiamare un processo, ma non è la stessa cosa. Non è possibile eseguire un flusso di lavoro N volte passandogli un canale di dimensione N: si passa il canale una volta e il flusso di lavoro itera su di esso internamente.

Applicare queste tecniche nel vostro lavoro vi permetterà di costruire pipeline Nextflow più sofisticate, in grado di gestire attività di elaborazione dati complesse rimanendo manutenibili e scalabili.

Pattern chiave

  1. Struttura del flusso di lavoro: Abbiamo definito input e output chiari per ogni flusso di lavoro usando la sintassi take: e emit:, creando interfacce ben definite tra i componenti, e racchiuso la logica del flusso di lavoro all'interno del blocco main:.

    workflow EXAMPLE_WORKFLOW {
    take:
    // I canali di input sono dichiarati qui
    input_ch

    main:
    // La logica del flusso di lavoro va qui
    // Qui vengono chiamati i processi e manipolati i canali
    result_ch = SOME_PROCESS(input_ch)

    emit:
    // I canali di output sono dichiarati qui
    output_ch = result_ch
}

  2. Import del flusso di lavoro: Abbiamo costruito due moduli di flusso di lavoro indipendenti e li abbiamo importati in una pipeline principale con istruzioni include.

    • Includere un singolo flusso di lavoro
    include { WORKFLOW_NAME } from './path/to/workflow'
    • Includere più flussi di lavoro
    include { WORKFLOW_A; WORKFLOW_B } from './path/to/workflows'
    • Includere con alias per evitare conflitti di nomi
    include { WORKFLOW_A as WORKFLOW_A_ALIAS } from './path/to/workflow'

  3. Entry point: Nextflow richiede un entry workflow senza nome per sapere da dove iniziare l'esecuzione. Questo entry workflow chiama i vostri flussi di lavoro nominati.

    • Flusso di lavoro senza nome (entry point)
    workflow {
    // Questo è il punto di ingresso quando lo script viene eseguito
    NAMED_WORKFLOW(input_ch)
}
    • Flusso di lavoro nominato (chiamato dall'entry workflow)
    workflow NAMED_WORKFLOW {
    // Deve essere chiamato dall'entry workflow
}

  4. Gestione del flusso di dati: Abbiamo imparato come accedere agli output del flusso di lavoro usando la notazione namespace (WORKFLOW_NAME.out.channel_name) e passarli ad altri flussi di lavoro.

    WORKFLOW_A(input_ch)
WORKFLOW_B(WORKFLOW_A.out.some_channel)

Risorse aggiuntive

Cosa c'è dopo?

Tornate al menu delle Side Quest oppure cliccate sul pulsante in basso a destra della pagina per passare all'argomento successivo nell'elenco.