Instale PowerDNS en Ubuntu 18.04, 20.04 y 22.04

Introducción

PowerDNS es una solución de servidor DNS de código abierto que ayuda a resolver los espacios de nombres. PowerDNS admite alta disponibilidad, redundancia de datos y varios backends, lo que la convierte en una solución flexible y sólida.

Esta guía muestra cómo instalar PowerDNS y la interfaz de administración de PowerDNS en Ubuntu.

Requisitos previos

• Acceso a la terminal.
• Acceso al usuario root.
• Un editor de texto, como nano.
• Un navegador web para acceder a PowerDNS Admin.

¿Por qué usar PowerDNS?

PowerDNS proporciona dos soluciones de servidor de nombres:

• El servidor autorizado , que utiliza la base de datos para resolver consultas sobre dominios.
• El Recursor , que consulta con otros servidores autorizados para resolver consultas.

Otros servidores de nombres combinan las dos funciones automáticamente. PowerDNS los ofrece por separado y permite la combinación perfecta de las dos soluciones para una configuración modular.

Además, PowerDNS es de código abierto, funciona igual de bien para volúmenes de consultas grandes y pequeños y ofrece muchas posibilidades para soluciones de back-end.

Instalación de PowerDNS en Ubuntu 18.04, 20.04 y 22.04

Siga los pasos a continuación para instalar y configurar PowerDNS con el servidor MariaDB como una base de datos de back-end. Además, los pasos guían a los usuarios a través de la configuración de la API y la interfaz web de administración de PowerDNS.

Paso 1:Instalar y configurar el servidor MariaDB

Para instalar y configurar MariaDB, haga lo siguiente:

1. Actualice y mejore los paquetes del sistema:

sudo apt update && sudo apt upgrade

2. Instale el servidor y el cliente de MariaDB con:

sudo apt install mariadb-server mariadb-client

Nota: Otros posibles servidores de bases de datos incluyen PostgreSQL, MySQL y otras bases de datos relacionales.

Espere a que finalice la instalación antes de continuar.

3. Conéctese a MariaDB con:

sudo mysql

El terminal se conecta a una sesión de base de datos.

4. Cree una base de datos para el servidor de nombres PowerDNS:

create database pda;

Nota: Si usa un nombre de base de datos diferente, cambie todos los comandos correspondientes en consecuencia.

5. Otorgue todos los privilegios al pda usuario y proporcione la contraseña de usuario:

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

6. Conéctese a la base de datos:

use pda;

7. Use las siguientes consultas SQL para crear tablas para el pda base de datos:

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. Confirme que las tablas se hayan creado con:

show tables;

El resultado enumera las tablas disponibles.

9. Salga de la conexión a la base de datos:

exit;

El comando devuelve la sesión al terminal.

Paso 2:Instalar PowerDNS

Para instalar PowerDNS en Ubuntu, haga lo siguiente:

1. Cambie al usuario root:

sudo su -

La sesión de terminal cambia al usuario raíz.

Nota: Más información sobre la diferencia entre sudo y su.

2. El systemd-resolved El servicio proporciona las resoluciones de nombres a las aplicaciones locales. PowerDNS utiliza su propio servicio para la resolución de nombres.

Deshabilitar el systemd-resolved servicio con:

systemctl disable --now systemd-resolved

La salida confirma la eliminación del servicio.

3. Elimine el archivo de configuración del servicio del sistema con:

rm -rf /etc/resolv.conf

4. Cree el nuevo resolv.conf archivo:

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

Agregar el servidor de nombres de Google garantiza la resolución de DNS.

5. Instale los paquetes back-end de la base de datos y el servidor PowerDNS con:

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

Espere a que se complete la instalación antes de continuar.

Paso 3:Configurar PowerDNS

Configure el archivo PowerDNS local para conectarse a la base de datos:

1. Abra el archivo de configuración para editarlo:

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

2. Agregue la siguiente información al archivo:

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

Intercambie el nombre de la base de datos, el usuario y la contraseña con los parámetros correctos si usa otros diferentes. Guarde y cierre el archivo.

3. Cambie los permisos del archivo:

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

4. Detenga los pdns servicio:

systemctl stop pdns

5. Pruebe la conexión a la base de datos:

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

El resultado muestra una conexión exitosa. Presiona CTRL +C para salir de la prueba.

6. Inicie el servicio:

systemctl start pdns

7. Verifique la conexión con el comando ss:

ss -alnp4 | grep pdns

Verifica el puerto TCP/UDP 53 está abierto y en LISTEN /UCONN estado.

Paso 4:Instale las dependencias de administración de PowerDNS

El administrador de PowerDNS ayuda a administrar PowerDNS a través de una interfaz web. Para instalar el panel localmente, haga lo siguiente:

1. Instale el paquete de desarrollo de Python:

apt install python3-dev

2. Instalar dependencias:

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. Obtenga la configuración de Node.js:

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

4. Instale Node.js con:

apt install -y nodejs

5. A continuación, instale el administrador de paquetes Yarn. Obtenga la clave pública de Yarn y agréguela a apt :

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

Yarn ayuda a construir los archivos de recursos.

6. Agrega Yarn a la lista de fuentes:

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

7. Actualice la lista de fuentes aptas:

apt update -y

8. Instalar hilo con:

apt install yarn -y

9. Clone el repositorio PowerDNS Admin Git en /opt/web/powerdns-admin :

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

Si utiliza un directorio diferente, intercambie el directorio de destino en el comando y en todas las apariciones posteriores.

10. Navegue hasta el directorio Git clonado:

