Installa PowerDNS su Ubuntu 18.04, 20.04 e 22.04

Introduzione

PowerDNS è una soluzione server DNS open source che aiuta a risolvere gli spazi dei nomi. PowerDNS supporta alta disponibilità, ridondanza dei dati e vari back-end, il che lo rende una soluzione flessibile e robusta.

Questa guida mostra come installare PowerDNS e l'interfaccia di amministrazione di PowerDNS su Ubuntu.

Prerequisiti

• Accesso al terminale.
• Accesso all'utente root.
• Un editor di testo, come nano.
• Un browser web per accedere a PowerDNS Admin.

Perché usare PowerDNS?

PowerDNS fornisce due soluzioni di server dei nomi:

• Il server autorevole , che utilizza il database per risolvere le query sui domini.
• Il ricorrente , che si consulta con altri server autorevoli per risolvere le query.

Altri nameserver combinano automaticamente le due funzioni. PowerDNS li offre separatamente e consente di combinare perfettamente le due soluzioni per una configurazione modulare.

Inoltre, PowerDNS è open source, funziona ugualmente bene per volumi di query piccoli e grandi e offre molte possibilità per soluzioni di back-end.

Installazione di PowerDNS su Ubuntu 18.04, 20.04 e 22.04

Segui i passaggi seguenti per installare e configurare PowerDNS con il server MariaDB come database back-end. Inoltre, i passaggi guidano gli utenti nella configurazione dell'interfaccia Web e dell'API di amministrazione PowerDNS.

Fase 1:installa e configura il server MariaDB

Per installare e configurare MariaDB, procedi come segue:

1. Aggiorna e aggiorna i pacchetti di sistema:

sudo apt update && sudo apt upgrade

2. Installa il server e il client MariaDB con:

sudo apt install mariadb-server mariadb-client

Nota: Altri possibili server di database includono PostgreSQL, MySQL e altri database relazionali.

Attendi il completamento dell'installazione prima di continuare.

3. Collegati a MariaDB con:

sudo mysql

Il terminale si connette a una sessione di database.

4. Creare un database per il server dei nomi PowerDNS:

create database pda;

Nota: Se si utilizza un nome di database diverso, modificare di conseguenza tutti i comandi conseguenti.

5. Concedi tutti i privilegi al pda utente e fornire la password utente:

grant all privileges on pda.* TO 'pda'@'localhost' identified by 'YOUR_PASSWORD_HERE';
flush privileges;

6. Connettiti al database:

use pda;

7. Utilizzare le seguenti query SQL per creare tabelle per il pda banca dati:

