DNS

[Stable: 2 - Stable]

Stable: 2 Stabilité: 2 - Stable

Code source : lib/dns.js

Le module node:dns permet la résolution de noms. Par exemple, utilisez-le pour rechercher les adresses IP des noms d’hôtes.

Bien que nommé d’après le Système de Noms de Domaine (DNS), il n’utilise pas toujours le protocole DNS pour les recherches. dns.lookup() utilise les fonctionnalités du système d’exploitation pour effectuer la résolution de noms. Il n’est pas forcément nécessaire d’effectuer une communication réseau. Pour effectuer une résolution de noms de la même manière que les autres applications du même système, utilisez dns.lookup().

ESM

import dns from 'node:dns'

dns.lookup('example.org', (err, address, family) => {
  console.log('address: %j family: IPv%s', address, family)
})
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

CJS

const dns = require('node:dns')

dns.lookup('example.org', (err, address, family) => {
  console.log('address: %j family: IPv%s', address, family)
})
// address: "2606:2800:21f:cb07:6820:80da:af6b:8b2c" family: IPv6

Toutes les autres fonctions du module node:dns se connectent à un véritable serveur DNS pour effectuer la résolution de noms. Elles utiliseront toujours le réseau pour effectuer des requêtes DNS. Ces fonctions n’utilisent pas le même ensemble de fichiers de configuration que ceux utilisés par dns.lookup() (par exemple, /etc/hosts). Utilisez ces fonctions pour effectuer toujours des requêtes DNS, en contournant les autres mécanismes de résolution de noms.

ESM

import dns from 'node:dns'

dns.resolve4('archive.org', (err, addresses) => {
  if (err) throw err

  console.log(`addresses: ${JSON.stringify(addresses)}`)

  addresses.forEach(a => {
    dns.reverse(a, (err, hostnames) => {
      if (err) {
        throw err
      }
      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`)
    })
  })
})

CJS

const dns = require('node:dns')

dns.resolve4('archive.org', (err, addresses) => {
  if (err) throw err

  console.log(`addresses: ${JSON.stringify(addresses)}`)

  addresses.forEach(a => {
    dns.reverse(a, (err, hostnames) => {
      if (err) {
        throw err
      }
      console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`)
    })
  })
})

Consultez la section Considérations relatives à l’implémentation pour plus d’informations.

Classe : dns.Resolver

Ajouté dans la version : v8.3.0

Un résolveur indépendant pour les requêtes DNS.

La création d’un nouveau résolveur utilise les paramètres de serveur par défaut. La configuration des serveurs utilisés pour un résolveur à l’aide de resolver.setServers() n’a pas d’incidence sur les autres résolveurs :

ESM

import { Resolver } from 'node:dns'
const resolver = new Resolver()
resolver.setServers(['4.4.4.4'])

// Cette requête utilisera le serveur à l’adresse 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org', (err, addresses) => {
  // ...
})

CJS

const { Resolver } = require('node:dns')
const resolver = new Resolver()
resolver.setServers(['4.4.4.4'])

// Cette requête utilisera le serveur à l’adresse 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org', (err, addresses) => {
  // ...
})

Les méthodes suivantes du module node:dns sont disponibles :

• resolver.getServers()
• resolver.resolve()
• resolver.resolve4()
• resolver.resolve6()
• resolver.resolveAny()
• resolver.resolveCaa()
• resolver.resolveCname()
• resolver.resolveMx()
• resolver.resolveNaptr()
• resolver.resolveNs()
• resolver.resolvePtr()
• resolver.resolveSoa()
• resolver.resolveSrv()
• resolver.resolveTxt()
• resolver.reverse()
• resolver.setServers()

Resolver([options])

[Historique]

Version	Modifications
v16.7.0, v14.18.0	L’objet options accepte maintenant une option tries.
v12.18.3	Le constructeur accepte désormais un objet options. La seule option prise en charge est timeout.
v8.3.0	Ajouté dans la version : v8.3.0

Créer un nouveau résolveur.

• options <Object>
  • timeout <integer> Délai d’expiration de la requête en millisecondes, ou -1 pour utiliser le délai d’expiration par défaut.
  • tries <integer> Nombre de tentatives que le résolveur essaiera de contacter chaque serveur de noms avant d’abandonner. Par défaut : 4

resolver.cancel()

Ajouté dans : v8.3.0

Annule toutes les requêtes DNS en attente effectuées par ce résolveur. Les rappels correspondants seront appelés avec une erreur ayant le code ECANCELLED.

resolver.setLocalAddress([ipv4][, ipv6])

Ajouté dans : v15.1.0, v14.17.0

• ipv4 <string> Une représentation sous forme de chaîne de caractères d'une adresse IPv4. Par défaut : '0.0.0.0'
• ipv6 <string> Une représentation sous forme de chaîne de caractères d'une adresse IPv6. Par défaut : '::0'

L'instance de résolveur enverra ses requêtes à partir de l'adresse IP spécifiée. Cela permet aux programmes de spécifier des interfaces sortantes lorsqu'elles sont utilisées sur des systèmes multi-hébergés.

Si une adresse v4 ou v6 n'est pas spécifiée, elle est définie par défaut et le système d'exploitation choisira automatiquement une adresse locale.

Le résolveur utilisera l'adresse locale v4 lors de la formulation de requêtes aux serveurs DNS IPv4, et l'adresse locale v6 lors de la formulation de requêtes aux serveurs DNS IPv6. Le rrtype des demandes de résolution n'a pas d'incidence sur l'adresse locale utilisée.

dns.getServers()

Ajouté dans : v0.11.3

• Retourne : <string[]>

Retourne un tableau de chaînes d'adresses IP, formatées selon la norme RFC 5952, qui sont actuellement configurées pour la résolution DNS. Une chaîne inclura une section de port si un port personnalisé est utilisé.

;['8.8.8.8', '2001:4860:4860::8888', '8.8.8.8:1053', '[2001:4860:4860::8888]:1053']

