HowtoForge

So installierst du PowerDNS und PowerAdmin auf Rocky Linux

von ·

PowerDNS ist eine kostenlose und quelloffene DNS-Server-Software. Sie kann als autoritativer Nameserver und DNS-Recursor verwendet werden. Der PowerDNS ist in C++ geschrieben und unterstützt mehrere Betriebssysteme, darunter BSD, Linux und macOS.

PowerDNS ist ein hochleistungsfähiger DNS-Server, der mehrere Arten von Backends wie BIND und RDBMS-Backends wie MySQL/MariaDB, PostgreSQL und Oracle-Datenbanken unterstützt.

Der PowerDNS-Server ist so leistungsstark, dass er Zehntausende von gleichzeitigen Zugriffen verarbeiten kann, unterstützt DNSSEC und bietet eine hohe Skriptfähigkeit mit Lua.

In dieser Anleitung zeigen wir dir, wie du PowerDNS und den PowerDNS-Admin auf einem Rocky Linux System installierst. Wir werden PowerDNS mit dem MySQL/MariaDB-Datenbank-Backend ausführen und den PowerDNS-Admin einrichten, der als webbasiertes Verwaltungstool für den PowerDNS-Server verwendet wird.

Diese Anleitung zeigt auch die Installation von Python-Paketen für Flask-basierte Projekte und die Konfiguration von Nginx und Gunicorn, die als Reverse-Proxy für die PowerDNS-Admin-Webanwendung verwendet werden.

Voraussetzungen

Um mit diesem Leitfaden zu beginnen, brauchst du die folgenden Voraussetzungen:

  • Einen Rocky Linux Server – Du kannst Rocky Linux v8 oder v9 verwenden.
  • Einen Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.

Installieren und Konfigurieren des MariaDB-Datenbank-Servers

Der PowerDNS ist eine skalierbare DNS-Server-Software, die mehrere Backends wie PostgreSQL, MariaDB/MySQL und SQLite unterstützt. Bei großen Einsätzen solltest du PostgreSQL oder MySQL/MariaDB als Datenbank-Backend verwenden.

Du beginnst nun mit der Installation und Konfiguration der MariaDB-Datenbank auf dem Rocky Linux Server. Du wirst den PowerDNS mit MariaDB als Datenbank-Backend einrichten.

Das Standard-Repository von Rocky Linux bietet mehrere Versionen von MariaDB-Serverpaketen. Führe den folgenden dnf-Befehl aus, um den MariaDB-Datenbankserver zu installieren.

sudo dnf install mariadb-server

Wenn du zur Bestätigung aufgefordert wirst, gibst du y ein, um zu bestätigen, und drückst ENTER, um fortzufahren.

mariadb installieren

Nachdem der MariaDB-Server installiert ist, führe den folgenden systemctl-Befehl aus, um den MariaDB-Dienst zu starten und zu aktivieren.

sudo systemctl start mariadb
sudo systemctl enable mariadb

Jetzt sollte der MariaDB-Server laufen und aktiviert sein. Führe den folgenden Befehl aus, um den MariaDB-Dienst zu überprüfen und sicherzustellen, dass der Dienst läuft.

sudo systemctl status mariadb

Du wirst die folgende Ausgabe sehen – Der MariaDB-Dienst läuft und ist aktiviert, was bedeutet, dass der Dienst beim Booten automatisch ausgeführt wird.

start enable verify mariadb

Jetzt, wo der MariaDB-Server läuft, kannst du die MariaDB-Installation mit dem Kommandozeilen-Tool „mysql_secure_installation“ einrichten und sichern.

Führe den folgenden Befehl aus, um die Installation des MariaDB-Servers abzusichern.

sudo mysql_secure_installation

Du wirst dann nach einigen Konfigurationen für den MariaDB-Server gefragt.

  • Das MariaDB Root-Passwort einrichten? Bestätige mit y und gib das neue Kennwort für deinen MariaDB-Server ein und wiederhole es.
  • Fernanmeldung für den MariaDB-Root-Benutzer deaktivieren? Bestätige die Eingabe mit y und deaktiviere sie.
  • Den anonymen Standardbenutzer von MariaDB entfernen? Gib zur Bestätigung y ein.
  • Den standardmäßigen Datenbanktest aus MariaDB entfernen? Gib zur Bestätigung erneut y ein.
  • Tabellenrechte neu laden, um neue Änderungen zu übernehmen? Gib zur Bestätigung y ein und MariaDB wird alle Berechtigungen neu laden und die neuen Einstellungen übernehmen.

