How would I generate a provider dynamically based on the output of a module?

[sicil1ano]

Hi. I have a big Terraform codebase deploying resources to Azure.
I have the following structure:

src
backend.tf
└──terraform
   └──main.tf
   └── variables.tf
   └── modules
       └── aks
       └──database
       └── cert_manager
       └── etc

I would like to migrate to Terragrunt soon as it would enable me to have DRY code and different configuration for each environment, which at the moment is injected via Azure DevOps variables when the pipeline starts.
However I have a problem:

In my main.tf I have the following:

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.81.0"
    }
    helm = {
      source  = "hashicorp/helm"
      version = "~>2.4.1"
    }
    mssql = {
      source  = "betr-io/mssql"
      version = "0.2.4"
    }
  }
}

provider "helm" {
  kubernetes {
    host                   = module.aks.kube_admin_config[0].host
    client_certificate     = base64decode(module.aks.kube_admin_config[0].client_certificate)
    client_key             = base64decode(module.aks.kube_admin_config[0].client_key)
    cluster_ca_certificate = base64decode(module.aks.kube_admin_config[0].cluster_ca_certificate)
  }
  alias = "mycluster"
}

module "cert_manager" {
  source            = "./modules/cert_manager"
  providers = {
    helm = helm.mycluster
  }
}

As you can see, the provider configuration depends on the output of aks module that creates the Kubernetes cluster.
The Helm provider configuration is then passed on to each module with the providers block, as cert_manager module shows.

How do I generate the Helm provider configuration dynamically given this setup?
I thought I might need to refactor so that I have a aks_configuration module where I configure the provider and then pass this on to the modules like cert_manager using Helm provider, then when migrating to Terragrunt, I could write a provider.hcl inside aks_configuration.

src
backend.tf
└──terraform
   └──main.tf
   └── variables.tf
   └── modules
       └── aks
       └──database
       └── aks_configuration
               └── cert_manager
                provider.hcl

I am not sure it is the right way of doing things though. What do you suggest?

[denis256]

Hi,
I think can be used terragrunt dependencies block to pass different helm provider configurations in through input block:

# terragrunt.hcl

dependency "aks_configuration" {
  config_path = "./terraform/modules/aks_configuration"
}

inputs = {
  kube_admin_config = dependency.aks_configuration.outputs.kube_admin_config
}

# main.tf

variable "kube_admin_config" {
  description = "Kubernetes admin configuration for connecting to AKS cluster."
  type = list(object({
    host                   = string
    client_certificate     = string
    client_key             = string
    cluster_ca_certificate = string
    # Add other attributes as needed
  }))
}

provider "helm" {
  alias = "mycluster"

  kubernetes {
    host                   = base64decode(terragrunt.input("kube_admin_config")[0].host)
    client_certificate     = base64decode(terragrunt.input("kube_admin_config")[0].client_certificate)
    client_key             = base64decode(terragrunt.input("kube_admin_config")[0].client_key)
    cluster_ca_certificate = base64decode(terragrunt.input("kube_admin_config")[0].cluster_ca_certificate)
  }
}

References:

https://terragrunt.gruntwork.io/docs/reference/config-blocks-and-attributes/#dependency

https://terragrunt.gruntwork.io/docs/reference/config-blocks-and-attributes/#inputs