Cloud Native Using Containers, Functions, and Data to Build Next-Generation Applications (Boris Scholl Trent Swanson Peter Jausovec)（Z-Library）

# Cloud Native: Using Containers, Functions, and Data to Build Next-Generation Applications ## 【One-Line Pitch】 A practical architectural guide for developers and architects who want to understand when and how to use containers, functions, microservices, and data patterns to design cloud-native applications that are scalable, resilient, and portable. If you're moving from traditional or lift-and-shift approaches to modern cloud architectures, this book gives you the foundational knowledge and decision frameworks you need. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces the cloud-native mindset—why software is eating the world, what makes "born-in-the-cloud" companies different, and the core triad of containers, functions, and data. Sets expectations that this is a design-and-architecture book, not a step-by-step implementation guide. - **Early (~9%–28%)**: Covers the fundamentals of distributed systems—the fallacies of distributed computing (network reliability, zero latency, single administrator, zero transport cost, homogeneous networks), the CAP theorem, and the Twelve-Factor App methodology. These concepts form the mental model for everything that follows. - **Early (~28%–38%)**: Dives deeper into Twelve-Factor principles applied to cloud-native contexts—backing services as attached resources, strict separation of build/release/run, stateless processes, data isolation per service, horizontal scaling, disposability, dev/prod parity, logs as event streams, and admin tasks as one-off processes. Also introduces compound SLA math. - **Middle (~38%–53%)**: Explains the core technologies—containers (Linux namespaces, control groups, Docker's role, copy-on-write filesystems, benefits like fast startup and portability) and begins contrasting them with functions and serverless computing. Clarifies that containers and functions are technologies, while microservices is an architectural style. - **Middle (~53%–end)**: Continues into advanced container isolation options (MicroVMs, Nabla containers, gVisor), and the excerpts indicate the book proceeds into service communication patterns, messaging/eventing, service meshes, data patterns, DevOps practices, and portability considerations—though the provided sample does not cover these later chapters in detail. ## 【Key Takeaways】 - **Distributed systems fallacies are still the #1 trap for cloud-native developers** (Early): The network is not reliable, latency is not zero, there is no single administrator, transport is not free, and networks are not homogeneous. Design your services to assume failures and account for serialization/deserialization costs. (Early) - **CAP theorem forces a consistency-vs-availability choice** (Early): Since network partitions are inevitable, you must decide whether to optimize for consistency (like ACID SQL systems) or high availability (like Cassandra). This choice drives your data architecture. (Early) - **The Twelve-Factor App is the foundation of cloud-native design** (Early): Stateless processes, externalized configuration, backing services as attached resources, and strict separation of build/release/run are non-negotiable for elasticity and horizontal scaling. (Early) - **Each service must own its data** (Early): Data isolation is a key tenet of microservices—services can only access another service's data through APIs, never directly. This enables independent scaling and evolution. (Early) - **Containers are OS-level virtualization, not VMs** (Middle): Linux namespaces create isolated workspaces, control groups manage resource limits, and copy-on-write filesystems enable lightweight, fast-starting, high-density deployments. Containers are ideal for scale-out scenarios. (Middle) - **Containers and functions are different technologies; microservices is an architectural style** (Middle): Don't conflate them. Understanding when to use each—and how to combine them with messaging/eventing—is key to efficient cloud-native design. (Middle) - **Your compound SLA is always lower than your best individual service** (Middle): Composite applications using multiple managed services will have an overall availability that is the product of all component SLAs—plan for "number of nines" accordingly. (Middle) - **Container isolation has advanced options beyond Docker** (Middle): Technologies like Nabla containers (unikernel-based) and gVisor (user-space kernel in Go) provide stronger isolation for multi-tenant or security-sensitive workloads. (Middle) ## 【Reading Tips】 - **Deep-read Chapters 1–2 (Early section)**: The distributed systems fallacies, CAP theorem, and Twelve-Factor App are the conceptual backbone. Skim if you already know these, but don't skip—the cloud-native applications of these principles are the book's real value. - **Use the container vs. function distinction as your decision framework** (Middle): Pay special attention to the section that clarifies containers vs. functions vs. microservices. This is where most architects get confused, and the book's guidance here is the most actionable. - **Skim the historical context** (Early–Middle): The origins of containers (LXC, Docker's rise) and the Twelve-Factor history are interesting but not critical. Focus on the "what it means for your design" parts. - **Watch for the compound SLA discussion** (Middle): This is a subtle but crucial point for anyone designing composite applications. It's easy to miss but has real cost and reliability implications. - **The later chapters (service meshes, messaging, data patterns, DevOps, portability) are not covered in this sample**—if those are your primary interest, you'll need to read the full book or seek additional sources. ## 【Coverage Limits】 This guide is based on excerpts covering roughly the first half of the book (through container isolation technologies). The later chapters on service communication, service meshes, messaging/eventing, data patterns, DevOps, and portability are mentioned in the table of contents but not covered in the provided sample. ##