Installieren Sie PowerDNS auf Ubuntu 18.04, 20.04 und 22.04

Einführung

PowerDNS ist eine Open-Source-DNS-Serverlösung, die beim Auflösen von Namespaces hilft. PowerDNS unterstützt Hochverfügbarkeit, Datenredundanz und verschiedene Backends, was es zu einer flexiblen und robusten Lösung macht.

Diese Anleitung zeigt, wie man PowerDNS und die PowerDNS-Verwaltungsschnittstelle auf Ubuntu installiert.

Voraussetzungen

• Zugang zum Terminal.
• Zugriff auf den Root-Benutzer.
• Ein Texteditor wie Nano.
• Ein Webbrowser für den Zugriff auf PowerDNS Admin.

Warum PowerDNS verwenden?

PowerDNS bietet zwei Nameserver-Lösungen:

• Der autoritative Server , die die Datenbank verwendet, um Abfragen zu Domänen aufzulösen.
• Der Rekursor , der sich mit anderen autoritativen Servern konsultiert, um Abfragen zu lösen.

Andere Nameserver kombinieren die beiden Funktionen automatisch. PowerDNS bietet sie separat an und ermöglicht die nahtlose Mischung der beiden Lösungen für einen modularen Aufbau.

Darüber hinaus ist PowerDNS Open Source, funktioniert gleichermaßen gut für kleine und große Abfragevolumina und bietet viele Möglichkeiten für Backend-Lösungen.

Installieren von PowerDNS auf Ubuntu 18.04, 20.04 und 22.04

Führen Sie die folgenden Schritte aus, um PowerDNS mit dem MariaDB-Server als Backend-Datenbank zu installieren und zu konfigurieren. Darüber hinaus führen die Schritte Benutzer durch die Einrichtung der PowerDNS Admin-Webschnittstelle und -API.

Schritt 1:MariaDB-Server installieren und konfigurieren

Gehen Sie wie folgt vor, um MariaDB zu installieren und zu konfigurieren:

1. Systempakete aktualisieren und upgraden:

sudo apt update && sudo apt upgrade

2. Installieren Sie den MariaDB-Server und -Client mit:

sudo apt install mariadb-server mariadb-client

Hinweis: Andere mögliche Datenbankserver sind PostgreSQL, MySQL und andere relationale Datenbanken.

Warten Sie, bis die Installation abgeschlossen ist, bevor Sie fortfahren.

3. Verbinden Sie sich mit MariaDB mit:

sudo mysql

Das Terminal stellt eine Verbindung zu einer Datenbanksitzung her.

4. Erstellen Sie eine Datenbank für den PowerDNS-Nameserver:

create database pda;

Hinweis: Wenn Sie einen anderen Datenbanknamen verwenden, ändern Sie alle nachfolgenden Befehle entsprechend.

5. Gewähren Sie pda alle Berechtigungen Benutzer und geben Sie das Benutzerkennwort ein:

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

6. Verbinden Sie sich mit der Datenbank:

use pda;

7. Verwenden Sie die folgenden SQL-Abfragen, um Tabellen für den pda zu erstellen Datenbank:

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. Bestätigen Sie, dass die Tabellen erstellt wurden mit:

show tables;

Die Ausgabe listet die verfügbaren Tabellen auf.

9. Beenden Sie die Datenbankverbindung:

exit;

Der Befehl gibt die Sitzung an das Terminal zurück.

Schritt 2:PowerDNS installieren

Gehen Sie wie folgt vor, um PowerDNS unter Ubuntu zu installieren:

1. Wechseln Sie zum Root-Benutzer:

sudo su -

Die Terminalsitzung wechselt zum Root-Benutzer.

Hinweis: Erfahren Sie mehr über den Unterschied zwischen sudo und su.

2. Die systemd-resolved Der Dienst stellt die Namensauflösungen für lokale Anwendungen bereit. PowerDNS verwendet einen eigenen Dienst zur Namensauflösung.

Deaktivieren Sie systemd-resolved Service mit:

systemctl disable --now systemd-resolved

Die Ausgabe bestätigt die Dienstentfernung.

3. Löschen Sie die Systemdienst-Konfigurationsdatei mit:

rm -rf /etc/resolv.conf

4. Erstellen Sie die neue resolv.conf Datei:

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

Das Anhängen des Google-Nameservers stellt die DNS-Auflösung sicher.

5. Installieren Sie die PowerDNS-Server- und Datenbank-Backend-Pakete mit:

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

Warten Sie, bis die Installation abgeschlossen ist, bevor Sie fortfahren.

Schritt 3:PowerDNS konfigurieren

Konfigurieren Sie die lokale PowerDNS-Datei, um eine Verbindung zur Datenbank herzustellen:

