Module dns de Node.js

Java FileModules intégrés de Node.js

de Node.jsdnsmodule est un module principal pour les requêtes Domain Name System (DNS). DNS (Domain Name System) est un système qui convertit des noms de domaine lisibles par l’humain (tels quewww.example.com) en adresses IP lisibles par machine (telles que192.0.2.1).

Pourquoi avez-vous besoin du module dns

Dans les communications réseau, les ordinateurs s’identifient en réalité entre eux par des adresses IP, mais les personnes trouvent plus facile de mémoriser des noms de domaine que des adresses IP numériques.dnsLe module offre la possibilité d’effectuer la résolution de noms de domaine dans les applications Node.js, ce qui permet aux développeurs de :

  • Résoudre des noms de domaine en adresses IP
  • Résoudre inversement des adresses IP en noms de domaine
  • Interroger des enregistrements DNS (MX, TXT, SRV, etc.)

Utilisation de base du module dns

Importer le module dns

Pour utiliser lednsmodule, vous devez d'abord l'importer :

const dns = require('dns');

Méthodes de résolution de base

dnsLe module fournit plusieurs méthodes de résolution. La plus couramment utilisée estlookupetresolve。

dns.lookup()

dns.lookup()est la méthode de résolution de domaine la plus simple. Elle utilise les fonctionnalités fournies par le système d'exploitation pour effectuer des requêtes DNS :

Exemple

dns.lookup('example.com', (err, address, famille) => {
  if (err) throw err;
  console.log(`address: ${address},version IP: IPv${family}`);
});

dns.resolve()

dns.resolve()offre un contrôle plus fin et peut interroger des types spécifiques d'enregistrements DNS :

Exemple

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

Méthodes principales du module dns

Résolution directe

La résolution directe est le processus de résolution d'un nom de domaine en une adresse IP :

Exemple

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

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

Résolution inverse

La résolution inverse est le processus de résolution d'une adresse IP en un nom de domaine :

Exemple

dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(`Résultat de la résolution inverse: ${hostnames}`);
});

Interrogation d'autres enregistrements DNS

dnsLe module prend également en charge l'interrogation d'autres types d'enregistrements DNS :

Exemple

// Enregistrement MX (enregistrement d'échange de courrier)
dns.resolveMx('google.com', (err, addresses) => {
  if (err) throw err;
  console.log(`Enregistrement MX: ${JSON.stringify(addresses)}`);
});

// Enregistrement TXT (enregistrement texte)
dns.resolveTxt('google.com', (err, records) => {
  if (err) throw err;
  console.log(`Enregistrement TXT: ${JSON.stringify(records)}`);
});

Méthodes synchrones et asynchrones

Méthodes asynchrones

Par défaut,dnsLes méthodes du module sont asynchrones et utilisent des fonctions de rappel pour gérer les résultats :

Exemple

dns.lookup('nodejs.org', (err, address, famille) => {
  console.log('Résultat asynchrone :', address);
});

Version Promise

À partir de Node.js v10.6.0,dnsles méthodes du module fournissent également des versions basées sur les promesses :

Exemple

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

async function lookupExample() {
  try {
    const result = await dnsPromises.lookup('nodejs.org');
    console.log('Résultat de la promesse :', result.address);
  } catch (err) {
    console.error(err);
  }
}

lookupExample();

Gestion des erreurs

Les requêtes DNS peuvent échouer, il est donc très important de gérer correctement les erreurs :

Exemple

dns.lookup('nonexistent.example.com', (err, address) => {
  if (err) {
    if (err.code === 'ENOTFOUND') {
      console.log('Le domaine n’existe pas');
    } else {
      console.log('Erreur inconnue :', err);
    }
    return;
  }
  console.log('Adresse :', address);
});

Les codes d'erreur DNS courants incluent :

  • ENOTFOUND: le domaine n'existe pas
  • ESERVFAIL: le serveur DNS a renvoyé un échec
  • ETIMEOUT: la requête DNS a expiré

Exemples d’application pratique

Vérifier si un domaine peut être résolu

Exemple

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

isDomainResolvable('google.com').then(result => {
  console.log('Le domaine est résolvable :', result);
});

