
## Introduction

Deno is a secure by default JavaScript and TypeScript runtime built in Rust and using V8. Deno provides great primitives to ease developers life such as:

- Strong security by default, you have to explicitly enable network, filesystem, or environment access
- Support of TypeScript out of the box
- Ships a self-contained, standalone binary
- No package manager, external modules are imported directly into local modules

In this guide, we will build a simple API in Deno using Oak and deploy to production on Koyeb.

## Requirements

To successfully follow and complete this tutorial, you need:

- [Docker](https://docs.docker.com/get-docker/) installed on your machine
- A [Koyeb account](https://www.koyeb.com) to deploy and run the dockerized Deno application

## Steps

To successfully complete this guide, you need to follow the steps below:

1. [**Write a simple Deno API with Oak**](#write-a-simple-deno-api-with-oak)
2. [**Dockerize the Deno application**](#dockerize-the-deno-application)
3. [**Push the Docker image on the Docker Hub**](#push-the-docker-image-on-the-docker-hub)
4. [**Deploy the Deno application to production on Koyeb**](#deploy-the-deno-application-to-production-on-koyeb)

## Write a simple Deno API with Oak

Let's start by writing a simple Deno API application with Oak. In a terminal, create a new folder and go to he freshly created directory.

```bash
mkdir koyeb-deno-example
cd koyeb-deno-example
```

Create a new file name `deno-demo.ts` and add the code snippet below:

```ts
import { Application, Router } from 'https://deno.land/x/oak/mod.ts'

const songs = new Map<string, any>([
  [
    '1',
    {
      id: '1',
      title: 'Herefore',
      author: 'Parcels',
    },
  ],
  [
    '2',
    {
      id: '2',
      title: 'True Sorry',
      author: 'Ibrahim Maalouf',
    },
  ],
  [
    '3',
    {
      id: '3',
      title: 'But I Do',
      author: 'Poldoore',
    },
  ],
])

const router = new Router()

router
  .get('/', (context) => {
    context.response.body = 'Hello World!'
  })
  .get('/songs', (context) => {
    context.response.body = Array.from(songs.values())
  })
  .get('/songs/:id', (context) => {
    if (context.params && context.params.id && songs.has(context.params.id)) {
      context.response.body = songs.get(context.params.id)
    }
  })

const app = new Application()
app.use(router.routes())
app.use(router.allowedMethods())

console.log(`HTTP webserver running on port 8080.`)
await app.listen({ port: 8080 })
```

The code above uses the Deno [oak](https://github.com/oakserver/oak) module, which is a middleware framework for Deno’s HTTP server and also provides a router middleware.

The application listens on port `8080` and exposes three different routes:

- `/`: Returning **Hello World!** as a response when a request is made
- `/songs`: Returning a list of songs
- `/songs/:id`: Returning details about a specific song

## Dockerize the Deno application

The next step is to Dockerize our Deno application to deploy and run it on the Koyeb serverless platform. In the `koyeb-deno-example` folder, create a Dockerfile with the content below:

```dockerfile
FROM hayd/alpine-deno:latest

WORKDIR /app
ADD deno-demo.ts /app

EXPOSE 8080

# Compile the app so that it doesn't need to be compiled at each start.
RUN deno cache deno-demo.ts

CMD ["run", "--allow-net", "deno-demo.ts"]
```

As you can see, we pass the `--allow-net` flag in the `CMD` instruction. As Deno is secured by default, we need to explicitly enable network access.

Build the Docker image by running the following command in the `koyeb-deno-example` folder:

```bash
docker build . -t <YOUR_DOCKER_HUB_USERNAME>/koyeb-deno-demo
```

_In this guide, we will push the Docker image on the Docker Hub registry. Replace `<YOUR_DOCKER_HUB_USERNAME>` with your Docker Hub username._

Once the build done, run the Docker image locally to ensure everything is running fine:

```bash
docker run -d -p 8080:8080 <YOUR_DOCKER_HUB_USERNAME>/koyeb-deno-demo`
```

Open your browser and navigate to `http://localhost:8080`. You see `Hello world!` served by the Docker container.

## Push the Docker image on the Docker Hub

As we previously built and tested our Docker image, we can now push it to the [Docker Hub](https://hub.docker.com/).
In your terminal run the command below to push the image.

```bash
docker push <YOUR_DOCKER_HUB_USERNAME>/koyeb-deno-demo
```

Within a few minutes, you will see your Docker image available on your Docker Hub account repository.

## Deploy the Deno application to production on Koyeb

In the [Koyeb control panel](https://app.koyeb.com/), on the **Overview** tab, click click **Create Web Service** to begin:

1. Select **Docker** as the deployment method.
2. Enter the name of the image you created in the **Docker image** field.
3. Click the **Private image** toggle and, in the select field, click **Create secret**. In the form that appears, fill in a name for the Secret, for instance `docker-hub-secret`, the registry provider, **Docker Hub** in our case, your Docker Hub **username** and **password**. We recommend you to [generate an access token](https://hub.docker.com/settings/security) from the Docker Hub to use instead of your password. Once you've filled all the fields, click the **Create** button.
4. Choose a name for your App and Service, for example `koyeb-deno-demo`, and click **Deploy**.

_You can add more regions to deploy your applications, set environment variables, and define the horizontal scaling according to your needs._

You will automatically be redirected to the Koyeb App page where you can follow the progress of your Deno application deployment. In a few seconds, once your app is deployed, click on the _Public URL_ ending with `koyeb.app`.

Your Deno application is now running on Koyeb and benefits from native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our edge network.


This tutorial showcases how easy it is to build and deploy a Deno application to production on the Koyeb serverless platform.

Deno

How to Build and Deploy a Deno Application on Koyeb