Building Modern Distributed Systems with Java

Explore remote procedure calls, serialization and deserialization, legacy to Google Protocol Buffers and Apache Avro formats, and idempotent design with service discovery for resilient distributed systems.

Explore message transport and format by comparing tcp, udp, ftp, http, xml, json, Google Protocol Buffers, and Apache Avro, highlighting readability, serialization time, and bandwidth considerations.

Explore synchronous request-reply and asynchronous fire-and-forget patterns, including timeouts, correlation IDs, and asynchronous with confirmation, to manage client-server interactions in modern distributed systems.

Discover how traditional load balancers prevent single points of failure by distributing client requests across backend servers, using health checks and software proxies such as Apache or Nginx.

Explore how service registries enable robust inter-service communication by registering endpoints, replicating information across nodes via heartbeats, and supporting dynamic load balancing without static nginx configurations.

Discover how service meshes use sidecar proxies for discovery, routing, and secure inter-service communication, removing rpc code from applications. Explore circuit breakers, canary deployments, and distributed tracing within Kubernetes.

Design idempotent services with a fixed idempotency key to handle retries and duplicates, and manage race conditions in distributed systems.

Demonstrate resilient backend by using docker compose to run two registered services behind a gateway, with dynamic scaling, traffic redirection, and controlled failure injection.

Compare traditional RDBMS and NoSQL solutions, highlighting three-tier architecture and migration challenges. Explore data sharding, consistent hashing, Cap theorem, and Cassandra as scalable, fault-tolerant options for distributed systems.

Learn how NoSQL databases shard petabytes of data using consistent hashing to distribute keys across nodes, reduce hotspots, and ease data movement during cluster resizing, with replication and consistency considerations.

Explore Apache Cassandra, a horizontally scalable, no-sql, columnar database that uses partitioning, replication, and tunable consistency to provide availability and performance in distributed systems.

Build a url shortening service with Apache Cassandra, using the DataStax driver, ensure idempotent statements, handle quorum failures, and verify ttl-based record expiry in a docker compose environment.

Explore when cluster-wide coordination is needed and how raft consensus, etcd, and distributed mutexes enable leader election and stateful, strongly consistent deployments.

Explore Raft's leader election and log replication, including terms, split votes, random delays, and append entries that commit data by a majority, ensuring safety and consistency.

Explore how etcd enables strongly consistent distributed configurations and service discovery through raft-based replication, quorum reads, leases, watches, and atomic mini transactions.

Learn how to implement a distributed mutex on etcd, providing acquire and unlock, with a fair waiting list, using etcd keys, lease IDs, mini transactions, watches, and automatic recovery.

Explore the leader election design pattern, its advantages and disadvantages, and how a single leader performs shared-resource tasks with consensus, compared to distributed locks via Etcd.

Deploy quorum-based etcd clusters with an odd node count across three or more availability zones or data centers to tolerate failures. Tune heartbeat interval and election timeout to match latency.

Explore ACID properties in distributed systems, highlighting durability through replication, and distinguishing consistency from atomicity and isolation, with idempotent services and client-side retries using raft-based coordination.

Explore asynchronous communication and message oriented middleware, including point to point and publish subscribe delivery, using Apache Kafka with producers and consumers configured for high availability and zero message loss.

Explore how Apache Kafka rethinks messaging by persisting all events in an append-only commit log and tracking consumer offsets for high-throughput, low-latency streaming.

Understand how Apache Kafka functions as a distributed system with topics, partitions, leaders, and replication, and how producers and consumers use idempotence, acks, and consumer groups.

Event driven architecture broadcasts real-time state changes to interoperable services via an event router, enabling elastic buffering and asynchronous communication. It covers messaging models and Kafka basics.

Practice 5 demonstrates a distributed messaging workflow with Kafka, notifying operations when long URLs contain inappropriate words, and examines high availability via multi-broker failover and producer buffering.