Automatizacion DNS con Bash: Scripts para Gestionar tus Dominios

Si administras mas de dos dominios, ya sabes lo tedioso que es entrar a un panel web, hacer clic en Zonas DNS, buscar el registro, editarlo, guardar y esperar la propagacion. Multiplica eso por diez dominios y tendras una hora perdida en tareas repetitivas. La automatizacion DNS con Bash elimina ese cuello de botella: un solo script puede actualizar docenas de registros en segundos, con logging automatico y sin riesgo de olvidar un cambio.

Hay escenarios donde la automatizacion no es un lujo sino una necesidad operativa. Si tu IP publica cambia y necesitas actualizar el registro A de tu servidor, cada minuto de retraso es tiempo de caida. Si migras un servicio entre servidores y necesitas apuntar varios subdominios a la nueva direccion, hacerlo manualmente es propenso a errores. Y si gestionas dominios .cl a traves de la API de NIC Chile, la automatizacion es la unica forma eficiente de mantener los registros sincronizados.

En este articulo vas a encontrar scripts Bash funcionales que puedes copiar, pegar y ejecutar en tu servidor. Pero antes de lanzarte a automatizar todo, es fundamental entender una distincion que muchos tutoriales ignoran: no es lo mismo automatizar DNS como cliente de hosting que como administrador root. Vamos a cubrir ambos niveles, con las herramientas y precauciones que cada uno requiere.

Interfaces DNS: Panel, API y CLI — Cuando Usar Cada Una

Existen tres formas principales de interactuar con tus registros DNS, y cada una tiene su lugar segun tu nivel de acceso y el tipo de cambio que necesitas hacer.

Panel web (cPanel, Plesk, DirectAdmin): Es la interfaz grafica que tu proveedor de hosting te entrega. Ideal para cambios puntuales — agregar un subdominio, modificar un registro MX, crear un registro TXT para verificacion. Si tienes hosting compartido en Elevocloud, el panel cPanel es tu herramienta principal para cambios DNS. No necesitas acceso SSH ni conocimientos de linea de comandos. La desventaja: es manual, lento para cambios masivos, y depende de la interfaz del proveedor.

API del proveedor: Algunos registradores y proveedores de hosting ofrecen APIs REST para gestionar DNS programaticamente. NIC Chile tiene su propia API para dominios .cl, y proveedores como Cloudflare ofrecen APIs completas. Esta es la capa correcta para automatizacion desde un cliente: tu script envia una peticion HTTP y el cambio se aplica sin tocar archivos de zona directamente. Es seguro, auditable y funciona desde cualquier servidor con curl.

CLI directo sobre BIND/named: Esta es la opcion de nivel root. Si tienes un VPS o servidor dedicado con Elevocloud y acceso SSH como root, puedes editar directamente los archivos de zona en /var/named/ y recargar BIND con rndc reload. Es la forma mas poderosa — y mas peligrosa — de administrar DNS. Un error de sintaxis en un archivo de zona puede romper la resolucion DNS de todos tus dominios. Solo debe usarse cuando tienes control total del servidor y entiendes las consecuencias.

La regla practica: si estas en hosting compartido, usa el panel o la API. Si tienes VPS/dedicado y sabes lo que haces, el CLI directo te da control absoluto — pero con gran poder viene gran responsabilidad.

Scripts Bash para Manipular Registros DNS

Antes de entrar a los scripts, una aclaracion crucial: los scripts que manejan archivos de zona BIND directamente (/var/named/) requieren acceso root y solo funcionan en servidores VPS o dedicados donde tú controlas el servicio DNS. Si tienes hosting compartido, estos scripts no aplican — en su lugar, usa la API de tu proveedor o el panel cPanel.

Para los scripts que siguen, asumimos que estas en un servidor Linux con Bash, tienes acceso root, y BIND esta configurado. Todos los scripts incluyen logging y validacion basica. Copia, adapta los valores a tu entorno, y prueba en un dominio de test antes de aplicar en produccion.

Script: Agregar un Registro A Automaticamente

Este script agrega un registro A a la zona DNS de un dominio, recarga BIND y registra el cambio en un log de auditoria. Es util cuando necesitas crear subdominios rapidamente o cuando un servicio nuevo necesita su propia entrada DNS.

#!/bin/bash
# add_dns_a.sh — Agrega un registro A a una zona BIND
# USO: ./add_dns_a.sh ejemplo.cl subdominio 192.168.1.100
# REQUIERE: acceso root, BIND configurado

set -euo pipefail

