Introduction to the newline guide to building and deploying a REST API using Deno.

Welcome to Build and Deploy a REST API with Deno!

In this lesson, we will install Deno and create our setup for the rest of the course.

How to Install Deno Locally and in Docker Containers

Introduction

Deno vs Node: A Deno Fresh Start to JavaScript Runtimes

We will look at the command line interface for running Deno

How to Use the Deno REPL Command Line Interface

In this lesson, we will look at general usage of Deno by running a file and also introduce the config file

Executing TypeScript Files With Deno With the Config File

Learn how to use the Deno standard library and other external modules with URL imports

Deno vs Golang's Standard Library

How to Start a Deno Server and Set Permissions

You will learn how to make a simple token authentication in Deno

How to Build a Token Authentication Server With Deno

Getting Started with Deno

Using Databases with Deno

How to Use PostgreSQL in Docker with Deno

How to Integrate MySQL or MariaDB With Deno

How to Add SQLite to Deno with deno-sqlite

Connect to a database

Introduction to database migrations - what, why and how

What is Database Migration? The Strategy to Migrate Data

Get started with database migrations using Nessie

How to Add Nessie to Deno to Migrate Databases

We will go through creating a migration using the Nessie CLI

How to Create a New Database Migration With Deno Nessie

We will look at how to write a migration script where we create a table

Edit a Deno Nessie Database Migration to Catch Errors

We will run our migration and learn how to roll back the migration

How to Run and Roll Back a Database Migration With Deno Nessie

We will create a seed file using the Nessie CLI

How to Create a Database Seed File With Deno Nessie

We will run our seed file and populate our database

How to Import JSON Data and Seed a Database With Deno Nessie

Database migrations

Introduction to the concept of REST APIs and why we use them

REST API Introduction

We will go through the thought process of planning an application.

Best Practices for a REST API: Endpoints and Database Schema

We will create the initial project files and set up our environment

How to Prepare Deno to Build a REST API

We will create the router and look at how to test our endpoints

How to Build REST API Endpoints in Deno

It's time to add Nessie! We will now initialize Nessie in our project and also spin up our development database

Integrate a PostgreSQL Database With Nessie Into a Deno API

Time to connect our models to our database!

Building a MySQL or PostgreSQL Database Pool in Deno

In this step, we will create our first data model and create a corresponding table using a migration

Migrating Data to PostgreSQL and Modeling Data in Deno

Creating the methods to access the database

Build API Calls That Generate SQL Queries in Deno

Creating the server endpoints for the Duck namespace

Create a Database Controller in Deno

We will look at how to set up authentication and further authorize the requests

How to Authenticate and Authorize REST API Requests in Deno

We will create two new tables using a migration and create the equivalent models

Create New Tables and Models With Deno Database Migration

We will create our Quack service and controller

Add List, Create, Read, Update, and Delete Requests in Deno

The last stretch! We will create our final namespace, Crumb, and connect it to our other models and our router

How to Build Many-to-Many Namespace Connections in Deno

Now that our application is completed, we will consider some improvements and discuss alternative approaches.

API Afterthoughts

REST API

We will introduce deployments and what we will learn in this module

Deployment Introduction

We will create a Docker image for our application

How to Create a Docker Image to Containerize an Application

You will learn how to create a basic CI file for GitHub and GitLab, and run tests on them

How to Create Continuous Integration Files for GitHub and GitLab

We will deploy our application to a server using CI, SSH and git.

How to Deploy a Deno API Server With the Digital Ocean API

We will deploy our application to Digital Ocean Apps. This is by far the easiest (but most costly) approach.

How to Deploy a Deno Docker Image to Digital Ocean

Similar to how we did it in lesson 1, we will be deploying using CI and SSH, but instead of git, we will be using Docker.

Deploy with Docker

Deployment

