Network Basics You Need to Learn in the AI Era

Why am I frantically catching up on network fundamentals now? Because I’ve come to realize deeply — if you don’t learn this stuff, you’ll be blocked at every turn in the AI era…

Layer 1: The ladder (proxy). A lot of people have it but don’t fully understand it — sometimes the network lags, but why? Are proxy and VPN the same thing? Can you pick the same VPN for both phone and computer? People say you can build a stable VPN with a VPS — is that true, and how?

Layer 2: Claude, A➗ — I’m sure everyone’s familiar. Accounts keep getting banned, but we still use it with devotion. And honestly, Claude’s desktop app is my absolute favorite AI learning tool — the interaction design is simply a joy. So to avoid getting banned, you need to understand the underlying network principles that prevent bans.

Layer 3: This involves local models and AI Native organization building, plus things like LANs and NAS get thrown in. So the most fundamental stuff like IP and DNS must also be understood.

Layer 4: A ton of useful tools. For example, batch scraping tools for WeChat Official Accounts (公众号) and video accounts (视频号) generally require proxy settings. If you don’t understand these principles, you won’t know whether you can scrape in parallel, or what impact switching proxies will have on your computer.

Layer 5: If you want to go overseas and earn US dollars, learning network fundamentals is even more critical. DNS resolution is one of the most common terms in the domain world. IP addresses, network requests, bandwidth, CPU, memory — these are things you MUST understand when your website gets hit by a DDoS attack, because it’s literally burning money.

…and there are many more situations where you need fundamental network knowledge. This article can’t solve all these problems at once, but I’ll use it to help you understand, in the most accessible way possible, the most basic network concepts you need to solve these real-world problems.

Before we start, for those interested, here’s the previous article for context.

逸尘 @gengdaJ · Jul 31 Article — Clash Verge from 0 to 1 Zero-Basics Tutorial (UI Overview). Why did I write this network basics tutorial? Because I’ve stepped on way too many network-related pitfalls recently… 301 528 161 23K

1. What is an IP?

IP (Internet Protocol) is a set of addressing rules used for internet communication; IPv4 and IPv6 are the two versions of these rules.

The purpose of IP is to let devices on a network find each other. For example, when you open a website, what’s essentially happening is your device sends a request to the website’s server: “I want to access you now, please send me the webpage content.”

So when the website server receives the request, how does it know where to send the data back? That’s where the IP address comes in — it locks down the coordinates.

There are three important IP address concepts to understand:

Type	Meaning
Internal/Private IP	Address used within a local network
Public IP	Address visible to the outside world on the internet
Egress IP	The final IP seen by the target website

Quick explanation of LAN (Local Area Network): a private local network formed by connecting multiple devices in a small area, like walkie-talkies in a company.

If you have a computer, phone, and iPad at home, they’re all on your home LAN, so they all have private IPs, usually shown as different addresses:

Computer: 192.168.1.10 Phone: 192.168.1.11 iPad: 192.168.1.12 Router: 192.168.1.1

But when they access external websites, they all go out through the same public IP, so websites might see them all as the same IP: 123.45.67.89. The full IP flow looks like this:

Computer 192.168.1.10 → Router 192.168.1.1 → Public egress IP 123.45.67.89 → Target website

Also, an IP address represents the network egress address you’re using for this particular internet session, and it can change.

For example, when you’re on home Wi-Fi, websites might see the public IP of your home broadband. When you switch to mobile data, the website might see your mobile carrier’s IP. When you use a proxy, VPN, or VPS, the website might see the proxy server’s, VPN node’s, or VPS’s IP instead.

1. What is IPv4?

IPv4 stands for Internet Protocol version 4. IPv4 addresses typically look like this:

192.168.1.1 8.8.8.8 1.1.1.1 255.255.255.255

In the official IPv4 specification, IPv4 is a 32-bit binary number — the address length is 4 octets (8 binary bits each), i.e., 4 groups of 8 bits, totaling 32 bits, like:

11000000101010000000000100000001

But humans obviously can’t read this format directly, so it’s split into 4 segments:

