HowtoForge

Wie installiert man PowerDNS-Server und PowerDNS-Admin unter Ubuntu 20.04

von ·

PowerDNS ist ein freier und quelloffener autoritativer Nameserver. Er ist in C++ geschrieben und läuft auf den Betriebssystemen Unix, Linux und MacOS. Er verwendet MySQL, MariaDB, PostgreSQL und Oracle, um Zonendateien und Datensätze zu speichern.

PowerDNS Admin ist ein webbasiertes Tool zur Verwaltung von PowerDNS. Sie können DNS-Zonen mit dem Webbrowser erstellen und verwalten. Es wird mit einer Vielzahl von Funktionen geliefert. Einige davon sind unten aufgeführt:

  • IPv4- und IPv6-Unterstützung
  • Statusseite mit nützlichen Informationen
  • Automatische Erstellung/Aktualisierung umgekehrter PTR-Einträge
  • Unterstützung für die Massenerstellung von Domänen
  • Unterstützung für Domain-Vorlagen
  • DNSSec-Unterstützung
  • Unterstützung lokaler DB, SAML, LDAP, Active Directory-Benutzerauthentifizierung

In diesem Tutorial zeigen wir Ihnen, wie Sie PowerDNS und PowerDNS admin auf einem Ubuntu 20.04 Server installieren.

Voraussetzungen

  • Ein Server, auf dem Ubuntu 20.04 läuft.
  • Ein gültiger Domain-Name, der auf Ihre Server-IP zeigt.
  • Der Server ist mit einem Root-Passwort konfiguriert.

Installieren und Konfigurieren des MariaDB-Servers

Bevor Sie beginnen, müssen Sie den MariaDB-Datenbankserver in Ihrem System installieren. Standardmäßig ist die neueste Version von MariaDB nicht im Standard-Repository von Ubuntu 20.04 verfügbar. Daher müssen Sie das MariaDB-Repository zu Ihrem System hinzufügen.

Installieren Sie zunächst die erforderlichen Pakete mit dem folgenden Befehl:

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

Sobald alle Pakete installiert sind, fügen Sie den MariaDB-Signaturschlüssel mit folgendem Befehl hinzu:

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

Als nächstes fügen Sie das MariaDB-Repository mit folgendem Befehl hinzu: Fügen Sie das MariaDB-Repository mit folgendem Befehl hinzu:

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

Installieren Sie anschließend den MariaDB-Server, indem Sie den folgenden Befehl ausführen:

apt-get install mariadb-server -y

Nach der Installation müssen Sie eine Datenbank und einen Benutzer für PowerDNS erstellen.

Melden Sie sich zunächst mit folgendem Befehl bei MariaDB an:

mysql

Sobald Sie sich angemeldet haben, erstellen Sie eine Datenbank und einen Benutzer mit folgendem Befehl: Nach der Anmeldung müssen Sie eine Datenbank und einen Benutzer für PowerDNS erstellen:

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

Als nächstes müssen Sie die Berechtigungen aufheben und die MariaDB-Shell mit dem folgenden Befehl verlassen:

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

PowerDNS installieren

Zuerst müssen Sie den systemaufgelösten Dienst von Ihrem System aus deaktivieren. Sie können ihn mit dem folgenden Befehl deaktivieren:

systemctl disable --now systemd-resolved

Als nächstes entfernen Sie die Standarddatei resolv.conf und erstellen eine neue Datei:

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

Installieren Sie dann den PowerDNS-Server mit dem folgenden Befehl:

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

Sobald der PowerDNS-Server installiert ist, können Sie mit dem nächsten Schritt fortfahren.

Konfigurieren von PowerDNS

Zuerst müssen Sie das PowerDNS-Datenbankschema in die PowerDNS-Datenbank importieren. Sie können es mit dem folgenden Befehl importieren:

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

Als nächstes müssen Sie die Verbindungsdetails der PowerDNS-Datenbank definieren. Sie können dies tun, indem Sie die Datei pdns.local.gmysql.conf bearbeiten:

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