Nachdem du den MariaDB-Einsatz gesichert hast, richtest du als Nächstes eine neue MariaDB-Datenbank und einen neuen Benutzer für den PowerDNS ein.

Führe zunächst den Befehl mysql aus, um dich in der MariaDB-Shell als MariaDB-Root-Benutzer anzumelden.

sudo mysql -u root -p

Wenn du nach dem Passwort gefragt wirst, gibst du das Passwort deines MariaDB-Root-Benutzers ein.

Als nächstes führst du die folgenden Abfragen aus, um eine neue MariaDB-Datenbank und einen neuen Benutzer zu erstellen. In diesem Beispiel erstellst du eine neue Datenbank pdns mit dem Benutzer pdnsadmin und dem Passwort„password„.

CREATE DATABASE pdns;
GRANT ALL ON pdns.* TO pdnsadmin@localhost IDENTIFIED BY 'password';
FLUSH PRIVILEGES;

Datenbank und Benutzer anlegen

Führe nun die folgenden Abfragen aus, um die Berechtigungen des MariaDB-Benutzers pdnsadmin@localhost zu überprüfen. Dies zeigt dir die Liste der Berechtigungen für den MariaDB-Benutzer pdnsadmin@localhost.

SHOW GRANTS FOR pdnsadmin@localhost;

Du wirst die folgende Ausgabe sehen – Der MariaDB-Benutzer pdnsadmin@localhost hat Rechte für die PowerDNS-Datenbank pdns.

Privilegien anzeigen

Gib nun„quit“ ein, um die MariaDB-Shell zu verlassen.

Wenn der MariaDB-Server läuft, installierst und konfigurierst du den PowerDNS-Server mit dem MariaDB-Datenbank-Backend.

Installieren und Konfigurieren von PowerDNS

Nachdem du den MariaDB-Datenbankserver installiert hast, installierst du nun den PowerDNS-Server und richtest den PowerDNS mit dem MariaDB-Datenbank-Backend ein.

Für die RHEL-basierten Betriebssysteme sind die PowerDNS im EPEL-Repository verfügbar. Bevor du also PowerDNS installierst, musst du das EPEL-Repository zu deinem System hinzufügen.

Führe den folgenden dnf-Befehl aus, um das EPEL-Repository zu installieren.

sudo dnf install epel-release -y

Nachdem das EPEL-Repository hinzugefügt wurde, führe den folgenden dnf-Befehl aus, um PowerDNS und das PowerDNS-MySQL-Backend zu installieren.

sudo dnf install pdns pdns-backend-mysql

Wenn du nach einer Bestätigung gefragt wirst, gib y ein, um zu bestätigen, und drücke ENTER, um fortzufahren.

powerdns installieren

Nachdem die PowerDNS-Installation abgeschlossen ist, führe den folgenden mysql-Befehl aus, um das Datenbankschema für PowerDNS zu importieren. Mit dem folgenden Befehl wird das Datenbankschema über den MariaDB-Benutzer pdnsadmin in die Datenbank pdns importiert.

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

Gib das Passwort für den pdnsadmin-Benutzer ein und drücke ENTER, um zu bestätigen und fortzufahren.

Datenbankschema importieren

Als Nächstes bearbeitest du die PowerDNS-Konfiguration „/etc/pdns/pdns.conf“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/pdns/pdns.conf

Entferne das Kommentarzeichen in der MariaDB-Backend-Konfiguration und ändere den Datenbanknamen, den Benutzer und das Passwort. Achte darauf, dass du die richtigen MariaDB-Datenbankdetails verwendest, die du erstellt hast.

#################################
# launch        Which backends to launch and order to query them in
#
launch=gmysql
gmysql-host=localhost
gmysql-user=pdnsadmin
gmysql-password=password
gmysql-dbname=pdns

Entkommentiere als Nächstes das Feld „api“ und ändere den Wert in„yes„. Dekommentiere dann die Option„api-key“ und ändere den Standardschlüssel. Die folgende PowerDNS-API wird für die Verwaltung des PowerDNS-Servers über die PowerDNS-Admin-Webanwendung verwendet.

#################################
# api   Enable/disable the REST API (including HTTP listener)
#
api=yes
#################################
# api-key       Static pre-shared authentication key for access to the REST API
#
api-key=CHANGEME

Speichere die Datei und beende den Editor, wenn du fertig bist.

Nachdem du den PowerDNS-Server konfiguriert hast, führe den folgenden Befehl aus, um die PowerDNS-Konfiguration zu überprüfen.

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

