healthyplant/phytopipe

PhytoPipe Docker

This repository is designed to show examples of ways in which you can utilize the Docker images that come prepackaged with https://github.com/healthyPlant/PhytoPipe based on Ubuntu 20.04.

Bioinformatics tools in the image

Examples to use the image (Linux/Mac)

1. use the interactive bash

shell
workDir=/my/work/directory
docker run -it --rm -v $workDir:/data healthyplant/phytopipe /bin/bash
#/data is a directory in the docker container and links to your local workDir (/my/work/directory) through the parameter "-v". You can run any Linux commands in the docker bash, for example list all files in /my/work/directory, and output results to /data folder.
ls -al /data

You can build databases following commands in https://github.com/healthyPlant/PhytoPipe/wiki.

shell
#for example, build nr Diamond database
mkdir -p /data/phytopipe_db/ncbi
cd /data/phytopipe_db/ncbi
wget ftp://ftp.ncbi.nlm.nih.gov/blast/db/FASTA/nr.gz
diamond makedb --in nr.gz -d nr
ls -ltr

#build Krona database
updateTaxonomy.sh
updateAccessions.sh
#now the databases are in the Krona folder /opt/KronaTools-2.8.1/taxonomy/ 
ls /opt/KronaTools-2.8.1/taxonomy/
#copy Krona databases to the local folder
mkdir -p /data/phytopipe_db/Krona_db
cp /opt/KronaTools-2.8.1/taxonomy/*  /data/phytopipe_db/Krona_db/
ls -al /data/phytopipe_db/Krona_db/

You can see the file nr.dmnd in the local folder /my/work/directory/phytopipe_db/ncbi, and the files all.accession2taxid.sorted and taxonomy.tab in the local folder /my/work/directory/phytopipe_db/Krona_db.

When you use the databases on the local folder, please use "-v" to setup the links in your docker command

-v /my/work/directory/phytopipe_db/ncbi:/opt/phytopipe/db/ncbi
-v /my/work/directory/phytopipe_db/Krona_db:/opt/KronaTools-2.8.1/taxonomy

2. Use the docker container as a second system

You can run the interactive bash in a docker container. Every time you start this docker container, your previous works (for example, installed tools) are still there. Here are some steps to use our phytopipe docker image.

i). create a phytopipe docker container

Using -v parameter to link the local folder to the container, - v /my/work/directory:/data, /data is a folder name in the container for the local folder /my/work/directory. Work on the folder /data in the container and view files in the local folder /my/work/directory.

workDir=/my/work/directory  #local folder
docker run -it -v $workDir:/data healthyplant/phytopipe /bin/bash 
#do something
touch testmycontainer
exit 

ii). find your docker container id

docker ps -a

Suppose your "CONTAINER ID" is a2b0f6be4c72

iii). start your docker container

docker start a2b0f6be4c72
docker exec -it a2b0f6be4c72 /bin/bash

iv). work on the docker container

ls -al testmycontainer
#You should see your previous work (testmycontainer)
cd /data
touch test
#please work on /data folder in the container. So you can access all your works on your local folder /my/work/directory. 
#You should see the file "test" in your local folder /my/work/directory.

Starting here, you can build databases and run PhytoPipe in this container following https://github.com/healthyPlant/PhytoPipe/wiki. PhytoPipe and other tools are installed in the /opt folder. You can find the tool commands in their installed directory under the folder /opt. For example, you can build small Kraken2 (e.g. virus only) database following the below commands,

shell
# Download taxonomy
DBNAME=/data/kraken_db_reduced
kraken2-build --download-taxonomy --db $DBNAME
# Collect plant and virus taxon id you need
get_species_taxids.sh -t 10239 > viral_taxIDs.txt
get_species_taxids.sh -t 33090 > plant_taxIDs.txt

# Extract sequences from NCBI blast nt database
nt_db=/data/ncbi_nt/nt  #suppose your NCBI nt blast database is in $workDir/ncbi_nt(/my/work/directory/ncbi_nt) 
blastdbcmd -db $nt_db -dbtype nucl -taxidlist viral_taxIDs -outfmt ">%a|kraken:taxid|%T %t#X#%s" | sed 's/#X#/\n/g' > viral.fasta
blastdbcmd -db $nt_db -dbtype nucl -taxidlist plant_taxIDs -outfmt ">%a|kraken:taxid|%T %t#X#%s" | sed 's/#X#/\n/g' > plant.fasta

# Add sequences to library
kraken2-build --add-to-library viral.fasta --db $DBNAME
kraken2-build --add-to-library plant.fasta --db $DBNAME

# Clean files
rm plant.fasta
rm viral.fasta
rm *_taxIDs.txt

# Build the database
kraken2-build --build --threads 16 --db $DBNAME

After successfully running, you should see the Kraken2 database fiels (*.k2d) in the folder /my/work/directory/kraken_db_reduced.

v). run PhytoPipe on the docker container

Before running PhytoPipe, please put your fastq files in /my/work/directory/phytopipe_run/raw (do not change 'raw', which is the default fastq file folder name PhytoPipe use ). After you modify /opt/phytopipe/config.yaml, you can run PhytoPipe using the following commands

shell
#dry run
snakemake  --configfile /opt/phytopipe/config.yaml -s /opt/phytopipe/Snakefile --config workDir=/data/phytopipe_run --cores 32 -n
#if dry run success, please run
snakemake  --configfile /opt/phytopipe/config.yaml -s /opt/phytopipe/Snakefile --config workDir=/data/phytopipe_run --cores 32 

After successfully running, you should see the report in the folder /my/work/directory/phytopipe_run.

3. Directly run a command in the image

This is example to run KronaTools to generate a Krona pie chart.

shell
docker run --rm -v /my/work/directory/phytopipe_db/Krona_db:/opt/KronaTools-2.8.1/taxonomy -v /my/work/directory/phytopipe_run/Dataset1:/data healthyplant/phytopipe ktImportTaxonomy -m 3 -t 5 -o /data/Dataset1.kraken2.krona.html /data/Dataset1.kraken2.report.txt

"-v /my/work/directory/phytopipe_db/Krona_db:/opt/KronaTools-2.8.1/taxonomy" builds a bridge between the local folder /my/work/directory/phytopipe_db/Krona_db and the folder /opt/KronaTools-2.8.1/taxonomy in the image. Any files in the local folder can be accessed by the docker container. Doing this allows that the Krona taxonomy database in the local machine can be used by the docker.

"-v /my/work/directory/phytopipe_run/Dataset1:/data" links your local work directory (Dataset1) to the folder /data in the docker container.

"healthyplant/phytopipe" is the docker image name.

"ktImportTaxonomy" is the command to run.

" -m 3 -t 5 " is the parameters for the command.

"-o /data/Dataset1.kraken2.krona.html" is the output. It is in the folder /data in the docker. But you can see it in your local work directory because of the bridge we built.

"/data/Dataset1.kraken2.report.txt" is the input from Kraken2 classification. The file "Dataset1.kraken2.report.txt" is in the local work directory /my/work/directory/phytopipe_run/Dataset1 .

If you want Docker run in the background, please use "-d or --detach" parameter. The Linux command "nohup" can't be used in Docker. "-d" is an option for Docker. For example, build Kraken2 and Kaiju databases

shell
#build Kraken2 database
docker run --rm -v /my/work/directory/phytopipe_db:/data healthyplant/phytopipe kraken2-build --download-taxonomy --threads 16 --db /data/kraken_db
docker run --rm -v /my/work/directory/phytopipe_db:/data healthyplant/phytopipe kraken2-build --download-library nt --db /data/kraken_db
docker run -d --rm -v /my/work/directory/phytopipe_db:/data healthyplant/phytopipe kraken2-build --build --threads 16 --db /data/kraken_db

#build Kaiju database
docker run -d --rm -v /my/work/directory/phytopipe_db/kaiju_db:/data healthyplant/phytopipe kaiju-makedb -s nr_euk

After one to two days running, the Kraken2 database files (.k2d) should be in your local folder/my/work/directory/phytopipe_db/kraken_db. The Kaiju database file (.fmi) should be in your local folder /my/work/directory/phytopipe_db/kaiju_db.
If you're just interested in viruses, you can build virus Kraken2 and Kaiju databases or download pre-built databases from https://benlangmead.github.io/aws-indexes/k2 and the Kaiju server. Here is the command for building Kaiju RVDB viral database.

shell
docker run -d --rm -v /my/work/directory/phytopipe_db/kaiju_db:/data healthyplant/phytopipe kaiju-makedb -s rvdb 

4. Run PhytoPipe

i). Build/update databases

You can use our script updateDatabaseDocker.sh to build or update all databases. Kraken2 database building will take several days.

shell
docker run -d --rm -v /my/work/directory/phytopipe_db:/data healthyplant/phytopipe bash /opt/phytopipe/scripts/updateDatabaseDocker.sh /opt/phytopipe /data v25.0

v25.0 is RVDB version from RVDB database, protein version. Please find the newest version when you update the database.
If you have problems to build the Kraken2 database, you can download https://benlangmead.github.io/aws-indexes/k2. If so, please kill the above process after one day running.

After database building finished, you will see several folders in the folder /my/work/directory/phytopipe_db.

1. kraken2 database
   Folder: /my/work/directory/phytopipe_db/kraken_db
   Files: hash.k2d opts.k2d seqid2taxid.map taxo.k2d
2. kaiju database
   Folder: /my/work/directory/phytopipe_db/kaiju_db
   Files: kaiju_db_nr_euk.fmi, names.dmp, nodes.dmp
3. NCBI blastn nt database downloaded from NCBI
   Folder: /my/work/directory/phytopipe_db/ncbi_nt
   Files: nt*
4. SILVA 18S and 28S Eukaryote ribosomal RNA database
   Folder: /my/work/directory/phytopipe_db/rRNA
   Files: silva-euk_com***ed_rRNA.fasta
5. Reference blastn and diamond blastx database
   Folder: /my/work/directory/phytopipe_db/ncbi
   Files: nr.dmnd, refseq_viral_genomic.fa, plantvirus.fa, rvdb.dmnd, microbial.tids
6. NCBI taxonomy database
   Folder: /my/work/directory/phytopipe_db/ncbi/taxonomy
   Files: refseq_viral.gb_taxon.txt, rvdb.gb_taxon.txt,plantvirus.gb_taxon.txt, nodes.dmp, names.dmp
7. Krona taxonomy database
   Folder: /my/work/directory/phytopipe_db/Krona_db
   Files: all.accession2taxid.sorted, taxonomy.tab

ii). Create your config.yaml file

You can download "config.docker.yaml" from https://github.com/healthyPlant/PhytoPipe to edit or copy the following code to edit

shell
#For single-read file
#seq_type: 'se'  #'se' for single-readd, 'pe' for paired-end  
#strand1: ''  #'' for single-read file name without R1, 'R1' for single-read file name end with R1 or R1_001
#strand2: 'R2'  # keep it even no pair R2 file

#For paired-end file
seq_type: 'pe'  #'se' for single-read, 'pe' for paired-end  
strand1: 'R1'  # for pair-end file name with R1 and R2 or R1_001 and R2_001; 1 for NCBI sequence
strand2: 'R2'   #for R2 or R2_001; 2 for NCBI sequence

input_format: 'fastq.gz'  #read file format. 'fq.gz' is an option 
number_of_threads: 16 #number of computer cores or threads

#please check wiki to see how to build the databases
#please do not change database paths here. They are the paths in the docker image. You can use "-v" to link the local databases 
#spike-in or contorl's sequence file 
control: /opt/phytopipe/db/phi-X174.fasta
#kraken2 database folder
krakenDb: /opt/phytopipe/db/kraken_db
#kaiju database file
kaijuDb: /opt/phytopipe/db/kaiju_db/kaiju_db_nr_euk.fmi
#NCBI blastn nt database downloaded from NCBI
blastnDb: /opt/phytopipe/db/ncbi_nt/nt
#NCBI nr database made by Diamond
blastxDb: /opt/phytopipe/db/ncbi/nr.dmnd
#viral reference database
blastnViralDb: /opt/phytopipe/db/ncbi/refseq_viral_genomic.fa
#blastnViralDb: /opt/phytopipe/db/ncbi/plantvirus.fa
#viral reference taxonomy onformation
blastnViralTaxonDb: /opt/phytopipe/db/ncbi/taxonomy/refseq_viral.gb_taxon.txt
#blastnViralTaxonDb: /opt/phytopipe/db/ncbi/taxonomy/plantvirus.gb_taxon.txt
#RVDB viral protein database made by Diamond
blastxViralDb: /opt/phytopipe/db/ncbi/rvdb.dmnd
#RVDB viral protein sequences taxonomy information
blastxViralTaxonDb: /opt/phytopipe/db/ncbi/taxonomy/rvdb.gb_taxon.txt
#SILVA 18S and 28S Eukaryote ribosomal RNA database
euk_rRNA: /opt/phytopipe/db/rRNA/silva-euk_combined_rRNA.fasta
#NCBI taxonomy database
taxDb: /opt/phytopipe/db/ncbi/taxonomy

#Virus acronym from ICTV
acronymDb: /opt/phytopipe/db/ICTV_virus_acronym.txt

#microbial taxon ids
microbialTaxon: /opt/phytopipe/db/ncbi/microbial.tids

#your monitored pathogens, if you don't have them, leave the file empty
#the file is a tab delimited
#column titles are:TaxonId Species
#each line have a specices taxonomy ID and name
monitorPathogen: /opt/phytopipe/db/monitorPathogen.txt

#Blast database type
#'virus' is for blasting against RVDB and viral references.
#'all' is for blasting NCBI nt and nr. It could take a long time to finish blastn
blastDbType: virus # or 'all' 
#Blast E-value cutoff 
blastEvalue: 1e-10

#reads used for assembly or mapping to a reference
#'trimmed' is for all trimmed reads including host reads
#'clean' is for all possible pathogen reads. host reads are supposed to be removed
mapReadType: 'clean' #'trimmed'

#trimmomatic, its adapters and parameters
trimmomatic: /opt/Trimmomatic-0.39/trimmomatic-0.39.jar
adapters: /opt/Trimmomatic-0.39/adapters/TruSeq3-SE.fa
trimmomatic_param: " LEADING:3 TRAILING:3 SLIDINGWINDOW:4:20 MINLEN:36 "

#de novo genome assembly tool
#'Trinity' or 'Spades'
assembler: Trinity # 'Spades'
#Spades parameters. Different kmers (k) may generate different results. 
#Spades parameters. Different kmers (k) may generate different results. 
spades_param: " " #" --only-assembler --phred-offset 33 -k 21,31,41,51,71,91,121 "

#Added in PhytoPipe.v2
#to limit blastn (>=v2.15) search in interesting taxons, such as: 2 (bacteria), 10239 (viruses), 4751 (fungi), 4762 (oomycetes)
includeTaxids: "2,10239,4751,4762"
#to exclude unwanted taxons in blastn search (>=v2.15), such as 38018 (bacteriophage),  32630 (synthetic construct), 451344 (unclassified archaeal viruses), 12333 (unclassified bacterial viruses), 552364 (unclassified virophages), 186616 (environmental samples)
excludeTaxids: "38018,32630,451344,12333,552364,186616"


#mapping tool
#'bwa' or 'bowtie'
mappingTool: bwa # 'bowtie2'
#mapping tool parameters
bwa_param: " -B 4 "  #default bwa setting #" -k 12 -A 1 -B 3 -O 1 -E 1 " #bwa loose mapping; 
bowtie2_param: " --very-sensitive-local -k 100 --score-min L,20,1.0 " #bowtie2 sensitive mapping; " --mp 20  --score-min L,-0.1,-0.1 " #bowtie2 very stringent mapping

#clumpify parameters
clumpify_param: "dedupe=t subs=0 passes=2 " #dupedist=40 optical=t # These parameters identify reads as duplicated only if they are an exact match (i.e., no substitution allowed).

#gobal variables, please do not change
#they can be changed in the command line
fastqDir: ""
flowCellDir: ""
workDir: ""
samples: ""

run_info:
  raw: raw                                #raw fastq file directoy
  log: logs                               #log files diretory
  qc: qc                                  #fastqc and multiqc directory
  trim: trimmed                           #trimmed directory
  clean: cleaned                          #clean reads after host, control ex. Phx174, duplicates removal
  assemble: assembly                      #assemble directory
  classify: classification                #read classification directory
  annotate: annotation                    #blast annotation directory  
  map: mapping                            #mapping reads directory   
  report: report                          #report directory    
  novel: novelVirus                       #novelVirus directory      

Important: If you use single-reads, please use the single-read setting and comment paired-end setting

shell
seq_type: 'se' 
strand1: ''  
strand2: 'R2'

If you use paired-end reads, please use the paired-end setting and comment single-read setting

shell
seq_type: 'pe'  
strand1: 'R1'  
strand2: 'R2' 

iii). Run PhytoPipe

Your sequence fastq.gz files are in the folder $workDir/raw. Here we use VIROMOCKchallenge https://gitlab.com/ilvo/VIROMOCKchallenge(paried-end reads) and https://gitlab.com/ilvo/VIROMOCKchallenge (single-reads, novel virus) to test the pipeline. Dataset8 is in https://github.com/healthyPlant/PhytoPipe/tree/main/test/data. All VIROMOCKchallenge datasets can be downloaded from DRYAD.

shell
workDir=/home/myname/Dataset8   #fastq.gz files are in /home/myname/Dataset8/raw
config=/home/myname/Dataset8/config.docker.yaml

#for Dataset10
#workDir=/home/myname/Dataset10    #fastq.gz files are in /home/myname/Dataset10/raw
#config=/home/myname/Dataset10/config.docker.yaml

#fastq file must be in $workDir/raw folder
ls -al $workDir/raw

#get your local databases
#kraken2 database folder
krakenDb_dir=/my/work/directory/phytopipe_db/kraken_db #hash.k2d  opts.k2d  seqid2taxid.map  taxo.k2d 
#kaiju database file
kaijuDb_dir=/my/work/directory/phytopipe_db/kaiju_db  #/kaiju_db_nr_euk.fmi
#NCBI blastn nt database downloaded from NCBI
ncbi_nt_dir=/my/work/directory/phytopipe_db/ncbi_nt  #/nt
#SILVA 18S and 28S Eukaryote ribosomal RNA database
euk_rRNA_dir=/my/work/directory/phytopipe_db/rRNA #/silva-euk_combined_rRNA.fasta
#NCBI db
ncbiDb_dir=/my/work/directory/phytopipe_db/ncbi #nr.dmnd refseq_viral_genomic.fa  rvdb.dmnd microbial.tids 
#NCBI taxonomy database
taxDb_dir=/my/work/directory/phytopipe_db/ncbi/taxonomy  #refseq_viral.gb_taxon.txt rvdb.gb_taxon.txt nodes.dmp names.dmp
#Krona taxonomy
kronaTaxDb_dir=/my/work/directory/phytopipe_db/krona_db  #all.accession2taxid.sorted taxonomy.tab


#dry run PhytoPipe on docker
docker run -it --rm --name phytopipe \
           -v $workDir:/data \
           -v $krakenDb_dir:/opt/phytopipe/db/kraken_db \
           -v $kaijuDb_dir:/opt/phytopipe/db/kaiju_db \
           -v $ncbi_nt_dir:/opt/phytopipe/db/ncbi_nt \
           -v $euk_rRNA_dir:/opt/phytopipe/db/rRNA \
           -v $ncbiDb_dir:/opt/phytopipe/db/ncbi \
           -v $taxDb_dir:/opt/phytopipe/db/ncbi/taxonomy \
           -v $kronaTaxDb_dir:/opt/KronaTools-2.8.1/taxonomy \
           -v $config:/opt/phytopipe/config.yaml \
          healthyplant/phytopipe \
           snakemake --configfile /opt/phytopipe/config.yaml \
           -s /opt/phytopipe/Snakefile \
           --config workDir=/data \
           --cores 32  -n

#If no errors on dry run, you can run PhytoPipe in the background
#use "-d" for runing in the background
docker run -d --rm --name phytopipe \
           -v $workDir:/data \
           -v $krakenDb_dir:/opt/phytopipe/db/kraken_db \
           -v $kaijuDb_dir:/opt/phytopipe/db/kaiju_db \
           -v $ncbi_nt_dir:/opt/phytopipe/db/ncbi_nt \
           -v $euk_rRNA_dir:/opt/phytopipe/db/rRNA \
           -v $ncbiDb_dir:/opt/phytopipe/db/ncbi \
           -v $taxDb_dir:/opt/phytopipe/db/ncbi/taxonomy \
           -v $kronaTaxDb_dir:/opt/KronaTools-2.8.1/taxonomy \
           -v $config:/opt/phytopipe/config.yaml \
          healthyplant/phytopipe \
           snakemake --configfile /opt/phytopipe/config.yaml \
           -s /opt/phytopipe/Snakefile \
           --config workDir=/data \
           --cores 32 

#check docker status
docker ps -a

#check logs
docker logs phytopipe
#or
docker run -d healthyplant/phytopipe | xargs docker logs -f

After successfully running, you should see the report in the $workDir.

You can put all the same type files (e.g., all paired-end reads or all single reads files) into the "raw" folder to run multiple samples.

You can download "runDocker.sh" from Github https://github.com/healthyPlant/PhytoPipe to edit and use it.

bash ./runDocker.sh

Using the PhytoPipe image in Windows

Please note that data must be under the same drive than the Docker Toolbox installation (usually C:) and in a folder with write permissions (e.g. C:\Users\User_name).

You should adapt and run commands in PowerShell in Windows.
The difference between Linux Bash and Windows PowerShell for a variable:
A new variable needs the preceding dollar ($) sign when assigning a value to it in Powershell, not in Bash;
To use a variable, add $ before the variable in Bash, add {} in PowerShell, e.g. ${variable}.

You can use our script updateDatabaseDocker.sh to build or update all databases. Kraken2 database building will take several days.
Suppose your database folder is C:\Users\User_name\phytopipe_db, you can run the following command

shell
docker run -d --rm -v "/c/Users/User_name/phytopipe_db":/data healthyplant/phytopipe bash /opt/phytopipe/scripts/updateDatabaseDocker.sh /opt/phytopipe /data v25.0

v25.0 is RVDB version from RVDB database, protein version. Please find the newest version when you update the database.

After the databases are built, you will see the following folders in C:/Users/User_name/phytopipe_db

#kraken2 database folder  
C:\Users\User_name\phytopipe_db\kraken_db #hash.k2d  opts.k2d  seqid2taxid.map  taxo.k2d   
#kaiju database folder  
C:\Users\User_name\phytopipe_db\kaiju_db  #/kaiju_db_nr_euk.fmi  
#NCBI blastn nt database downloaded from NCBI  
C:\Users\User_name\phytopipe_db\ncbi_nt  #/nt_1.* .....  
#SILVA 18S and 28S Eukaryote ribosomal RNA database  
C:\Users\User_name\phytopipe_db\rRNA #/silva-euk_combined_rRNA.fasta  
#NCBI db  
C:\Users\User_name\phytopipe_db\ncbi #nr.dmnd refseq_viral_genomic.fa  rvdb.dmnd microbial.tids   
#NCBI taxonomy database  
C:\Users\User_name\phytopipe_db\taxonomy  #refseq_viral.gb_taxon.txt rvdb.gb_taxon.txt nodes.dmp names.dmp  
#Krona taxonomy  
C:\Users\User_name\phytopipe_db\krona_db  #all.accession2taxid.sorted taxonomy.tab  

Now you can test the pipeline using https://github.com/healthyPlant/PhytoPipe/tree/main/test/data.

shell
#suppose your work directory is C:\Users\User_name\Dataset8
$workDir="/c/Users/User_name/Dataset8"  #add $ before variable and change a backslash "\" to a slash "/"

#the config file is config.docker.yaml
$config="/c/Users/User_name/Dataset8/config.docker.yaml"

#please put all fastq.gz files into the folder C:/Users/User_name/Dataset8/raw.

#variables for databases
$phytopipeDb_dir="/c/Users/User_name/phytopipe_db"
$kronaTaxDb_dir="/c/Users/User_name/phytopipe_db/krona_db"

#dry run PhytoPipe on docker
docker run -it --rm --name phytopipe `
           -v ${workDir}:/data `
           -v ${phytopipeDb_dir}:/opt/phytopipe/db `
           -v ${kronaTaxDb_dir}:/opt/KronaTools-2.8.1/taxonomy `
           -v ${config}:/opt/phytopipe/config.yaml `
          healthyplant/phytopipe `
           snakemake --configfile /opt/phytopipe/config.yaml `
           -s /opt/phytopipe/Snakefile `
           --config workDir=/data `
           --cores 32  -n

#If no errors on dry run, you can run PhytoPipe in the background
#use "-d" for runing in the background
docker run -d --rm --name phytopipe `
           -v ${workDir}:/data `
           -v ${phytopipeDb_dir}:/opt/phytopipe/db `
           -v ${kronaTaxDb_dir}:/opt/KronaTools-2.8.1/taxonomy `
           -v ${config}:/opt/phytopipe/config.yaml `
          healthyplant/phytopipe `
           snakemake --configfile /opt/phytopipe/config.yaml `
           -s /opt/phytopipe/Snakefile `
           --config workDir=/data `
           --cores 32  -n

#check docker status
docker ps -a

#check logs
docker logs phytopipe

After successfully running, you should see the report in the work directory (C:\Users\User_name\Dataset8).