Come installare il server PowerDNS e l'amministratore PowerDNS su Ubuntu 20.04

PowerDNS è un server dei nomi autorevole gratuito e open source. È scritto in C++ e funziona su sistemi operativi Unix, Linux e macOS. Utilizza MySQL, MariaDB, PostgreSQL e Oracle per archiviare file e record di zona.

PowerDNS Admin è uno strumento basato sul Web utilizzato per la gestione di PowerDNS. È possibile creare e gestire zone DNS utilizzando il browser web. Viene fornito con un ricco set di funzionalità. Alcuni di essi sono elencati di seguito:

• Supporto IPv4 e IPv6
• Pagina di stato che mostra informazioni utili
• Crea/aggiorna automaticamente i record PTR inverso
• Supporto per la creazione di domini in blocco
• Supporto per i modelli di dominio
• Supporto DNSSec
• Supporta l'autenticazione utente DB locale, SAML, LDAP e Active Directory

In questo tutorial, ti mostreremo come installare PowerDNS e l'amministratore PowerDNS sul server Ubuntu 20.04.

Prerequisiti

• Un server che esegue Ubuntu 20.04.
• Un nome di dominio valido puntato all'IP del tuo server.
• Una password di root è configurata sul server.

Installa e configura il server MariaDB

Prima di iniziare, dovrai installare il server del database MariaDB nel tuo sistema. Per impostazione predefinita, l'ultima versione di MariaDB non è disponibile nel repository predefinito di Ubuntu 20.04. Quindi dovrai aggiungere il repository MariaDB al tuo sistema.

Innanzitutto, installa i pacchetti richiesti con il seguente comando:

apt-get install software-properties-common gnupg2 -y

Una volta installati tutti i pacchetti, aggiungi la chiave di firma MariaDB con il seguente comando:

apt-key adv --fetch-keys 'https://mariadb.org/mariadb_release_signing_key.asc'

Quindi, aggiungi il repository MariaDB con il seguente comando:

add-apt-repository 'deb [arch=amd64,arm64,ppc64el] http://mirrors.ukfast.co.uk/sites/mariadb/repo/10.5/ubuntu focal main'

Quindi, installa il server MariaDB eseguendo il seguente comando:

apt-get install mariadb-server -y

Una volta installato, dovrai creare un database e un utente per PowerDNS.

Innanzitutto, accedi a MariaDB con il seguente comando:

mysql

Una volta effettuato l'accesso, crea un database e un utente con il seguente comando:

MariaDB [(none)]> create database pdns;
MariaDB [(none)]> grant all on pdns.* to [email protected] identified by 'password';

Quindi, svuota i privilegi ed esci dalla shell MariaDB con il seguente comando:

MariaDB [(none)]> flush privileges;
MariaDB [(none)]> exit;

Installa PowerDNS

Innanzitutto, dovrai disabilitare il servizio risolto dal sistema dal tuo sistema. Puoi disabilitarlo con il seguente comando:

systemctl disable --now systemd-resolved

Quindi, rimuovi il file resolv.conf predefinito e crea un nuovo file:

rm -rf /etc/resolv.conf
echo "nameserver 8.8.8.8" > /etc/resolv.conf

Quindi, installa il server PowerDNS con il seguente comando:

apt-get install pdns-server pdns-backend-mysql -y

Una volta installato il PowerDNS, puoi procedere al passaggio successivo.

Configura PowerDNS

Innanzitutto, dovrai importare lo schema del database PowerDNS nel database PowerDNS. Puoi importarlo con il seguente comando:

mysql -u pdnsadmin -p pdns < /usr/share/pdns-backend-mysql/schema/schema.mysql.sql

Successivamente, sarà necessario definire i dettagli della connessione al database PowerDNS. Puoi farlo modificando il file pdns.local.gmysql.conf:

nano /etc/powerdns/pdns.d/pdns.local.gmysql.conf

Modifica le seguenti righe:

# MySQL Configuration
#
# Launch gmysql backend
launch+=gmysql

# gmysql parameters
gmysql-host=127.0.0.1
gmysql-port=3306
gmysql-dbname=pdns
gmysql-user=pdnsadmin
gmysql-password=password
gmysql-dnssec=yes
# gmysql-socket=

