HashiCorp Terraform Reviews

The usual use cases for HashiCorp Terraform that I work with mostly include automating tasks such as provisioning resources and creating resources over the clouds. If we want to create an EC2 instance on AWS, we have to log into EC2 and follow specific steps for creating instances. Creating thousands of EC2 instances with the same configuration requires repeating those steps, which can lead to mistakes. But using HashiCorp Terraform helps us by enabling infrastructure as code, allowing us to create infrastructure using code.

We can write simple code, and based on that, we can create multiple instances with a single run of code.

HashiCorp Terraform also supports multi-cloud developments, allowing us to work with AWS, Azure, Google, and Oracle simultaneously. It enables immutable infrastructure, and after HashiCorp Terraform creates resources, a state file is generated that stores metadata, which we can control using version control, allowing us to revert to previous versions if needed.

The most valuable features or capabilities of HashiCorp Terraform include automation, multi-cloud support, version control of state files, environment management, and support for third-party services such as databases and monitoring.

The open-source nature of HashiCorp Terraform is important for accessing community contributions and tools as it is free to use. The community-driven development means there is a large and active community of contributors worldwide. HashiCorp Terraform works with multiple providers such as AWS, Azure, and GCP, and it can also support custom providers, which is a significant advantage.

HashiCorp Terraform could be improved by enhancing security around state files, as it stores sensitive information such as passwords and secrets within them. If someone acquires a state file, they can access those secrets. HashiCorp Terraform should implement better security measures to keep sensitive information hidden from unauthorized users.

I have been working with HashiCorp Terraform for more than three years.

HashiCorp Terraform is stable and reliable as long as we maintain the state file correctly.

HashiCorp Terraform's scalability is straightforward because we can utilize a variable called count to scale our resources easily.

Before HashiCorp Terraform, I did not use a different solution for the same use cases. AWS has a service called CloudFormation that performs similar functions, but it is specific to AWS. However, HashiCorp Terraform is applicable worldwide, and I haven't used anything else, so I don't have experience with other solutions.

I participated in the initial setup and deployment of HashiCorp Terraform. Knowing the requirements is essential for what we need to create using HashiCorp Terraform. If we're beginners, it's necessary to follow HashiCorp's documentation to understand what is needed, allowing us to create Terraform modules and files easily. For me, it isn't a big deal; we just need to gather and analyze the necessary information to proceed.

We have developed one solution using HashiCorp Terraform.

HashiCorp Terraform's state management capabilities are the main key point because whatever HashiCorp Terraform creates is stored in a state. Managing this state file is crucial. We can manage it either locally or remotely, but using local storage can lead to failures, and we might lose our state file.

Best practice is to store it remotely, such as on AWS S3 or Azure storage blobs, and we must maintain versions of the state file. This allows us to revert to previous states in version control if there are issues with the current state.

HashiCorp Terraform's modular architecture is beneficial because I have created a module for EC2 instances. When a team member wants to create an EC2 instance, they can utilize my module without recreating it. This approach follows the DRY principle (do not repeat yourself), achieving simplicity and reducing code repetition.

On a scale of one to ten, I rate HashiCorp Terraform an eight out of ten.

My main use case for HashiCorp Terraform is creating infrastructures for landing zones and resources such as resource groups, virtual networks, subnets, virtual machines, Application Gateways, and load balancers. All of these resources are created by HashiCorp Terraform.

To use HashiCorp Terraform for these resources, I first receive data from the client on what needs to be created, such as a resource group. After that, I need to create a virtual network, and within that virtual network, I need to create a subnet and a virtual machine, alongside Azure Firewall. I use HashiCorp Terraform for writing these configurations via VS Code.

Basically, I use HashiCorp Terraform for creating the infrastructure of landing zones on the Azure portal.

The first best feature of HashiCorp Terraform is the locking feature. HashiCorp Terraform is a multi-cloud platform that supports multiple clouds such as AWS and Azure. HashiCorp Terraform provides a locking feature where if one user is creating any resources on HashiCorp Terraform, another user cannot create any resources on the same infrastructure until the first user completes their work on HashiCorp Terraform.

Apart from that, HashiCorp Terraform provides complete visibility of the code. If I make any error in the code, HashiCorp Terraform indicates that, allowing me to easily debug the error. These kinds of features are unique in HashiCorp Terraform.

