Empfehlungen zur DNS-Cache-Konfiguration für jede Entwicklungssprache

Autor: Di Helong

1. Hintergrund

Im Computerbereich, wenn es um Leistungsoptimierung geht Maßnahmen, die Sie zunächst in Betracht ziehen sollten, ist die Verwendung eines Caching-Mechanismus, der folgende Vorteile bringen kann:

1 Pfad und Zwischenspeicherung heißer Daten in der Nähe für ein anschließendes schnelles Lesen, wodurch die Verarbeitungseffizienz erheblich verbessert wird. Reduzieren Sie die Häufigkeit der Ferndatenerfassung und verringern Sie den Druck auf den Rücken -End-Datendienste und Reduzierung der Netzwerkbandbreitenkosten; Von der schnellen Anzeige von Seiten durch Browser bis hin zu beliebten kommerziellen Produkten wie CDN und Cloud-Storage-Gateways ist alles abgedeckt. Das Caching-Konzept wird angewendet.

Im Bereich öffentlicher Netzwerke hat der Caching-Mechanismus ausgereifter Produkte wie Betriebssysteme, Browser und mobile Apps die Probleme, mit denen Netzwerkanbieter wie Telekommunikationsanbieter konfrontiert sind, weitgehend beseitigt China Unicom und Inhaltsanbieter wie große Portalplattformen und CDN-Hersteller stehen unter Servicedruck. Nur das DNS des Betreibers kann problemlos Hunderte Millionen DNS-Auflösungen pro Sekunde bewältigen, und der Netzwerkgerätecluster kann die Internetbandbreite auf Tbit-Ebene pro Sekunde problemlos ertragen Nur die CDN-Plattform kann schnell Milliarden von Anfragen pro Sekunde verarbeiten.

Angesichts des derzeit enormen und wachsenden Umfangs des Domänennamenzugriffs optimiert das Team des Autors ständig die Clusterarchitektur und verbessert die Leistung der DNS-Software. Es besteht ein dringender Bedarf Um die Optimierung der Anforderungsmechanismen für die Auflösung von Domainnamen in verschiedenen Kundenumgebungen zu fördern, haben wir speziell Teammitglieder für die Durchführung von Recherchen und das Schreiben dieses Leitfadens organisiert, um dem Front-End-Entwicklungs- und Betriebspersonal des Unternehmens, den Kunden und anderen sinnvolle Vorschläge zu unterbreiten Optimieren Sie den gesamten DNS-Anfrageprozess, um die Geschäftseffizienz zu steigern.

In diesem Artikel wird hauptsächlich erläutert, wie das Caching von DNS-Auflösungsdatensätzen lokal auf dem Client unter verschiedenen Geschäfts- und Entwicklungssprachenhintergründen gleichzeitig implementiert wird, basierend auf der Analyse des Autorenteams des DNS selbst und des Unternehmensnetzwerks. Verstehen Sie die Umgebung, geben Sie einige andere Maßnahmen an und arbeiten Sie schließlich an der Standardisierung von DNS-Auflösungsanforderungen auf der Clientseite.

2. Begriffserklärung 1. Kunde

Der in diesem Artikel erwähnte Kunde bezieht sich im Allgemeinen auf alle Zu den aktiven Objekten, die Netzwerkanfragen initiieren, gehören unter anderem Server, PCs, mobile Endgeräte, Betriebssysteme, Befehlszeilentools, Skripte, Servicesoftware, Benutzer-APPs usw.

2. DNS

Client Erst nachdem die IP-Adresse des Servers durch Initiieren einer Domänennamenauflösungsanforderung an das DNS erhalten wurde, kann eine Netzwerkkommunikationsanforderung an die IP-Adresse und den Dienst oder Inhalt initiiert werden Die vom Domainnamen getragenen Informationen werden tatsächlich erhalten.

Referenz: Domain Name SystemDomain Name Resolution Process

man resolv.conf

Wenn die Auflösung des Domänennamens abnormal ist, sollte auch die Möglichkeit einer Anomalie des LDNS-Dienstes oder einer Entführung der Auflösung in Betracht gezogen werden.

Referenz: TCP/IP-Einstellungen (einschließlich DNS) im Windows-System ändern;