Ändern Sie die folgenden Zeilen:

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

Speichern und schließen Sie die Datei und erteilen Sie der Datei pdns.local.gmysql.conf die entsprechende Berechtigung:

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

Stoppen Sie dann den PowerDNS-Server und überprüfen Sie den PowerDNS mit dem folgenden Befehl:

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

Wenn alles in Ordnung ist, sollten Sie die folgende Ausgabe erhalten:

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

Starten Sie als nächstes den PowerDNS-Server mit folgendem Befehl:

systemctl start pdns

An diesem Punkt wird PowerDNS gestartet und hört auf Port 53 ab. Sie können dies mit dem folgenden Befehl überprüfen:

ss -alnp4 | grep pdns

Sie sollten die folgende Ausgabe erhalten:

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

PowerDNS-Admin installieren

In diesem Abschnitt zeigen wir Ihnen, wie Sie PowerDNS admin mit Nginx installieren.

Erforderliche Abhängigkeiten installieren

Installieren Sie zunächst alle für die PowerDNS-Verwaltung erforderlichen Abhängigkeiten 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

Wenn alle Abhängigkeiten installiert sind, fügen Sie das Repository Node.js mit folgendem Befehl hinzu:

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

Installieren Sie anschließend das Node.js mit folgendem Befehl:

apt-get install nodejs -y

Fügen Sie als Nächstes das Garn-Repository mit folgendem Befehl hinzu: Fügen Sie als Nächstes 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

Aktualisieren Sie als Nächstes das Repository und installieren Sie Garn mit folgendem Befehl: Aktualisieren Sie als Nächstes das Repository und installieren Sie Garn mit folgendem Befehl

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

An diesem Punkt sind alle erforderlichen Abhängigkeiten installiert, Sie können nun mit dem nächsten Schritt fortfahren.

PowerDNS-Admin herunterladen

Laden Sie als Nächstes die neueste Version der PowerDNS-Verwaltung aus dem Git-Repository in das Nginx-Stammverzeichnis herunter:

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

Ändern Sie dann das Verzeichnis in das heruntergeladene Verzeichnis und erstellen Sie eine virtuelle Python-Umgebung mit dem folgenden Befehl:

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

Aktivieren Sie als nächstes die virtuelle Umgebung und installieren Sie alle Python-Abhängigkeiten mit dem folgenden Befehl:

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

Deaktivieren Sie als nächstes die virtuelle Umgebung mit folgendem Befehl: Deaktivieren Sie die virtuelle Umgebung mit folgendem Befehl

deactivate

Datenbankverbindung definieren

Als Nächstes müssen Sie die Verbindungsdetails der PowerDNS-Datenbank mit der Datei default_config.py definieren:

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

Ändern Sie 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

Speichern und schließen Sie die Datei, ändern Sie dann das Verzeichnis in das pdns-Verzeichnis und aktivieren Sie die virtuelle Umgebung:

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

Aktualisieren Sie als Nächstes die Datenbank mit dem folgenden Befehl:

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

Deaktivieren Sie als nächstes die virtuelle Umgebung mit folgendem Befehl:

deactivate

Aktivieren der PowerDNS-Administrations-API

Der PowerDNS-Administrator verwendet die JSON-API zum Lesen von Statistiken und zum Ändern von Zoneninhalten, Metadaten und DNSSEC-Schlüsselmaterial. Sie können sie aktivieren, indem Sie die Datei pdns.conf bearbeiten:

nano /etc/powerdns/pdns.conf

Ändern Sie die folgenden Zeilen:

api=yes
api-key=yoursecretekey

Speichern und schließen Sie die Datei und starten Sie den PowerDNS-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart pdns

Konfigurieren von Nginx für PowerDNS-Admin

Als Nächstes müssen Sie den Nginx für PowerDNS-Administrator konfigurieren. Dazu erstellen Sie eine Nginx-Konfigurationsdatei für den virtuellen Host mit dem folgenden Befehl:

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

Fügen Sie 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;
  }

}