Du siehst die folgende Ausgabe – Die Verbindung von PowerDNS mit dem MariaDB-Datenbank-Backend ist erfolgreich, du kannst jetzt „Strg+c“ drücken, um den Vorgang zu beenden.

Datenbankverbindung verifizieren

Führe nun den folgenden systemctl-Befehl aus, um den PowerDNS-Dienst zu starten und zu aktivieren.

sudo systemctl start pdns
sudo systemctl enable pdns

Überprüfe abschließend den PowerDNS-Dienst, um sicherzustellen, dass PowerDNS läuft und aktiviert ist.

sudo systemctl status pdns

In der folgenden Ausgabe siehst du, dass der PowerDNS-Dienst läuft und aktiviert ist, d.h. er wird beim Booten automatisch ausgeführt.

pdns-Dienst überprüfen

An dieser Stelle hast du die Installation des PowerDNS-Servers abgeschlossen. Als Nächstes beginnst du mit der Installation von PowerDNS-Admin, das als Web-Frontend für die Verwaltung des PowerDNS-Servers verwendet wird.

Installation von PowerDNS-Admin

Wenn PowerDNS läuft, installierst und konfigurierst du jetzt PowerDNS-Admin auf dem Rocky Linux Server. Der PowerDNS-Admin ist eine auf Python und Flask basierende Webanwendung, daher ist die Installation des PowerDNS-Admin ganz ähnlich wie die Installation des Flask-Webframeworks.

Im Folgenden findest du einige Schritte, die du ausführen musst, um PowerDNS-Admin auf Rocky Linux zu installieren

  • Installation der Paketabhängigkeiten
  • Einrichten der virtuellen Python-Umgebung
  • Installation der Python-Abhängigkeiten
  • PowerDNS-Admin mit MariaDB-Datenbank konfigurieren
  • Datenbankschema generieren und statische Dateien erstellen

Beginnen wir nun mit der Installation von PowerDNS-Admin

Installation der Paketabhängigkeiten

Der erste Schritt bei der Installation von PowerDNS-Admin ist die Installation von Paketabhängigkeiten wie Python3, Pip, Node.js und Yarn.

Bevor du beginnst, führe den unten stehenden dnf-Befehl aus, um das„powertools„-Repository auf deinem Rocky Linux-System zu aktivieren.

sudo dnf config-manager --set-enabled powertools

Nachdem du das „powertools“-Repository aktiviert hast, installierst du die Python-Pakete mit dem unten stehenden dnf-Befehl.

sudo dnf install python3 python3-devel python3-pip python3-xmlsec gcc git mariadb-devel openldap-devel xmlsec1-devel xmlsec1-openssl libtool-ltdl-devel

Wenn du zur Bestätigung aufgefordert wirst, gib y ein und drücke ENTER, um fortzufahren.

install python dependnecies

Als Nächstes fügst du die Repositories Node.js und Yarn mit dem unten stehenden Befehl zu deinem System hinzu. Die Pakete Node.js und Yarn werden verwendet, um statische Dateien für die PowerAdmin-Webanwendung zu erstellen. In diesem Beispiel wird Node.js v16 verwendet.

curl -sL https://rpm.nodesource.com/setup_16.x | bash -
curl -sL https://dl.yarnpkg.com/rpm/yarn.repo -o /etc/yum.repos.d/yarn.repo

Setup-Repository

Nachdem du die Repositories hinzugefügt hast, führe den folgenden dnf-Befehl aus, um den Node.js- und Yarn-Paketmanager zu installieren.

sudo dnf install nodejs yarn

Gib y ein und drücke ENTER, wenn du zur Installation aufgefordert wirst.

nodejs installieren

Wenn du aufgefordert wirst, den GPG-Schlüssel zu bestätigen, gibst du ebenfalls y ein und drückst ENTER.

gpg-Schlüssel importieren

Als Nächstes führst du den Befehl pip3 aus, um das Python-Pip-Paket zu aktualisieren und die Virtualenv auf deinem System zu installieren.

pip3 install -U pip
pip3 install -U virtualenv

Python pip und virtualenv werden nun im Verzeichnis„/usr/local/bin“ installiert. Füge das Verzeichnis„/usr/local/bin“ mit dem unten stehenden Befehl zur Umgebungsvariablen $PATH deines Systems hinzu.

echo "export PATH="/usr/local/bin:$PATH"" >> ~/.bashrc