8 bits . 8 bits . 8 bits . 8 bits

Each segment of 8 binary bits, converted to decimal, gives us what we see:

192.168.1.1

Using 192.168.1.1 as an example:

192 .168 .1 .1 11000000 .10101000 .00000001 .00000001

Why do you often hear people say IPv4 addresses are limited? That’s because IPv4 is fundamentally a 32-bit binary number. Each binary digit can only be 0 or 1, so the theoretical total number of IPv4 addresses is: 2^32 = 4,294,967,296, which is approximately 4.29 billion.

And not all of these 4.29 billion addresses can be used as public IPs, because some are reserved for private networks, loopback (explained later), broadcast, documentation examples, and other special purposes.

Private IPv4 addresses are only used within local networks. There are three major private address ranges:

10.0.0.0 ~ 10.255.255.255 172.16.0.0 ~ 172.31.255.255 192.168.0.0 ~ 192.168.255.255

The most common ones for home routers are:

192.168.0.x 192.168.1.x

For example:

192.168.1.1 Router 192.168.1.10 Computer 192.168.1.11 Phone 192.168.1.12 iPad

I used to wonder about something — let’s see if anyone else had the same question: why do so many people’s computers show the IP 192.168.1.1?

Actually, 192.168.1.1 is a private local address, not a public one, so it doesn’t need to be globally unique. It’s like how Hotel A has room 101 and Hotel B also has room 101 — as long as they’re in different hotels, there’s no conflict.

There’s also a special term: loopback address. The most common IPv4 loopback address is: 127.0.0.1. It’s also commonly called: localhost (anyone who does vibe coding knows there are plenty of memes about this — localhost: 3000…).

A loopback address means accessing yourself. For example, if you type http://127.0.0.1:3000 in your browser, it means you’re accessing port 3000 service running on your current computer from the browser (ports will be covered later). It doesn’t go to the internet or the router — communication happens entirely within your own machine.

2. What is IPv6?

IPv6 stands for Internet Protocol version 6. One of the major reasons it exists is that IPv4 addresses are running out.

IPv4 is only 32 bits, while IPv6 is 128 bits. The number of addresses is: 2^128 = 340,282,366,920,938,463,463,374,607,431,768,211,456. So no more worries about running out of IPs…

IPv6 no longer uses IPv4’s “dotted decimal format”. Instead, it uses “hexadecimal + colon separators”. A full IPv6 address looks like this (split into 8 groups):

2001 : 0db8 : 85a3 : 0000 : 0000 : 8a2e : 0370 : 7334

Each group is 4 hexadecimal characters. Hexadecimal characters include:

0 1 2 3 4 5 6 7 8 9 a b c d e f

The standard text form of IPv6 is usually written as x:x:x:x:x:x:x:x, i.e., 8 groups of hexadecimal numbers separated by colons.

Because IPv6 is so long, abbreviations are allowed. For example, the full address 2001:0db8:0000:0000:0000:0000:0000:0001 can first drop the leading zeros in each group, becoming: 2001:db8:0:0:0:0:0:1.

And if there are consecutive groups of 0000 in the middle, you can use :: to omit them:

2001:db8::1

The “::” here means a string of consecutive zeros has been omitted. But note: in one IPv6 address, :: can only appear at most once.

3. How does a private IP become a public egress IP? — NAT

The flow above works like this: Computer 192.168.1.10 → Router → Public egress IP 123.45.67.89 → Target website.

All traffic leaving the LAN is first handed to the router (which in a home also plays the role of the default gateway). The action of “private IP becoming public egress IP” is the router performing NAT (Network Address Translation).

Why is this translation necessary? Because private IPs can’t be used directly on the global internet. For example, your computer’s IP is 192.168.1.10 — it works in your home, but there could be countless devices worldwide with the same IP 192.168.1.10. Websites have no way to determine which device to send data back to based on that address.

So when data leaves your home, the router replaces the source IP from a private address to your home’s public egress address. Let’s say your home’s public IP is 123.45.67.89:

Before translation: Source IP: 192.168.1.10 Destination IP: Website server IP

After NAT: Source IP: 123.45.67.89 Destination IP: Website server IP

The website ultimately sees 123.45.67.89, not 192.168.1.10.

So when multiple devices at home share the same public IP, how does the router know whether to hand the response data to the computer or the phone?

The answer is: The router records the mapping for each connection, distinguishing not just by private IP but also by port. This more specific mechanism is called PAT (Port Address Translation), though in everyday usage it’s lumped into NAT.

For example, the router might internally record:

Internal Device	Internal Connection	External Connection
Computer	192.168.1.10:50001	123.45.67.89:61001
Phone	192.168.1.11:50002	123.45.67.89:61002
Tablet	192.168.1.12:50003	123.45.67.89:61003

When the website sends data back to 123.45.67.89:61002, the router checks its records and knows this data belongs to the phone.

Beyond router NAT, sometimes the ISP performs another layer of NAT, called CGNAT (Carrier-Grade NAT). The reason is still that IPv4 addresses are insufficient — ISPs make many home users share a small pool of public IPv4s. In this case, there might be two layers of translation:

Computer private IP → Home router NAT → ISP internal address → ISP CGNAT → Real public egress IP → Website

In this scenario, the WAN address (Wide Area Network address, i.e., the IP the router uses to connect to the external network) you see in your router’s admin panel may not be a real public IP, because the website ultimately sees the egress IP after the ISP’s CGNAT.

CGNAT also brings some practical effects:

• It’s harder to actively connect to your home devices from the public internet (accessing your home NAS remotely becomes difficult);
• Router port forwarding may not work directly;
• The address shown in your router may differ from the address shown on IP lookup websites.

4. Want to access your home NAS from outside? — Port Forwarding, Tunneling, and Mesh Networking

When you’re away from home, how do you access files on your home NAS or local AI services?

Why is it so hard to access home devices from outside? Because most home devices have private IPs (like 192.168.1.10), which are meaningless on the public internet. To access them from outside, devices on the public internet need to be able to find and connect to your home’s internal devices. There are two scenarios — with a public IP and without:

Option 1: Have a public IP — Port Forwarding + DDNS If your broadband ISP assigned you a public IP (not CGNAT), you can set up port forwarding in the router: forward a certain public port on the router to a certain port on an internal device.

Public: http://your-home-public-IP:8080 → Router (port forwarding) → Internal: 192.168.1.100:3000 (service on NAS)

But home broadband public IPs are usually dynamic and change over time, so you also need DDNS (Dynamic Domain Name System) — which fixedly points your domain to your current, changing public IP. You just need to remember the domain; when the IP changes, DDNS updates automatically.

Option 2: No public IP — Intranet Penetration (Tunneling) Most home broadband is behind CGNAT and doesn’t have a real public IP at all, making port forwarding impossible. That’s when you need intranet penetration: you install a client on your home network that actively connects out to a relay server with a public IP, “borrowing” that path to expose your internal service.

Someone outside → Public relay server (has public IP) → Penetration client at your home → NAS service

Common tools: frp, cpolar, 花生壳 (Oray), ngrok. The downside is an extra hop — speed and stability are affected by the relay server.

Option 3: Mesh networking — Tailscale, ZeroTier I use Tailscale for auto-creating WeChat Official Account articles (I’ll share about that in future articles).

Mesh networking pulls multiple devices into a “virtual LAN”, letting them access each other as if they were on the same internal network, no matter where they physically are. It uses P2P direct connections (Peer-to-Peer, where two devices connect directly to transmit data) + relay fallback (if direct connection fails, it automatically switches to a relay server for forwarding). It’s more flexible than intranet penetration and is encrypted by default.

Phone (elsewhere) ⇄ Virtual LAN ⇄ Home NAS

Advantages: no need to expose any port to the public internet, good security; phones, computers, and NAS can all access each other. It’s well-suited for “AI Native organizations” to connect devices and local models into a single network.

2. What are clients, servers, and websites?

Who exactly is communicating with whom on the internet? The answer is clients and servers.

