HashiCorp Terraform Reviews

HashiCorp Terraform is a system solution that allows for infrastructure to be managed as code. allows for the efficient creation and management of infrastructure by packaging everything together in one package. This includes the networking, security, and encryption for Google Kubernetes Engine (GKE) deployment.

By using HashiCorp Terraform, the infrastructure is all in one place and can be easily tested and checked for security vulnerabilities before deployment.

The valuable features of HashiCorp Terraform are the infrastructure can be written, shared, and collaborated on using code, which speeds up deployment. Additionally, bugs and issues can be fixed in the code and redeployed, making it less risky. It is a more efficient method compared to the traditional approach of writing scripts to set up infrastructure.

The infrastructure is transparent, as it is stored in a source control system, such as Bitbucket, making it easy for all team members to access and review. Furthermore, Terraform enables the creation of a deployment pipeline using tools, such as Atlantis, which automates the process of scanning and deploying the code. This streamlines the deployment process and adds features, such as auditing, risk management, and security scanning to the deployment process. Terraform provides a more organized and secure way of managing infrastructure, compared to the traditional ad-hoc method.

HashiCorp Terraform is an open-source tool that relies on external developers to create plugins to expand its capabilities. However, this approach can be problematic as not all plugins are created by professionals and some may have security vulnerabilities. In the case of GKE, Google has created a solid plugin, but for other services, one must search for plugins on the HashiCorp Terraform registry, which can be hit or miss, as many plugins are created by students or hobbyists, who may not continue to maintain or update them. This model of open-sourced plugins may not be the most reliable or secure way of expanding the tool's capabilities. 

It is possible that when using a plugin with HashiCorp Terraform, there may be security issues or the plugin may become outdated in the future. HashiCorp Terraform only takes responsibility for the infrastructure and code of the program itself, not the plugin. This is a point of concern as it is the responsibility of the user to police and manage the plugins, which can be a significant overhead. Additionally, the solution requires plugins for modules, so without them, Terraform cannot communicate with certain resources.

To improve this, it would be beneficial if HashiCorp Terraform had a system in place where they certify and test the plugins. This would take the burden off of users and reduce the cost of using the solution. The current system relies heavily on open-source plugins which may not be fully developed, lack features, or may not be secure. It is not uncommon for users to have to fork or manage these plugins themselves, which can be a significant undertaking.

The module system in the solution is not the best, as it forces users to rely on third-party developers who may not be qualified from a security or engineering standpoint. This can create a problem for users as they may not have access to all the features they need, and may have to fork or manage the plugins themselves. HashiCorp Terraform, as the creators of this system, should take more responsibility for the management and security of these third-party plugins.

The use of open-source code, such as that used in this solution, can present issues as it may not always be fully supported or maintained by its creators. This publicly traded, multi-billion dollar company, may not want to take full responsibility for the plugins and modules that are created by third parties. This can be problematic for users, as they may have to police the plugins themselves to ensure they are secure and functional. Furthermore, while some companies such as Google may have the resources to create their own Terraform plugin and take responsibility for it, many other companies and developers do not have the same resources and may not take responsibility for maintaining their own plugins. This can lead to a broken system where users may have to pay extra to have broken plugins fixed. Overall, this highlights the need for a better system of support and maintenance for open-source code and plugins.

I have been using HashiCorp Terraform for approximately four years.

The solution is scalable. It is well suited to managing complex cloud environments, such as Google Kubernetes Engine, that require various services and configurations.

HashiCorp Terraform is a cost-effective solution.

HashiCorp Terraform has issues with testing and the modules. Overall, the concept is great. What they did works well. However, the extension to it is not the greatest.

I rate HashiCorp Terraform a seven out of ten.

I use this solution for infrastructure for my projects that are deployed in Google Cloud. I work in EPA systems. 

The solution allows you to have infrastructure-like code which is basically what Terraform has been about. Terraform makes it easier to figure out the kind of problem that has occurred, why, and who was responsible.

Although using an older version, I've found the biggest advantage of Terraform is that it can be used across multiple cloud providers and multiple platforms and it has a simple API. 

The biggest disadvantage of Terraform is its lack of flexibility in common programming languages. It also lacks flexibility in creating some functions like complex expressions to declare random variables, and features that require any programming language. Those issues are because HashiCorp is trying to keep the API as simple as possible. I would like to see some idea of functional programming in Terraform. It would be great if you could process your data and push it back to the model. It would mean a huge improvement in flexibility. 