HashiCorp Terraform has positively impacted my organization by allowing me to create resources on the Azure portal automatically by writing some code within a few minutes instead of clicking through the Azure portal, which previously took a lot of time. Now I can create all resources in one click within a few seconds or within a few minutes.

If I create one resource on the Azure cloud using the manual click process, it takes around one to two hours. However, via HashiCorp Terraform, it takes around five to ten minutes. This saves a lot of time, and I am only discussing one resource. With HashiCorp Terraform, I can create all resources in one click, which saves around eighty percent of my time.

Some features are lacking in HashiCorp Terraform. When I create any resources, it shows the error but does not specify what the exact error is. If there were a feature that showed the exact error, it would save my time in debugging.

Recently, HashiCorp Terraform changed the registry design. Previously, I found the provider code on the left and in the right top corner, but now it is not showing there, which creates confusion about where I can get the provider code. If it could provide the provider code again on the first page of the registry, it would be helpful for me.

HashiCorp Terraform is stable.

HashiCorp Terraform is scalable.

The customer support for HashiCorp Terraform was very good.

I did not use any other services before HashiCorp Terraform; I solely relied on the manual click process for creating resources. Then HashiCorp Terraform came and changed my approach, making it easier.

I have seen a return on investment because HashiCorp Terraform saves my time and requires fewer employees. When I used the manual click process for creating resources on Azure cloud, it needed more employees. However, with HashiCorp Terraform, fewer employees can create many resources with a single click, saving money in terms of cost reduction and also time.

My advice to others looking into using HashiCorp Terraform is that everyone should use it because it reduces work time and simplifies creating infrastructure easily. HashiCorp Terraform does not require any kind of hard work and is easy to use, so I recommend everyone should use HashiCorp Terraform. I would rate this product an eight out of ten.

My main use case is only to provision the VM. Normally, in previous times, my team and I worked very hard to build the base image, and then we performed manual workload to build a VM template on the vCenter. Each time we needed to provision a VM, it took a long time. My team and I learned about HashiCorp Packer and built the base image template and VM template from HashiCorp Packer, then used HashiCorp Terraform to provision the VM with that template.

Right now, I am provisioning approximately 30 or 40 VMs for non-prod, and we plan to do this in production very soon.

HashiCorp Terraform has changed my workflow significantly because it spends considerably less time compared to my previous approach. I can say that it is 10 times faster than my previous method. HashiCorp Terraform is very helpful.

HashiCorp Terraform offers the ability to use modules, and we separated one central module so we can differentiate between non-prod and production environments. We try to do something idempotent with HashiCorp Terraform, similar to Ansible. We want to make sure that each environment is clean and not mixed together.

HashiCorp Terraform makes it very easy to manage non-prod and production across different environments.

Currently, there is not much to add. However, something that could improve the experience is bridging the gap between applying HashiCorp Terraform on the vCenter and applying it on cloud-based solutions like AWS. Since I tried HashiCorp Terraform on vCenter, I noticed a difference between cloud and on-premise implementations because I have to manage the datastore cluster from vCenter. When running Terraform plan, we have to read it carefully before applying. Initially, I did not know much about vCenter, but after trying HashiCorp Terraform, I realized that the datastore should also have a cluster. When applying HashiCorp Terraform, I need to ensure I am not sticking to separate datastores but rather keeping them in the same datastore cluster. HashiCorp Terraform taught me a lot about vCenter infrastructure. Before using it, I never knew we had datastore clusters.

HashiCorp Terraform provides another benefit in managing infrastructure at scale. For example, I have a group of Kubernetes clusters with three masters and three workers. If I want to add one more worker node, I can use HashiCorp Terraform to deploy the VM, and then Ansible takes action to join the worker to the cluster. This approach spends considerably less time than before.

I started using HashiCorp Terraform on my new project approximately one year ago.

HashiCorp Terraform is stable in my experience. Stability depends on understanding how HashiCorp Terraform state works.

We manage HashiCorp Terraform state very well. I do not store it locally. We manage HashiCorp Terraform state through S3, which works well as long as we know how to manage it properly.

HashiCorp Terraform's scalability can handle larger environments easily and can handle large environments.

For large scale infrastructure at the VM or networking level, HashiCorp Terraform is the best choice and the first option to use.

I am an end user, and my company does not have a business relationship with the vendor other than being a customer. I am not a partner or reseller.

Because I have used the community version, I have never reached out to them for customer support.

The HashiCorp website is really useful. I always go to the HashiCorp website to learn about HashiCorp products. There are helpful guidelines on the HashiCorp website.