Übernimm die neuen Änderungen in der Datei„~/.bashrc“ mit dem unten stehenden Befehl. Du solltest nun die Befehle„pip“ und„virtualenv“ ausführen.

source ~/.bashrc

Einrichten der virtuellen Python-Umgebung

Nachdem du die Paketabhängigkeiten installiert hast, lädst du den Quellcode von PowerDNS-Admin herunter und richtest die virtuelle Python-Umgebung für PowerDNS-Admin ein.

Klone den PowerDNS-Admin-Quellcode mit dem folgenden git-Befehl in das Verzeichnis „/opt/powerdns-admin“.

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

Nachdem der Quellcode heruntergeladen wurde, verschiebe das Arbeitsverzeichnis nach„/opt/powerdns-admin“ und erstelle eine neue virtuelle Python-Umgebung„flask„.

cd /opt/powerdns-admin
virtualenv -p python3 flask

Aktiviere nun die virtuelle Python-Umgebung„flask“ mit dem folgenden Befehl.

source flask/bin/activate

Nach der Aktivierung sollte die Eingabeaufforderung wie folgt aussehen: „(flask) [user@hostname /directory/path]#„.

Virtualenv erstellen

Von nun an sollte sich deine Arbeitsumgebung immer in der virtuellen Python-Umgebung„flask“ befinden.

Installation der Python-Abhängigkeiten

Nachdem du die virtuelle Python-Umgebung eingerichtet und mit einem Cate versehen hast, installierst du die Python-Abhängigkeiten mit dem Befehl pip.

Führe den folgenden pip-Befehl aus, um die Python-Abhängigkeiten für den PowerDNS-Admin zu installieren.

pip install python-dotenv
pip install -r requirements.txt

Jetzt beginnt die Installation – Damit werden die Python-Abhängigkeiten installiert, die für den PowerDNS-Admin erforderlich sind und in der Datei„requirements.txt“ gespeichert sind.

python-Abhängigkeiten installieren

Nachdem du die Python-Abhängigkeiten installiert hast, kannst du den PowerDNS-Admin mit der MariaDB-Datenbank einrichten und konfigurieren.

PowerDNS-Admin mit der MariaDB-Datenbank konfigurieren

Nachdem du die Python-Abhängigkeiten installiert hast, richtest du nun den PowerDNS-Admin mit der MariaDB-Datenbank ein. Die Datenbankdetails für den PowerDNS-Admin werden die gleiche Datenbank sein wie der PowerDNS-Server.

Bearbeite nun die Datei„/opt/powerdns-admin/powerdnsadmin/default_config.py“ mit dem folgenden nano-Editor-Befehl.

nano /opt/powerdns-admin/powerdnsadmin/default_config.py

Ändere die Konfiguration wie unten angegeben.

SALT = 'RANDOM-GENERATED'
SECRET_KEY = 'RANDOM-GENERATED'
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 die Datei und beende den Editor, wenn du fertig bist.

Datenbankschema generieren und statische Dateien erstellen

Nachdem du die MariaDB-Datenbank auf PowerDNS-Admin konfiguriert hast, wirst du die Datenbank migrieren und statische Dateien für PowerDNS-Admin erstellen.

Führe zunächst den folgenden Befehl aus, um die Datenbank des PowerDNS-Admin zu migrieren. Dadurch wird ein neues Datenbankschema in die Datenbank eingefügt, die für den PowerDNS-Admin verwendet wird.

export FLASK_APP=powerdnsadmin/__init__.py
flask db upgrade

Unten siehst du die Ausgabe, die du erhältst, wenn die Datenbankmigration abgeschlossen ist.

Datenbank migrieren

Nachdem die Datenbankmigration abgeschlossen ist, führe den folgenden Befehl aus, um statische Dateien für den PowerDNS-Admin zu erzeugen.

yarn install --pure-lockfile
flask assets build

Unten siehst du die Installation einiger JavaScript-Abhängigkeiten über den Garn-Paketmanager und den Prozess der Erstellung statischer Dateien für den PowerDNS-Admin.

statische Dateien generieren

Wenn die statischen Dateien erstellt sind, führe den folgenden Befehl aus, um die virtuelle Python-Umgebung zu deaktivieren.

deactivate

An diesem Punkt hast du die grundlegende Installation von PowerDNS-Admin mit dem MariaDB-Datenbankserver abgeschlossen. Du kannst die PowerDNS-Admin Anwendung jetzt über die Kommandozeile starten, aber du kannst PowerDNS-Admin auch als Systemd-Dienst ausführen.