dns.lookup(hostname[, options], callback)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	L'option verbatim est maintenant obsolète au profit de la nouvelle option order.
v18.4.0	Pour la compatibilité avec node:net, lors du passage d'un objet option, l'option family peut être la chaîne 'IPv4' ou la chaîne 'IPv6'.
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v17.0.0	Les options verbatim sont désormais définies par défaut sur true.
v8.5.0	L'option verbatim est désormais prise en charge.
v1.2.0	L'option all est désormais prise en charge.
v0.1.90	Ajouté dans : v0.1.90

• hostname <string>

• options <integer> | <Object>

  • family <integer> | <string> La famille d'enregistrement. Doit être 4, 6 ou 0. Pour des raisons de compatibilité ascendante, 'IPv4' et 'IPv6' sont interprétés respectivement comme 4 et 6. La valeur 0 indique qu'une adresse IPv4 ou IPv6 est renvoyée. Si la valeur 0 est utilisée avec { all: true } (voir ci-dessous), soit l'une ou les deux adresses IPv4 et IPv6 sont renvoyées, selon le résolveur DNS du système. Par défaut : 0.
  • hints <number> Un ou plusieurs indicateurs getaddrinfo pris en charge. Plusieurs indicateurs peuvent être transmis en effectuant un OU bit à bit de leurs valeurs.
  • all <boolean> Lorsque la valeur est true, le rappel renvoie toutes les adresses résolues dans un tableau. Sinon, renvoie une seule adresse. Par défaut : false.
  • order <string> Lorsque la valeur est verbatim, les adresses résolues sont renvoyées non triées. Lorsque la valeur est ipv4first, les adresses résolues sont triées en plaçant les adresses IPv4 avant les adresses IPv6. Lorsque la valeur est ipv6first, les adresses résolues sont triées en plaçant les adresses IPv6 avant les adresses IPv4. Par défaut : verbatim (les adresses ne sont pas réordonnées). La valeur par défaut est configurable à l'aide de dns.setDefaultResultOrder() ou de --dns-result-order.
  • verbatim <boolean> Lorsque la valeur est true, le rappel reçoit les adresses IPv4 et IPv6 dans l'ordre où le résolveur DNS les a renvoyées. Lorsque la valeur est false, les adresses IPv4 sont placées avant les adresses IPv6. Cette option sera obsolète au profit de order. Lorsque les deux sont spécifiés, order a une priorité plus élevée. Le nouveau code ne doit utiliser que order. Par défaut : true (les adresses ne sont pas réordonnées). La valeur par défaut est configurable à l'aide de dns.setDefaultResultOrder() ou de --dns-result-order.

• callback <Function>

  • err <Error>
  • address <string> Une représentation sous forme de chaîne de caractères d'une adresse IPv4 ou IPv6.
  • family <integer> 4 ou 6, indiquant la famille de l'address, ou 0 si l'adresse n'est pas une adresse IPv4 ou IPv6. 0 est un indicateur probable d'un bogue dans le service de résolution de noms utilisé par le système d'exploitation.

Résout un nom d'hôte (par exemple, 'nodejs.org') dans le premier enregistrement A (IPv4) ou AAAA (IPv6) trouvé. Toutes les propriétés de l'option sont facultatives. Si options est un entier, il doit être 4 ou 6 – si options n'est pas fourni, alors les adresses IPv4 ou IPv6, ou les deux, sont renvoyées si elles sont trouvées.

Avec l'option all définie sur true, les arguments de callback deviennent (err, addresses), avec addresses étant un tableau d'objets avec les propriétés address et family.

En cas d'erreur, err est un objet Error, où err.code est le code d'erreur. Gardez à l'esprit que err.code sera défini sur 'ENOTFOUND' non seulement lorsque le nom d'hôte n'existe pas, mais aussi lorsque la recherche échoue d'autres manières, comme l'absence de descripteurs de fichiers disponibles.

dns.lookup() n'a pas nécessairement de lien avec le protocole DNS. L'implémentation utilise une fonctionnalité du système d'exploitation qui peut associer des noms à des adresses et inversement. Cette implémentation peut avoir des conséquences subtiles mais importantes sur le comportement de tout programme Node.js. Veuillez prendre le temps de consulter la section Considérations relatives à l'implémentation avant d'utiliser dns.lookup().

Exemple d'utilisation :

ESM

import dns from 'node:dns'
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
}
dns.lookup('example.org', options, (err, address, family) =>
  console.log('adresse : %j famille : IPv%s', address, family)
)
// adresse : "2606:2800:21f:cb07:6820:80da:af6b:8b2c" famille : IPv6

// Lorsque options.all est true, le résultat sera un tableau.
options.all = true
dns.lookup('example.org', options, (err, addresses) => console.log('adresses : %j', addresses))
// adresses : [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]

CJS

const dns = require('node:dns')
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
}
dns.lookup('example.org', options, (err, address, family) =>
  console.log('adresse : %j famille : IPv%s', address, family)
)
// adresse : "2606:2800:21f:cb07:6820:80da:af6b:8b2c" famille : IPv6

// Lorsque options.all est true, le résultat sera un tableau.
options.all = true
dns.lookup('example.org', options, (err, addresses) => console.log('adresses : %j', addresses))
// adresses : [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]

Si cette méthode est invoquée comme sa version util.promisify()ée et que all n'est pas défini sur true, elle retourne une Promise pour un Object avec des propriétés address et family.

Indicateurs getaddrinfo pris en charge

[Historique]

Version	Modifications
v13.13.0, v12.17.0	Ajout de la prise en charge de l'indicateur dns.ALL.

Les indicateurs suivants peuvent être transmis en tant qu'indications à dns.lookup().