In this course, we will learn how to work with [Deno](https://deno.land) to create a REST API using TypeScript with the web framework [Oak](https://github.com/oakserver/oak) and the migration tool [Nessie](https://github.com/halvardssm/deno-nessie). 
Deno is a JavaScript runtime created by [Ryan Dahl](https://tinyclouds.org), the same creator for Node, as an attempt to simplify the JavaScript landscape by strictly following the WebAPI specs. 
If you are interested in learning more about the motivation behind Deno, you can watch this video where Ryan Dahl explains "[10 Things I Regret About Node.js](https://www.youtube.com/watch?v=M3BM9TB-8yA)"

We will explore how to create an application using the powers of TypeScript, and learn how to traverse the Deno ecosystem which is much like the native web ecosystem. 
There are 5 modules that will take you from installing Deno and running your first lines of code, to working with web frameworks and databases, and in the end, deploying your application to a web server using a deployment pipeline.

Throughout this course, you will experience all the different aspects of Deno which you will need to create your own application in the future. 
And from this course, you will get a good feeling for if Deno is ready to be your next default for new projects.

In this course, we will learn how to create and deploy a REST API with Deno from scratch.

Build and deploy a REST API with Deno

Integrating databases into your application

Importance of database migrations in production applications

Deploying Deno applications to production using CICD

We will now create our first deployment using git and SSH. Although it's not the
prettiest, and has its flaws, it's by far the easiest way to get up and running.

To be able to follow this tutorial, you will need a DigitalOcean account (see
the Deployment Introduction lesson in this module for instructions).

 if have not
already done this. We will now proceed with creating a server which is called a

 button in the top right of the DigitalOcean console,
and select 

You should now be on the Droplet creation page. Select the latest LTS image from
Ubuntu, and then choose the smallest available CPU option from the 

Skip adding block storage, and choose the datacentre closest to you (the
location doesn't really matter for this tutorial). Accept the defaults for VPC
network, and don't check any of the boxes for additional options.

For authentication, add your SSH key, and if you don't have one, follow their
guide on how to create an SSH key. Only select one Droplet, and keep the default
hostname. Keep the tags empty, select your default project, and don't select
backups.

, and your Droplet should be up and running in a couple of
minutes.

You should now be able to SSH into your new server by getting its IP address
from the Droplet page.

If you get a prompt for adding the host to your known list, you can accept it.

You should now be inside your server. For good measure, run an update and
upgrade to make sure that you have the latest updates. We should also take this
opportunity to install Make and Deno, as we'll be using them soon.

apt update && apt upgrade
apt install make
snap install deno

The next step is to set up our firewall, and for this we will be using a tool
called UFW. The steps taken will be very similar to

By executing the below, we are by default denying all incoming, and allowing all
outgoing connections. We are also allowing incoming SSH (port 22) and HTTP
(port 80) connections.

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow http

IMPORTANT: before going further, be sure that you allowed SSH (port 22) from
above, as you won't be able to access your server again if you don't, and will
have to delete the Droplet and start over.

Now we have to enable UFW to get the firewall up and running.

As we want our pipeline to access our server and run a script to update our
application to the latest version, we need a separate user, only allowed to do
these exact actions, for security reasons.

Let's start by adding the user and giving it a secure password.

Now we also need to give it sudo permissions and make the access passwordless:

usermod -aG sudo ci
echo "ci ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/ci-user

 user is set up, we can switch to it and confirm that the sudo
is indeed passwordless:

If you get no errors or password prompts, you can exit out of the root user and
back into the 

Now we also want to make sure that we can log in remotely. In the 

 account,
create an SSH key which can be used by our pipeline:

The generator will give you a couple of prompts, but just 

 your way
through them to leave them at their default values.

Once the key is generated, we want to place it in the authorized keys so that we
can log in using it.

cat ~/.ssh/id_rsa.pub > ~/.ssh/authorized_keys

Lastly, copy the private key locally so that we can use it in the pipeline
later.

There are multiple ways of running Postgres, but generally you want to use a
managed service like

. That being said,
for small hobby projects, or where you know what you are doing, you can also
install it locally on your server. I will show both approaches, so choose the
one best suited for you.

First let's install PostgreSQL. We will mostly follow


guide, but in summarized steps. Execute the following:

sudo apt install postgresql postgresql-contrib

Postgres should now be running, so we can access it via 

 which will allow
us to directly query the database from our shell.

For security reasons, our application should never use the default 


user when connecting, so we will need to change it, and for good measure, we
should use MD5 authentication instead of the linux connected user. One reason
for this is so that we have the server users separated from the database, and
also so that we won't have to place server credentials in our application.

With the command below, change the default Postgres password to something you
will remember.

ALTER USER postgres PASSWORD 'Radiator-Scapegoat2-Yanking';

---
title: How to Deploy a Deno API Server With the Digital Ocean API
description: We will deploy our application to a server using CI, SSH and git.
code: https://gitlab.com/fullstackio/books/newline-course-apps/halvard-morstad-build-and-deploy-a-rest-api-with-deno-app/-/tree/main/app_with_sqlite_db%20(updated)/module_5.3?ref_type=heads
---

## Deploy with SSH and git

We will now create our first deployment using git and SSH. Although it's not the
prettiest, and has its flaws, it's by far the easiest way to get up and running.

> To be able to follow this tutorial, you will need a DigitalOcean account (see
> the Deployment Introduction lesson in this module for instructions).

### Create Droplet

Log into your [Digital Ocean account](https://digitalocean.com) if have not
already done this. We will now proceed with creating a server which is called a
`Droplet` in DigitalOcean.

Press the green `Create` button in the top right of the DigitalOcean console,
and select `Droplets` from the dropdown.

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_06/lesson_03/public/assets/create_droplet.png)

You should now be on the Droplet creation page. Select the latest LTS image from
Ubuntu, and then choose the smallest available CPU option from the `Basic` plan
(should be $5 a month).

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_06/lesson_03/public/assets/droplet_select_plan.png)

Skip adding block storage, and choose the datacentre closest to you (the
location doesn't really matter for this tutorial). Accept the defaults for VPC
network, and don't check any of the boxes for additional options.

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_06/lesson_03/public/assets/droplet_select_region.png)

For authentication, add your SSH key, and if you don't have one, follow their
guide on how to create an SSH key. Only select one Droplet, and keep the default
hostname. Keep the tags empty, select your default project, and don't select
backups.

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_06/lesson_03/public/assets/droplet_select_finalize.png)

Finally press `Create`, and your Droplet should be up and running in a couple of
minutes.

### Server setup

You should now be able to SSH into your new server by getting its IP address
from the Droplet page.

![](https://d2uusema5elisf.cloudfront.net/courses/build-and-deploy-a-rest-api-with-deno/module_06/lesson_03/public/assets/droplet_ip.png)

```shell
ssh root@xxx.xxx.xxx.xxx
```

> If you get a prompt for adding the host to your known list, you can accept it.

You should now be inside your server. For good measure, run an update and
upgrade to make sure that you have the latest updates. We should also take this
opportunity to install Make and Deno, as we'll be using them soon.

```shell
apt update && apt upgrade
apt install make
snap install deno
```

#### Set up firewall with UFW

The next step is to set up our firewall, and for this we will be using a tool
called UFW. The steps taken will be very similar to
[this tutorial](https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-20-04)
from DigitalOcean.

By executing the below, we are by default denying all incoming, and allowing all
outgoing connections. We are also allowing incoming SSH (port 22) and HTTP
(port 80) connections.

```shell
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow http
```

> IMPORTANT: before going further, be sure that you allowed SSH (port 22) from
> above, as you won't be able to access your server again if you don't, and will
> have to delete the Droplet and start over.

Now we have to enable UFW to get the firewall up and running.

```shell
sudo ufw enable
```

#### Add a CI user

As we want our pipeline to access our server and run a script to update our
application to the latest version, we need a separate user, only allowed to do
these exact actions, for security reasons.

Let's start by adding the user and giving it a secure password.

```shell
sudo adduser ci
```

Now we also need to give it sudo permissions and make the access passwordless:

```shell
usermod -aG sudo ci
echo "ci ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/ci-user
```

Once the new `ci` user is set up, we can switch to it and confirm that the sudo
is indeed passwordless:

```shell
su ci
sudo -i
```

If you get no errors or password prompts, you can exit out of the root user and
back into the `ci` user:

```shell
exit
```

Now we also want to make sure that we can log in remotely. In the `ci` account,
create an SSH key which can be used by our pipeline:

```shell
ssh-keygen -b 4096
```

The generator will give you a couple of prompts, but just `enter` your way
through them to leave them at their default values.

Once the key is generated, we want to place it in the authorized keys so that we
can log in using it.

```shell
cat ~/.ssh/id_rsa.pub > ~/.ssh/authorized_keys
```

Lastly, copy the private key locally so that we can use it in the pipeline
later.

```shell
cat ~/.ssh/id_rsa
```

### Install database

There are multiple ways of running Postgres, but generally you want to use a
managed service like
[DO's Managed Databases](https://digitalocean.com/databases). That being said,
for small hobby projects, or where you know what you are doing, you can also
install it locally on your server. I will show both approaches, so choose the
one best suited for you.

##### Local Postgres

First let's install PostgreSQL. We will mostly follow
[this](https://www.digitalocean.com/community/tutorials/how-to-install-postgresql-on-ubuntu-20-04-quickstart)
guide, but in summarized steps. Execute the following:

```shell
sudo apt install postgresql postgresql-contrib
```

Postgres should now be running, so we can access it via `psql` which will allow
us to directly query the database from our shell.

```shell
sudo -u postgres psql
```

For security reasons, our application should never use the default `postgres`
user when connecting, so we will need to change it, and for good measure, we
should use MD5 authentication instead of the linux connected user. One reason
for this is so that we have the server users separated from the database, and
also so that we won't have to place server credentials in our application.

With the command below, change the default Postgres password to something you
will remember.

> Don't forget the semicolon (`;`) at the end of each database query!

```sql
ALTER USER postgres PASSWORD 'Radiator-Scapegoat2-Yanking';
```

We can now create a new user (in Postgres, this is called `role`) with a
password, and a database owned by this user. Substitute the password below with
your own secure string.

```sql
CREATE ROLE quacker LOGIN PASSWORD 'Bronze-Plated5-Approve'; 
CREATE DATABASE quacker OWNER 'quacker';
```

Let's test out our new user! Exit the `psql` shell by typing `exit`.

```sql
exit
```

Now we are back to our familiar Ubuntu shell. Although we added/changed password
for our database users, we need to tell Postgres that we want to authenticate
using a password. Let's make some changes to our Postgres config, using Vim or
any other command line editor of your choice:

> If you don't know about any command line editors, [Vim](https://www.vim.org/)
> is a pretty standard one which is mostly available on any system by default.
> Although Vim is a bit dificult to start withm there are tons of interactive
> tutorials online. Here you can even learn Vim by playing a
> [game](https://vim-adventures.com/)!