Continuous Integration with Deno

Node has gained a lot of popularity since it was introduced in 2009. Despite its success, Ryan Dahl, Node’s original creator, believes there’s room for improvement, and so he has recently released Deno, a new runtime for JavaScript and TypeScript, as its successor.

How is Deno different? Well, Deno, like Node, uses the V8 engine and event-driven architecture. But here is where the similarities end.

TypeScript gets first-class support at last. Deno compiles to JavaScript without additional packages.
Deno ships as a single executable with built-in, Go-inspired test runners and dependency management.
Deno has better security by default. Programs run in a sandbox that doesn’t have access to the network, the environment, or the filesystem unless explicitly granted.

The most significant difference, though, is that Deno doesn’t have a package manager (say goodbye to npm). That means Node.js modules are largely unsupported. Instead, Deno uses decentralized ES Modules. To compensate, Deno developers have introduced an audited standard library and support for third-party modules.

In this tutorial, we’ll learn how to use Semaphore Continuous Integration (CI) to test Deno applications. As a bonus, we’ll explore how to release Deno applications in Docker using Continuous Delivery (CD).

Prerequisites

If you wish to do this tutorial along with me, you’ll need the following:

Deno on your Mac, Linux, or Windows machine.
Git and GitHub account.
Docker and a Docker Hub account.
A Semaphore account. You can get one for free at semaphoreci.com.

To get started quickly, you can use our starter demo project; feel free to fork it.

It features an oak-based HTTP API service with a PostgreSQL backend and includes integration tests. The project comes with everything you need to build Docker images.

Otherwise, these instructions should work with any Deno application. You may need to make slight adjustments, though, depending on how your code is organized.

Prepare a Testing Image

Semaphore’s composable containers feature lets us work with cutting-edge tools and languages like Deno. We can tailor Docker images to exact specifications and use them to drive CI/CD jobs seamlessly. Semaphore supports any container as long as it includes some basic packages like SSH, Git, and FTP.

Let’s take a few minutes to prepare a Dockerfile for Deno.

We can start from a Debian image:

FROM debian:buster

Then, we tweak some settings and install the required packages:

RUN echo 'APT::Get::Assume-Yes "true";' > /etc/apt/apt.conf.d/99semaphore
RUN echo 'DPkg::Options "--force-confnew";' >> /etc/apt/apt.conf.d/99semaphore
ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update \
        && apt-get install -y --no-install-recommends \
               ca-certificates sudo locales netbase netcat \
               procps lftp curl unzip git openssh-client \
        && rm -rf /var/cache/apt/archives

Next, we set up the locale, so logs have the correct dates and format:

RUN ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime
RUN locale-gen C.UTF-8 || true
ENV LANG=C.UTF-8

And finally, install Deno. We’ll the most current version at the time of writing this, v1.1.1:

RUN curl -fsSL https://deno.land/x/install/install.sh | sh -s v1.1.1
RUN cp /root/.deno/bin/deno /usr/local/bin && rm -rf /root/.deno

The final result, which we’ll call Dockerfile.ci should look like this:

# Dockerfile.ci

FROM debian:buster

RUN echo 'APT::Get::Assume-Yes "true";' > /etc/apt/apt.conf.d/99semaphore
RUN echo 'DPkg::Options "--force-confnew";' >> /etc/apt/apt.conf.d/99semaphore
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update \
        && apt-get install -y --no-install-recommends \
               ca-certificates sudo locales netbase netcat \
               procps lftp curl unzip git openssh-client \
        && rm -rf /var/cache/apt/archives

RUN ln -sf /usr/share/zoneinfo/Etc/UTC /etc/localtime
RUN locale-gen C.UTF-8 || true
ENV LANG=C.UTF-8

RUN curl -fsSL https://deno.land/x/install/install.sh | sh -s v1.1.1
RUN cp /root/.deno/bin/deno /usr/local/bin && rm -rf /root/.deno

CMD ["/bin/sh"]

Now all we have to do is build the image:

$ docker build -t YOUR_DOCKER_HUB_USER/deno:v1.1.1 -f Dockerfile.ci .

Upload it to Docker Hub:

$ docker login -u YOUR_DOCKER_HUB_USER
$ docker push YOUR_DOCKER_HUB_USER/deno:v1.1.1

And we are set to go.

Add Your Project to Semaphore

To add your project to Semaphore follow these steps:

Select your repository from the list.

In the next screen, you can add more people to the project. Once done, click on Go to Workflow Builder to continue.

Add people to the project - Deno tutorial

Choose the Single Job starter workflow and click on Customize it first.

Single Job starter workflow - Deno tutorial

You are now at the Workflow Builder, which lets you visually set up the CI/CD pipeline.

The main element in the view is the pipeline. A pipeline consists of a series of blocks which are executed from left to right.
Each block has one or more jobs. Once all jobs in a block complete, the next block starts.
Jobs contain the commands that do the work and run in parallel. If any command fails, the pipeline stops and is marked as failed.

Let’s create our first job:

Click the pipeline to view its settings. On the right side, under Environment Type select Docker containers.

Type the name of the image you uploaded in the previous section: YOUR_DOCKER_HUB_USER/deno:v1.1.1.

Click on the first block in the pipeline to begin editing it.

In this block, we only need to download and cache the project’s dependencies. For this, we can combine Semaphore’s cache tool with deno cache:

cache restore takes a list of keys and retrieves the first match. Our project lists all dependencies in src/deps.ts, so we can use it as part of the key:

cache restore deps-$(checksum src/deps.ts),deps-master

deno cache downloads dependencies without executing any code. To download them in the current directory:

export DENO_DIR=$PWD/deps
deno cache src/deps.ts

