Variables Terraform

Table of Contents

What are Terraform Variables?

Terraform variables are placeholders for values that can be customized and reused across multiple Terraform configurations. They enable infrastructure as code (IaC) practitioners to manage complex environments with ease and flexibility. By using variables, Terraform configurations become more modular, reusable, and maintainable. This leads to a more efficient and effective infrastructure management process.

In Terraform, variables can be used to represent various infrastructure components, such as resource names, IP addresses, region locations, and more. They can be defined and set within Terraform configurations, allowing for customization and automation of infrastructure deployment and management. By leveraging variables, Terraform configurations can be easily adapted to different environments, such as development, staging, and production, without requiring code modifications.

Types of Variables in Terraform

Terraform offers three types of variables to support infrastructure as code (IaC) management: input variables, output variables, and local variables. Each type has its unique purpose and use cases.

Input Variables

Input variables are placeholders for values that are provided during the execution of a Terraform configuration. They enable customization and reusability of Terraform configurations across different environments. Input variables can be defined using the “variable” block in Terraform configurations. They can represent various infrastructure components, such as resource names, IP addresses, region locations, and more.

Output Variables

Output variables are used to return specific values from a Terraform configuration after it has been executed. They provide a way to extract and display information about the created infrastructure resources. Output variables can be defined using the “output” block in Terraform configurations. They are particularly useful for sharing information between Terraform configurations or for displaying important details about the infrastructure resources that have been created.

Local Variables

Local variables are used to simplify Terraform configurations by storing frequently used values or expressions. They are defined within the Terraform configuration file and are only accessible within that file. Local variables can be defined using the “locals” block in Terraform configurations. They are particularly useful for reducing redundancy and improving the readability of Terraform configurations.

For example, a local variable can be used to define a common prefix for resource names, making it easier to manage and identify resources within a Terraform configuration. Local variables can also be used to calculate complex expressions or perform data manipulation, improving the efficiency and maintainability of Terraform configurations.

In summary, Terraform offers three types of variables: input variables, output variables, and local variables. Each type has its unique purpose and use cases, enabling infrastructure as code (IaC) practitioners to manage complex environments with ease and flexibility. By using variables, Terraform configurations become more modular, reusable, and maintainable, leading to a more efficient and effective infrastructure management process.

Declaring Variables in Terraform

In Terraform, variables can be declared using the “variable” block in the configuration file. This block defines the variable name, type, description, and any default values. Properly declaring variables is essential for ensuring the reusability and maintainability of Terraform configurations.

Variable Block Syntax

The syntax for declaring variables in Terraform is as follows:

variable "variable\_name" { type = "type" description = "description" default = "default\_value" }

Where “variable\_name” is the name of the variable, “type” is the variable type (such as string, number, or list), “description” is a brief explanation of the variable’s purpose, and “default\_value” is an optional default value for the variable.

Best Practices for Variable Declaration

When declaring variables in Terraform, it’s essential to follow best practices to ensure the reusability and maintainability of the configurations. Here are some best practices to consider:

Use descriptive variable names: Variable names should be descriptive and easy to understand. Avoid abbreviations or unclear names that may cause confusion.
Provide clear descriptions: Each variable should have a clear and concise description that explains its purpose and usage. This helps other users understand the configuration and reduces the risk of misuse.
Use appropriate variable types: Use the appropriate variable type for each variable, such as string, number, or list. This ensures that the variable is used consistently throughout the configuration and reduces the risk of errors.
Set default values: Whenever possible, set default values for variables. This makes it easier to use the configuration in different environments and reduces the risk of errors due to missing or incorrect variable values.

Here’s an example of declaring a variable in Terraform:

variable "region" { type = string description = "The AWS region where the resources will be created" default = "us-west-2" }

In this example, the variable “region” is declared as a string with a clear description and a default value of “us-west-2”. This variable can now be used in resource blocks to specify the AWS region for the created resources.

Using Variables in Terraform Configurations

Once variables are declared, they can be used in Terraform configurations to customize and reuse infrastructure as code (IaC) templates. Variables can be used in various parts of the configuration, including resource blocks, provisioners, and output values.

Interpolation

Interpolation is the process of inserting the value of a variable into a string or expression. In Terraform, interpolation is achieved using the “${}” syntax. For example, if a variable “region” is declared as “us-west-2”, it can be used in a resource block as follows:

resource "aws\_instance" "example" { ami = "ami-0c94855ba95c574c8" instance\_type = "t2.micro" region = "${var.region}" }

In this example, the value of the “region” variable is interpolated into the “region” argument of the “aws\_instance” resource block.

Referencing Variables in Resource Blocks

Variables can also be referenced directly in resource blocks without interpolation. For example, if a variable “instance\_type” is declared as “t2.micro”, it can be used in a resource block as follows:

