Using Maps and Key-Value Variables in Terraform

 

Using Maps and Key-Value Variables in Terraform

Terraform maps provide a powerful way to store and manage collections of key-value pairs. This functionality, combined with key-value variables, allows you to define flexible configurations that adapt based on your needs.

Defining Maps

A map is declared using curly braces {} and contains zero or more key-value pairs separated by commas. Keys must be strings, while values can be any data type supported by Terraform (strings, numbers, lists, or even nested maps).

Here's an example of a map defining environment variables:

variable "env_vars" {
  type = map(string)
  default = {
    "DATABASE_URL" = "postgres://user:password@localhost:5432/mydb"
    "API_KEY" = "your_api_key_here"
  }
}

This defines a variable named env_vars of type map(string), meaning keys are strings and values are also strings. It sets default values for two environment variables.

Using Maps in Resources

You can access map values within your Terraform configuration using the key enclosed in square brackets []. Here's how to use the env_vars map in a resource:

resource "null_resource" "set_env_vars" {

  provisioner "local-exec" {
    command = <<EOF
      export DATABASE_URL=${var.env_vars["DATABASE_URL"]}
      export API_KEY=${var.env_vars["API_KEY"]}
      # ... other commands using environment variables
    EOF
  }
}

This configuration defines a null_resource with a local-exec provisioner. The command uses string interpolation ($) to access the values from the env_vars map using their respective keys.

Key-Value Variables with Maps

Key-value variables provide a convenient way to define variables where the key itself serves as meaningful information. You can leverage maps to create sets of key-value variables with a consistent structure.

Here's an example:

variable "server_config" {
  type = map(object({
    name   = string
    type   = string
    image  = string
  }))

  default = {
    web = {
      name   = "web-server"
      type   = "web"
      image  = "nginx:latest"
    }
    db = {
      name   = "database"
      type   = "database"
      image  = "postgres:latest"
    }
  }
}

This defines a variable named server_config of type map(object). Here, the inner object defines the structure for each server configuration within the map. The default value specifies configurations for two servers ("web" and "db") with details like name, type, and image.

Using Key-Value Variables in Resources

You can access individual server configurations within the server_config map using their keys. Here's how to use them in an aws_instance resource:

resource "aws_instance" "server" {
  for_each = var.server_config

  name   = each.key
  ami     = var.server_config[each.key].image
  # ... other configuration options based on server_config values
}

This configuration defines an aws_instance resource for each server defined in the server_config map. The for_each meta-argument iterates over the map. The each.key references the current server name, and var.server_config[each.key] accesses the corresponding configuration object.

Benefits of Using Maps and Key-Value Variables

• Improved Organization: Maps keep configuration data organized and easy to manage.
• Flexibility: Key-value variables combined with maps allow for dynamic configuration based on your needs.
• Reusability: Define configurations once in maps and reuse them across resources.

By mastering maps and key-value variables, you can create well-structured, maintainable, and adaptable Terraform configurations for your infrastructure needs.