Node.js dns-Modul

Java FileNode.js integrierte Module

von Node.jsdnsModul ist ein Kernmodul für Abfragen des Domain Name System (DNS). DNS (Domain Name System) ist ein System, das für Menschen lesbare Domänennamen (wie z. B.www.example.com) in maschinenlesbare IP-Adressen (wie z. B.192.0.2.1).

Warum benötigen Sie das dns-Modul

In der Netzwerkkommunikation identifizieren Computer sich tatsächlich gegenseitig über IP-Adressen, aber Menschen finden es einfacher, sich Domänennamen als numerische IP-Adressen zu merken.dnsDas Modul bietet die Möglichkeit, in Node.js-Anwendungen Domänennamenauflösung durchzuführen, sodass Entwickler:

  • Domänennamen in IP-Adressen auflösen
  • IP-Adressen umgekehrt in Domänennamen auflösen
  • DNS-Einträge abfragen (MX, TXT, SRV usw.)

Grundlegende Verwendung des dns-Moduls

Importieren des dns-Moduls

Um dasdnsModul, müssen Sie es zuerst importieren:

const dns = require('dns');

Grundlegende Auflösungsmethoden

dnsDas Modul bietet mehrere Auflösungsmethoden. Die am häufigsten verwendete istlookupundresolve。

dns.lookup()

dns.lookup()ist die einfachste Methode zur Domainauflösung. Sie verwendet die vom Betriebssystem bereitgestellte Funktionalität, um DNS-Abfragen durchzuführen:

Beispiel

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

dns.resolve()

dns.resolve()bietet eine feinere Steuerung und kann bestimmte Arten von DNS-Einträgen abfragen:

Beispiel

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

Hauptmethoden des dns-Moduls

Forward-Auflösung

Forward-Auflösung ist der Vorgang, einen Domainnamen in eine IP-Adresse aufzulösen:

Beispiel

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

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

Reverse-Auflösung

Reverse-Auflösung ist der Vorgang, eine IP-Adresse in einen Domainnamen aufzulösen:

Beispiel

dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(`Ergebnis der Reverse-Auflösung: ${hostnames}`);
});

Abfragen anderer DNS-Einträge

dnsDas Modul unterstützt auch das Abfragen anderer Arten von DNS-Einträgen:

Beispiel

// MX-Eintrag (Mail-Exchange-Eintrag)
dns.resolveMx('google.com', (err, addresses) => {
  if (err) throw err;
  console.log(`MX-Eintrag: ${JSON.stringify(addresses)}`);
});

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

Synchrone und asynchrone Methoden

Asynchrone Methoden

Standardmäßig,dnsDie Methoden des Moduls sind asynchron und verwenden Callback-Funktionen, um Ergebnisse zu verarbeiten:

Beispiel

dns.lookup('nodejs.org', (err, address, Familie) => {
  console.log('Asynchrones Ergebnis:', address);
});

Promise-Version

Ab Node.js v10.6.0,dnsDie Methoden des Moduls bieten auch Promise-basierte Versionen:

Beispiel

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

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

lookupExample();

Fehlerbehandlung

DNS-Abfragen können fehlschlagen, daher ist die korrekte Behandlung von Fehlern sehr wichtig:

Beispiel

dns.lookup('nonexistent.example.com', (err, address) => {
  if (err) {
    if (err.code === 'ENOTFOUND') {
      console.log('Domain existiert nicht');
    } else {
      console.log('Unbekannter Fehler:', err);
    }
    return;
  }
  console.log('Adresse:', address);
});

Zu den häufigen DNS-Fehlercodes gehören:

  • ENOTFOUND: Domain existiert nicht
  • ESERVFAIL: DNS-Server hat einen Fehler zurückgegeben
  • ETIMEOUT: DNS-Abfrage ist zeitlich abgelaufen

Praktische Anwendungsbeispiele

Prüfen, ob eine Domain aufgelöst werden kann

Beispiel

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

isDomainResolvable('google.com').dann(result => {
  console.log('Domain ist auflösbar:', result);
});

Batch-Auflösung von Domänennamen

Beispiel

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('Auflösung fehlgeschlagen:', err);
  });

Leistungsüberlegungen

DNS-Abfragen sind I/O-Operationen und können die Anwendungsleistung beeinträchtigen:

  1. Ergebnisse zwischenspeichern: Für häufig abgefragte Domänen sollten Sie Ergebnisse auf Anwendungsebene zwischenspeichern
  2. Parallelitätsgrenzen: Vermeiden Sie eine große Anzahl gleichzeitiger DNS-Abfragen
  3. Timeout-Einstellungen: Legen Sie ein angemessenes Timeout für DNS-Abfragen fest