resource "aws\_instance" "example" { ami = "ami-0c94855ba95c574c8" instance\_type = var.instance\_type region = "us-west-2" }

In this example, the value of the “instance\_type” variable is referenced directly in the “instance\_type” argument of the “aws\_instance” resource block.

Common Use Cases

Variables are commonly used in Terraform configurations for the following purposes:

Customizing resource names: Variables can be used to customize the names of resources, making it easier to manage and identify resources within a Terraform configuration.
Specifying resource locations: Variables can be used to specify the location of resources, such as the AWS region or the Google Cloud zone.
Setting resource properties: Variables can be used to set the properties of resources, such as the instance type or the number of instances.
Defining output values: Variables can be used to define output values, which provide information about the created resources.

By using variables in Terraform configurations, infrastructure as code (IaC) practitioners can create more modular, reusable, and maintainable configurations. Variables enable customization and automation of infrastructure deployment and management, improving the efficiency and effectiveness of the infrastructure management process.

Variable Sources and Default Values

In Terraform, variable sources and default values are used to specify the values of input variables. Variable sources are used to provide a location where Terraform can retrieve the variable value, while default values are used to specify a default value for the variable if no value is provided.

Variable Sources

Variable sources are used to specify where Terraform should look for the value of a variable. Variable sources can be specified using the “variable” block in the Terraform configuration file. The “default” argument can be used to specify a default value for the variable, while the “source” argument can be used to specify a variable source.

Here’s an example of specifying a variable source:

variable "region" { type = string description = "The AWS region where the resources will be created" default = "us-west-2" source = "terraform.example.com/variables/region" }

In this example, the “region” variable is declared as a string with a default value of “us-west-2”. The “source” argument specifies the location where Terraform should look for the value of the “region” variable.

Default Values

Default values are used to specify a default value for a variable if no value is provided. Default values can be specified using the “default” argument in the “variable” block. If no value is provided for the variable, Terraform will use the default value.

Here’s an example of specifying a default value:

variable "region" { type = string description = "The AWS region where the resources will be created" default = "us-west-2" }

In this example, the “region” variable is declared as a string with a default value of “us-west-2”. If no value is provided for the “region” variable, Terraform will use the default value of “us-west-2”.

Difference between Variable Sources and Default Values

Variable sources and default values serve different purposes in Terraform. Variable sources are used to specify where Terraform should look for the value of a variable, while default values are used to specify a default value for a variable if no value is provided.

Variable sources are useful when the value of a variable is stored in an external location, such as a remote backend or a variable file. Default values are useful when the value of a variable is known in advance and can be used as a fallback if no value is provided.

Here’s an example of using both a variable source and a default value:

variable "region" { type = string description = "The AWS region where the resources will be created" default = "us-west-2" source = "terraform.example.com/variables/region" }

Securing Sensitive Variables in Terraform Configurations

When working with Terraform configurations, it’s important to secure sensitive variables, such as passwords, API keys, and access tokens. Terraform provides several mechanisms for securing sensitive variables, including environment variables, sensitive variables, and variable validation.

Environment Variables

Environment variables can be used to secure sensitive variables in Terraform configurations. Environment variables are variables that are set outside of the Terraform configuration file and are accessed by Terraform at runtime. By using environment variables, sensitive variables can be kept out of the Terraform configuration file and away from version control systems.

Here’s an example of using an environment variable to secure a sensitive variable:

variable "api_key" {} provider "aws" { region = "us-west-2" access_key = "${var.api_key}" }

In this example, the “api\_key” variable is declared without a default value. The “access\_key” argument of the “aws” provider block references the “api\_key” variable. To secure the “api\_key” variable, it can be set as an environment variable:

export TF_VAR_api_key= terraform plan

In this example, the “TF\_VAR\_api\_key” environment variable is set to the sensitive value of the “api\_key” variable. Terraform will access the “api\_key” variable from the environment variable at runtime.

Sensitive Variables

Sensitive variables can be used to secure sensitive data in Terraform configurations. Sensitive variables are variables that are marked as sensitive and are not displayed in the Terraform output. By using sensitive variables, sensitive data can be kept out of the Terraform output and away from unauthorized users.

Here’s an example of using a sensitive variable to secure a sensitive value:

variable "password" { type = string description = "The password for the database" sensitive = true }

In this example, the “password” variable is declared as a string with the “sensitive” argument set to “true”. The “sensitive” argument marks the “password” variable as sensitive and hides its value in the Terraform output.

Variable Validation

Variable validation can be used to secure sensitive variables in Terraform configurations. Variable validation is the process of validating the value of a variable before it is used in the Terraform configuration. By using variable validation, sensitive variables can be validated against a set of rules to ensure that they meet certain criteria.

Here’s an example of using variable validation to secure a sensitive variable:

