Index
A
- abstraction, Environment Implementation Layers-Testing and Delivering Changes to Environment Infrastructure
- Accelerate (Forsgren et al.), Use Infrastructure as Code to Optimize for Change, Myth: Speed and Quality Are Trade-Offs, Myth: Speed and Quality Are Trade-Offs
- Accelerate State of DevOps Report (DORA), Cloud Age Approaches to Change Management, Use Infrastructure as Code to Optimize for Change, What Continual Testing Means
- Accelerate team (see DORA [DevOps Research and Assessment] Accelerate team)
- active-active data synchronization, Use Continuous Data Transfer
- Age of Sprawl, The Path to the Cloud Age-The Path to the Cloud Age
- Age of Sustainable Growth, The Path to the Cloud Age
- Agile, Cloud Age Approaches to Change Management, What Continual Testing Means
- Alibaba Cloud, Infrastructure Platforms
- Amazon, Building Server Images, Cluster as a service (IaaS provisioned)
- Amazon DynamoDB, Serverless Application Infrastructure
- Amazon Web Services (see AWS)
- Animator, Orchestrating Image Building
- Ansible, Infrastructure as Code Tools, Domain-Specific and General-Purpose Languages
- Antifragile (Taleb), Myth: Speed and Quality Are Trade-Offs
- antifragility, Myth: Speed and Quality Are Trade-Offs
- antipatterns, Principles, Practices, and Patterns, Designing Deployable Infrastructure Stacks
- Configuration in Code, Patterns for Configuring Stacks, Configuration in Code-Related patterns
- Modular Monolith, Modular Monolith
- Monolithic Stack, Patterns for Sizing and Structuring Stacks, Monolithic Stack-Application Group Stack
- Multi-Environment Stack, Multi-Environment Stack-Related patterns
- Obfuscation Module, Related Patterns-Related Patterns
- Persistent and Ephemeral Stack Stages, Dual Persistent and Ephemeral Stack Stages-Related patterns
- Snowflakes as Code, Snowflakes as Code-Related patterns, Configuring Infrastructure Stack Instances
- Spaghetti Module, Spaghetti Module-Related Patterns
- Unshared Module, Unshared Module
- application clusters, Application Clusters as Code-Application Clusters as Code
- application code, versus infrastructure code, Infrastructure Code Processing-Understanding When Code Executes, Tracing Infrastructure Code Execution, Challenges with Testing Infrastructure Code
- application delivery services, Platform Delivery Services, Application Delivery Services
- application deployments, Understanding What You Can Define as Code
- Application Group Stack pattern, Patterns for Sizing and Structuring Stacks, Application Group Stack-Related patterns
- application infrastructure descriptors, Application Infrastructure Descriptor
- application runtime platforms, Application Runtime Platforms-Serverless platforms
- application runtime services, Engineering Platforms, Providing Application
Runtime Infrastructure-Conclusion
- application-driven infrastructure design, Application-Driven Infrastructure Design-Reference Application-Driven Infrastructure Design, Application-Driven Infrastructure Design-Application-Driven Infrastructure Design
- applications, Infrastructure Platforms, Infrastructure Platforms
- architectural quanta, Infrastructure Deployment Stacks, Designing Deployable Infrastructure Stacks
- architectures
- Architectures for Open and Scalable Clouds (Bias), Create Disposable Things
- Argo, Ensure That Code and Deployed Resources Are Consistent
- artifacts, Distributing Code Branches as Artifacts-Distributing Libraries as Artifacts
- as code paradigm, Understanding What You Can Define as Code-Code or Configuration?
- Assemble substep, Processing and Deploying Infrastructure Code, Infrastructure Deployment Stacks, Code Processing Steps for Building and Deploying, Build Once, Deploy Many Workflow
- assertions, Verification: Making Assertions About Infrastructure Resources
- Atmos, Infrastructure Deployment Scripts
- auto-recovery, Creating a Server from an Event
- auto-scaling, Creating a Server from an Event
- automated delivery pipelines (see pipelines)
- automated test suites, Why Continually Test Infrastructure Code?, What Should We Test with Infrastructure?
- automated testing (see code testing implementation; code testing strategy)
- automatic deployment triggers, Automatically Triggering Deployment-Implementing Triggers
- automation
- automation fear spiral, Minimize Variation
- availability, Designing Environments for Operability Scenarios-Designing Environments for Operability Scenarios, What Should We Test with Infrastructure?
- availability scenarios, Designing Environments for Operability Scenarios-Designing Environments for Operability Scenarios
- AWS (Amazon Web Services), Infrastructure Platforms, IaaS in the Data Center, Pull Configuration with Initialization Scripts
- AWS CDK
- AWS CloudFormation, Infrastructure as Code Tools
- AWS Lambda, Serverless Application Infrastructure
- AWS Service Catalog, Using an Infrastructure Code Deployment Service
- AWS Step Functions, Serverless Application Infrastructure
- Azure, Infrastructure Platforms, IaaS in the Data Center, Pull Configuration with Initialization Scripts, Building Server Images, Cluster as a service (IaaS provisioned)
- Azure Cosmos DB, Serverless Application Infrastructure
B
- backend as a service (BaaS), Serverless Application Infrastructure
- backward-incompatible changes, Separate Software and Data Changes
- baking server images, Baking Images and Frying Instances
- Batect, Working on Code Locally
- Beck, Kent: Tidy First?, Safely Changing Live Infrastructure
- best practices, Principles, Practices, and Patterns, Designing Deployable Infrastructure Stacks
- Bias, Randy: Architectures for Open and Scalable Clouds, Create Disposable Things
- Bicep, Processing and Deploying Infrastructure Code
- block storage, Storage resources
- blue-green deployments, Blue-Green Deployments
- BOSH, Infrastructure as Code Tools
- branches, Distributing Code Branches as Artifacts, Manually Triggering Deployment
- Brand, Stewart: How Buildings Learn, Design Principles for Infrastructure as Code
- A Brief and Incomplete History of Build Pipelines (Newman), Designing Infrastructure Delivery Pipelines
- Bryant, Daniel: Platform Engineering, Platform Delivery Services
- build on deploy workflow, Build on Deploy Workflow
- build once, deploy many workflow, Build Once, Deploy Many Workflow-Bundling or Locking Dependencies
- build projects, organizing, Organizing Projects in a Codebase-Multiple repositories with multiple projects
- build stage, Build Stage, Build Stage: Preparing for Distribution-Pull Requests and Trunk-Based Development, Pipeline Stage Content
- building and distributing Infrastructure as Code, Building and Distributing
Infrastructure as Code-Conclusion (see pipelines)
- Building Evolutionary Architectures (Ford et al.), Design Principles for Infrastructure as Code, Infrastructure Deployment Stacks
- Bundle Module pattern, Bundle Module-Related Patterns
- bundling dependencies, Bundling or Locking Dependencies
- Burgess, Mark, Preface
- business capabilities, Infrastructure Platforms
- business goals, Strategic Goals and Infrastructure as Code
- business logic, Serverless platforms
- business logic code, Infrastructure from Code
- Butler-Cole, Ben, Rolling Upgrades and Canary Releases
C
- canary deployments, Rolling Upgrades and Canary Releases, Separate Software and Data Changes
- capabilities, Application-Driven Infrastructure Design, Application-Driven Infrastructure Design
- capability diagrams, The Start of Infrastructure Design: Workloads
- capacity, Designing Environments for Operability Scenarios
- carbon footprints, Hosting and environmental costs
- CD (continuous delivery), Core Infrastructure Delivery Workflows-Minimize Disruption When Deploying Changes, Designing Infrastructure Delivery Pipelines-Delivery Pipeline Software and Services, Why Continually Test Infrastructure Code?
- central deployment services, Deploying from a Central Service-Deploying from a Central Service
- CERN Data Centre Evolution (McCance), Create Disposable Things
- CFEngine, Infrastructure as Code Tools, Building Servers as Code
- CFRs (cross-functional requirements), What Should We Test with Infrastructure?
- The Challenger Launch Decision (Vaughan), Myth: Speed and Quality Are Trade-Offs
- change delivery workflow, Core Infrastructure Delivery Workflow-Workflow Cycles
- change fail percentage, The Four Key Metrics
- change management, Cloud Age Approaches to Change Management-The Path to the Cloud Age
- change scope, Change scope
- changing existing infrastructure, Changing Existing Infrastructure-Conclusion
- and CD principles, Make Changes Using Only the Automated Process
- challenge of, Changing Existing Infrastructure
- incremental changes, Changing a System Incrementally-Handle Incomplete Changes
- live changes, Safely Changing Live Infrastructure-Use Expand and Contract to Incrementally Change Live Infrastructure
- making routine, Changing Existing Infrastructure
- and management of downtime, Management of downtime
- managing data, Managing Data When Changing Live Infrastructure-Use Continuous Disaster Recovery
- minimizing disruption, Minimizing Disruption When Deploying Changes-Rolling Upgrades and Canary Releases
- myths about, Myth: Infrastructure Doesn’t Change Very Often
- optimizing for, Use Infrastructure as Code to Optimize for Change-Myth: Speed and Quality Are Trade-Offs
- chaos engineering, Managing the Risks of Testing in Production
- Chef, Infrastructure as Code Tools, Domain-Specific and General-Purpose Languages, Domain-Specific and General-Purpose Languages, Ensure That Code and Deployed Resources Are Consistent, Distributing Stack Packages as Artifacts
- circular dependencies, Providers, Consumers, and Interfaces
- ClickOps approach, Coding Infrastructure
- CLIOps approach, Coding Infrastructure
- cloned servers, Hot-Cloning an Existing Server
- closed-box model of configuration, Defining Configuration as Code
- Cloud Age, From the Iron Age to the Cloud Age-The Path to the Cloud Age, Myth: Speed and Quality Are Trade-Offs, Conclusion, Assume Systems Are Unreliable
- cloud agnostic hosting, Multicloud
- cloud computing, Principles of Cloud Infrastructure, Infrastructure Platforms
- Cloud Deployment Manager, Infrastructure as Code Tools
- cloud infrastructure (see Infrastructure as Code)
- cloud native, Principles of Cloud Infrastructure, Cross-Environment Clusters-Cross-Environment Clusters
- Cloud Native Computing Foundation (CNCF), Infrastructure Platforms
- Cloud Native Landscape diagram, The Path to the Cloud Age
- cloud platform-provided services, Providing Platform Service Functionality
- cloud-init, Pull Configuration with Initialization Scripts
- cloud-portable infrastructure code, Infrastructure as Code Tools
- CloudFormation, Implementation
- cluster as a service, Cluster as a service (IaaS provisioned)
- cluster topologies, Cluster Topologies-Cross-Environment Clusters
- clusters, Application Clusters as Code-Packaged cluster distribution, Cross-Environment Clusters-Cross-Environment Clusters
- CNCF (Cloud Native Computing Foundation), Infrastructure Platforms, Cross-Environment Clusters
- code
- and CD, Keep All Code Production-Ready
- CUPID properties for design, CUPID Properties for Design-CUPID Properties for Design
- defining configuration as, Defining Configuration as Code
- defining infrastructure as, Understanding What You Can Define as Code-Understanding What You Can Define as Code
- dynamic stack code, Verification: Making Assertions About Infrastructure Resources
- executing, Understanding When Code Executes, Processing and Deploying Infrastructure Code, Tracing Infrastructure Code Execution
- infrastructure code versus application code, Infrastructure Code Processing-Understanding When Code Executes, Tracing Infrastructure Code Execution, Challenges with Testing Infrastructure Code
- instance-specific code, Consequences-Implementation
- lifecycle stages, Design Across Infrastructure Code Lifecycle Stages
- local, Working on Code Locally-Just Enough Environment, Support Local Testing, Deploying Infrastructure Code from Your Computer-Deploying Infrastructure Code from Your Computer
- organizing in repositories, Organizing Types of Code-Project support files
- ownership of, Code ownership
- and platform services, Providing Platform Service Functionality
- processing, Infrastructure Code Processing-Managing Infrastructure State, Code Processing Steps for Building and Deploying
- quality, What Should We Test with Infrastructure?
- refactoring, Infrastructure Code Processing, Tracing Infrastructure Code Execution, Safely Changing Live Infrastructure
- serverless and non-serverless, Serverless Application Infrastructure
- static code analysis, Offline Static Code Analysis-Connected Static Code Analysis
- techniques, Coding Infrastructure-Managing Your Code in a Source Code Repository
- treating infrastructure code as real code, Code or Configuration?
- versioning and promoting, Distributing Stack Packages as Artifacts
- versus configuration, Code or Configuration?
- code libraries, The Infrastructure Components, Infrastructure Code Libraries-Libraries as Deployable Stacks, Designing Infrastructure Code Libraries-Conclusion
- Bundle Module pattern, Bundle Module-Related Patterns
- distributing as artifacts, Distributing Libraries as Artifacts
- Facade Module pattern, Facade Module-Related Patterns
- Infrastructure Domain Entity pattern, Infrastructure Domain Entity-Related Patterns
- Modular Monolith antipattern, Modular Monolith
- Obfuscation Module antipattern, Related Patterns-Related Patterns
- sharing across stacks, Sharing Infrastructure Code Components
- Spaghetti Module antipattern, Spaghetti Module-Related Patterns
- Stack Module pattern, Stack Module-Implementation
- Unshared Module antipattern, Unshared Module
- code quality, What Should We Test with Infrastructure?
- code testing implementation, Infrastructure Code Testing Implementation-Conclusion
- code testing strategy, Infrastructure Code Testing Strategy-Conclusion
- codebases, Build Small, Simple Pieces That Can Change Independently, Use of Interfaces for Composability, Keep All Code Production-Ready, Organizing Projects in a Codebase-Dedicated integration test projects
- cognitive size, Cognitive size-Cognitive size
- cohesion, Cohesion and Coupling-Cohesion and Coupling
- Compile substep, Processing and Deploying Infrastructure Code, Code Processing Steps for Building and Deploying, Build Once, Deploy Many Workflow
- compliance, Compliance, What Should We Test with Infrastructure?, Shift Left-Compliance as Code
- compliance controls, Compliance as Code-Controls by Workflow
- complicated subsystem teams, Workflows and Team Topologies for Delivering Software and Infrastructure
- components, Infrastructure Components-Conclusion (see compositions; libraries; stacks)
- application-driven design, Application-Driven Infrastructure Design-Reference Application-Driven Infrastructure Design
- breaking changes up by, Break a Change into Increments-Break a Change into Increments
- cognitive size, Cognitive size-Cognitive size
- cohesion and coupling, Cohesion and Coupling-Cohesion and Coupling
- controls by design layers, Controls by Component Design Layer
- and CUPID properties for design, CUPID Properties for Design
- deployable infrastructure as, Providing Deployable Infrastructure as a Component-Providing Deployable Infrastructure as a Component
- design workflow, Design Workflow-Design Workflow
- lifecycles, Component lifecycles
- managing interfaces between, Management of Interfaces Between Components-Management of Interfaces Between Components
- provider-consumer relationship, Providers, Consumers, and Interfaces-Providers, Consumers, and Interfaces
- refactoring, Refactor Components So They Can Be Isolated
- and secret provision, Consequences
- sharing and reuse, Sharing and Reuse of Infrastructure Code-Application-Driven Infrastructure Design
- terminology for, Infrastructure Components-The Infrastructure Components
- third-party, Supply-Chain Checks
- and workloads, The Start of Infrastructure Design: Workloads-The Start of Infrastructure Design: Workloads
- composable infrastructure code, CUPID Properties for Design, Use of Interfaces for Composability-Use of Interfaces for Composability
- composite resources, Infrastructure Resources
- compositions, The Infrastructure Components, Infrastructure Compositions-Infrastructure Compositions, Configuring Infrastructure Stack Instances, Wiring Stacks Together with a Composition-Wiring Stacks Together with a Composition
- compute, Compute resources
- compute capacity, Designing Environments for Operability Scenarios
- compute resources, Compute resources
- concurrency, What You Can’t Replicate Outside Production
- ConfigHub, Infrastructure from Code
- configuration
- configuration drift, Minimize Variation-Minimize Variation, Push on Change, GitOps Deployment for Software
- configuration environments, Environment Implementation Layers, Multiple Environments in One Cluster
- configuration files, Stack Configuration Files-Related patterns
- Configuration in Code antipattern, Patterns for Configuring Stacks, Configuration in Code-Related patterns
- configuration registries, Implementing a Configuration Registry-Single or Multiple Configuration Registries, Integration Registry Lookup-Related patterns
- configuration registry implementation, Implementing a Configuration Registry-Single or Multiple Configuration Registries
- Configuration Stack pattern, Patterns for Configuring Stacks, Deployment Wrapper Stack-Related patterns
- consistency, System Architecture Goals and Infrastructure as Code, Define Everything as Code, Multiple Delivery Environments, Working on Code Locally
- Consul, Standalone Packaged Configuration Registries
- consumer components, Providers, Consumers, and Interfaces-Providers, Consumers, and Interfaces, Use Test Fixtures to Replace Consumers-Use Test Fixtures to Replace Consumers
- consumer stacks, patterns for, Resource Discovery Patterns-Related patterns
- container clusters, Application Clusters as Code
- container images, Distributing Stack Packages as Artifacts
- containers, Principles of Cloud Infrastructure, Environment Implementation Layers, Working on Code Locally
- continual testing, Continually Test and Deliver All Work in Progress, Infrastructure Code Testing Strategy-Immediate Testing and Eventual Testing
- continuity, Cluster Topologies
- continuous configuration synchronization, Continuous Configuration Synchronization-Continuous Configuration Synchronization
- continuous data transfer, Use Continuous Data Transfer
- continuous delivery (CD), Core Infrastructure Delivery Workflows-Minimize Disruption When Deploying Changes, Designing Infrastructure Delivery Pipelines-Delivery Pipeline Software and Services, Why Continually Test Infrastructure Code?
- Continuous Delivery (Humble and Farley), Designing Infrastructure Delivery Pipelines
- continuous deployment, Implementing Infrastructure
Delivery with Pipelines
- continuous disaster recovery, Use Continuous Disaster Recovery
- Continuous Stack Reset pattern, Continuous Stack Reset-Related patterns
- control planes, Platform Delivery Services-Platform Management Services
- Controller pattern, GitOps Deployment for Software, Infrastructure as Data
- controls, Compliance as Code-Controls by Workflow
- Conway’s law, Organizational structure, Aligning Environments to Organizational Structure
- correction controls, Compliance as Code
- cost of ownership, Cost of ownership
- coupling, Cohesion and Coupling-Cohesion and Coupling, Management of Interfaces Between Components
- COVID-19 pandemic, The Path to the Cloud Age
- cross-environment clusters, Cross-Environment Clusters-Cross-Environment Clusters
- cross-functional requirements (CFRs), What Should We Test with Infrastructure?
- cross-project tests, Cross-project tests
- CUPID properties for design, CUPID Properties for Design-CUPID Properties for Design
- customer value, Strategic Goals and Infrastructure as Code-Strategic Goals and Infrastructure as Code
D
- dark launching, Handle Incomplete Changes
- data, Data partitioning, What’s on a Server, Managing the Risks of Testing in Production, Managing Data When Changing Live Infrastructure-Use Continuous Disaster Recovery
- data centers, IaaS in the Data Center-IaaS in the Data Center
- data infrastructure, Segregate Data Infrastructure
- data management, Managing the Risks of Testing in Production
- data storage, structured, Storage resources
- data transfer, continuous, Use Continuous Data Transfer
- DDD (domain-driven design), Implementation, Organize code by domain concept-Organize code by domain concept
- Debois, Patrick, Preface
- declarative code, Imperative and Declarative Languages and Tools, Tests for Declarative Code Often Have Low Value
- decomposing modules, Implementation
- define everything as code, Automate the Full Process
- delivery
- delivery controls, Controls by Workflow
- delivery cycles, Keep Delivery Cycles Short
- delivery environments, Multiple Delivery Environments-Multiple Delivery Environments, Aligning Environments to Organizational Structure
- delivery lead time, The Four Key Metrics
- delivery pipelines (see pipelines)
- delivery scope, Delivery scope
- delivery services, Platform Delivery Services-Platform Management Services, Providing Application
Runtime Infrastructure
- dependencies
- between stacks, Resource Discovery Patterns-Related patterns
- bundling or locking, Bundling or Locking Dependencies
- circular, Providers, Consumers, and Interfaces
- defining as interfaces, Management of Interfaces Between Components-Management of Interfaces Between Components
- and deployment, Build on Deploy Workflow, Using Input Materials for Deployment
- deployment dependencies, Code Processing Steps for Building and Deploying
- discovery implementation, Implementing Discovery in Stack Code
- handling with test fixtures, Just Enough Environment, Pipeline Stage Context, Dependencies Complicate Testing Infrastructure, Use Test Fixtures to Handle Dependencies-Refactor Components So They Can Be Isolated
- at resource versus component level, Use of Interfaces for Composability-Use of Interfaces for Composability
- and test doubles, Testing Infrastructure Code Is Slow, Dependencies Complicate Testing Infrastructure
- Dependency injection (DI), Using Dependency Injection
- dependency versioning, Build Once, Deploy Many Workflow
- Deploy substep, Processing and Deploying Infrastructure Code
- deployable infrastructure components (see stacks)
- deployment, Providing Deployable Infrastructure as a Component-Providing Deployable Infrastructure as a Component, Deploying Infrastructure-Conclusion
- activities executing during, Deploying Infrastructure
- design forces for, Design Forces for Infrastructure Packaging and Deployment-Compliance
- minimizing disruption, Minimize Disruption When Deploying Changes
- orchestration scripts, Using Delivery Orchestration Scripts, Infrastructure Deployment Scripts, Store and Load
- progressive, Managing the Risks of Testing in Production
- running infrastructure deployments, Running Infrastructure Deployments-Triggering Infrastructure Deployments
- stack deployment scripts, Managing Dependencies in a Deployment Script-Managing Dependencies in a Deployment Script
- strategies, Understanding Software Deployment Strategies-Infrastructure from Code
- three-step process model, Processing and Deploying Infrastructure Code, Tracing Infrastructure Code Execution
- triggering, Triggering Infrastructure Deployments-Implementing Triggers
- wedged, Consequences
- zero-downtime, Managing the Risks of Testing in Production
- deployment controls, Controls by Workflow
- deployment dependencies, Code Processing Steps for Building and Deploying
- deployment frequency, The Four Key Metrics
- deployment scripts, Managing Dependencies in a Deployment Script-Managing Dependencies in a Deployment Script
- deployment service UIs, Manually Triggering Deployment
- deployment services, Using an Infrastructure Code Deployment Service-Using an Infrastructure Code Deployment Service
- deployment stacks (see stacks)
- Deployment Wrapper Stack pattern, Patterns for Configuring Stacks, Deployment Wrapper Stack-Related patterns
- deployment-generated secrets, Generating Secrets
- descriptor files, Application Infrastructure Descriptor
- design, Design Principles for Infrastructure as Code-Conclusion
- of application runtime services (see application runtime services)
- cohesion and coupling, Cohesion and Coupling-Cohesion and Coupling
- of components (see components)
- CUPID properties for, CUPID Properties for Design-CUPID Properties for Design
- design forces (see design forces)
- of environments (see environments)
- and interfaces, Management of Interfaces Between Components-Use of Interfaces for Composability
- Iron Age approach to, Conclusion
- of libraries (see code libraries)
- across lifecycle stages, Design Across Infrastructure Code Lifecycle Stages
- of provider-consumer relationship, Providers, Consumers, and Interfaces-Providers, Consumers, and Interfaces
- of servers (see servers as code)
- of stacks (see stacks)
- and testability, Testing Infrastructure Code Is Slow
- traditional approaches to, Design Principles for Infrastructure as Code
- workflow for, Design Workflow-Design Workflow
- design forces, Design Forces-Security
- design patterns (see antipatterns; patterns)
- desired state model, Code Processing Steps for Building and Deploying
- detection controls, Compliance as Code
- developer portals, Platform Management Services, Manually Triggering Deployment
- development environments, Working on Code Locally
- development stage, Development Stage
- deviance, normalization of, Myth: Speed and Quality Are Trade-Offs
- DevOps, Preface, Cloud Age Approaches to Change Management, Cloud Age Approaches to Change Management
- DevOps Research and Assessment (DORA) Accelerate team (see DORA [DevOps Research and Assessment] Accelerate team)
- DevSecOps, Team Topologies for Shifting Left
- DI (Dependency injection), Using Dependency Injection
- disaster recovery, Use Continuous Disaster Recovery
- disposability, Create Disposable Things
- disruption, minimizing, Minimizing Disruption When Deploying Changes-Rolling Upgrades and Canary Releases
- distributed monoliths, Implementing Discovery in Stack Code
- distribution, Distribution of Infrastructure Code-Distributing Libraries as Artifacts
- Dodds, Kent C., Sharing Infrastructure Code Components
- Dojo, Working on Code Locally
- domain concepts, Organize code by domain concept-Organize code by domain concept
- domain-based code and components, CUPID Properties for Design
- domain-driven design (DDD), Implementation, Organize code by domain concept-Organize code by domain concept
- domain-specific languages (DSLs), Domain-Specific and General-Purpose Languages-Domain-Specific and General-Purpose Languages
- Domain-Specific Languages (Fowler and Parsons), Domain-Specific and General-Purpose Languages
- don’t repeat yourself (DRY) principle, Sharing Infrastructure Code Components
- DORA (DevOps Research and Assessment) Accelerate team
- downstream environments, Multiple Delivery Environments
- downtime, Management of downtime, Minimize Disruption When Deploying Changes
- drift detection, Minimize Variation, GitOps Deployment for Software-GitOps Deployment for Software
- DRY (don’t repeat yourself) principle, Sharing Infrastructure Code Components
- dry run command, Syntax Checking
- DSLs (domain-specific languages), Domain-Specific and General-Purpose Languages-Domain-Specific and General-Purpose Languages
- Dual Persistent and Ephemeral Stack Stages antipattern, Dual Persistent and Ephemeral Stack Stages-Related patterns
- dynamic stack code, Verification: Making Assertions About Infrastructure Resources
- dynamic systems, Create Disposable Things
E
- effort metric, Measuring Infrastructure Delivery Effectiveness
- emulators, Local IaaS Emulators, Testing Infrastructure Code Is Slow, Local Infrastructure Emulators
- enablement team, Infrastructure Enablement Team
- enabling teams, Workflows and Team Topologies for Delivering Software and Infrastructure
- engineering platforms, Infrastructure Platforms, Infrastructure Platforms, Engineering Platforms-Providing Platform Service Functionality
- environment branches, Distributing Code Branches as Artifacts
- environment variables, Stack Environment Variables-Implementation
- environmental costs, Hosting and environmental costs
- environments, Stack Patterns for Multiple Instances of Infrastructure, Designing Environments-Conclusion
- and CD, Ensure That Environments Are Consistent
- and cluster topologies, Cluster Topologies-Cross-Environment Clusters
- consistency across, System Architecture Goals and Infrastructure as Code
- development, Working on Code Locally
- and IaaS resource groups, IaaS Resource Groups and Environments-IaaS Resource Groups and Environments
- implementation layers, Environment Implementation Layers-Testing and Delivering Changes to Environment Infrastructure
- multi-environment architectures, Multi-Environment Architectures-Multi-Environment Architectures
- multiple delivery environments, Multiple Delivery Environments-Multiple Delivery Environments
- multiple environment replicas, Multiple Environment Replicas-Replicating Environments for User Bases
- with multiple stacks, Environments with Multiple Stacks-Environments with Multiple Stacks
- partial, Just Enough Environment
- personal, Personal IaaS Environments-Personal IaaS Environments
- production, What You Can’t Replicate Outside Production
- split for alignment, Environments Split for Alignment-Aligning Environments to Governance Concerns
- ephemeral instances, Testing Infrastructure Code Is Slow
- Ephemeral Test Stack pattern, Ephemeral Test Stack-Related patterns
- event-based store-and-load processes, Store and Load
- eventual testing, Immediate Testing and Eventual Testing
- exceptional changes, Changing Existing Infrastructure
- Execute substep, Processing and Deploying Infrastructure Code, Code Processing Steps for Building and Deploying
- Expand and Contract technique, Use Expand and Contract to Incrementally Change Live Infrastructure-Use Expand and Contract to Incrementally Change Live Infrastructure
- external DSLs, Domain-Specific and General-Purpose Languages
- externalized configuration, Defining Configuration as Code
- externally hosted services, Providing Platform Service Functionality
- Extreme Programming, Pull Requests and Trunk-Based Development
F
- FaaS (function as a service), Serverless Application Infrastructure-Serverless platforms
- Facade Module pattern, Facade Module-Related Patterns
- Facebook, Monorepo: Integrating Components in the Build
- fakes, Dependencies Complicate Testing Infrastructure
- fan-in integration workflow, Fan-in: Integrating Components During Delivery-Fan-in: Integrating Components During Delivery
- fan-out delivery pattern, Multiple Delivery Environments-Multiple Delivery Environments, Distributing Environments Geographically
- Farley, David: Continuous Delivery, Designing Infrastructure Delivery Pipelines
- feature branches, Handle Incomplete Changes
- feature hiding, Handle Incomplete Changes
- feature toggles, Handle Incomplete Changes
- federated delivery, Federation: Integrating Components at Runtime
- federated integration workflow, Federation: Integrating Components at Runtime-Federation: Integrating Components at Runtime
- Fitzgerald, Charles, IaaS in the Data Center
- Ford, Neal: Building Evolutionary Architectures, Design Principles for Infrastructure as Code, Infrastructure Deployment Stacks
- Forsgren, Nicole: Accelerate, Use Infrastructure as Code to Optimize for Change, Myth: Speed and Quality Are Trade-Offs, Myth: Speed and Quality Are Trade-Offs
- four key metrics, The Four Key Metrics, Design Forces for Infrastructure Packaging and Deployment, Measuring Infrastructure Delivery Effectiveness-Measuring Infrastructure Delivery Effectiveness
- Fowler, Martin, Test Pyramid, Refactor Components So They Can Be Isolated
- frying server instances, Baking Images and Frying Instances
- full stack infrastructure team, Full Stack Infrastructure Team
- Full System Stack pattern, Patterns for Sizing and Structuring Stacks, Full System Stack-Related patterns
- function as a service (FaaS), Serverless Application Infrastructure-Serverless platforms
- functional testing, Outcomes: Proving Infrastructure Works Correctly
- functionality, testing, What Should We Test with Infrastructure?
G
- general-purpose languages (GPLs), Domain-Specific and General-Purpose Languages
- geographical distribution, Geographical distribution, Distributing Environments Geographically-Distributing Environments Geographically
- GitHub, Distributing Stack Packages as Artifacts
- GitOps deployment, GitOps Deployment for Software-GitOps Deployment for Software
- Given, When, Then format, Tests for Declarative Code Often Have Low Value
- go-live events, Why Continually Test Infrastructure Code?
- goals (see strategic goals; system architectures goals)
- Google, IaaS in the Data Center, Cluster as a service (IaaS provisioned), Monorepo: Integrating Components in the Build
- Google Cloud, Infrastructure Platforms, Pull Configuration with Initialization Scripts
- Google Cloud Deployment Manager, Infrastructure as Code Tools
- Google Cloud Infrastructure Manager, Using an Infrastructure Code Deployment Service
- governance, Governance-Conclusion
- aligning environments to, Aligning Environments to Governance Concerns
- and cluster topologies, Cluster Topologies
- compliance as code, Compliance as Code-Compliance as Code
- intention and steps, Governance-Governance
- Iron Age models, Cloud Age Approaches to Change Management
- lightweight, Security
- policy-as-code tools, Offline Static Code Analysis
- and resource groups, IaaS Resource Groups and Environments
- in Shadow Age, The Path to the Cloud Age
- shifting left, Shift Left-Team Topologies for Shifting Left
- GPLs (general-purpose languages), Domain-Specific and General-Purpose Languages
H
- Hansson, David Heinemeier, IaaS in the Data Center
- hardening for security, Building Server Images
- hardware, Principles of Cloud Infrastructure
- hardware provisioning, Understanding What You Can Define as Code, Creating a Server by Using Network Provisioning-Creating a Server by Using Network Provisioning
- HashiCorp, Infrastructure Deployment Stacks, Libraries as Deployable Stacks, Implementation
- HashiCorp Configuration Language (HCL), Imperative and Declarative Languages and Tools
- HashiCorp Packer, Orchestrating Image Building
- Heat, Infrastructure as Code Tools
- Heroku, Cross-Environment Clusters
- high-level and low-level languages, Low-Level and High-Level Languages
- horizontal design, Horizontal Design-Horizontal Design
- hosting costs, Hosting and environmental costs
- hot-cloning servers, Hot-Cloning an Existing Server
- How Big Should a Micro-service Be? (Lewis), Cognitive size
- How Buildings Learn (Brand), Design Principles for Infrastructure as Code
- Humble, Jez: Continuous Delivery, Designing Infrastructure Delivery Pipelines
- hybrid cloud hosting, Multicloud
- hyperscalers, Infrastructure Platforms
I
- IaaS (Infrastructure as a Service), Environment Implementation Layers
- IaaS platforms, Infrastructure Platforms-Infrastructure Platforms
- creating new server instances, Creating a Server from an Event-Push Configuration with External Commands
- creating servers with, Creating and Provisioning a New Server Instance-Push Configuration with External Commands
- in data centers, IaaS in the Data Center-IaaS in the Data Center
- emulating, Local IaaS Emulators
- and environments, Designing Environments, Personal IaaS Environments-Personal IaaS Environments
- platform registry services, IaaS Platform Registry Services
- and security, Security
- and server clusters as code, Server Clusters as Code
- serverless implementations, Serverless platforms
- testing, Testing and Delivering Changes to Environment Infrastructure
- IaaS resource groups, IaaS Resource Groups and Environments-IaaS Resource Groups and Environments
- IaaS resources, Understanding What You Can Define as Code, The Infrastructure Components
- IaD (infrastructure as data), Infrastructure as Code Tools, Infrastructure as Data-Infrastructure as Data
- IaSQL, Infrastructure as Code Tools, Infrastructure as Data
- idempotent and procedural code, Procedural and Idempotent Code-Procedural and Idempotent Code
- identifiers, unique, Use Stack Parameters to Create Unique Identifiers, Distributing Code Branches as Artifacts
- idiomatic components, CUPID Properties for Design
- IfC (infrastructure from code), Infrastructure as Code Tools, Infrastructure from Code, Infrastructure from Code
- immediate testing, Immediate Testing and Eventual Testing
- immutable (term), Immutable Server, Distribution of Infrastructure Code
- immutable infrastructure, Rolling Upgrades and Canary Releases
- Immutable Server pattern, Immutable Server
- imperative languages and code, Imperative and Declarative Languages and Tools-Imperative and Declarative Languages and Tools
- incremental changes, Workflow Cycles-Workflow Cycles, Changing a System Incrementally-Handle Incomplete Changes
- increments, Break a Change into Increments
- indirect deployments, Implementing Triggers
- InfraBlocks, Infrastructure Deployment Scripts
- infrastructure, Infrastructure Platforms
- Infrastructure as a Service (IaaS) (see IaaS)
- Infrastructure as Code, What Is Infrastructure as Code?-Conclusion
- challenges of, What Is Infrastructure as Code?-What Is Infrastructure as Code?
- Cloud Age approaches, From the Iron Age to the Cloud Age-The Path to the Cloud Age, Conclusion
- core practices, Core Practices for Infrastructure as Code-Build Small, Simple Pieces That Can Change Independently
- core premise, Procedural and Idempotent Code
- delivery (see delivery)
- design (see design)
- key metrics, The Four Key Metrics, Design Forces for Infrastructure Packaging and Deployment, Measuring Infrastructure Delivery Effectiveness-Measuring Infrastructure Delivery Effectiveness
- languages, Understanding When Code Executes, Types of Languages for Coding Infrastructure-Conclusion, Distributing Stack Packages as Artifacts
- versus no-code and low-code automation, Infrastructure as Code-Infrastructure as Code
- optimizing for change with, Use Infrastructure as Code to Optimize for Change-Myth: Speed and Quality Are Trade-Offs
- and organizational strategy, Strategic Goals and Infrastructure as Code-Strategic Goals and Infrastructure as Code
- platforms (see platforms)
- principles of infrastructure, Principles of Cloud Infrastructure-Conclusion
- system architecture goals, System Architecture Goals and Infrastructure as Code
- techniques (see techniques)
- term’s origin, Preface, The Path to the Cloud Age
- tools (see tools)
- infrastructure as data (IaD), Infrastructure as Code Tools, Infrastructure as Data-Infrastructure as Data
- infrastructure capability diagrams, The Start of Infrastructure Design: Workloads
- infrastructure code (see code)
- infrastructure delivery lifecycle, What Is Infrastructure as Code?
- infrastructure delivery pipelines (see pipelines)
- infrastructure deployment stacks (see stacks)
- Infrastructure Domain Entity pattern, Infrastructure Domain Entity-Related Patterns
- infrastructure enablement team, Infrastructure Enablement Team
- infrastructure from code (IfC), Infrastructure as Code Tools, Infrastructure from Code, Infrastructure from Code
- infrastructure instance management teams, Infrastructure Instance Management Teams-Infrastructure Instance Management Teams, Infrastructure Service Teams
- infrastructure management platforms, Platform Delivery Services-Platform Management Services
- infrastructure management services, Platform Delivery Services
- infrastructure platforms (see platforms)
- infrastructure resources, Infrastructure Platforms-Network resources
- infrastructure service teams, Infrastructure Service Teams-Multiple Infrastructure Platform Teams
- infrastructure stack instance, Infrastructure Deployment Stacks
- infrastructure surgery, Manually Remap Live Infrastructure
- infrastructure test diamond, Test Pyramid
- initialization scripts, Pull Configuration with Initialization Scripts-Pull Configuration with Initialization Scripts
- input materials, for deployments, Triggering Infrastructure Deployments-Implementing Triggers
- instance-specific code, Consequences-Implementation
- integrated infrastructure automation tool registries, Integrated Infrastructure Automation Tool Registries
- Integration Registry Lookup pattern, Resource Discovery Patterns, Integration Registry Lookup-Related patterns
- integration tests, Cross-project tests, Test Pyramid, Use Test Fixtures to Replace Providers
- integration workflows, Integration Workflows-Pretesting Infrastructure
- interface contracts, Management of Interfaces Between Components
- interfaces, Management of Interfaces Between Components-Use of Interfaces for Composability
- internal DSLs, Domain-Specific and General-Purpose Languages
- Inversion of Control Containers and the Dependency Injection Pattern (Fowler), Using Dependency Injection
- Iron Age
- ISO files, Booting an OS Installer
- iterative changes, Break a Change into Increments
K
- Kanban, What Continual Testing Means
- Kanies, Luke, Preface
- key-value store services, IaaS Platform Registry Services
- Kim, Gene: The Visible Ops Handbook, Use Infrastructure as Code to Optimize for Change
- known unknowns, What You Can’t Replicate Outside Production
- Kubernetes, Server Clusters as Code, Packaged cluster distribution
- Kubernetes Controller pattern, GitOps Deployment for Software, Infrastructure as Data
L
- Language Server Protocol (LSP), Immediate Testing and Eventual Testing
- languages, Understanding When Code Executes, Types of Languages for Coding Infrastructure-Conclusion, Distributing Stack Packages as Artifacts
- latency, Distributing Environments Geographically
- law of Demeter, Use of Interfaces for Composability
- layers of abstraction, Environment Implementation Layers-Testing and Delivering Changes to Environment Infrastructure
- Lean, Cloud Age Approaches to Change Management, What Continual Testing Means
- Lewis, James: How Big Should a Micro-service Be?, Cognitive size
- libraries (see code libraries)
- lifecycle hooks, Store and Load
- lifecycle stages, design forces across, Design Forces Across Lifecycle Stages-Security
- lifecycles, Component lifecycles, Building Servers as Code
- lightweight governance, Security
- linting and linters, Offline Static Code Analysis
- live changes, Safely Changing Live Infrastructure-Use Expand and Contract to Incrementally Change Live Infrastructure
- local code, Working on Code Locally-Just Enough Environment, Support Local Testing, Deploying Infrastructure Code from Your Computer-Deploying Infrastructure Code from Your Computer
- local emulators, Local IaaS Emulators, Testing Infrastructure Code Is Slow, Local Infrastructure Emulators
- local testing, Support Local Testing
- LocalStack, Local Infrastructure Emulators
- lock-files, Bundling or Locking Dependencies
- lock-in, Multicloud
- locking dependencies, Bundling or Locking Dependencies
- locking solutions, Deploying Infrastructure Code from Your Computer
- logs, secrets leaked by, Injecting Secrets at Runtime
- low-code automation, Infrastructure as Code
- low-level and high-level languages, Low-Level and High-Level Languages
- LSP (Language Server Protocol), Immediate Testing and Eventual Testing
M
- Majors, Charity: Yes
- manual deployment, Implementing Infrastructure
Delivery with Pipelines, Manually Triggering Deployment-Manually Triggering Deployment
- manual deployment triggers, Manually Triggering Deployment-Manually Triggering Deployment
- manual pipeline stages, Pipeline Stage Actions, Pipeline Stage Actions
- Manual Stack Parameters pattern, Patterns for Configuring Stacks, Manual Stack Parameters-Implementation
- matching, Resource Matching-Related patterns
- McCance, Gavin: CERN Data Centre Evolution, Create Disposable Things
- mean time to restore (MTTR), The Four Key Metrics
- Meszaros, Gerard: xUnit Test Patterns, Dependencies Complicate Testing Infrastructure
- metrics, The Four Key Metrics, Design Forces for Infrastructure Packaging and Deployment, Measuring Infrastructure Delivery Effectiveness-Measuring Infrastructure Delivery Effectiveness
- Micro Stack pattern, Patterns for Sizing and Structuring Stacks, Micro Stacks-Related patterns, Example Infrastructure Deployment Stacks
- microrepos, A separate repository for each build project-A separate repository for each build project
- microservices architectures, Federation: Integrating Components at Runtime
- Microsoft, Monorepo: Integrating Components in the Build
- middleware, Engineering Platforms
- mob programming (mobbing), Immediate Testing and Eventual Testing
- mocks, Dependencies Complicate Testing Infrastructure
- Modular Monolith antipattern, Modular Monolith
- modules (see code libraries)
- monitoring, Managing the Risks of Testing in Production, Managing the Risks of Testing in Production
- monitoring controls, Controls by Workflow
- Monolithic Stack antipattern, Patterns for Sizing and Structuring Stacks, Monolithic Stack-Application Group Stack
- monorepos, Monorepo: Integrating Components in the Build-Monorepo: Integrating Components in the Build, Full codebase in one repository
- Moto, Local Infrastructure Emulators
- move fast and break things philosophy, The Path to the Cloud Age, Myth: Speed and Quality Are Trade-Offs
- moved block feature, Define Changes to Live Infrastructure in Code
- MTTR (mean time to restore), The Four Key Metrics
- multi-environment architectures, Multi-Environment Architectures-Multi-Environment Architectures
- Multi-Environment Stack antipattern, Multi-Environment Stack-Related patterns
- multi-tenant systems, Replicating Environments for User Bases
- multicloud hosting, Multicloud
- multiple delivery environments, Multiple Delivery Environments-Multiple Delivery Environments
- multiple environment replicas, Multiple Environment Replicas-Replicating Environments for User Bases
- multitenancy infrastructure deployments, Shared Infrastructure as a Service
- myths about infrastructure, Myth: Infrastructure Doesn’t Change Very Often-Myth: Speed and Quality Are Trade-Offs
N
- National Institute of Standards and Technology (NIST), Infrastructure Platforms
- Netflix, Orchestrating Image Building
- network provisioning, creating servers with, Creating a Server by Using Network Provisioning
- network resources, Network resources-Network resources
- networked filesystems, Storage resources
- Newman, Sam: A Brief and Incomplete History of Build Pipelines, Designing Infrastructure Delivery Pipelines
- NIST (National Institute of Standards and Technology), Infrastructure Platforms
- no-code automation, Infrastructure as Code-Infrastructure as Code
- No-Code Module pattern, Stack Module-Implementation
- non-functional requirements (NFRs), What Should We Test with Infrastructure?
- normalization of deviance, Myth: Speed and Quality Are Trade-Offs
O
- Obfuscation Module antipattern, Related Patterns-Related Patterns
- object storage, Storage resources
- observability, Managing the Risks of Testing in Production
- OCI Registry As Storage (ORAS), Distributing Stack Packages as Artifacts
- offline tests and testing, Testing Infrastructure Code Is Slow, Infrastructure Code Testing Implementation-Local Infrastructure Emulators, Online Testing Stages for Stacks
- online tests and testing, Testing Infrastructure Code Is Slow, Infrastructure Code Testing Implementation, Online Testing Stages for Stacks-Outcomes: Proving Infrastructure Works Correctly
- OpenStack Heat, Infrastructure as Code Tools
- OpenTofu, Infrastructure as Code Tools, Libraries as Deployable Stacks, Implementation, Define Changes to Live Infrastructure in Code
- OpenTofu), Designing Infrastructure Code Libraries
- operability scenarios, Designing Environments for Operability Scenarios-Designing Environments for Operability Scenarios
- operability, testing, What Should We Test with Infrastructure?
- operational services, Engineering Platforms, Providing Application
Runtime Infrastructure
- Oracle Cloud Infrastructure Resource Manager, Using an Infrastructure Code Deployment Service
- ORAS (OCI Registry As Storage), Distributing Stack Packages as Artifacts
- orchestration scripts, Using Delivery Orchestration Scripts-Using Delivery Orchestration Scripts, Infrastructure Deployment Scripts, Store and Load
- orchestration tools, Orchestrating Image Building
- organizational strategy and goals, Strategic Goals and Infrastructure as Code-System Architecture Goals and Infrastructure as Code
- organizational structure, Organizational structure, Aligning Environments to Organizational Structure-Aligning Environments to Organizational Structure
- OS installers, Booting an OS Installer
- OS package repositories, Where Things Come From
- ownership, Code ownership, Cost of ownership, Aligning Environments to Organizational Structure-Aligning Environments to Organizational Structure, Cluster Topologies, Multiple repositories with multiple projects
P
- PaaS (platform-as-a-service) solutions, Platform Management Services, Environment Implementation Layers
- packaged cluster distribution, Packaged cluster distribution
- packages, Providing Platform Service Functionality, Where Things Come From, Distributing Stack Packages as Artifacts-Distributing Stack Packages as Artifacts
- packaging formats, Distributing Stack Packages as Artifacts
- packaging, design forces for, Design Forces for Infrastructure Packaging and Deployment-Compliance
- Packer, Orchestrating Image Building
- pair programming, Pull Requests and Trunk-Based Development, Immediate Testing and Eventual Testing
- Pais, Manuel: Team Topologies, Workflows and Team Topologies for Delivering Software and Infrastructure
- Parallel Change technique, Use Expand and Contract to Incrementally Change Live Infrastructure
- parameter files, Consequences-Implementation
- parameters, Keep Parameters Simple-Keep Parameters Simple, Consequences, Stack Parameter Registry
- (see also patterns for configuring stacks)
- Parsons, Rebecca: Domain-Specific Languages, Domain-Specific and General-Purpose Languages
- partial environments, Just Enough Environment
- partnered systems, Replicating Environments for User Bases
- passive triggers, Pipeline Stage Actions
- password management tools, Implementation
- path to production, Multiple Delivery Environments
- patterns, Principles, Practices, and Patterns, Designing Deployable Infrastructure Stacks
- patterns for code testing, Persistent Test Stack-Related patterns
- patterns for configuring stacks, Patterns for Configuring Stacks-Related patterns
- Deployment Wrapper Stack, Patterns for Configuring Stacks, Deployment Wrapper Stack-Related patterns
- Manual Stack Parameters, Patterns for Configuring Stacks, Manual Stack Parameters-Implementation
- Pipeline Stack Parameters, Patterns for Configuring Stacks, Pipeline Stack Parameters-Related patterns
- Scripted Parameters, Patterns for Configuring Stacks, Scripted Parameters-Implementation
- Stack Configuration Files, Patterns for Configuring Stacks, Stack Configuration Files-Related patterns
- Stack Environment Variables, Patterns for Configuring Stacks, Stack Environment Variables-Implementation
- Stack Parameter Registry, Patterns for Configuring Stacks, Implementation, Stack Parameter Registry-Related patterns
- Wrapper Stack pattern, Related patterns
- patterns for designing stacks, Patterns for Sizing and Structuring Stacks-Related patterns
- Application Group Stack, Patterns for Sizing and Structuring Stacks, Application Group Stack-Related patterns
- Full System Stack, Patterns for Sizing and Structuring Stacks, Full System Stack-Related patterns
- Micro Stack, Patterns for Sizing and Structuring Stacks, Micro Stacks-Related patterns, Example Infrastructure Deployment Stacks
- Reusable Stack, Reusable Stack-Related patterns, Configuring Infrastructure Stack Instances, Conclusion, Environments with Multiple Stacks
- Shared Stack, Patterns for Sizing and Structuring Stacks, Shared Stack-Implementation
- Single Service Stack, Patterns for Sizing and Structuring Stacks, Single Service Stack-Related patterns
- patterns for resource discovery, Resource Discovery Patterns-Related patterns
- performance, and automated code testing, What Should We Test with Infrastructure?
- Periodic Stack Rebuild pattern, Periodic Stack Rebuild-Related patterns
- Persistent and Ephemeral Stack Stages antipattern, Dual Persistent and Ephemeral Stack Stages-Related patterns
- persistent instances, Testing Infrastructure Code Is Slow
- Persistent Test Stack pattern, Persistent Test Stack-Related patterns
- personal environments, Personal IaaS Environments-Personal IaaS Environments
- phoenix servers, Rolling Upgrades and Canary Releases
- physical environments, Environment Implementation Layers
- pipeline orchestration systems, Delivery Pipeline Software and Services
- Pipeline Stack Parameters pattern, Patterns for Configuring Stacks, Pipeline Stack Parameters-Related patterns
- pipeline stage triggers, Pipeline Stage Actions-Pipeline Stage Actions
- pipeline stages, Designing Infrastructure Delivery Pipelines-Pipeline Stage Context
- pipelines, Implementing Infrastructure
Delivery with Pipelines-Conclusion
- plan command, Previewing Changes, Preview: Seeing What Changes Will Be Made
- platform controls, Controls by Workflow
- platform delivery services, Platform Delivery Services-Platform Management Services
- Platform Engineering (Bryant), Platform Delivery Services
- platform groups, Workflows and Team Topologies for Delivering Software and Infrastructure
- platform layers, Providing Application
Runtime Infrastructure-Providing Application
Runtime Infrastructure
- platform management services, Platform Delivery Services
- platform service configuration, Understanding What You Can Define as Code
- platform services, Infrastructure Platforms, Engineering Platforms, Platform Services-Providing Platform Service Functionality
- platform-as-a-service (PaaS) solutions, Platform Management Services, Environment Implementation Layers
- platform-building frameworks, Platform Management Services
- platforms, Infrastructure Platforms-Conclusion
- policy as code, Compliance as Code-Compliance as Code
- policy controls, Controls by Component Design Layer
- policy-as-code tools, Offline Static Code Analysis
- polycloud hosting, Multicloud
- post-code infrastructure automation, Infrastructure from Code
- The Practical Test Pyramid (Vocke), Test Pyramid
- practices, Principles, Practices, and Patterns
- predictability, CUPID Properties for Design
- pregenerated secrets, Generating Secrets
- pretesting, Pretesting Infrastructure
- prevention controls, Compliance as Code
- preview command, Previewing Changes, Preview: Seeing What Changes Will Be Made
- previewing changes, Preview: Seeing What Changes Will Be Made
- primitive resources, Infrastructure Resources
- principle of least knowledge, Use of Interfaces for Composability
- principles, Principles, Practices, and Patterns
- private infrastructure, IaaS in the Data Center-IaaS in the Data Center
- procedural and idempotent code, Procedural and Idempotent Code-Procedural and Idempotent Code
- production environments, What You Can’t Replicate Outside Production
- production, testing in, Testing in Production-Managing the Risks of Testing in Production
- progressive deployment, Managing the Risks of Testing in Production
- progressive testing, Cross-project tests, Pipeline Stage Context, Testing Infrastructure Code Is Slow, Progressive Testing-Swiss Cheese Testing Model
- project support files, organizing, Project support files-Project support files
- projects, Organizing Projects in a Codebase-Multiple repositories with multiple projects, Using Delivery Orchestration Scripts
- provenance, What Should We Test with Infrastructure?
- provider components, Providers, Consumers, and Interfaces-Providers, Consumers, and Interfaces, Use Test Fixtures to Replace Providers-Use Test Fixtures to Replace Providers
- provider stacks, patterns for, Resource Discovery Patterns-Related patterns
- provisioning scripts, Applicability-Implementation
- pull configuration, Pull Configuration with Initialization Scripts-Pull Configuration with Initialization Scripts, Continuous Configuration Synchronization
- pull deployments, Server Clusters as Code, Pull Deployment for Software
- pull requests (PRs), Pull Requests and Trunk-Based Development-Pull Requests and Trunk-Based Development
- Pulumi
- Puppet, Infrastructure as Code Tools, Domain-Specific and General-Purpose Languages, Domain-Specific and General-Purpose Languages, Ensure That Code and Deployed Resources Are Consistent
- push configuration, Push Configuration with External Commands, Server Clusters as Code
- push deployment, Server Clusters as Code, Push Deployment for Software
- push on change approach, Push on Change
R
- rebuilding, Make Everything Reproducible-Make Everything Reproducible, Periodic Stack Rebuild-Related patterns
- refactoring, Infrastructure Code Processing, Tracing Infrastructure Code Execution, Refactor Components So They Can Be Isolated, Safely Changing Live Infrastructure
- reference application-driven infrastructure design, Reference Application-Driven Infrastructure Design-Reference Application-Driven Infrastructure Design
- registries, Implementing a Configuration Registry-Single or Multiple Configuration Registries, Integration Registry Lookup-Related patterns
- regulations, IaaS in the Data Center, Compliance, Data regulations, Distributing Environments Geographically, Build Once, Deploy Many Workflow
- release candidates, Build Stage: Preparing for Distribution
- release stage, Release Stage
- Remote State File Lookup pattern, Resource Discovery Patterns, Stack State Lookup-Related patterns
- renaming resources, Define Changes to Live Infrastructure in Code
- repeatability principle, Ensure That Any Procedure Can Be Repeated-Ensure That Any Procedure Can Be Repeated
- replacement, changing servers by, Changing Servers by Replacement-Immutable Server
- replica environments, Multiple Environment Replicas-Replicating Environments for User Bases
- repositories, Managing Your Code in a Source Code Repository, Organizing Projects in a Codebase
- reproducibility, Make Everything Reproducible-Make Everything Reproducible
- requirements, Application-Driven Infrastructure Design
- resilience, Resilience
- resource discovery
- resource groups, IaaS Resource Groups and Environments-IaaS Resource Groups and Environments
- Resource Matching pattern, Resource Matching-Related patterns
- reusability, Define Everything as Code
- Reusable Stack pattern, Reusable Stack-Related patterns, Configuring Infrastructure Stack Instances, Conclusion, Environments with Multiple Stacks
- role inheritance, Server Roles
- rolling deployments, Separate Software and Data Changes
- rolling upgrades, Rolling Upgrades and Canary Releases
- routine changes, Changing Existing Infrastructure
- run stage, Run Stage
- runtime, Design Forces for Runtime-Runtime influence on other stages, Injecting Secrets at Runtime
- runtime services (see application runtime services)
- runtime systems, Using Design Forces to Choose the Environment
Implementation Layer
- runtime-generated secrets, Generating Secrets
S
- Salt Project, Infrastructure as Code Tools
- SBOMs, Supply-Chain Checks
- scalability, What Should We Test with Infrastructure?
- scalability scenarios, Designing Environments for Operability Scenarios
- scaling, Scaling
- Scarlett, Cher, Sharing Infrastructure Code Components
- scripted OS installers, Creating a Server by Using Network Provisioning
- Scripted Parameters pattern, Patterns for Configuring Stacks, Scripted Parameters-Implementation
- scripts and scripting
- configuring server images, Orchestrating Image Building
- for infrastructure deployment, Infrastructure Deployment Scripts
- initialization scripts, Pull Configuration with Initialization Scripts-Pull Configuration with Initialization Scripts
- orchestration scripts, Using Delivery Orchestration Scripts-Using Delivery Orchestration Scripts, Infrastructure Deployment Scripts, Store and Load
- provisioning scripts, Applicability-Implementation
- stack deployment, Managing Dependencies in a Deployment Script-Managing Dependencies in a Deployment Script
- task-focused, Moving Beyond Task-Based Scripting, Procedural and Idempotent Code-Procedural and Idempotent Code
- value of, Ensure That Any Procedure Can Be Repeated-Ensure That Any Procedure Can Be Repeated
- wrapper scripts, Infrastructure Deployment Scripts-Infrastructure Deployment Scripts
- secrets, Managing Your Code in a Source Code Repository, Implementation, Implementation, Consequences, Handling Secrets-Injecting Secrets at Runtime
- secrets management, Storage resources
- secrets management services, Implementation
- secrets storage services, Using a Secrets Storage Service-Using a Secrets Storage Service
- security, Security-Security, Building Server Images, Aligning Environments to Governance Concerns, What Should We Test with Infrastructure?, Supply-Chain Checks-Supply-Chain Checks
- security hardening, Building Server Images
- segregation, Multiple Delivery Environments
- Sellmayr, Florian, Ensure That Any Procedure Can Be Repeated
- server clusters, Server Clusters as Code
- server configuration code, Server Configuration Code
- server configuration images and tools, Distributing Stack Packages as Artifacts
- server images, Baking Images and Frying Instances, Building Server Images-Building Server Images, Modifying a Stock Image
- server roles, Server Roles
- serverless, Principles of Cloud Infrastructure, Environment Implementation Layers, Serverless Application Infrastructure-Serverless platforms
- serverless code, Serverless Application Infrastructure
- servers as code, Building Servers as Code-Conclusion
- service teams, Infrastructure Service Teams-Multiple Infrastructure Platform Teams
- Shadow Age, The Path to the Cloud Age-The Path to the Cloud Age
- Shafer, Andrew Clay, Preface
- shared infrastructure as a service, Shared Infrastructure as a Service-Shared Infrastructure as a Service
- shared network volumes, Storage resources
- Shared Stack pattern, Patterns for Sizing and Structuring Stacks, Shared Stack-Implementation
- shared-nothing architectures, Sharing Stack Instances Across Workloads
- shifting left, Shift Left-Team Topologies for Shifting Left
- siloed infrastructure deployment, Siloed Infrastructure Deployment
- Single Service Stack pattern, Patterns for Sizing and Structuring Stacks, Single Service Stack-Related patterns
- single-project repositories, A separate repository for each build project-A separate repository for each build project
- single-tenant systems, Replicating Environments for User Bases
- Skelton, Matthew: Team Topologies, Workflows and Team Topologies for Delivering Software and Infrastructure
- skunkworks digital departments, The Path to the Cloud Age
- snowflakes, Avoid Snowflake Systems-Avoid Snowflake Systems
- Snowflakes as Code antipattern, Snowflakes as Code-Related patterns, Configuring Infrastructure Stack Instances
- software, What’s on a Server
- (see also applications; code; code libraries)
- software delivery build stage, Build Stage: Preparing for Distribution
- software supply chain, What Should We Test with Infrastructure?
- source code (see code)
- source code management (SCM) systems (see repositories)
- source code repositories (see repositories)
- Spaghetti Module antipattern, Spaghetti Module-Related Patterns
- speed-quality trade-off myth, Myth: Speed and Quality Are Trade-Offs-Myth: Speed and Quality Are Trade-Offs
- stability, Myth: Speed and Quality Are Trade-Offs
- Stack Configuration Files pattern, Patterns for Configuring Stacks, Stack Configuration Files-Related patterns
- stack deployment scripts, Managing Dependencies in a Deployment Script-Managing Dependencies in a Deployment Script
- Stack Environment Variables pattern, Patterns for Configuring Stacks, Stack Environment Variables-Implementation
- stack model, Infrastructure Deployment Stacks
- Stack Module pattern, Libraries as Deployable Stacks, Stack Module-Implementation
- stack modules, Libraries as Deployable Stacks
- Stack Parameter Registry pattern, Patterns for Configuring Stacks, Implementation, Stack Parameter Registry-Related patterns
- stack projects, Infrastructure Deployment Stacks
- stack provisioning scripts, Applicability-Implementation
- Stack Reference Lookup pattern, Resource Discovery Patterns, Related patterns-Related patterns
- Stack Resource Lookup pattern, Resource Discovery Patterns, Related patterns-Related patterns
- Stack State Lookup pattern, Resource Discovery Patterns, Stack State Lookup-Related patterns
- stack tools, Infrastructure Deployment Stacks
- StackQL, Infrastructure as Code Tools
- stacks, Infrastructure Deployment Stacks-Infrastructure Deployment Stacks
- versus compositions, The Infrastructure Components, Infrastructure Compositions
- configuring (see stacks, configuring)
- creating servers as part of, Creating a Server as Part of a Stack
- designing (see stacks, designing)
- environments with multiple, Environments with Multiple Stacks-Environments with Multiple Stacks
- integrating (see stacks, integrating)
- sharing and reuse, Sharing and Reuse of Infrastructure Code, Sharing Stack Code Across Multiple Instances-Sharing Stack Instances Across Workloads
- terminology for, Infrastructure Deployment Stacks
- stacks, configuring, Configuring Infrastructure Stack Instances-Conclusion
- stacks, designing, Designing Deployable Infrastructure Stacks-Conclusion
- stacks, integrating, Configuring Infrastructure Stack Instances, Integrating Infrastructure Stacks-Conclusion
- standalone packaged configuration registries, Standalone Packaged Configuration Registries
- state files, Managing Infrastructure State, Manually Remap Live Infrastructure-Manually Remap Live Infrastructure
- State of DevOps Report (DORA), Cloud Age Approaches to Change Management, Use Infrastructure as Code to Optimize for Change, What Continual Testing Means
- state, managing, Managing Infrastructure State
- static code analysis, Offline Static Code Analysis-Connected Static Code Analysis
- storage resources, Storage resources
- store-and-load process, Store and Load
- strategic goals, Strategic Goals and Infrastructure as Code-Strategic Goals and Infrastructure as Code
- stream-aligned teams, Workflows and Team Topologies for Delivering Software and Infrastructure
- structured data storage, Storage resources
- stubs, Dependencies Complicate Testing Infrastructure
- supply-chain checks, Supply-Chain Checks-Supply-Chain Checks
- Swiss cheese model, Swiss Cheese Testing Model
- syntax checking, Syntax Checking
- system architecture goals, System Architecture Goals and Infrastructure as Code
- system concerns, and business logic, Serverless platforms
- System Initiative, Infrastructure from Code
- system layers, Infrastructure Platforms-Infrastructure Platforms
T
- Taleb, Nassim Nicholas: Antifragile, Myth: Speed and Quality Are Trade-Offs
- Taraporewalla, Sarah, What Should We Test with Infrastructure?
- task-focused scripts, Moving Beyond Task-Based Scripting, Procedural and Idempotent Code-Procedural and Idempotent Code
- TBD (trunk-based development), Pull Requests and Trunk-Based Development-Pull Requests and Trunk-Based Development
- team ownership, Multiple repositories with multiple projects
- team topologies, Workflows and Team Topologies for Delivering Software and Infrastructure-Infrastructure Enablement Team, Team Topologies for Shifting Left-Team Topologies for Shifting Left
- Team Topologies (Skelton and Pais), Workflows and Team Topologies for Delivering Software and Infrastructure
- teams, Aligning Environments to Organizational Structure, Workflows and Team Topologies for Delivering Software and Infrastructure-Infrastructure Enablement Team, Infrastructure Service Teams-Multiple Infrastructure Platform Teams
- techniques
- tenancy, Sharing Stack Instances Across Workloads
- Terhorst-North, Daniel, CUPID Properties for Design
- Terraform, Domain-Specific and General-Purpose Languages
- aws_instance provider, Low-Level and High-Level Languages
- and Consul, Standalone Packaged Configuration Registries
- deployment-level components, Infrastructure Components
- emergence, Infrastructure as Code Tools
- modules, Designing Infrastructure Code Libraries
- output value storage, Implementation
- plan command, Preview: Seeing What Changes Will Be Made
- renaming infrastructure resources with, Define Changes to Live Infrastructure in Code
- separately deployable units, Infrastructure Deployment Stacks
- stacks and components, Infrastructure Deployment Stacks, Libraries as Deployable Stacks
- Terraform Automation and Collaboration Software (TACOS), Managing Infrastructure State, Using an Infrastructure Code Deployment Service
- Terragrunt, Implementation, Infrastructure Deployment Scripts
- Terrakube, Using an Infrastructure Code Deployment Service
- Terraspace, Infrastructure Deployment Scripts
- test diamond, Test Pyramid
- test doubles, Testing Infrastructure Code Is Slow, Dependencies Complicate Testing Infrastructure
- test fixtures, Just Enough Environment, Pipeline Stage Context, Dependencies Complicate Testing Infrastructure, Use Test Fixtures to Handle Dependencies-Refactor Components So They Can Be Isolated
- test instance lifecycles, Test Instance Lifecycles-Related patterns
- test orchestration, Test Orchestration-Avoid Tight Coupling with Pipeline Tools
- test pyramid, Test Pyramid-Test Pyramid
- test stages, for infrastructure delivery, Test Stages
- test suites, Why Continually Test Infrastructure Code?, What Should We Test with Infrastructure?
- tests and testing (see code testing implementation; code testing strategy)
- continual testing, Continually Test and Deliver All Work in Progress, Infrastructure Code Testing Strategy-Immediate Testing and Eventual Testing
- cross-project tests, Cross-project tests
- dedicated integration test projects, Dedicated integration test projects
- defining tests as code, Understanding What You Can Define as Code
- driving better design with, Use of Interfaces for Composability
- infrastructure abstraction layers, Testing and Delivering Changes to Environment Infrastructure
- integration tests, Cross-project tests, Test Pyramid, Use Test Fixtures to Replace Providers
- offline tests and testing, Testing Infrastructure Code Is Slow, Infrastructure Code Testing Implementation-Local Infrastructure Emulators, Online Testing Stages for Stacks
- online tests and testing, Testing Infrastructure Code Is Slow, Infrastructure Code Testing Implementation, Online Testing Stages for Stacks-Outcomes: Proving Infrastructure Works Correctly
- orchestration scripts for, Using Delivery Orchestration Scripts
- patterns for (see patterns for code testing)
- across pipeline stages, Pipeline Stage Context-Pipeline Stage Context
- pretesting, Pretesting Infrastructure
- progressive, Cross-project tests, Pipeline Stage Context
- server configuration images, Distributing Stack Packages as Artifacts
- and shifting left, Shift Left-Team Topologies for Shifting Left
- test stages, in core delivery workflow, Test Stages
- unit tests, Tracing Infrastructure Code Execution, Unit Testing Code Generation, Test Pyramid
- tfmigrate, Script Live Infrastructure Changes
- ticketing systems, Manually Triggering Deployment
- Tidy First? (Beck), Safely Changing Live Infrastructure
- tire fires, What Is Infrastructure as Code?
- toil, Measuring Infrastructure Delivery Effectiveness, Infrastructure Service Teams
- tools, Infrastructure as Code Tools-Infrastructure as Code Tools
- benefits of, Preface
- configuration registry services, Integrated Infrastructure Automation Tool Registries
- and consistency, Working on Code Locally
- for deployment, Infrastructure as Data, Infrastructure Deployment Scripts
- emulators, Local IaaS Emulators, Testing Infrastructure Code Is Slow, Local Infrastructure Emulators
- for IfC, Infrastructure from Code
- linters and policy as code tools, Offline Static Code Analysis-Offline Static Code Analysis
- no-code and low-code tools, Infrastructure as Code-Infrastructure as Code
- for packaging infrastructure code, Distributing Stack Packages as Artifacts
- for password management, Implementation
- for pipelines, Motivation, Delivery Pipeline Software and Services-Delivery Pipeline Software and Services
- for platforms, Infrastructure Platforms-Infrastructure Platforms, Application Delivery Services-Platform Management Services
- for previewing changes, Preview: Seeing What Changes Will Be Made
- running with orchestration scripts, Using Delivery Orchestration Scripts-Using Delivery Orchestration Scripts
- for scripting changes to state files, Script Live Infrastructure Changes
- for secrets management, Storing Secrets in Encrypted Files
- server configuration, Server Configuration Code, Distributing Stack Packages as Artifacts
- server creation, Creating a Server by Using Network Provisioning-Creating a Server by Using Network Provisioning
- server image building, Orchestrating Image Building
- supply-chain validation, Supply-Chain Checks
- synchronizing code to servers with, Ensure That Code and Deployed Resources Are Consistent
- for test orchestration, Consider Test Orchestration Tools-Avoid Tight Coupling with Pipeline Tools
- topologies
- tracer bullet pipelines, Break a Change into Increments
- tracing, Tracing Infrastructure Code Execution
- traffic, What You Can’t Replicate Outside Production
- trail marker pipelines, Break a Change into Increments
- triggers
- trunk-based development (TBD), Pull Requests and Trunk-Based Development-Pull Requests and Trunk-Based Development
U
- unique identifiers, Use Stack Parameters to Create Unique Identifiers, Distributing Code Branches as Artifacts
- unit tests, Tracing Infrastructure Code Execution, Unit Testing Code Generation, Test Pyramid
- Unix philosophy, CUPID Properties for Design
- unknown unknowns, What You Can’t Replicate Outside Production
- Unshared Module antipattern, Unshared Module
- upstream environments, Multiple Delivery Environments
- users, creativity of, What You Can’t Replicate Outside Production
- utilization, Measuring Infrastructure Delivery Effectiveness
V
- validation stages, Designing Infrastructure Delivery Pipelines
- value stream mapping, Infrastructure Instance Management Teams
- variation, Minimize Variation-Minimize Variation, Multiple Delivery Environments
- Vaughan, Diane: The Challenger Launch Decision, Myth: Speed and Quality Are Trade-Offs
- vendor lock-in, Multicloud
- version control systems (VCS) (see repositories)
- version lock-files, Bundling or Locking Dependencies
- version spread, Measuring Infrastructure Delivery Effectiveness
- vertical design, Vertical Design-Shared Infrastructure Included in Vertical Design
- virtual environments, Environment Implementation Layers
- virtualization, Environment Implementation Layers
- visibility, Define Everything as Code
- The Visible Ops Handbook (Kim), Use Infrastructure as Code to Optimize for Change
- VMware, Building Server Images
- Vocke, Ham: The Practical Test Pyramid, Test Pyramid
- Vogels, Werner, Assume Systems Are Unreliable
W
- walking skeletons, Break a Change into Increments
- waterfall model, Core Infrastructure Delivery Workflows
- Weaveworks, Ensure That Code and Deployed Resources Are Consistent
- wedged stack deployments, Consequences
- white-label services, Replicating Environments for User Bases
- Willis, John, Preface
- workflow cycles, Workflow Cycles-Workflow Cycles
- workflows, Core Infrastructure Delivery Workflows-Conclusion (see building and distributing Infrastructure as Code; workflows, specific)
- workflows, specific
- build on deploy workflow, Build on Deploy Workflow
- build once, deploy many workflow, Build Once, Deploy Many Workflow-Bundling or Locking Dependencies
- design workflow, Design Workflow-Design Workflow
- fan-in integration workflow, Fan-in: Integrating Components During Delivery-Fan-in: Integrating Components During Delivery
- federated integration workflow, Federation: Integrating Components at Runtime-Federation: Integrating Components at Runtime
- PRs and TBD, Pull Requests and Trunk-Based Development-Pull Requests and Trunk-Based Development
- for shifting left, Workflow for Shifting Left-Workflow for Shifting Left
- for working on code locally, Working on Code Locally
- working sets, Working sets
- workload alignment, Workload alignment
- workloads, Infrastructure Platforms, Infrastructure Platforms, The Start of Infrastructure Design: Workloads-The Start of Infrastructure Design: Workloads (see application runtime services; environments; stacks, designing)
- Wrapper Module pattern, Facade Module-Related Patterns
- wrapper scripts, Infrastructure Deployment Scripts-Infrastructure Deployment Scripts
- Wrapper Stack pattern, Related patterns, Patterns for Configuring Stacks, Deployment Wrapper Stack-Related patterns
- wrapper stacks, Libraries as Deployable Stacks, Distributing Libraries as Artifacts