Streaming via Unix Domain Sockets

Use streams over local sockets for high-performance communication between microservices on the same host.

In this lesson, you will learn how to leverage Unix Domain Sockets (UDS) to create high-performance, low-latency streaming pipelines between two Node.js processes running on the same host.

Why Unix Domain Sockets?

When you need two microservices on the same physical server to talk to each other, using standard TCP sockets involves the network stack—loopback interfaces, checksum calculations, and routing logic. This introduces unnecessary overhead. Unix Domain Sockets bypass the network stack entirely. They treat communication as a file-based stream, offering significantly higher throughput and lower latency for inter-process communication (IPC).

Implementing the Stream

Because UDS in Node.js returns a net.Socket (which is a Duplex stream), you can use them exactly like any other stream you’ve worked with, including pipes and backpressure management.

Here is a simplified example of setting up a streaming producer:

const net = require('net');
const fs = require('fs');

const socketPath = '/tmp/my-app.sock';

// Clean up existing socket file before starting
if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath);

const server = net.createServer((socket) => {
  // We can pipe any readable stream into the socket
  // The stream will respect backpressure automatically
  process.stdin.pipe(socket);
});

server.listen(socketPath);

On the consumer side, you simply connect to the same file path:

const client = net.createConnection(socketPath);

client.on('data', (data) => {
  console.log('Received chunk:', data.length);
});

Managing Backpressure

The beauty of this approach is that it is fully backpressure-aware. If your consumer process (the reader) slows down, the internal buffer of the net.Socket fills up. Node.js then signals the producer to pause its readable stream, preventing memory bloating. This makes UDS an ideal transport layer for high-throughput microservices that need to exchange data without the overhead of HTTP or TCP.

Because the underlying mechanism is just a stream, you can easily plug this into your existing pipeline patterns (like the reactive data pipelines or stream orchestrators you’ve already mastered) without changing your core application logic.

Key Takeaway: Unix Domain Sockets provide a high-performance IPC mechanism by treating local process-to-process communication as a stream, fully supporting native backpressure and efficient memory usage.