kronos443/aws-route53-ddns

Amazon AWS Route53 Dynamic DNS Client

Key features:

• Supports multiple domains simultaneously to the same entry point
• Supports specific URL's as well as wild cards. e.g. home.example1.com and *.example2.com
• Wild card domain mapping supports the use of reverse proxy servers to access internal services
• Multiple methods (4) are supported for specifying the AWS credentials for ease of use. See Providing the AWS Credentials below.
• Up to 10 web hooks to monitor correct function and errors. Ideal for use with monitors such as Uptime Kuma.

Developed using Python and Amazon's BOTO3 library this container will update one or more A records in multiple hosted zones with the locally detected external IP address.

Please see:

https://github.com/ArthurMitchell42/Amazon_AWS_DDNS_Client

https://github.com/ArthurMitchell42/AWS_Route53_DDNS_Docker

Supported Architectures

Currently supports AMD64 (developed on windows and the Synology DS918+ NAS), ARM32 V7 (armhf) (suitable for running on docker under Raspberry PI 32-bit OS) & ARM64 (ARM64V8) (suitable for running on docker under Raspberry PI with a 64-bit OS such as Raspberry PI OS 64-bit and Ubuntu 64-bit)

Going forward I'll be focusing on 64-bit containers for security reasons.

History

See the app readme.md information at https://github.com/ArthurMitchell42/Amazon_AWS_DDNS_Client

PLEASE NOTE

The current Raspberry PI 32-bit OS based on Buster has a bug in the libseccomp library.

Please see this note: https://docs.linuxserver.io/faq#libseccomp

If you wish to use the ARM32V7 image on a 32-bit Raspberry PI OS you have 2 options:

1. Run the container as privelidged (Not generally recommended)
2. Follow the link above to the Linuxserver team's documents and follow option 2 (My personal preference, although I haven't tested the other option.) to update your docker host Raspberry PI

This should instantly fix this, and any other "funnies" you are having with docker containers.

Preparation and Application Setup

The following steps should be taken when setting up this container:

Prepair an AWS key

1. Get an AWS IAM key pair
2. Enable permissions to access Route53 (and only Route53) for the key

Setup the AWS Route53 Zones and Records

3. Have a functional hosted zone for your domain
4. If you want one specific URL to point to your IP set up a single A-Record such as home.yourdomain.com
5. If you want to use reverse proxy to have a number of sub-domain URLs pointing to a number of resources on your IP set up address then set up your records as listed below.

Setup the container

6. Create the configuration directory on the mapped docker share directory.
7. Create the .ini file with the nessesary information in the mapped docker share directory.
8. Add the container to your system and start.

The Configuration File

A text file named AWS_Route53_DDNS.ini should be created in the /config mapped directory. This sets all the options for the program.
The log file is created in the same directory with the name AWS_Route53_DDNS.log and this file will rotate when it reaches 100KB with up to 5 logs named AWS_Route53_DDNS.log.1, AWS_Route53_DDNS.log.2 etc.

Example Configuration File

[Domains]
yourdomain.com = home.yourdomain.com
yourdomain.eu = yourdomain.eu
yourdomain.click = yourdomain.click
[Credentials]
; See notes below on the four methods of providing credentials
;AWS_Access_Key_ID = AAAAAAAAAAAAAAAAAAAAAA
;AWS_Secret_Access_Key = BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
;AWS_Credential_Profile = route53_user
;
[Defaults]
Update_Interval = 3600
Exception_Interval = 300
; Log_Level options are: Debug Info Warning Error Critical
Log_Level_Logfile = Info
Log_Level_Console = Warning
TTL = 3211
Sleep_Time_Initial_Authorisation = 1
Sleep_Time_Inter_Domain = 1
WebHook_Alive = 'HTTP://x.x.x.x/aaaaaaaaa'
WebHook_Alive1 = 'HTTP://x.x.x.x/aaaaaaaaa'
WebHook_Alive2 = 'HTTP://x.x.x.x/aaaaaaaaa'
WebHook_Alert = 'HTTP://x.x.x.x/aaaaaaaaa'
WebHook_Alert1 = 'HTTP://x.x.x.x/aaaaaaaaa'

Please note, a configuration issue resulting in any domain record having an issue updating will cause the docker container to be be marked as unhealthy. Be mindful of this if your system is set to restart a container that marks itself as unhealthy since the solution may be to check the log and find any logical issues in the AWS configuration which might have caused this state rather than just restarting the container.

The Configuration File Parameters

The parameters for the configuration file are as follows.

The example file above shows two main options for configuring an address. The first updates a specific A record in the hosted domain so that home.yourdomain.com is given the external IP address. This is the most simple case and you must create an A-Record with the name home.yourdomain.com in AWS before it can be updated.

