Ricerca nel sito web

Come installare PowerDNS e PowerDNS-Admin su Ubuntu 22.04

Questo tutorial esiste per queste versioni del sistema operativo

  • Ubuntu 22.04 (Jammy Jellyfish)
  • Ubuntu 20.04 (Focal Fossa)

Su questa pagina

  1. Prerequisiti
  2. Installa e configura il server MariaDB
  3. Installa PowerDNS
  4. Configura PowerDNS
  5. Installa PowerDNS Admin
    1. Installa le dipendenze richieste

    1. Configura la connessione al database
    2. Abilita l'API di amministrazione PowerDNS

    PowerDNS è un nameserver autorevole gratuito e open source scritto in C++. È multipiattaforma e può essere eseguito su sistemi operativi Unix, Linux e macOS. Supporta diversi database come MySQL, MariaDB, PostgreSQL e Oracle per archiviare file e record di zona.

    PowerDNS Admin è un'applicazione basata sul Web che può essere utilizzata per la gestione di PowerDNS tramite un browser Web. Consente di creare e gestire zone DNS utilizzando l'interfaccia Web PowerDNS. Offre funzionalità molto utili, tra cui supporto IPv4 e IPv6, dominio di massa, supporto DNSSec, AD, LDAP, autenticazione SAML e altro ancora.

    In questo post, spiegheremo come installare PowerDNS e PowerDNS admin sul server Ubuntu 22.04.

    Prerequisiti

    • Un server che esegue Ubuntu 22.04.
    • Un nome di dominio valido indicato con l'IP del tuo server.
    • Sul server è configurata una password di root.

    Installa e configura il server MariaDB

    Innanzitutto, dovrai installare il server del database MariaDB sul tuo sistema.

    apt-get install mariadb-server -y

    Una volta installato MariaDB, sarà necessario creare un database e un utente per PowerDNS.

    Innanzitutto, accedi a MariaDB con il seguente comando:

    mysql

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

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

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

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

    Installa PowerDNS

    Prima di iniziare, dovrai disabilitare il servizio risolto da systemd dal tuo sistema. Puoi disabilitarlo con il seguente comando:

    systemctl disable --now systemd-resolved

    Successivamente, 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

    Successivamente, installa il server PowerDNS con il seguente comando:

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

    Una volta installato PowerDNS, puoi procedere al passaggio successivo.

    Configura PowerDNS

    Innanzitutto, importa lo schema del database PowerDNS nel database PowerDNS con il seguente comando:

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

    Successivamente, sarà necessario creare un file di configurazione PowerDNS e definire i dettagli della connessione al database PowerDNS:

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

    Aggiungi 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 imposta i permessi appropriati per il file pdns.local.gmysql.conf:

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

    Quindi, arrestare il server PowerDNS e testare 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:

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

    Successivamente, avvia il server PowerDNS con il seguente comando:

    systemctl start pdns

    Ora puoi controllare lo stato del PowerDNS usando il seguente comando:

    systemctl status pdns

    Dovresti vedere il seguente output:

    ? pdns.service - PowerDNS Authoritative Server
     Loaded: loaded (/lib/systemd/system/pdns.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2022-08-06 10:37:28 UTC; 8s ago
       Docs: man:pdns_server(1)
             man:pdns_control(1)
             https://doc.powerdns.com
   Main PID: 93982 (pdns_server)
      Tasks: 8 (limit: 2242)
     Memory: 43.1M
        CPU: 166ms
     CGroup: /system.slice/pdns.service
             ??93982 /usr/sbin/pdns_server --guardian=no --daemon=no --disable-syslog --log-timestamp=no --write-pid=no

Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: UDP server bound to [::]:53
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: TCP server bound to 0.0.0.0:53
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: TCP server bound to [::]:53
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: PowerDNS Authoritative Server 4.5.3 (C) 2001-2021 PowerDNS.COM BV
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: Using 64-bits mode. Built using gcc 11.2.0.
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: PowerDNS comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to redi>
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: Creating backend connection for TCP
Aug 06 10:37:28 ubuntu2204 systemd[1]: Started PowerDNS Authoritative Server.
Aug 06 10:37:28 ubuntu2204 pdns_server[93982]: About to create 3 backend threads for UDP
Aug 06 10:37:29 ubuntu2204 pdns_server[93982]: Done launching threads, ready to distribute questions

    A questo punto, PowerDNS è avviato e 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=93982,fd=5))
