Last Updated on August 7, 2025 by Arnav Sharma
With Terraform, HashiCorp has introduced a powerful tool for defining cloud infrastructure in a high-level configuration language. As developers or IT pros, we browse through directories and files, harnessing Terraform’s path functions: path.module, path.root, and path.cwd, to construct paths relative to our configurations, modules, and the current working directory. This blog dives into these path functions with some used cases.
The Cornerstones of Terraform File Paths
Terraform’s configuration language offers different path functions that allow developers to dynamically generate file paths within Terraform configurations. These functions serve as the backbone for managing resources, modules, and dependencies within Terraform code. At the core of these path-related functions are path.module, path.root, and path.cwd, each playing an important role in how Terraform interprets filesystem paths.
path.module: The Module’s Filesystem Path
path.module holds the key to the current module’s filesystem path. When Terraform executes, this function generates a relative or absolute path to the directory containing the module where the expression is placed. This allows developers to reference paths that include various files and modules within their configuration files, providing a flexible way to manage resources and configurations dynamically.
Example 1: Using path.module to Reference a Template File
Imagine you have a Terraform module that provisions a virtual machine (VM), and you want to use a configuration template that’s located within the same module directory. Here’s how you can use path.module to dynamically construct the path to the template file:
resource "some_vm_provider" "vm" {
# Assuming 'config_template.tpl' is within the same directory as this module
user_data = templatefile("${path.module}/config_template.tpl", {
some_variable = "some_value"
})
}In this example, ${path.module} dynamically generates the filesystem path to the module where this resource is defined, allowing Terraform to correctly locate config_template.tpl.
path.root: Root Module Directory
The path.root function reveals the path to the root module directory, differentiating between the current module and the root module. This distinction is crucial, especially when dealing with nested modules or when Terraform commands are run from a subdirectory within the project. path.root ensures that references and paths remain consistent, regardless of the module depth or the location from which Terraform commands are executed.
Example 2: Differentiating Resources with path.root
Suppose you’re working in a large Terraform project with multiple nested modules, and you need to create a resource that should only be instantiated once per project, regardless of the number of modules. You can leverage path.root to ensure the resource’s name is unique across the entire project:
resource "some_resource" "unique" {
name = "unique-resource-${md5(path.root)}"
}Here, path.root helps generate a unique identifier for the resource by creating a hash of the root module’s filesystem path, ensuring the resource’s name remains unique across the entire Terraform project.
path.cwd: Current Working Directory
path.cwd steps into the realm of the current working directory, offering a way to reference the path to the directory from which Terraform is run. This function is particularly useful for including files relative to the Terraform configuration’s execution point, enabling developers to structure their projects in a way that best suits their operational workflows.
Example 3: Leveraging path.cwd for Local File Inclusion
In a scenario where you’re running Terraform commands from a directory that contains files you wish to include in your configuration (e.g., a list of IPs to whitelist), you can use path.cwd to include those files dynamically:
resource "some_firewall_rule" "whitelist" {
# Assuming 'whitelist.txt' is in the current working directory
ips = file("${path.cwd}/whitelist.txt")
}This example demonstrates how ${path.cwd} is used to refer to the current working directory from which Terraform commands are executed, allowing for the dynamic inclusion of whitelist.txt.
Practical Applications and Considerations
Utilizing these path functions within Terraform configurations empowers developers to architect their infrastructure with precision and adaptability. For instance, when defining a resource that depends on a template stored in a different directory, path.module can be used to generate the file path dynamically, ensuring the template is correctly referenced regardless of where the Terraform code is executed from.
However, while the flexibility offered by these path functions is invaluable, it also demands careful consideration. Operations that depend on the file path, especially write operations, can produce different behavior depending on whether you use remote or local module sources. This can lead to potential issues, such as overwriting data or executing unexpected code, particularly when paths are used with files for provisioning resources like VMs.