I did not evaluate other options. I only know HashiCorp Terraform.

I would rate HashiCorp Terraform an eight out of ten because I still need some time to understand HashiCorp Terraform in depth.

HashiCorp Terraform is deployed in an on-premise setup.

I have not seen a return on investment yet. However, HashiCorp Terraform is very fast. In my previous solution, we did everything manually. When creating a VM base image template, I needed significant time to download an ISO image from an official OS source like Ubuntu and then perform manual workload. We spent most of the time on manual processes. HashiCorp Terraform helps us a lot. We work together with Packer for this process. In previous times, when creating a VM, I had to import the VM template to create the VM from the template in vCenter, assign the VLAN, and configure the IP manually. With HashiCorp Terraform, we automate everything, and the results are perfect.

I have never experienced pricing, setup cost, or licensing for HashiCorp Terraform.

I believe we should consider organizing code in a more structured way. I think that for now, I am not as experienced with HashiCorp Terraform as I am with other technologies, but from my experience, we rely on the .tf file. I try to do something like import the .tf file inside the directory. We should have something like a database VM part, Kubernetes cluster VM part, and any other VM part inside different directories, and then we should have one file that includes all of those directories into the main file.

HashiCorp Terraform is good and very fast for provisioning infrastructure environments, but it should be stable only if we know how to manage HashiCorp Terraform state. If other people want to try HashiCorp Terraform in a safe way, they should understand how HashiCorp Terraform state works. That is my advice.

I would rate this product an eight out of ten.

My main use case for HashiCorp Terraform is to provision infrastructure on AWS cloud. This is the main goal of my using Terraform.

I have completed multiple projects using HashiCorp Terraform for AWS infrastructure. One project is mostly related to bank infrastructure, which involved a multi-account setup, including VPC, shared resources within the shared account such as transit gateway, networking, and the compute was done on EKS, EC2, and some storage resources such as RDS, S3, EBS volumes, and encryption. I used KMS keys for security, adding more security using security groups, NACLs, and network firewall. There were many resources that I provisioned using Terraform for that project.

Those are mostly my use cases that are related to AWS infrastructure provisioning using HashiCorp Terraform.

HashiCorp Terraform offers excellent features that have greatly improved my experience. Every time I use Terraform, it makes my daily routine work easy since even a small change on multiple accounts can take much longer to do manually. Using Terraform, I can change four or five lines of code and it is all done. This saves my time and hard work, significantly improving my experience.

Infrastructure as Code is the most important feature that saves me the most time and makes my workflow smoother. State management is also an important aspect of this. I have used saving states on AWS cloud, so it was easily managed and properly used for my team.

HashiCorp Terraform has positively impacted my organization because we have standard code which we are using for multiple customers. This serves as our baseline. Most customers are using the same thing, so it saves a lot of time and effort. It makes things faster because we just need to make a few changes that are different for every customer. This is very helpful in bringing us revenue and helping us to be more productive in our work.

For example, if we had no baseline code for HashiCorp Terraform, provisioning every resource for very big projects, such as the bank project I completed, could take months of manual work, which could also have the possibility of errors due to human nature. Using Terraform, we saved those months of time and completed it within about a week. This has helped tremendously. We have a baseline now for the majority of use cases, and with little changes that can be done within hours or days, we can complete work that could take months if done manually.

There can be improvements in HashiCorp Terraform. There are times when a small error can ruin very valuable resources. In that case, exception handling in development can improve the overall Terraform productivity.

The documentation for HashiCorp Terraform is one of the best, and I appreciated it. However, there can be improvements for when Terraform destroy can destroy useful and very important resources such as databases. In those critical places, there should be a special prompt that informs the user so that the user can double-check what they are going to do with Terraform plan. That can be a technical improvement. Other than that, documentation is comprehensive and easy to understand.

Since the beginning of my career, I have been using HashiCorp Terraform, starting as a trainer and then working in a production-level environment. Overall, I have been using this tool for four and a half years.

HashiCorp Terraform is stable in my experience.

I would rate HashiCorp Terraform's scalability positively because it covers most of the resources that I use daily in my work, specifically on AWS cloud. It has most of the resources covered, so I would say it is good at scaling.

Before using HashiCorp Terraform, I had my own scripts using Python and shell, but those were not in a productivity sense in competition with Terraform. Terraform is much easier to use and much faster, allowing me to deploy using Terraform. The custom scripts were highly dependent on future changes.

