GNU/Linux >> Tutoriels Linux >  >> Linux

Installez PowerDNS sur Ubuntu 18.04, 20.04 et 22.04

Présentation

PowerDNS est une solution de serveur DNS open source qui aide à résoudre les espaces de noms. PowerDNS prend en charge la haute disponibilité, la redondance des données et divers backends, ce qui en fait une solution flexible et robuste.

Ce guide montre comment installer PowerDNS et l'interface d'administration de PowerDNS sur Ubuntu.

Prérequis

  • Accès au terminal.
  • Accès à l'utilisateur root.
  • Un éditeur de texte, tel que nano.
  • Un navigateur Web pour accéder à PowerDNS Admin.

Pourquoi utiliser PowerDNS ?

PowerDNS fournit deux solutions de serveur de noms :

  • Le serveur faisant autorité , qui utilise la base de données pour résoudre les requêtes sur les domaines.
  • Le récurseur , qui consulte d'autres serveurs faisant autorité pour résoudre les requêtes.

D'autres serveurs de noms combinent automatiquement les deux fonctions. PowerDNS les propose séparément et permet de combiner les deux solutions de manière transparente pour une configuration modulaire.

De plus, PowerDNS est open source, fonctionne aussi bien pour les petits que pour les gros volumes de requêtes et offre de nombreuses possibilités pour les solutions backend.

Installation de PowerDNS sur Ubuntu 18.04, 20.04 et 22.04

Suivez les étapes ci-dessous pour installer et configurer PowerDNS avec le serveur MariaDB en tant que base de données principale. De plus, les étapes guident les utilisateurs tout au long de la configuration de l'interface Web et de l'API PowerDNS Admin.

Étape 1 :Installer et configurer le serveur MariaDB

Pour installer et configurer MariaDB, procédez comme suit :

1. Mettre à jour et mettre à niveau les packages système :

sudo apt update && sudo apt upgrade

2. Installez le serveur et le client MariaDB avec :

sudo apt install mariadb-server mariadb-client

Remarque : Les autres serveurs de base de données possibles incluent PostgreSQL, MySQL et d'autres bases de données relationnelles.

Attendez la fin de l'installation avant de continuer.

3. Connectez-vous à MariaDB avec :

sudo mysql

Le terminal se connecte à une session de base de données.

4. Créez une base de données pour le serveur de noms PowerDNS :

create database pda;

Remarque : Si vous utilisez un nom de base de données différent, modifiez toutes les commandes en conséquence.

5. Accordez tous les privilèges au pda utilisateur et indiquez le mot de passe utilisateur :

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

6. Connectez-vous à la base de données :

use pda;

7. Utilisez les requêtes SQL suivantes pour créer des tables pour le pda base de données :

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. Confirmez que les tables ont été créées avec :

show tables;

La sortie répertorie les tables disponibles.

9. Quittez la connexion à la base de données :

exit;

La commande renvoie la session au terminal.

Étape 2 :Installez PowerDNS

Pour installer PowerDNS sur Ubuntu, procédez comme suit :

1. Basculez vers l'utilisateur root :

sudo su -

La session de terminal passe à l'utilisateur root.

Remarque : Découvrez la différence entre sudo et su.

2. Le systemd-resolved Le service fournit les résolutions de noms aux applications locales. PowerDNS utilise son propre service pour les résolutions de noms.

Désactiver le systemd-resolved service avec :

systemctl disable --now systemd-resolved

La sortie confirme la suppression du service.

3. Supprimez le fichier de configuration du service système avec :

rm -rf /etc/resolv.conf

4. Créez le nouveau resolv.conf fichier :

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

L'ajout du serveur de noms Google garantit la résolution DNS.

5. Installez les packages de serveur et de base de données PowerDNS avec :

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

Attendez que l'installation soit terminée avant de continuer.

Étape 3 :Configurer PowerDNS

Configurez le fichier PowerDNS local pour vous connecter à la base de données :

1. Ouvrez le fichier de configuration pour le modifier :

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

2. Ajoutez les informations suivantes au fichier :

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

