Deploy a Deno App

Deno (opens in a new tab) is a next-generation runtime for JavaScript and TypeScript projects with a modern feature set focused on security, developer experience, and performance.

This guide explains how to deploy a Deno application to Koyeb using Git-driven deployment. The application can be built using either native buildpacks or from a Dockerfile.

To successfully follow this documentation, you will need to have a Koyeb account (opens in a new tab). You can optionally install the Koyeb CLI if you prefer to follow this guide without leaving the terminal.

You can deploy and preview the Deno application from this guide using the Deploy to Koyeb button below.

(opens in a new tab)

You can consult the repository on GitHub (opens in a new tab) to find out more about the example application that this guide uses.

Create the Deno app

To create a basic Deno application, you'll need to install Deno (opens in a new tab) on your local computer.

To begin, create and navigate to a new directory for your Deno project:

mkdir example-deno
cd example-deno

Next, create a main.ts file to define our simple Deno application. Paste the following contents within:

const port = parseInt(Deno.env.get('PORT') ?? '8000')
 
function hello_world(_req: Request): Response {
  return new Response('Hello, world!')
}
 
Deno.serve({ port: port }, hello_world)

The application starts a basic web server that responds to all requests with a "Hello, world!" message. The server uses the PORT environment variable to determine which port to listen on and falls back on port 8000 if the variable is undefined.

Test the Deno app locally

You can run the application by typing:

deno run main.ts

Since the application references the PORT environment variable, Deno will prompt you to allow access to the environment. Type "y" to allow. It will then prompt you to confirm that it can serve the application with network access. Again, type "y":

┌ ⚠  Deno requests env access to "PORT".
├ Run again with --allow-env to bypass this prompt.
└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all env permissions) >️ y
┌ ⚠  Deno requests net access to "0.0.0.0:8000".
├ Requested by `Deno.listen()` API.
├ Run again with --allow-net to bypass this prompt.
└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all net permissions) > y

As the message indicates, you can provide the --allow-env and --allow-net options to avoid these prompts in future invocations.

Once you confirm access with both prompts, you can visit localhost:8000 in your web browser to access the application. You should see the "Hello, world!" message from the application.

When you are finished, press CTRL-C to stop the server.

Add project metadata files

Next, we need to add the files the project metadata files. These are used to manage dependencies, define scripts, and more.

If you want to deploy using the Node.js buildpack (opens in a new tab), you'll need to create a package.json file. Koyeb's build process uses that file as an identifier for Node.js-compatible projects. We will list the deno-bin package (opens in a new tab) as a dependency to install Deno within the environment.

First, find the latest version of Deno by typing:

curl --head https://github.com/denoland/deno/releases/latest | grep location | grep --only-matching '[^/]*$'

You'll see a response that looks something like this:

v1.39.0

We will ask for this version or later in our dependency list.

In the project root, create a new file called package.json with the following contents. Be sure to adjust the ^1.39.0 line to the version line you found above, prefixed by the ^ character:

{
  "name": "Deno example application",
  "scripts": {
    "dev": "deno run --watch --allow-net --allow-env main.ts",
    "build": "deno compile --allow-net --allow-env --output=example-deno main.ts",
    "start": "./example-deno"
  },
  "dependencies": {
    "deno-bin": "^1.39.0"
  }
}

This names the project and creates three scripts that you can use to manage the project:

• dev: Runs the project in development mode, allowing access to the network and environment while watching the file for changes.
• build: Compiles the project into a single binary file.
• start: Runs the file compiled by the build script.

You can run these with deno task <SCRIPT> or npm run <SCRIPT> if you have npm installed locally.

Deno knows how to use package.json files natively now, so we can rely on that file for our script definitions for more flexibility. If you know that you don't need compatibility with the Node.js ecosystem, you could alternatively define a deno.json file with just the script definitions (called tasks in this context) instead:

{
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env main.ts",
    "build": "deno compile --allow-net --allow-env --output=example-deno main.ts",
    "start": "./example-deno"
  }
}

This file defines the same scripts as the package.json file without the deno-bin compatibility tool. This is helpful if you plan on using Deno-native files and plan on using Docker to build your project.

.git
.gitignore
Dockerfile
.dockerignore
node_modules
tmp
.env
example-deno
README.md

FROM denoland/deno
 
WORKDIR /app
 
COPY main.ts /app
RUN deno cache main.ts
 
ARG PORT
EXPOSE ${PORT:-8000}
 
CMD ["run", "--allow-net", "--allow-env", "main.ts"]

Push the project to GitHub

Once you're finished configuring the project locally, you can commit your work and push it to GitHub.

Start by downloading the generic .gitignore file for Node.js projects from GitHub. We can use this as a starting point for our project:

curl -L https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore -o .gitignore

Add an entry for the artifact produced by the build task that we configured:

echo "example-deno" >> .gitignore

Run the following commands to create a new Git repository within the project's root directory, commit the project files, and push changes to GitHub.

git init
git add :/
git commit -m "Add project files"
git remote add origin git@github.com:<YOUR_GITHUB_USERNAME>/<YOUR_REPOSITORY_NAME>.git
git push -u origin main

Deploy to Koyeb using git-driven deployment

Once the repository is pushed to GitHub, you can deploy the Deno application to Koyeb. Any changes in the deployed branch of your codebase will automatically trigger a redeploy on Koyeb, ensuring that your application is always up-to-date.

Deploy to Koyeb from a container registry

If you chose to build a container image for the Deno application, you can optionally deploy the application from a container registry instead of from GitHub.