DOMAIN="$1"
SUBDOMAIN="$2"
IP="$3"
ZONE_DIR="/var/named"
ZONE_FILE="${ZONE_DIR}/${DOMAIN}.db"
LOG_FILE="/var/log/dns_changes.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# Validar argumentos
if [[ $# -ne 3 ]]; then
  echo "Uso: $0 dominio subdominio IP"
  exit 1
fi

# Verificar que la zona existe
if [[ ! -f "$ZONE_FILE" ]]; then
  echo "ERROR: Zona $ZONE_FILE no encontrada" >&2
  exit 1
fi

# Agregar registro A
RECORD="${SUBDOMAIN}   IN  A       ${IP}"
echo "$RECORD" >> "$ZONE_FILE"

# Incrementar serial
sed -i "s/\([0-9]\{10\}\)/$(date +%s)/1" "$ZONE_FILE"

# Recargar BIND
rndc reload "$DOMAIN" 2>/dev/null || systemctl reload named

# Log de auditoria
echo "[${TIMESTAMP}] ADD_A ${SUBDOMAIN}.${DOMAIN} -> ${IP}" >> "$LOG_FILE"
echo "Registro A agregado: ${SUBDOMAIN}.${DOMAIN} -> ${IP}"

Antes de ejecutar, verifica que el serial del archivo de zona use formato epoch. Siempre prueba con dig +short subdominio.dominio.cl despues del cambio para confirmar que propago correctamente.

Script: Listar Todos los Registros de un Dominio

No siempre necesitas editar — a veces solo necesitas ver que registros tiene un dominio. Este script extrae y formatea los registros de una zona BIND y ademas los verifica contra la resolucion DNS real usando dig, para detectar discrepancias entre lo que esta configurado y lo que responde internet.

#!/bin/bash
# list_dns_records.sh — Lista registros DNS de una zona
# USO: ./list_dns_records.sh ejemplo.cl

set -euo pipefail

DOMAIN="$1"
ZONE_DIR="/var/named"
ZONE_FILE="${ZONE_DIR}/${DOMAIN}.db"

if [[ ! -f "$ZONE_FILE" ]]; then
  echo "Zona no encontrada: $ZONE_FILE" >&2
  exit 1
fi

echo "=== Registros configurados en $ZONE_FILE ==="
grep -v '^;' "$ZONE_FILE" | grep -v '^$' | column -t

echo ""
echo "=== Resolucion DNS actual (dig) ==="
echo "A     : $(dig +short "$DOMAIN" A)"
echo "AAAA  : $(dig +short "$DOMAIN" AAAA)"
echo "MX    : $(dig +short "$DOMAIN" MX)"
echo "NS    : $(dig +short "$DOMAIN" NS)"
echo "TXT   : $(dig +short "$DOMAIN" TXT)"
echo "SOA   : $(dig +short "$DOMAIN" SOA)"

La combinacion de leer el archivo de zona y consultar con dig te da una vision completa. Si el archivo dice una IP y dig devuelve otra, tienes un problema de propagacion pendiente o de zona mal configurada.

Script: Actualizar un Registro DNS Existente

Modificar un registro existente en BIND requiere reemplazar la linea vieja con la nueva. Este script busca el registro por nombre y tipo, lo reemplaza, incrementa el serial y recarga BIND.

#!/bin/bash
# update_dns_record.sh — Actualiza un registro DNS existente
# USO: ./update_dns_record.sh ejemplo.cl subdominio A 192.168.1.200

set -euo pipefail

DOMAIN="$1"
NAME="$2"
TYPE="$3"
VALUE="$4"
ZONE_FILE="/var/named/${DOMAIN}.db"
LOG_FILE="/var/log/dns_changes.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

if [[ ! -f "$ZONE_FILE" ]]; then
  echo "Zona no encontrada" >&2; exit 1
fi

# Buscar linea existente del registro
OLD_LINE=$(grep -E "^${NAME}[[:space:]]+IN[[:space:]]+${TYPE}" "$ZONE_FILE")
if [[ -z "$OLD_LINE" ]]; then
  echo "No se encontro registro ${TYPE} para ${NAME}" >&2
  exit 1
fi

# Reemplazar en archivo
sed -i "s|${OLD_LINE}|${NAME}   IN  ${TYPE}       ${VALUE}|" "$ZONE_FILE"

# Incrementar serial
sed -i "s/\([0-9]\{10\}\)/$(date +%s)/1" "$ZONE_FILE"

# Recargar BIND
rndc reload "$DOMAIN" 2>/dev/null || systemctl reload named

echo "[${TIMESTAMP}] UPDATE ${TYPE} ${NAME}.${DOMAIN} -> ${VALUE}" >> "$LOG_FILE"
echo "Registro actualizado: ${NAME}.${DOMAIN} ${TYPE} -> ${VALUE}"

Este script hace un reemplazo directo — no maneja registros con multiples lineas para el mismo nombre. Para esos casos mas complejos, necesitas un parser de zona mas sofisticado.

Script: Respaldar Configuracion DNS a JSON

Antes de hacer cualquier cambio masivo, es inteligente respaldar el estado actual de tus zonas DNS. Este script exporta todas las zonas de BIND a archivos JSON separados, uno por dominio, con marca de tiempo.

#!/bin/bash
# backup_dns_zones.sh — Respaldar zonas DNS a JSON
# USO: ./backup_dns_zones.sh

BACKUP_DIR="/opt/dns-backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
mkdir -p "${BACKUP_DIR}/${TIMESTAMP}"

for zone_file in /var/named/*.db; do
  DOMAIN=$(basename "$zone_file" .db)

  # Convertir zona a JSON con jq
  {
    echo "{\"domain\": \"$DOMAIN\", \"records\": ["
    grep -v '^;' "$zone_file" | grep -v '^$' | awk '{
      split($1, name, ".")
      printf "  {\"name\": \"%s\", \"type\": \"%s\", \"value\": \"%s\"}", $1, $4, $5
    }' | jq -s '.'
    echo "], \"backup_date\": \"$TIMESTAMP\"}"
  } > "${BACKUP_DIR}/${TIMESTAMP}/${DOMAIN}.json"

  echo "Respaldado: $DOMAIN -> ${BACKUP_DIR}/${TIMESTAMP}/${DOMAIN}.json"
done

echo "Backup completo: ${BACKUP_DIR}/${TIMESTAMP}/"

Este backup en JSON te permite comparar configuraciones antes y despues de un cambio, hacer rollback consultando el JSON y restaurando la zona, e importar a sistemas de gestion de configuracion como Ansible.

Dominios .cl: Como Funciona el DNS y Donde Automatizarlo

Para dominios .cl, es importante entender la arquitectura antes de automatizar: NIC Chile solo gestiona la delegacion de nameservers (NS records). Los registros DNS individuales (A, CNAME, MX, TXT) los administra tu proveedor de DNS primario, que puede ser tu hosting, Cloudflare, Route53 u otro.

NIC Chile no ofrece un servicio de DNS primario ni una API para editar registros A/CNAME/MX. Segun su propia documentacion, los detalles de DNS provienen del proveedor de hosting. Lo que puedes hacer via NIC Chile es cambiar a que nameservers apunta tu dominio .cl.

Donde Gestionar los Registros DNS de un .cl

Automatizacion via API de tu Proveedor de Hosting

Si tu hosting usa cPanel con WHM, puedes automatizar registros DNS via la API JSON de cPanel:

#!/bin/bash
# update_cpanel_dns.sh — Actualiza registro A via cPanel API
# USO: ./update_cpanel_dns.sh tudominio.cl 192.168.1.100

set -euo pipefail

DOMAIN="$1"
NEW_IP="$2"
CPANEL_USER="TU_USUARIO_CPANEL"
CPANEL_TOKEN="TU_API_TOKEN_CPANEL"
CPANEL_HOST="tu-servidor.elevocloud.com"

# Actualizar registro A via cPanel UAPI
curl -s \
  -H "Authorization: cpanel ${CPANEL_USER}:${CPANEL_TOKEN}" \
  "https://${CPANEL_HOST}:2083/execute/DNS/mass_edit_zone?zone=${DOMAIN}&serial=1&line1_type=A&line1_name=@&line1_address=${NEW_IP}&line1_ttl=300"

echo "Registro A actualizado: ${DOMAIN} -> ${NEW_IP}"

Guarda el token en una variable de entorno o archivo .env excluido del control de versiones, nunca directamente en el script.

Si usas Cloudflare como DNS primario (opcion comun para dominios .cl con mejor rendimiento), usa la API de Cloudflare en su lugar — tiene endpoints bien documentados para cada tipo de registro.

Automatizar con Cron: Cambios DNS Programados

Una vez que tienes scripts funcionales, el siguiente paso es programarlos con cron para que se ejecuten automaticamente. Casos de uso reales: actualizar el registro A si la IP publica cambia (util para servidores caseros con IP dinamica), sincronizar registros DNS entre servidores, o verificar la propagacion de cambios cada hora.

Ejemplo de crontab para verificar IP publica y actualizar DNS si cambio:

# Editar crontab
crontab -e

# Verificar IP publica cada 15 minutos y actualizar si cambio
*/15 * * * * /opt/scripts/check-and-update-dns.sh >> /var/log/dns_cron.log 2>&1

# Respaldar zonas DNS todos los dias a las 3am
0 3 * * * /opt/scripts/backup_dns_zones.sh >> /var/log/dns_backup.log 2>&1

Para scripts que detectan cambio de IP publica, el script base es:

#!/bin/bash
# check-ip-change.sh — Verifica si la IP publica cambio

NEW_IP=$(curl -s ifconfig.me)
STORED_IP=$(cat /var/cache/my-server-ip.txt 2>/dev/null)

if [[ "$NEW_IP" != "$STORED_IP" ]]; then
  echo "IP changed: $STORED_IP -> $NEW_IP"
  echo "$NEW_IP" > /var/cache/my-server-ip.txt
  # Aca llamas a tu script de update DNS
  /opt/scripts/update_dns_record.sh mi-dominio.cl @ A "$NEW_IP"
fi

Esta combinacion de cron + scripts es el fundamento de infrastructure as code para DNS.

dnsdiff: Comparar Configuraciones DNS Antes de Aplicar

Antes de aplicar un cambio grande a tus zonas DNS, es inteligente comparar la configuracion actual con la nueva. El comando diff entre dos respaldos JSON hace el trabajo.

# Comparar backup de hoy con el de ayer
diff /opt/dns-backups/20260715_030000/mi-dominio.cl.json \
     /opt/dns-backups/20260714_030000/mi-dominio.cl.json

Si el output esta vacio, no hay diferencias. Si hay diferencias, diff te muestra exactamente que registros cambiaron, cuales se agregaron y cuales desaparecieron. Esto es especialmente util cuando automatizas cambios: siempre puedes hacer un backup automatico antes de cada modificacion y comparar el estado antes/despues.

Tambien puedes usar dig para comparar la resolucion real de un dominio entre dos momentos:

echo "=== Ayer ===" && dig +short mi-dominio.cl A @8.8.8.8
echo "=== Hoy ===" && dig +short mi-dominio.cl A @8.8.8.8

Esto te muestra que esta realmente propagado en internet, no solo lo que dice tu archivo de zona.

Errores Comunes al Automatizar DNS y Como Evitarlos

Los errores mas frecuentes al automatizar DNS que vemos en produccion:

1. TTLs muy largos. Si configuras un TTL de 48 horas y despues descubris que el registro esta mal, vas a esperar 48 horas para que se corrija en todo el mundo. Usa TTLs cortos (300-3600 segundos) durante desarrollo y solo aumentalos cuando el dominio este estable.

2. No hacer backup antes de cambiar. Un script que modifica zonas sin backup previo es un accidente esperando pasar. Siempre respalda antes de modificar.

3. API keys hardcodeadas en scripts. Si subis un script con tu API key a GitHub, alguien va a encontrarlo y usarlo. Usa variables de entorno o archivos .env excluidos con .gitignore.

4. No verificar despues de cambiar. Un script que modifica y no verifica es como pintar a ciegas. Agrega siempre una verificacion post-cambio con dig o nslookup al final del script.

5. Olvidar el serial de BIND. En BIND, el serial es lo que hace que el servidor sepa que la zona cambio. Si editás un archivo de zona manualmente y no incrementas el serial, tus cambios no se propagan a los secondary nameservers. Los scripts de arriba manejan esto automaticamente, pero es la razon por la que la automatizacion es mas segura que la edicion manual.

Conclusion: DNS como Codigo

La automatizacion DNS no es solo para sysadmins hardcore. Cualquier desarrollador que maneje mas de un dominio o mas de un servidor se beneficia de scripts que reducen errores, ahorran tiempo y crean un registro de auditoria de cada cambio.

Empieza pequeno: un script que liste tus registros, otro que haga un backup antes de cada cambio. A medida que ganas confianza, agrega automatizacion de actualizaciones, cron jobs para verificacion de IP, y sincronizacion entre environments.

La infraestructura como codigo aplica a DNS tanto como a cualquier otra parte de tu stack. Scripts versionados, respaldos en JSON, y diffs antes de aplicar son las practicas que separan la administracion DNS profesional de la improvisacion.

Si necesitas un VPS con acceso root para implementar automatizacion DNS avanzada, los servidores de Elevocloud incluyen SSH con clave, acceso root y los recursos necesarios para correr tus scripts de produccion.

Articulos relacionados: Registros DNS: tipos A, CNAME, MX y TXT · Que es un servidor DNS y como funciona