DNS dinamico è un servizio di rete per la mappatura di nomi di dominio su indirizzi IP dinamici (temporanei, che cambiano frequentemente). Viene utilizzato per accedere a computer che non dispongono di un indirizzo IP statico, come quelli nelle reti SOHO (Small Office/Home Office), e viene spesso utilizzato in combinazione con il port forwarding per accedere ai sistemi che si trovano dietro i firewall NAT. Questo articolo ti guiderà attraverso la configurazione completa di un server DNS dinamico in un container Docker su un sistema Debian 10, inclusa la configurazione dei record DNS richiesti, il posizionamento dell'API di gestione dietro un proxy inverso HTTPS Nginx e l'automazione del DNS lato client registrare gli aggiornamenti.
Requisiti
- Un singolo server Debian 10, opzionalmente con connettività IPv6. (192.0.2.2 e 2001:0db8::0db9 verranno utilizzati come segnaposto rispettivamente per IPv4 e IPv6 del server.)
- Accesso all'utente root o a un utente con privilegi sudo.
- Le porte tcp/53 e udp/53 devono essere disponibili sull'host.
- Un nome di dominio registrato e l'accesso ai suoi server dei nomi/file di zona. Crea record DNS per questo dominio come mostrato nella sezione successiva.
- Il $EDITOR è necessario impostare la variabile di ambiente.
- Facoltativamente, qualsiasi sistema client Linux/Unix per configurare gli aggiornamenti automatici dei record DNS.
Creazione di record DNS.
Dovrai creare almeno 2 record DNS affinché il tuo server DNS dinamico funzioni. Innanzitutto, scegli un sottodominio come ns1.your_domain che punterà all'indirizzo IPv4 del tuo server. In secondo luogo, scegli un sottodominio come ddns.your_domain che sarà delegato a ns1.your_domain.
Il tuo server DNS dinamico gestirà tutti i record in ddns.your_domain. Il terzo record, di tipo AAAA, è facoltativo. I record corrispondenti hanno il seguente aspetto:
ns1.your_domain A 192.0.2.2
ddns.your_domain NS ns1.your_domain
ns1.your_domain AAAA 2001:0db8::0db9 (optional)
Dovresti creare questi record nel pannello di controllo del tuo registrar di domini. Tieni presente che potrebbero essere necessarie fino a 24 ore prima che questi record si propaghino correttamente, ma in genere sono necessari alcuni minuti.
Installazione
Se non stai utilizzando l'utente root, ti consigliamo di avviare una shell di root temporanea, poiché la maggior parte dei comandi mostrati in questa guida richiede privilegi elevati. Per avviare una shell di root, usa uno dei seguenti comandi:
sudo su - root
sudo -s
Passaggio 1:aggiornamento e installazione delle dipendenze.
È sempre buona norma aggiornare prima il sistema:
apt update
apt upgrade -y
reboot
Dopo il riavvio, installa i pacchetti software richiesti per questa configurazione:
- certbot verranno utilizzati per ottenere certificati SSL/TLS.
- fare è necessario per creare l'immagine della finestra mobile in cui verrà eseguito il server DDNS.
- apt-transport-https , certificati ca , arricciare , gnupg2 e proprietà-software-comuni sono necessari per installare il repository Docker e la relativa chiave GPG.
- dnsutils fornisce scavare , che verrà utilizzato per il test.
apt install -y certbot make apt-transport-https curl ca-certificates software-properties-common gnupg2 dnsutils
Passaggio 2:installa Docker CE.
Aggiungi la chiave GPG di Docker:
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -
Installa il repository Docker:
add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/debian buster stable"
Aggiorna la cache del repository di Debian, quindi installa la finestra mobile e le sue dipendenze:
apt update
apt install -y docker-ce docker-ce-cli containerd.io
Una volta completata l'installazione, assicurati che il servizio Docker sia abilitato e in esecuzione come segue:
systemctl enable --now docker.service
Passaggio 3:scarica e crea docker-ddns
Il nostro server DNS dinamico sarà alimentato da un contenitore Docker che utilizza Bind come server DNS e un'API di gestione scritta in Go. Innanzitutto, clona il repository Github e crea l'immagine del contenitore con i seguenti comandi:
git clone https://github.com/dprandzioch/docker-ddns.git
cd docker-ddns
make image
Attendi il completamento del processo, che potrebbe richiedere del tempo, quindi apri il file envfile con un editor di testo:
$EDITOR envfile
E inserisci quanto segue:
SHARED_SECRET=your_secret
ZONE=ddns.your_domain
RECORD_TTL=60
Il segreto condiviso è una password che verrà utilizzata per l'autenticazione con l'API di gestione. ZONE indica la zona DNS di cui sarà responsabile il tuo server e il record TTL specifica per quanto tempo i record DNS possono essere memorizzati nella cache. Si consiglia un TTL di 60 secondi per gli IP dinamici che cambiano frequentemente.
Se necessario, puoi generare una stringa casuale di 40 caratteri per il segreto utilizzando il comando seguente:
cat /dev/urandom | tr -dc "a-zA-Z0-9" | fold -w 40 | head -1
Ora possiamo creare il contenitore:
docker create -it -p 127.0.0.1:8080:8080 -p 53:53 -p 53:53/udp --env-file envfile -v /mnt/ddns-data:/var/cache/bind --name ddns-server davd/docker-ddns
Questo comando creerà un container chiamato ddns-server dall'immagine che abbiamo creato in precedenza e mapperà le porte 8080/tcp, 53/tcp e 53/udp dall'host al container. Inoltre monterà la directory /mnt/ddns-data dall'host, su /var/cache/bind nel filesystem del contenitore. Viene utilizzato per la persistenza dei dati DNS nella ricreazione del container.
Verifica che il contenitore sia stato creato con il comando:
docker container ls -a
Una singola voce dovrebbe essere emessa con il nome ddns-server.
Fase 4:servizio Systemd (opzionale)
Questo passaggio serve per una gestione più semplice ma non è strettamente necessario. Se scegli di non utilizzare un servizio systemd, dovrai gestire il contenitore manualmente o utilizzare un'altra soluzione di gestione. Tieni presente che per distribuzioni di container più grandi e complesse, è consigliata una soluzione di orchestrazione come Kubernetes o Docker Swarm. In questo caso, un servizio systemd è perfetto, poiché stiamo eseguendo un solo container.
Per poter gestire questo contenitore come servizio di sistema, lo avvolgeremo in un'unità systemd. Crea il file /etc/systemd/system/ddns-server-ct.service con il tuo editor di testo:
$EDITOR /etc/systemd/system/ddns-server-ct.service
E aggiungi quanto segue:
[Unit]
Description=DDNS Server Docker Container
After=docker.service
Requires=docker.service
Requires=network.target
[Service]
Type=oneshot
TimeoutStartSec=240
Restart=no
RemainAfterExit=yes
ExecStart=/usr/bin/docker start ddns-server
ExecStop=/usr/bin/docker stop ddns-server
[Install]
WantedBy=multi-user.target
Salva ed esci, quindi imposta le autorizzazioni corrette su questo file di unità:
chmod 664 /etc/systemd/system/ddns-server-ct.service
Carica il nuovo file di servizio con il seguente comando:
systemctl daemon-reload
Ora dovresti essere in grado di avviare e interrompere questo contenitore utilizzando systemctl come qualsiasi altro servizio di sistema.
Se vuoi che il server DDNS si avvii automaticamente all'avvio del sistema, esegui quanto segue:
systemctl enable ddns-server-ct.service
Passaggio 5:testare il tuo server
Prima di procedere con l'installazione, testeremo l'API di gestione in locale. Avvia il contenitore:
systemctl start ddns-server-ct.service
Invia una richiesta GET all'API per creare un nuovo record:
NOTA: L'API è attualmente accessibile solo localmente (cioè da localhost).
curl "http://127.0.0.1:8080/update?secret=your_secret&domain=test1&addr=1.1.1.1"
Curl dovrebbe restituire la seguente risposta:
{"Success":true,"Message":"Updated A record for test1 to IP address 1.1.1.1","Domain":"test1","Domains":["test1"],"Address":"1.1.1.1","AddrType":"A"} NOTA: Il dominio test1 fa riferimento a test1.ddns.your_domain. poiché il server gestisce ddns.your_domain. zona.
Esegui una ricerca DNS per verificare che il record sia stato effettivamente creato e per testare la risoluzione DNS:
dig +short -t A test1.ddns.your_domain @127.0.0.1
L'output dovrebbe essere 1.1.1.1.
Passaggio 6:proxy inverso
Poiché l'API funziona su HTTP, il tuo segreto di autenticazione può essere potenzialmente sniffato ogni volta che invii una richiesta sulla rete. Un utente malintenzionato potrebbe quindi manipolare i tuoi record DNS utilizzando il tuo segreto. Imposteremo un proxy inverso utilizzando Nginx e lo proteggeremo utilizzando HTTPS. Innanzitutto, ottieni un certificato SSL da Let's Encrypt utilizzando certbot:
certbot certonly --standalone --agree-tos -m [email protected] -d ns1.your_domain
La proprietà del tuo dominio verrà verificata e verrà rilasciato un certificato. Quindi, installa Nginx e assicurati che sia abilitato e in esecuzione:
apt install -y nginx systemctl enable --now nginx.service
Quindi disabilita il file di blocco del server predefinito, poiché non è necessario:
unlink /etc/nginx/sites-enabled/default
Creeremo ora un nuovo file di configurazione per il proxy inverso, ad esempio:
$EDITOR /etc/nginx/sites-available/ddns-api-proxy.conf
E incolla quanto segue, assicurandoti di sostituire gli indirizzi IP e i nomi di dominio con i tuoi:
server {
listen 192.0.2.2:8080;
server_name ns1.your_domain;
ssl on;
ssl_certificate /etc/letsencrypt/live/ns1.your_domain/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/ns1.your_domain/privkey.pem;
location /update {
proxy_pass http://127.0.0.1:8080;
}
location / {
return 404;
}
access_log /var/log/nginx/ddns-api-access.log;
error_log /var/log/nginx/ddns-api-error.log;
} Facoltativo: Se desideri che l'API sia accessibile tramite IPv6, aggiungi la seguente riga dopo la direttiva listen esistente:
listen [2001:0db8::0db9]:8080;
Abilita questa configurazione e applica le modifiche ricaricando Nginx:
ln -s /etc/nginx/sites-available/ddns-api-proxy.conf /etc/nginx/sites-enabled/
systemctl reload nginx.service
L'API dovrebbe ora essere accessibile su Internet e accetterà solo connessioni HTTPS. Per testarlo, immetti il comando:
curl "https://ns1.your_domain:8080/update?secret=your_secret&domain=test2&addr=1.1.1.2"
Dovrebbe restituire quanto segue:
{"Success":true,"Message":"Updated A record for test2 to IP address 1.1.1.2","Domain":"test2","Domains":["test2"],"Address":"1.1.1.2","AddrType":"A"} Fase 7:configurazione del client
Puoi impostare aggiornamenti automatici dei record su qualsiasi router che supporti provider DNS dinamici personalizzati, come Pfsense. Puoi anche configurarli sulla maggior parte degli altri dispositivi nel tuo ufficio o nella rete domestica. Per aggiornare o creare un record, è necessario inviare una richiesta GET al seguente endpoint:
https://ns1.your_domain:8080/update?secret=your_secret&domain=your_subdomain&addr=your_ip_address
Puoi anche aggiornare i record di più sottodomini con un'unica richiesta. Ad esempio, per creare/aggiornare record per sub1.ddns.your_domain e sub2.ddns.your_domain con indirizzo IP 198.51.100.100, devi inviare una richiesta GET a questo URL:
https://ns1.your_domain:8080/update?secret=your_secret&domain=sub1,sub2&addr=198.51.100.100
Il parametro addr può anche contenere un indirizzo IPv6 per creare/aggiornare record DNS AAAA, ad esempio:
https://ns1.your_domain:8080/update?secret=your_secret&domain=cheese&addr=2001:0db8:aaaa::
Per automatizzare questi aggiornamenti su un client Linux, salva il seguente script bash come /opt/ddns-update.sh:
#!/bin/bash
while [ -z $CURRENTIP ] do
CURRENTIP=`dig -r +short myip.opendns.com @resolver1.opendns.com 2>/dev/null`
sleep 1
done
curl -s "https://ns1.your_domain:8080/update?secret=your_secret&domain=your_subdomain&addr=${CURRENTIP}"
Questo script utilizza un ciclo while avvolto attorno a un comando dig che ottiene l'indirizzo IP pubblico del client e lo memorizza in una variabile. Il ciclo assicura che l'IP pubblico venga recuperato correttamente. Quindi, cURL viene utilizzato per inviare una richiesta API per aggiornare il record DNS con questo IP appena recuperato. Assicurati di sostituire i valori per tuo_segreto e tuo_sottodominio.
Quindi, rendi questo script eseguibile:
chmod +x /opt/ddns-update.sh
Quindi avvia l'editor crontab:
crontab -e
Aggiungi la seguente riga alla fine del tuo crontab:
*/2 * * * * /opt/ddns-update.sh
Salva ed esci. Lo script verrà ora eseguito ogni due minuti, mantenendo aggiornato il record DNS dinamico con l'ultimo indirizzo IP pubblico del client.
Ulteriori letture
- Articolo Wikipedia sul DNS dinamico
- docker-ddns su Github