tcp   LISTEN 0      128           0.0.0.0:53         0.0.0.0:*    users:(("pdns_server",pid=93982,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 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_16.x | bash -

    Successivamente, 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

    Successivamente, 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 Amministrazione PowerDNS

    Successivamente, 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

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

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

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

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

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

    deactivate

    Configura la 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 modifica la directory in pdns e attiva l'ambiente virtuale:

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

    Successivamente, aggiorna il database con il seguente comando:

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

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

    deactivate

    Abilita l'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 della chiave 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 come proxy inverso per l'amministratore PowerDNS

    Successivamente, dovrai configurare Nginx come proxy inverso per l'amministratore 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

    Successivamente, modifica la proprietà del 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 PowerDNS Admin

    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 pdnsadmin sockt 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/

    Successivamente, ricarica il demone systemd con il seguente comando:

    systemctl daemon-reload

    Successivamente, abilitare il servizio pdnsadmin per l'avvio al riavvio del sistema con il seguente comando:

    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 Sat 2022-08-06 10:52:44 UTC; 9s ago
TriggeredBy: ? pdnsadmin.socket
   Main PID: 98696 (gunicorn)
      Tasks: 2 (limit: 2242)
     Memory: 63.1M
        CPU: 913ms
     CGroup: /system.slice/pdnsadmin.service
             ??98696 /var/www/html/pdns/flask/bin/python /var/www/html/pdns/flask/bin/gunicorn --pid /run/pdnsadmin/pid --bind unix:/run/pdns>
             ??98697 /var/www/html/pdns/flask/bin/python /var/www/html/pdns/flask/bin/gunicorn --pid /run/pdnsadmin/pid --bind unix:/run/pdns>

Aug 06 10:52:44 ubuntu2204 systemd[1]: Started PowerDNS-Admin.
Aug 06 10:52:44 ubuntu2204 gunicorn[98696]: [2022-08-06 10:52:44 +0000] [98696] [INFO] Starting gunicorn 20.0.4
Aug 06 10:52:44 ubuntu2204 gunicorn[98696]: [2022-08-06 10:52:44 +0000] [98696] [INFO] Listening at: unix:/run/pdnsadmin/socket (98696)
Aug 06 10:52:44 ubuntu2204 gunicorn[98696]: [2022-08-06 10:52:44 +0000] [98696] [INFO] Using worker: sync
Aug 06 10:52:44 ubuntu2204 gunicorn[98697]: [2022-08-06 10:52:44 +0000] [98697] [INFO] Booting worker with pid: 98697

? pdnsadmin.socket - PowerDNS-Admin socket
     Loaded: loaded (/etc/systemd/system/pdnsadmin.socket; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2022-08-06 10:52:44 UTC; 9s ago
   Triggers: ? pdnsadmin.service
     Listen: /run/pdnsadmin/socket (Stream)
     CGroup: /system.slice/pdnsadmin.socket

Aug 06 10:52:44 ubuntu2204 systemd[1]: Listening on PowerDNS-Admin socket.

    Accedi all'amministrazione PowerDNS

    È ora possibile aprire il browser Web e accedere all'interfaccia Web di amministrazione di PowerDNS utilizzando l'URL http://pdnsadmin.example.com. Verrai reindirizzato alla seguente pagina:

    Fare clic sul pulsante Crea un account. Dovresti vedere la seguente schermata:

    Fornisci i dettagli dell'utente amministratore e fai clic sul pulsante Registrati per creare un account. Dovresti vedere l'interfaccia web di amministrazione di PowerDNS nella schermata seguente:

    Fornire l'URL dell'API PowerDNS per connettersi a PowerDNS e gestirlo. Quindi, fai clic sul pulsante Aggiorna per salvare le modifiche. Dovresti vedere la seguente pagina:

    Fare clic sul pulsante Dashboard. Dovresti vedere la dashboard di amministrazione di PowerDNS nella schermata seguente:

    Conclusione

    Congratulazioni! hai installato e configurato correttamente PowerDNS e PowerDNS admin con Nginx sul server Ubuntu 22.04. Ora puoi creare zone e aggiungere record tramite l'interfaccia web di amministrazione di PowerDNS, quindi testarla. Non esitate a chiedermi se avete domande