I've been using this solution for three years. 

The solution is stable and we haven't had any problems in that regard. 

The solution is scalable and we are constantly working on increasing of size of our infrastructure.

The initial setup is a little complex but not very difficult. Implementation time depends on the size of the deployment. Our deployment was carried out in-house. We need at least one person per 50 models of Terraform for implementation. 

We've had a return on our investment because it's decreased the overall ops overhead via the front team.

I am not using a payable Terraform although I'm quite familiar with the price and don't consider it to be expensive. Licensing costs are mid-range. 

I would suggest reading documentation and experimenting with the solution. 

I rate the solution 10 out of 10. 

We have about 50 users.

With Terraform, you don't need to understand the console of your cloud providers. You only need to understand how Terraform works, and you manage your infrastructure tools in Terraform.

In Terraform, there's a file called main.tf, where everything starts. In the main.tf, you need to specify the provider you're using. For example, maybe you want to use GCP, but you don't want to work on GCP. That's where you will list everything you need. It's like a key for you to access GCP. 

Sometimes, it can be challenging to undo. Let's say I'm using the provider here, and you want to use it on your site over there. You have to delete the provider you are using before switching providers. It doesn't sync well. The providers don't sync well. And also the documentation sometimes, they need to work on the documentation of Terraform. They're not concise.

The error logging could be better. Sometimes, when you try to set something on Terraform, it gives you an error, but you don't understand how the error has been logged. 

I started using Terraform two years ago.

Terraform is one of the most stable products HashiCorp provides

Terraform is scalable.

Terraform is an open-source product, so we rely on documentation. I rate the Terraform documentation five out of 10. It should provide more examples about the way you should write some resources or models.

Setting up Terraform is straightforward. You only need to deploy the binary. I rate it 10 out of 10 for ease of setup. 

I rate Terraform seven out of 10. There aren't many products that do what Terraform does. It's easy to use and set up.

We are using HashiCorp Terraform to deploy infrastructure for our customers in Amazon AWS.

Our process has been made more efficient with the use of HashiCorp Terraform. This includes the ability to create deployments while also avoiding errors and misconfigurations. With this solution, we can ensure consistency in the deployment of all our customers.

The state file is the most beneficial aspect of HashiCorp Terraform. It enables the retrieval and utilization of a previous state to build upon. This feature is particularly important since it allows for the identification of changes from the previous state, making the state file a critical component of the process.

When a misconfiguration or drift occurs, fixing the issue can be difficult. For instance, if there is a change in API calls while a script is running, it can be challenging to make corrections. This may require additional review and modifications to the code. I recall an instance where an industry budget creation process was altered, and it took significant time to amend the code. In fact, I had to add five or six different script portions to resolve the issue.

In a future update, it would be beneficial for HashiCorp Terraform to include a code-writing feature. There is the availability of third-party solutions, it would be preferable to have the ability to write code, create a plan, and receive feedback on what will be implemented. It would be great if the generated code was easily readable and viewable, as this would be an exciting addition.

I have been using HashiCorp Terraform for approximately two years.

My advice to others is its crucial to handle key and access management properly because the most convenient method is to add your key to your computer's environment variables. However, this approach is not the most secure way to manage your keys. Therefore, exercise caution in this regard.

I rate HashiCorp Terraform a nine out of ten.

We are using it for infrastructure as code automation. We are running its latest version.

The state backend, automated describe functionality, modular structures, and variablization using templates are most valuable.

The state locking functionality can be improved. In certain situations, we have to force-unlock the state, which sometimes does not work. When that happens, we have to manually go to the state backend and remove that particular state, which is kind of a cumbersome process.

It should also have more functions, more expressions, and support for more products.

I have been using this solution for almost four years.

It has good stability.

It is good in terms of scalability. We have almost 35 to 40 users. We definitely plan to increase its usage.

We did interact with their technical support. It was easy to schedule a call with them. It was also easy to contact their sales team and the support team. It was definitely a good experience.

We had AWS CloudFormation as well as Azure ARM templates.

Its initial setup is quite good and simple. It didn't take more than one and a half hours.

I did it myself. We have four people for its maintenance. We have one admin and three deployers.

They have given it to us at a monthly cost, but it is on a yearly basis.