Einrichten des Systemd-Dienstes für PowerDNS-Admin

In diesem Schritt richtest du eine neue systemd-Dienstdatei für die PowerDNS-Admin-Anwendung ein. So kannst du PowerDNS-Admin einfach über den systemd-Befehl verwalten und warten. Außerdem wird dadurch die Konfiguration von PowerDNS-Admin vereinfacht.

Um zu beginnen, erstelle eine neue systemd-Dienstdatei „/etc/systemd/system/powerdns-admin.service“ mit dem folgenden nano-Editor-Befehl.

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

Füge die unten stehende Konfiguration in die Datei ein. Mit dieser Konfiguration führst du die PowerDNS-Admin-Anwendung über das gunicorn aus und läufst als Benutzer und Gruppe„pdns„. Außerdem wird PowerDNS-Admin mit der UNIX-Socket-Datei‚/run/powerdns-admin/socket‘ ausgeführt.

[Unit]
Description=PowerDNS-Admin
Requires=powerdns-admin.socket
After=network.target
[Service]
PIDFile=/run/powerdns-admin/pid
User=pdns
Group=pdns
WorkingDirectory=/opt/powerdns-admin
ExecStartPre=+mkdir -p /run/powerdns-admin/
ExecStartPre=+chown pdns:pdns -R /run/powerdns-admin/
ExecStart=/usr/local/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

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes erstellst du eine neue systemd-Socket-Datei für den PowerDNS-Admin„/etc/systemd/system/powerdns-admin.socket“ mit dem unten stehenden nano-Editor.

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

Füge die folgende Konfiguration in die Datei ein.

[Unit]
Description=PowerDNS-Admin socket

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

[Install]
WantedBy=sockets.target

Speichere die Datei und beende den Editor, wenn du fertig bist.

Erstelle nun eine neue Konfigurationsdatei „/etc/tmpfiles.d/powerdns-admin.conf“ mit dem unten stehenden nano-Editor-Befehl.

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

Füge die folgende Konfiguration in die Datei ein.

d /run/powerdns-admin 0755 pdns pdns -

Speichere die Datei und beende den Editor, wenn du fertig bist.

Nachdem du eine neue systemd-Dienstdatei und eine neue Konfiguration hinzugefügt hast, führe den folgenden Befehl aus, um den systemd-Manager neu zu laden und die neuen Dienstdateien auf systemd anzuwenden.

sudo systemctl daemon-reload

Starte und aktiviere nun den PowerDNS-Admin-Dienst mit dem folgenden systemctl-Befehl. Der PowerDNS-Admin sollte jetzt mit gunicorn laufen und die Socket-Datei öffnen, die im Verzeichnis„/run/powerdns-admin/“ verfügbar ist.

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

powerdns-admin als Dienst einrichten

Führe abschließend den folgenden Befehl aus, um den PowerDNS-Admin-Dienst zu überprüfen und sicherzustellen, dass der Dienst läuft.

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

Die folgende Ausgabe zeigt, dass der powerdns-admin.service und der powerdns-admin.socket laufen und beide aktiviert sind. Beide Dienste werden beim Start des Systems automatisch ausgeführt.

pdns-Dienste überprüfen

Installation von Nginx als Reverse Proxy für PowerDNS-Admin

In diesem Schritt richtest du Nginx als Reverse Proxy für den PowerDNS-Admin ein.

Führe den folgenden dnf-Befehl aus, um Nginx auf deinem Rocky Linux Server zu installieren. Wenn du dazu aufgefordert wirst, gibst du zur Bestätigung y ein und drückst ENTER, um fortzufahren.

sudo dnf install nginx

Als nächstes erstellst du mit dem folgenden nano-Editor einen neuen Nginx-Server-Block „/etc/nginx/conf.d/pdns.conf„.

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

Füge die folgende Konfiguration in die Datei ein und achte darauf, dass du den Domainnamen änderst. In diesem Beispiel wird die Domain ‚pdns.hwdomain.io‘ für den PowerDNS-Admin verwendet.