Beispiel

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;
}

Methode

MethodeBeschreibungBeispiel
dns.lookup(hostname[, options], callback)Löst einen Hostnamen in die erste IPv4- oder IPv6-Adresse auf. Der optionale Parameteroptionswird verwendet, um die Auflösungsmethode anzugeben, wie z. B.family(4 oder 6).dns.lookup('example.com', (err, address) => {});
dns.resolve(hostname[, rrtype], callback)Fragt DNS-Einträge eines angegebenen Eintragstyps ab und gibt standardmäßig A-Einträge zurück. Unterstützte Typen sind A, AAAA, MX, TXT usw.dns.resolve('example.com', 'MX', (err, addresses) => {});
dns.resolve4(hostname, callback)Fragt die IPv4-Adressen eines Hostnamens ab.dns.resolve4('example.com', (err, addresses) => {});
dns.resolve6(hostname, callback)Fragt die IPv6-Adressen eines Hostnamens ab.dns.resolve6('example.com', (err, addresses) => {});
dns.resolveMx(hostname, callback)Fragt die MX-Einträge (Mail Exchange) eines Hostnamens ab.dns.resolveMx('example.com', (err, addresses) => {});
dns.resolveTxt(hostname, callback)Fragt die TXT-(Text-)Einträge eines Hostnamens ab.dns.resolveTxt('example.com', (err, records) => {});
dns.reverse(ip, callback)Löst eine IP-Adresse in einen Hostnamen auf.dns.reverse('8.8.8.8', (err, hostnames) => {});
dns.getServers()Gibt ein Array der aktuellen DNS-Server zurück.console.log(dns.getServers());
dns.setServers(servers)Legt ein benutzerdefiniertes Array von DNS-Servern fest.dns.setServers(['8.8.8.8', '8.8.4.4']);

rrtypes

Im Folgenden sind die gültigen rrtypes-Werte in der Methode dns.resolve() aufgeführt:

  • 'A'IPv4-Adresse, Standard
  • 'AAAA'IPv6-Adresse
  • 'MX'Mail-Exchange-Einträge
  • 'TXT'Text-Einträge
  • 'SRV'SRV-Einträge
  • 'PTR'Wird für die Reverse-IP-Abfrage verwendet.
  • 'NS'Domänennamenserver-Einträge
  • 'CNAME'Alias-Einträge
  • 'SOA'Anfangswert des autoritativen Datensatzes

Fehlercodes

Jede DNS-Abfrage kann die folgenden Fehlercodes zurückgeben:

  • dns.NODATA: Keine Datenantwort.
  • dns.FORMERR: Fehler im Abfrageformat.
  • dns.SERVFAIL: Allgemeiner Fehler.
  • dns.NOTFOUND: Domänenname nicht gefunden.
  • dns.NOTIMP: Die angeforderte Operation ist nicht implementiert.
  • dns.REFUSED: Abfrage abgelehnt.
  • dns.BADQUERY: Fehler im Abfrageformat.
  • dns.BADNAME: Fehler im Domänennamenformat.
  • dns.BADFAMILY: Adressprotokoll wird nicht unterstützt.
  • dns.BADRESP: Fehler im Antwortformat.
  • dns.CONNREFUSED: Verbindung zum DNS-Server nicht möglich.
  • dns.TIMEOUT: Zeitüberschreitung beim Verbinden mit dem DNS-Server.
  • dns.EOF: Ende der Datei.
  • dns.FILE: Fehler beim Lesen der Datei.
  • dns.NOMEM: Speicherüberlauf.
  • dns.DESTRUCTION: Kanal zerstört.
  • dns.BADSTR: Fehler im Zeichenfolgenformat.
  • dns.BADFLAGS: Ungültiger Bezeichner.
  • dns.NONAME: Der angegebene Host ist nicht numerisch.
  • dns.BADHINTS: Ungültiger HINTS-Bezeichner.
  • dns.NOTINITIALIZED: Die c-ares-Bibliothek wurde nicht initialisiert.
  • dns.LOADIPHLPAPI: Fehler beim Laden von iphlpapi.dll.
  • dns.ADDRGETNETWORKPARAMS: Die Funktion GetNetworkParams wurde nicht gefunden.
  • dns.CANCELLED: DNS-Abfrage abgebrochen.

