Módulo dns de Node.js

Java FileMódulos integrados de Node.js


de Node.jsdnsEl módulo es un módulo central para consultas del Sistema de Nombres de Dominio (DNS). DNS (Domain Name System) es el sistema que convierte nombres de dominio legibles por humanos (comowww.example.com) a direcciones IP legibles por máquinas (como192.0.2.1) . Sistema.

¿Por qué se necesita el módulo dns?

En la comunicación de red, las computadoras realmente se identifican entre sí mediante direcciones IP, pero a las personas les resulta más fácil recordar nombres de dominio que direcciones IP numéricas.dnsEl módulo proporciona la capacidad de realizar resolución de nombres de dominio en aplicaciones Node.js, lo que permite a los desarrolladores:

  • Resolver nombres de dominio a direcciones IP
  • Resolver inversamente direcciones IP a nombres de dominio
  • Consultar registros DNS (MX, TXT, SRV, etc.)

Uso básico del módulo dns

Importar el módulo dns

Para usardnsel módulo, primero debe importarlo:

const dns = require('dns');

Métodos básicos de resolución

dnsEl módulo proporciona varios métodos de resolución; el más común eslookupyresolve。

dns.lookup()

dns.lookup()es el método más simple de resolución de nombres de dominio; utiliza las funciones proporcionadas por el sistema operativo para realizar consultas DNS:

Ejemplo

dns.lookup('example.com', (err, address, family) => {
  if (err) throw err;
  console.log(`dirección: ${address},versión de IP: IPv${family}`);
});

dns.resolve()

dns.resolve()proporciona un control más granular, permitiendo consultar tipos específicos de registros DNS:

Ejemplo

dns.resolve('example.com', 'A', (err, addresses) => {
  if (err) throw err;
  console.log(`Registro A: ${JSON.stringify(addresses)}`);
});

Métodos principales del módulo dns

Resolución directa

La resolución directa es el proceso de convertir un nombre de dominio en una dirección IP:

Ejemplo

dns.resolve4('google.com', (err, addresses) => {
  if (err) throw err;
  console.log(`dirección IPv4: ${addresses}`);
});

dns.resolve6('google.com', (err, addresses) => {
  if (err) throw err;
  console.log(`dirección IPv6: ${addresses}`);
});

Resolución inversa

La resolución inversa es el proceso de convertir una dirección IP en un nombre de dominio:

Ejemplo

dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(`resultado de la resolución inversa: ${hostnames}`);
});

Consulta de otros registros DNS

dnsEl módulo también admite consultar otros tipos de registros DNS:

Ejemplo

// Registro MX (registro de intercambio de correo)
dns.resolveMx('google.com', (err, addresses) => {
  if (err) throw err;
  console.log(`Registro MX: ${JSON.stringify(addresses)}`);
});

// Registro TXT (registro de texto)
dns.resolveTxt('google.com', (err, records) => {
  if (err) throw err;
  console.log(`Registro TXT: ${JSON.stringify(records)}`);
});

Métodos síncronos y asíncronos

Métodos asíncronos

Por defecto,dnslos métodos del módulo son asíncronos y utilizan funciones de devolución de llamada para manejar los resultados:

Ejemplo

dns.lookup('nodejs.org', (err, address, family) => {
  console.log('Resultado asíncrono:', address);
});

Versión con Promise

A partir de Node.js v10.6.0,dnslos métodos del módulo también proporcionan versiones basadas en Promise:

Ejemplo

const { promises: dnsPromises } = require('dns');

async function lookupExample() {
  try {
    const result = await dnsPromises.lookup('nodejs.org');
    console.log('Resultado Promise:', result.address);
  } catch (err) {
    console.error(err);
  }
}

lookupExample();

Manejo de errores

Las consultas DNS pueden fallar, por lo que es muy importante manejar los errores correctamente:

Ejemplo

dns.lookup('nonexistent.example.com', (err, address) => {
  if (err) {
    if (err.code === 'ENOTFOUND') {
      console.log('El dominio no existe');
    } else {
      console.log('Error desconocido:', err);
    }
    return;
  }
  console.log('Dirección:', address);
});

Los códigos de error DNS comunes incluyen:

  • ENOTFOUND: el dominio no existe
  • ESERVFAIL: el servidor DNS devolvió un fallo
  • ETIMEOUT: la consulta DNS agotó el tiempo de espera