I would advise others to understand the state backend and how Terraform works. They should also go through functions as well as expressions in the Terraform official documentation.

I would rate HashiCorp Terraform an eight out of ten.

We deliver the platform as a service to businesses. For example, one request for a particular subscription could be in the business domain or non-business domain, whatever it may be, based on the demand, we deliver the customized subscription to them. For each service, we have different constraints. What needs to be delivered in the VNet of Azure, and what needs to be done externally.

The ARM template is very easy to work with, which is a big help to us. At the end of the day, there are a lot of tools that we explore like FollowMe and other solutions, which come in handy.

I personally say it's already simplified. I don't see many areas for improvement because Terraform employs a lot of skilled engineers that put their time and energy into providing a fantastic enterprise-level tool like this. There is not much more to simplify. There are already quite notable features in Terraform and we've already been provided with updates and other features. In short, there are many things which are already in place, so I don't think that we need anything more from Terraform.

I have been using this solution for over six months.

Personally, I haven't really experienced any significant instability issues with Terraform. Once or twice I've noticed log issues, but apart from that, I haven't really experienced any problems. Keep in mind, this is the first platform that we are building using Terraform, so we have yet to come across the version with the initial data. In the future, I may face heat and pressure when I'm doing that, but I am not really sure because I have not done the hands-on work of it.

Technical support is offered by HashiCorp, but we can't call HashiCorp for technical support because we don't currently use the enterprise version. Our products are community-driven and the community support is great.

Considering we started from scratch, the initial setup was pretty straightforward. We didn't have any challenges. We started our platform build from scratch using Terraform.

For maintenance-related issues, we use GitHub to find the solution to any problems we encounter; we simply log an issue and follow-up with them.

Provided your environment requires Terraform and/or you have skilled engineers who can perform the required maintenance, I would definitely recommend this solution. Terraform is not justified for use just anywhere; you need to have an experienced team to limit any issues. You need to have a certain level of training to consume the services in their DevOps Toolbox and then use them properly. I definitely support and recommend Terraform, but what you get out of it depends on the business environment as well as the team members' knowledge in Terraform.

On a scale from one to ten, I would give this solution a rating of seven; strictly because I was uncomfortable using the ARM template earlier. After another six months, I am sure I will give it a rating of 10, but at this point in time in my experience, I say seven, but not because of the tool itself.

We use it to provision cloud infrastructure. We use it to provision all kinds of infrastructure from wherever we want, we Terraform to the cloud.

We provision new infrastructure, we update existing infrastructure with it, we manage our DNS records, and also deploy new applications on Kubernetes. That's the main use, but we use it for all of our infrastructures, so it has a lot of different use cases.

Before we used it, we were writing a lot of scripts to provision infrastructure and there weren't guidelines for anything on how to provision and how our environment will look. Now with Terraform, it's all templated and everyone in my team just uses modules that are templates, modules of Terraform, and all our environments look the same. It doesn't matter if it's dev, if it's QAs, if it's production, it looks the same. It just has different names and different types of machines. We want to pay less in the dev environments and QA but we want to have better performance in production. It's just the variable to change the type of machine that we want to use, but the template remains the same.

We save a lot of time with this solution. It also saves a lot of human errors and the whole team knows how to do the same thing.

The most valuable aspect of this solution is that it's agnostic. It can work with different cloud providers, which we may do in the future, so it benefits us. With not much change, I can deploy the same infrastructure to other cloud providers. Now we work with Azure but we can work with AWS or GCP and with minor changes we can deploy the same applications to other clouds. We can replicate the existing cases with minor changes and it's easily deployed.

It should have a more object-oriented approach like different coding languages.

It's really stable. We have no issues with it.

There are around five or six DevOps engineers who use this solution in my company. It's used on a daily basis. We use it for maybe 20% of our infrastructure, but we intend to use it for 100% all with Terraform.

I haven't needed to contact their technical support. 

We switched to Terraform because we wanted to minimize time and minimize human errors. We wanted to have alignment between all of our environments and really just development is faster.

We went with it because I had a really good experience with it in previous jobs.

The initial setup is straightforward. There are some things you need to understand to know if you want to make more complex templates but it's pretty straightforward. It's really flexible. 

Overall, the deployment takes around 15 minutes. 

It's open-source so it's free. 

