Dependency injection

As explained in Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform

Dependency injection is a design pattern in which high-level modules obtain low-level dependencies through an abstraction rather than constructing or directly binding to them.

Dependency injection decouples high-level infrastructure resources from low-level dependencies. High-level resources request low-level attributes through an abstraction instead of constructing or binding directly to them. The pattern combines inversion of control with dependency inversion, allowing network changes to evolve without disrupting servers, queues, applications, or databases. section 4.2 section 4.2.3

Apply dependency injection through these infrastructure practices:

• Use an infrastructure API or state as an abstraction layer; the high-level resource retrieves and parses the metadata it needs. section 4.2.3
• Start with a facade when one low-level module serves a few high-level modules; use an adapter for many consumers or heterogeneous providers, and a mediator for many interdependent resources. section 4.6
• Preserve idempotency, composability, and evolvability while isolating changes between modules and resources. section 4.6

Server and network

A server uses Apache Libcloud to query the GCP API for a subnet name, parse the returned metadata, and assign itself the fifth IP address in the network range. After the network range changes, the network is deployed first; the server retrieves the new metadata and recalculates its address without changing its own configuration logic. section 4.2.3

Infrastructure facades and mediators

A storage-bucket module outputs bucket attributes for an access-control module, exposing a simplified interface while keeping the bucket implementation independent. When a firewall depends on both a server and a network, a mediator creates the network first, the server second, and the firewall third; it can also organize deletion. section 4.3 section 4.5

Dependency injection also supports refactoring monolithic IaC. Extract independent resources first, separate their configuration and state, then update dependent resources to retrieve low-level identifiers through the provider API. Test each isolated component and repeat the workflow toward lower-level resources, minimizing disruption and preserving resource state. section 10.2.3 section 10.3

Figure 4.6 Dependency injection combines inversion of control and dependency inversion to loosen infrastructure dependencies and isolate low-level and high-level resources.

Use the dependency diagram to see how inversion of control and dependency inversion form an abstraction buffer between high- and low-level infrastructure resources. section 4.2.3

How Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform covers it

How deep it goes

Explains principles, provider APIs, Python implementations, pattern selection, and refactoring steps through infrastructure examples.

Examples

Uses GCP servers, networks, subnets, storage buckets, access controls, firewalls, and monolithic IaC refactoring.

What it assumes

Assumes familiarity with infrastructure resources and IaC, while defining inversion of control and dependency inversion before combining them.

What you can do after

Apply it via Apache Libcloud or provider APIs to isolate infrastructure changes and organize dependent resource creation.

How it connects

Connects inversion of control, dependency inversion, facade, adapter, mediator, idempotency, composability, and evolvability.

liveBookmanning.com

Read Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  ASP.NET Core in Action, 3eDependency injection is a design pattern in which an object receives its dependencies from an external provider rather than creating them itself.
• 

  liveBookmanning.com
  .NET MAUI in ActionDependency injection is a technique in which an object receives its required dependencies from an external provider rather than constructing them itself.
• 

  liveBookmanning.com
  Modern AngularDependency injection is a software design technique in which a framework supplies an object's required dependencies rather than the object constructing them itself.
• 

  liveBookmanning.com
  Shipping Go: Develop, deliver, discuss, design, and go againDependency injection is a software design technique in which a component receives the services or objects it depends on from outside rather than constructing them itself.
• 

  liveBookmanning.com
  Functional Design and Architecture: Examples in HaskellDependency injection is a technique for supplying a component's external functionality through an abstraction rather than constructing or selecting its concrete implementation internally.
• 

  liveBookmanning.com
  Kafka Streams in Action, Second EditionDependency injection is a design technique in which an object's required dependencies are supplied by external configuration or a framework rather than created by the object itself.
• 

  liveBookmanning.com
  Pro Angular 16Dependency injection is a technique in which a framework supplies an object's required dependencies rather than the object constructing them directly.
• 

  liveBookmanning.com
  Pro ASP.NET Core 7, Tenth EditionDependency injection is a software design technique in which a component receives its dependencies from external configuration or composition rather than creating them itself.
• 

  liveBookmanning.com
  The Art of Unit Testing 3eA technique in which a component receives a value or behavior from outside rather than creating it internally.
• 

  liveBookmanning.com
  Learn Go with Pocket-Sized ProjectsDependency injection is a technique in which an object or component receives its required dependencies from outside rather than constructing them internally.
• 

  liveBookmanning.com
  Build Python Web Apps with StreamlitDependency injection is a software design pattern in which an object receives the components it depends on from outside rather than constructing them internally.
• 

  liveBookmanning.com
  gRPC Microservices in GoDependency injection is a design technique in which a component receives its required collaborators from outside rather than constructing them internally.
• 

  liveBookmanning.com
  Building Web APIs with ASP.NET CoreDependency injection is a software design pattern in which a component receives its required dependencies from an external provider rather than constructing them itself.
• 

  liveBookmanning.com
  .NET in Action, Second EditionDependency injection is a pattern in which an object receives its dependencies from an external composition mechanism rather than creating them itself.
• 

  liveBookmanning.com
  Simple Object-Oriented Design: Create clean, maintainable applicationsA dependency injection framework is a software framework that constructs objects and supplies their declared dependencies according to configuration or conventions.
• 

  liveBookmanning.com
  Rust Servers, Services, and AppsDependency injection is a technique in which a component receives the resources or services it needs from an external provider.
• 

  liveBookmanning.com
  Go by ExampleDependency injection is a software design technique in which required dependencies are supplied to a component from outside rather than created internally.
• 

  liveBookmanning.com
  Spring in Action, Sixth EditionA framework that supplies an object's dependencies from outside the object rather than requiring the object to construct them.
• 

  liveBookmanning.com
  Go in Action, Second EditionDependency injection is a design technique in which a component receives its required collaborators from outside rather than constructing them internally.
• 

  liveBookmanning.com
  100 Go Mistakes and How to Avoid ThemDependency injection is a technique in which a component receives required dependencies from its caller rather than constructing or retrieving them internally.

Compare how 21 books explain dependency injection →

Related concepts

• ASP.NET Coreused by · ASP.NET Core is Microsoft’s cross-platform, open-source framework for building web applications and services on the .NET platform.
• inversion of controlequivalent to · Inversion of control is a design principle that delegates application flow, object creation, or dependency selection from application components to an external mechanism or caller.
• view componentused by · A view component is a reusable presentation component that encapsulates application logic and renders a portion of a user interface or response.
• design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
• dependency inversionuses · Dependency inversion is a design principle in which high-level policy and low-level implementation depend on abstractions rather than directly on each other.
• testabilityproduces · Testability is the degree to which a system’s behavior can be exercised and evaluated effectively, efficiently, and reliably through testing.

This explainer was generated by Manning's knowledge graph from the text of Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform. The section links point to the parts of the book it draws on.