Salva e chiudi il file, quindi dai il permesso appropriato al file pdns.local.gmysql.conf:

chmod 640 /etc/powerdns/pdns.d/pdns.local.gmysql.conf

Quindi, arresta il server PowerDNS e verifica il PowerDNS con il seguente comando:

systemctl stop pdns
pdns_server --daemon=no --guardian=no --loglevel=9

Se tutto va bene, dovresti ottenere il seguente output:

Nov 02 10:43:47 gmysql Connection successful. Connected to database 'pdns' on '127.0.0.1'.
Nov 02 10:43:47 gmysql Connection successful. Connected to database 'pdns' on '127.0.0.1'.
Nov 02 10:43:47 gmysql Connection successful. Connected to database 'pdns' on '127.0.0.1'.
Nov 02 10:43:47 Done launching threads, ready to distribute questions

Quindi, avvia il server PowerDNS con il seguente comando:

systemctl start pdns

A questo punto PowerDNS è avviato ed è in ascolto sulla porta 53. Puoi verificarlo con il seguente comando:

ss -alnp4 | grep pdns

Dovresti ottenere il seguente output:

udp     UNCONN   0        0                0.0.0.0:53             0.0.0.0:*      users:(("pdns_server",pid=33140,fd=5))                                         
tcp     LISTEN   0        128              0.0.0.0:53             0.0.0.0:*      users:(("pdns_server",pid=33140,fd=7))                                         

Installa l'amministratore PowerDNS

In questa sezione, ti mostreremo come installare l'amministratore PowerDNS con Nginx.

Installa le dipendenze richieste

Innanzitutto, installa tutte le dipendenze richieste per l'amministratore di PowerDNS con il seguente comando:

apt-get install nginx python3-dev libsasl2-dev libldap2-dev libssl-dev libxml2-dev libxslt1-dev libxmlsec1-dev libffi-dev pkg-config apt-transport-https virtualenv build-essential libmariadb-dev git python3-flask -y

Una volta installate tutte le dipendenze, aggiungi il repository Node.js con il seguente comando:

curl -sL https://deb.nodesource.com/setup_14.x | bash -

Quindi, installa Node.js con il seguente comando:

apt-get install nodejs -y

Successivamente, aggiungi il repository di filati con il seguente comando:

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list

Quindi, aggiorna il repository e installa Yarn con il seguente comando:

apt-get update -y
apt-get install yarn -y

A questo punto, tutte le dipendenze richieste sono installate, ora puoi procedere al passaggio successivo.

Scarica PowerDNS Admin

Quindi, scarica l'ultima versione di PowerDNS admin dal repository Git nella directory principale di Nginx:

git clone https://github.com/ngoduykhanh/PowerDNS-Admin.git /var/www/html/pdns

Quindi, cambia la directory nella directory scaricata e crea un ambiente virtuale Python con il seguente comando:

cd /var/www/html/pdns/
virtualenv -p python3 flask

Quindi, attiva l'ambiente virtuale e installa tutte le dipendenze Python con il seguente comando:

source ./flask/bin/activate
pip install -r requirements.txt

Successivamente, disattiva dall'ambiente virtuale con il seguente comando:

deactivate

Definisci connessione al database

Successivamente, dovrai definire i dettagli della connessione al database PowerDNS nel file default_config.py:

nano /var/www/html/pdns/powerdnsadmin/default_config.py

Modifica le seguenti righe:

SALT = 'yoursecretekey'
SECRET_KEY = 'yoursecretekey'
BIND_ADDRESS = '0.0.0.0'
PORT = 9191
HSTS_ENABLED = False
OFFLINE_MODE = False

SQLA_DB_USER = 'pdnsadmin'
SQLA_DB_PASSWORD = 'password'
SQLA_DB_HOST = '127.0.0.1'
SQLA_DB_NAME = 'pdns'
SQLALCHEMY_TRACK_MODIFICATIONS = True

Salva e chiudi il file, quindi cambia la directory in pdns e attiva l'ambiente virtuale:

cd /var/www/html/pdns/
source ./flask/bin/activate