cache store takes a list of keys and a directory and saves it for future runs:

cache store deps-$(checksum src/deps.ts),deps-master deps

Put together, the commands for the job are:

checkout
export DENO_DIR=$PWD/deps
cache restore deps-$(checksum src/deps.ts),deps-master
deno cache src/deps.ts
cache store deps-$(checksum src/deps.ts),deps-master deps

Click on Run the Workflow > Start to try the CI pipeline. Semaphore creates a new git branch called setup-semaphore.

Wait a few seconds for the job to complete. You can check the logs by clicking on the job.

Nice work! We’re ready to start testing.

Testing with Continuous Integration

In this section, we’ll create a new block with two test jobs. The tests use a PostgreSQL database. The easiest way to get one is to connect a new container since we’re already using them in the pipeline.

Open the Workflow Builder.

Select the pipeline and click on +Add Container

Call the new container “postgres”
Type the name of a postgres image on Image: postgres:12
Click on +Add environment variable and add the POSTGRES_HOST_AUTH_METHOD variable with value trust to allow connections without a password.

Create a new block using +Add Block.

Open the Prologue section. The commands we put here will be executed before every job in the block. We’ll use these commands to retrieve the dependencies:

checkout
export DENO_DIR=$PWD/deps
cache restore deps-$(checksum src/deps.ts),deps-master

Open the Environment Variables section and create the variable DB_HOST = postgres

Create three test jobs:

The first job does Database tests. Type the following commands:

deno run --allow-net --allow-env src/migrate.js
deno test --allow-net --allow-env src/tests/database.test.js

Click on +Add another job.
The second job does Integration tests. Type the following commands. Note that in this one, we also need to start the application before running the tests.

deno run --allow-net --allow-env src/app.js &
deno run --allow-net --allow-env src/migrate.js
deno test --allow-net --allow-env src/tests/app.test.js

The third job does Static tests. Deno ships with a code linter. To enable it, we need to use the --unstable flag.

deno lint --unstable src/*.js src/*.ts src/tests/*.js

You can try the pipeline once more with Run the Workflow > Start.

Run Deno with Docker

Docker lets us create portable images that can run anywhere. In this section, we’ll learn how to prepare a production image Deno.

Before Semaphore can push to your Docker registry, you must create a secret with the login details.

To do it:

Click on Secrets under Configuration on the left menu.

Click Create New Secret.
Create two variables for your Docker Hub username and password:
- DOCKER_USERNAME = YOUR DOCKER USERNAME
- DOCKER_PASSWORD = YOU DOCKER PASSWORD
Click on Save changes

Open the Workflow Builder again and scroll right to the end of the pipeline. We’ll add a second pipeline using a promotion. Promotions lets us tie multiple pipelines together with user-defined conditions.

Click on + Add First Promotion.

Check the Enable automatic promotion option. You can set start conditions here.

Enable automatic promotion - Deno tutorial

Click on the first block on the new pipeline.
Rename the job to “Docker Build”.
On the right side of the screen, scroll down to the Secrets section and enable the dockerhub secret.

enable the dockerhub secret - Deno tutorial

The Docker build job consists of four commands:

echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin

Pull the latest image available.

docker pull "${DOCKER_USERNAME}"/addressbook-deno:latest || true

Build the new version of the image, reusing layers from previous versions when possible.

docker build -t "${DOCKER_USERNAME}"/addressbook-deno:latest --cache-from "${DOCKER_USERNAME}"/addressbook-deno:latest .

Push the new image version.

docker push "${DOCKER_USERNAME}"/addressbook-deno:latest

We’ll use this Dockerfile to build the production image:

FROM debian:buster
RUN apt-get update \
        && apt-get install -y --no-install-recommends ca-certificates curl unzip netcat \
        && rm -rf /var/cache/apt/archives
RUN groupadd --gid 1000 deno \
  && useradd --uid 1000 --gid deno --shell /bin/bash --create-home deno
USER deno
RUN curl -fsSL -k https://deno.land/x/install/install.sh | sh -s v1.1.1
ENV HOME "/home/deno"
ENV DENO_INSTALL "${HOME}/.deno"
ENV PATH "${DENO_INSTALL}/bin:${PATH}"
RUN mkdir -p $HOME/app/src
COPY --chown=deno:deno src/ $HOME/app/src
WORKDIR $HOME/app/src
EXPOSE 4000
RUN deno cache deps.ts
CMD deno run --allow-env --allow-net app.js

Compared with the image we used in the CI pipeline, this production image is leaner, has all the code and dependencies baked in, and runs as the deno user instead of root.

The final Docker build job should look like this:

checkout
echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
docker pull "${DOCKER_USERNAME}"/addressbook-deno:latest || true
docker build -t "${DOCKER_USERNAME}"/addressbook-deno:latest --cache-from "${DOCKER_USERNAME}"/addressbook-deno:latest .
docker push "${DOCKER_USERNAME}"/addressbook-deno:latest

We’re done configuring the pipeline. Start it one last time.

Once it completes, click on promote to start the build.

That’s all! From now on, Semaphore will run the pipelines on every push to GitHub.

Semaphore runs the pipelines - Deno tutorial

What’s Next?

You have prepared a production image with your application, now it’s time to think about deploying it—don’t leave it sitting on Docker Hub, collecting dust.

Do you want to run your Deno application in Kubernetes but don’t know how to begin? Download our free CI/CD with Docker and Kubernetes ebook, which explains everything you need to know to get started and includes detailed how-to tutorials.

After that, check out our Kubernetes guides:

Interested in JavaScript or TypeScript? Don’t miss these great posts:

Thanks for reading!