Using maps in Terraform: A complete guide

Overview

In this comprehensive guide, we’ll dive deep into using maps in Terraform, from the basics to advanced applications. Maps, or key-value pairs in Terraform, play a crucial role in managing complex infrastructure deployments more effectively and efficiently. Whether you’re new to Terraform or seeking to enhance your Terraform knowledge, this guide will provide valuable insights and examples to help you harness the power of maps in your Terraform projects.

What are Terraform Maps?

Before stepping into the examples, let’s understand what maps are in the context of Terraform. Maps are a collection of key-value pairs where each key is unique. They are extremely useful for passing a group of values to a module or for configuring resources dynamically.

variable "ami" {
  type = map(string)
  default = {
    "us-east-1" = "ami-123456",
    "us-west-1" = "ami-abcdef"
  }
}

Basic Usage of Maps

Our first example showcases how maps can be accessed in Terraform. Here, the goal is to dynamically select an AMI ID based on the AWS region.

resource "aws_instance" "example" {
  ami           = var.ami[var.region]
  instance_type = "t2.micro"
}

This demonstrates the basic way to access a specific value in a map by using its key.

Advanced Techniques Using Maps

As we have seen the basics, let’s move on to more sophisticated uses of maps. One such technique is merging maps. This is particularly helpful when you have default settings in one map and override those settings with another map.

locals {
  defaults = {
    instance_type = "t2.micro",
    count         = 1
  }
  overrides = {
    us-east-1 = {
      instance_type = "t2.large",
      count = 2
    }
  }
}

resource "aws_instance" "advanced_example" {
  count         = merge(local.defaults, local.overrides[var.region]).count
  ami           = var.ami[var.region]
  instance_type = merge(local.defaults, local.overrides[var.region]).instance_type
}

This showcases how you can dynamically adjust resource properties based on region-specific configurations.

Conditionals with Maps

Maps can also be used in combination with conditionals to implement logic based on the presence or absence of specific keys. This technique can streamline configurations and improve readability.

locals {
  instance_types = {
    "small" = "t2.micro",
    "large" = "t2.large"
  }
}

resource "aws_instance" "conditional_example" {
  count         = var.size == "large" ? local.instance_types["large"] : local.instance_types["small"]
  ami           = var.ami[var.aws_region]
  instance_type = local.instance_types[var.size]
}

Here, depending on the size specified, the Terraform configuration selects an appropriate instance type.

Looping Over Maps

Another powerful feature of maps in Terraform is the ability to loop over them, which is especially handy when you need to create multiple resources based on the map’s contents. Terraform’s for_each statement makes this possible.

resource "aws_instance" "looping_example" {
  for_each      = var.ami
  ami           = each.value
  instance_type = "t2.micro"
  tags = {
    "Name" = "Instance-${each.key}"
  }
}

This illustrates how to create an AWS instance for each AMI ID in the map, tagging each with its respective key.

Combining Maps with Modules

In more complex Terraform configurations, modules play a vital role in encapsulating and reusing code. Maps can be effectively used to pass configurations to these modules, further enhancing modularity and maintainability.

module "instance" {
  source      = "./modules/instance"
  ami_map     = var.ami
  instance_type_map = {
    "us-east-1" = "t2.large",
    "us-west-1" = "t2.micro"
  }
}

Here, we pass two maps to a module, illustrating how flexible maps can be when managing diverse configurations across multiple environments.

Conclusion

Maps in Terraform offer a sophisticated way to manage complex configurations, enabling dynamic resource provisioning and enhancing code reusability. By mastering maps, you can greatly simplify and streamline your Terraform code, making your infrastructure deployments more efficient and maintainable.