Quindi, aggiorna il database con il seguente comando:

export FLASK_APP=powerdnsadmin/__init__.py
flask db upgrade
yarn install --pure-lockfile
flask assets build

Successivamente, disattiva l'ambiente virtuale con il seguente comando:

deactivate

Abilita API di amministrazione PowerDNS

L'amministratore di PowerDNS utilizza l'API JSON per leggere le statistiche e modificare il contenuto della zona, i metadati e il materiale delle chiavi DNSSEC. Puoi abilitarlo modificando il file pdns.conf:

nano /etc/powerdns/pdns.conf

Modifica le seguenti righe:

api=yes
api-key=yoursecretekey

Salva e chiudi il file, quindi riavvia il servizio PowerDNS per applicare le modifiche:

systemctl restart pdns

Configura Nginx per PowerDNS Admin

Successivamente, dovrai configurare l'amministratore Nginx per PowerDNS. Per fare ciò, crea un file di configurazione dell'host virtuale Nginx con il seguente comando:

nano /etc/nginx/conf.d/pdns-admin.conf

Aggiungi le seguenti righe:

server {
  listen	*:80;
  server_name               pdnsadmin.example.com;

  index                     index.html index.htm index.php;
  root                      /var/www/html/pdns;
  access_log                /var/log/nginx/pdnsadmin_access.log combined;
  error_log                 /var/log/nginx/pdnsadmin_error.log;

  client_max_body_size              10m;
  client_body_buffer_size           128k;
  proxy_redirect                    off;
  proxy_connect_timeout             90;
  proxy_send_timeout                90;
  proxy_read_timeout                90;
  proxy_buffers                     32 4k;
  proxy_buffer_size                 8k;
  proxy_set_header                  Host $host;
  proxy_set_header                  X-Real-IP $remote_addr;
  proxy_set_header                  X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_headers_hash_bucket_size    64;

  location ~ ^/static/  {
    include  /etc/nginx/mime.types;
    root /var/www/html/pdns/powerdnsadmin;

    location ~*  \.(jpg|jpeg|png|gif)$ {
      expires 365d;
    }

    location ~* ^.+.(css|js)$ {
      expires 7d;
    }
  }

  location / {
    proxy_pass            http://unix:/run/pdnsadmin/socket;
    proxy_read_timeout    120;
    proxy_connect_timeout 120;
    proxy_redirect        off;
  }

}

Salva e chiudi il file, quindi controlla Nginx per eventuali errori di sintassi con il seguente comando:

nginx -t

Dovresti ottenere il seguente output:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Quindi, cambia la proprietà dei pdns in www-data:

chown -R www-data:www-data /var/www/html/pdns

Infine, riavvia il servizio Nginx per applicare le modifiche:

systemctl restart nginx

Crea un file di servizio Systemd per l'amministratore PowerDNS

Successivamente, dovrai creare un file di servizio systemd per gestire il servizio PowerDNS.

Innanzitutto, crea un file di servizio pdns con il seguente comando:

nano /etc/systemd/system/pdnsadmin.service

Aggiungi le seguenti righe:

[Unit]
Description=PowerDNS-Admin
Requires=pdnsadmin.socket
After=network.target

[Service]
PIDFile=/run/pdnsadmin/pid
User=pdns
Group=pdns
WorkingDirectory=/var/www/html/pdns
ExecStart=/var/www/html/pdns/flask/bin/gunicorn --pid /run/pdnsadmin/pid --bind unix:/run/pdnsadmin/socket 'powerdnsadmin:create_app()'
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

Salva e chiudi il file, quindi crea un file sockt pdnsadmin con il seguente comando:

nano /etc/systemd/system/pdnsadmin.socket

Aggiungi le seguenti righe:

[Unit]
Description=PowerDNS-Admin socket

[Socket]
ListenStream=/run/pdnsadmin/socket

[Install]
WantedBy=sockets.target

Salva e chiudi il file, quindi crea i file e le directory richiesti con il seguente comando:

echo "d /run/pdnsadmin 0755 pdns pdns -" >> /etc/tmpfiles.d/pdnsadmin.conf
mkdir /run/pdnsadmin/
chown -R pdns: /run/pdnsadmin/
chown -R pdns: /var/www/html/pdns/powerdnsadmin/

Quindi, ricarica il demone systemd con il seguente comando:

systemctl daemon-reload

Quindi, abilita l'avvio del servizio pdnsadmin al riavvio del sistema con il comando seguente:

systemctl enable --now pdnsadmin.service pdnsadmin.socket

Successivamente, verifica lo stato di entrambi i servizi utilizzando il seguente comando:

systemctl status pdnsadmin.service pdnsadmin.socket

Dovresti ottenere il seguente output:

? pdnsadmin.service - PowerDNS-Admin
     Loaded: loaded (/etc/systemd/system/pdnsadmin.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2020-11-02 10:54:19 UTC; 5s ago
TriggeredBy: ? pdnsadmin.socket
   Main PID: 38881 (gunicorn)
      Tasks: 2 (limit: 2353)
     Memory: 62.5M
     CGroup: /system.slice/pdnsadmin.service
             ??38881 /var/www/html/pdns/flask/bin/python /var/www/html/pdns/flask/bin/gunicorn --pid /run/pdnsadmin/pid --bind unix:/run/pdnsa>
             ??38898 /var/www/html/pdns/flask/bin/python /var/www/html/pdns/flask/bin/gunicorn --pid /run/pdnsadmin/pid --bind unix:/run/pdnsa>

Nov 02 10:54:19 pdnsadmin.example.com systemd[1]: Started PowerDNS-Admin.
Nov 02 10:54:19 pdnsadmin.example.com gunicorn[38881]: [2020-11-02 10:54:19 +0000] [38881] [INFO] Starting gunicorn 20.0.4
Nov 02 10:54:19 pdnsadmin.example.com gunicorn[38881]: [2020-11-02 10:54:19 +0000] [38881] [INFO] Listening at: unix:/run/pdnsadmin/socket (38881)
Nov 02 10:54:19 pdnsadmin.example.com gunicorn[38881]: [2020-11-02 10:54:19 +0000] [38881] [INFO] Using worker: sync
Nov 02 10:54:19 pdnsadmin.example.com gunicorn[38898]: [2020-11-02 10:54:19 +0000] [38898] [INFO] Booting worker with pid: 38898

? pdnsadmin.socket - PowerDNS-Admin socket
     Loaded: loaded (/etc/systemd/system/pdnsadmin.socket; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2020-11-02 10:54:19 UTC; 5s ago
   Triggers: ? pdnsadmin.service
     Listen: /run/pdnsadmin/socket (Stream)
     CGroup: /system.slice/pdnsadmin.socket

Nov 02 10:54:19 pdnsadmin.example.com systemd[1]: Listening on PowerDNS-Admin socket.

Accedi all'interfaccia utente Web di amministrazione di PowerDNS

Ora apri il tuo browser web e accedi all'interfaccia web di amministrazione di PowerDNS utilizzando l'URL http://pdnsadmin.example.com . Verrai reindirizzato alla seguente pagina:

Fai clic su Crea un account pulsante. Dovresti vedere la seguente schermata:

Fornisci i dettagli dell'utente amministratore e fai clic su Registrati pulsante per creare un account. Dovresti vedere la pagina di accesso dell'amministratore PowerDNS nella schermata seguente:

Fornisci il nome utente e la password dell'amministratore e fai clic su Accedi pulsante. Dovresti vedere l'interfaccia web di amministrazione di PowerDNS nella pagina seguente:

Qui, fornisci l'URL dell'API PowerDNS per connetterti a PowerDNS e gestirlo. Quindi, fai clic su Aggiorna pulsante per salvare le modifiche. Dovresti vedere la seguente pagina:

Fai clic sulla Dashboard pulsante. Dovresti vedere la dashboard dell'amministratore di PowerDNS nella schermata seguente:

Conclusione

Congratulazioni! hai installato e configurato correttamente l'amministratore PowerDNS e PowerDNS sul server Ubuntu 20.04. Ora puoi creare zone e aggiungere record tramite l'interfaccia Web di amministrazione di PowerDNS.