Das DNS-System kann die Zuordnungsbeziehung zwischen Domänennamen und IPs dynamisch bereitstellen. Die Hosts-Datei, die häufig in verschiedenen Betriebssystemen zu finden ist, ist eine statische Aufzeichnungsdatei der Zuordnungsbeziehung zwischen Domänennamen und IPs . Normalerweise haben Hosts-Einträge Vorrang vor der DNS-Auflösung. Das heißt, wenn kein lokaler Cache vorhanden ist oder ein Cache-Fehler vorliegt, wird der entsprechende Domänennamen-Eintrag zuerst über Hosts abgefragt. Informationen zur Steuerung dieser Logik in der Linux-Umgebung finden Sie unten im Einführungsabschnitt zum C/C++-Sprach-DNS-Cache.

In der tatsächlichen Arbeit werden die oben genannten Standardfunktionen häufig verwendet, um die Zuordnungsbeziehung zwischen bestimmten Domänennamen und bestimmten IPs in die Hosts-Datei (allgemein als „feste Hosts“ bezeichnet) zu schreiben, was üblich ist Umgehen Sie den DNS-Auflösungsprozess für den gezielten Zugriff (der Effekt ist derselbe wie die Option -x von Curl oder die angegebene Proxy-Option -e von wget); #Time-To-Live, Überlebenszeitwert, dieses Konzept ist in vielen Bereichen anwendbar und kann unterschiedliche Bedeutungen haben.

Die in diesem Artikel enthaltenen TTL-Beschreibungen beziehen sich alle auf das Daten-Caching, das direkt als „Gültigkeitszeitraum“ der zwischengespeicherten Daten ab dem Zeitpunkt der Datenerhebung verstanden werden kann Daten, die länger als die angegebene TTL-Zeit in der Datenbank vorhanden sind, gelten als abgelaufene Daten. Wenn die Daten erneut aufgerufen werden, wird die Gültigkeit sofort von der maßgeblichen Datenquelle bestätigt oder abgerufen.

Da der Caching-Mechanismus normalerweise passiv ausgelöst und aktualisiert wird, nimmt der Client dies nicht wahr, wenn sich die ursprünglichen maßgeblichen Back-End-Daten während der Cache-Gültigkeitsdauer des Clients ändern Die Leistung ist auf eine gewisse Verzögerung bei der Datenaktualisierung im Unternehmen und kurzfristige Inkonsistenzen zwischen zwischengespeicherten Daten und maßgeblichen Daten zurückzuführen.

Für die Cache-TTL von clientseitigen DNS-Einträgen empfehlen wir gleichzeitig einen Wert von 60; , oder ein Unternehmen mit seltenen Anpassungen der Domainnamenauflösung, kann entsprechend erweitert werden, sogar auf Stunden- oder Tagesebene; -entwickeltes Client-DNS-Caching. Jede Entwicklungssprache bietet möglicherweise unterschiedliche Unterstützung für DNS-Caching. Lassen Sie uns sie hier einzeln analysieren.

(1) Glibcs ​​getaddrinfo-Funktion

Funktionsprototyp:

int getaddrinfo( const char *node, 
 const char *service,
 const struct addrinfo *hints,
 struct addrinfo **res);

Wir können die folgenden Systemaufrufe über den Befehl strace in der Linux-Umgebung sehen

//连接nscd
socket(PF_LOCAL, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3
connect(3, {sa_family=AF_LOCAL, sun_path="/var/run/nscd/socket"}, 110) = -1 ENOENT (No such file or directory)
close(3)

Über die Unix-Socket-Schnittstelle „/var/run/nscd /socket“ stellt eine Verbindung zum nscd-Dienst her, um den DNS-Cache abzufragen.

2) Fragen Sie die Datei /etc/hosts ab

Wenn der NSCD-Dienst nicht startet oder die Cache-Fehler, Abfrage der Hosts-Datei fortsetzen, wir sollten den folgenden Systemaufruf sehen können