Beispiel

Im Folgenden finden sich einige Beispiele für gängige Methoden des dns-Moduls; sie zeigen, wie man die IP-Adresse eines Hosts abfragt, DNS-Einträge abruft und so weiter.

1. Verwenden Sie dns.lookup(), um eine IP-Adresse zu erhalten

Beispiel

const dns = require('dns');

// IPv4-Adresse einer Domain nachschlagen
dns.lookup('example.com', (err, address, Familie) => {
  if (err) throw err;
  console.log(`IP-Adresse: ${address},Adressfamilie: IPv${family}`);
});

dns.lookup() ist eine vereinfachte Schnittstelle, die die erste IPv4- oder IPv6-Adresse für den angegebenen Hostnamen findet.

2. Verwenden Sie dns.resolve(), um verschiedene Arten von DNS-Einträgen abzufragen

Beispiel

const dns = require('dns');

// MX-Einträge abfragen
dns.resolve('example.com', 'MX', (err, addresses) => {
  if (err) throw err;
  console.log('MX-Einträge:', addresses);
});

// TXT-Einträge abfragen
dns.resolve('example.com', 'TXT', (err, records) => {
  if (err) throw err;
  console.log('TXT-Einträge:', records);
});

Mit dns.resolve() können Sie Datensatztypen (wie MX, TXT usw.) angeben, um verschiedene DNS-Einträge abzufragen.

3. Verwenden Sie dns.reverse() für eine Reverse-DNS-Abfrage

Beispiel

const dns = require('dns');

// Reverse-Auflösung einer IP-Adresse in einen Hostnamen
dns.reverse('8.8.8.8', (err, hostnames) => {
  if (err) throw err;
  console.log(Hostname von `8.8.8.8: ${hostnames}`);
});

Die Reverse-Auflösung löst eine IP-Adresse zu einem Domänennamen auf und wird oft verwendet, um die Übereinstimmung zwischen einem Domänennamen und einer IP-Adresse zu prüfen.

4. DNS-Server abrufen und festlegen

Beispiel

const dns = require('dns');

// Aktuelle DNS-Serverliste abrufen
console.log('Aktuelle DNS-Server:', dns.getServers());

// Einen benutzerdefinierten DNS-Server festlegen
dns.setServers(['1.1.1.1', '8.8.8.8']);
console.log('Neuer DNS-Server:', dns.getServers());

Mit dns.getServers() können Sie die Liste der aktuell auf dem System konfigurierten DNS-Server abrufen. dns.setServers() ermöglicht es Ihnen, benutzerdefinierte DNS-Server festzulegen, sodass bestimmte DNS-Auflösungsdienste für Abfragen verwendet werden können.

Asynchrone und synchrone Methoden

  • Asynchrone Methoden: wie zum Beispieldns.lookup()、dns.resolve()etc., nicht blockierend, geeignet für nebenläufige Aufgaben.
  • Synchrone Methoden: wie zum Beispieldns.lookupSync()、dns.resolve4Sync(), blockierend, geeignet für den Einsatz in kleinem Umfang, Verwendung in Szenarien mit hoher Nebenläufigkeit vermeiden.

Praktische Anwendungsszenarien

  • Domänennamenauflösung für Webanwendungen: Die IP-Adresse eines Domänennamens auf dem Server abfragen, um Webseiten oder Ressourcen abzurufen.
  • Überprüfung der Mailserver-Konfiguration: Die Korrektheit der Mailserver-Konfiguration anhand von MX-Einträgen überprüfen.
  • Anti-Spam: Durch Reverse-DNS-Abfrage wird erkannt, ob der Server, der E-Mails sendet, mit dem Domainnamen übereinstimmt, wodurch die Quelle von Spam identifiziert wird.
  • Lastverteilung: Durch Auflösen der verschiedenen IP-Adressen eines Domainnamens wird ein Lastverteilungsschema erstellt, um den Datenverkehr auf mehrere Server zu verteilen.

dnsDas Modul ermöglicht es Node.js-Anwendungen, Domainnamen aufzulösen und DNS-Abfragen durchzuführen, was ihnen mehr Flexibilität bei der Handhabung der Netzwerkkommunikation gibt. Durch asynchrone Schnittstellen können DNS-Abfragen effizient abgeschlossen werden, ohne den Hauptthread zu blockieren.

Java FileNode.js integrierte Module

Weitere Erweiterungen