• dns.ADDRCONFIG : Limite les types d'adresses retournées aux types d'adresses non-bouclées configurées sur le système. Par exemple, les adresses IPv4 ne sont retournées que si le système actuel a au moins une adresse IPv4 configurée.
• dns.V4MAPPED : Si la famille IPv6 a été spécifiée, mais qu'aucune adresse IPv6 n'a été trouvée, retourne les adresses IPv4 mappées IPv6. Ce n'est pas pris en charge sur certains systèmes d'exploitation (par exemple, FreeBSD 10.1).
• dns.ALL : Si dns.V4MAPPED est spécifié, retourne les adresses IPv6 résolues ainsi que les adresses IPv4 mappées IPv6.

dns.lookupService(adresse, port, rappel)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument rappel lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.11.14	Ajouté dans : v0.11.14

• adresse <string>
• port <number>
• rappel <Function>
  • err <Error>
  • nom d'hôte <string> par exemple : example.com
  • service <string> par exemple : http

Résout l'adresse et le port donnés en un nom d'hôte et un service à l'aide de l'implémentation getnameinfo sous-jacente du système d'exploitation.

Si adresse n'est pas une adresse IP valide, une TypeError sera levée. Le port sera converti en nombre. S'il ne s'agit pas d'un port valide, une TypeError sera levée.

En cas d'erreur, err est un objet Error, où err.code est le code d'erreur.

ESM