I am aware of Ansible, but I have never used it for provisioning infrastructure. I have used it for configuration management on the provisioned infrastructure.

I used the free version of HashiCorp Terraform with no setup cost or licensing needed.

I have seen a return on investment with HashiCorp Terraform. It saved us a lot of time. However, I used the free version and did not go with the licensing or the paid version.

I used the free version of HashiCorp Terraform with no setup cost or licensing needed.

I am aware of Ansible, but I have never used it for provisioning infrastructure. I have used it for configuration management on the provisioned infrastructure.

I would advise others looking into using HashiCorp Terraform to review its documentation and understand how the inputs and outputs are interlinked, and how the use of Terraform can be compatible with the use cases.

I am very satisfied with HashiCorp Terraform. I would give this product a rating of nine out of ten.

I started my journey with HashiCorp Terraform in 2023 at Toolbox Tech, coming from a background with no prior experience in cloud or infrastructure. After going through a DevOps learning path focused on GCP, I was able to quickly get up to speed. My first major project involved using Terraform to build and integrate a platform for AutoAvaliar, a Brazilian company that connects vehicle sellers to buyers.

Over the last 12 months, my work has spanned both Google Cloud Platform and Microsoft Azure. Terraform has been the cornerstone of my workflow in both environments. The difference it makes is night and day. Before, deploying infrastructure meant navigating the cloud console, a tedious process of 'click, wait, click, wait.' Now, we define and deploy complex infrastructure entirely through code, which is repeatable, version-controlled, and incredibly fast.

I work at Toolbox Tech, where we provide services to clients like Embracon and AutoAvaliar. Terraform is essential in all this work, allowing us to rapidly provision infrastructure for our internal projects and for our clients.

For example, I recently worked on a project integrating Azure Kubernetes Service with Azure Key Vault. I noticed the team was creating all their key vaults manually through the console. I built a GitHub Actions pipeline that automates the entire process. Now, creating a new Key Vault is as simple as adding a configuration file to a GitHub repository, which has been a huge time-saver for them.

Similarly, in GCP, I have developed a comprehensive suite of standardized Terraform modules for a wide array of services, including Cloud Run, App Engine, Firestore, and Cloud SQL. This empowers developers: instead of manually setting up their services, they can now use a CI/CD pipeline. Once their application code is ready, the pipeline uses our Terraform modules to provision the necessary services and automatically deploy the app to production.

Ultimately, HashiCorp Terraform is an essential tool for us. It empowers us to accelerate our development cycles, reduce manual errors, and create robust, standardized infrastructure across multiple cloud providers.

Terraform has fundamentally improved our organization by:

1. Accelerating Delivery: We now deploy infrastructure in minutes, not hours.
2. Reducing Errors: Automating with code eliminates manual configuration mistakes.
3. Improving Security: We centrally manage infrastructure and avoid sharing sensitive cloud credentials.
4. Controlling Costs: The state file gives us a clear view of all provisioned resources, helping us eliminate waste.
5. Standardizing Deployments: Reusable modules ensure consistency and best practices.

The three most valuable features for me are the state file, reusable modules, and the simplicity of HCL.

1. The State File: This is Terraform's core strength. It acts as a single source of truth for our infrastructure, allowing us to track every resource, plan changes safely, and detect any manual modifications. Before Terraform, we lacked visibility into who was creating what, leading to higher costs. Now, with the state file, we have full control and can easily remove unused resources.

2. Reusable Modules: The ability to create and share modules is a game-changer. At Toolbox Tech, we build our own modules to enforce standards and encapsulate complexity. This allows developers to provision complex infrastructure, like a full CI/CD pipeline that deploys to Cloud Run and sets up New Relic alerts, without needing to be Terraform experts themselves. The public Terraform Registry is also a fantastic resource for getting started quickly.

3. HCL (HashiCorp Configuration Language): The syntax is declarative and very easy to read, making it simple for new team members to learn and contribute. It's much more approachable than using a general-purpose programming language for infrastructure. 

A built-in feature to generate a visual diagram or graph of the infrastructure directly from the state file would be incredibly valuable. This would allow teams to easily visualize all deployed resources and their dependencies without relying on third-party tools.

I have been using the solution for three years.