//读取 hosts 文件
open("/etc/host.conf", O_RDONLY)= 3
fstat(3, {st_mode=S_IFREG|0644, st_size=9, ...}) = 0
...
open("/etc/hosts", O_RDONLY|O_CLOEXEC)= 3
fcntl(3, F_GETFD) = 0x1 (flags FD_CLOEXEC)
fstat(3, {st_mode=S_IFREG|0644, st_size=178, ...}) = 0

3) DNS-Dienst abfragen

#🎜 🎜#Fragen Sie die IP-Adresse des DNS-Servers (Nameserver) aus der Konfiguration /etc/resolv.conf ab und führen Sie dann eine DNS-Abfrage durch, um die Auflösungsergebnisse zu erhalten. Wir können den folgenden Systemaufruf

//获取 resolv.conf 中 DNS 服务 IP
open("/etc/resolv.conf", O_RDONLY)= 3
fstat(3, {st_mode=S_IFREG|0644, st_size=25, ...}) = 0
mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fef2abee000
read(3, "nameserver 114.114.114.114nn", 4096) = 25
...
//连到 DNS 服务，开始 DNS 查询
connect(3, {sa_family=AF_INET, sin_port=htons(53), sin_addr=inet_addr("114.114.114.114")}, 16) = 0
poll([{fd=3, events=POLLOUT}], 1, 0)= 1 ([{fd=3, revents=POLLOUT}])

sehen und darüber, ob der Client zuerst nach der Datei /etc/hosts suchen oder zuerst den DNS-Server von /etc/resolv beziehen soll Die .conf-Abfrageanalyse wird von /etc/nsswitch.conf gesteuert:

#/etc/nsswitch.conf 部分配置
...
#hosts: db files nisplus nis dns
hosts:files dns
...

Sie können tatsächlich durch den Strace-Befehl sehen, dass nach dem Systemaufruf von nscd socket, /etc/ Vor resolv.conf wird die Datei gelesen Durch die Analyse kann die Funktion getaddrinfo in Kombination mit nscd DNS-Caching realisieren.

(2) Domänennamenauflösungsfunktion der libcurl-Bibliothek

libcurl-Bibliothek ist unter der Sprache c/c++ Es handelt sich um eine Netzwerkübertragungsbibliothek, die häufig von Clients verwendet wird. Der Curl-Befehl wird basierend auf dieser Bibliothek implementiert. Diese Bibliothek ruft auch die Bibliotheksfunktion getaddrinfo auf, um die Auflösung von DNS-Domänennamen zu implementieren, und unterstützt außerdem das DNS-Caching von nscd.

newfstatat(AT_FDCWD, "/etc/nsswitch.conf", {st_mode=S_IFREG|0644, st_size=510, ...}, 0) = 0
...
openat(AT_FDCWD, "/etc/nsswitch.conf", O_RDONLY|O_CLOEXEC) = 3

Die Java-Sprache ist in vielen Unternehmen die Hauptsprache für die Entwicklung von Geschäftssystemen. Java wird durch Schreiben eines getestet und verifiziert einfaches HTTP-Client-Programm. Ob die Netzwerkbibliothek DNS-Caching unterstützt. Der Test verifizierte die beiden Komponenten HttpURLConnection und Apache httpcomponents-client in der Java-Standardbibliothek.

(1) Java-Standardbibliothek HttpURLConnection

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;


public class HttpUrlConnectionDemo {

public static void main(String[] args) throws Exception {
String urlString = "http://example.my.com/";

int num = 0;
while (num < 5) {
URL url = new URL(urlString);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setDoOutput(true);

OutputStream os = conn.getOutputStream();
os.flush();
os.close();

if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
InputStream is = conn.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
sb.append(line);
}
System.out.println("rsp:" + sb.toString());
} else {
System.out.println("rsp code:" + conn.getResponseCode());
}
num++;
}
}
}

测试结果显示 Java 标准库 HttpURLConnection 是支持 DNS 缓存，5 次请求中只有一次 DNS 请求。

（2）Apache httpcomponents-client

import java.util.ArrayList;
import java.util.List;

import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.entity.UrlEncodedFormEntity;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.NameValuePair;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.BasicNameValuePair;