The most common communication model on the internet can be simply understood as:

Client → Request → Server Client ← Response ← Server

When you open a webpage, scroll videos, log into accounts, post comments, or call an AI, it can all be understood this way — your software sends a request to a remote server, and the server processes it and returns the result.

1. What is a client?

A client is the party that actively initiates requests. Your everyday browser, mobile apps, desktop software, mini-programs, game clients, command-line tools, and code scripts can all be clients.

For example, when you open a website with Chrome, Chrome is the client. When you browse X on your phone, the X app is the client. When you use Codex to call GPT, the Codex software is the client. When you write a Python script to request an API, that script can also be a client.

Here’s an easily confused point! A client isn’t necessarily your computer or phone itself — it’s usually a piece of software running on a device.

For instance, when you open Chrome on your Mac to visit a website, the Mac is the device, and Chrome is the client for that visit. When you open YouTube on your iPhone, the iPhone is the device, and the YouTube app is the client.

A client is mainly responsible for three things: receiving your actions, turning your actions into network requests, and displaying the server’s returned results to you.

For example, you type a sentence on a website and click “Send”. You see yourself clicking a button, but behind the scenes there are actually three steps — the browser (as client) sends your input to the server, the server processes it and returns a result, and the browser displays the result on the page.

2. What is a server?

A server provides services like web pages, images, videos, login, search, comments, payments, file downloads, and AI-generated results.

For example, when you open YouTube, YouTube’s servers return pages, videos, comments, and recommendations. When you open X, X’s servers return your timeline, tweets, images, videos, and interaction data. When you open ChatGPT, OpenAI’s servers receive your question, process it, and return an answer.

So a server is essentially: one or a group of machines dedicated to providing services, plus the programs running on those machines. Note that “server” has two meanings:

The first meaning is what we commonly call a server — a real machine that waits for others to access and provides services. Examples include cloud servers, VPS instances, and physical servers in data centers. In this sense, it’s more like a remote computer.

The second meaning is in terms like web server, database server, proxy server, and mail server — these are more about a service program or system. (Proxy server will be explained later.)

3. What is a website?

Many people think a website is just a webpage, but actually a website is a complete set of online services.

The page you see is just the surface of a website. Behind a website, there’s usually a frontend, backend, database, servers, and network infrastructure.

The frontend is the part you can see and interact with — pages, buttons, input fields, images, animations.

The backend is the part on the server that handles business logic — like checking whether you’re logged in, validating membership permissions, processing payments, saving comments, calling AI models.

The database is where data is stored — user accounts, article content, comments, orders, chat history, membership status.

For example, when you open an AI tool website and see the input box and generate button, that’s the frontend. When you click “Generate”, the backend receives your request, checks your permissions, and may call the model. Additionally, your account info, history, and remaining usage are typically stored in the database.

So a website isn’t a single page — it’s a complete service composed of frontend, backend, database, and servers.

A small website might run on a single server, but large platforms are much more complex. Platforms like YouTube, X, TikTok, Taobao, and OpenAI often have many servers working together in the background: web servers, login servers, database servers, image servers, video servers, recommendation systems, risk control systems, caching systems, CDN nodes (CDN will be covered later), and so on.

4. What are requests and responses?

The most core actions between client and server are requests and responses.

A request is the client saying to the server: “I need something” or “Please do something for me.”

For example, when you open the homepage, the client is requesting the homepage content. When you click login, the client is requesting the server to verify your account and password. When you refresh your timeline, the client is requesting the latest content.

A response is the result returned after the server processes the request.

For example, the server returns webpage content, login success, login failure, video data, AI-generated results, or tells you that you don’t have permission, the request failed, and so on.

5. What makes a server run? — CPU, RAM, Disk, GPU

What is a server made of? When choosing a VPS, renting a server, or determining whether you can run AI models locally, you’ll encounter server component terms — this even touches on AI hardware investments, so you definitely need to understand these…

