DNS moduli
DNS moduliga kirish
DNS (Domain Name System) moduli Node.js’da nomlarni aniqlash (name resolution) funksiyalarini taqdim etadi.
U ikkita asosiy APIni taklif qiladi:
- Callback-ga asoslangan API: callback funksiyalariga ega an’anaviy Node.js uslubi
- Promise-ga asoslangan API:
dns.promisesorqali zamonaviy async/await qo‘llab-quvvatlashi
Asosiy xususiyatlarga quyidagilar kiradi:
- Domen nomlarini IP manzillarga aylantirish (A/AAAA yozuvlari)
- Teskari DNS qidiruvlarini bajarish (PTR yozuvlari)
- Turli DNS yozuv turlarini so‘rash (MX, TXT, SRV va boshqalar)
- Muayyan sozlamalar bilan maxsus DNS resolverlarini yaratish
- DNS server sozlamalarini dasturiy ravishda sozlash
Eslatma: DNS moduli ikki xil rejimda ishlashi mumkin - operatsion tizim imkoniyatlaridan foydalanish yoki to‘g‘ridan-to‘g‘ri tarmoq DNS so‘rovlarini bajarish.
Bu ilovangizda xost nomini aniqlash (resolution) qanday ishlashiga ta’sir qiladi.
DNS bilan ishlashni boshlash
Domenning IP manzilini qidirish uchun DNS modulidan foydalanishning tezkor misoli:
Asosiy DNS qidiruvi
const dns = require('dns');
// Look up a domain name
dns.lookup('example.com', (err, address, family) => {
if (err) {
console.error('Lookup error:', err);
return;
}
console.log(`IP address: ${address}`);
console.log(`IP version: IPv${family}`);
});
Misolni ishga tushirish »
Import va sozlash
DNS modulidan foydalanish uchun uni callback-ga yoki Promise-ga asoslangan API yordamida Node.js ilovangizga import qilishingiz mumkin:
Callback-ga asoslangan API
// Import the DNS module
const dns = require('dns');
// Example usage
dns.lookup('example.com', (err, address, family) => {
if (err) throw err;
console.log(`Resolved: ${address} (IPv${family})`);
});
Promise’ga asoslangan API (Node.js 10.0.0+)
// Import the promises API
const { promises: dns } = require('dns');
// Or: const dns = require('dns').promises;
// Example with async/await
async function lookupDomain(domain) {
try {
const address = await dns.lookup(domain);
console.log(`Resolved: ${address.address} (IPv${address.family})`);
} catch (err) {
console.error('Lookup failed:', err);
}
}
lookupDomain('example.com');
Eslatma: Odatda yangi kod uchun Promise-ga asoslangan API afzalroq, chunki u zamonaviy async/await patternlari bilan yaxshiroq ishlaydi va xatolarni yaxshiroq boshqarish imkonini beradi.
Asosiy DNS qidiruvlari
DNS moduli domen nomlari va IP manzillarini qidirishning bir necha usullarini taqdim etadi. Eng keng tarqalgan operatsiyalar:
dns.lookup(): Xost nomlarini aniqlash (resolve) uchun operatsion tizim imkoniyatlaridan foydalanadidns.resolve*(): DNS so‘rovlarini to‘g‘ridan-to‘g‘ri nom serverlariga bajaradidns.reverse(): Teskari DNS qidiruvlarini amalga oshiradi (IP-dan xost nomiga)
Domen nomlarini IP manzillarga aylantirish
const dns = require('dns');
// Callback-based API
dns.lookup('www.example.com', (err, address, family) => {
if (err) throw err;
console.log('IP address: %s', address);
console.log('IP version: IPv%s', family);
});
Misolni ishga tushirish »
const dns = require('dns').promises;
// Promise-based API
async function lookupExample() {
try {
const result = await dns.lookup('www.example.com');
console.log('IP address:', result.address);
console.log('IP version: IPv' + result.family);
} catch (err) {
console.error('Lookup failed:', err);
}
}
lookupExample();
Misolni ishga tushirish »
Eslatma: dns.lookup() metodi nomlarni aniqlash uchun operatsion tizim imkoniyatlaridan foydalanadi va tarmoq aloqasini amalga oshirishi shart emas.
Domen uchun barcha IP manzillarni qidirish
const dns = require('dns');
// Get all IPv4 addresses
dns.resolve4('www.google.com', (err, addresses) => {
if (err) throw err;
console.log('IPv4 addresses:');
addresses.forEach(address => {
console.log(` ${address}`);
});
// Perform a reverse lookup on the first IP
dns.reverse(addresses[0], (err, hostnames) => {
if (err) throw err;
console.log(`Reverse lookup for ${addresses[0]}:`);
hostnames.forEach(hostname => {
console.log(` ${hostname}`);
});
});
});
Misolni ishga tushirish »
DNS yozuvlari turlari
DNS moduli turli xil DNS yozuvlari turlarini qidirishni qo‘llab-quvvatlaydi:
| Metod | Yozuv turi | Tavsif |
|---|---|---|
resolve4() |
A | IPv4 manzillari |
resolve6() |
AAAA | IPv6 manzillari |
resolveMx() |
MX | Pochta almashinuvi yozuvlari |
resolveTxt() |
TXT | Matn yozuvlari |
resolveSrv() |
SRV | Xizmat yozuvlari |
resolveNs() |
NS | Nom server yozuvlari |
resolveCname() |
CNAME | Kanonik nom yozuvlari |
resolveSoa() |
SOA | Vakolat boshlanishi (Start of Authority) yozuvlari |
resolvePtr() |
PTR | Pointer yozuvlari |
resolveNaptr() |
NAPTR | Nom vakolati ko‘rsatkichi (NAPTR) yozuvlari |
resolveAny() |
ANY | Har qanday yozuvlar |
Kengaytirilgan DNS operatsiyalari
1. Maxsus DNS aniqlash (resolution)
DNS qidiruvlarini qo‘shimcha nazorat qilish uchun maxsus sozlamalar bilan maxsus DNS-resolverni yarating:
const dns = require('dns');
// Create a new resolver
const resolver = new dns.Resolver();
// Set custom server (Google's public DNS)
resolver.setServers(['8.8.8.8', '8.8.4.4']);
// Use the custom resolver
resolver.resolve4('www.example.com', (err, addresses) => {
if (err) throw err;
console.log('Addresses resolved using Google DNS:');
addresses.forEach(addr => {
console.log(` ${addr}`);
});
});
// See what servers are configured
console.log('Current resolver servers:', resolver.getServers());
Misolni ishga tushirish »
Eslatma: Maxsus resolver yaratish tizimning standart sozlamalari o‘rniga maxsus DNS serverlaridan foydalanmoqchi bo‘lganingizda yoki turli qidiruvlar uchun turli xil sozlamalar kerak bo‘lganda foydali bo‘ladi.
2. Tarmoq darajasida va operatsion tizim darajasida nomlarni aniqlash
DNS moduli nomlarni aniqlashda ikki xil yondashuvni taklif qiladi:
| Funksiya | Amalga oshirish | Tarmoq so‘rovlari | Foydalanadi |
|---|---|---|---|
dns.lookup() |
getaddrinfo() tizim chaqiruvidan foydalanadi |
Tarmoqqa bevosita so‘rov yuborilmaydi | Mahalliy konfiguratsiyaga amal qiladi (hosts fayli va h.k.) |
dns.resolve*(), dns.reverse() |
Haqiqiy tarmoq so‘rovlarini amalga oshiradi | Har doim DNS serverlariga ulanadi | Mahalliy konfiguratsiyani chetlab o‘tadi, to‘g‘ridan-to‘g‘ri DNS so‘rovlari |
Ogohlantirish: Ushbu farqlar tufayli dns.lookup() va dns.resolve*() metodlaridan olingan natijalar har doim ham mos kelmasligi mumkin, ayniqsa maxsus xost konfiguratsiyasiga ega muhitlarda.
3. Xatolarni qayta ishlash va qayta urinishlar
Ishonchli DNS bilan ishlash xatolarni to‘g‘ri boshqarishni talab qiladi. Bu yerda keng tarqalgan DNS xatolarini qanday hal qilish va qayta urinib ko‘rish mantiqini amalga oshirish mumkin:
const dns = require('dns');
function lookupWithErrorHandling(domain) {
dns.lookup(domain, (err, address, family) => {
if (err) {
console.error(`DNS lookup failed for ${domain}`);
// Check specific error codes
switch (err.code) {
case 'ENOTFOUND':
console.error(' Domain name not found');
break;
case 'ETIMEDOUT':
console.error(' DNS lookup timed out');
break;
case 'ENODATA':
console.error(' Domain exists but no data of requested type');
break;
case 'ESERVFAIL':
console.error(' DNS server returned general failure');
break;
default:
console.error(` Error code: ${err.code}`);
}
return;
}
console.log(`DNS lookup successful for ${domain}`);
console.log(` IP address: ${address}`);
console.log(` IP version: IPv${family}`);
});
}
// Test with valid and invalid domains
lookupWithErrorHandling('www.google.com');
lookupWithErrorHandling('this-domain-does-not-exist-123456789.com');
Misolni ishga tushirish »
Eslatma: DNS xatolari tarmoq muammolari yoki DNS tarqalishidagi kechikishlar tufayli vaqtinchalik bo‘lishi mumkin.
Production ilovalarida eksponensial kechiktirish (exponential backoff) bilan qayta urinish mantiqini qo‘llashingiz mumkin.
Unumdorlikni optimallashtirish
DNS qidiruvlari ilovalarda unumdorlikning tor joyi (bottleneck) bo‘lishi mumkin. DNS aniqlashni optimallashtirish uchun quyidagi strategiyalar mavjud:
1. Keshlash
Xuddi shu domen uchun takroriy qidiruvlarni oldini olish uchun oddiy DNS keshini qo‘llang:
const dns = require('dns');
const util = require('util');
const lookup = util.promisify(dns.lookup);
const dnsCache = new Map();
async function cachedLookup(domain) {
if (dnsCache.has(domain)) {
console.log('Cache hit for:', domain);
return dnsCache.get(domain);
}
console.log('Cache miss for:', domain);
const result = await lookup(domain);
dnsCache.set(domain, result);
return result;
}
// Example usage
(async () => {
const domains = ['google.com', 'facebook.com', 'google.com'];
for (const domain of domains) {
const result = await cachedLookup(domain);
console.log(`${domain} → ${result.address}`);
}
})();
Misolni ishga tushirish »
2. Parallel qidiruvlar
Parallel ravishda bir nechta DNS qidiruvlarini amalga oshirish uchun Promise.all() dan foydalaning:
const dns = require('dns').promises;
async function lookupMultiple(domains) {
try {
const lookups = domains.map(domain => dns.lookup(domain));
const results = await Promise.all(lookups);
return domains.map((domain, i) => ({
domain,
...results[i]
}));
} catch (err) {
console.error('One or more lookups failed:', err);
throw err;
}
}
// Example usage
lookupMultiple(['google.com', 'facebook.com', 'github.com'])
.then(results => console.log(results))
.catch(console.error);
Misolni ishga tushirish »
3. Maxsus resolverlar va kutish vaqtlari (timeout)
Yaxshiroq boshqarish uchun maxsus DNS-serverlar va kutish vaqtlarini sozlang:
const dns = require('dns');
const { Resolver } = dns;
// Create a custom resolver with timeout
const resolver = new Resolver();
resolver.setServers(['8.8.8.8', '1.1.1.1']); // Google and Cloudflare DNS
// Set timeout for all operations (in ms)
const TIMEOUT = 2000;
async function resolveWithTimeout(domain, rrtype = 'A') {
return new Promise((resolve, reject) => {
const timer = setTimeout(() => {
reject(new Error(`DNS query timed out after ${TIMEOUT}ms`));
}, TIMEOUT);
resolver.resolve(domain, rrtype, (err, addresses) => {
clearTimeout(timer);
if (err) return reject(err);
resolve(addresses);
});
});
}
// Example usage
resolveWithTimeout('example.com')
.then(console.log)
.catch(console.error);
Misolni ishga tushirish »
DNS moduli va uchinchi tomon DNS kutubxonalari
| Xususiyat | Node.js DNS moduli | Uchinchi tomon kutubxonalari |
|---|---|---|
| Set | O‘rnatilgan, hech qanday bog‘liqlik yo‘q | O‘rnatish va boshqarishni talab qiladi |
| Xususiyatlar to‘plami | Asosiy DNS operatsiyalari | Ko‘pincha kengroq |
| Keshlash | O‘rnatilgan emas | Ko‘pincha keshlashni o‘z ichiga oladi |
| Kengaytirilgan xususiyatlar | Cheklangan | DNSSEC, DoH, DoT qo‘llab-quvvatlashini o‘z ichiga olishi mumkin |
| Unumdorlik | Asosiy foydalanish uchun yaxshi | Muayyan foydalanish holatlari uchun optimallashtirilgan bo‘lishi mumkin |
Node.js uchun mashhur uchinchi tomon DNS kutubxonalariga quyidagilar kiradi:
dns-packet: Past darajadagi DNS paketini kodlash/dekodlashnative-dns: DNSni to‘liqroq amalga oshirishdns2: Promise qo‘llab-quvvatlashiga ega zamonaviy DNS kutubxonasi
Xulosa
Node.js DNS moduli domen nomlari tizimi bilan o‘zaro ishlash uchun muhim funksiyalarni ta’minlaydi. Asosiy xususiyatlarga quyidagilar kiradi:
- Domen nomlari uchun IP manzillarni qidirish
- Turli DNS yozuv turlarini aniqlash (A, AAAA, MX, TXT va boshqalar)
- Teskari DNS qidiruvlarini amalga oshirish
- Muayyan sozlamalar bilan maxsus resolverlarni yaratish
- Callback-ga asoslangan va Promise-ga asoslangan API
DNS modulini tushunish domen nomi bo‘yicha tarmoq resurslari bilan o‘zaro aloqada bo‘lishi, maxsus nomlarni aniqlash mantiqini amalga oshirishi yoki domen bilan bog‘liq ma’lumotlarni tekshirishi kerak bo‘lgan ilovalar uchun juda muhimdir.
W3Schools Pathfinder
Yutuqlaringizni kuzating – bu bepul!