public class QuickStart {
public static void main(final String[] args) throws Exception {
int num = 0;
while (num < 5) {
try (final CloseableHttpClient httpclient = HttpClients.createDefault()) {
final HttpGet httpGet = new HttpGet("http://example.my.com/");
try (final CloseableHttpResponse response1 = httpclient.execute(httpGet)) {
System.out.println(response1.getCode() + " " + response1.getReasonPhrase());
final HttpEntity entity1 = response1.getEntity();
EntityUtils.consume(entity1);
}
}
num++;
}
}
}

测试结果显示 Apache httpcomponents-client 支持 DNS 缓存，5 次请求中只有一次 DNS 请求。

从测试中发现 Java 的虚拟机实现一套 DNS 缓存，即实现在 java.net.InetAddress 的一个简单的 DNS 缓存机制，默认为缓存 30 秒，可以通过 networkaddress.cache.ttl 修改默认值，缓存范围为 JVM 虚拟机进程，也就是说同一个 JVM 进程中，30秒内一个域名只会请求DNS服务器一次。同时 Java 也是支持 nscd 的 DNS 缓存，估计底层调用 getaddrinfo 函数，并且 nscd 的缓存级别比 Java 虚拟机的 DNS 缓存高。

# 默认缓存 ttl 在 jre/lib/security/java.security 修改，其中 0 是不缓存，-1 是永久缓存
networkaddress.cache.ttl=10

# 这个参数 sun.net.inetaddr.ttl 是以前默认值，目前已经被 networkaddress.cache.ttl 取代

Go

随着云原生技术的发展，Go 语言逐渐成为云原生的第一语言，很有必要验证一下 Go 的标准库是否支持 DNS 缓存。通过我们测试验证发现 Go 的标准库 net.http 是不支持 DNS 缓存，也是不支持 nscd 缓存，应该是没有调用 glibc 的库函数，也没有实现类似 getaddrinfo 函数的功能。这个跟 Go语言的自举有关系，Go 从 1.5 开始就基本全部由 Go(.go) 和汇编 (.s) 文件写成的，以前版本的 C(.c) 文件被全部重写。不过有一些第三方 Go 版本 DNS 缓存库，可以自己在应用层实现，还可以使用 fasthttp 库的 httpclient。

（1）标准库net.http

package main

import (
"flag"
"fmt"
"io/ioutil"
"net/http"
"time"
)

var httpUrl string

func main() {
flag.StringVar(&httpUrl, "url", "", "url")
flag.Parse()
getUrl := fmt.Sprintf("http://%s/", httpUrl)

fmt.Printf("url: %sn", getUrl)
for i := 0; i < 5; i++ {
_, buf, err := httpGet(getUrl)
if err != nil {
fmt.Printf("err: %vn", err)
return
}
fmt.Printf("resp: %sn", string(buf))
time.Sleep(10 * time.Second)# 等待10s发起另一个请求
}
}

func httpGet(url string) (int, []byte, error) {
client := createHTTPCli()
resp, err := client.Get(url)
if err != nil {
return -1, nil, fmt.Errorf("%s err [%v]", url, err)
}
defer resp.Body.Close()

buf, err := ioutil.ReadAll(resp.Body)
if err != nil {
return resp.StatusCode, buf, err
}

return resp.StatusCode, buf, nil
}
func createHTTPCli() *http.Client {
readWriteTimeout := time.Duration(30) * time.Second
tr := &http.Transport{
DisableKeepAlives: true,//设置短连接
IdleConnTimeout: readWriteTimeout,
}
client := &http.Client{
Timeout: readWriteTimeout,
Transport: tr,
}
return client
}

从测试结果来看，net.http 每次都去 DNS 查询，不支持 DNS 缓存。

（2）fasthttp 库

fasthttp 库是 Go 版本高性能 HTTP 库，通过极致的性能优化，性能是标准库 net.http 的 10 倍，其中一项优化就是支持 DNS 缓存，我们可以从其源码看到

//主要在fasthttp/tcpdialer.go中
type TCPDialer struct {
...
// This may be used to override DNS resolving policy, like this:
// var dialer = &fasthttp.TCPDialer{
//Resolver: &net.Resolver{
//PreferGo: true,
//StrictErrors: false,
//Dial: func (ctx context.Context, network, address string) (net.Conn, error) {
//d := net.Dialer{}
//return d.DialContext(ctx, "udp", "8.8.8.8:53")
//},
//},
// }
Resolver Resolver

// DNSCacheDuration may be used to override the default DNS cache duration (DefaultDNSCacheDuration)
DNSCacheDuration time.Duration
...
}