For anyone starting with Terraform, my advice is to invest time in learning the core concepts, as the official documentation is excellent and primarily in English. Also, while AI tools can help generate boilerplate code, they don't replace a solid understanding of how Terraform works, especially regarding state management. Always review AI-generated code carefully before applying it to your infrastructure.

At Remessa, we use HashiCorp Terraform for everything involving infrastructure. We use HashiCorp Terraform to manage our repository on GitHub, to manage permissions, invitations, and teams. We use HashiCorp Terraform to manage our AWS infrastructure, DNS, policies on Cloudflare. We use HashiCorp Terraform to manage our alerts on PagerDuty, and we set up some things on Grafana with other services.

We use GitOps, so when we need to make changes such as upgrading our databases when a new Postgres version is released, we can see the version of each database that worked, allowing us to manage the process effectively. We can see in the state that our main database will be upgraded immediately. We can prevent breaks or issues because of the states, which allows us to schedule a window time for upgrades when needed.

HashiCorp Terraform operates on a declarative rather than imperative approach. This enables us to repeat processes and creation, which is the greatest advantage because we can test. If something doesn't work, we can do a rollback or change everything, and using Git, we have the history of every change. We can pick a change in the history tree to discuss and see what changed.

Our infrastructure has a repository with HashiCorp Terraform, and we have modules for that. The benefit is the concept of not repeating yourself, so we have an instance that we can use to create a new instance or cluster as quickly and correctly as possible. Everything works the same way. We don't have servers running on different systems such as Ubuntu, Red Hat, or Debian. Everything is uniform, so we don't need to think about different ways to create, manage, or access. The benefit of this uniformity is significant.

We utilize HashiCorp Terraform's state management capabilities.

Two aspects of HashiCorp Terraform could be improved: it should have better included tests and a more precise validator. I have faced issues where I needed to create something in a particular way and wanted to validate if everything was working properly, but the validator is not a strong point of HashiCorp Terraform.

Using HashiCorp Terraform Cloud is straightforward, but using other backends such as AWS S3 or Oracle Object Store is not as straightforward. Working with modules can be complex. However, when using HashiCorp Terraform's modules, you're typically a more advanced user, so this complexity isn't problematic.

I have been working with HashiCorp Terraform for five years.

HashiCorp Terraform is extremely stable. I faced an issue once in five years where the way I declared the resource was correct, but I had problems with the binary. When I investigated the problem, the community had created an issue, and they released patches the next day. It has been totally stable with only one minor issue in five years.

Given it's in the cloud, HashiCorp Terraform is very much scalable.

When HashiCorp Terraform changed their license version, I considered migrating to another similar tool. However, after understanding the changes, I decided to continue using it since it remained open source, with restrictions only for HashiCorp competitors. This was crucial for me as I only work with open-source solutions.

All my colleagues in the company shared the same concern, and we studied migrating from HashiCorp Terraform because of the license change. I have experience with alternatives such as Crossplane, which I studied once and wanted to test. There is also OpenTofu, a fork of HashiCorp Terraform, which I tested a few times.

I continue using HashiCorp Terraform because the HashiCorp Language (HCL) is excellent to work with. The syntax is clear, and we have numerous resources and examples. Usually, I can find examples of what I want to create from other users' implementations. The benefits are the language, syntax, agility, and velocity. HashiCorp Terraform works effectively even with complex infrastructures.

To others considering HashiCorp Terraform, planning the infrastructure is key, including drawing out the idea. Using HashiCorp Terraform is straightforward, but migrating everything to modules or reworking on HashiCorp Terraform can be complicated and overwhelming. Think thoroughly before implementation, but don't hesitate to try it. All necessary information is available online, and the community is excellent.

On a scale of one to ten, I would rate HashiCorp Terraform as a solution nine out of ten.

I use it to deploy our Kubernetes clusters and Boomi as well. I can run Boomi by itself and not worry about Terraform and Kubernetes, and that's okay. 

However, my use case requires me to run it in a cluster environment to scale up and scale down accordingly and manage costs. This is why I chose Kubernetes. Although it's possible to manually roll it out, I have security requirements to consider for a secure environment. To make it repeatable, I use Bicep or Terraform, as I'm mostly running in Azure. 

I decided on Terraform to manage deployments across multiple environments. This includes a dev environment, a QA environment, and now a production environment. I test and then run Terraform to deploy these environments. In AI, it's more about setting up your environment. 

