Terraform is an infrastructure as code (IaC) tool that allows you to define and manage your infrastructure using declarative configuration files. In addition to basic variable types like strings and numbers, Terraform also supports complex variable types that enable you to define more structured and sophisticated data. In this article, we’ll explore the complex variable types available in Terraform and provide examples to illustrate their usage.
1. List Variables
List variables in Terraform allow you to define an ordered collection of values. Each element in the list can be of any valid Terraform data type, including other complex variable types. List variables are useful when you need to manage multiple values of the same type.
Here’s an example of how to define and use a list variable in Terraform:
variable "fruits" {
type = list(string)
default = ["apple", "banana", "orange"]
}
resource "example_resource" "my_resource" {
count = length(var.fruits)
name = var.fruits[count.index]
}
In this example, we define a list variable called “fruits” of type list(string). The default value of the “fruits” variable is an array of strings, namely “apple”, “banana”, and “orange”. We then use this list variable inside a resource block, where we create multiple instances of the resource based on the length of the “fruits” list. The count.index allows us to access each element of the list during resource creation.
2. Map Variables
Map variables in Terraform allow you to define a collection of key-value pairs. Map keys are unique, and each value can be of any valid Terraform data type, including other complex variable types. Map variables are useful when you need to manage configurations with different parameters or settings.
Here’s an example of how to define and use a map variable in Terraform:
variable "server_ports" {
type = map(number)
default = {
web = 80
database = 3306
cache = 6379
}
}
resource "example_resource" "my_resource" {
for_each = var.server_ports
name = each.key
port = each.value
}
In this example, we define a map variable called “server_ports” of type map(number). The default value of the “server_ports” variable is a map with keys representing server names (“web”, “database”, “cache”) and values representing the corresponding port numbers. We use the for_each parameter to iterate over each key-value pair in the map and create a separate instance of the resource for each entry.
3. Object Variables
Object variables in Terraform allow you to define a structured collection of attributes. Each attribute within the object can have its own data type, including other complex variable types. Object variables are useful when you need to manage configurations with multiple related attributes.
Here’s an example of how to define and use an object variable in Terraform:
variable "person" {
type = object({
name = string
age = number
address = string
})
default = {
name = "John Doe"
age = 30
address = "123 Main St"
}
}
resource "example_resource" "my_resource" {
name = var.person.name
age = var.person.age
address = var.person.address
}
In this example, we define an object variable called “person” using the object type. The “person” object has three attributes: “name” of type string, “age” of type number, and “address” of type string. We provide a default value for the “person” variable with sample attribute values. Inside the resource block, we access each attribute of the “person” object using dot notation.
4. Tuple Variables
Tuple variables in Terraform allow you to define an ordered collection of elements with different data types. Tuple elements can be of any valid Terraform data type, including other complex variable types. Tuple variables are useful when you need to manage collections of related but distinct values.
Here’s an example of how to define and use a tuple variable in Terraform:
variable "employee" {
type = tuple([
string, # name
number, # age
bool, # active
])
default = [
"Alice",
25,
true,
]
}
resource "example_resource" "my_resource" {
name = var.employee[0]
age = var.employee[1]
active = var.employee[2]
}
In this example, we define a tuple variable called “employee” using the tuple type. The “employee” tuple has three elements: “name” of type string, “age” of type number, and “active” of type bool. We provide a default value for the “employee” variable with sample attribute values. Inside the resource block, we access each element of the “employee” tuple using indexing (0-based).
Best Practices for Using Complex Variable Types
While working with complex variable types in Terraform, it’s important to keep the following best practices in mind:
1. Define Clear and Descriptive Variable Names
Choose variable names that accurately reflect the purpose and content of the variable. This helps improve the readability and maintainability of your Terraform code.
2. Provide Default Values
Assign default values to complex variables whenever possible. Default values ensure that your Terraform configuration can be used without requiring users to explicitly specify every value. It also helps prevent configuration errors and provides a better out-of-the-box experience.
3. Validate Input Values
Consider using validation rules and constraints for complex variable types. You can define input variable validation using Terraform’s input variable validation blocks. This helps ensure that the provided values adhere to the expected data types and constraints, reducing the risk of misconfigurations.
4. Document Variable Usage
Document the usage and expected structure of complex variables in your Terraform modules or configurations. Clearly explain the purpose of each variable, the expected data types, and any additional requirements or constraints. This documentation helps users understand how to correctly provide values for the variables.
5. Handle Variable Interdependencies
When working with complex variable types, consider the interdependencies between different variables. Ensure that variables that rely on each other are properly defined and consistent. For example, if a map variable depends on another variable for its values, make sure the dependent variable is set correctly.
6. Test and Validate Configurations
Regularly test and validate your Terraform configurations that use complex variable types. Perform thorough testing to ensure that the configurations work as expected and handle various scenarios and edge cases. This helps identify any issues or inconsistencies early on and allows for necessary adjustments.
7. Leverage Modules and Reusability
Take advantage of Terraform modules to encapsulate complex variable types and promote reusability. By creating reusable modules, you can abstract complex configurations into separate entities and easily reuse them across different projects or environments.
Conclusion
In this article, we covered the complex variable types available in Terraform: list, map, object, and tuple. We explored their definitions, provided examples, and discussed best practices for working with these variable types in your Terraform configurations.
By leveraging complex variable types, you can structure and manage more sophisticated and dynamic data in your Terraform infrastructure code. This flexibility allows you to create reusable, scalable, and maintainable configurations, ultimately making it easier to manage your infrastructure as code.