可以参考如下方法使用 fasthttp client 端

func main() {
// You may read the timeouts from some config
readTimeout, _ := time.ParseDuration("500ms")
writeTimeout, _ := time.ParseDuration("500ms")
maxIdleConnDuration, _ := time.ParseDuration("1h")
client = &fasthttp.Client{
ReadTimeout: readTimeout,
WriteTimeout:writeTimeout,
MaxIdleConnDuration: maxIdleConnDuration,
NoDefaultUserAgentHeader:true, // Don't send: User-Agent: fasthttp
DisableHeaderNamesNormalizing: true, // If you set the case on your headers correctly you can enable this
DisablePathNormalizing:true,
// increase DNS cache time to an hour instead of default minute
Dial: (&fasthttp.TCPDialer{
Concurrency:4096,
DNSCacheDuration: time.Hour,
}).Dial,
}
sendGetRequest()
sendPostRequest()
}

（3）第三方DNS缓存库

这个是 github 中的一个 Go 版本 DNS 缓存库

可以参考如下代码，在HTTP库中支持DNS缓存

r := &dnscache.Resolver{}
t := &http.Transport{
DialContext: func(ctx context.Context, network string, addr string) (conn net.Conn, err error) {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
ips, err := r.LookupHost(ctx, host)
if err != nil {
return nil, err
}
for _, ip := range ips {
var dialer net.Dialer
conn, err = dialer.DialContext(ctx, network, net.JoinHostPort(ip, port))
if err == nil {
break
}
}
return
},
}

Python

（1）requests 库

#!/bin/python

import requests

url = 'http://example.my.com/'

num = 0
while num < 5:
headers={"Connection":"close"} # 开启短连接
r = requests.get(url,headers = headers)
print(r.text)
num +=1

（2）httplib2 库

#!/usr/bin/env python
import httplib2
http = httplib2.Http()
url = 'http://example.my.com/'

num = 0
while num < 5:
loginHeaders={
'User-Agent': 'Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Maxthon/4.0 Chrome/30.0.1599.101 Safari/537.36',
'Connection': 'close'# 开启短连接
}
response, content = http.request(url, 'GET', headers=loginHeaders)
print(response)
print(content)
num +=1

（3）urllib2 库

#!/bin/python

import urllib2
import cookielib

httpHandler = urllib2.HTTPHandler(debuglevel=1)
httpsHandler = urllib2.HTTPSHandler(debuglevel=1)
opener = urllib2.build_opener(httpHandler, httpsHandler)
urllib2.install_opener(opener)

loginHeaders={
'User-Agent': 'Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Maxthon/4.0 Chrome/30.0.1599.101 Safari/537.36',
'Connection': 'close' # 开启短连接
}

num = 0
while num < 5:
request=urllib2.Request('http://example.my.com/',headers=loginHeaders)
response = urllib2.urlopen(request)
page=''
page= response.read()
print response.info()
print page
num +=1

Python 测试三种库都是支持 nscd 的 DNS 缓存的(推测底层也是调用 getaddrinfo 函数)，以上测试时使用 HTTP 短连接，都在 python2 环境测试。

总结

针对 HTTP 客户端来说，可以优先开启 HTTP 的 keep-alive 模式，可以复用 TCP 连接，这样可以减少 TCP 握手耗时和重复请求域名解析，然后再开启 nscd 缓存，除了 Go 外，C/C++、Java、Python 都可支持 DNS 缓存，减少 DNS查询耗时。

这里只分析了常用 C/C++、Java、Go、Python 语言，欢迎熟悉其他语言的小伙伴补充。

2. Unix/类 Unix 系统常用 dns 缓存服务：

在由于某些特殊原因，自研或非自研客户端本身无法提供 DNS 缓存支持的情况下，建议管理人员在其所在系统环境中部署DNS缓存程序；

