Terraform Locals vs Variables

Last Updated on April 2, 2024 by Arnav Sharma

In Terraform, both locals and variables are used to define values, but they serve different purposes and have different behaviors. Understanding the distinction between them is crucial for effective Terraform configuration.

Variables

1. Purpose: Variables in Terraform are analogous to function arguments. They are used to customize Terraform modules with different values. This makes your Terraform configurations more dynamic and reusable.
2. Definition: Variables are defined in Terraform using the variable keyword. They can be set from outside the module (e.g., via command-line flags, environment variables, Terraform Cloud, or the terraform.tfvars file).
3. Usage: Variables are used to allow users to input custom values. They are often used for setting up resources that might need different configurations in different environments (like development, staging, production).
4. Scope: Variables can be accessed by any resource or module within the same module where they are declared.

Example 1: Defining and Using a Variable

variable “instance_type” {
  description = “The type of EC2 instance to create.”
  type        = string
  default     = “t2.micro”
}

resource “aws_instance” “example” {
  ami           = “ami-0c55b159cbfafe1f0”
  instance_type = var.instance_type
}

In this example, the instance_type variable allows users to specify the type of EC2 instance. If not specified, it defaults to t2.micro.

Example 2: Overriding Variable Values

You can override the default value of a variable in several ways, such as through command-line flags or a terraform.tfvars file.

Command-line:

terraform apply -var=”instance_type=t2.large”

terraform.tfvars file:

instance_type = “t2.large”

Locals

1. Purpose: Locals (short for “local values”) are used to simplify your Terraform code and reduce repetition. They are like constants or helper variables within a Terraform module.
2. Definition: Locals are defined using the locals block. They are only accessible within the module where they are defined.
3. Usage: Locals are useful for creating complex expressions that you need to reuse. For example, you might use a local to construct a naming convention that is used in several resources within a module.
4. Scope: Local values are module-scoped and can only be referenced within the module where they are defined. They cannot be set or overridden from outside the module.

Example 1: Defining and Using Locals

locals {
  common_tags = {
    Owner       = “Team A”
    Environment = “Prod”
  }
}

resource “aws_instance” “example” {
  ami           = “ami-0c55b159cbfafe1f0”
  instance_type = “t2.micro”
  tags          = local.common_tags
}

In this example, local.common_tags is used to apply the same set of tags to multiple resources within the module.

Example 2: Simplifying Expressions with Locals

locals {
  subnet_prefix = “10.0.${var.environment_id}.0/24”
}

resource “aws_subnet” “example” {
  vpc_id     = aws_vpc.main.id
  cidr_block = local.subnet_prefix
}

Here, local.subnet_prefix simplifies the creation of a subnet CIDR block based on an environment ID provided as a variable.

Key Differences Illustrated

• Mutability: Variables can be changed externally (e.g., different instance types for different deployments), while locals are fixed once defined (e.g., common_tags used consistently across resources).
• Scope: Variables can be passed into modules from parent modules or the Terraform command line. Locals are only accessible within the module where they are defined.
• Purpose: Variables are for user inputs and external configuration. Locals are for internal organization, reducing repetition, and simplifying complex expressions.

When to Use Each

• Use variables when you need to:
  • Allow users to customize the configuration.
  • Create modules that can be used in different environments with different settings.
• Use locals when you need to:
  • Simplify complex expressions that are used multiple times within a module.
  • Create a fixed internal value that helps make your configuration more readable and maintainable.

FAQ

Q: How can you effectively use local variables in Terraform for naming resources?

Local variables in Terraform, often referred to as “locals,” are a powerful feature for defining common values or expressions within your configuration files. They help to avoid duplication and simplify the ability to change values throughout your configuration. By using locals to name resources, you can assign a single value or expression that is used throughout various modules or resources, ensuring consistency and making your infrastructure as code (IaC) more maintainable.

Q: What are some best practices for defining and using Terraform variables?