server {
        listen                  80;
        server_name             pdns.hwdomain.io;
        return 301 https://$http_host$request_uri;
}
server {
listen                  443 ssl http2;
server_name              pdns.hwdomain.io;
index                   index.html index.htm;
error_log               /var/log/nginx/error_powerdnsadmin.log error;
access_log              off;

ssl_certificate                 /etc/letsencrypt/live/pdns.hwdomain.io/fullchain.pem;
ssl_certificate_key             /etc/letsencrypt/live/pdns.hwdomain.io/privkey.pem;
#ssl_dhparam                     path_to_your_dhparam.pem;
ssl_prefer_server_ciphers       on;
ssl_ciphers                     'EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH';
ssl_session_cache               shared:SSL:10m;

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 $http_host;
proxy_set_header                X-Scheme $scheme;
proxy_set_header                X-Real-IP $remote_addr;
proxy_set_header                X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header                X-Forwarded-Proto $scheme;
proxy_headers_hash_bucket_size  64;

location ~ ^/static/  {
include         mime.types;
root            /opt/powerdns-admin/powerdnsadmin;
location        ~* \.(jpg|jpeg|png|gif)$ { expires 365d; }
location        ~* ^.+.(css|js)$ { expires 7d; }
}

location ~ ^/upload/  {
include         mime.types;
root            /opt/powerdns-admin;
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          http:// $scheme://;
}
}

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes führst du den folgenden Befehl aus, um die Nginx-Konfiguration zu überprüfen und sicherzustellen, dass die Konfiguration korrekt ist. Du solltest die folgende Meldung sehen: „Syntax ok – Test erfolgreich„.

sudo nginx -t

Führe nun den folgenden systemctl-Befehl aus, um den Nginx-Dienst zu starten und zu aktivieren.

sudo systemctl start nginx
sudo systemctl enable nginx

nginx-Einrichtung

Überprüfe abschließend den Nginx-Dienst mit dem folgenden Befehl, um sicherzustellen, dass der Dienst läuft.

sudo systemctl status nginx

Du solltest die Ausgabe sehen, dass der Nginx-Dienst läuft und aktiviert ist. Damit wird der Nginx-Dienst beim Systemstart automatisch ausgeführt.

nginx prüfen

Zugriff auf die PowerDNS-Admin Installation

Öffne den Webbrowser und rufe den Domainnamen deiner PowerDNS-Admin Installation auf (z.B.: https://pdns.hwdomain.io). Du solltest die PowerDNS-Admin Anmeldeseite erhalten.

Klicke auf den Link„Create an account„, um einen neuen Administrator-Benutzer für PowerDNS-Admin einzurichten.

pdns Konto erstellen

Gib nun die Daten des neuen Benutzers, deine E-Mail-Adresse und dein Passwort ein. Klicke dann zur Bestätigung auf„Registrieren„.

Admin-Benutzer einrichten

Nachdem der Administrator-Benutzer erstellt wurde, wirst du wieder auf die PowerDNS-Admin Anmeldeseite umgeleitet. Melde dich mit deinem neuen Benutzer admin und deinem Passwort an und klicke dann auf„Anmelden„.

pdns admin Anmeldung

Du solltest nun das PowerDNS-Admin Dashboard erhalten. Der PowerDNS-Admin läuft, ist aber noch nicht mit dem PowerDNS-Server verbunden.

Um den PowerDNS-Server mit PowerDNS-Admin einzurichten, musst du den API-Schlüssel, den du über den PowerDNS-Server konfiguriert hast, zum PowerDNS-Admin hinzufügen.

Gib die API-Daten des PowerDNS-Servers im Abschnitt„PDNS-Einstellungen“ ein und klicke auf„Aktualisieren„.

Feuer einstellen

Wenn PowerDNS-Admin und der PowerDNS-Server über die API verbunden sind, sollte dein Dashboard wie der folgende Screenshot aussehen.

pdnsadmin Dashboard

Von hier aus kannst du jetzt ganz einfach neue DNS-Datensätze hinzufügen oder bestehende DNS-Datensätze über das PowerDNS-Admin Dashboard ändern.

Fazit

In dieser Anleitung hast du gelernt, wie du einen PowerDNS-Server mit MySQL/MariaDB-Datenbank auf einem Rocky-Linux-Server installierst. Außerdem hast du gelernt, wie du die MariaDB-Datenbank auf Rocky Linux einrichtest. Schließlich hast du gelernt, wie du den PowerDNS-Admin installierst und konfigurierst, der als webbasiertes Verwaltungstool für den PowerDNS-Server verwendet wird. Der PowerDNS-Admin läuft mit Nginx als Reverse Proxy und MariaDB-Datenbank-Backend.

Wenn der PowerDNS-Server und PowerDNS-Admin laufen, kannst du deinen DNS-Server über das Web-Administrations-Dashboard verwalten. Du kannst DNS-Datensätze über das PowerDNS-Admin Administrations-Dashboard hinzufügen, bearbeiten oder löschen.

Das könnte dich auch interessieren …