1. Öffnen Sie die Konfigurationsdatei zum Bearbeiten:

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

2. Fügen Sie der Datei die folgenden Informationen hinzu:

# 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=

Tauschen Sie den Datenbanknamen, den Benutzer und das Passwort mit den richtigen Parametern aus, wenn Sie andere verwenden. Speichern und schließen Sie die Datei.

3. Ändern Sie die Dateiberechtigungen:

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

4. Beenden Sie die pdns Dienst:

systemctl stop pdns

5. Testen Sie die Verbindung zur Datenbank:

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

Die Ausgabe zeigt eine erfolgreiche Verbindung. Drücken Sie STRG +C um den Test zu beenden.

6. Starten Sie den Dienst:

systemctl start pdns

7. Überprüfen Sie die Verbindung mit dem Befehl ss:

ss -alnp4 | grep pdns

Überprüfen Sie den TCP/UDP-Port 53 ist offen und in LISTEN /UCONN Zustand.

Schritt 4:PowerDNS-Admin-Abhängigkeiten installieren

Der PowerDNS Admin hilft bei der Verwaltung von PowerDNS über eine Webschnittstelle. Gehen Sie wie folgt vor, um das Dashboard lokal zu installieren:

1. Installieren Sie das Python-Entwicklungspaket:

apt install python3-dev

2. Abhängigkeiten installieren:

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. Rufen Sie das Node.js-Setup ab:

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

4. Installieren Sie Node.js mit:

apt install -y nodejs

5. Installieren Sie als Nächstes den Yarn-Paketmanager. Rufen Sie den öffentlichen Yarn-Schlüssel ab und fügen Sie ihn zu apt hinzu :

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

Yarn hilft beim Erstellen der Asset-Dateien.

6. Garn zur Quellenliste hinzufügen:

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

7. Aktualisieren Sie die apt-Quellenliste:

apt update -y

8. Installieren Sie Yarn mit:

apt install yarn -y

9. Klonen Sie das PowerDNS Admin Git-Repository nach /opt/web/powerdns-admin :

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

Wenn Sie ein anderes Verzeichnis verwenden, tauschen Sie das Zielverzeichnis im Befehl und in allen nachfolgenden Erscheinungen aus.

10. Navigieren Sie zum geklonten Git-Verzeichnis:

cd /opt/web/powerdns-admin

11. Erstellen Sie eine virtuelle Python-Umgebung:

python3 -mvenv ./venv

12. Aktivieren Sie die virtuelle Umgebung mit:

source ./venv/bin/activate

13. Aktualisieren Sie Pip auf die neueste Version:

pip install --upgrade pip

Der Pip-Paketmanager hilft bei der Installation zusätzlicher Python-Anforderungen.

14. Installieren Sie die Anforderungen aus der requirements.txt Datei:

pip install -r requirements.txt

Nach der Installation aller Anforderungen erfordert der PowerDNS Admin eine zusätzliche Konfiguration, bevor er ausgeführt werden kann.

Schritt 5:PowerDNS Admin konfigurieren und ausführen

Gehen Sie wie folgt vor, um PowerDNS Admin auf einer lokalen Instanz zu konfigurieren und zu starten:

1. Verwenden Sie den Befehl cp, um das Beispiel development.py zu kopieren Python-Datei in production.py :

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

2. Öffnen Sie die production.py Datei zum Bearbeiten:

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

3. Bearbeiten Sie die folgenden Zeilen:

#import urllib.parse

SECRET_KEY = 'e951e5a1f4b94151b360f47edf596dd2'

SQLA_DB_PASSWORD = 'changeme'

4. Entkommentieren Sie den Bibliotheksimport, geben Sie einen zufällig generierten geheimen Schlüssel ein und geben Sie das korrekte Datenbankkennwort ein.

import urllib.parse

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

SQLA_DB_PASSWORD = 'YOUR_PASSWORD_HERE'

Hinweis: Generieren Sie einen zufälligen Schlüssel mit Python:

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

Kopieren Sie die Ausgabe und fügen Sie sie in SECRET_KEY ein Wert.

Speichern und schließen Sie die Datei.

5. Exportieren Sie die Konfigurationsvariable der Produktions-App:

export FLASK_CONF=../configs/production.py

6. Exportieren Sie die Flask-Anwendungsvariable:

export FLASK_APP=powerdnsadmin/__init__.py

7. Aktualisieren Sie das Datenbankschema:

flask db upgrade

8. Projektabhängigkeiten installieren:

yarn install --pure-lockfile

9. Flask-App-Assets erstellen:

flask assets build

Warten Sie, bis der Build abgeschlossen ist.

10. Führen Sie die Anwendung aus mit:

