Terraform Functions with Examples

In this article, we delve into Terraform functions, the backbone of this open-source infrastructure as code tool, offering users built-in operators to efficiently manipulate and transform data in their configuration files.

Create a MySQL RDS Database Instance with Terraform 20

What is Terraform?

1280px Terraform Logo.svg removebg preview 1
  • It is an open-source IaaC (Infrastructure as a code) software tool where you define and create resources using providers in the declarative configuration language example JSON.
  • With Terraform, You can package and reuse the code in the form of modules.
  • It supports a number of cloud infrastructure providers such as AWS, Azure, GCP, IBM Cloud, OCI, etc.

What are Terraform Functions?

Terraform functions are built-in, reusable code blocks that perform specific tasks within Terraform configurations. They make your code more dynamic and ensure your configuration is DRY. Functions allow you to perform various operations, such as converting expressions to different data types, calculating lengths, and building complex variables.

Multiple Categories of Terraform Functions

  • String Functions:
    • Perform operations on textual data.
    • Examples include upper for case conversion and trimprefix for string manipulation.
  • Numeric Functions:
    • Operate on numerical values.
    • Include functions like min and max for finding minimum and maximum values.
  • Collection Functions:
    • Manage lists and maps efficiently.
    • Functions like length determine list size, while concat combines lists.
  • Date and Time Functions:
    • Handle timestamp formatting and manipulation.
    • Functions like formatdate enhance the management of temporal data.
  • Crypto and Hash Functions:
    • Enable cryptographic operations and hash calculations.
    • Essential for securing sensitive information and ensuring data integrity.
  • Filesystem Functions:
    • Interact with files and directories.
    • Functions like file and fileexists streamline local resource management.
  • IP Network Functions:
    • Facilitate manipulation and calculation of IP addresses and subnets.
    • Functions like cidrsubnet support dynamic network configuration.
  • Encoding Functions:
    • Transform data between encoding formats.
    • Includes functions like base64encode for interoperability tasks.
  • Type Conversion Functions:
    • Convert between different data types seamlessly.
    • Functions like toset and tolist enhance adaptability in resource attribute handling.

Table Summarizing Terraform Functions

Function TypeDescription
StringFunctions for string manipulation.
CollectionFunctions for manipulating collections like arrays, objects, lists, and maps.
EncodingEncoding and decoding functions dealing with various formats such as base64, text, JSON, YAML, etc.
File SystemFunctions for essential file operations.
NumericFunctions for performing mathematical operations on numeric values.
Date and TimeFunctions for date and time manipulation.
Hash and CryptoFunctions working with hashing and cryptographic mechanisms.
IP NetworkFunctions to work with CIDR ranges.
Type ConversionFunctions for converting data types.
Table Summarizing the Function Types in Terraform

Best Practices for Using Terraform Functions

  1. Read Documentation: Familiarize yourself with the official Terraform documentation to understand the full range of available functions and their usage.
  2. Modularity: Leverage functions to create modular and reusable code. This helps maintain a clean and organized codebase.
  3. Testing: Test your Terraform configurations thoroughly, especially when using complex functions. This ensures that your infrastructure is defined as expected.
  4. Version Compatibility: Be aware of Terraform version compatibility when using functions, as updates may introduce new functions or changes to existing ones.

Benefits of using Terraform Functions

  1. Dynamic Configurations: Functions enable the creation of adaptable configurations, adjusting to changing requirements.
  2. Code Reusability: Functions reduce redundancy, promoting modular, reusable code across resources and modules.
  3. Readability and Maintainability: Functions enhance code clarity, making configurations more understandable and maintainable.
  4. Standardized Operations: Functions provide a consistent approach for common operations, ensuring code uniformity.
  5. Abstraction of Complexity: Functions simplify configurations by abstracting complex operations, improving overall readability.
  6. Facilitates Testing: Functions allow easier testing of specific functionalities, supporting unit tests for reliable configurations.
  7. Interpolation and Expression: Functions offer powerful interpolation, enabling dynamic value composition within configurations.
  8. Enhanced Data Manipulation: Functions cover a range of data manipulation tasks, facilitating effective handling and transformation.
  9. Adherence to Best Practices: Terraform functions encourage adherence to best practices, promoting standardized IaC development.
  10. Facilitates Infrastructure Composition: Functions play a crucial role in composing complex infrastructure setups through dynamic variable creation and conditional operations.

Potential Drawback of using Terraform Functions

