# Networking Capabilities of Node.js: A Complete Developer's Guide

Master backend networking in Node.js with practical insights into HTTP servers, real-time communication, socket programming, and security hardening. Build scalable network applications with production-ready patterns.

🎯 HTTP/HTTPS Server Implementation

Node.js ships with native HTTP/HTTPS modules enabling lightweight server creation without external dependencies. The http module handles incoming requests asynchronously, perfect for REST APIs and traditional request-response patterns.

import http from 'http';
import fs from 'fs';
import https from 'https';

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ message: 'Hello from Node.js' }));
});

const httpsOptions = {
  key: fs.readFileSync('key.pem'),
  cert: fs.readFileSync('cert.pem')
};

https.createServer(httpsOptions, (req, res) => {
  res.end('Secure connection established');
}).listen(443);

server.listen(3000);

Both HTTP and HTTPS operate on event-driven architecture. The non-blocking I/O model allows handling thousands of concurrent connections efficiently. HTTPS requires certificate setup for encrypted communication—essential for production environments handling sensitive data.

🔧 TCP/UDP Socket Programming

Sockets provide low-level network communication bypassing HTTP abstractions. TCP (Transmission Control Protocol) ensures reliable, ordered delivery ideal for critical data. UDP (User Datagram Protocol) offers lower latency for applications tolerating occasional packet loss.

import net from 'net';

const tcpServer = net.createServer((socket) => {
  socket.write('Welcome to TCP server\n');

  socket.on('data', (data) => {
    console.log('Received:', data.toString());
    socket.write(`Echo: ${data}`);
  });

  socket.on('end', () => console.log('Client disconnected'));
}).listen(8000);

// UDP server
import dgram from 'dgram';
const udpServer = dgram.createSocket('udp4');

udpServer.on('message', (msg, rinfo) => {
  console.log(`UDP message from ${rinfo.address}: ${msg}`);
});

udpServer.bind(9000);

TCP maintains connection state through handshaking, guaranteeing message delivery and order. UDP fires packets without handshaking—lightweight but unreliable. Choose TCP for financial transactions; UDP for video streaming or gaming where speed matters more than perfection.

⚡ WebSocket Real-Time Communication

WebSockets establish persistent, bidirectional connections over HTTP, eliminating request-response overhead. Perfect for live notifications, collaborative tools, and multiplayer applications requiring sub-second latency.

import { WebSocketServer } from 'ws';
import http from 'http';

const server = http.createServer();
const wss = new WebSocketServer({ server });

wss.on('connection', (ws) => {
  console.log('Client connected');

  ws.on('message', (message) => {
    // Broadcast to all connected clients
    wss.clients.forEach((client) => {
      if (client.readyState === 1) {
        client.send(`Broadcast: ${message}`);
      }
    });
  });

  ws.on('close', () => console.log('Client disconnected'));
});

server.listen(3001);

WebSockets maintain single TCP connection indefinitely, reducing handshake overhead by 99% compared to repeated HTTP connections. Browser support is universal in modern environments. Memory footprint scales linearly with client count—consider connection pooling for 10,000+ concurrent connections.

🔒 DNS Resolution & Security

DNS resolution translates domain names to IP addresses. Node.js provides both blocking and async methods through the dns module. Always use async variants to prevent event loop blocking in production.

import dns from 'dns';
import tls from 'tls';

// Async DNS resolution
dns.resolve4('example.com', (err, addresses) => {
  if (err) throw err;
  console.log(`IPv4 addresses: ${addresses}`);
});

// Rate limiting middleware (pseudo-code)
const rateLimiter = new Map();
const limit = (req, res, next) => {
  const key = req.ip;
  const count = rateLimiter.get(key) || 0;

  if (count > 100) {
    return res.status(429).send('Too many requests');
  }

  rateLimiter.set(key, count + 1);
  next();
};

// TLS cipher configuration
const tlsOptions = {
  ciphers: 'HIGH:!aNULL:!MD5',
  honorCipherOrder: true,
  secureOptions: tls.DEFAULT_ECDH
};

Always validate DNS responses against expected values—DNS poisoning remains a threat vector. Implement exponential backoff for DNS queries during failures. Rate limiting prevents DDoS attacks by throttling malicious traffic patterns. TLS cipher configuration hardens against cryptographic attacks; rotate cipher suites quarterly.

Key Takeaways

• HTTP/HTTPS handle traditional request-response; WebSockets enable real-time bidirectional flow
• TCP guarantees delivery; UDP prioritizes speed—choose based on data criticality
• DNS resolution must be async to prevent event loop blocking
• Implement rate limiting and TLS hardening for production deployments
• Monitor connection counts; WebSocket servers scale differently than HTTP servers
• Socket connections persist indefinitely until explicitly closed—implement heartbeats to detect stale connections

Comments

[Emir Taner]

It is very impressive, thank you for sharing!