variable "database_name" { type = string description = "The name of the database" validation { condition = can(regex("^[a-zA-Z0-9_]{3,16}$", var.database\_name)) error\_message = "The database name must be between 3 and 16 characters long and can only contain letters, numbers, and underscores." } }

In this example, the “database\_name” variable is declared as a string with a validation rule. The validation rule uses a regular expression to validate the value of the “database\_name” variable. If the value of the “database\_name” variable does not meet the criteria, Terraform will display an error message.

By using environment variables, sensitive variables, and variable validation, sensitive variables can be secured in Terraform configurations. These mechanisms help ensure that sensitive data is kept out of the Terraform configuration file and away from unauthorized users.

How to Pass Variables to Terraform Configurations

Passing variables to Terraform configurations is an essential part of customizing and reusing Terraform configurations. Terraform provides several mechanisms for passing variables to configurations, including command-line arguments, environment variables, and variable files.

Command-Line Arguments

Command-line arguments can be used to pass variables to Terraform configurations. Command-line arguments are variables that are passed to Terraform at runtime using the command line. By using command-line arguments, variables can be customized without modifying the Terraform configuration file.

Here’s an example of using command-line arguments to pass variables to a Terraform configuration:

terraform apply -var "region=us-west-2" -var "instance\_type=t2.micro"

In this example, the “region” and “instance\_type” variables are passed to Terraform using command-line arguments. The “-var” flag is used to specify the variable name and value.

Environment Variables

Environment variables can be used to pass variables to Terraform configurations. Environment variables are variables that are set outside of the Terraform configuration file and are accessed by Terraform at runtime. By using environment variables, sensitive variables can be kept out of the Terraform configuration file and away from version control systems.

Here’s an example of using environment variables to pass variables to a Terraform configuration:

export TF\_VAR\_region=us-west-2 export TF\_VAR\_instance\_type=t2.micro terraform plan

In this example, the “TF\_VAR\_region” and “TF\_VAR\_instance\_type” environment variables are set to the values of the “region” and “instance\_type” variables. Terraform will access the “region” and “instance\_type” variables from the environment variables at runtime.

Variable Files

Variable files can be used to pass variables to Terraform configurations. Variable files are files that contain variables and their values. By using variable files, variables can be customized without modifying the Terraform configuration file.

Here’s an example of using a variable file to pass variables to a Terraform configuration:

# variables.tfvars region = "us-west-2" instance\_type = "t2.micro" # terraform apply -var-file="variables.tfvars"

In this example, the “variables.tfvars” file contains the “region” and “instance\_type” variables and their values. The “-var-file” flag is used to specify the variable file name. Terraform will access the “region” and “instance\_type” variables from the “variables.tfvars” file at runtime.

By using command-line arguments, environment variables, and variable files, variables can be passed to Terraform configurations. These mechanisms help ensure that Terraform configurations are customized and reused effectively.

Best Practices for Using Variables in Terraform Configurations

Using variables in Terraform configurations is essential for managing infrastructure as code. However, it’s important to follow best practices to ensure that variables are used effectively and securely. Here are some best practices for using variables in Terraform configurations:

Naming Conventions

Use clear and descriptive names for variables. Variable names should be concise, yet informative, and should accurately reflect the variable’s purpose. Use consistent naming conventions across your Terraform configurations to make it easier to understand and maintain your code.

Descriptions

Include descriptions for variables to provide context and meaning. Descriptions should explain the variable’s purpose, data type, and any constraints or validation rules. Descriptions can also include examples of how to use the variable.

Validation

Use variable validation to ensure that variables are used correctly. Variable validation can be used to enforce data types, constraints, and validation rules. Validation helps prevent errors and ensures that variables are used consistently across your Terraform configurations.

Default Values

Use default values for variables to make your Terraform configurations more flexible and reusable. Default values provide a fallback value for variables that are not explicitly set. Default values can also help simplify your Terraform configurations by reducing the number of required variables.

Variable Sources

Use variable sources to externalize variable values and make your Terraform configurations more modular and reusable. Variable sources can include environment variables, variable files, and data sources. Externalizing variable values also helps keep sensitive information out of your Terraform configurations and version control systems.

Securing Sensitive Variables

Secure sensitive variables in Terraform configurations using environment variables, sensitive variables, and variable validation. Sensitive variables should never be hard-coded into your Terraform configurations or stored in version control systems. Use encryption, hashing, and other security measures to protect sensitive variables and ensure that they are used securely.

Testing

Test your Terraform configurations with different variable values to ensure that they are working as expected. Testing helps identify errors, bugs, and other issues that can arise from using variables incorrectly. Testing also helps ensure that your Terraform configurations are flexible and reusable in different environments and use cases.

By following these best practices, you can ensure that variables are used effectively and securely in your Terraform configurations. Best practices help ensure that your Terraform configurations are maintainable, scalable, and reusable, making it easier to manage your infrastructure as code.