Unix Sockets

Same socket API, local address

A Unix domain socket (UDS) is a connection endpoint addressed by a filesystem path (/tmp/app.sock) rather than an IP:port. It gives the same full-duplex, stream-oriented connections as TCP — but only between processes on the same machine, and it skips the entire network stack.

The beauty in Go: the net package treats it as just another network. Change "tcp" → "unix" and the address, and your code is otherwise identical.

graph LR
subgraph host["one host"]
  C["client process"] -->|"net.Dial(unix, /tmp/app.sock)"| S["server process"]
  S -->|"net.Listen(unix, /tmp/app.sock)"| C
end

A bidirectional conn, runnable

Real UDS needs a filesystem socket the sandbox can’t create, so here’s the same net.Conn request/response model over an in-memory net.Pipe — the exact interface a Unix socket gives you:

package main

import (
"bufio"
"fmt"
"net"
)

func main() {
// net.Pipe gives two connected, in-memory net.Conn endpoints —
// the same Read/Write interface a Unix (or TCP) socket provides.
server, client := net.Pipe()

// Server goroutine: read a request line, write a response.
go func() {
	defer server.Close()
	req, _ := bufio.NewReader(server).ReadString('\n')
	fmt.Fprintf(server, "echo: %s", req)
}()

// Client: send a request, read the reply.
fmt.Fprintln(client, "ping")
resp, _ := bufio.NewReader(client).ReadString('\n')
fmt.Print(resp) // echo: ping
client.Close()
}

Over a real Unix socket the only difference is how you obtain the conn — Listen/Accept/Dial on a path — not how you use it.

A real Unix-socket server and client

On an actual machine:

// Server — listen on a socket file.
os.Remove("/tmp/app.sock") // clear any stale socket from a crash
ln, err := net.Listen("unix", "/tmp/app.sock")
if err != nil { log.Fatal(err) }
defer ln.Close()
for {
	conn, err := ln.Accept()
	if err != nil { break }
	go handle(conn) // one goroutine per connection, just like TCP
}

// Client — dial the path.
conn, err := net.Dial("unix", "/tmp/app.sock")

Restrict who can connect with the socket file’s permissions:

os.Chmod("/tmp/app.sock", 0o600) // only the owner may connect

HTTP over a Unix socket

Because http.Serve accepts any net.Listener, you can speak HTTP over a socket file — the pattern used by the Docker daemon, admin/metrics endpoints, and sidecars that shouldn’t be on the network:

// Server:
ln, _ := net.Listen("unix", "/tmp/api.sock")
http.Serve(ln, mux) // HTTP, but over the socket file

// Client: teach the Transport to dial the socket; the URL host is ignored.
client := &http.Client{Transport: &http.Transport{
	DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
		return (&net.Dialer{}).DialContext(ctx, "unix", "/tmp/api.sock")
	},
}}
resp, _ := client.Get("http://unix/status")

See also

• pipes — simpler, one-directional local IPC.
• TCP sockets (web) — the same net API over the network.
• UDP sockets (web) — connectionless datagrams.
• memory-mapped files — another zero-copy local sharing trick.

Next: sharing a file as memory, with no copies — memory-mapped files.

Related topics