import dns from 'node:dns';
dns.lookupService('127.0.0.1', 22, (err, nom d'hôte, service) => {
  console.log(nom d'hôte, service);
  // Affiche : localhost ssh
});

CJS

const dns = require('node:dns');
dns.lookupService('127.0.0.1', 22, (err, nom d'hôte, service) => {
  console.log(nom d'hôte, service);
  // Affiche : localhost ssh
});

Si cette méthode est appelée comme sa version util.promisify()ée, elle retourne une Promise pour un Object avec des propriétés hostname et service.

dns.resolve(hostname[, rrtype], callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lance désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string> Nom d’hôte à résoudre.
• rrtype <string> Type d’enregistrement de ressource. Par défaut : 'A'.
• callback <Function>
  • err <Error>
  • records <string[]> | <Object[]> | <Object>

Utilise le protocole DNS pour résoudre un nom d’hôte (par ex. 'nodejs.org') en un tableau d’enregistrements de ressources. La fonction callback a des arguments (err, records). En cas de succès, records sera un tableau d’enregistrements de ressources. Le type et la structure des résultats individuels varient en fonction de rrtype :

rrtype	records contient	Type de résultat	Méthode abrégée
'A'	Adresses IPv4 (par défaut)	<string>	dns.resolve4()
'AAAA'	Adresses IPv6	<string>	dns.resolve6()
'ANY'	Tous les enregistrements	<Object>	dns.resolveAny()
'CAA'	Enregistrements d’autorisation CA	<Object>	dns.resolveCaa()
'CNAME'	Enregistrements de nom canonique	<string>	dns.resolveCname()
'MX'	Enregistrements d’échange de courrier	<Object>	dns.resolveMx()
'NAPTR'	Enregistrements de pointeur d’autorité de nom	<Object>	dns.resolveNaptr()
'NS'	Enregistrements de serveur de nom	<string>	dns.resolveNs()
'PTR'	Enregistrements de pointeur	<string>	dns.resolvePtr()
'SOA'	Enregistrements de début d’autorité	<Object>	dns.resolveSoa()
'SRV'	Enregistrements de service	<Object>	dns.resolveSrv()
'TXT'	Enregistrements texte	<string[]>	dns.resolveTxt()

En cas d'erreur, err est un objet Error, où err.code est l'un des codes d'erreur DNS.

dns.resolve4(hostname[, options], callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v7.2.0	Cette méthode prend désormais en charge le passage d'options, notamment options.ttl.
v0.1.16	Ajouté dans : v0.1.16

• hostname <string> Nom d'hôte à résoudre.

• options <Object>

  • ttl <boolean> Récupère la valeur de la durée de vie (TTL) de chaque enregistrement. Lorsque true, le rappel reçoit un tableau d'objets { address: '1.2.3.4', ttl: 60 } plutôt qu'un tableau de chaînes, la TTL étant exprimée en secondes.

• callback <Function>

  • err <Error>
  • addresses <string[]> | <Object[]>

Utilise le protocole DNS pour résoudre une adresse IPv4 (enregistrements A) pour le hostname. L'argument addresses transmis à la fonction callback contiendra un tableau d'adresses IPv4 (par ex., ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

dns.resolve6(hostname[, options], callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v7.2.0	Cette méthode prend désormais en charge le passage d'options, notamment options.ttl.
v0.1.16	Ajouté dans : v0.1.16

• hostname <string> Nom d'hôte à résoudre.

• options <Object>

  • ttl <boolean> Récupère la valeur de la durée de vie (TTL) de chaque enregistrement. Lorsque true, le rappel reçoit un tableau d'objets { address: '0:1:2:3:4:5:6:7', ttl: 60 } plutôt qu'un tableau de chaînes, la TTL étant exprimée en secondes.

• callback <Function>

  • err <Error>
  • addresses <string[]> | <Object[]>

Utilise le protocole DNS pour résoudre les adresses IPv6 (enregistrements AAAA) pour le hostname. L'argument addresses transmis à la fonction callback contiendra un tableau d'adresses IPv6.

dns.resolveAny(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un callback invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.

• hostname <string>
• callback <Function>
  • err <Error>
  • ret <Object[]>

Utilise le protocole DNS pour résoudre tous les enregistrements (également appelés requête ANY ou *). L'argument ret passé à la fonction callback sera un tableau contenant différents types d'enregistrements. Chaque objet a une propriété type qui indique le type de l'enregistrement actuel. Et en fonction du type, des propriétés supplémentaires seront présentes sur l'objet :

Type	Propriétés
'A'	address / ttl
'AAAA'	address / ttl
'CNAME'	value
'MX'	Se référer à dns.resolveMx()
'NAPTR'	Se référer à dns.resolveNaptr()
'NS'	value
'PTR'	value
'SOA'	Se référer à dns.resolveSoa()
'SRV'	Se référer à dns.resolveSrv()
'TXT'	Ce type d'enregistrement contient une propriété de tableau appelée entries qui fait référence à dns.resolveTxt(), par exemple { entries: ['...'], type: 'TXT' }

Voici un exemple de l'objet ret passé au callback :

;[
  { type: 'A', address: '127.0.0.1', ttl: 299 },
  { type: 'CNAME', value: 'example.com' },
  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
  { type: 'NS', value: 'ns1.example.com' },
  { type: 'TXT', entries: ['v=spf1 include:_spf.example.com ~all'] },
  {
    type: 'SOA',
    nsname: 'ns1.example.com',
    hostmaster: 'admin.example.com',
    serial: 156696742,
    refresh: 900,
    retry: 900,
    expire: 1800,
    minttl: 60,
  },
]

Les opérateurs de serveurs DNS peuvent choisir de ne pas répondre aux requêtes ANY. Il peut être préférable d'appeler des méthodes individuelles telles que dns.resolve4(), dns.resolveMx(), et ainsi de suite. Pour plus de détails, voir RFC 8482.

dns.resolveCname(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.3.2	Ajouté dans : v0.3.2

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements CNAME pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements de noms canoniques disponibles pour le hostname (par exemple, ['bar.example.com']).

dns.resolveCaa(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v15.0.0, v14.17.0	Ajouté dans : v15.0.0, v14.17.0

• hostname <string>
• callback <Function>
  • err <Error>
  • records <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements CAA pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements d'autorisation de l'autorité de certification disponibles pour le hostname (par exemple, [{critical: 0, iodef: 'mailto:[email protected]'}, {critical: 128, issue: 'pki.example.com'}]).

dns.resolveMx(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lance désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements d'échange de courrier (MX) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'objets contenant à la fois une propriété priority et exchange (par exemple : [{priority: 10, exchange: 'mx.example.com'}, ... ]).

dns.resolveNaptr(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lance désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.9.12	Ajouté dans : v0.9.12

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements basés sur des expressions régulières (NAPTR) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'objets avec les propriétés suivantes :

• flags
• service
• regexp
• replacement
• order
• preference

{
  flags: 's',
  service: 'SIP+D2U',
  regexp: '',
  replacement: '_sip._udp.example.com',
  order: 30,
  preference: 100
}

dns.resolveNs(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.90	Ajouté dans : v0.1.90

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements de serveur de noms (enregistrements NS) pour le hostname. L'argument addresses passé à la fonction callback contiendra un tableau d'enregistrements de serveur de noms disponibles pour hostname (par exemple, ['ns1.example.com', 'ns2.example.com']).

dns.resolvePtr(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v6.0.0	Ajouté dans : v6.0.0

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <string[]>

Utilise le protocole DNS pour résoudre les enregistrements de pointeur (enregistrements PTR) pour le hostname. L'argument addresses passé à la fonction callback sera un tableau de chaînes contenant les enregistrements de réponse.

dns.resolveSoa(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.11.10	Ajouté dans : v0.11.10

• hostname <string>
• callback <Function>
  • err <Error>
  • address <Object>

Utilise le protocole DNS pour résoudre un enregistrement de début d'autorité (enregistrement SOA) pour le hostname. L'argument address passé à la fonction callback sera un objet avec les propriétés suivantes :

• nsname
• hostmaster
• serial
• refresh
• retry
• expire
• minttl

{
  nsname: 'ns.example.com',
  hostmaster: 'root.example.com',
  serial: 2013101809,
  refresh: 10000,
  retry: 2400,
  expire: 604800,
  minttl: 3600
}

dns.resolveSrv(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • addresses <Object[]>

Utilise le protocole DNS pour résoudre les enregistrements de service (enregistrements SRV) pour le hostname. L'argument addresses passé à la fonction callback sera un tableau d'objets avec les propriétés suivantes :

• priority
• weight
• port
• name

{
  priority: 10,
  weight: 5,
  port: 21223,
  name: 'service.example.com'
}

dns.resolveTxt(hostname, callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève maintenant ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v0.1.27	Ajouté dans : v0.1.27

• hostname <string>
• callback <Function>
  • err <Error>
  • records <string[][]>

Utilise le protocole DNS pour résoudre les requêtes de texte (enregistrements TXT) pour le hostname. L'argument records passé à la fonction callback est un tableau bidimensionnel des enregistrements de texte disponibles pour hostname (par exemple : [ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Chaque sous-tableau contient des blocs TXT d'un enregistrement. Selon le cas d'utilisation, ceux-ci peuvent être joints ou traités séparément.

dns.reverse(ip, callback)

Ajouté dans : v0.1.16

• ip <string>
• callback <Function>
  • err <Error>
  • hostnames <string[]>

Effectue une requête DNS inverse qui résout une adresse IPv4 ou IPv6 en un tableau de noms d'hôtes.

En cas d'erreur, err est un objet Error, où err.code est l'un des codes d'erreur DNS.

dns.setDefaultResultOrder(order)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est désormais prise en charge.
v17.0.0	La valeur par défaut a été modifiée à verbatim.
v16.4.0, v14.18.0	Ajouté dans : v16.4.0, v14.18.0

• order <string> doit être 'ipv4first', 'ipv6first' ou 'verbatim'.

Définit la valeur par défaut de order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : définit order par défaut sur ipv4first.
• ipv6first : définit order par défaut sur ipv6first.
• verbatim : définit order par défaut sur verbatim.

La valeur par défaut est verbatim et dns.setDefaultResultOrder() a une priorité plus élevée que --dns-result-order. Lors de l'utilisation de threads de travail, dns.setDefaultResultOrder() du thread principal n'affectera pas les ordres DNS par défaut dans les threads de travail.

dns.getDefaultResultOrder()

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est désormais prise en charge.
v20.1.0, v18.17.0	Ajouté dans : v20.1.0, v18.17.0

Obtient la valeur par défaut de order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : pour order par défaut sur ipv4first.
• ipv6first : pour order par défaut sur ipv6first.
• verbatim : pour order par défaut sur verbatim.

dns.setServers(servers)

Ajouté dans : v0.11.3

• servers <string[]> tableau d’adresses formatées RFC 5952

Définit l’adresse IP et le port des serveurs à utiliser lors de l’exécution de la résolution DNS. L’argument servers est un tableau d’adresses formatées RFC 5952. Si le port est le port DNS par défaut de l’IANA (53), il peut être omis.

dns.setServers(['8.8.8.8', '[2001:4860:4860::8888]', '8.8.8.8:1053', '[2001:4860:4860::8888]:1053'])

Une erreur sera levée si une adresse invalide est fournie.

La méthode dns.setServers() ne doit pas être appelée pendant qu’une requête DNS est en cours.

La méthode dns.setServers() affecte uniquement dns.resolve(), dns.resolve*() et dns.reverse() (et spécifiquement pas dns.lookup()).

Cette méthode fonctionne beaucoup comme resolve.conf. C’est-à-dire que si une tentative de résolution avec le premier serveur fourni entraîne une erreur NOTFOUND, la méthode resolve() ne tentera pas de résoudre avec les serveurs suivants fournis. Les serveurs DNS de secours ne seront utilisés que si les serveurs précédents expirent ou entraînent une autre erreur.

API DNS de promesses

[Historique]

Version	Changements
v15.0.0	Exposé comme require('dns/promises').
v11.14.0, v10.17.0	Cette API n’est plus expérimentale.
v10.6.0	Ajouté dans : v10.6.0

L’API dns.promises fournit un autre ensemble de méthodes DNS asynchrones qui renvoient des objets Promise au lieu d’utiliser des rappels. L’API est accessible via require('node:dns').promises ou require('node:dns/promises').

Classe : dnsPromises.Resolver

Ajouté dans : v10.6.0

Un résolveur indépendant pour les requêtes DNS.

La création d’un nouveau résolveur utilise les paramètres de serveur par défaut. La définition des serveurs utilisés pour un résolveur à l’aide de resolver.setServers() n’affecte pas les autres résolveurs :

ESM

import { Resolver } from 'node:dns/promises'
const resolver = new Resolver()
resolver.setServers(['4.4.4.4'])

// Cette requête utilisera le serveur à 4.4.4.4, indépendamment des paramètres globaux.
const addresses = await resolver.resolve4('example.org')

CJS

const { Resolver } = require('node:dns').promises
const resolver = new Resolver()
resolver.setServers(['4.4.4.4'])

// Cette requête utilisera le serveur à 4.4.4.4, indépendamment des paramètres globaux.
resolver.resolve4('example.org').then(addresses => {
  // ...
})

// Alternativement, le même code peut être écrit en utilisant le style async-await.
;(async function () {
  const addresses = await resolver.resolve4('example.org')
})()

Les méthodes suivantes de l’API dnsPromises sont disponibles :

• resolver.getServers()
• resolver.resolve()
• resolver.resolve4()
• resolver.resolve6()
• resolver.resolveAny()
• resolver.resolveCaa()
• resolver.resolveCname()
• resolver.resolveMx()
• resolver.resolveNaptr()
• resolver.resolveNs()
• resolver.resolvePtr()
• resolver.resolveSoa()
• resolver.resolveSrv()
• resolver.resolveTxt()
• resolver.reverse()
• resolver.setServers()

resolver.cancel()

Ajouté dans : v15.3.0, v14.17.0

Annule toutes les requêtes DNS en attente effectuées par ce résolveur. Les promesses correspondantes seront rejetées avec une erreur ayant le code ECANCELLED.

dnsPromises.getServers()

Ajouté dans : v10.6.0

• Retourne : <string[]>

Retourne un tableau de chaînes d’adresses IP, formatées selon la RFC 5952, qui sont actuellement configurées pour la résolution DNS. Une chaîne inclura une section de port si un port personnalisé est utilisé.

;['8.8.8.8', '2001:4860:4860::8888', '8.8.8.8:1053', '[2001:4860:4860::8888]:1053']

dnsPromises.lookup(hostname[, options])

[Historique]

Version	Modifications
v22.1.0, v20.13.0	L'option verbatim est désormais obsolète au profit de la nouvelle option order.
v10.6.0	Ajouté dans : v10.6.0

• hostname <string>
• options <integer> | <Object>
  • family <integer> La famille d’enregistrements. Doit être 4, 6 ou 0. La valeur 0 indique qu’une adresse IPv4 ou IPv6 est retournée. Si la valeur 0 est utilisée avec { all: true } (voir ci-dessous), l’une ou l’autre, ou les deux, des adresses IPv4 et IPv6 sont retournées, selon le résolveur DNS du système. Par défaut : 0.
  • hints <number> Un ou plusieurs indicateurs getaddrinfo pris en charge. Plusieurs indicateurs peuvent être passés en utilisant l’opération OU bit à bit de leurs valeurs.
  • all <boolean> Lorsque true, la Promise est résolue avec toutes les adresses dans un tableau. Sinon, retourne une seule adresse. Par défaut : false.
  • order <string> Lorsque verbatim, la Promise est résolue avec les adresses IPv4 et IPv6 dans l’ordre où le résolveur DNS les a retournées. Lorsque ipv4first, les adresses IPv4 sont placées avant les adresses IPv6. Lorsque ipv6first, les adresses IPv6 sont placées avant les adresses IPv4. Par défaut : verbatim (les adresses ne sont pas réordonnées). La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order. Le nouveau code doit utiliser { order: 'verbatim' }.
  • verbatim <boolean> Lorsque true, la Promise est résolue avec les adresses IPv4 et IPv6 dans l’ordre où le résolveur DNS les a retournées. Lorsque false, les adresses IPv4 sont placées avant les adresses IPv6. Cette option sera obsolète au profit de order. Lorsque les deux sont spécifiés, order a une priorité plus élevée. Le nouveau code ne doit utiliser que order. Par défaut : actuellement false (les adresses sont réordonnées), mais cela devrait changer dans un avenir pas trop lointain. La valeur par défaut est configurable à l’aide de dns.setDefaultResultOrder() ou --dns-result-order.

Résout un nom d’hôte (par exemple, 'nodejs.org') dans le premier enregistrement A (IPv4) ou AAAA (IPv6) trouvé. Toutes les propriétés option sont facultatives. Si options est un entier, il doit être 4 ou 6 – si options n’est pas fourni, alors les adresses IPv4 ou IPv6, ou les deux, sont retournées si elles sont trouvées.

Avec l’option all définie sur true, la Promise est résolue avec addresses étant un tableau d’objets avec les propriétés address et family.

En cas d’erreur, la Promise est rejetée avec un objet Error, où err.code est le code d’erreur. Gardez à l’esprit que err.code sera défini sur 'ENOTFOUND' non seulement lorsque le nom d’hôte n’existe pas, mais aussi lorsque la recherche échoue d’autres manières telles que l’absence de descripteurs de fichiers disponibles.

dnsPromises.lookup() n’a pas nécessairement de lien avec le protocole DNS. L’implémentation utilise une fonctionnalité du système d’exploitation qui peut associer des noms à des adresses et inversement. Cette implémentation peut avoir des conséquences subtiles mais importantes sur le comportement de tout programme Node.js. Veuillez prendre le temps de consulter la section Considérations relatives à l’implémentation avant d’utiliser dnsPromises.lookup().

Exemple d’utilisation :

ESM

import dns from 'node:dns'
const dnsPromises = dns.promises
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
}

await dnsPromises.lookup('example.org', options).then(result => {
  console.log('adresse : %j famille : IPv%s', result.address, result.family)
  // adresse : "2606:2800:21f:cb07:6820:80da:af6b:8b2c" famille : IPv6
})

// Lorsque options.all est true, le résultat sera un tableau.
options.all = true
await dnsPromises.lookup('example.org', options).then(result => {
  console.log('adresses : %j', result)
  // adresses : [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]
})

CJS

const dns = require('node:dns')
const dnsPromises = dns.promises
const options = {
  family: 6,
  hints: dns.ADDRCONFIG | dns.V4MAPPED,
}

dnsPromises.lookup('example.org', options).then(result => {
  console.log('adresse : %j famille : IPv%s', result.address, result.family)
  // adresse : "2606:2800:21f:cb07:6820:80da:af6b:8b2c" famille : IPv6
})

// Lorsque options.all est true, le résultat sera un tableau.
options.all = true
dnsPromises.lookup('example.org', options).then(result => {
  console.log('adresses : %j', result)
  // adresses : [{"address":"2606:2800:21f:cb07:6820:80da:af6b:8b2c","family":6}]
})

dnsPromises.lookupService(address, port)

Ajouté dans : v10.6.0

• address <string>
• port <number>

Résout l’adresse et le port donnés en un nom d’hôte et un service en utilisant l’implémentation getnameinfo sous-jacente du système d’exploitation.

Si address n’est pas une adresse IP valide, une TypeError sera levée. Le port sera converti en nombre. S’il ne s’agit pas d’un port légal, une TypeError sera levée.

En cas d’erreur, la Promise est rejetée avec un objet Error, où err.code est le code d’erreur.

ESM

import dnsPromises from 'node:dns/promises'
const result = await dnsPromises.lookupService('127.0.0.1', 22)

console.log(result.hostname, result.service) // Affiche : localhost ssh

CJS

const dnsPromises = require('node:dns').promises
dnsPromises.lookupService('127.0.0.1', 22).then(result => {
  console.log(result.hostname, result.service)
  // Affiche : localhost ssh
})

dnsPromises.resolve(hostname[, rrtype])

Ajouté dans : v10.6.0

• hostname <string> Nom d’hôte à résoudre.
• rrtype <string> Type d’enregistrement de ressource. Par défaut : 'A'.

Utilise le protocole DNS pour résoudre un nom d’hôte (par exemple, 'nodejs.org') en un tableau d’enregistrements de ressource. En cas de succès, la Promise est résolue avec un tableau d’enregistrements de ressource. Le type et la structure des résultats individuels varient en fonction de rrtype :

rrtype	records contient	Type de résultat	Méthode abrégée
'A'	Adresses IPv4 (par défaut)	<string>	dnsPromises.resolve4()
'AAAA'	Adresses IPv6	<string>	dnsPromises.resolve6()
'ANY'	Tous les enregistrements	<Object>	dnsPromises.resolveAny()
'CAA'	Enregistrements d’autorisation CA	<Object>	dnsPromises.resolveCaa()
'CNAME'	Enregistrements de nom canonique	<string>	dnsPromises.resolveCname()
'MX'	Enregistrements d’échange de mail	<Object>	dnsPromises.resolveMx()
'NAPTR'	Enregistrements de pointeur d’autorité de nom	<Object>	dnsPromises.resolveNaptr()
'NS'	Enregistrements de serveur de noms	<string>	dnsPromises.resolveNs()
'PTR'	Enregistrements de pointeur	<string>	dnsPromises.resolvePtr()
'SOA'	Enregistrements de début d’autorité	<Object>	dnsPromises.resolveSoa()
'SRV'	Enregistrements de service	<Object>	dnsPromises.resolveSrv()
'TXT'	Enregistrements de texte	<string[]>	dnsPromises.resolveTxt()

En cas d’erreur, la Promise est rejetée avec un objet Error, où err.code est l’un des codes d’erreur DNS.

dnsPromises.resolve4(hostname[, options])

Ajouté dans : v10.6.0

• hostname <string> Nom d'hôte à résoudre.
• options <Object>
  • ttl <boolean> Récupérer la valeur Time-To-Live (TTL) de chaque enregistrement. Lorsque la valeur est true, la Promise est résolue avec un tableau d'objets { address: '1.2.3.4', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

Utilise le protocole DNS pour résoudre les adresses IPv4 (enregistrements A) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'adresses IPv4 (par exemple ['74.125.79.104', '74.125.79.105', '74.125.79.106']).

dnsPromises.resolve6(hostname[, options])

Ajouté dans : v10.6.0

• hostname <string> Nom d'hôte à résoudre.
• options <Object>
  • ttl <boolean> Récupérer la valeur Time-To-Live (TTL) de chaque enregistrement. Lorsque la valeur est true, la Promise est résolue avec un tableau d'objets { address: '0:1:2:3:4:5:6:7', ttl: 60 } plutôt qu'un tableau de chaînes, avec le TTL exprimé en secondes.

Utilise le protocole DNS pour résoudre les adresses IPv6 (enregistrements AAAA) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d'adresses IPv6.

dnsPromises.resolveAny(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre tous les enregistrements (également appelé requête ANY ou *). En cas de succès, la Promise est résolue avec un tableau contenant différents types d'enregistrements. Chaque objet a une propriété type qui indique le type de l'enregistrement actuel. Et en fonction du type, des propriétés supplémentaires seront présentes sur l'objet :

Type	Propriétés
'A'	address / ttl
'AAAA'	address / ttl
'CNAME'	value
'MX'	Voir dnsPromises.resolveMx()
'NAPTR'	Voir dnsPromises.resolveNaptr()
'NS'	value
'PTR'	value
'SOA'	Voir dnsPromises.resolveSoa()
'SRV'	Voir dnsPromises.resolveSrv()
'TXT'	Ce type d'enregistrement contient une propriété de tableau appelée entries qui fait référence à dnsPromises.resolveTxt(), par exemple { entries: ['...'], type: 'TXT' }

Voici un exemple de l'objet de résultat :

;[
  { type: 'A', address: '127.0.0.1', ttl: 299 },
  { type: 'CNAME', value: 'example.com' },
  { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 },
  { type: 'NS', value: 'ns1.example.com' },
  { type: 'TXT', entries: ['v=spf1 include:_spf.example.com ~all'] },
  {
    type: 'SOA',
    nsname: 'ns1.example.com',
    hostmaster: 'admin.example.com',
    serial: 156696742,
    refresh: 900,
    retry: 900,
    expire: 1800,
    minttl: 60,
  },
]

dnsPromises.resolveCaa(hostname)

Ajouté dans : v15.0.0, v14.17.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements CAA pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’objets contenant les enregistrements d’autorisation d’autorité de certification disponibles pour le hostname (par exemple, [{critical: 0, iodef: 'mailto:[email protected]'},{critical: 128, issue: 'pki.example.com'}]).

dnsPromises.resolveCname(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements CNAME pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’enregistrements de nom canonique disponibles pour le hostname (par exemple, ['bar.example.com']).

dnsPromises.resolveMx(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements d’échange de courrier (enregistrements MX) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’objets contenant à la fois une propriété priority et une propriété exchange (par exemple, [{priority: 10, exchange: 'mx.example.com'}, ...]).

dnsPromises.resolveNaptr(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements basés sur des expressions régulières (enregistrements NAPTR) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’objets ayant les propriétés suivantes :

• flags
• service
• regexp
• replacement
• order
• preference

{
  flags: 's',
  service: 'SIP+D2U',
  regexp: '',
  replacement: '_sip._udp.example.com',
  order: 30,
  preference: 100
}

dnsPromises.resolveNs(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de serveur de noms (enregistrements NS) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’enregistrements de serveur de noms disponibles pour le hostname (par exemple, ['ns1.example.com', 'ns2.example.com']).

dnsPromises.resolvePtr(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de pointeur (enregistrements PTR) pour le hostname. En cas de succès, la Promise est résolue avec un tableau de chaînes contenant les enregistrements de réponse.

dnsPromises.resolveSoa(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre un enregistrement de début d’autorité (enregistrement SOA) pour le hostname. En cas de succès, la Promise est résolue avec un objet ayant les propriétés suivantes :

• nsname
• hostmaster
• serial
• refresh
• retry
• expire
• minttl

{
  nsname: 'ns.example.com',
  hostmaster: 'root.example.com',
  serial: 2013101809,
  refresh: 10000,
  retry: 2400,
  expire: 604800,
  minttl: 3600
}

dnsPromises.resolveSrv(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les enregistrements de service (enregistrements SRV) pour le hostname. En cas de succès, la Promise est résolue avec un tableau d’objets ayant les propriétés suivantes :

• priority
• weight
• port
• name

{
  priority: 10,
  weight: 5,
  port: 21223,
  name: 'service.example.com'
}

dnsPromises.resolveTxt(hostname)

Ajouté dans : v10.6.0

• hostname <string>

Utilise le protocole DNS pour résoudre les requêtes de texte (enregistrements TXT) pour le hostname. En cas de succès, la Promise est résolue avec un tableau bidimensionnel des enregistrements de texte disponibles pour hostname (par ex. [ ['v=spf1 ip4:0.0.0.0 ', '~all' ] ]). Chaque sous-tableau contient des blocs TXT d’un enregistrement. Selon le cas d’utilisation, ceux-ci peuvent être joints ou traités séparément.

dnsPromises.reverse(ip)

Ajouté dans la version : v10.6.0

• ip <string>

Effectue une requête DNS inverse qui résout une adresse IPv4 ou IPv6 en un tableau de noms d’hôtes.

En cas d’erreur, la Promise est rejetée avec un objet Error, où err.code est l’un des codes d’erreur DNS.

dnsPromises.setDefaultResultOrder(order)

[Historique]

Version	Modifications
v22.1.0, v20.13.0	La valeur ipv6first est désormais prise en charge.
v17.0.0	La valeur par défaut a été remplacée par verbatim.
v16.4.0, v14.18.0	Ajouté dans : v16.4.0, v14.18.0

• order <string> doit être 'ipv4first', 'ipv6first' ou 'verbatim'.

Définit la valeur par défaut de order dans dns.lookup() et dnsPromises.lookup(). La valeur peut être :

• ipv4first : définit order par défaut sur ipv4first.
• ipv6first : définit order par défaut sur ipv6first.
• verbatim : définit order par défaut sur verbatim.

La valeur par défaut est verbatim, et dnsPromises.setDefaultResultOrder() est prioritaire sur --dns-result-order. Lors de l’utilisation de threads de worker, dnsPromises.setDefaultResultOrder() à partir du thread principal n’affecte pas les ordres DNS par défaut dans les workers.

dnsPromises.getDefaultResultOrder()

Ajouté dans la version : v20.1.0, v18.17.0

Obtient la valeur de dnsOrder.

dnsPromises.setServers(servers)

Ajouté dans la version : v10.6.0

• servers <string[]> tableau d’adresses formatées RFC 5952

Définit l’adresse IP et le port des serveurs à utiliser lors de la résolution DNS. L’argument servers est un tableau d’adresses formatées RFC 5952. Si le port est le port DNS par défaut IANA (53), il peut être omis.

dnsPromises.setServers(['8.8.8.8', '[2001:4860:4860::8888]', '8.8.8.8:1053', '[2001:4860:4860::8888]:1053'])

Une erreur sera levée si une adresse non valide est fournie.

La méthode dnsPromises.setServers() ne doit pas être appelée pendant qu’une requête DNS est en cours.

Cette méthode fonctionne un peu comme resolve.conf. Autrement dit, si la tentative de résolution avec le premier serveur fourni génère une erreur NOTFOUND, la méthode resolve() ne tentera pas de résoudre avec les serveurs suivants fournis. Les serveurs DNS de secours ne seront utilisés que si les précédents expirent ou génèrent une autre erreur.

Codes d’erreur

Chaque requête DNS peut renvoyer l’un des codes d’erreur suivants :

• dns.NODATA : le serveur DNS a renvoyé une réponse sans données.
• dns.FORMERR : le serveur DNS affirme que la requête est mal formatée.
• dns.SERVFAIL : le serveur DNS a renvoyé une erreur générale.
• dns.NOTFOUND : nom de domaine introuvable.
• dns.NOTIMP : le serveur DNS n’implémente pas l’opération demandée.
• dns.REFUSED : le serveur DNS a refusé la requête.
• dns.BADQUERY : requête DNS mal formatée.
• dns.BADNAME : nom d’hôte mal formaté.
• dns.BADFAMILY : famille d’adresses non prise en charge.
• dns.BADRESP : réponse DNS mal formatée.
• dns.CONNREFUSED : impossible de contacter les serveurs DNS.
• dns.TIMEOUT : délai d’attente dépassé lors de la communication avec les serveurs DNS.
• dns.EOF : fin de fichier.
• dns.FILE : erreur de lecture du fichier.
• dns.NOMEM : mémoire insuffisante.
• dns.DESTRUCTION : le canal est en cours de destruction.
• dns.BADSTR : chaîne mal formatée.
• dns.BADFLAGS : indicateurs illégaux spécifiés.
• dns.NONAME : le nom d’hôte donné n’est pas numérique.
• dns.BADHINTS : indicateurs d’indices illégaux spécifiés.
• dns.NOTINITIALIZED : l’initialisation de la bibliothèque c-ares n’a pas encore été effectuée.
• dns.LOADIPHLPAPI : erreur de chargement de iphlpapi.dll.
• dns.ADDRGETNETWORKPARAMS : impossible de trouver la fonction GetNetworkParams.
• dns.CANCELLED : requête DNS annulée.

L’API dnsPromises exporte également les codes d’erreur ci-dessus, par exemple, dnsPromises.NODATA.

Considérations relatives à l’implémentation

Bien que dns.lookup() et les différentes fonctions dns.resolve*()/dns.reverse() aient le même objectif d’associer un nom de réseau à une adresse réseau (ou vice versa), leur comportement est très différent. Ces différences peuvent avoir des conséquences subtiles mais importantes sur le comportement des programmes Node.js.

dns.lookup()

En interne, dns.lookup() utilise les mêmes fonctionnalités du système d’exploitation que la plupart des autres programmes. Par exemple, dns.lookup() résoudra presque toujours un nom donné de la même manière que la commande ping. Sur la plupart des systèmes d’exploitation de type POSIX, le comportement de la fonction dns.lookup() peut être modifié en changeant les paramètres dans nsswitch.conf(5) et/ou resolv.conf(5), mais la modification de ces fichiers modifiera le comportement de tous les autres programmes s’exécutant sur le même système d’exploitation.

Bien que l’appel à dns.lookup() soit asynchrone du point de vue de JavaScript, il est implémenté comme un appel synchrone à getaddrinfo(3) qui s’exécute sur le pool de threads de libuv. Cela peut avoir des implications négatives surprenantes en matière de performances pour certaines applications, voir la documentation de UV_THREADPOOL_SIZE pour plus d’informations.

Diverses API de mise en réseau appelleront dns.lookup() en interne pour résoudre les noms d’hôtes. Si cela pose problème, envisagez de résoudre le nom d’hôte en une adresse en utilisant dns.resolve() et d’utiliser l’adresse au lieu d’un nom d’hôte. En outre, certaines API de mise en réseau (telles que socket.connect() et dgram.createSocket()) permettent de remplacer le résolveur par défaut, dns.lookup().

dns.resolve(), dns.resolve*(), et dns.reverse()

Ces fonctions sont implémentées de manière très différente de dns.lookup(). Elles n'utilisent pas getaddrinfo(3) et effectuent toujours une requête DNS sur le réseau. Cette communication réseau est toujours effectuée de manière asynchrone et n'utilise pas le pool de threads de libuv.

Par conséquent, ces fonctions ne peuvent pas avoir le même impact négatif sur les autres traitements qui se produisent sur le pool de threads de libuv que dns.lookup() peut avoir.

Elles n'utilisent pas le même ensemble de fichiers de configuration que dns.lookup(). Par exemple, elles n'utilisent pas la configuration de /etc/hosts.