I made my own DNS server

As a developer, I've always been fascinated by the intricate workings of the web. While we often take for granted the seamless experience of typing a URL into our browsers and instantly accessing websites, there's a complex system operating behind the scenes. To deepen my understanding of this fundamental web technology, I decided to embark on a project to create my own DNS server.

Understanding DNS and Nameservers

Before diving into the implementation, it's crucial to understand what DNS (Domain Name System) is and how it works. DNS is essentially the phonebook of the internet. It translates human-readable domain names (like www.example.com) into IP addresses (like 192.0.2.1) that computers use to identify each other on the network.

Nameservers play a vital role in this system. They are servers dedicated to handling queries about the location of domain names' services. When you type a URL into your browser, your computer first contacts a DNS resolver, which then queries various nameservers to find the IP address associated with that domain name.

TCP/UDP and DNS Server Communication

DNS servers primarily use UDP (User Datagram Protocol) for communication due to its speed and efficiency. UDP is connectionless, meaning it doesn't require a continuous connection between the client and server, making it ideal for quick DNS lookups.

Here's a simplified explanation of how a DNS query works:

1. Your computer sends a UDP packet containing the DNS query to a DNS resolver.

2. The resolver sends queries to various nameservers, starting with the root servers.

3. The nameservers respond with either an answer or a referral to another nameserver.

4. Once the resolver gets the final answer, it sends it back to your computer.

While UDP is the primary protocol, DNS can fall back to TCP for larger responses or when UDP packets are lost.

Implementing the DNS Server: Code Snippets

Let's look at some basic code snippets to understand how a DNS server listens for and responds to requests. Here's a simplified version of the core functionality:

const dgram = require('dgram');
const server = dgram.createSocket('udp4');

server.on('message', (msg, rinfo) => {
  // Decode the DNS query
  const query = dnsPacket.decode(msg);

  // Process the query and generate a response
  const response = processQuery(query);

  // Encode and send the response
  const responseBuffer = dnsPacket.encode(response);
  server.send(responseBuffer, rinfo.port, rinfo.address);
});

server.bind(53);

This code sets up a UDP server that listens on port 53 (the standard DNS port) and processes incoming messages.

Packaging with Docker

To make the DNS server and its dependencies easily deployable, I used Docker. Here's a snippet from my Docker Compose file:

version: "3.8"
services:
  dns-backend:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "53:53/udp"
      - "3000:3000"
    depends_on:
      - redis
    environment:
      - REDIS_HOST=redis
      - REDIS_PORT=6379
    networks:
      - dns-network
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    volumes:
      - ./redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - dns-network

This configuration sets up two services: the DNS server backend and a Redis instance for storing DNS records. It also defines the necessary network and volume configurations.

Conclusion

Building my own DNS server was an enlightening experience that deepened my understanding of how the web works at a fundamental level. It gave me hands-on experience with network protocols, distributed systems, and containerization.

While this implementation is not meant for production use, it serves as a great learning tool and a starting point for further exploration into internet infrastructure.

If you're interested in exploring the code or trying it out yourself, you can find the complete project on my GitHub repository: https://github.com/CodeGeek04/Personal-DNS

Happy coding and exploring!