Create a .gitignore file for Terraform

In the world of version control and collaborative coding, managing your project's files efficiently is crucial. This is where the ".gitignore" file comes into play. Understanding what a .gitignore file is and how to use it can save you from numerous headaches.

In this blog post, we'll not only demystify the concept of .gitignore but also dive into practical steps, focusing on creating a .gitignore file tailored specifically for your Terraform projects. So, let's embark on this journey and take the first step toward creating a clean and secure version control environment for your Terraform endeavours.

What is .gitignore?

Essentially, a .gitignore file is a simple yet powerful tool in Git. It allows you to specify which files or directories should be ignored and excluded from being tracked by Git.

By doing so, you can keep your repository clean, prevent sensitive data from being accidentally committed, and improve the overall performance of your version control operations.

Create a .gitignore file for your Terraform projects

Let’s get started and work through creating a .gitignore file for use within your Terraform projects.

Step 1 - Create a new directory

Let’s create a new directory for our project to be stored within. You can open up your bash terminal and type in the following command:

mkdir terraform-project

Step 2 - Initialize your project

We now want to switch to the new directory and then initialize the directory for both git and terraform use. To do that we use the following commands:

cd terraform-project
git init
terraform init

Step 3 - Create a .gitignore file

We are now ready to create the .gitignore file, you can do this from a bash command but I prefer to use an editor, whether that be something like Notepad or VS Code.

Open your editor of choice and create a new file, save it as .gitignore within your project directory. There are a lot of different things we want to make sure aren’t synced to our version control system when we are working in our Terraform projects. Things such as:

Local Terraform directories
Terraform state files
Crash log files
Files containing sensitive data, variable files
Terraform override files
Terraform plan files
Terraform CLI configuration files

GitHub has created a repository of .gitignore files, their Terraform one can be found here.

# Local .terraform directories
**/.terraform/*

# .tfstate files
*.tfstate
*.tfstate.*

# Crash log files
crash.log
crash.*.log

# Exclude all .tfvars files, which are likely to contain sensitive data, such as
# password, private keys, and other secrets. These should not be part of version 
# control as they are data points which are potentially sensitive and subject 
# to change depending on the environment.
*.tfvars
*.tfvars.json

# Ignore override files as they are usually used to override resources locally and so
# are not checked in
override.tf
override.tf.json
*_override.tf
*_override.tf.json

# Include override files you do wish to add to version control using negated pattern
# !example_override.tf

# Include tfplan files to ignore the plan output of command: terraform plan -out=tfplan
# example: *tfplan*

# Ignore CLI configuration files
.terraformrc
terraform.rc

Copy this template into your .gitignore file and save it to your project directory.

Conclusion

In this blog post, we embarked on a journey to demystify the concept of the ".gitignore" file, a small but mighty tool in the world of version control. By gaining a clear understanding of what .gitignore is and how it can be harnessed, you've taken the first step towards a smoother, more organized, and secure development workflow.

The power of .gitignore lies in its ability to declutter your Git repositories, safeguard sensitive data, and optimize the overall performance of your version control operations. By following the steps outlined in this post, you've learned how to create a customized .gitignore file tailored specifically for your Terraform projects, ensuring that only the necessary files are tracked and committed. Remember that precise file management can significantly enhance your collaboration with fellow developers and protect your project's integrity.