Design Patterns for Cloud Native Applications Patterns in Practice Using APIs, Data, Events, and Streams (Kasun Indrasiri, Sriskandarajah Suhothayan) (Z-Library)

【One-Line Pitch】 A pattern catalog for engineers who already accept cloud native as the goal and now need the "how": concrete design patterns for APIs, data, events, and streams, with the trade-offs and technologies behind each. Best for backend and platform developers, architects, and tech leads working on microservices in greenfield or brownfield systems. 【Book Arc】 - **Opening (~0%–10%)**: Frames the problem — cloud native is settled in principle, so the real question is design. Introduces the shift from SOA/ESB monoliths to microservices, and previews the pattern families covered in later chapters. - **Early (~10%–30%)**: Establishes fundamentals: cloud native characteristics, the build methodology (including a control plane for dynamic management and observability/monitoring), Kubernetes as the de facto orchestration layer, and why conventional patterns must be adapted. - **Early–Middle (~30%–50%)**: Communication patterns. Synchronous styles (request-response, RPC) and asynchronous messaging (queues, single-receiver, asynchronous request-reply), plus service definition concerns like schema registries and AsyncAPI. - **Middle (~50%–65%)**: Connectivity and composition — service connectivity, abstraction, registry/discovery, resilient connectivity, sidecar and service mesh, then orchestration, choreography, and Saga for business transactions. - **Late (~65%–85%)**: Data management patterns — choosing data stores, decentralized data ownership, and composing data across services while preserving scalability and reliability. - **Ending (~85%–100%)**: Event-driven architecture patterns — event delivery, event sourcing, and orchestrating events across asynchronous services, closing with the tools and technologies for building cloud native systems. 【Key Takeaways】 - **Cloud native is a methodology shift, not just a deployment target** (Early): the book stresses that architecture, technology, and process all change together; treating it as "containers plus CI/CD" misses the point. - **Microservices exist to remove SOA's centralization** (Early): fine-grained, business-capability-oriented services replace the ESB, enabling independent scaling and deployment — the trade-off is distributed complexity you must design for. - **Kubernetes is the portability substrate** (Early): its abstractions (service discovery, health monitoring, rolling upgrades, affinity, namespaces) let applications avoid coupling to a specific cloud, provided you avoid platform-specific features. - **Choose communication style by use case, not by fashion** (Middle): request-response suits interactive calls; asynchronous messaging suits decoupling and guaranteed delivery. The book warns that asynchronous request-reply is not simply a "better" request-response. - **Schemas are a reliability concern in async messaging** (Middle): without schema-based serialization, producers and consumers drift into type mismatches; registries and AsyncAPI-style contracts address this, at some message-size cost. - **Connectivity patterns are layered, not competing** (Middle): service abstraction, discovery, resilient connectivity, sidecar, and service mesh solve different problems and are often combined. - **Composition needs a transaction strategy** (Middle): orchestration and choreography organize multi-service business flows, while Saga handles failure and consistency across them. - **Data is the hard part of distribution** (Late): decentralized data management, store selection, and data composition are framed as first-class design decisions rather than afterthoughts. 【Reading Tips】 - Read Chapters 1–2 closely if you are new to cloud native; they define vocabulary used everywhere else. Skim if you already run microservices on Kubernetes. - Treat the pattern chapters as a reference: jump to the pattern matching your current problem (e.g., Saga for distributed transactions, service mesh for cross-cutting connectivity) rather than reading linearly. - Pay attention to the "Considerations" and "Related patterns" framing — the value is in when *not* to use a pattern, and which patterns pair well. - Keep the technology comparisons (REST, GraphQL, gRPC, WebSocket; AMQP brokers; schema registries) as a decision aid, not a ranking. - The excerpts do not cover the full text of the data management and event-driven chapters in detail; read those chapters directly for their pattern specifics. 【Coverage Limits】 This guide is synthesized from stratified excerpts and the table of contents; several chapters (notably data management and event-driven architecture) are represented only by their scope statements, so pattern-level detail there is not summarized.