While Terraform functions offer numerous benefits, it’s essential to be aware of potential drawbacks:

  • Complexity and Learning Curve:
    • Drawback: Extensive use of functions, especially for complex operations, might introduce a learning curve for new users or team members. Understanding the full range of functions and their interactions can be challenging.
  • Potential for Over-Abstraction:
    • Drawback: Excessive use of functions can lead to over-abstraction, making the code harder to understand. Balancing abstraction with clarity is crucial to maintaining code readability.
  • Limited Error Handling:
    • Drawback: Terraform functions might have limited error handling mechanisms. In some cases, unexpected inputs or conditions could lead to runtime errors that might be challenging to diagnose and troubleshoot.
  • Dependency on Terraform Versions:
    • Drawback: The availability and behavior of functions may vary across Terraform versions. Upgrading Terraform might introduce changes to function behavior, requiring careful consideration and potential adjustments in existing code.
  • Performance Impact:
    • Drawback: Complex or computationally intensive functions could potentially impact Terraform’s performance. While the impact might be negligible in most cases, it’s essential to be mindful of function efficiency in large-scale configurations.
  • Potential for Abuse:
    • Drawback: Overreliance on functions for intricate logic might lead to configurations that are difficult to maintain. Careful consideration is necessary to ensure that functions are used appropriately and do not compromise the simplicity of the configuration.
  • Debugging Challenges:
    • Drawback: Debugging configurations that heavily rely on functions can be challenging. Understanding the flow of execution and pinpointing issues might require additional effort, particularly in more complex setups.
  • Limited Functionality in certain contexts:
    • Drawback: Some functions may have limitations in certain contexts or might not be available for all resource types. Users need to be aware of these limitations and plan accordingly.
  • Potential for Function Overuse:
    • Drawback: There’s a risk of overusing functions to achieve complex configurations. This can make the code overly intricate and could potentially be simplified by reevaluating the need for certain functions.

What is Terraform Console?

Terraform console is an interactive command-line environment provided by Terraform that allows users to evaluate expressions and interact with Terraform configurations in real-time. It’s a convenient tool for testing and experimenting with Terraform language constructs, functions, and expressions without the need to apply changes to the actual infrastructure.

Usage Example: To start the Terraform console, run the following command in the directory containing your Terraform configuration files:

terraform console

Once in the console, you can enter expressions and see the results. For example:

> 5 + 3

> var.region

> concat(["web-", "app-", "db-"], "-")

Here, the console evaluates the sum of 5 and 3, retrieves the value of the var.region variable, and concatenates a list of strings.

Remember that Terraform console is a tool for exploration and testing. It doesn’t apply changes to your infrastructure; rather, it helps you understand and experiment with Terraform configurations before applying them.

Practical Guide For Using Terraform Functions

provider "aws" {
  region     = var.region
  profile = "default"

locals {
  time = formatdate("DD MMM YYYY hh:mm ZZZ", timestamp())

variable "region" {
  default = "ap-south-1"

variable "tags" {
  type = list
  default = ["firstec2","secondec2"]

variable "ami" {
  type = map
  default = {
    "us-east-1" = "ami-0c7217cdde317cfec"
    "us-west-2" = "ami-008fe2fc65df48dac"
    "ap-south-1" = "ami-03f4878755434977f"

resource "aws_key_pair" "loginkey" {
  key_name   = "login-key"
  public_key = file("${path.module}/three-tier1.pub")

resource "aws_instance" "app-dev" {
   ami = lookup(var.ami,var.region)
   instance_type = "t2.micro"
   key_name = aws_key_pair.loginkey.key_name
   count = 2

   tags = {
     Name = element(var.tags,count.index)

output "timestamp" {
  value = local.time
Screenshot 2023 12 27 132120 1

Function Used in this Code-

  1. formatdate Function:
    • Purpose: Formats a timestamp into a human-readable date and time string.
    • Usage in Code: formatdate(“DD MMM YYYY hh:mm ZZZ”, timestamp())
    • Explanation: The function takes two parameters – the format string and the timestamp. It returns a string representing the timestamp in the specified format.
  2. timestamp Function:
    • Purpose: Retrieves the current timestamp.
    • Usage in Code: timestamp()
    • Explanation: This function returns the current timestamp, representing the current date and time.
  3. file Function:
    • Purpose: Reads the contents of a file.
    • Usage in Code: file(“${path.module}/three-tier1.pub”)
    • Explanation: It reads the contents of the specified file and can be used to load information from files into Terraform configurations. In this case, it reads the content of the public key file.
  4. lookup Function:
    • Purpose: Looks up a value in a map based on a given key.
    • Usage in Code: lookup(var.ami, var.region)
    • Explanation: It searches for the value associated with the specified region key in the var.ami map. It helps in selecting the correct Amazon Machine Image (AMI) ID based on the chosen AWS region.
  5. element Function:
    • Purpose: Retrieves an element from a list based on its index.
    • Usage in Code: element(var.tags, count.index)
    • Explanation: It returns the value at the current index in the var.tags list. This is used to assign unique names to the instances based on the current index.
  6. output Block:
    • Purpose: Declares an output variable for displaying information after applying Terraform.
    • Usage in Code: output “timestamp” { value = local.time }
    • Explanation: It declares an output variable named “timestamp” with the value being the formatted date and time string stored in the local.time variable. This information will be displayed when you run terraform apply.


Terraform’s built-in functions provide a powerful and flexible way to enhance your infrastructure provisioning code. These functions allow you to perform calculations, manipulate data, and dynamically generate configuration values within your Terraform code. With many functions available, you can easily tailor your infrastructure provisioning process to meet your needs.


For reference visit the official website Developer.hashicorp.com.

Any queries pls contact us @Devopshint.

Related Articles:

Terraform State File Management | Terraform Local State File | Terraform Remote

About Akash Bhujbal

Hey, I am Akash Bhujbal, I am an aspiring DevOps and Cloud enthusiast who is eager to embark on a journey into the world of DevOps and Cloud. With a strong passion for technology and a keen interest in DevOps and Cloud based solutions, I am driven to learn and contribute to the ever-evolving field of DevOps and Cloud.

Leave a Comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Share via
Copy link