cd /opt/web/powerdns-admin

11. Cree un entorno virtual de Python:

python3 -mvenv ./venv

12. Activa el entorno virtual con:

source ./venv/bin/activate

13. Actualice pip a la última versión:

pip install --upgrade pip

El administrador de paquetes pip ayuda a instalar requisitos adicionales de Python.

14. Instale los requisitos desde requirements.txt archivo:

pip install -r requirements.txt

Después de instalar todos los requisitos, PowerDNS Admin requiere una configuración adicional antes de ejecutarse.

Paso 5:configurar y ejecutar PowerDNS Admin

Para configurar e iniciar PowerDNS Admin en una instancia local, haga lo siguiente:

1. Utilice el comando cp para copiar el ejemplo desarrollo.py archivo de Python a production.py :

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

2. Abra el producción.py archivo para editar:

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

3. Edite las siguientes líneas:

#import urllib.parse

SECRET_KEY = 'e951e5a1f4b94151b360f47edf596dd2'

SQLA_DB_PASSWORD = 'changeme'

4. Descomente la importación de la biblioteca, proporcione una clave secreta generada aleatoriamente y proporcione la contraseña de la base de datos correcta.

import urllib.parse

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

SQLA_DB_PASSWORD = 'YOUR_PASSWORD_HERE'

Nota: Genere una clave aleatoria usando Python:

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

Copie y pegue el resultado en el SECRET_KEY valor.

Guarde y cierre el archivo.

5. Exporte la variable de configuración de la aplicación de producción:

export FLASK_CONF=../configs/production.py

6. Exporte la variable de aplicación del matraz:

export FLASK_APP=powerdnsadmin/__init__.py

7. Actualice el esquema de la base de datos:

flask db upgrade

8. Instale las dependencias del proyecto:

yarn install --pure-lockfile

9. Cree activos de la aplicación del matraz:

flask assets build

Espere a que se complete la compilación.

10. Ejecute la aplicación con:

./run.py

Deje la aplicación ejecutándose.

11. La aplicación actualmente se ejecuta en localhost en el puerto 9191 . Visite la siguiente dirección:

http://localhost:9191

Se muestra la pantalla de inicio de sesión para PowerDNS Admin. Actualmente, no hay usuarios, y el primer usuario que registre será la cuenta de administrador.

12. En la terminal, salga del entorno virtual y cierre la sesión del usuario raíz con:

exit

El terminal vuelve a su estado normal.

Paso 6:Crear el servicio de administración de PowerDNS

Configure el administrador de PowerDNS para que se ejecute al inicio:

1. Cree un archivo de servicio systemd para PowerDNS Admin:

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

2. Agregue los siguientes contenidos:

[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. Cree un archivo de unidad:

sudo systemctl edit --force powerdns-admin.service

4. Agregue lo siguiente:

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

5. Cree un archivo de socket:

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

6. Inserte la siguiente información:

[Unit]
Description=PowerDNS-Admin socket

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

[Install]
WantedBy=sockets.target

7. Cree un archivo de entorno:

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

8. Agregue la siguiente información:

d /run/powerdns-admin 0755 pdns pdns -

9. Vuelva a cargar el demonio:

sudo systemctl daemon-reload

10. Inicie y habilite el servicio y el socket:

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

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

11. Verifique el estado con:

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

Los servicios se muestran como ejecutándose sin ningún error.

Paso 7:Instalar y configurar Nginx

Para configurar PowerDNS Admin para que se ejecute en Nginx, haga lo siguiente:

1. Instale Nginx con:

sudo apt install nginx -y

2. Edite el archivo de configuración de Nginx:

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

3. Agregue la siguiente información:

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 usa un nombre de servidor diferente, cambie localhost a la dirección de su servidor.

4. Confirme que el archivo no tiene errores de sintaxis:

nginx -t

5. Cambiar la propiedad de powerdns-admin a www-data :

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

6. Reinicie el servicio Nginx:

sudo systemctl restart nginx

7. Acceda a la página de administración de PowerDNS a través del navegador:

localhost

Si se vincula a una dirección diferente, use la dirección provista en el archivo de configuración de Nginx.

Paso 8:configurar la API de PowerDNS

Para configurar la API de PowerDNS, haga lo siguiente:

1. Inicie sesión en PowerDNS Admin a través del navegador. Si se ejecuta por primera vez, primero cree un nuevo usuario. El primer usuario es automáticamente el administrador.

2. Abra la clave API pestaña s en el menú de la izquierda.

3. Haga clic en Agregar clave+ botón.

4. El rol el campo predeterminado es Administrador usuario. Agregue una descripción opcional para la clave.

5. Haga clic en Crear clave para generar una clave API.

6. Una ventana emergente imprime la clave. Copiar la clave y presiona Confirmar para continuar.

7. Navegue hasta el Panel de control página.

8. Introduzca el dominio y la clave API. Guarde los cambios.

9. Habilite la API en la configuración de PowerDNS. Abra el archivo de configuración en la terminal:

nano /etc/powerdns/pdns.conf

10. Descomente y cambie las siguientes líneas:

api=yes
api-key=yoursecretekey
webserver=yes

11. Guarde los cambios y cierre nano. La API está configurada y lista para usar.

Conclusión

Después de seguir los pasos de esta guía, configuró PowerDNS, la interfaz web de administración de PowerDNS en Nginx, y conectó la API de PowerDNS.

A continuación, obtenga información sobre los diferentes tipos de registros de DNS o las prácticas recomendadas de seguridad de DNS.