The second and third lines show a more flexible option that would allow you to create multiple sub-domain mappings to resources within your network using reverse proxy. To make this work you must create an A-Record within you hosted zone (domain) called yourdomain.click and then a second A-Record called *.yourdomain.click that has a value of yourdomain.click. This will cause any DNS request for sub-domains of this address such as voip.yourdomain.click or sonarr.yourdomain.click to be mapped through to the IP address set up in the yourdomain.click A-Record.

Providing the AWS Credentials

The AWS authorisation credentials can be provided in one of 4 methods.

1. Add them to the AWS_Route53_DDNS.ini file using the AWS_Access_Key_ID and AWS_Secret_Access_Key options

This method is the easiest to get started. It does mean the credentials could be exposed through backups or to users who have access to change the setup however.

2. Add them to the container when the container is created, usually through docker compose, using the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables

This is also quick and easy but has the draw back that anyone with access to the docker system via a management tool such as Portainer can access the credentials.

3. Use docker secrets using the AWS_ACCESS_KEY_ID_FILE and AWS_SECRET_ACCESS_KEY_FILE environment variables

This is the most secure method of providing credentials.

4. Use a credentials file in the standard AWS format placed in the directory mapped to /config

This method is ideal if you want to have a single file with multiple credentials that is shared between multiple applications such as S3 or SES services. Use the AWS_Credential_Profile to target the correct profile.

Note In line with the principles of docker secrets the contents of the files should be just the string that forms the key or secret. The app will perform minor cleaning of the contents to remove white space and superfluous returns/line feeds however.

Usage

Create you container locally by either:

Docker CLI

docker run -d \
        --name AWS_Route53_DDNS \
        -v /path/to/config:/config \
        -e AWS_ACCESS_KEY_ID=your-access-ID \
        -e AWS_SECRET_ACCESS_KEY=your-key-secret \
        -e TZ=Europe/London  \
        --restart unless-stopped 
        kronos443/aws-route53-ddns

docker run -d \
        --name AWS_Route53_DDNS \
        -v /path/to/config:/config \
        -e AWS_ACCESS_KEY_ID_FILE=/run/secrets/aws-access-key-id \
        -e AWS_SECRET_ACCESS_KEY_FILE=/run/secrets/aws-secret-access-key \
        -e TZ=Europe/London  \
        --restart unless-stopped 
        kronos443/aws-route53-ddns

Docker Compose

Options 1 & 4

---
version: "2.1"
services:
  aws-route53-ddns:
    image: kronos443/aws-route53-ddns:amd64-latest
    container_name: AWS_Route53_DDNS
    environment:
      - TZ=Europe/London
    volumes:
      - /path/to/config:/config
    restart: unless-stopped

Option 2

---
version: "2.1"
services:
  aws-route53-ddns:
    image: kronos443/aws-route53-ddns:amd64-latest
    container_name: AWS_Route53_DDNS
    environment:
      - TZ=Europe/London
      - AWS_ACCESS_KEY_ID=your-access-ID
      - AWS_SECRET_ACCESS_KEY=your-key-secret
    volumes:
      - /path/to/config:/config
    restart: unless-stopped

Option 3

---
version: "2.1"
services:
  aws-route53-ddns:
    image: kronos443/aws-route53-ddns:amd64-latest
    container_name: AWS_Route53_DDNS
    environment:
      - TZ=Europe/London
      - AWS_ACCESS_KEY_ID_FILE=/run/secrets/your-access-id-file
      - AWS_SECRET_ACCESS_KEY_FILE=/run/secrets/your-key-secret-file
    volumes:
      - /path/to/config:/config
    restart: unless-stopped

Synology NAS

To run the container on a Synology NAS:

1. Open File Station and create a new directory to act as the /config volume. E.g. /docker/AWS_Route53_DDNS.
2. Put your customised AWS_Route53_DDNS.ini file in this directory.
3. Use the GUI on the desktop to search the registry for kronos443.
4. Download the image from the registry by double clicking it.
5. On the image tab, double click the newly downloaded image to start configuring it.
6. On the Gerneral Settings window, name the image and if you want eneable resource limitation.
7. Click advanced settings
8. On the Advanced Settings window under the Advanced Settings tab enable auto-restart
9. On the volume tab add folder and map your new docker/AWS_Route53_DDNS directory to /config
10. On the netwrok tab select 'Use same network as Docker Host'
11. On the Environment tab add the environment variables
12. Click apply, then Next and on the Summary window Apply

Parameters

The parameters are described below.

If you find this container useful then please *** buying me a coffee by following this link or scanning the QR below. :)