Skip to content
System Design

Inter-Service Communication

A guide to the protocols, patterns, and architectural styles for communication between services in a distributed system.

Table of Contents

Synchronous vs. Asynchronous Communication

  • Synchronous: The client sends a request and waits for a response. This is a blocking operation. REST is a common example of synchronous communication.
  • Asynchronous: The client sends a request and does not wait for an immediate response. This is a non-blocking operation, often managed with message queues or event-driven architectures.

Common Communication Protocols

TCP/IP (Transmission Control Protocol/Internet Protocol)

  • A connection-oriented protocol that provides reliable, ordered, and error-checked delivery of a stream of bytes.
  • It establishes a connection before data is sent and ensures that all data arrives in the correct order.
  • Used by many higher-level protocols, including HTTP.

UDP (User Datagram Protocol)

  • A connectionless protocol that is faster than TCP but does not provide reliability, ordering, or error checking.
  • It is often used for applications where speed is more important than reliability, such as video streaming, online gaming, and DNS.

HTTP (Hypertext Transfer Protocol)

  • An application-layer protocol for transmitting hypermedia documents, such as HTML. It is the foundation of data communication for the World Wide Web.
  • It follows a client-server model, where the client sends a request and the server sends a response.

Architectural Styles and Patterns

REST (Representational State Transfer)

REST is an architectural style for designing networked applications. It is not a protocol but a set of constraints that, if followed, lead to a scalable, fault-tolerant, and easy-to-use system.

  • Key Principles:
    • Client-Server: Separates the user interface from the data storage, improving portability and scalability.
    • Stateless: Each request from a client must contain all the information needed to understand and complete the request. The server does not store any client context between requests.
    • Cacheable: Responses must be explicitly or implicitly labeled as cacheable or non-cacheable.
    • Uniform Interface: A consistent interface between clients and servers simplifies and decouples the architecture.
    • Layered System: The architecture can be composed of hierarchical layers, where each component cannot see beyond the immediate layer with which it is interacting.

RPC (Remote Procedure Call)

RPC is a pattern where a client executes a procedure or function on a remote server as if it were a local call. The client and server are tightly coupled through a generated stub.

  • gRPC: A modern, open-source RPC framework developed by Google. It uses HTTP/2 for transport and Protocol Buffers as the interface description language, providing features like authentication, load balancing, and health checking.

Real-time Communication

WebSockets

  • Provides a full-duplex communication channel over a single, long-lived TCP connection.
  • Allows for real-time, bidirectional communication between the client and server.
  • Use Cases: Chat applications, real-time multiplayer games, live data feeds.

Long Polling

  • A technique where the client sends a request to the server, and the server holds the connection open until it has new data to send. Once the data is sent, the connection is closed, and the client immediately sends another request.
  • It is a way to simulate a push mechanism from the server.

Server-Sent Events (SSE)

  • A standard that allows a server to send events to a client over a single HTTP connection.
  • The connection is kept open, and the server can push data to the client at any time.
  • Key Difference from WebSockets: SSE is unidirectional (server to client only).

Summary

Choosing the right communication method is crucial for designing efficient and scalable distributed systems. The choice depends on the specific requirements of the application, including the need for synchronous or asynchronous communication, real-time updates, and the trade-offs between performance and reliability. Understanding the differences between protocols like TCP and UDP, architectural styles like REST and RPC, and real-time patterns like WebSockets is essential for making informed design decisions.