Échangez le nom, l'utilisateur et le mot de passe de la base de données avec les paramètres corrects si vous en utilisez d'autres. Enregistrez et fermez le fichier.

3. Modifiez les autorisations du fichier :

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

4. Arrêtez les pdns service :

systemctl stop pdns

5. Testez la connexion à la base de données :

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

La sortie indique une connexion réussie. Appuyez sur CTRL +C pour quitter le test.

6. Démarrez le service :

systemctl start pdns

7. Vérifiez la connexion avec la commande ss :

ss -alnp4 | grep pdns

Vérifiez le port TCP/UDP 53 est ouvert et en LISTEN /UCONN état.

Étape 4 :Installer les dépendances d'administration PowerDNS

L'administrateur PowerDNS permet de gérer PowerDNS via une interface Web. Pour installer le tableau de bord localement, procédez comme suit :

1. Installez le package de développement Python :

apt install python3-dev

2. Installez les dépendances :

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. Récupérez la configuration de Node.js :

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

4. Installez Node.js avec :

apt install -y nodejs

5. Ensuite, installez le gestionnaire de packages Yarn. Récupérez la clé publique Yarn et ajoutez-la à apt :

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

Yarn aide à créer les fichiers d'actifs.

6. Ajoutez Yarn à la liste des sources :

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

7. Mettez à jour la liste des sources d'apt :

apt update -y

8. Installez Yarn avec :

apt install yarn -y

9. Clonez le référentiel PowerDNS Admin Git sur /opt/web/powerdns-admin :

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

Si vous utilisez un répertoire différent, échangez le répertoire de destination dans la commande et dans toutes les apparitions ultérieures.

10. Accédez au répertoire Git cloné :

cd /opt/web/powerdns-admin

11. Créez un environnement virtuel Python :

python3 -mvenv ./venv

12. Activez l'environnement virtuel avec :

source ./venv/bin/activate

13. Mettez à niveau pip vers la dernière version :

pip install --upgrade pip

Le gestionnaire de packages pip permet d'installer des exigences Python supplémentaires.

14. Installez les exigences à partir du requirements.txt fichier :

pip install -r requirements.txt

Après avoir installé toutes les exigences, l'administrateur PowerDNS nécessite une configuration supplémentaire avant de s'exécuter.

Étape 5 :Configurer et exécuter PowerDNS Admin

Pour configurer et démarrer PowerDNS Admin sur une instance locale, procédez comme suit :

1. Utilisez la commande cp pour copier l'exemple development.py Fichier Python vers production.py :

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

2. Ouvrez le production.py fichier à éditer :

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

3. Modifiez les lignes suivantes :

#import urllib.parse

SECRET_KEY = 'e951e5a1f4b94151b360f47edf596dd2'

SQLA_DB_PASSWORD = 'changeme'

4. Décommentez l'importation de la bibliothèque, fournissez une clé secrète générée de manière aléatoire et fournissez le mot de passe correct de la base de données.

import urllib.parse

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

SQLA_DB_PASSWORD = 'YOUR_PASSWORD_HERE'

Remarque : Générez une clé aléatoire à l'aide de Python :

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

Copiez et collez la sortie dans le SECRET_KEY valeur.

Enregistrez et fermez le fichier.

5. Exportez la variable de configuration de l'application de production :

export FLASK_CONF=../configs/production.py

6. Exportez la variable d'application flask :

export FLASK_APP=powerdnsadmin/__init__.py

7. Mettez à niveau le schéma de la base :

flask db upgrade

8. Installez les dépendances du projet :

yarn install --pure-lockfile

9. Créez des ressources d'application flask :

flask assets build

Attendez que la construction soit terminée.

10. Exécutez l'application avec :

./run.py

Laissez l'application en cours d'exécution.

11. L'application s'exécute actuellement sur localhost sur le port 9191 . Rendez-vous à l'adresse suivante :

http://localhost:9191

L'écran de connexion pour PowerDNS Admin s'affiche. Actuellement, il n'y a pas d'utilisateurs, et le premier utilisateur que vous enregistrez sera le compte administrateur.

