GCP in Action A practical guide to building and deploying secure, scalable applications using Google Cloud Platform (Raymond Blum)（Z-Library）

【One-Line Pitch】 A hands-on architectural guide that teaches you to choose, wire, and operate Google Cloud Platform services by building one realistic distributed application end to end. Best for developers and architects who already know the basics of cloud and want a decision-making framework rather than a service catalog. 【Book Arc】 - **Opening (~0%–13%)**: Frames the problem — GCP's breadth is easy to get lost in — and sets up the book's method: learn services by responsibility (compute, storage, identity, async, data permanence, response delivery) rather than by product name. - **Early (~14%–31%)**: Section 1 builds the fundamentals: decomposing an application's features, translating vague requirements like latency and transaction boundaries into concrete needs, and disambiguating overlapping GCP products across compute, storage, identity, and asynchronous processing. - **Middle (~32%–50%)**: Section 2 moves to architecture at the borders — client-side technology choices (native, web, desktop, chatbots), backend-agnostic API design, migration and vendor lock-in planning, and frontend patterns like backends-for-frontends and async request handling. - **Late (~51%–60%)**: Section 3 is the case study: a global distributed voting system, covering demand forecasting, regional boundaries, failure categorization, monitoring and incident response, auto-scaling, data permanence with snapshots and archives, and frontend implementation. - **Ending (~61%–100%)**: Section 4 generalizes the case study — replacing components in isolation, requirements-based infrastructure evaluation, cost comparison of database alternatives, migration planning, and reusing the voting system as a reference implementation for other domains. 【Key Takeaways】 - **Organize cloud choices by responsibility, not by product** (Early): the book's core lens is that compute, storage, identity, async processing, data permanence, and response delivery are the real decision axes; products are interchangeable answers to those needs. - **Requirements must be decomposed before services are chosen** (Early): latency, transaction boundaries, and similar terms are broken into primary elements so the architect has finer granularity and more flexibility in meeting them. - **Overlapping GCP products are disambiguated explicitly** (Early): four domains — compute power, data storage, identity/authentication, and asynchronous processing — get side-by-side treatment including each product's caveats, not just strengths. - **Design backend-agnostic clients at the cloud border** (Middle): general API design principles, visibility levels, and migration planning reduce vendor lock-in and product obsolescence risk; tightly coupled services should be identified and packaged deliberately. - **Frontend architecture is a first-class concern** (Middle): avoiding multiple sources of truth, hiding sensitive logic, backends-for-frontends, and distinguishing blocking from asynchronous requests are treated as design decisions, not implementation details. - **Failure is categorized, not just handled** (Late): the voting case study classifies failure types, scope, progression, and causes, then maps failure modes to mitigation measures and monitoring/alerting practices. - **Data permanence is a design goal with distinct mechanisms** (Late): snapshots for continuity, backups for recovery, and archives for posterity are separated, and access patterns drive storage model choices. - **The case study is meant to be reused** (Ending): the voting system's components and design patterns are presented as models or direct building blocks for unrelated systems with similar functional requirements. 【Reading Tips】 - Read Section 1 carefully even if you know GCP — its value is the decision framework, and later chapters assume it. - Skim the client-side technology survey (Chapter 5) unless you're choosing a frontend stack; the architectural chapters (6–7) deserve deep reading. - Treat the voting system case study as the spine: read it with the book's GitHub code bundle open, and note where each earlier principle reappears. - The migration and cost-calculation material in Section 4 is the most practically reusable — slow down there if you're planning a real migration. - Keep a running list of "which GCP product for which responsibility" as you read; that list is the book's real deliverable. 【Coverage Limits】 The excerpts cover the book's structure, chapter topics, and stated goals but do not include detailed technical content, code, or specific product comparisons; this guide therefore describes the book's approach and coverage rather than its concrete recommendations.