
This is a Dynamic DNS system built using AWS Route53 and a Node script running on a Raspberry Pi.

![](./aws-ddns.jpg)

## Index
* [What is a DDNS?](#what-is-a-ddns)
* [Prerequisites](#prerequisites)
* [Getting your current IP](#getting-your-current-ip)
* [Get the IP address from your DNS record to check if it needs to be updated](#get-the-ip-address-from-your-dns-record-to-check-if-it-needs-to-be-updated)
* [Update IP in DNS record](#update-ip-in-dns-record)
* [Run the script on a schedule](#run-the-script-on-a-schedule)
* [Resources](#resources)

## What is a DDNS?
A dynamic DNS is handy if you want to host or access things on your home network from the internet but you don't have a static IP address from your service provider.

Essentially what it does is update the IP address for a given DNS record to be the current public IP address of the machine running the script.

So for example, if you want to have a domain name always pointing to your home network, you run this script on a machine within your home network.

Let's say your domain is `example.com`, you could create an A record for `home.example.com` that points to your home network. You could manually check what your current public IP address is and set it in the AWS console. But likely you have a dynamic IP at home, and it may randomly change at any moment, breaking your DNS record.

Let's automate updating it

## Prerequisites
You'll need:
* An AWS account
	* With credentials set up in your environment of choice
* A domain and hosted zone set up in Route53
* Node installed
* AWS-SDK node package
* Some kind of machine running in your network of choice that will be always on so that it can run the script on a regular schedule. I use a Raspberry Pi as it's low power, easy to setup, and tiny.

First setup your project. I used NPM to init a new project, then added the `aws-sdk` and `node-fetch` packages. Also add `"type": "module"` to your _package.json_ so node doesn't yell at you for using `import`.

## Getting your current IP
There are many ways to do this. A trivial way that I chose is to use a service provided by AWS [checkip.amazonaws.com](http://checkip.amazonaws.com). Simply fetch that URL and trim the result to get your current public IP address.

It's probably a good idea to be validating the IP address returned is a valid IPV4 format. I make a simple helper function to validate an IP address

```javascript
import fetch from "node-fetch";

function validateIp(ipString) {
	const re = /^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/;
	return !!ipString.match(re);
}

async function getCurrentIp() {
	console.log("Fetching current ip...");
	const response = await fetch("http://checkip.amazonaws.com/");
	const ip = (await response.text()).trim();
	if (validateIp(ip)) {
		console.log(ip);
		return ip;
	}
	console.error("Fetching ip failed");
	return false
}

async function main() {
	const ip = await getCurrentIp();
	if (!ip) {
		return 1;
	}
}

main();
```

## Get the IP address from your DNS record to check if it needs to be updated

This maybe isn't actually necessary. You're really just making a call to save yourself from making a call. But if this script got more complicated this might be a better idea.

Check out the [AWS Node SDK Docs](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-started-nodejs.html) and the [AWS JavaScript Route53 SDK Docs](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Route53.html) for more details on their usage.

I made a function  `getIpFromDnsRecord` that fetches the current IP address from the A record of the given hostname and hosted zone id.

```javascript
import fetch from "node-fetch";
import AWS from "aws-sdk";

const hostedZoneId = "GETTHISIDFROMYOURAWSCONSOLE";
const hostname = "home.yourdomain.com";

const route53 = new AWS.Route53({ apiVersion: "2013-04-01" });

function validateIp(ipString) {
	const re = /^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/;
	return !!ipString.match(re);
}

async function getIpFromDnsRecord() {
	console.log(`Fetching ip currently set for ${hostname}...`);
	const params = {
		HostedZoneId: hostedZoneId,
		StartRecordName: hostname,
		StartRecordType: "A",
		MaxItems: "2"
	}
	const recordSets = await route53.listResourceRecordSets(params).promise()
	for (let record of recordSets["ResourceRecordSets"]) {
		if (record["Name"] == hostname + ".") {
			if (record["ResourceRecords"].length == 1) {
				const ip = record["ResourceRecords"][0]["Value"].trim();
				if (validateIp(ip)) {
					console.log(ip);
					return ip;
				}
			}
		}
	}
	console.error(`Fetching ip for hostname ${hostname} failed`)
	return false;
}

async function getCurrentIp() {
	console.log("Fetching current ip...");
	const response = await fetch("http://checkip.amazonaws.com/");
	const ip = (await response.text()).trim();
	if (validateIp(ip)) {
		console.log(ip);
		return ip;
	}
	console.error("Fetching ip failed");
	return false
}

async function main() {
	const ip = await getCurrentIp();
	if (!ip) {
		return 1;
	}

	const previousIp = await getIpFromDnsRecord();
	if (!previousIp) {
		return 1;
	}

	if (ip == previousIp) {
		console.log("Ip hasn't changed. No action required")
	} else {
		console.log("Ip address has changed!")
	}
	
	return 0;
}

main();
```

## Update IP in DNS record
If the current public IP address is different than the one set in your DNS record, you'll want to update it!

I made a function `setIpInDnsRecord(ip)` that will update the DNS record in Route53.

```javascript
import fetch from "node-fetch";
import AWS from "aws-sdk";

const hostedZoneId = "GETTHISIDFROMYOURAWSCONSOLE";
const hostname = "home.yourdomain.com";

const route53 = new AWS.Route53({ apiVersion: "2013-04-01" });

function validateIp(ipString) {
	const re = /^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/;
	return !!ipString.match(re);
}

async function setIpInDnsRecord(ip) {
	console.log(`Updating DNS record for ${hostname} to ${ip}...`);
	const date = new Date();
	const params = {
		ChangeBatch: {
			Changes: [{
				Action: "UPSERT", // this will update an existing record
				ResourceRecordSet: {
					Name: hostname,
					ResourceRecords: [
						{ Value: ip }
					],
					TTL: 300,
					Type: "A"
				}
			}],
			Comment: `Updated IP address on ${date.toString()}`
		},
		HostedZoneId: hostedZoneId
	};
	const response = await route53.changeResourceRecordSets(params).promise();
	// missing any error handling
	console.log(`DNS record for ${hostname} updated to ${ip}. Can take up to 60s to propogate`);
}

async function getIpFromDnsRecord() {
	console.log(`Fetching ip currently set for ${hostname}...`);
	const params = {
		HostedZoneId: hostedZoneId,
		StartRecordName: hostname,
		StartRecordType: "A",
		MaxItems: "2"
	}
	const recordSets = await route53.listResourceRecordSets(params).promise()
	for (let record of recordSets["ResourceRecordSets"]) {
		if (record["Name"] == hostname + ".") {
			if (record["ResourceRecords"].length == 1) {
				const ip = record["ResourceRecords"][0]["Value"].trim();
				if (validateIp(ip)) {
					console.log(ip);
					return ip;
				}
			}
		}
	}
	console.error(`Fetching ip for hostname ${hostname} failed`)
	return false;
}

async function getCurrentIp() {
	console.log("Fetching current ip...");
	const response = await fetch("http://checkip.amazonaws.com/");
	const ip = (await response.text()).trim();
	if (validateIp(ip)) {
		console.log(ip);
		return ip;
	}
	console.error("Fetching ip failed");
	return false
}

async function main() {
	const ip = await getCurrentIp();
	if (!ip) {
		return 1;
	}

	const previousIp = await getIpFromDnsRecord();
	if (!previousIp) {
		return 1;
	}

	if (ip == previousIp) {
		console.log("Ip hasn't changed. No action required")
	} else {
		console.log("Ip address has changed!")
		await setIpInDnsRecord(ip);
	}
	
	return 0;
}

main();
```

And that's about it for the script! You could make this simpler or more complex as you see fit.

Try it out by running the script

```bash
node script.js
```

## Run the script on a schedule
I am running this on a Raspberry Pi running the Raspberry Pi OS. This should be similar to any Linux environment (I think? 🤷🏻‍♂️).

I used a cron to schedule the node script. Open your cron schedules with
```bash
crontab -e
```

Add a new schedule for your script. Google cron syntax if you're unfamiliar. I set mine to trigger ever 10 minutes.

```crontab
*/10 * * * * node /home/YOURUSERNAME/path/to/script.js
```

Save that file with the new entry at the bottom.

Now just restart your machine and the cron should take effect.

As long as the device remains powered on and running inside your network, your DNS record will remain updated with your current IP address!

## Resources
*  [AWS Node SDK Docs](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/getting-started-nodejs.html)
*  [AWS JavaScript Route53 SDK Docs](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Route53.html)
* [AWS DDNS Example](https://github.com/awslabs/route53-dynamic-dns-with-lambda/blob/master/v1/dynamic_dns_lambda.py)
* [Crons on Raspberry Pi](https://bc-robotics.com/tutorials/setting-cron-job-raspberry-pi/)
* [DDNS Example from Anthony Heddings](https://gist.github.com/anthonyheddings/f22967967bbf524ed510c356678b2651)

AWS Dynamic DNS


During a recent project to convert my JavaScript & Node [Battlesnake](https://play.battlesnake.com/) over to TypeScript & [Deno](https://deno.land/), I decided I would also create a more robust suite of tests for it.

![Deno and Github logos with an addition symbol between them](DenoTestsAndGithubActionsCI.png)

If you are unfamiliar with [Battlesnake](https://play.battlesnake.com/), it is an online and in-person programming competition where you build a AI in the form of a REST API that can play a multiplayer version of the classic game [Snake](https://en.wikipedia.org/wiki/Snake_(video_game_genre). You can check out details on their [website](https://play.battlesnake.com/) to learn more, and even watch some past events on their [Twitch channel](https://www.twitch.tv/BattlesnakeOfficial).

## Tl;dr
* [Deno Tests](#deno-tests): Deno includes a very simple test runner framework.
* [Github Actions](#github-actions): Github actions allow you to automate tasks based on triggers within your Github repo.
* [Create the workflow](#create-the-workflow): A .yml file describes a series of actions you would like to perform based on a trigger.
* [Automate Deno tests](#automate-deno-tests): Just add a `run: deno test` command to your workflow .yml.

## Deno Tests
[Deno](https://deno.land/) includes a simple test runner for tests in js, ts, jsx, or tsx files. It can be run with:

```bash
deno test
```

To create tests, all you need to use is use the `Deno.test()` method included with Deno within files ending in *test* (`{*_,}test.{js,ts,jsx,tsx}`) anywhere in your project structure. I put mine in *tests/*.

Example of a basic test:

```typescript
import { assert } from "https://deno.land/std/testing/asserts.ts";
import { root } from "../app/main.ts";

Deno.test("Root response contains expected fields", () => {
  // when
  const result = root();
  // then
  assert(result?.apiversion);
  assert(result?.author);
  assert(result?.head);
  assert(result?.tail);
  assert(result?.color);
});
```

This test is simply asserting that values exist for these specified fields.

You can add many tests to single files by calling `Deno.test()` over and over again. You can also make as many test files as you like, Deno will automatically execute all the files it recognizes ending in *test* (`{*_,}test.{js,ts,jsx,tsx}`).

Visit the [Deno Testing docs](https://deno.land/manual/testing) for more info about creating tests.

Easy! So now I can create a robust set of unit tests for my Battlesnake AI.

Since the game Battlesnake works by [sending you the entire game state for every move](https://docs.battlesnake.com/references/api), I can also save the game state JSON from particularly tricky moves and use them within their own tests. The output can be compared against the single best move, or even a set of equally good moves if their are multiple. Creating tests like this tests the behaviour of the AI overall and ensures that changes to the behaviour aren't making the AI perform worse on moves it previously was able to do correctly.

So now that I have tests up and working, I wanted to automate them using Github Actions.

## Github Actions
Github Actions are still quite new to me and I hadn't touched them at all before this project. I just assumed it would be complicated to set up.

For what I wanted to do for this project it was actually trivial. Couldn't have been easier.

What I wanted was to run these tests automatically whenever pushing to my repository. I figured this Deno app is pretty simple all things considered, so I shouldn't have to mess around with Docker or anything like that.

I'll step you through what I did.

## Create the workflow
Github Actions are based around these things called workflows. They are essentially .yml scripts that describe the series of events you want to perform in your action.

If you click the Actions tab within the repo you want to create the Action you will be presented with a Get started with GitHub Actions page. This page has many example actions you get you started for so many different languages, frameworks, and platforms. It will even suggest actions to you based on the contents of your repo. I chose the *Skip this asn set up a workflow yourself* option.

![Get started with Github Actions](DenoAndGithubActions-get-started-with-github-actions.png)

This plops you into a web editor and gives you a basic example workflow .yml file to start with. It looks something like this:

```yaml
# This is a basic workflow to help you get started with Actions

name: CI

# Controls when the action will run. Triggers the workflow on push or pull request
# events but only for the master branch
on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job will run on
    runs-on: ubuntu-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
    - uses: actions/checkout@v2

    # Runs a single command using the runners shell
    - name: Run a one-line script
      run: echo Hello, world!

    # Runs a set of commands using the runners shell
    - name: Run a multi-line script
      run: |
        echo Add other actions to build,
        echo test, and deploy your project.

```

With this you can actually click the *Start commit* button and that will guide you to commit this .yml file to your repo within the *.github/workflows/* directory.

You can see near the top of that file that there are triggers for `on push` and `on pull_request` attached to the master branch. You can try to push something to master and see it work!

If you visit the Actions tab of your repo now you will see your Actions and the history of all the times they have run. You can click into them for more details and to see the console outputs. Also by default it will email your Github account email whenever an action fails. I imagine this can be changed somewhere if you don't like that.

![Github Actions](DenoAndGithubActions-github-actions.png)

## Automate Deno tests
Now I wanted to try to run my tests using Deno. I knew this would involve installing Deno somehow so I searched around.

I found [this repo](https://github.com/denolib/setup-deno) from [denolib](https://github.com/denolib) with exactly what I wanted.

Really all you need to do is add the `uses` line pointing to this repo to your workflow .yml file under the `steps` section. You can also include the Deno version you prefer. Then within the `run` section you now have access to `deno` and all of its functions.

So now my workflow .yml file looks like this:

```yaml
name: CI

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@master
    - uses: denolib/setup-deno@master
      with:
        deno-version: v1.x
    - run: deno run https://deno.land/std/examples/welcome.ts
```

One really cool feature of Deno is that you can run scripts from the web right in the terminal, and you can also do this right within Github Actions. That is what the URL is doing in

```yaml
- run: deno run https://deno.land/std/examples/welcome.ts
```

You can run this and then look within your Github Actions for the console output from this example *welcome.ts* file.

So now to run my tests, all I needed to do was change that `deno run` command to `deno test`. My final .yml workflow looks something like this:

```yaml
name: CI

on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]

jobs:
  run-tests:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@master
    - uses: denolib/setup-deno@master
      with:
        deno-version: v1.x
    - run: deno test
```

Now every time I push to my master branch all my tests will be run, including any new tests I just committed, and I will be notified both on the Github UI and in my email if any tests fail. I can then log into Github and look at the output to see what failed.

I hope this small guide helped you out and showed you just how simple both Deno and Github Actions are!

#node

AWS Dynamic DNS

March 20, 2022 5 Minute Read

Deno Tests & GitHub Actions CI

May 23, 2020 6 Minute Read

Get in touch