Ejemplos de aplicación práctica

Comprobar si un dominio se puede resolver

Ejemplo

function isDomainResolvable(domain) {
  return new Promise((resolve) => {
    dns.lookup(domain, (err) => {
      resolve(!err);
    });
  });
}

isDomainResolvable('google.com').then(result => {
  console.log('El dominio se puede resolver:', result);
});

Resolución por lotes de dominios

Ejemplo

const domains = ['google.com', 'facebook.com', 'twitter.com'];

Promise.all(domains.map(domain => dnsPromises.lookup(domain)))
  .then(results => {
    results.forEach((result, index) => {
      console.log(`${domains[index]} => ${result.address}`);
    });
  })
  .catch(err => {
    console.error('Error de resolución:', err);
  });

Consideraciones de rendimiento

Las consultas DNS son operaciones de E/S y pueden afectar el rendimiento de la aplicación:

  1. Almacenar en caché los resultados: para dominios consultados con frecuencia, considere almacenar en caché los resultados en la capa de aplicación
  2. Límite de concurrencia: evite lanzar una gran cantidad de consultas DNS al mismo tiempo
  3. Configuración de tiempo de espera: establezca un tiempo de espera razonable para las consultas DNS

Ejemplo

const cache = new Map();

async function cachedLookup(domain) {
  if (cache.has(domain)) {
    return cache.get(domain);
  }
 
  const result = await dnsPromises.lookup(domain);
  cache.set(domain, result);
  return result;
}


Método

MétodoDescripciónEjemplo
dns.lookup(hostname[, options], callback)Resuelve el nombre de host a la primera dirección IPv4 o IPv6. El parámetro opcionaloptionsse utiliza para especificar el modo de resolución, comofamily(4 o 6).dns.lookup('example.com', (err, address) => {});
dns.resolve(hostname[, rrtype], callback)Consulta registros DNS de un tipo específico; por defecto devuelve registros A. Los tipos admitidos incluyen A, AAAA, MX, TXT, etc.dns.resolve('example.com', 'MX', (err, addresses) => {});
dns.resolve4(hostname, callback)Consulta la dirección IPv4 de un nombre de host.dns.resolve4('example.com', (err, addresses) => {});
dns.resolve6(hostname, callback)Consulta la dirección IPv6 de un nombre de host.dns.resolve6('example.com', (err, addresses) => {});
dns.resolveMx(hostname, callback)Consulta el registro MX (intercambio de correo) de un nombre de host.dns.resolveMx('example.com', (err, addresses) => {});
dns.resolveTxt(hostname, callback)Consulta el registro TXT (texto) de un nombre de host.dns.resolveTxt('example.com', (err, records) => {});
dns.reverse(ip, callback)Resuelve una dirección IP a un nombre de host.dns.reverse('8.8.8.8', (err, hostnames) => {});
dns.getServers()Devuelve un array de los servidores DNS actuales.console.log(dns.getServers());
dns.setServers(servers)Establece un array de servidores DNS personalizados.dns.setServers(['8.8.8.8', '8.8.4.4']);

rrtypes

A continuación se enumeran los valores válidos de rrtypes en el método dns.resolve():

  • 'A'Dirección IPv4, por defecto
  • 'AAAA'Dirección IPv6
  • 'MX'Registro de intercambio de correo
  • 'TXT'Registro de texto
  • 'SRV'Registro SRV
  • 'PTR'Se utiliza para la búsqueda inversa de IP
  • 'NS'Registro de servidores de nombres
  • 'CNAME'Registro de alias
  • 'SOA'Valor inicial del registro de autorización

Códigos de error

