Description

From smart appliances to gigantic data centers, from phones to satellites, networks are the way computers talk to each other. Learn how to use network protocols, choose or design serialization protocols, and architect systems with servers and clients.

Start with the most widely-used protocol on the Internet: TCP. Build a chat server where multiple clients can chat in real time. Explore client-side TCP by building a client for Redis. Scale and harden server and client, thanks to features of the BEAM. Then dig into UDP, TCP’s “looser” sibling. Code a system for reporting metrics capable of rivaling hardened software like StatsD. Learn about DNS, which powers domain resolution for the Internet. Next, secure your TCP traffic with TLS. Lastly, explore HTTP, the protocol that even your microwave could be using. Build a JSON API, client, and server. Learn the differences between HTTP/1.1 and HTTP/2, and add real-time features via WebSockets.

The BEAM was built for networks and has been honed for more than three decades. It’s the perfect fit. Leverage years of real-world experience building network-intensive applications from a member of the Elixir core team, and become an expert at network programming in Elixir and Erlang.

Contents and Extracts

Introduction

What Is Network Programming Anyway?

• Erlang and Elixir: The Perfect Fit
• Which One, Though, Erlang or Elixir?
• Where Do We Go Next?
• TCP
  • TCP: Exploring the Basics
    • TCP 101
    • Building a TCP Echo Server
    • Testing with TCP
    • Becoming Socket Pros with Modes and Packet Parsing
    • Wrapping Up
  • Designing a Chat Protocol and Its TCP Server
    • Designing a Simple Chat Protocol
    • Writing Code for the Chat Protocol
    • Moving to the Server Side
    • Chatting with Clients
    • Wrapping Up
  • Scaling TCP on the Server Side
    • Increasing Scalability with Multiple Acceptors
    • Rewriting the Server with Thousand Island
    • Wrapping Up
  • Building TCP Clients
    • The Redis Protocol
    • Building Our First Client
    • Queuing Requests
    • Wrapping Up
  • Scaling and Optimizing TCP Clients
    • Pooling TCP Client Sockets
    • Building State-Machine-Like TCP Clients
    • Pooling Connections Through Registry
    • Wrapping Up
  • Securing Protocols: TLS
    • Understanding How TLS Works
    • The ssl Application
    • Securing Our Chat System
    • Wrapping Up
• UDP
  • Same Layer, Different Protocol: Introducing UDP excerpt
    • The Basics of the Protocol
    • Building a Metrics Ingestion Daemon
    • Wrapping Up
  • Adding Guarantees to UDP
    • Ordering, Splitting, and Dropping Packets
    • Adding Guarantees
    • Wrapping Up
  • UDP in the Wild: DNS
    • Understanding How DNS Works
    • Writing a Simple DNS Client
    • inet_res
    • Writing a DNS Server Is So Easy
    • Wrapping Up
• HTTP
  • Talking the Internet Protocol: HTTP/1.1
    • HTTP/1.1 Protocol Basics
    • Serving JSON with Plug and Bandit
    • Connecting to Servers with Mint
    • Higher-Level Client Libraries: Finch and Req
    • Wrapping Up
  • HTTP/2 and the Future
    • HTTP/2: Why It Was Needed and What Changed
    • Using HTTP/2 with Plug and Mint
    • Evolving in Parallel with QUIC and HTTP/3
    • Wrapping Up
  • Communicating in Real Time with WebSockets
    • The WebSocket Protocol
    • Making a Silly Real-Time Game
    • Wrapping Up
• Appendixes
  • The OSI Model
  • TCP Protocol Details
    • TCP Binary Format
    • Connection States
  • UDP Broadcast and Multicast
    • Broadcast
    • Multicast
  • DNS Protocol Details
    • DNS Message Header
    • DNS Message Body
  • Controlling Other Machines with SSH
    • Using SSH as Clients
    • SSH Server