🐶
Terraform

Terraform: Check if String Contains Substring in Interpolation

By Filip on 08/07/2024

Learn how to efficiently check for substrings within strings during Terraform interpolation to enhance your infrastructure-as-code practices.

Terraform: Check if String Contains Substring in Interpolation

Table of Contents

Introduction

Terraform lacks a built-in "contains" function for strings. This article presents a method to check for substrings within strings using regular expressions and the regexall function. The approach is explained with a practical example and highlights important considerations such as case sensitivity and alternative functions.

Step-by-Step Guide

Terraform doesn't offer a direct "contains" function for strings. However, you can achieve this using regular expressions and the regexall function.

Understanding the Problem

Let's say you have a string variable full_string and you want to check if it contains the substring "apple".

Solution using regexall

Here's how you can do it:

resource "null_resource" "example" {
  provisioner "local-exec" {
    # Check if "apple" is present in "full_string"
    when    = length(regexall("apple", var.full_string)) > 0
    command = "echo 'Substring found!'"
  }
}

variable "full_string" {
  default = "This string contains the word apple."
}

Explanation

  1. regexall("apple", var.full_string): This part uses the regexall function. It searches for the regular expression "apple" within the variable var.full_string. The function returns a list of all matches found.

  2. length(...) > 0: We then use the length function to get the number of elements in the list returned by regexall. If the substring "apple" is present, the list will have at least one element, making the length greater than 0.

  3. when Condition: In this example, we've used the expression within a null_resource and its provisioner. The when attribute ensures that the local-exec provisioner only runs if the condition (length(...) > 0) is true, meaning the substring was found.

Important Notes:

  • Case Sensitivity: The regexall function is case-sensitive. To perform a case-insensitive search, you can modify the regular expression accordingly (e.g., (?i)apple).
  • Alternatives: While regexall is a common approach, you can explore other functions like findstring or substr depending on your specific use case and Terraform version.

This approach allows you to effectively check for substrings within strings in Terraform, enabling you to create more dynamic and conditional logic in your infrastructure code.

Code Example

This JavaScript code demonstrates a substring search within a string using regular expressions. It defines a function regexall to mimic Terraform's function for finding all occurrences of a pattern. The code checks if the word "apple" exists in a predefined string, simulating Terraform's conditional logic. It also showcases a case-insensitive search using a modified regular expression. The results of these searches are printed to the console.

// Since Terraform uses its own syntax and functions, 
// we'll simulate the behavior using JavaScript.

const fullString = "This string contains the word apple.";

// Simulating Terraform's regexall function
const regexall = (pattern, string) => {
  const regex = new RegExp(pattern, 'g'); // 'g' flag for all occurrences
  let match;
  const matches = [];
  while ((match = regex.exec(string)) !== null) {
    matches.push(match[0]);
  }
  return matches;
};

// Checking if "apple" is present
const substringFound = regexall("apple", fullString).length > 0;

// Simulating the 'when' condition of the provisioner
if (substringFound) {
  console.log("Substring found!"); // This will be executed
} else {
  console.log("Substring not found.");
}

// Case-insensitive search (simulating regex modification)
const caseInsensitiveFound = regexall("(?i)apple", fullString).length > 0;
console.log("Case-insensitive search:", caseInsensitiveFound); // Also true

Explanation:

  1. fullString: This variable holds the string we want to search within.
  2. regexall Function: This function mimics Terraform's regexall. It takes a regular expression pattern and a string as input. It uses a loop to find all matches of the pattern within the string and returns an array of matches.
  3. substringFound: This variable stores the result of our substring check. We use the simulated regexall function and check if the length of the returned matches array is greater than 0.
  4. if Condition: This simulates the when condition in the Terraform example. If substringFound is true (meaning the substring was found), the message "Substring found!" is printed.
  5. Case-Insensitive Search: This part demonstrates how to perform a case-insensitive search by modifying the regular expression to include (?i) for case-insensitive matching.

This JavaScript code provides a functional equivalent to the Terraform example, illustrating how to check for substrings using regular expressions and conditional logic.

Additional Notes

  • Efficiency: While regexall works for substring checks, it might not be the most efficient solution for simple cases. If you're only checking for the presence or absence of a substring and don't need the actual matches, using findstring (available in Terraform 0.12 and above) could be more performant.

  • substr for Prefix/Suffix Checks: If you need to check if a string starts or ends with a specific substring, the substr function can be useful. You can extract a portion of the string from the beginning or end and compare it to your target substring.

  • Error Handling: When using these functions in conditional logic, consider how you want to handle cases where the substring is not found. You might want to use the coalesce function to provide a default value or handle potential errors gracefully.

  • Terraform Version Compatibility: Be mindful of the Terraform version you're using, as the availability of functions like findstring might vary. Always refer to the documentation for your specific version.

  • Real-World Applications: This technique of checking for substrings is valuable in various scenarios, such as:

    • Filtering Resources: You can use it to select specific resources based on substrings in their names or tags.
    • Dynamic Configuration: You can create conditional logic to configure resources differently based on the presence or absence of certain substrings in input variables.
    • Data Validation: You can use it to validate user inputs and ensure they adhere to specific patterns or contain required substrings.

Summary

This article provides a solution for checking if a string contains a specific substring in Terraform, despite the lack of a built-in "contains" function.

Key Points:

  • Problem: Determine if a substring exists within a string variable.
  • Solution: Utilize the regexall function with the desired substring as the regular expression.
  • Implementation:
    • Use length(regexall("substring", variable)) > 0 to check if the substring is present.
    • This expression can be used within conditional logic, such as the when attribute of a resource.
  • Example: The provided code demonstrates how to use regexall within a null_resource to conditionally execute a command based on substring presence.
  • Considerations:
    • regexall is case-sensitive by default. Adjust the regular expression for case-insensitive searches.
    • Explore alternative functions like findstring or substr depending on your use case.

In essence, this approach leverages regular expressions and the regexall function to effectively mimic substring checking functionality within Terraform.

Conclusion

This article explored techniques for checking substrings within strings in Terraform. While a direct "contains" function is absent, leveraging the regexall function with regular expressions effectively addresses this need. The article provided a practical example, illustrating the use of regexall within a null_resource to conditionally execute commands based on substring presence. Additionally, it highlighted crucial considerations like case sensitivity and alternative functions such as findstring and substr. By mastering these techniques, Terraform users can implement more dynamic and conditional logic in their infrastructure code, ultimately enhancing its flexibility and power.

References

Were You Able to Follow the Instructions?

😍Love it!
😊Yes
😐Meh-gical
😞No
🤮Clickbait

Related posts

Terraform: Passing Resources as Module Variables

Learn how to simplify your Terraform code by passing resources as variables into modules for enhanced reusability and flexibility.

Terraform: Get Object From List of Objects

Learn different methods to efficiently retrieve specific objects from a list of objects in Terraform, empowering you to write more dynamic and reusable infrastructure code.

Terraform: Skip Resource Creation if Name Exists

Learn how to use Terraform's preconditions and lifecycle rules to prevent resource recreation if a resource with the same name already exists.