liveBook · Manning

Distributed system

As explained in Platform Engineering on Kubernetes

A distributed system is a computing system whose functionality is divided among independently operating services that communicate across process or network boundaries.

A distributed system divides functionality among independently operating services that communicate across process or network boundaries. Unlike a monolith, its services can evolve, scale, and be changed by teams more independently, but the architecture introduces coordination and operational complexity. section 1.4.2 section 2.1

Distributed applications trade monolithic simplicity for finer operational and team-level control:

  • Teams work against stronger service boundaries instead of coordinating every change in one shared codebase. section 1.4.2
  • Services can scale according to their own load rather than requiring the entire application to scale together. section 1.4.2
  • Operations must account for networking latency, failures in individual services, and eventual inconsistencies. section 2.1

A controllable cloud-native application

A walking-skeleton application provides a practical distributed-system model that can be configured, experimented with, and deliberately broken. Running it exposes the effects of service failures, network latency, and eventual inconsistencies; Kubernetes supplies the cluster environment. section 2.1

Figure 1.20 In a monolith application, all the logic to implement different use cases are bundled together. This push different teams to work on the same codebase and requires them to have complex coordination practices to avoid conflicting changes.

Compare bundled monolithic logic with independently evolving services and the coordination practices each architecture requires. section 1.4.2

How Platform Engineering on Kubernetes covers it

How deep it goes
Explains architectural differences, scaling benefits, and operational failures, but stops short of service-internal implementation details.
Examples
Uses a walking-skeleton application, monolith comparison, Kubernetes cluster, and figures contrasting bundled logic with distributed services.
What it assumes
Assumes familiarity with monolithic applications while introducing distributed application challenges through a controllable Kubernetes example.
What you can do after
Evaluate distributed architecture trade-offs and experiment with service latency, failures, scaling, and consistency in Kubernetes.
How it connects
Connects distributed systems with monoliths, cloud-native applications, Kubernetes, networking latency, resilience, and eventual consistency.

Also explained in

Compare how 15 books explain distributed system →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Platform Engineering on Kubernetes. The section links point to the parts of the book it draws on.