CPU (Central Processing Unit): The brain of the server. It handles all computation and logic — processing requests, running programs, forwarding data. More cores and higher clock speeds mean more work done simultaneously. Building websites and running backend logic mainly depends on the CPU.

GPU (Graphics Processing Unit): Originally a graphics card for image rendering, but because it excels at “many simple calculations at the same time” (parallel computing), it’s also used for AI training and inference. The mathematical essence of large AI models is massive matrix operations, and GPUs are designed exactly for that. When you hear “4090 running local models” or “buying H100s for training,” they’re talking about GPUs.

RAM (Random Access Memory): The server’s “temporary workbench.” Data goes into memory before being processed — extremely fast but wiped clean when power is lost. More RAM means more concurrent requests and more processes running simultaneously. If you notice your computer getting very laggy when Codex runs multiple tasks, it’s mostly a memory issue — I’d suggest using tw93’s Mole tool to self-check.

Storage (Disk): The server’s “warehouse” — permanently stores data (system, files, database). SSDs (Solid State Drives) are fast but expensive, HDDs (Hard Disk Drives) are slow but cheap. New servers today essentially all use SSD.

6. CDN: How do websites make it fast for users worldwide?

CDN (Content Delivery Network) addresses this problem: a website is hosted in one place, but users are all over the world — how do you make the website load fast for everyone?

The answer is “opening branches nearby”: the website copies content (images, videos, JS files, etc.) to many servers around the world. When users access it, they automatically connect to the nearest server, instead of going back to the origin server every time.

Without CDN: Beijing user → US origin server (slow) With CDN: Beijing user → Beijing edge node (fast) → fetches from origin only when not cached

Key points:

• Edge nodes: CDN cache servers deployed worldwide, close to users;
• Smart routing: DNS and global load balancing direct users to the nearest node (this ties back to “the same domain resolving to different IPs in different regions”);
• Caching: static content (images, videos) is cached on edge nodes — repeat visits hit the cache directly without going back to origin.

7. One of a website’s biggest enemies: DDoS Attacks

DDoS (Distributed Denial of Service): attackers use a large number of compromised computers/devices (a botnet) to simultaneously send massive requests to a target website, saturating the server’s bandwidth (the amount of data that can be transmitted per unit time over a network — detailed in Section 4), CPU, and memory, making it inaccessible to legitimate users.

Massive botnet devices → Simultaneously flood requests → Website bandwidth/CPU/memory saturated → Legitimate users can’t get in

Why is it “literally burning money”?

• If the website uses metered bandwidth/traffic billing, being flooded = astronomical bills;
• Either you buy a higher-spec server to withstand it (spending money), or you buy anti-DDoS protection services (spending even more money), or your business goes down and you lose revenue.

3. What are domain names, URLs, and DNS?

1. Concepts and relationships

Concept	Plain explanation
Domain name	An easy-to-remember name for a website, e.g., openai.com
URL	A complete web address, e.g., https://openai.com/chatgpt
DNS	The system that translates domain names into IPs

IP is the address machines actually use, but humans don’t like remembering IPs (you can’t memorize a string of numbers to visit websites every day), so the internet introduced domain names.

A domain name gives a server a name that’s easy for humans to remember. You just remember openai.com — you don’t need to remember the server IP behind it. But computers ultimately communicate via IP, so there needs to be a “translation system” in the middle that translates openai.com into the server’s IP. That translation system is DNS.

Relationship: Domain name → DNS lookup → IP address → Connect to server

2. What is a domain name?

A domain name is a website’s name on the internet, used to replace complex, hard-to-remember IP addresses. But a domain name is not the same as a URL, and it has its own hierarchical structure. For example, the domain www.example.com can be broken into three levels:

www.example.com │ │ │ Subdomain Second-level Top-level domain domain

.com is a top-level domain (TLD). Other common TLDs include .net, .org, .cn, .ai, .io, etc. example is the second-level domain — usually the part you actually register and own. www is a subdomain. Many websites use www, but some don’t.

Also, domains and IPs don’t have a one-to-one correspondence. One domain can map to multiple IPs, and this is very common.