Speichern und schließen Sie die Datei, und überprüfen Sie dann die Nginx mit dem folgenden Befehl auf Syntaxfehler:

nginx -t

Sie sollten 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

Ändern Sie als nächstes den Eigentümer der pdns in www-data:

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

Schließlich starten Sie den Nginx-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart nginx

Erstellen Sie eine Systemdienstdatei für PowerDNS Admin

Als nächstes müssen Sie eine Systemdienstdatei erstellen, um den PowerDNS-Dienst zu verwalten.

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

nano /etc/systemd/system/pdnsadmin.service

Fügen Sie 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

Speichern und schließen Sie die Datei, und erstellen Sie dann eine pdnsadmin sockt-Datei mit folgendem Befehl: „pdnsadmin sockt file“:

nano /etc/systemd/system/pdnsadmin.socket

Fügen Sie die folgenden Zeilen hinzu:

[Unit]
Description=PowerDNS-Admin socket

[Socket]
ListenStream=/run/pdnsadmin/socket

[Install]
WantedBy=sockets.target

Speichern und schließen Sie die Datei, und erstellen Sie dann die erforderlichen Dateien und Verzeichnisse mit folgendem Befehl: Speichern und schließen Sie die Datei, und erstellen Sie dann die erforderlichen Dateien und Verzeichnisse mit folgendem 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/

Laden Sie anschließend den systemd-Dämon mit folgendem Befehl neu:

systemctl daemon-reload

Aktivieren Sie als Nächstes den pdnsadmin-Dienst beim Systemneustart mit folgendem Befehl: Aktivieren Sie den pdnsadmin-Dienst beim Systemneustart mit folgendem Befehl

systemctl enable --now pdnsadmin.service pdnsadmin.socket

Überprüfen Sie als nächstes den Status beider Dienste mit folgendem Befehl: Überprüfen Sie als nächstes den Status beider Dienste mit folgendem Befehl

systemctl status pdnsadmin.service pdnsadmin.socket

Sie sollten die folgende Ausgabe erhalten:

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

Zugriff auf PowerDNS-Admin-Web-Benutzeroberfläche

Öffnen Sie nun Ihren Webbrowser und greifen Sie über die URL http://pdnsadmin.example.com auf die PowerDNS-Administrator-Webschnittstelle zu. Sie werden auf die folgende Seite umgeleitet:

PowerDNS-Administrator-Anmeldung

Klicken Sie auf die Schaltfläche Create an account. Sie sollten den folgenden Bildschirm sehen:

Ein Konto erstellen

Geben Sie Ihre Admin-Benutzerdaten ein und klicken Sie auf die Schaltfläche Registrieren, um ein Konto zu erstellen. Auf dem folgenden Bildschirm sollten Sie die PowerDNS-Administrator-Anmeldeseite sehen:

Bitte loggen Sie sich ein

Geben Sie Ihren Admin-Benutzernamen und Ihr Passwort ein und klicken Sie auf die Schaltfläche Anmelden. Auf der folgenden Seite sollten Sie die PowerDNS-Verwaltungs-Webschnittstelle sehen:

PowerDNS-Administrations-Dashboard

Geben Sie hier die URL der PowerDNS-API an, um eine Verbindung zu PowerDNS herzustellen und es zu verwalten. Klicken Sie dann auf die Schaltfläche Update, um die Änderungen zu speichern. Sie sollten die folgende Seite sehen:

PowerDNS-API konfiguriert

Klicken Sie auf die Schaltfläche Dashboard. Auf dem folgenden Bildschirm sollten Sie das PowerDNS-Verwaltungs-Dashboard sehen:

Das Dashboard Ihres PowerDNS-Servers

Schlussfolgerung

Herzlichen Glückwunsch! Sie haben PowerDNS und PowerDNS admin auf dem Ubuntu 20.04 Server erfolgreich installiert und konfiguriert. Sie können jetzt Zonen erstellen und Datensätze über die PowerDNS-Admin-Webschnittstelle hinzufügen.

Das könnte dich auch interessieren …