So installierst du PowerDNS und PowerDNS-Admin unter Ubuntu 22.04

PowerDNS ist ein kostenloser und quelloffener autoritativer Nameserver, der in C++ geschrieben wurde. Er ist plattformübergreifend und kann auf Unix-, Linux- und macOS-Betriebssystemen ausgeführt werden. Er unterstützt verschiedene Datenbanken wie MySQL, MariaDB, PostgreSQL und Oracle, um Zonendateien und Datensätze zu speichern.

PowerDNS Admin ist eine webbasierte Anwendung, mit der du PowerDNS über einen Webbrowser verwalten kannst. Sie ermöglicht es dir, DNS-Zonen über die PowerDNS-Webschnittstelle zu erstellen und zu verwalten. Sie bietet sehr nützliche Funktionen, darunter IPv4- und IPv6-Unterstützung, Bulk-Domain, DNSSec-Unterstützung, AD-, LDAP- und SAML-Authentifizierung und mehr.

In diesem Beitrag erklären wir dir, wie du PowerDNS und PowerDNS admin auf einem Ubuntu 22.04 Server installierst.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 22.04 läuft.
  • Ein gültiger Domainname, der auf die IP deines Servers zeigt.
  • Ein Root-Passwort ist auf dem Server konfiguriert.

MariaDB Server installieren und konfigurieren

Zuerst musst du den MariaDB-Datenbankserver auf deinem System installieren.

apt-get install mariadb-server -y

Sobald MariaDB installiert ist, musst du eine Datenbank und einen Benutzer für PowerDNS erstellen.

Melde dich zunächst mit folgendem Befehl bei MariaDB an:

mysql

Nach der Anmeldung erstellst du eine Datenbank und einen Benutzer mit dem folgenden Befehl:

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

Als Nächstes löschst du die Berechtigungen und verlässt die MariaDB-Shell mit dem folgenden Befehl:

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

PowerDNS installieren

Bevor du beginnst, musst du den Dienst systemd-resolved in deinem System deaktivieren. Du kannst ihn mit dem folgenden Befehl deaktivieren:

systemctl disable --now systemd-resolved

Als Nächstes entfernst du die Standarddatei resolv.conf und erstellst eine neue Datei:

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

Als Nächstes installierst du den PowerDNS-Server mit dem folgenden Befehl:

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

Sobald der PowerDNS installiert ist, kannst du mit dem nächsten Schritt fortfahren.

PowerDNS konfigurieren

Importiere zunächst das PowerDNS-Datenbankschema mit dem folgenden Befehl in die PowerDNS-Datenbank:

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

Als Nächstes musst du eine PowerDNS-Konfigurationsdatei erstellen und die Details der PowerDNS-Datenbankverbindung festlegen:

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

Füge die folgenden Zeilen hinzu:

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

Speichere und schließe die Datei und erteile der Datei pdns.local.gmysql.conf die entsprechenden Rechte :

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

Als Nächstes beendest du den PowerDNS-Server und testest PowerDNS mit dem folgenden Befehl:

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

Wenn alles in Ordnung ist, solltest du die folgende Ausgabe erhalten:

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

Starte als Nächstes den PowerDNS-Server mit dem folgenden Befehl:

systemctl start pdns

Du kannst nun den Status des PowerDNS mit folgendem Befehl überprüfen:

systemctl status pdns

Du solltest die folgende Ausgabe sehen:

? 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

Zu diesem Zeitpunkt ist PowerDNS gestartet und lauscht an Port 53. Du kannst es mit dem folgenden Befehl überprüfen:

ss -alnp4 | grep pdns

Du solltest die folgende Ausgabe erhalten:

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))

PowerDNS Admin installieren

In diesem Abschnitt zeigen wir dir, wie du PowerDNS Admin mit Nginx installierst.

Erforderliche Abhängigkeiten installieren

Installiere zunächst alle Abhängigkeiten, die für PowerDNS Admin erforderlich sind, mit dem folgenden Befehl:

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

Sobald alle Abhängigkeiten installiert sind, fügst du das Node.js-Repository mit dem folgenden Befehl hinzu:

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

Als Nächstes installierst du Node.js mit dem folgenden Befehl:

apt-get install nodejs -y

Als Nächstes fügst du das Garn-Repository mit folgendem Befehl hinzu:

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

Als Nächstes aktualisierst du das Repository und installierst Yarn mit dem folgenden Befehl:

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

Jetzt sind alle erforderlichen Abhängigkeiten installiert und du kannst mit dem nächsten Schritt fortfahren.

PowerDNS Admin herunterladen

Als Nächstes lädst du die neueste Version von PowerDNS Admin aus dem Git-Repository in das Nginx-Stammverzeichnis herunter:

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

Wechsle dann in das heruntergeladene Verzeichnis und erstelle eine virtuelle Python-Umgebung mit dem folgenden Befehl:

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

Als Nächstes aktivierst du die virtuelle Umgebung und installierst alle Python-Abhängigkeiten mit dem folgenden Befehl:

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