Large websites rarely have just one server. Behind a domain name there may be multiple IPs, used for load balancing, disaster recovery, CDN acceleration, and proximity-based access.

For example, if you access a website from the US, DNS might return a server IP near the US. If you access the same site from Singapore, DNS might return a server IP near Singapore. So the same domain can resolve to different IPs depending on region, network, and time.

Conversely, one IP can also map to multiple domains. A single server or public IP may host multiple websites.

For example, a.com, b.com, and c.com could all point to the same server IP. After receiving a request, the server looks at which domain is in your request to determine which website you’re trying to access.

So domains and IPs are not strictly one-to-one: one domain can resolve to multiple IPs, and one IP can host multiple domains.

3. What is a URL?

A URL is what we commonly call a “complete web address.” A domain is only part of a URL — a URL is more complete because it not only tells you which website you’re visiting, but also which protocol to use, which page to access, and what parameters to include. For example:

https://www.example.com/articles?id=123#comments

This can be broken down as follows:

Part	Example	Meaning
Protocol	https://	What method of communication
Domain	www.example.com	Which website to visit
Path	/articles	Which page on the website
Parameters	?id=123	Additional info for the server
Anchor	#comments	A specific location within the page

4. What is DNS?

DNS stands for Domain Name System.

Its core function is translating domain names into IP addresses. Humans type in domain names, but network communication ultimately relies on IPs. For example, when you type youtube.com, the browser first needs to know which IP youtube.com corresponds to. This lookup process is called DNS resolution.

But note something important! Domain → IP is just one type of record in DNS’s domain information database, not the whole story. So you can’t completely equate DNS with “translating domain names to IPs” — the DNS records section below includes things beyond name resolution.

The general process is:

You type youtube.com ↓ Browser asks DNS: which IP does youtube.com correspond to? ↓ DNS returns an IP ↓ Browser connects to the server for that IP

To understand the complete, real DNS lookup flow, you need to understand these concepts 👇

1) What is caching?

A cache is temporarily remembering previously queried results for quick reuse later.

For example, if you just visited www.example.com and the system already found its corresponding IP, the next time you visit that site within a short window, the browser or system may reuse the previous result instead of doing a full lookup again.

This has two benefits: first, faster access; second, reduced load on the DNS system.

Browser cache is the DNS lookup result temporarily stored by the browser itself.

If the browser doesn’t have the answer, it typically asks the operating system (OS — the Windows, macOS, iOS, Android layer). The OS may also store DNS lookup results.

For example, if you accessed the same domain through another app (not Chrome) earlier, the resolution result may already be stored by the OS. When Chrome accesses the same domain, it can pull the result from the system.

But caches don’t last forever. Each DNS record (covered later) typically has a TTL — the cache validity period (how long this resolution result can be cached). If the TTL is 300 seconds, the resolution result can be cached for about 5 minutes. After expiry, the system needs to re-query. This is also why after you modify your domain’s DNS records, changes don’t take effect globally immediately — many places are still using the old cache until the TTL expires and refreshes.

2) What are local DNS and recursive DNS?

If neither the browser nor the OS has the answer, the device has to ask a DNS server.

This DNS server is usually called the local DNS, also known as the recursive DNS resolver.

This local DNS might come from your broadband ISP (automatically assigned to your router when it connects to the ISP), or it might be a public DNS you manually set (publicly available domain resolution services, chosen for speed and stability), such as Google DNS, Cloudflare DNS, etc.

For example, when you connect to home Wi-Fi, the router or ISP usually automatically tells your device: “When you look up a domain, ask this DNS server.”

Recursive DNS means: you ask it about a domain, and it takes responsibility for querying all the way down and bringing back the final IP result. For example, you ask local DNS: what IP does www.example.com resolve to?

If it has the answer in its cache, it tells you directly. If it doesn’t, it goes to query the root DNS, TLD DNS, and authoritative DNS (all explained below). This is called recursive querying.

3) Why set a public DNS? Like Google DNS or Cloudflare DNS

