Michio JP

Michio JP


InfraGenie | Decouple Your Terraform with Dependency Injection


InfraGenie is allows you to split out your infrastructure project into separate independent pieces, each with its own terraform state. This is done using a pattern similar to dependency injection in programming languages, but under the hood it uses terraform data blocks.

infragenie drawio (3)

Why this pattern?

There are several reasons why you would want to adopt this pattern:

  1. Flexibility in customising your infrastructure. We know that for a single project the infrastructure might change from one environment to another. For example if you are using an Elasticsearch service in production you might use a self-hosted version in dev to save costs. InfraGenie makes this process very easy
  2. Split your terraform state. By splitting your state accross several modules you can run several applies in parallel. It makes the terraform refresh faster. It also makes your applies safer since if some apply goes haywire it will only affect the resources in the current module.

What about Terraform modules?

Terraform modules can allow you to acheive some flexibiliy buy you still share state across the entire project. It is more difficult to make part of a module optional. The count syntax and similar foreach declarative statements in terraform can be confusing if you are not used to the declarative style it uses.

How it works

To use infragenie you simply create a file called genie.hcl in the root of your project and use it to define your pipeline.

# genie.hcl

# unified variables for use in all pipelines
variables {
  project_name = "myproj123"
  environment = "dev"
  region = "us-east-1"

# resource injections definition
inject {
  main_vpc = {
    source = vpc.aws_vpc.vpc # source can come from any of the pipeline steps

pipeline {
  steps = [
      name = "vpc"
      description = "creates a vpc and 2 subnets"
      source = "./vpc"
      name = "ecs"
      description = "creates an ecs cluster and SG"
      source = "./ecs"


Now with this genie file you can use the vpc in any of your modules as a data definition:

# ecs/main.tf

resource "aws_security_group" "ecs_service_sg" {
  # using global variables
  name_prefix = "${var.project_name}-${var.environment}"
  # using vpc from other module as data block
  vpc_id      = data.aws_vpc.main_vpc.id


You can install InfraGenie CLI via pip

pip install infragenie


You can use the examples to try out infragenie:

Clone the repository:

git clone https://github.com/diggerhq/infragenie
cd infragenie/examples/ecs_fargate

export your AWS keys:


Use igm to apply the example:

igm apply

take note of the generated .infragenie directory along with all the generated data. After exploration you can destroy the resources with:

igm destroy


Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please start the project if you think other people will also find it useful.

Download Details:

Author: diggerhq
Download Link: Download The Source Code
Official Website: https://github.com/diggerhq/infragenie 
License: MIT License

What is GEEK

Buddha Community

InfraGenie | Decouple Your Terraform with Dependency Injection

Getting Started with ASP.NET Core Dependency Injection

I’ve lately been feeling my way around getting an actual, production-ready ASP.NET Core app developed, and one of the features I’ve really been digging (one of many) is native support for Dependency Injection (DI). DI is huge in modern web apps, so making it the default for ASP.NET

#asp.net core #asp.net core dependency injection #dependency #injection #programming

Seamus  Quitzon

Seamus Quitzon


ActiveInject. Fast and Lightweight Dependency Injection Library

What is ActiveInject?

ActiveInject is a lightning-fast and powerful dependency injection library. It has a lot of tools and features to offer: support for nested scopes, singletons and transient bindings, modules, multi-threaded, and single-threaded injectors.

At the same time, it’s thoroughly optimized with all the dependencies graph preprocessing performed at startup time. According to the benchmarks, in some scenarios, ActiveInject is 5.5 times faster than Guice and hundreds of times faster than Spring DI. You can check the benchmark sources here.

ActiveInject_ is an independent technology of ActiveJ platform. It has no third-party dependencies on its own and can be used as a stand-alone DI library._

Getting Started

Let’s try the library out and bake some virtual cookies using ActiveInject. A cookie requires the following ingredients: FlourSugar and Butter. These ingredients form a Pastry which can be baked into a Cookie. Assume each of these entities has a POJO. Let’s start with a basic example:

public void provideAnnotation() {
  Module cookbook = new AbstractModule() {
     Sugar sugar() { return new Sugar("WhiteSugar", 10.f); }

     Butter butter() { return new Butter("PerfectButter", 20.0f); }

     Flour flour() { return new Flour("GoodFlour", 100.0f); }

     Pastry pastry(Sugar sugar, Butter butter, Flour flour) {
        return new Pastry(sugar, butter, flour);

     Cookie cookie(Pastry pastry) {
        return new Cookie(pastry);

  Injector injector = Injector.of(cookbook);

Here we’ve created an AbstractModule named cookbook that contains all the required bindings, or “recipes”, for the ingredients. Call Injector.getInstance method to get an instance of the Cookie.

How does it work from the inside? Injector provides all the required dependencies for the component recursively traversing the dependencies graph in a postorder way. So it first created SugarButter and Flour, the next was Pastry, and finally a Cookie.

#java #dependency injection #java library #dependency injection tutorial

Dependency Injection Implementation in Core Java

Implement your own lightweight Dependency Injection in core Java without using any framework.


This article will guide you to understand and build a lightweight Java application using your own Dependency Injection implementation.

Dependency Injection … DI… Inversion Of Control…IoC, I guess you might have heard these names so many times while your regular routine or specially interview preparation time that you wonder what exactly it is.

but if you really want to understand how internally it works then continue reading here.

#java #tutorial #dependency injection #inversion of control #dependency injection implementation in core java #core java

Myriam  Rogahn

Myriam Rogahn


Python Dependency Injection

Writing clean, maintainable code is a challenging task. Fortunately, there are many patterns, techniques, and reusable solutions available to us to make achieving that task much easier. Dependency Injection is one of those techniques, which is used to write loosely-coupled yet highly-cohesive code.

In this post, we’ll show you how to implement Dependency Injection as you develop an app for plotting historic weather data. After developing the initial app, using Test-Driven Development, you’ll refactor it using Dependency Injection to decouple pieces of the app to make it easier to test, extend, and maintain.

By the end of this post, you should be able to explain what Dependency Injection is and implement it in Python with Test-Driven Development (TDD).

What is Dependency Injection?

In software engineering, Dependency Injection is a technique in which an object receives other objects that it depends on.

  1. It was introduced to manage the complexity of one’s codebase.
  2. It helps simplify testing, extending code, and maintenance.
  3. Most languages that allow for the passing of objects and functions as parameters support it. You hear more about Dependency Injection in Java and C#, though, since it’s difficult to implement. On the other hand, thanks to Python’s dynamic typing along with its duck typing system, it’s easy to implement and thus less noticeable. Django, Django REST Framework, and FastAPI all utilize Dependency Injection.


  1. Methods are easier to test
  2. Dependencies are easier to mock
  3. Tests doesn’t have to change every time that we extend our application
  4. It’s easier to extend the application
  5. It’s easier to maintain the application

For more, refer to Martin Fowler’s Forms of Dependency Injection article.

To see it in action, let’s take a look at a few real-world examples.

Plotting Historic Weather Data


  1. You’ve decided to build an app for drawing plots from weather history data.
  2. You’ve downloaded 2009 temperature by hour data for London.
  3. Your goal is to draw a plot of that data to see how temperature changed over time.

#injection #dependency #python

Getting Started With Terraform Modules


In this article, we will see a subtle introduction to terraform modules, how to pass data into the module, get something from the module and create a resource (GKE cluster), it’s intended to be as simple as possible just to be aware of what a module is composed of, or how can you do your own modules, sometimes it makes sense to have modules to abstract implementations that you use over several projects, or things that are often repeated along the project. So let’s see what it takes to create and use a module.

The source code for this article can be found here. Note that in this example I’m using GCP since they give you $300 USD for a year to try their services and it looks pretty good so far, after sign-up you will need to go to IAM, then create a service account and after that export the key (this is required for the terraform provider to talk to GCP).

Composition of a Module

A module can be any folder with a main.tf file in it, yes, that is the only required file for a module to be usable, but the recommendation is that you also put a README.md file with a description of the module if it’s intended to be used by people if it’s a sub-module it’s not necessary, also you will need a file called variables.tf and other outputs.tf of course if it’s a big module that cannot be split into sub-modules you can split those files for convenience or readability, variables should have descriptions so the tooling can show you what are they for, you can read more about the basics for a module here.

Before moving on let’s see the folder structure of our project:



├── account.json




├── main.tf


├── module


│   ├── main.tf


│   ├── outputs.tf


│   └── variables.tf


├── README.md


└── terraform.tfvars



1 directory, 8 files

The Project

Let’s start with the main.tf that will call our module, notice that I added a few additional comments but it’s pretty much straight forward, we set the provider, then we define some variables, call our module and print some output (output can also be used to pass data between modules).



## Set the provider to be able to talk to GCP


provider "google" {


  credentials = "${file("account.json")}"


  project     = "${var.project_name}"


  region      = "${var.region}"





## Variable definition


variable "project_name" {


  default = "testinggcp"


  type    = "string"





variable "cluster_name" {


  default = "demo-terraform-cluster"


  type    = "string"





variable "region" {


  default = "us-east1"


  type    = "string"





variable "zone" {


  default = "us-east1-c"


  type    = "string"





## Call our module and pass the var zone in, and get cluster_name out


module "terraform-gke" {


  source = "./module"


  zone = "${var.zone}"


  cluster_name = "${var.cluster_name}"





## Print the value of k8s_master_version


output "kubernetes-version" {


  value = module.terraform-gke.k8s_master_version



Then terraform.tfvars has some values to override the defaults that we defined:



project_name = "testingcontainerengine"


cluster_name = "demo-cluster"


region = "us-east1"


zone = "us-east1-c"

#tutorial #devops #terraform #gcp cloud #terraform tutorial #kubernetes for beginners #terraform modules