Deaktiviere dann die virtuelle Umgebung mit folgendem Befehl:

deactivate

Datenbankverbindung konfigurieren

Als nächstes musst du die Details der PowerDNS-Datenbankverbindung in der Datei default_config.py definieren:

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

Ändere die folgenden Zeilen:

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

Speichere und schließe die Datei, ändere dann das Verzeichnis in pdns und aktiviere die virtuelle Umgebung:

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

Als Nächstes aktualisierst du die Datenbank mit dem folgenden Befehl:

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

Deaktiviere dann die virtuelle Umgebung mit dem folgenden Befehl:

deactivate

Aktivieren der PowerDNS Admin API

PowerDNS Admin verwendet JSON API, um Statistiken zu lesen und Zoneninhalte, Metadaten und DNSSEC-Schlüsselmaterial zu ändern. Du kannst sie aktivieren, indem du die Datei pdns.conf bearbeitest :

nano /etc/powerdns/pdns.conf

Ändere die folgenden Zeilen:

api=yes
api-key=yoursecretekey

Speichere und schließe die Datei und starte dann den PowerDNS-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart pdns

Nginx als Reverse Proxy für PowerDNS Admin konfigurieren

Als Nächstes musst du Nginx als Reverse-Proxy für den PowerDNS-Admin konfigurieren. Dazu erstellst du mit dem folgenden Befehl eine Konfigurationsdatei für den virtuellen Nginx-Host:

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

Füge die folgenden Zeilen hinzu:

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

}

Speichere und schließe die Datei und überprüfe dann Nginx mit dem folgenden Befehl auf Syntaxfehler:

nginx -t

Du solltest die folgende Ausgabe erhalten:

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

Als Nächstes änderst du die Eigentümerschaft von pdns in www-data:

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

Zum Schluss startest du den Nginx-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart nginx

Erstellen einer Systemd-Dienstdatei für PowerDNS Admin

Als Nächstes musst du eine systemd-Dienstdatei erstellen, um den PowerDNS-Dienst zu verwalten.

Erstelle zunächst eine pdns-Dienstdatei mit dem folgenden Befehl:

nano /etc/systemd/system/pdnsadmin.service

Füge die folgenden Zeilen hinzu:

[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

Speichere und schließe die Datei und erstelle dann eine pdnsadmin sockt Datei mit dem folgenden Befehl:

nano /etc/systemd/system/pdnsadmin.socket

Füge die folgenden Zeilen hinzu:

[Unit]
Description=PowerDNS-Admin socket

[Socket]
ListenStream=/run/pdnsadmin/socket

[Install]
WantedBy=sockets.target

Speichere und schließe die Datei und erstelle dann die benötigten Dateien und Verzeichnisse mit dem folgenden Befehl:

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/

Als Nächstes lädst du den systemd-Daemon mit dem folgenden Befehl neu:

systemctl daemon-reload

Aktiviere als Nächstes den pdnsadmin-Dienst mit folgendem Befehl, damit er beim Neustart des Systems gestartet wird:

systemctl enable --now pdnsadmin.service pdnsadmin.socket

Als Nächstes überprüfst du den Status beider Dienste mit dem folgenden Befehl:

systemctl status pdnsadmin.service pdnsadmin.socket

Du solltest die folgende Ausgabe erhalten:

? 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.

Zugriff auf PowerDNS Admin

Du kannst jetzt deinen Webbrowser öffnen und über die URL http://pdnsadmin.example.com auf die PowerDNS Admin-Weboberfläche zugreifen . Du wirst auf die folgende Seite weitergeleitet:

PowerDNS Verwaltung

Klicke auf die Schaltfläche Ein Konto erstellen. Du solltest den folgenden Bildschirm sehen:

Neues Passwort festlegen

Gib deine Admin-Benutzerdaten ein und klicke auf die Schaltfläche Registrieren, um ein Konto zu erstellen. Auf dem folgenden Bildschirm solltest du die PowerDNS-Admin-Webschnittstelle sehen:

PowerDNS Admin Dashboard

Gib die PowerDNS API URL an, um dich mit PowerDNS zu verbinden und es zu verwalten. Klicke dann auf die Schaltfläche Aktualisieren, um die Änderungen zu speichern. Du solltest die folgende Seite sehen:

PDNS-Einstellungen

Klicke auf die Schaltfläche Dashboard. Auf dem folgenden Bildschirm solltest du das PowerDNS Admin-Dashboard sehen:

Dashboard

Fazit

Herzlichen Glückwunsch! Du hast PowerDNS und PowerDNS admin mit Nginx auf dem Ubuntu 22.04 Server erfolgreich installiert und konfiguriert. Du kannst jetzt über die PowerDNS-Admin-Weboberfläche Zonen erstellen und Datensätze hinzufügen und sie dann testen. Wenn du noch Fragen hast, kannst du mich gerne fragen

Das könnte dich auch interessieren …