Developer Quickstart

This tutorial provides a quick intro to the DNAnexus developer experience, and progresses to building a fully functional, useful app on the Platform. For a more in-depth discussion of the Platform, take a look at Intro to Building Apps.
The steps below require the DNAnexus SDK. You must download and install it if you have not done so already.
In addition to this Quickstart, there are Developer Tutorials located in the sidebar that go over helpful tips for new users as well. A few of them include:
​Distributed by Chr (sh)​
​Parallel by Chr (py)​
​R Shiny Example Web App​
1. Build a simple app
Every DNAnexus app starts with 2 files:
​dxapp.json: a file containing the app's metadata: its inputs and outputs, how the app will be run, etc.
a script that will be executed in the cloud when the app is run
Let's start by creating a file called dxapp.json with the following text:
1
{ "name": "coolapp",
2
  "runSpec": {
3
    "distribution": "Ubuntu",
4
    "release": "20.04",
5
    "version": "0",
6
    "interpreter": "python3",
7
    "file": "code.py"
8
  }
9
}
Copied!
Above, we've specified the name for our app (coolapp), the type of interpreter (python3) to run our script with, and a path (code.py) to the script that we will create next. ("version":"0") refers to the version of Ubuntu 20.04 application execution environment that supports (python3) interpreter.
Next, we create our script in a file called code.py with the following text:
1
import dxpy
2
​
3
@dxpy.entry_point('main')
4
def main(**kwargs):
5
    print("Hello, DNAnexus!")
6
    return {}
Copied!
That's all we need. To build the app, first log in to DNAnexus and start a project with dx login. In the directory with the two files above, run:
1
$ dx login
2
 ...
3
$ dx build -a
Copied!
Now, run the app and watch the output:
1
$ dx run coolapp --watch
Copied!
That's it! You have just made and run your first DNAnexus applet. Applets are lightweight apps that live in your project, and are not visible in the App Library. When you typed dx run, the app ran on its own Linux instance in the cloud. You have exclusive, secure access to the CPU, storage, and memory on the instance. The DNAnexus API lets your app read and write data on the Platform, as well as launch other apps.
The app is now available in the DNAnexus web interface, as part of the project that you started. It can be configured and run in the Workflow Builder, or shared with other users by sharing the project.
2. Run BLAST
Next, we'll make our app do something a bit more interesting: take in two files with FASTA-formatted DNA, run the BLAST tool to compare them, and output the result.
In the cloud, your app will run on Ubuntu Linux 20.04, where BLAST is available as an APT package, blast2. You can request that the DNAnexus execution environment install it before your script is run by listing blast2 in the execDepends field of your dxapp.json like this:
1
{ "name": "coolapp",
2
  "runSpec": {
3
    "distribution": "Ubuntu",
4
    "release": "20.04",
5
    "version": "0",
6
    "interpreter": "python3",
7
    "file": "code.py",
8
    "execDepends": [ {"name": "blast2"} ]
9
  }
10
}
Copied!
Next, let's update code.py to run BLAST:
1
import dxpy, subprocess
2
​
3
@dxpy.entry_point('main')
4
def main(seq1, seq2):
5
    dxpy.download_dxfile(seq1, "seq1.fasta")
6
    dxpy.download_dxfile(seq2, "seq2.fasta")
7
​
8
    subprocess.call("blastn -query seq1.fasta -subject seq2.fasta > report.txt", shell=True)
9
​
10
    report = dxpy.upload_local_file("report.txt")
11
    return {"blast_result": report}
Copied!
We're now ready to rebuild the app and test it on some real data. You can use some demo inputs available in the Demo Data project, or you can upload your own data with dx upload or via the website. If you use the Demo Data inputs, make sure the project you are running your app in is the same region as the Demo Data project.
Rebuild the app with dx build -a, and run it like this:
1
$ dx run coolapp -i seq1="Demo Data:/Developer Quickstart/NC_000868.fasta" -i seq2="Demo Data:/Developer Quickstart/NC_001422.fasta" --watch
Copied!
Once the job is done, you can examine the output with dx head report.txt, download it with dx download, or view it on the website.
3. Provide an input/output spec
​Workflows are a powerful way to visually connect, configure, and run multiple apps in pipelines. To add our app to a workflow and be able to connect its inputs and/or outputs to other apps, our app will need both input and output specifications. Let's update our dxapp.json as follows:
1
{
2
  "name": "coolapp",
3
  "runSpec": {
4
    "distribution": "Ubuntu",
5
    "release": "20.04",
6
    "version": "0",
7
    "interpreter": "python3",
8
    "file": "code.py",
9
    "execDepends": [ {"name": "blast2"} ]
10
  },
11
  "inputSpec": [
12
    {"name": "seq1", "class": "file"},
13
    {"name": "seq2", "class": "file"}
14
  ],
15
  "outputSpec": [
16
    {"name": "blast_result", "class": "file"}
17
  ]
18
}
Copied!
Rebuild the app with dx build -a. You can run it in the same way as before, but now we can add the applet to a workflow. Click "New Workflow" while looking at your project on the website, and click on coolapp once to add it to the workflow. You'll see inputs and outputs appear on the workflow stage which can be connected to other stages in the workflow.
Also, if you now go back to the command line and run dx run coolapp with no input arguments, it will prompt you for the input values for seq1 and seq2.
4. Configure app settings
In addition to specifying input files, the I/O specification can also be used to configure settings that we want the app to use. For example, we can configure the E-value setting and other BLAST settings with this code and dxapp.json:
code.py
1
import dxpy, subprocess
2
​
3
@dxpy.entry_point('main')
4
def main(seq1, seq2, evalue, blast_args):
5
    dxpy.download_dxfile(seq1, "seq1.fasta")
6
    dxpy.download_dxfile(seq2, "seq2.fasta")
7
​
8
    command = "blastn -query seq1.fasta -subject seq2.fasta -evalue {e} {args} > report.txt".format(e=evalue, args=blast_args)
9
    subprocess.call(command, shell=True)
10
​
11
    report = dxpy.upload_local_file("report.txt")
12
    return {"blast_result": report}
Copied!
dxapp.json
1
{
2
  "name": "coolapp",
3
  "runSpec": {
4
    "distribution": "Ubuntu",
5
    "release": "20.04",
6
    "version": "0",
7
    "interpreter": "python3",
8
    "file": "code.py",
9
    "execDepends": [ {"name": "blast2"} ]
10
  },
11
  "inputSpec": [
12
    {"name": "seq1", "class": "file"},
13
    {"name": "seq2", "class": "file"},
14
    {"name": "evalue", "class": "float", "default": 0.01},
15
    {"name": "blast_args", "class": "string", "default": ""}
16
  ],
17
  "outputSpec": [
18
    {"name": "blast_result", "class": "file"}
19
  ]
20
}
Copied!
Rebuild the app again and add it in the workflow builder. You should now see the evalue and blast_args settings available when you click the gear button on the stage. After building and configuring a workflow, you can run the workflow itself with dx run workflowname.
5. Use SDK tools
One of the utilities provided in the SDK is dx-app-wizard. This tool will prompt you with a series of questions with which it will create the basic files needed for a new app. It also gives you the option of writing your app as a bash shell script instead of Python. Just run dx-app-wizard to try it out.
Command Line Quickstart
Developer Tutorials
Last modified 1mo ago
Export as PDF
Copy link
Contents
1. Build a simple app
2. Run BLAST
3. Provide an input/output spec
4. Configure app settings
5. Use SDK tools