6 Terraform Folder Structure Best Practices

Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. When used correctly, Terraform can help you manage your infrastructure in a reliable and scalable way.

One of the keys to using Terraform effectively is to structure your Terraform code in a way that is easy to understand and maintain. In this article, we will discuss six best practices for structuring your Terraform code. By following these best practices, you can make your Terraform code more readable, maintainable, and reusable.

1. Organize your Terraform code into modules

Modules help you keep your code organized and maintainable. When you have a lot of Terraform code, it can be difficult to keep track of everything without some sort of organizational system. Modules help you group related resources together so that you can easily find what you’re looking for.

Modules also make it easier to reuse code. If you have a module that’s been tested and is working well, you can simply reuse it in other projects rather than having to recreate it from scratch. This saves you time and effort in the long run.

Finally, modules help you share code with others. If you have a module that you think would be useful to someone else, you can simply share it with them rather than giving them access to your entire codebase. This makes collaboration much easier.

2. Use a consistent naming convention for resources

When you have dozens or even hundreds of resources in your Terraform code, it can be difficult to keep track of them all. A consistent naming convention helps to alleviate this problem by making it easier to find and reference specific resources.

There are many different ways to name your resources, but one popular convention is to use the resource type as a prefix. For example, you might name an AWS S3 bucket “s3_bucket” or a Google Cloud Storage bucket “gcs_bucket”.

This convention makes it easy to quickly identify the type of resource you’re dealing with, which can be helpful when troubleshooting or trying to understand someone else’s code. It also makes it easier to search for resources, since you can simply search for the resource type (e.g. “s3”) instead of having to remember the exact name of the resource.

3. Create variables to make your code more reusable and maintainable

If you find yourself writing the same code over and over again, it’s a good idea to create a variable for it. This way, you can simply reference the variable instead of duplicating the code. Not only does this make your code more concise, it also makes it easier to update should you need to change the value of the code.

It’s also a good idea to create variables for any values that are likely to change in the future, such as server IP addresses or usernames. This way, you can easily update the value in one place and have it propagate throughout your code.

Finally, creating variables can help you organize your code into logical groups. For example, you could create a group of variables for all of your networking code, another group for your server code, and so on. This makes it easier to find and reuse code later on.

4. Use outputs to expose the values of created resources

When you create a resource in Terraform, such as an AWS EC2 instance, that resource is given a unique ID. This ID is generated by Terraform and is used internally by Terraform to manage the state of your infrastructure.

However, there are times when you need to know the value of that ID outside of Terraform. For example, you might need to pass the ID of an EC2 instance to a script that needs to SSH into that instance.

This is where outputs come in. Outputs allow you to expose the values of created resources so that they can be used outside of Terraform.

To output the value of a resource, you simply add an output block to your Terraform code. The output block takes two arguments:

The first argument is the name of the output. This can be anything you want.

The second argument is the value you want to output. This is usually the value of a created resource, such as an EC2 instance ID.

Here’s an example of an output block that outputs the ID of an EC2 instance:

output “ec2_instance_id” {
value = “${aws_instance.example.id}”
}

This output can then be accessed using the terraform output command. For example, to output the value of the ec2_instance_id output, you would run the following command:

terraform output ec2_instance_id

Outputting the value of a resource is a great way to expose that value to other tools and scripts. However, it’s important to note that outputs are only meant to be used for read-only data.

If you try to output a value that can be modified, such as the value of a variable, Terraform will show a warning. This is because Terraform cannot guarantee that the value of the output will not change in the future, which could cause problems for any scripts or tools that are relying on that value.

5. Use version control to track changes to your infrastructure

When you make changes to your infrastructure, it’s important to have a way to track those changes so that you can roll back if necessary. Version control provides a way to do that.

Version control also allows you to share your infrastructure with others and collaborate on changes. This is especially important when working with a team of people.

There are many different version control systems available, but Git is the most popular. If you’re not familiar with Git, there are plenty of resources available to learn.

Once you have a version control system in place, you can start tracking changes to your Terraform files. Every time you make a change, you can commit the change with a message describing what was changed. This will help you keep track of your changes over time.

6. Use workspaces to manage multiple environments

When you have multiple environments (e.g. development, staging, and production), it’s important to keep them separate so that changes made in one environment don’t accidentally get applied to another. This is where workspaces come in.

A workspace is a logical container for a set of Terraform resources. You can use workspaces to create isolated environments within your Terraform project. For example, you could have a workspace for each environment (development, staging, and production).

To create a workspace, simply add a file called “workspaces.tf” to your Terraform project with the following contents:

terraform {
workspace “development” {
# …
}

workspace “staging” {
# …
}

workspace “production” {
# …
}
}

This will create three workspaces named “development”, “staging”, and “production”. You can switch between these workspaces using the “terraform workspace” command.

Now, when you run “terraform apply”, Terraform will automatically apply your changes to the correct workspace. This is a huge time saver and helps prevent mistakes.