Terraform variables are essential for creating flexible and reusable Infrastructure as Code (IaC) configurations. Best practices for using Terraform variables include defining them within your configuration files with clear, descriptive names, and using them to store values or expressions that change values across different environments or modules. Variables allow for the dynamic configuration of resources and modules, enhancing the reusability and adaptability of your Terraform code.

Q: Can you explain how to use dynamic expressions in Terraform?

Dynamic expressions in Terraform enable more flexible and adaptable code. They are particularly useful in scenarios where the value is not static but needs to be calculated or derived from other sources. For instance, you can use dynamic expressions to create a for_each loop, which iterates over a list or map, to provision multiple similar resources. Dynamic expressions can also be used to reference attributes of other resources or data sources, allowing for more complex and interconnected configurations.

Q: What are the prerequisites for learning Terraform and applying it in a DevOps context?

To effectively learn and apply Terraform in a DevOps context, some prerequisites include general coding knowledge, an understanding of cloud platforms like AWS or Azure, and familiarity with basic DevOps principles. Knowledge of programming languages like Python can be helpful, as it aids in understanding the syntax and logic of Infrastructure as Code (IaC). Additionally, an understanding of cloud resources and their configuration is crucial for defining and managing infrastructure using Terraform.

Q: How can Terraform’s for_each construct enhance infrastructure management?

Terraform’s for_each construct is a powerful tool for managing infrastructure, particularly when dealing with multiple instances of similar resources. It allows you to iterate over a list or map and create a resource for each item. This reduces duplication in your code and simplifies management by treating multiple instances as variations of a single configuration. For_each is particularly useful in scenarios like creating multiple AWS instances or assigning resource tags to a set of similar resources.

Q: Can you provide an example of assigning AWS credentials in Terraform using HCL?

Assigning AWS credentials in Terraform involves using HashiCorp Configuration Language (HCL) to specify the credentials as either environment variables or directly in the Terraform configuration files. For example, you can assign AWS credentials by defining them in a provider block, ensuring that Terraform has the necessary permissions to provision resources in your AWS account. It’s important to follow best practices for security and privacy when managing sensitive information like credentials in your Terraform configurations.

Q: What is the significance of Azure resource tags in Terraform, and how are they implemented?

Resource tags in Terraform are key-value pairs assigned to resources, which help in organizing, managing, and identifying resources within a cloud environment. Tags can include information like the purpose of the resource, the environment it belongs to, or the team responsible for it. In Terraform, you can implement resource tags using the ‘tag’ attribute in resource configurations. Properly tagging resources is considered a best practice in cloud resource management and is particularly useful for cost allocation and tracking.

Q: How can Kubernetes be effectively utilized in cloud infrastructure management?

Kubernetes, a powerful tool for managing containerized applications, is highly recommended for cloud infrastructure management. Numerous stories and guides available on platforms like Medium can provide valuable insights and step-by-step instructions to help you leverage Kubernetes effectively.

Q: What are the benefits of using Terraform locals in infrastructure as code practices?

Terraform locals are essential for efficient infrastructure coding, especially when defining and managing resources. They allow for the re-use of values within your Terraform configuration, leading to cleaner and more maintainable code. Flavius, a Terraform expert, highlights the use of local values in ensuring a more streamlined and effective workflow.

Q: Can you provide a guide on how to name resources using Terraform locals?

Certainly! Using Terraform locals to name resources involves assigning a name to an expression defined within your Terraform module. This technique allows for a consistent prefix to be used across resources, ensuring that your infrastructure’s naming convention is both meaningful and organized.

Q: What are some key lessons from Python and general coding knowledge for Terraform users?

For Terraform users, incorporating Python and general coding knowledge can be extremely beneficial. Over the past three years, there have been numerous insights and lessons, with one notable example being a short article outlining 10 essential lessons. These cover various aspects of coding and can significantly enhance your ability to write and understand Terraform configurations.

keywords: input variable and output terraform local values use cases value is used throughout recommended from medium use local values stories to help step-by-step guide actual value terraform certified terraform runs values in terraform load balancer config