Mistakes I Made Deploying an IaC Project in GCP Using Terraform (and How I Fixed Them)

Introduction:

I recently deployed an IaC project in GCP using Terraform. The project was a simple web application, but it was a good learning experience. In this blog post, I'll discuss some of the mistakes that I made deploying the project, and how I fixed them.

Mistake #1: Not using modules

One of the biggest mistakes I made was not using modules. Modules are a way to reuse code in Terraform, and they can make your code much more maintainable. For example, I had a set of resources that I used to create a database. I could have put these resources in a module, and then I could have reused the module in other projects.

How I fixed the mistake:

I fixed this mistake by starting to use modules. I created a module for the database resources, and then I reused the module in other projects. This made my code much more maintainable, and it made it easier to deploy the project.

Here are some of the benefits of using modules:

• Reusability: Modules can be reused in multiple projects, which can save you time and effort.
• Maintainability: Modules make your code easier to maintain, because you only have to make changes in one place.
• Consistency: Modules can help you to ensure that your code is consistent across different projects.

Mistake #2: Not using variables

Another mistake I made was not using variables. Variables are a way to pass data into Terraform, and they can make your code more flexible. For example, I had a set of resources that I used to create a web server. I could have used variables to pass the web server's name and port number into Terraform.

How I fixed the mistake:

I fixed this mistake by starting to use variables. I created variables for the web server's name and port number, and then I passed the variables into Terraform. This made my code more flexible, and it made it easier to deploy the project to different environments.

Here are some of the benefits of using variables:

• Flexibility: Variables can make your code more flexible, by allowing you to change the values of the variables without having to change the code itself.
• Reusability: Variables can make your code more reusable, by allowing you to use the same code in different environments with different values for the variables.
• Documentation: Variables can help you to document your code, by providing a clear explanation of the values that the variables can take.

Mistake #3: Not using Terraform Cloud

I also made the mistake of not using Terraform Cloud. Terraform Cloud is a hosted version of Terraform, and it can make it easier to manage your Terraform projects. For example, Terraform Cloud can help you to track your changes, and it can help you to collaborate with others on your projects.

How I fixed the mistake:

I fixed this mistake by starting to use Terraform Cloud. I created a Terraform Cloud account, and I imported my Terraform projects into Terraform Cloud. This made it easier to manage my projects, and it made it easier to collaborate with others on my projects.

Here are some of the benefits of using Terraform Cloud:

• Centralized management: Terraform Cloud provides a centralized location for managing your Terraform projects.
• Collaboration: Terraform Cloud makes it easy to collaborate with others on your Terraform projects.
• Auditing: Terraform Cloud provides auditing features that can help you to track changes to your Terraform projects.

Mistake #4: Not testing my code

Finally, I made the mistake of not testing my code. Testing is important to make sure that your code works as expected. For example, I could have written some unit tests to test the database resources.

How I fixed the mistake:

I fixed this mistake by starting to test my code. I wrote some unit tests to test the database resources, and I also wrote some integration tests to test the entire project. This made me more confident that my code worked as expected, and it made it easier to find and fix bugs.

Here are some of the benefits of testing your code:

• Confidence: Testing your code can give you confidence that your code works as expected.
• Bug fixing: Testing your code can help you to find and fix bugs.
• Documentation: Testing your code can help you to document your code.

Conclusion:

I made a lot of mistakes when I was deploying the IaC project in GCP using Terraform. However, I learned from my mistakes, and I was able to fix them. I hope that this blog post will help you to avoid making the same mistakes that I made.

Here is the link to the full post detailing how I completed this project:https://dev.to/wonder717/deploying-an-infrastructure-as-code-project-in-gcp-using-terraform-25jn

Thanks for reading!

About Me
My name is Wonder; a cloud architect/engineer doubling in AWS and GCP but more inclined to AWS 😉. Excited to embark on this journey with you lot and hopefully we learn from each other so we can grow collectively. Here are my socials;
LinkedIn: https://www.linkedin.com/in/wonder-agudah-784268183
Dev community: https://dev.to/wonder717
GitHub: https://github.com/Wonder717