My advice to someone considering this solution would be to work with the HashiCorp Best Practices of Terraform, work with Terraform modules, and write templates for everything. 

I would rate Terraform a nine out of ten. 

We use HashiCorp Terraform to set up AWS infrastructure, and sometimes Cloudflare.

It is not exactly a tool for configuration, it is for setting up the development of the infrastructure.

The concept of infrastructure as code is quite intriguing.

We have an infrastructure in our code and a state file where we can verify whether something is changed when it was changed, and who changed it. When we use Terraform, these kinds of things fascinate us.

I often wonder why they don't create a UI. That is something I always consider. I realize CLI is useful, but I prefer to do things in this manner. Why are we opting for CLI? I want to make things easy. I understand that most don't agree with me, but that is what I would prefer.

I don't think that they will agree on this. I am looking for a drag-and-drop or anything that can just generate modules behind the scenes and allow people to quickly accomplish things. 

I am aware that it does not serve the purpose of Terraform, and that too, is an issue. 

We have a purpose for infrastructure as code, and when the code is gone, you are working on UI. Terraform is not a programming language, most things are straightforward; we cannot do. Terraform lacks these features.

I would say the programming language, perhaps using more of a programming language rather than this declarative language, is something I'd want to explore in the future.

I would want to see more programmatic capabilities implemented, such as if, else, and simple to manage things in terms of how I can use some programming functions to assist us to achieve more.

I would like to have programming language-relevant features, to have programming language be the primary way.

I have been using HashiCorp Terraform for three years.

I don't think HashiCorp Terraform is particularly stable. I would rate it a three and a half out of five. However, we are always working on it and making improvements. They had a lot of problems in the past, but today most things are done correctly.

While there are new versions coming in, there are always issues that arise.

It is not about stability, but about version upgrades. They have newer versions and occasionally backward compatibility. It happened a long time ago but is not an issue anymore. I had a bad experience at the beginning, which is why I remember it.

Someone who is just starting, in my opinion, will encounter difficulties. That is why I believe the language should be changed to a programmed language that everyone can comprehend.

The previous version had several difficulties with the state file, including some backward compatibility and parameter changes, but they are now more stable.

I have not encountered any issues with HashiCorp Terraform's scalability.

We are using Terraform to build up infrastructure in order to document our infrastructure more declaratively. That is what Terraform excels at. I never had any problems with scalability, either in terms of improvement or anything else. 

There are some glitches with Terraform servers. When we are initializing, we occasionally encounter an issue; in three years, this has happened to me twice.

We have 20 people in our organization who use this solution, if we add developers we have approximately 60 people.

From inside the cloud services, I am working on EKS Kubernetes, ECS Elastic Containerized Services, and Elasticsearch, which is now known as OpenSearch. I am working on EKS, Kubernetes, ECS, Elastic Containerized Services, as well as Elastic Search, which is now known as Open Search, and Redis ElastiCache, which is a component of MSK Kafka.

These are the tools I am using. Jenkins is used for the CI process, as well as GitHub Action is used for the CI process. 

As previously mentioned for alerts, we use Opsgenie and Grafana for the dashboards and premises. 

Many third-party services, such as NGINX, are used in Kubernetes. We use Cube Metrics for these kinds of activities, such as metrics scraping.

I have worked with Ansible as well, however, if you asked me to compare the two, I would say Terraform is superior to Ansible. I am not going to get into specifics. 

Terraform, is self-explanatory. It knows how to run, if we want to build some infrastructure, it understands where to start, how to start, what the dependencies are, and so on. 

We must occasionally inform Terraform of some dependencies, which is fine. Terraform, on the other hand, already understands the sequence in which it must execute certain infrastructure to build up. Those are the advantages over Ansible.

The disadvantage of Terraform is that, once again, we must use functions to build up variables or something similar, but Terraform's dry notion is not very good.

When I say dry, I mean that you should not repeat the bad code. Other references are being used to handle this. That is something I would want to suggest.

The initial setup is simple. It is not a difficult process to set up.

I would rate the initial setup a four out of five. it is easy.

When a new version is released, it is backward compatible. And I would say that is good in terms of Terraform maintainability. Normally, we don't have to make many changes, and backward compatibility is beneficial.

In terms of maintenance, it does not require a lot of attention.

It's good, I would rate HashiCorp Terraform an eight out of ten.