现介绍 Unix/类 Unix 系统适用的几款常见轻量级 DNS 缓存程序。而多数桌面操作系统如 Windows、MacOS 和几乎所有 Web 浏览器均自带 DNS 缓存功能，本文不再赘述。

P.S. DNS 缓存服务请务必确保随系统开机启动；

nscd

name service cache daemon 即装即用，通常为 linux 系统默认安装，相关介绍可参考其 manpage：man nscd；man nscd.conf

（1）安装方法：通过系统自带软件包管理程序安装，如 yum install nscd

（2）缓存管理（清除）：

1.service nscd restart 重启服务清除所有缓存；

2.nscd -i hosts 清除 hosts 表中的域名缓存（hosts 为域名缓存使用的 table 名称，nscd 有多个缓存 table，可参考程序相关 manpage）

dnsmasq

较为轻量，可选择其作为 nscd 替代，通常需单独安装

（1）安装方法：通过系统自带软件包管理程序安装，如 yum install dnsmasq

（2）核心文件介绍（基于 Dnsmasq version 2.86，较低版本略有差异，请参考对应版本文档如 manpage 等）

（3）/etc/default/dnsmasq 提供六个变量定义以支持六种控制类功能

（4）/etc/dnsmasq.d/ 此目录含 README 文件，可参考；目录内可以存放自定义配置文件

（5）/etc/dnsmasq.conf 主配置文件，如仅配置 dnsmasq 作为缓存程序，可参考以下配置

listen-address=127.0.0.1#程序监听地址，务必指定本机内网或回环地址，避免暴露到公网环境
port=53 #监听端口
resolv-file=/etc/dnsmasq.d/resolv.conf#配置dnsmasq向自定义文件内的 nameserver 转发 dns 解析请求
cache-size=150#缓存记录条数，默认 150 条，可按需调整、适当增大
no-negcache #不缓存解析失败的记录，主要是 NXDOMAIN，即域名不存在
log-queries=extra #开启日志记录，指定“=extra”则记录更详细信息，可仅在问题排查时开启，平时关闭
log-facility=/var/log/dnsmasq.log #指定日志文件

#同时需要将本机 /etc/resolv.conf 第一个 nameserver 指定为上述监听地址，这样本机系统的 dns 查询请求才会通过 dnsmasq 代为转发并缓存响应结果。
#另 /etc/resolv.conf 务必额外配置 2 个 nameserver，以便 dnsmasq 服务异常时支持系统自动重试，注意 resolv.conf 仅读取前 3 个 nameserver

（6）缓存管理（清除）：

1.kill -s HUP `pidof dnsmasq` 推荐方式，无需重启服务

2.kill -s TERM `pidof dnsmasq` 或 service dnsmasq stop

3.service dnsmasq force-reload 或 service dnsmasq restart

（7）官方文档：https://thekelleys.org.uk/dnsmasq/doc.html

3. 纯内网业务取消查询域名的AAAA记录的请求

以 linux 操作系统为例，常用的网络请求命令行工具常常通过调用 getaddrinfo() 完成域名解析过程，如 ping、telnet、curl、wget 等，但其可能出于通用性的考虑，均被设计为对同一个域名每次解析会发起两个请求，分别查询域名 A 记录（即 IPV4 地址）和 AAAA 记录（即 IPV6 地址）。

因目前大部分公司的内网环境及云上内网环境还未使用 ipv6 网络，故通常 DNS 系统不为内网域名添加 AAAA 记录，徒劳请求域名的 AAAA 记录会造成前端应用和后端 DNS 服务不必要的资源开销。因此，仅需请求内网域名的业务，如决定自研客户端，建议开发人员视实际情况，可将其设计为仅请求内网域名 A 记录，尤其当因故无法实施本地缓存机制时。

4. 规范域名处理逻辑

客户端需严格规范域名/主机名的处理逻辑，避免产生大量对不存在域名的解析请求（确保域名从权威渠道获取，避免故意或意外使用随机构造的域名、主机名），因此类请求的返回结果（NXDOMAIN）通常不被缓存或缓存时长较短，且会触发客户端重试，对后端 DNS 系统造成一定影响。

Das obige ist der detaillierte Inhalt vonEmpfehlungen zur DNS-Cache-Konfiguration für jede Entwicklungssprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!