Cada consulta DNS puede devolver los siguientes códigos de error:

  • dns.NODATA: respuesta sin datos.
  • dns.FORMERR: formato de consulta incorrecto.
  • dns.SERVFAIL: fallo general.
  • dns.NOTFOUND: dominio no encontrado.
  • dns.NOTIMP: la operación solicitada no está implementada.
  • dns.REFUSED: consulta rechazada.
  • dns.BADQUERY: formato de consulta incorrecto.
  • dns.BADNAME: formato de nombre de dominio incorrecto.
  • dns.BADFAMILY: el protocolo de dirección no es compatible.
  • dns.BADRESP: formato de respuesta incorrecto.
  • dns.CONNREFUSED: no se pudo conectar con el servidor DNS.
  • dns.TIMEOUT: tiempo de espera de conexión al servidor DNS agotado.
  • dns.EOF: fin del archivo.
  • dns.FILE: error de lectura de archivo.
  • dns.NOMEM: desbordamiento de memoria.
  • dns.DESTRUCTION: el canal fue destruido.
  • dns.BADSTR: formato de cadena incorrecto.
  • dns.BADFLAGS: identificador ilegal.
  • dns.NONAME: el host proporcionado no es numérico.
  • dns.BADHINTS: identificador de HINTS ilegal.
  • dns.NOTINITIALIZED: la biblioteca c-ares aún no se ha inicializado.
  • dns.LOADIPHLPAPI: error al cargar iphlpapi.dll.
  • dns.ADDRGETNETWORKPARAMS: no se pudo encontrar la función GetNetworkParams.
  • dns.CANCELLED: consulta DNS cancelada.

Ejemplo

A continuación se muestran algunos ejemplos de métodos comunes del módulo dns, que ilustran cómo consultar la dirección IP de un host, obtener registros DNS, etc.

1. Usar dns.lookup() para obtener la dirección IP

Ejemplo

const dns = require('dns');

// Buscar la dirección IPv4 del dominio
dns.lookup('example.com', (err, address, family) => {
  if (err) throw err;
  console.log(`Dirección IP: ${address},Familia de direcciones: IPv${family}`);
});

dns.lookup() es una interfaz simplificada que busca la primera dirección IPv4 o IPv6 en el hostname especificado.

2. Usar dns.resolve() para consultar diferentes tipos de registros DNS

Ejemplo

const dns = require('dns');

// Consultar el registro MX
dns.resolve('example.com', 'MX', (err, addresses) => {
  if (err) throw err;
  console.log('Registro MX:', addresses);
});

// Consultar el registro TXT
dns.resolve('example.com', 'TXT', (err, records) => {
  if (err) throw err;
  console.log('Registro TXT:', records);
});

Mediante dns.resolve(), se puede especificar el tipo de registro (como MX, TXT, etc.) para consultar diferentes registros DNS.

3. Uso de dns.reverse() para la consulta DNS inversa

Ejemplo

const dns = require('dns');

// Resolución inversa de una dirección IP a un nombre de host
dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(El nombre de host de `8.8.8.8`: ${hostnames}`);
});

La resolución inversa convierte una dirección IP en un nombre de dominio; se utiliza a menudo para verificar la correspondencia entre el dominio y la dirección IP.

4. Obtener y configurar servidores DNS

Ejemplo

const dns = require('dns');

// Obtener la lista actual de servidores DNS
console.log('Servidores DNS actuales:', dns.getServers());

// Configurar un servidor DNS personalizado
dns.setServers(['1.1.1.1', '8.8.8.8']);
console.log('Nuevo servidor DNS:', dns.getServers());

Con dns.getServers() se puede obtener la lista de servidores DNS configurados actualmente en el sistema; dns.setServers() permite personalizar los servidores DNS para utilizar un servicio de resolución DNS específico al realizar consultas.

Métodos asíncronos y síncronos

  • Métodos asíncronos: comodns.lookup()、dns.resolve()etc., no bloqueantes, adecuados para tareas concurrentes.
  • Métodos síncronos: comodns.lookupSync()、dns.resolve4Sync(), bloqueantes, adecuados para usos a pequeña escala; evite utilizarlos en escenarios de alta concurrencia.

Escenarios de aplicación práctica

  • Resolución de nombres de dominio en aplicaciones web: consultar la dirección IP del dominio en el servidor para obtener páginas web o recursos.
  • Verificación de la configuración del servidor de correo: mediante el registro MX se verifica la corrección de la configuración del servidor de correo.
  • Anti-spam: mediante la consulta DNS inversa, se detecta si el servidor que envía el correo coincide con el dominio, identificando así el origen del spam.
  • Equilibrio de carga: al resolver las diferentes direcciones IP de un dominio, se crean esquemas de equilibrio de carga para distribuir el tráfico entre varios servidores.

dnsEl módulo permite que las aplicaciones Node.js realicen resolución de nombres de dominio y consultas DNS, lo que brinda más flexibilidad en la comunicación de red. Mediante interfaces asíncronas, las consultas DNS pueden completarse de manera eficiente sin bloquear el hilo principal.

Java FileMódulos integrados de Node.js

Otras extensiones