By default, the DNS your device uses is usually auto-assigned by your broadband ISP — this is called ISP DNS (or carrier DNS). It’s “good enough” but not great.

Public DNS refers to free DNS services publicly provided by companies or organizations — like Google’s 8.8.8.8 or Cloudflare’s 1.1.1.1. Anyone can manually point their device’s DNS to these.

Switching to public DNS has several main benefits:

First: faster and more stable.

ISP DNS is typically shared by millions of users. During peak times it can slow down, or the entire service can go down (which manifests as “web pages won’t load, but WeChat still works”).

Google and Cloudflare have deployed massive numbers of nodes globally using anycast technology. Your query automatically goes to the nearest node, giving fast speed and high availability.

Second: avoid ISPs “doing things behind your back.”

ISPs frequently manipulate your DNS query results. The most common practices:

• 404 hijacking: you typo a domain and should get “site not found,” but the ISP DNS redirects you to its own ad page;
• Tampering with resolution results: resolving certain domains to IPs they want you to go to;
• DNS pollution: returning wrong IPs for some overseas domains.

Switching to public DNS bypasses these ISP DNS manipulations.

Third: privacy.

Every DNS query is like a record of “which websites you’re about to visit.” With ISP DNS, these records are all in the hands of your ISP.

Both Google and Cloudflare have published privacy policies. Cloudflare additionally promises to clear logs within 24 hours.

Fourth: better security.

Public DNS typically supports DNSSEC (which verifies that resolution results haven’t been tampered with). Cloudflare also offers filtering addresses — 1.1.1.2 automatically blocks malware, and 1.1.1.3 additionally blocks adult content.

Fifth: solving real problems.

When web pages won’t open, domain resolution fails, or websites keep redirecting, switching to public DNS often solves the issue directly.

Sixth: working with proxies.

When using a proxy, if DNS lookups still go through the local ISP, there are two problems: one is possible pollution, and the other is exposing “which overseas sites you’re visiting” to your ISP.

The Fake-IP and remote DNS settings in proxy software essentially exist to handle this problem (covered in the DNS section of the previous article, Clash Verge Tutorial).

Here are some common public DNS addresses worth remembering:

Provider	IPv4 Addresses	Features
Google DNS	8.8.8.8 / 8.8.4.4	Global deployment, fast
Cloudflare	1.1.1.1 / 1.0.0.1	Better privacy, filtering versions available
AliDNS	223.5.5.5 / 223.6.6.6	Fast access in China
DNSPod	119.29.29.29	Fast access in China

4) What are root DNS, TLD DNS, and authoritative DNS?

If the recursive DNS doesn’t know the answer either, it has to start from the top of the DNS hierarchy — the root DNS.

The root DNS doesn’t directly tell you the final IP of www.example.com. It’s more like a master index that only tells you where to go next.

For example, to look up www.example.com, the root DNS checks the trailing .com and tells the recursive DNS: “You’re looking up a .com domain — go ask the TLD DNS responsible for .com.”

The DNS responsible for top-level domains is called the TLD DNS.

For instance, when you look up www.example.com, the recursive DNS asks the .com TLD DNS. The .com TLD DNS also usually doesn’t return the final IP — it says: “Here’s where the authoritative DNS for example.com is. Go ask it.”

The authoritative DNS is where the actual DNS records for a domain are stored.

For example, example.com’s authoritative DNS might hold: which IPv4 address and which IPv6 address www.example.com should point to.

So the recursive DNS finally asks the authoritative DNS: “What IP does www.example.com actually correspond to?” Only the authoritative DNS returns the final answer. The recursive DNS then brings that answer back to your device, and your browser — now holding the IP — can actually connect to the server.

5. What are DNS records?

DNS records are the “answers” that DNS queries ultimately retrieve — the mapping table that determines where a domain should resolve to.

Where a domain resolves isn’t decided out of thin air — it’s configured through DNS records. After you buy a domain, you configure resolution records at your domain registrar or DNS provider. The most common record types are:

Record Type	Function	Plain explanation	When it’s used
A record	Points a domain to an IPv4 address	Tells the world: this domain’s