Résolution par lots des noms de domaine

Exemple

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('Échec de la résolution :', err);
  });

Considérations de performance

Les requêtes DNS sont des opérations d'E/S et peuvent affecter les performances de l'application :

  1. Mettre en cache les résultats: Pour les domaines fréquemment interrogés, envisagez de mettre en cache les résultats au niveau de l'application
  2. Limites de concurrence: Évitez d'effectuer un grand nombre de requêtes DNS en même temps
  3. Paramètres de délai d'attente: Définissez un délai d'attente raisonnable pour les requêtes DNS

Exemple

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éthode

MéthodeDescriptionExemple
dns.lookup(hostname[, options], callback)Résout un nom d'hôte en la première adresse IPv4 ou IPv6. Le paramètre facultatifoptionsest utilisé pour spécifier la méthode de résolution, telle quefamily(4 ou 6).dns.lookup('example.com', (err, address) => {});
dns.resolve(hostname[, rrtype], callback)Interroge les enregistrements DNS d'un type d'enregistrement spécifié, renvoyant les enregistrements A par défaut. Les types pris en charge incluent A, AAAA, MX, TXT, etc.dns.resolve('example.com', 'MX', (err, addresses) => {});
dns.resolve4(hostname, callback)Interroge les adresses IPv4 d'un nom d'hôte.dns.resolve4('example.com', (err, addresses) => {});
dns.resolve6(hostname, callback)Interroge les adresses IPv6 d'un nom d'hôte.dns.resolve6('example.com', (err, addresses) => {});
dns.resolveMx(hostname, callback)Interroge les enregistrements MX (échange de courrier) d'un nom d'hôte.dns.resolveMx('example.com', (err, addresses) => {});
dns.resolveTxt(hostname, callback)Interroge les enregistrements TXT (texte) d'un nom d'hôte.dns.resolveTxt('example.com', (err, records) => {});
dns.reverse(ip, callback)Résout une adresse IP en un nom d'hôte.dns.reverse('8.8.8.8', (err, hostnames) => {});
dns.getServers()Renvoie un tableau des serveurs DNS actuels.console.log(dns.getServers());
dns.setServers(servers)Définit un tableau personnalisé de serveurs DNS.dns.setServers(['8.8.8.8', '8.8.4.4']);

rrtypes

Ce qui suit répertorie les valeurs rrtypes valides dans la méthode dns.resolve() :

  • 'A'Adresse IPv4, par défaut
  • 'AAAA'Adresse IPv6
  • 'MX'Enregistrements d'échange de courrier
  • 'TXT'Enregistrements texte
  • 'SRV'Enregistrements SRV
  • 'PTR'Utilisé pour la recherche inversée d'adresse IP
  • 'NS'Enregistrements de serveur de noms de domaine
  • 'CNAME'Enregistrements d'alias
  • 'SOA'Valeur initiale de l'enregistrement faisant autorité

Codes d'erreur

Chaque requête DNS peut renvoyer les codes d'erreur suivants :

  • dns.NODATA: Aucune donnée dans la réponse.
  • dns.FORMERR: Erreur de format de requête.
  • dns.SERVFAIL: Échec général.
  • dns.NOTFOUND: Nom de domaine introuvable.
  • dns.NOTIMP: L'opération demandée n'est pas implémentée.
  • dns.REFUSED: Requête refusée.
  • dns.BADQUERY: Erreur de format de requête.
  • dns.BADNAME: Erreur de format de nom de domaine.
  • dns.BADFAMILY: Protocole d'adresse non pris en charge.
  • dns.BADRESP: Erreur de format de réponse.
  • dns.CONNREFUSED: Impossible de se connecter au serveur DNS.
  • dns.TIMEOUT: Délai d'attente dépassé lors de la connexion au serveur DNS.
  • dns.EOF: Fin de fichier.
  • dns.FILE: Erreur de lecture du fichier.
  • dns.NOMEM: Débordement de mémoire.
  • dns.DESTRUCTION: Canal détruit.
  • dns.BADSTR: Erreur de format de chaîne.
  • dns.BADFLAGS: Identificateur illégal.
  • dns.NONAME: L'hôte donné n'est pas numérique.
  • dns.BADHINTS: Identificateur HINTS illégal.
  • dns.NOTINITIALIZED: La bibliothèque c-ares n'a pas été initialisée.
  • dns.LOADIPHLPAPI: Erreur lors du chargement de iphlpapi.dll.
  • dns.ADDRGETNETWORKPARAMS: Impossible de trouver la fonction GetNetworkParams.
  • dns.CANCELLED: Requête DNS annulée.