I develop AI-based products and use Terraform to create a consistent and secure environment in Azure. Once deployed, I get a security score from Azure and receive recommendations for improvements. If a resource is noncompliant under SOC 2, type one or two, ISO, or HIPAA, I make the changes in Terraform, redeploy, and observe score improvements. Terraform aids in ensuring my deployments are correctly configured across environments.

The most valuable feature is predictability. When I need to put something, it is repeatable. I can deploy it in one environment, change the parameter, and it will work in another. If changes are needed, I track who did what because my Terraform scripts are version-controlled. This reduces guesswork and trial and error from the UI, replacing it with code, which enhances maintainability. In cloud environments, manual configurations can be forgotten or misunderstood if the original person leaves, but Terraform ensures documentation and consistent configurations.

The area for improvement is the speed at which resources become available. When a new resource is introduced in AWS or Azure, especially since I work mostly in Azure, how quickly can it be integrated into my Terraform scripts ensuring rapid availability of resources is crucial.

I have used the solution for two to three years now.

The solution is stable because I can define which version I want to use. I am not at the mercy of the latest version. I can choose a stable version and decide whether to upgrade based on its performance.

The solution scales well. Terraform runs only when our pipelines run and parallelizes resource creation/updates whenever possible.

The setup is straightforward, but mastering it may take a day or two. Maintenance requires significant expertise. The challenge lies in understanding the environments being created, not Terraform itself.

I am using the free version. The paid version is necessary when you run it and manage it in the environment, however, I only use Terraform runtimes. The documentation is excellent, and understanding how to read it is crucial. 

Once I understand the different concepts of Terraform, it becomes straightforward, allowing for further capabilities. A major challenge was applying Terraform to existing resources, yet now the new import method is much improved. 

My product rating is eight out of ten.

We primarily use HashiCorp Terraform for our infrastructure deployments and cloud deployments. As a cloud architect and infra DevOps architect, we use HashiCorp Terraform to deploy our code, builds, and set up CI/CD pipelines. We create Terraform code and deploy it through Terraform Enterprise.

Regarding state management and orchestration capabilities of HashiCorp Terraform's impact on our workflows, we had two different environments. Initially, we used Jenkins for our CI/CD pipelines. Because we primarily work on Azure, we use remote state files for Azure deployments. Jenkins runs the HashiCorp Terraform code, and then the state file gets saved in our Azure storage as a remote location. Whenever we require that state file, we can retrieve it from there.

At a later stage, we enhanced the environment by setting up Terraform Enterprise in our environment. Currently, we have it within our environment. We set up Terraform Enterprise with HashiCorp's license. We create modules from HashiCorp Terraform using the Azure ARM provider, and then we set up those modules to apply Azure best practices. We provide this to the development team and other teams so they can reuse these modules and deploy secure codes. We also manage upgrades and the complete lifecycle of TFE, and we provide these services to our other teams.

One of the major benefits of HashiCorp Terraform is that it is platform-agnostic because it supports multiple cloud platforms. This is the biggest advantage.

The state file is one of the key features of HashiCorp Terraform that helps us because whenever there is a drift, it actually helps us identify those and reset the environment to the actual desired state.

From our environment, we have enabled the health monitoring and drift detection features in HashiCorp Terraform. These have been really useful for our environment. It helps us where we do not have HashiCorp Terraform code for the environments and get that created, and whenever there is a manual change, we get to know that.

One issue we have faced with HashiCorp Terraform is that sometimes the latest features that Microsoft suggests are added in their services take some time for HashiCorp Terraform to get enhanced. Sometimes there is that lag where we want some service or configuration which is not yet enabled in the HashiCorp Terraform module.

The initial setup process for HashiCorp Terraform was fine and possible without major challenges. However, currently, our organization helps set up governance and policies, including those related to the OS. There is a challenge where our organization is recommending a specific OS, which is currently not supported by HashiCorp Terraform.

I have been working with HashiCorp Terraform for the last 10 years.

Since it is based on Azure, HashiCorp Terraform is highly scalable.

From the maintenance point of view, it is not difficult to maintain HashiCorp Terraform because primarily all those resources or the infrastructure we set up in Azure, and we have the high availability setup. From that perspective, there haven't been major challenges.

In terms of the stability and reliability of HashiCorp Terraform, I have not had any performance issues with it. There was only one challenge when we installed one of the patches in HashiCorp Terraform, and we lost some database. That was one challenge, which was not a known issue. Later, they identified that there was one defect in that code. Apart from that, there have been no challenges.

Since it is based on Azure, HashiCorp Terraform is highly scalable.