CREATE TABLE domains (
  id                    INT AUTO_INCREMENT,
  name                  VARCHAR(255) NOT NULL,
  master                VARCHAR(128) DEFAULT NULL,
  last_check            INT DEFAULT NULL,
  type                  VARCHAR(6) NOT NULL,
  notified_serial       INT UNSIGNED DEFAULT NULL,
  account               VARCHAR(40) CHARACTER SET 'utf8' DEFAULT NULL,
  PRIMARY KEY (id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE UNIQUE INDEX name_index ON domains(name);


CREATE TABLE records (
  id                    BIGINT AUTO_INCREMENT,
  domain_id             INT DEFAULT NULL,
  name                  VARCHAR(255) DEFAULT NULL,
  type                  VARCHAR(10) DEFAULT NULL,
  content               VARCHAR(64000) DEFAULT NULL,
  ttl                   INT DEFAULT NULL,
  prio                  INT DEFAULT NULL,
  change_date           INT DEFAULT NULL,
  disabled              TINYINT(1) DEFAULT 0,
  ordername             VARCHAR(255) BINARY DEFAULT NULL,
  auth                  TINYINT(1) DEFAULT 1,
  PRIMARY KEY (id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE INDEX nametype_index ON records(name,type);
CREATE INDEX domain_id ON records(domain_id);
CREATE INDEX ordername ON records (ordername);


CREATE TABLE supermasters (
  ip                    VARCHAR(64) NOT NULL,
  nameserver            VARCHAR(255) NOT NULL,
  account               VARCHAR(40) CHARACTER SET 'utf8' NOT NULL,
  PRIMARY KEY (ip, nameserver)
) Engine=InnoDB CHARACTER SET 'latin1';


CREATE TABLE comments (
  id                    INT AUTO_INCREMENT,
  domain_id             INT NOT NULL,
  name                  VARCHAR(255) NOT NULL,
  type                  VARCHAR(10) NOT NULL,
  modified_at           INT NOT NULL,
  account               VARCHAR(40) CHARACTER SET 'utf8' DEFAULT NULL,
  comment               TEXT CHARACTER SET 'utf8' NOT NULL,
  PRIMARY KEY (id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE INDEX comments_name_type_idx ON comments (name, type);
CREATE INDEX comments_order_idx ON comments (domain_id, modified_at);


CREATE TABLE domainmetadata (
  id                    INT AUTO_INCREMENT,
  domain_id             INT NOT NULL,
  kind                  VARCHAR(32),
  content               TEXT,
  PRIMARY KEY (id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE INDEX domainmetadata_idx ON domainmetadata (domain_id, kind);


CREATE TABLE cryptokeys (
  id                    INT AUTO_INCREMENT,
  domain_id             INT NOT NULL,
  flags                 INT NOT NULL,
  active                BOOL,
  content               TEXT,
  PRIMARY KEY(id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE INDEX domainidindex ON cryptokeys(domain_id);


CREATE TABLE tsigkeys (
  id                    INT AUTO_INCREMENT,
  name                  VARCHAR(255),
  algorithm             VARCHAR(50),
  secret                VARCHAR(255),
  PRIMARY KEY (id)
) Engine=InnoDB CHARACTER SET 'latin1';

CREATE UNIQUE INDEX namealgoindex ON tsigkeys(name, algorithm);

8. Conferma che le tabelle sono state create con:

show tables;

L'output elenca le tabelle disponibili.

9. Uscire dalla connessione al database:

exit;

Il comando restituisce la sessione al terminale.

Fase 2:installa PowerDNS

Per installare PowerDNS su Ubuntu, procedi come segue:

1. Passa all'utente root:

sudo su -

La sessione del terminale cambia nell'utente root.

Nota: Scopri la differenza tra sudo e su.

2. Il systemd-resolved il servizio fornisce le risoluzioni dei nomi alle applicazioni locali. PowerDNS utilizza il proprio servizio per la risoluzione dei nomi.

Disattiva il systemd-resolved servizio con:

systemctl disable --now systemd-resolved

L'output conferma la rimozione del servizio.

3. Eliminare il file di configurazione del servizio di sistema con:

rm -rf /etc/resolv.conf

4. Crea il nuovo resolv.conf file:

echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

L'aggiunta del server dei nomi di Google garantisce la risoluzione DNS.

5. Installa il server PowerDNS ei pacchetti back-end del database con:

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

Attendi il completamento dell'installazione prima di continuare.

Fase 3:Configura PowerDNS

Configura il file PowerDNS locale per la connessione al database:

1. Apri il file di configurazione per la modifica:

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

2. Aggiungi le seguenti informazioni al file:

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

# gmysql parameters
gmysql-host=127.0.0.1
gmysql-port=3306
gmysql-dbname=pda
gmysql-user=pda
gmysql-password=YOUR_PASSWORD_HERE
gmysql-dnssec=yes
# gmysql-socket=

Scambiare il nome del database, l'utente e la password con i parametri corretti se si utilizzano parametri diversi. Salva e chiudi il file.

3. Modifica i permessi del file:

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

4. Interrompi il pdns servizio:

systemctl stop pdns

5. Testare la connessione al database:

pdns_server --daemon=no --guardian=no --loglevel=9

L'output mostra una connessione riuscita. Premi CTRL +C per uscire dal test.

6. Avvia il servizio:

systemctl start pdns

7. Verifica la connessione con il comando ss:

ss -alnp4 | grep pdns

Verifica la porta TCP/UDP 53 è aperto e in LISTEN /UCONN stato.

Passaggio 4:installa le dipendenze di amministrazione di PowerDNS

L'amministratore PowerDNS aiuta a gestire PowerDNS tramite un'interfaccia web. Per installare la dashboard in locale, procedi come segue:

1. Installa il pacchetto di sviluppo Python:

apt install python3-dev

2. Installa le dipendenze:

apt install -y git libmysqlclient-dev libsasl2-dev libldap2-dev libssl-dev libxml2-dev libxslt1-dev libxmlsec1-dev libffi-dev pkg-config apt-transport-https python3-venv build-essential curl

3. Recupera la configurazione di Node.js:

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

4. Installa Node.js con:

apt install -y nodejs

5. Quindi, installa il gestore di pacchetti di filati. Recupera la chiave pubblica Yarn e aggiungila ad apt :

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -

Yarn aiuta a creare i file delle risorse.

6. Aggiungi Filato all'elenco delle fonti:

echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list

7. Aggiorna l'elenco delle fonti apt:

apt update -y

8. Installa il filato con:

apt install yarn -y

9. Clona il repository Git di PowerDNS Admin su /opt/web/powerdns-admin :

git clone https://github.com/ngoduykhanh/PowerDNS-Admin.git /opt/web/powerdns-admin

Se si utilizza una directory diversa, scambiare la directory di destinazione nel comando e in tutti gli aspetti successivi.

10. Passare alla directory Git clonata:

cd /opt/web/powerdns-admin

11. Crea un ambiente virtuale Python:

python3 -mvenv ./venv

12. Attiva l'ambiente virtuale con:

source ./venv/bin/activate

13. Aggiorna pip all'ultima versione:

pip install --upgrade pip

Il gestore di pacchetti pip aiuta a installare requisiti Python aggiuntivi.

14. Installa i requisiti da requirements.txt file:

pip install -r requirements.txt

Dopo aver installato tutti i requisiti, l'amministratore PowerDNS richiede una configurazione aggiuntiva prima dell'esecuzione.

Fase 5:Configura ed esegui l'amministratore PowerDNS

Per configurare e avviare PowerDNS Admin su un'istanza locale, procedi come segue:

1. Usa il comando cp per copiare l'esempio development.py File Python su production.py :

cp /opt/web/powerdns-admin/configs/development.py /opt/web/powerdns-admin/configs/production.py

2. Apri production.py file da modificare:

nano /opt/web/powerdns-admin/configs/production.py

3. Modifica le seguenti righe:

#import urllib.parse

SECRET_KEY = 'e951e5a1f4b94151b360f47edf596dd2'

SQLA_DB_PASSWORD = 'changeme'

4. Decommentare l'importazione della libreria, fornire una chiave segreta generata casualmente e fornire la password del database corretta.

import urllib.parse

SECRET_KEY = '\x19\xc7\xd8\xa7$\xb6P*\xc6\xb8\xa1E\x90P\x12\x95'

SQLA_DB_PASSWORD = 'YOUR_PASSWORD_HERE'

Nota: Genera una chiave casuale usando Python:

python3 -c "import os; print(os.urandom(16))"

Copia e incolla l'output nel SECRET_KEY valore.

Salva e chiudi il file.

5. Esporta la variabile di configurazione dell'app di produzione:

export FLASK_CONF=../configs/production.py

6. Esporta la variabile dell'applicazione del pallone:

export FLASK_APP=powerdnsadmin/__init__.py

7. Aggiorna lo schema del database:

flask db upgrade

8. Installa le dipendenze del progetto:

yarn install --pure-lockfile

9. Crea risorse app flask:

flask assets build

Attendi il completamento della compilazione.

10. Eseguire l'applicazione con:

./run.py

Lascia l'applicazione in esecuzione.

11. L'applicazione è attualmente in esecuzione su localhost sulla porta 9191 . Visita il seguente indirizzo:

http://localhost:9191

Viene visualizzata la schermata di accesso per PowerDNS Admin. Attualmente non ci sono utenti e il primo utente che registri sarà l'account amministratore.

12. Nel terminale, uscire dall'ambiente virtuale e disconnettersi dall'utente root con:

exit

Il terminale torna a uno stato normale.

Passaggio 6:crea il servizio di amministrazione PowerDNS

Configura PowerDNS Admin per l'esecuzione all'avvio:

1. Crea un file di servizio systemd per PowerDNS Admin:

sudo nano /etc/systemd/system/powerdns-admin.service

2. Aggiungi i seguenti contenuti:

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

[Service]
User=root
Group=root
PIDFile=/run/powerdns-admin/pid
WorkingDirectory=/opt/web/powerdns-admin
ExecStartPre=/bin/bash -c '$$(mkdir -p /run/powerdns-admin/)'
ExecStart=/opt/web/powerdns-admin/venv/bin/gunicorn --pid /run/powerdns-admin/pid --bind unix:/run/powerdns-admin/socket 'powerdnsadmin:create_app()'
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

3. Crea un file di unità:

sudo systemctl edit --force powerdns-admin.service

4. Aggiungi quanto segue:

[Service]
Environment="FLASK_CONF=../configs/production.py"

5. Crea un file socket:

sudo nano /etc/systemd/system/powerdns-admin.socket

6. Inserisci le seguenti informazioni:

[Unit]
Description=PowerDNS-Admin socket

[Socket]
ListenStream=/run/powerdns-admin/socket

[Install]
WantedBy=sockets.target

7. Crea un file di ambiente:

sudo nano /etc/tmpfiles.d/powerdns-admin.conf

8. Aggiungi le seguenti informazioni:

d /run/powerdns-admin 0755 pdns pdns -

9. Ricarica il demone:

sudo systemctl daemon-reload

10. Avvia e abilita il servizio e il socket:

sudo systemctl start powerdns-admin.service powerdns-admin.socket

sudo systemctl enable powerdns-admin.service powerdns-admin.socket

11. Verifica lo stato con:

sudo systemctl status powerdns-admin.service powerdns-admin.socket

I servizi vengono visualizzati come in esecuzione senza errori.

Fase 7:installa e configura Nginx

Per configurare PowerDNS Admin per l'esecuzione su Nginx, procedi come segue:

1. Installa Nginx con:

sudo apt install nginx -y

2. Modifica il file di configurazione di Nginx:

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

3. Aggiungi le seguenti informazioni:

server {
  listen *:80;
  server_name               localhost;

  index                     index.html index.htm index.php;
  root                      /opt/web/powerdns-admin;
  access_log                /var/log/nginx/powerdns-admin.local.access.log combined;
  error_log                 /var/log/nginx/powerdns-admin.local.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 /opt/web/powerdns-admin/powerdnsadmin;

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

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

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

}

Se utilizzi un nome server diverso, cambia localhost all'indirizzo del tuo server.

4. Conferma che il file non contiene errori di sintassi:

nginx -t

5. Modifica la proprietà di powerdns-admin a www-data :

sudo chown -R www-data:www-data /opt/web/powerdns-admin

6. Riavvia il servizio Nginx:

sudo systemctl restart nginx

7. Accedi alla pagina di amministrazione di PowerDNS tramite il browser:

localhost

Se si esegue il collegamento a un indirizzo diverso, utilizzare l'indirizzo fornito nel file di configurazione di Nginx.

Fase 8:Configura l'API PowerDNS

Per configurare l'API PowerDNS, procedi come segue:

1. Accedere a PowerDNS Admin tramite il browser. Se si esegue per la prima volta, creare prima un nuovo utente. Il primo utente è automaticamente l'amministratore.

2. Apri la Chiave API s scheda nel menu a sinistra.

3. Fare clic su Aggiungi chiave+ pulsante.

4. Il ruolo il campo predefinito è Amministratore utente. Aggiungi una descrizione facoltativa per la chiave.

5. Fare clic su Crea chiave per generare una chiave API.

6. Una finestra popup stampa la chiave. Copia la chiave e premi Conferma per continuare.

7. Vai alla Dashboard pagina.

8. Immettere il dominio e la chiave API. Salva le modifiche.

9. Abilitare l'API nella configurazione PowerDNS. Apri il file di configurazione nel terminale:

nano /etc/powerdns/pdns.conf

10. Decommenta e modifica le seguenti righe:

api=yes
api-key=yoursecretekey
webserver=yes

11. Salva le modifiche e chiudi nano. L'API è configurata e pronta per l'uso.

Conclusione

Dopo aver eseguito i passaggi di questa guida, hai configurato PowerDNS, l'interfaccia Web di amministrazione di PowerDNS su Nginx e connesso l'API PowerDNS.

Successivamente, scopri i diversi tipi di record DNS o le best practice per la sicurezza DNS.