Infrastructure as Code (for Epub True) (Kief Morris) (z-library.sk, 1lib.sk, z-lib.sk)

【One-Line Pitch】 A pattern-driven guide to designing, delivering, and evolving cloud infrastructure as code, written for engineers and architects who want to move beyond tool tutorials toward durable design judgment. Read it if you own infrastructure that must change frequently without breaking. 【Book Arc】 - **Opening (~0%–10%)**: Frames the core argument — infrastructure as code is a Cloud Age approach to automating infrastructure that embraces continual change, not a way to freeze it. Introduces the FoodSpin running example, the antipattern vocabulary, and why the author avoids "best practice" language. - **Early (~10%–35%)**: Builds the conceptual toolkit: what counts as infrastructure code versus configuration, how IaaS platforms, platform services, and SaaS APIs fit together, and how stacks are built, modeled, and deployed. Covers configuration parameters, secrets handling, and the first design patterns for sizing and structuring stacks. - **Middle (~35%–55%)**: Moves into design patterns and antipatterns in depth — stack modules, facade and obfuscation modules, reusable stacks, vertical versus shared designs, and how to organize environments and resource groups. Server lifecycle patterns appear here: pull versus push configuration, role inheritance, and replacing servers rather than mutating them. - **Late (~55%–85%)**: Applies the patterns to delivery and operations: pipelines, testing, governance, and the organizational forces (team ownership, coupling, coordination cost) that shape infrastructure design. The excerpts are thinner here, so treat this stage as directionally mapped rather than fully detailed. - **Ending (~85%–100%)**: Closes on evolving infrastructure over time and the strategic context — supporting growth while managing cost — plus emerging directions such as infrastructure from code and post-code automation. The excerpts do not cover the closing chapters in detail. 【Key Takeaways】 - **Change is the goal, not the risk** (Opening): The book reframes frequent, reliable change as the source of resilient systems, citing Accelerate research, and treats heavyweight change control as the Iron Age antipattern. - **Antipatterns beat "best practices"** (Opening): Morris deliberately avoids one-size-fits-all prescriptions, describing patterns with their trade-offs and limitations so you can judge fit for your context. - **DevOps is people and culture first** (Opening): Tooling alone — a Jenkins install or a separate "DevOps team" — can add barriers rather than remove them; IaC is valuable only insofar as it bridges collaboration gaps. - **Code versus configuration is a real distinction** (Early): Code defines aspects consistent across deployed instances; configuration specifies what differs per instance. Mixing them into stack code couples code to environments and raises the cost of creating new ones. - **Stack sizing is a design decision** (Early/Middle): Full System Stacks, Micro Stacks, and vertical workload-aligned designs trade cohesion against coupling and coordination overhead; shared runtimes create deployment dependencies that block independent upgrades. - **Modules are not free abstractions** (Middle): Facade Modules that don't simplify, Obfuscation Modules, and Unshared Modules are named antipatterns; wrapping low-level resources rarely solves the real problem for non-infrastructure users. - **Replace servers, don't nurse them** (Middle): Continuous synchronization leaves gaps, and servers built at different times drift; replacement from a baked image is the more reliable path, with pull configuration preferred over push. - **Secrets should be generated, not handled** (Early): Deployment-generated and runtime-generated secrets keep credentials out of human hands and out of pipeline logs, reducing exposure and misuse. 【Reading Tips】 - Read the opening chapters closely for the vocabulary — code versus configuration, stack versus stack instance, pattern versus antipattern — because the rest of the book assumes it. - Treat the pattern chapters as a reference catalog: skim the pattern names and motivations first, then deep-read only the patterns that match your current stack-sizing or module problems. - Pay attention to the FoodSpin examples; they recur and make abstract trade-offs concrete. - When a pattern is presented, ask what forces it resolves and where it breaks — the book's value is in the reasoning, not the recipe. - If you are new to IaC, read the early chapters before touching tool-specific material; the excerpts suggest tooling is secondary to design. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book in detail, with only directional coverage of later delivery, governance, and evolution chapters. Specific chapter titles, figures, and closing material are not fully represented.