Cloud Native Development with Google Cloud (Daniel Vaughan)（Z-Library）

# Cloud Native Development with Google Cloud ## 【One-Line Pitch】 A practical, project-driven guide for developers, architects, and engineering managers who want to build and run cloud native applications on Google Cloud—covering everything from core concepts like microservices and containers to hands-on deployment, security, and observability. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces cloud native development as a methodology—distinguishing "cloud hosted" (where) from "cloud native" (how)—and frames Google Cloud as a laboratory for innovation, a factory for automation, and a citadel for secure operations. Emphasizes open standards (containers, Kubernetes, Knative, PostgreSQL, HTTP) to minimize vendor lock-in. - **Early (~9%–25%)**: Covers the Twelve-Factor App principles adapted for cloud native—including concurrency via horizontal scaling, disposability with fast startup/graceful shutdown, and the importance of treating instances as ephemeral. Introduces Domain-Driven Design (DDD) for defining microservice boundaries and explains when to split components (scaling limits, team friction) while warning about added complexity. - **Early (~25%–34%)**: Moves into practical setup: installing and configuring the gcloud CLI, setting default regions/zones, and essential command-line utilities (envsubst, jq, yq, pack). Introduces the example project (Skills Mapper) and begins building serverless functions with Cloud Functions, including event-driven triggers and service account setup. - **Middle (~34%–47%)**: Transitions from Cloud Functions to Cloud Run for long-running services, explaining why Cloud Functions aren't suitable for stateful or high-traffic workloads. Covers deployment via Cloud Native Buildpacks, performance testing with Apache Bench (ab), and cost modeling for Cloud Run (CPU/memory per 100ms, per-request charges, network egress). - **Late (~47%–end)**: Continues with scaling considerations, observability, and production-readiness—addressing nonfunctional requirements like security, monitoring, and testing, and showing how to move from prototype to production with confidence. ## 【Key Takeaways】 - **Cloud native is about "how," not "where"** (Early): Cloud hosted means location; cloud native means embracing cloud APIs and abstractions. This distinction shapes every architectural decision—from service selection to deployment strategy. - **Open standards reduce vendor lock-in** (Early): Prioritize services built on open or de facto standards (containers, Kubernetes, Knative, PostgreSQL, HTTP). Learning them once lets you apply skills across clouds and on-premises. - **Horizontal scaling beats vertical scaling** (Early): Adding more smaller instances is more efficient and reliable than beefing up a single process with more CPU/memory. This avoids concurrency complexity and improves fault tolerance. - **Disposability is a design principle** (Early): Treat instances as replaceable—design for fast startup and graceful shutdown to minimize downtime and prevent data loss when infrastructure fails. - **Microservice boundaries need discipline** (Early): Use Domain-Driven Design to define bounded contexts and single responsibilities. Split services only when scaling limits or team friction demand it—fine-grained components add complexity. - **Cloud Functions vs. Cloud Run is a runtime decision** (Middle): Cloud Functions suit occasional, event-driven tasks; Cloud Run handles long-running, stateful services that need to scale dynamically. Choose based on workload characteristics. - **Performance testing is measurable and iterative** (Middle): Use tools like Apache Bench to test latency percentiles (e.g., 95th percentile under 500ms). Cost modeling for Cloud Run depends on CPU/memory per 100ms, per-request fees, and network egress—optimize resource allocation accordingly. ## 【Reading Tips】 - **Skim the opening chapters (0–9%)** if you're already familiar with cloud concepts; focus instead on the Twelve-Factor principles and DDD sections, which are the conceptual backbone. - **Deep-read the practical setup (25–34%)** if you're new to Google Cloud—the gcloud CLI configuration and command-line utilities (envsubst, jq, yq) are essential for following along. - **Pay close attention to the Cloud Functions → Cloud Run transition (34–47%)**: This is where the book shifts from theory to real deployment, and the reasoning behind the runtime choice is crucial. - **Use the performance and cost sections (44–47%) as a reference**: The Apache Bench commands and Cloud Run pricing breakdown are directly applicable to your own projects. - **Don't skip the security and service account discussions** (around 38%): Setting up invoker roles and OIDC authentication is a common stumbling block for beginners. ## 【Coverage Limits】 The excerpts cover the book's opening through roughly the middle (up to ~47%), including core concepts, setup, Cloud Functions, and Cloud Run deployment. Later chapters on continuous integration/delivery, observability, and advanced scaling are referenced but not detailed in this guide. ##