Using Terraform To Manage Infrastructure Resources
Tags: terraform, devops, cloud
Published: 2022-11-28 04:35:18

DevOps has come a long way, and every organization wants to embrace it. With DevOps becoming mainstream, it has given rise to many tools. Automation has always been an integral part of the DevOps approach. Every DevOps engineer aims to automate mundane tasks and strives for excellence. DevOps engineers have a hunger for automation and an eye for efficiency. They also like acquiring new skills to become more effective at their work. Developers and DevOps engineers are smart people. They want to be the kind of engineers with answers rather than questions. 

Even if we say DevOps is a cultural phenomenon, we need tools to do DevOps. There are so many tools in the market. It can sometimes be overwhelming to pick one tool over the other. One such category of must-know tool for DevOps folks is Infrastructure as Code (IaC) tools. Especially [Terraform](https://www.terraform.io/), as it is already ruling the world of infrastructure automation. Learning how to use tools like Terraform will help you automate your company’s infrastructure setup and provision of resources easily. Keep reading to know why you should learn Terraform, what it is, and our helpful tips for getting started.

## What is Infrastructure as Code (IaC)
DevOps is a bridge that brings software developers and the operations team together to streamline the software development process. With the DevOps culture, companies can build software faster, deliver quickly and respond more rapidly to changing customer needs. Many organisations use Infrastructure as Code (IaC) as one of their essential practices to implement DevOps processes the right way. IaC is an approach to defining, provisioning and managing your required infrastructure in code format. This helps you to cut the effort and the time needed to bring up the infrastructure with manual processes. 

![terraform devops](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k9hgrxtivh8w8y42326k.png)

DevOps and Infrastructure as Code (IaC) have become indispensable for organisations to streamline their software development processes. Both DevOps and IaC help engineers automate manual tasks so they can focus on producing new features instead of spending time on mundane tasks. With the combination of DevOps and IAC, you reduce human errors, enhance collaboration between software developers and IT teams, improve the deployment process, and accelerate software delivery cycles. IAC makes it possible for everyone in your organization to treat physical servers, networks, storage systems, databases and other operational assets as programmable virtual objects. 

Also, let us see how the keyword Infrastructure as Code (IaC)  is performing on Google trends. As you can see, the trend is going up and above.

![IaC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/a3xrhpzcli1ljsdftofd.png)

## What is Terraform
Terraform is an open-source tool for building, modifying, and versioning infrastructure safely and effectively. Basically, it is a tool that helps developers manage the infrastructure. Terraform was developed by HashiCorp in 2012, written in Golang and has constantly been evolving ever since. It is now used in many companies across the world as a way to automate their infrastructure management. Terraform provides a way for developers to avoid using manual scripts, which can be error-prone and difficult to maintain. Terraform makes it possible for developers to describe the desired state of their infrastructure in code format and then apply changes to the environment as needed. Terraform can be easily integrated with all service providers as well as custom in-house solutions. While working with Terraform, you need Terraform configurations written in text files. These text files define what you like to create in terms of infrastructure. These configurations are described in the form of code. 

![Terraform configuration](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ypju2joyqgp277mqyy85.png)
Image source: [O’Reilly](https://www.oreilly.com/content/why-use-terraform/)

For example, with Terraform, you will be able to configure an EC2 instance or an S3 bucket with infrastructure as code concept in just minutes. You don’t require an AWS expert here, if you know Terraform, that should be enough. Not just an instance, you can spin up any large tech stack with the help of Terraform. 

As we discussed above, Terraform uses a configuration file to describe the infrastructure you want to create. This includes things like provider credentials, resource IDs, IP addresses, etc. Once the file is saved, Terraform builds your infrastructure. With this infrastructure, you can launch things like servers, databases, and load balancers. Terraform’s configuration file is composed of three sections: A variable section, a provisioning section, and an output section. The variable section is where you store the information necessary to connect to your infrastructure. The provisioning section contains the instructions to create your infrastructure. The output section is where you can view the progress of your build.

In Terraform, writing modules is an integral part of managing infrastructure. Any Terraform resources configuration where a developer can perform init and apply is a module. These resources are specified in the .tf files. A Terraform module can consist of one or more resource files, i.e .tf files. 
For example, a simple module below outputs "Hello, World Terraform!"

```
terraform {
  required_version = ">= 0.12.26"
}
# website::tag::1:: Very simple Terraform module: that outputs "Hello, World Terraform!"
output "hello_world_terraform" {
  value = "Hello, World Terraform!"
}
```
## Why Terraform? 
You can easily configure your infrastructure when the requirement is significantly less, but what if you like to provision a bunch of virtual machines and load balancers? Do you like repeatedly going to the cloud provider's dashboard to do this? How time-consuming that can be. In such a scenario, the developers waste a lot of time configuring infrastructure instead of writing valuable features. Manually provisioning the infrastructure resources burdens the developers. It also poses some risk of misconfiguration and creates havoc. There was a need for a solution to automate the provisioning of resources without having to do everything manually. 

Now, how about the idea of automating the creation of infrastructure by defining everything in the form of code? How amazing is that? You don't have to configure each required resource manually; all that can happen with a simple tool. 

The [Infrastructure as Code](https://en.wikipedia.org/wiki/Infrastructure_as_code) (IaC) movement started when [AWS introduced CloudFormation](https://aws.amazon.com/about-aws/whats-new/2011/02/25/introducing-aws-cloudformation/) in 2011. Well, CloudFormation was only confined to AWS resources, but there was a need for a cloud-agnostic solution; that is when Hashicorp Terraform was introduced to the world by Mitchell Hashimoto and Armon Dadgar [Source: [Hashicorp](https://www.hashicorp.com/about/origin-story)]. 

Gone are the days when businesses used to have their infrastructure hosted on one cloud provider. It is now the new cloud-native ecosystem where hybrid and multi-cloud have become a must to avoid vendor lock-in and reap the various benefits of these approaches. This is where Terraform shines, as it is a cloud-agnostic tool. Terraform can easily manage hybrid or multi-cloud deployments. Being cloud agnostic, Terraform also provides an immutable infrastructure approach; once deployed, resources will never change. To manage your infrastructure at scale, you need Terraform, or else it is a daunting task to manage and scale infrastructure manually. 

Terraform is a blessing for IT administrators because it helps them to reconfigure infrastructure easily. It also helps them to cut operational costs associated with old approaches to infrastructure configuration. 

## Why Should You Know Terraform?
Let us again go to Google trends to see how Terraform is behaving. Well, even though the trend was always up and above, after 2021, we can see a sudden spike. This image should give a hint to all DevOps engineers and developers why they should learn Terraform. 

![Terraform trend](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lmx6ahj1owmg250uyvp7.png)

DevOps is a culture; it requires not just a set of best practices but also some of the best-in-breed tools to do it correctly. Every organization is now considered a software organization. Sooner or later, they move their workloads from traditional data centres to the cloud. Many have already transitioned themselves into the cloud and reaping the benefits.

Organizations hire DevOps engineers to ensure the software is deployed with speed and at frequent intervals with the help of automation. To automate various tasks and deploy software, these engineers are required to know different concepts and tools. One such highly recommended approach in DeOps is Infrastructure as Code (IaC). However, infrastructure automation is one thing that every organization takes very seriously, which is why engineers who know IaC automation tools like Terraform are in high demand. 

Managing and provisioning infrastructure are not easy tasks. Organizations tend to spend vast amounts of money here. When an unskilled engineer does this job of infrastructure setup and that too in the traditional ways, it becomes a bottleneck for others who work with cloud-native technologies in the organisation. 

Since IaC involves a declarative format and automation, things move up quickly in configuring and provisioning the infrastructure. Hence,  organizations invest heavily in such engineers with skills and know tools like Terraform. 

There are many other benefits to learning how to use Terraform.

### DevOps Tool in Demand
Terraform, being an Infrastructure as Code (IaC) tool, has high demand in the DevOps industry today. DevOps engineers with IaC skills are in high demand. It is an added advantage if they know a tool like Terraform. Also, the above shared Google trends chart clearly shows how Terraform is growing. 

### Ease of Use
With the help of a simple configuration file, engineers can create and manage a scalable infrastructure with little to no experience. This can be helpful for individuals in different roles, including DevOps engineers, developers, and architects. Developers like tools that are simple to use and set up. In addition, terraform has a less learning curve, which makes it an efficient player in the DevOps market for developers and DevOps engineers to learn this tool. 

### Scalability
Terraform allows you to create an infrastructure that scales with your company. This means you can create a system that can easily be modified for large-scale projects and accommodate changes in resource demand. Scalability is one major challenge when it comes to infrastructure since it involves enormous costs. It is enticing for any developer to learn this tool to contribute to the company's scalable infrastructure. 

### Reusability
Terraform allows you to use its configuration file as a template. You can use the same configuration file whenever you need to create a similar infrastructure. This makes it easy to scale your infrastructure as your business grows. Developers are always in search of such tools that make their lives easier.

### Increased Developer Productivity
Terraform enhances developers' morale since automation takes the key part with simple commands once you define your files. It reduces the burden on developers by helping them create IT infra manually. Many engineers learn this tool to automate their day-to-day tasks.
 
## How to get started with Terraform?
Terraform can be better understood with a simple tutorial. To start with, we have a simple Hello World tutorial. Let us learn Terraform together. 

Install Terraform from the [official website](https://learn.hashicorp.com/tutorials/terraform/install-cli)

Once you install Terraform, verify if installed properly by running the command,
`terraform --version`

Create a simple directory 
`mkdir learn_terraform`

Get inside the directory.
`cd learn_terraform`

Create a simple main.tf file with simple code to demonstrate how Terraform works. 

```
terraform {
  required_version = ">= 0.12.26"
}
# website::tag::1:: Very simple Terraform module: that outputs "Hello, World Terraform!"
output "hello_world_terraform" {
  value = "Hello, World Terraform!"
}
```

The first thing we need to do is to initialize the Terraform with the following command,
`terraform init `

The output you should see is as below,

![Terraform starting](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f9lnxes6p8ic4f63xcum.png)
Let’s validate our Terraform with the command,
`terraform validate` 

Then you should see an output,

![valid Terraform](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k6x4qy9y8dvwkra8lror.png)

Now, apply our plan with the command,
`terraform apply`

The output you should see is,

![Terraform apply](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k3wd8wfaoy6chas9fjpk.png)

The first time, you need to approve when asked to Enter a value. You need to write ‘yes’ as shown above.

The last step is to use the destroy command.
`terraform destroy`

The output will be as below,

![terraform destro](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uzyttwo1x7r034l8ybk7.png)

Now, let’s compare the state before and after the destroy command.

![changed files](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/siyyvwa1sgpmmr38mpj4.png)

You can see the difference easily between the two states compared. 

### Let’s provision an NGINX server using Terraform:
If you update the `main.tf` file with the following code, you will be able to create the nginx container through Docker. [For this, you need Docker Desktop installed on your computer]

```
terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "~> 2.13.0"
    }
  }
}

provider "docker" {}

resource "docker_image" "nginx" {
  name         = "nginx:latest"
  keep_locally = false
}

resource "docker_container" "nginx" {
  image = docker_image.nginx.latest
  name  = "tutorial"
  ports {
    internal = 80
    external = 8000
  }
}
```

In the above file, we are defining the nginx image to be used to create our resource. And the provider is set to Docker. The ports specified are 80 as internal and 8000 as external. Once we initialize and apply the plan with the above file, we should be able to see the nginx container running on the localhost:8000

Let’s initialize with the following command,

`terraform init`

Then the apply command,

`terraform apply`

Open the localhost:8000, and you should see the nginx welcome page.

![Nginx running](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/my2cd52wgzrozy5twfhg.png)

You can stop the container by running the following command,
`terraform destroy`

### Harness and Terraform
![Terraform and Harness Integration](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8qzfxwvsgegbupru06sq.png)

Infrastructure provisioning and automation are of great value for cloud-native applications today. Automating infrastructure provisioning allows your developers to scale up and down on the fly while reaping the cost benefits by saving a lot of manual effort required. With tools like Terraform, IaC becomes a reality, and it becomes more interesting when you integrate this strategy into your deployment pipelines across all environments. With this, you can do end-to-end automation effectively. [Harness](https://app.harness.io/auth/#/signup/?utm_source=internal&utm_medium=social&utm_campaign=community&pavan_dev_terraform_article=replace&utm_term=get-started) lets you use Terraform to provision infrastructure as part of your deployment process. Harness can provision any resource that is supported by a [Terraform provider or plugin](https://www.terraform.io/docs/configuration/providers.html). 

![terraform plan and destroy](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v5d86khqhx6arb0vlmte.png)

You can easily configure plan, apply and destroy steps in your pipeline.

![Terraform steps](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p14bxavijzwud4mip8ev.png)

![different terraform stages and steps](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hp0j8fsok5mxpidn7mwx.png)

#### Conclusion
Terraform enriches DevOps culture through automation. It empowers DevOps professionals to define, provision, and configure cloud resources in the most reliable, consistent, and predictable manner. Applying the Infrastructure as Code (IaC) principles, Terraform lessens the burden on IT professionals. Terraform is a highly recommended DevOps tool and is here to stay. Don't forget to check out Harness' robust Terraform integration by booking your demo today.