12. Dans le terminal, quittez l'environnement virtuel et déconnectez-vous de l'utilisateur root avec :

exit

Le terminal revient à un état normal.

Étape 6 :Créer un service d'administration PowerDNS

Configurez PowerDNS Admin pour qu'il s'exécute au démarrage :

1. Créez un fichier de service systemd pour l'administrateur PowerDNS :

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

2. Ajoutez le contenu suivant :

[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. Créez un fichier unité :

sudo systemctl edit --force powerdns-admin.service

4. Ajoutez ce qui suit :

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

5. Créez un fichier socket :

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

6. Insérez les informations suivantes :

[Unit]
Description=PowerDNS-Admin socket

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

[Install]
WantedBy=sockets.target

7. Créez un fichier d'environnement :

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

8. Ajoutez les informations suivantes :

d /run/powerdns-admin 0755 pdns pdns -

9. Rechargez le démon :

sudo systemctl daemon-reload

10. Démarrez et activez le service et le socket :

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

11. Vérifiez l'état avec :

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

Les services s'affichent comme s'exécutant sans aucune erreur.

Étape 7 :Installer et configurer Nginx

Pour configurer PowerDNS Admin pour qu'il s'exécute sur Nginx, procédez comme suit :

1. Installez Nginx avec :

sudo apt install nginx -y

2. Modifiez le fichier de configuration Nginx :

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

3. Ajoutez les informations suivantes :

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

}

Si vous utilisez un nom de serveur différent, modifiez localhost à l'adresse de votre serveur.

4. Vérifiez que le fichier ne contient aucune erreur de syntaxe :

nginx -t

5. Changer le propriétaire de powerdns-admin à www-data :

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

6. Redémarrez le service Nginx :

sudo systemctl restart nginx

7. Accédez à la page d'administration de PowerDNS via le navigateur :

localhost

Si vous créez un lien vers une adresse différente, utilisez l'adresse fournie dans le fichier de configuration Nginx.

Étape 8 :Configurer l'API PowerDNS

Pour configurer l'API PowerDNS, procédez comme suit :

1. Connectez-vous à PowerDNS Admin via le navigateur. Si vous exécutez pour la première fois, créez d'abord un nouvel utilisateur. Le premier utilisateur est automatiquement l'administrateur.

2. Ouvrez la clé API s dans le menu de gauche.

3. Cliquez sur Ajouter une clé+ bouton.

4. Le rôle le champ par défaut est Administrateur utilisateur. Ajoutez une description facultative pour la clé.

5. Cliquez sur Créer une clé pour générer une clé API.

6. Une fenêtre contextuelle imprime la clé. Copier la clé et appuyez sur Confirmer pour continuer.

7. Accédez au tableau de bord page.

8. Entrez le domaine et la clé API. Enregistrez les modifications.

9. Activez l'API dans la configuration PowerDNS. Ouvrez le fichier de configuration dans le terminal :

nano /etc/powerdns/pdns.conf

10. Décommentez et modifiez les lignes suivantes :

api=yes
api-key=yoursecretekey
webserver=yes

11. Enregistrez les modifications et fermez nano. L'API est configurée et prête à être utilisée.

Conclusion

Après avoir suivi les étapes de ce guide, vous avez configuré PowerDNS, l'interface Web d'administration PowerDNS sur Nginx, et connecté l'API PowerDNS.

Ensuite, découvrez les différents types d'enregistrements DNS ou les meilleures pratiques de sécurité DNS.


Linux

  1. Installer Podman sur Ubuntu

  2. Choses à installer sur Ubuntu 20.04

  3. Installer GitLab sur Ubuntu 18.04

  4. Installer Nginx sur Ubuntu

  5. Installer Qt sur Ubuntu

Installer Redis sur Ubuntu

Installer Jenkins sur Ubuntu 18.04

Installer Elasticsearch sur Ubuntu 18.04

Installer MongoDB sur Ubuntu 18.04

Comment installer PowerDNS et PowerAdmin sur CentOS 8

Comment configurer PowerDNS sur Ubuntu Linux