Master Go Network Protocols: From TCP/UDP to HTTP/3 and TLS

Introduction

Network protocols are the traffic rules of the Internet. For Go developers who have only used http.ListenAndServe, performance, security, and real‑time constraints can quickly become bottlenecks. This article starts from the layered model, systematically reviews TCP, UDP, HTTP, RPC, WebSocket, TLS, CDN, and HTTP/3, and ties each concept to Go development and deployment practices.

Network Layering Models

Understanding the layered model helps keep a global view instead of getting stuck in a single layer.

OSI 7‑layer model (theoretical): Physical → Data Link → Network → Transport → Session → Presentation → Application.

TCP/IP 4‑layer model (developer‑friendly):

Network Interface Layer: Ethernet, Wi‑Fi.

Network Layer: IP, routing.

Transport Layer: TCP, UDP.

Application Layer: HTTP, RPC, WebSocket, etc.

Go developers mainly interact with the Transport and Application layers, but a full‑stack understanding speeds up problem location.

Transport Layer Protocols

TCP – The Reliable Foundation

Three‑way handshake and four‑way termination ensure reliable connections.

Packets are ordered and loss‑free.

Commonly used for web services and database connections.

Go TCP server example:

ln, _ := net.Listen("tcp", ":8080")
for {
    conn, _ := ln.Accept()
    go func(c net.Conn) {
        defer c.Close()
        buf := make([]byte, 1024)
        n, _ := c.Read(buf)
        fmt.Println("收到:", string(buf[:n]))
        c.Write([]byte("已收到"))
    }(conn)
}

UDP – The Speedy Messenger

Connection‑less, no reliability guarantee, but low latency.

Suitable for voice calls, live streaming, real‑time games.

Application Layer Protocols

HTTP

HTTP/1.1: Widely used but suffers from head‑of‑line blocking.

HTTP/2: Multiplexing, header compression, server push.

HTTP/3: Built on QUIC (UDP), faster and more stable.

RPC

Common in micro‑service architectures, abstracts transport details.

gRPC is the mainstream choice in the Go ecosystem (HTTP/2 + Protobuf).

WebSocket

Single handshake, long‑lived connection.

Bidirectional communication, ideal for IM, collaboration, real‑time push.

Security Layer: TLS/SSL

Purpose: encrypt traffic and prevent man‑in‑the‑middle attacks.

Mechanism: asymmetric encryption during handshake, symmetric encryption for data transfer.

Go native HTTPS support example:

http.ListenAndServeTLS(":443", "server.crt", "server.key", nil)

Network Optimization and Evolution

CDN

Cache content closer to users.

Alleviates origin server load and reduces latency.

Used for static assets and edge‑cached APIs.

HTTP/2 & HTTP/3

HTTP/2 solves head‑of‑line blocking and improves transfer efficiency.

HTTP/3, based on UDP’s QUIC, offers faster, more stable delivery, especially on weak networks.

Go Development and Deployment Practices

HTTP/2 support by default: Go enables HTTP/2 automatically when TLS is used.

HTTPS is essential: Enable TLS, preferably with free Let’s Encrypt certificates.

CDN integration: Deploy static resources to a CDN for performance gains.

Real‑time scenarios: Use WebSocket for chat/notifications; consider UDP/QUIC for games or live streaming.

Micro‑services: Prefer gRPC for internal service calls.

Conclusion

Layered model: Grasp the whole stack.

TCP/UDP: Build a solid transport foundation.

HTTP/RPC/WebSocket: Choose the right application‑layer protocol.

TLS: Ensure security.

CDN/HTTP/3: Optimize performance.

By flexibly combining these protocols and optimization techniques, Go developers can build services that are not only functional but also excel in performance, security, and stability.

Thought Exercise

If you were to deploy a global real‑time interactive application such as an online education platform, how would you combine CDN, WebSocket, HTTP/3, and TLS to design the overall solution?