System Design on AWS (Jayanth Kumar, Mandeep Singh) (Z-Library)

# System Design on AWS ## 【One-Line Pitch】 A practical, decision-oriented guide for architects and senior engineers who need to choose and combine AWS services to build scalable, resilient, and cost-effective systems—from foundational distributed computing concepts to advanced architectural patterns. ## 【Book Arc】 - **Opening (~0%–3%)**: Establishes the core challenges of large-scale cloud applications and introduces the eight fallacies of distributed computing—unreliable networks, zero latency assumptions, and infinite bandwidth myths—that shape every design decision throughout the book. - **Early (~3%–19%)**: Covers data layer fundamentals, including nonrelational database concepts (schema flexibility, key-value stores like Dynamo), caching strategies (local vs. remote, Redis persistence models), and load-balancing algorithms (round robin, weighted, hash-based). - **Early–Middle (~19%–32%)**: Explores communication protocols (TCP/IP, UDP, HTTP, WebRTC, GraphQL), synchronous vs. asynchronous service design, server-sent events, and transitions into containerization with Docker—covering container lifecycle, orchestration, and modern deployment strategies like canary releases. - **Middle (~32%–48%)**: Delves into architectural patterns including domain-driven design, choreography vs. orchestration, message brokers, and publisher-subscriber models. Introduces AWS networking fundamentals—VPCs, subnets, internet/NAT gateways, hybrid connectivity, and multi-account strategies. - **Late (~48%–end)**: Examines specific AWS services in depth—RDS for ACID-compliant relational data, DynamoDB with DAX caching, OpenSearch for search functionality, and autoscaling strategies including prescaling for spiky traffic. The book concludes with practical design considerations for real-world applications. ## 【Key Takeaways】 - **Distributed computing fallacies are design constraints, not theoretical warnings** (Early): Assuming reliable networks, zero latency, or infinite bandwidth leads to fragile architectures. Design for network fault tolerance, edge computing for latency reduction, and traffic routing that accounts for bandwidth contention from the start. - **Nonrelational databases trade schema rigidity for scalability and flexibility** (Early): Key-value stores like Dynamo excel in scenarios requiring fast, direct data access—session management, user profiles, product catalogs, and real-time analytics. However, developers must handle complex data relationships at the application layer, which complicates application design. - **Caching strategy is a fundamental architectural decision** (Early): Choose between local caching (fast, but limited to a single machine) and remote caching (shared across distributed systems, providing scalability and fault tolerance). Redis offers two persistence models—RDB snapshots for full recovery but potential data loss between snapshots, and AOF write-ahead logging for durability up to the last command. - **Load-balancing algorithms involve trade-offs between simplicity and intelligence** (Early): Round robin distributes requests equally but ignores server load; weighted round robin accounts for varying capacities; hash-based algorithms ensure session persistence but face issues with server changes. Most production clusters use simple round robin due to identical machine configurations. - **Containerization evolved from physical server inefficiencies** (Early): Traditional deployment suffered from resource monopolization and underutilization. Containers run as isolated processes with their own namespaces, filesystems, and network stacks—with an init process (PID 1) managing application processes and handling signals. - **Modern deployment strategies minimize risk through gradual rollouts** (Early): Continuous Deployment automates the pipeline from test to staging to production. Canary deployments release updates to a small user group first, monitor metrics like error rates and latency, and enable automated rollbacks before full deployment. - **AWS networking fundamentals determine security and connectivity** (Middle): The only difference between public and private subnets is a direct route to an internet gateway. Private subnets require NAT services for internet access. AWS recommends multi-account setups with services like Control Tower and Landing Zone for clear division of responsibility and governance. - **Service selection depends on your consistency requirements** (Late): RDS suits business requirements needing full ACID compliance for relational structured data. DynamoDB with DAX serves eventually consistent reads from cache while writing to both DynamoDB and DAX for write operations. OpenSearch handles search queries across food items, locations, and filters. ## 【Reading Tips】 - **Skim the fallacies chapter (~0%–3%)** if you're already experienced with distributed systems—the eight fallacies are foundational but well-known; focus instead on the AWS-specific implications mentioned throughout. - **Deep-read the caching and load-balancing sections (~7%–8%)**—these concepts appear repeatedly in later chapters and are essential for understanding service-specific optimizations like DAX. - **Pay special attention to the networking chapter (~39%–48%)**—VPC design, subnet routing, and hybrid connectivity are the most complex topics for beginners and form the backbone of any AWS architecture. - **Use the containerization chapter (~29%–32%) as a bridge**—if you're already familiar with Docker, skim quickly; if not, this is where the book transitions from theory to practical deployment strategies. - **The service-specific chapters (~48%+) are best read as reference material**—rather than reading sequentially, jump to the service relevant to your current project (RDS, DynamoDB, OpenSearch) and cross-reference with earlier concepts. ## 【Coverage Limits】 Excerpts do not cover the book's final chapters in detail, including the financial application case study (Chapter 21), advanced Kubernetes orchestration specifics, or the complete AWS service catalog. The guide focuses on the foundational concepts and architectural patterns that appear in the sampled material. ##