Whenever we face any issues, we escalate it to HashiCorp technical support, and we get that support. We have regular interaction with them. I would rate the HashiCorp technical support an eight on a scale of one to ten, where ten is the best.

Positive

From a configuration management perspective, we have used Jenkins and SCCM. My experience is limited to that, but some of my team members have used Ansible and others as well.

The major benefit of HashiCorp Terraform in comparison to Jenkins and SCCM is that these are only configuration management tools, but HashiCorp Terraform is a language where you can deploy those, and you provide those providers for different cloud environments. This gives it a tactical advantage. It deals with having a seat, or it always helps having a lesser technical landscape. We don't have to have additional tools or any other feature to develop that IaC code as well.

When we did the POC and wanted to set up our production environment, it took us around three to four months. Now that we have set up that pipeline for the upgrades, it doesn't take us that long. For the production deployment, currently, it takes us around two weeks, excluding the testing, the stage deployment, development, and deployment.

We have not calculated the measurable benefits recently from using HashiCorp Terraform. On a high level, I would say it has improved our overall environment, speed, and excellence by approximately 20%.

I can provide feedback regarding my experience working with HashiCorp Terraform. We haven't found any major challenges with the integration of HashiCorp Terraform. Frankly speaking, we haven't explored it completely, but for our requirements, it has been working fine.

I have not had any AI-driven projects or AI-driven tasks, nor have I utilized any AI within HashiCorp Terraform yet. I might not be the right person regarding the HashiCorp Terraform licensing part because I haven't been involved from the costing perspective.

Based on my experience, I would recommend HashiCorp Terraform to others, majorly because of the advantages of being platform-agnostic and all those other features. My overall rating for HashiCorp Terraform is eight out of ten.

The primary use case for Terraform is the deployment of infrastructure as a code, creating pipelines, and deploying scripts for services like VPC, EC2, and other AWS services. I also use Terraform for managing multi-cloud environments, easily connecting with services like AWS, Azure, and GCP.

The most valuable feature of Terraform is its ability to easily connect and manage various cloud services, such as AWS, Azure and GCP. I appreciate that with just a few commands, Terraform can deploy tools into the server, which simplifies the process significantly. 

Additionally, the support for YAML and Bash scripts allows for straightforward deployment. Terraform's infrastructure as a code tool facilitates deploying code on tools, and once configured with AWS and local Terraform systems, it can be reused multiple times without much issue.

When connecting to services on a hybrid cloud, I sometimes face issues with understanding usernames or passwords, leading to loss of connectivity. User education could improve this.

I have been using Terraform for approximately three years.

Once the configuration is set, there are generally no significant stability issues. Terraform runs smoothly.

Scalability is effective, and I would rate it a ten out of ten.

I have not faced any significant issues that required me to contact support, however, they provide mail IDs, a portal, and contact numbers for assistance. I would rate it nine out of ten.

Positive

I used Ansible before using Terraform. Currently, I prefer Terraform for its ease of use, though Ansible is also very efficient with few commands.

The initial setup is straightforward, using YAML and Bash scripts for creating infrastructure, which can then be easily deployed using tools like Visual Studio Code.

I use the open-source version of Terraform, so there is no cost for me. There is a paid version available for clients who require premium features such as security and compliance.

I have worked with Ansible, which is also effective for connecting to servers and services with minimal commands.

On a scale of one to ten, I rate Terraform a ten. 

Ansible is also highly effective when minimal command usage is required.

It is a useful configuration management solution. DevOps practices are a main tool for infrastructure as a code.

Cross-platform and many third-party providers could work with another product to manage via Terraform. It's easy to create a deployment solution. You can use various CI/CD tools, such as GitHub Actions or GitLab CI. Configuring these tools is straightforward and highly customizable.

They perform better with their commercial product, Terraform Cloud. Everything in the free product is already available in a comparable solution.

I have been using HashiCorp Terraform for over five years.

The solution is stable.

I rate the solution’s stability a nine out of ten.

I rate the solution’s scalability a seven out of ten.

Some responses are very long, and some needed features take a lot of time.

Neutral

I have used Ansible.

It takes around 30 minutes to deploy completely.

I rate the initial setup an eight out of ten, where one is difficult, and ten is easy.

It is less time-consuming.

We use the free tier of the solution.

I recommend the solution because it's easier to write the code and manage.

Overall, I rate the solution an eight to nine out of ten.