./run.py

Lassen Sie die Anwendung laufen.

11. Die Anwendung wird derzeit auf localhost auf Port 9191 ausgeführt . Besuchen Sie die folgende Adresse:

http://localhost:9191

Der Anmeldebildschirm für PowerDNS Admin wird angezeigt. Derzeit gibt es keine Benutzer, und der erste Benutzer, den Sie registrieren, soll das Administratorkonto sein.

12. Verlassen Sie im Terminal die virtuelle Umgebung und melden Sie sich vom Root-Benutzer ab mit:

exit

Das Terminal kehrt in den Normalzustand zurück.

Schritt 6:PowerDNS-Verwaltungsdienst erstellen

Konfigurieren Sie PowerDNS Admin so, dass es beim Start ausgeführt wird:

1. Erstellen Sie eine systemd-Dienstdatei für PowerDNS Admin:

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

2. Fügen Sie den folgenden Inhalt hinzu:

[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. Erstellen Sie eine Unit-Datei:

sudo systemctl edit --force powerdns-admin.service

4. Fügen Sie Folgendes hinzu:

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

5. Erstellen Sie eine Socket-Datei:

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

6. Geben Sie die folgenden Informationen ein:

[Unit]
Description=PowerDNS-Admin socket

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

[Install]
WantedBy=sockets.target

7. Erstellen Sie eine Umgebungsdatei:

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

8. Fügen Sie die folgenden Informationen hinzu:

d /run/powerdns-admin 0755 pdns pdns -

9. Laden Sie den Daemon neu:

sudo systemctl daemon-reload

10. Starten und aktivieren Sie den Dienst und Socket:

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

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

11. Überprüfen Sie den Status mit:

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

Die Dienste laufen ohne Fehler.

Schritt 7:Nginx installieren und konfigurieren

Gehen Sie wie folgt vor, um PowerDNS Admin für die Ausführung auf Nginx zu konfigurieren:

1. Installieren Sie Nginx mit:

sudo apt install nginx -y

2. Bearbeiten Sie die Nginx-Konfigurationsdatei:

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

3. Fügen Sie die folgenden Informationen hinzu:

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;
  }

}

Wenn Sie einen anderen Servernamen verwenden, ändern Sie localhost an Ihre Serveradresse.

4. Bestätigen Sie, dass die Datei keine Syntaxfehler enthält:

nginx -t

5. Ändern Sie den Eigentümer von powerdns-admin zu www-data :

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

6. Starten Sie den Nginx-Dienst neu:

sudo systemctl restart nginx

7. Greifen Sie über den Browser auf die PowerDNS-Admin-Seite zu:

localhost

Wenn Sie auf eine andere Adresse verlinken, verwenden Sie die in der Nginx-Konfigurationsdatei angegebene Adresse.

Schritt 8:PowerDNS-API konfigurieren

Gehen Sie wie folgt vor, um die PowerDNS-API zu konfigurieren:

1. Melden Sie sich über den Browser bei PowerDNS Admin an. Wenn Sie es zum ersten Mal ausführen, erstellen Sie zuerst einen neuen Benutzer. Der erste Benutzer ist automatisch der Administrator.

2. Öffnen Sie den API-Schlüssel s-Tab im linken Menü.

3. Klicken Sie auf Schlüssel hinzufügen+ Schaltfläche.

4. Die Rolle ist standardmäßig der Administrator Benutzer. Fügen Sie eine optionale Beschreibung für den Schlüssel hinzu.

5. Klicken Sie auf Schlüssel erstellen um einen API-Schlüssel zu generieren.

6. Ein Popup-Fenster druckt den Schlüssel. Kopieren Sie den Schlüssel und drücken Sie Bestätigen um fortzufahren.

7. Navigieren Sie zum Dashboard Seite.

8. Geben Sie die Domäne und den API-Schlüssel ein. Speichern Sie die Änderungen.

9. Aktivieren Sie die API in der PowerDNS-Konfiguration. Öffnen Sie die Konfigurationsdatei im Terminal:

nano /etc/powerdns/pdns.conf

10. Entkommentieren und ändern Sie die folgenden Zeilen:

api=yes
api-key=yoursecretekey
webserver=yes

11. Speichern Sie die Änderungen und schließen Sie nano. Die API ist eingerichtet und einsatzbereit.

Fazit

Nachdem Sie die Schritte in diesem Handbuch ausgeführt haben, haben Sie PowerDNS, die PowerDNS Admin-Webschnittstelle auf Nginx, eingerichtet und die PowerDNS-API verbunden.

Informieren Sie sich als Nächstes über die verschiedenen DNS-Eintragstypen oder Best Practices für die DNS-Sicherheit.