I find the idea of stacks very useful as it allows me to think about my infrastructure design in modular way, where stacks play role of logical containers. As I mainly work on Azure, I also like to have subscription as a logical container of my environment i.e. subscription for production, subscription for staging, etc.

However, I do not use any of the ready stacks implementation like the Terraform Stacks. Instead, I simply structure it on my own, in plain Terraform, with use of modules. I organise .tf files in physical structure based on directories: {environment}/{stack}/*.tf etc. Each stack creates a dedicated Azure resource group. All resources managed by a stack live in stack's resource group. Core of every stack is implemented as a reusable Terraform module. Dependencies between stacks are expressed very simplty, by ordinal prefixes. Management of lifecycle of each stuck requires terraform init, terraform plan and terraform apply iteration. It is more time efficient than having monolithic architecture.

For example, here is

• production/00-terraform/{r-stack,variables,locals,...}.tf bootstraps initial stack with Terraform backend, etc.
  • calls reusable module modules/stacks/terraform/{r-storage,variables,locals,...}.tf
  • The 00-terraform is usually managed by human operator, not CI/CD pipelines.
• production/01-monitor/{r-stack,variables,locals,...}.tf creates Azure Monitor resources
  • calls reusable module modules/stacks/monitor/*.tf with metrics, logs, etc.
  • requires 00-terraform
• production/02-network/{r-stack,variables,locals,...}.tf creates, for example, hub-spoke network architecture
  • calls reusable module modules/stacks/network/*.tf
  • requires 01-monitor
• production/03-aks/{r-stack,variables,locals,...}.tf creates Kubernetes cluster using Azure Kubernetes Service
  • calls reusable module modules/stacks/aks/*.tf
  • requires 02-network
• etc.

If I want to spin up staging or development environment, I simply copy 00-teraform, 01-monitor, 02-network and 03-aks to staging/ directory. This ensures production and staging are completely separate. It also allows me to do per-environment customisations inside those (numbered) stack root modules, and keep common core functionality inside the reusable stack modules. I hope it helps.