Exemple

Voici quelques exemples de méthodes courantes du module dns, montrant comment interroger l'adresse IP d'un hôte, récupérer des enregistrements DNS, etc.

1. Utilisez dns.lookup() pour obtenir une adresse IP

Exemple

const dns = require('dns');

// Rechercher l'adresse IPv4 d'un domaine
dns.lookup('example.com', (err, address, famille) => {
  if (err) throw err;
  console.log(`Adresse IP: ${address},Famille d'adresses: IPv${family}`);
});

dns.lookup() est une interface simplifiée qui trouve la première adresse IPv4 ou IPv6 pour le nom d'hôte spécifié.

2. Utilisez dns.resolve() pour interroger différents types d'enregistrements DNS

Exemple

const dns = require('dns');

// Interroger les enregistrements MX
dns.resolve('example.com', 'MX', (err, addresses) => {
  if (err) throw err;
  console.log('Enregistrements MX :', addresses);
});

// Interroger les enregistrements TXT
dns.resolve('example.com', 'TXT', (err, records) => {
  if (err) throw err;
  console.log('Enregistrements TXT :', records);
});

En utilisant dns.resolve(), vous pouvez spécifier des types d'enregistrements (tels que MX, TXT, etc.) pour interroger différents enregistrements DNS.

3. Utiliser dns.reverse() pour une requête DNS inverse

Exemple

const dns = require('dns');

// Résoudre inversement une adresse IP en nom d'hôte
dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(Nom d'hôte de `8.8.8.8: ${hostnames}`);
});

La résolution inverse résout une adresse IP en un nom de domaine, souvent utilisée pour vérifier la correspondance entre un nom de domaine et une adresse IP.

4. Obtenir et définir les serveurs DNS

Exemple

const dns = require('dns');

// Obtenir la liste actuelle des serveurs DNS
console.log('Serveurs DNS actuels :', dns.getServers());

// Définir un serveur DNS personnalisé
dns.setServers(['1.1.1.1', '8.8.8.8']);
console.log('Nouveau serveur DNS :', dns.getServers());

Avec dns.getServers(), vous pouvez obtenir la liste des serveurs DNS actuellement configurés sur le système. dns.setServers() permet de définir des serveurs DNS personnalisés, afin que des services de résolution DNS spécifiques puissent être utilisés pour les requêtes.

Méthodes asynchrones et synchrones

  • Méthodes asynchrones : telles quedns.lookup()、dns.resolve()etc., non bloquantes, adaptées aux tâches concurrentes.
  • Méthodes synchrones : telles quedns.lookupSync()、dns.resolve4Sync(), bloquantes, adaptées à une utilisation à petite échelle, à éviter dans les scénarios à forte concurrence.

Scénarios d'application pratiques

  • Résolution de noms de domaine pour les applications web: Interroger l'adresse IP d'un nom de domaine sur le serveur pour récupérer des pages web ou des ressources.
  • Vérification de la configuration du serveur de messagerie: Vérifier l'exactitude de la configuration du serveur de messagerie via les enregistrements MX.
  • Anti-spam: Grâce à une requête DNS inverse, détectez si le serveur qui envoie des e-mails correspond au nom de domaine, ce qui permet d'identifier la source du spam.
  • Équilibrage de charge: En résolvant les différentes adresses IP d'un nom de domaine, créez un schéma d'équilibrage de charge pour répartir le trafic entre plusieurs serveurs.

dnsLe module permet aux applications Node.js d'effectuer la résolution de noms de domaine et des requêtes DNS, leur donnant plus de flexibilité dans la gestion des communications réseau. Grâce à des interfaces asynchrones, les requêtes DNS peuvent être effectuées efficacement sans bloquer le thread principal.

Java FileModules intégrés de Node.js

Autres extensions