Terraform is a platform-agnostic tool that allows you to build, change, and version infrastructure securely and efficiently. Terraform is an open-source tool and a Hashicorp-developed multi-cloud, infrastructure-as-code solution that uses the declarative Hashicorp Configuration Language. It aids in the management of established, well-known service providers such as GCP and AWS and specialized in-house solutions.
Terraform can manage both mainstream cloud service providers and unique in-house solutions. In addition, it collaborates with “providers” to manage external resources (public cloud infrastructure, private cloud infrastructure, software as a service, network appliances, and platform).
Terraform – An Infrastructure as Code Tool or IAC Tool
Since its release, terraform has grown in popularity as the first multi-cloud “Infrastructure as Code” technology. Another reason for its widespread use is the straightforward syntax for ensuring modularity. Terraform, classified as an IAC tool, works by treating and managing infrastructure code in the same way that software code is treated and managed.
How does Terraform work?
Terraform users may define their whole infrastructure using only configuration files and version control. Terraform parses the code and transforms it into an application programming interface or API call to the resource provider when a command to deploy and execute a server, database, or load balancer is delivered. In addition, terraform is open source, meaning developers can always add to its functionality by writing new plugins or compiling different versions of existing ones.
Terraform Core and Terraform Plugins are the two most significant components of Terraform.
The reading and interpolation of resource plan implementations, resource graphs, state management features, and configuration files are handled by Terraform Core. Compiled binaries built in the Go programming language make up Core. In addition, every compiled binary serves as a command-line interface (CLI) for interacting with plugins via remote procedure calls (RPC).
Terraform Plugins are in charge of determining resources for certain Terraform services. This includes establishing trust with infrastructure providers and setting up the libraries used to make API requests. Terraform Plugins are executable binaries written in Go that may be used as a specialized service or a provisioner. (Provisioner plugins are used to run commands against a specific resource.)
Features of Terraform
- Terraform is capable of managing many environments.
- It is pretty simple to manage external service providers.
- To boost failure tolerance, it can manage numerous clouds.
- For speedier development, it uses a Declarative technique.
- It aids in presenting the generated model in a graphical and understandable format.
- Its modular code contributes significantly to consistency, reusability, and collaboration.
Importance of Terraform
- All changes in an environment are tracked in the Terraform state file.
- It provides a fantastic way to bundle and reuse standard code using modules.
- Its modules are similar to scripting or programming languages’ functions or methods.
- State files can also be used as a data source for other Terraform projects.
- It helps to translate HCL code into JSON.
- It make incremental changes to resources.
- It imports current resources to a Terraform state, and
- It provides support for software-defined networking.
- It supports multiple cloud platforms
- It lock modules before applying state changes to assure that only one person can make changes at a time.
Important concepts about Terraform
Providers- Providers are in charge of developing and managing resources. Terraform is built on a plugin architecture. The provider binary will be downloaded and installed using the ‘init’ command. AWS, Azure, Docker, Kubernetes, and others are examples.
Resources- These are small building pieces with one or more infrastructure components, such as a virtual machine, a subnet, or a load balancer. Because the resource name and type server serve as an identification for a specific resource, it must be unique.
Modules- Modules are used as containers for many resources that may be utilized to organize configuration code and make it reusable. At least one module, known as the ‘root’ module, is present in every Terraform configuration.
Input variables- The input variables are used to define your infrastructure’s configuration values. If it needs to be modified, these values can be utilized frequently without recalling every occurrence.
Output Variables- After the infrastructure has been deployed, the output variables are utilized to obtain information about it. These can be used for providing information to the server, such as IP addresses.
Terraform Remote- You can run Terraform in a remote environment with shared access to the state to share infrastructure responsibility. The remote backend’ is the name for this capability.
Important Terraform Commands
Terraform version- This displays the Terraform version currently installed on the system. This might be useful for identifying problems or new methods to work with the current version.
Terraform plan- Generates a plan for executing Terraform. To ensure that the Terraform state is up-to-date, it reads the current state of any pre-existing remote objects. Then, the current state is compared to the previous state, and the differences are calculated.
- A set of change actions is proposed to make the remote objects fit the configuration. The changes will not be implemented as a result of this.
- If this proposal meets your expectations, it can be implemented later.
Terraform fmt- This converts Terraform configuration files to a standard format. Because the canonical format may differ slightly between Terraform versions, this command should be executed on modules after upgraded Terraform.
Terraform providers- These display information about the configuration provider needs in the current working directory.
Terraform validate- This command verifies that a configuration is internally consistent and syntactically correct.
Terraform apply- The actions specified in a Terraform plan are carried out using this command.
Terraform destroy- This command destroys all remote objects handled by a Terraform setup.
Terraform import- Terraform may import infrastructure that already exists. This command enables us to put resources developed through other means under Terraform’s control.
Terraform show- Converts a state or plan file into a human-readable format. This can be used to check a plan to see if the planned operations are as expected or to check the present condition.
Terraform output- The value of an output variable is extracted from the state file by Terraform output. The result will show all of the root module’s outcomes with no further arguments.
Terraform is a fantastic and quickly evolving IaC solution that will undoubtedly boost the productivity of DevOps installations.
Terraform has a lot of advantages for both developers and enterprises. With the ability to interact with all major cloud service providers, this open-source solution can help you streamline your business objectives and take your DevOps projects to the next level of success.
- Terraform
- CloudFormation
- Heat
- Ansible
- SaltStack
- Ansible, Chef and Puppet are configuration management tools which means they are primarily designed to install and manage software on existing servers
- Terraform and CloudFormation are infrastructure orchestration tools which are designed to provision servers and infrastructure themselves.
- Terraform supports multiple platforms - AWS, GCP, Azure etc.
- Terraform has a simple language and a fast learning curve. The syntax is easy to read and understand.
- Terraform is easy to integrate with configuration management tools like Ansible.
- It is easily extensible with plugins.
- It is free.
- How will you authenticate to AWS?
- Which region will the resource be launched in?
- Which resource do you want to launch?
It is important to note that while static credentials in your main file is an easy method and useful as a tutorial or for hobby use it is not considered best practice.
AWS, AZURE, GCP , ALIBABA, IBM, SALESFORCE etc
Deploying AWS EC2 instances with Terraform is one of the easiest ways to build infrastructure as code, and automate the provisioning, deployment and maintenance of resources to EC2 as well as custom solutions. This lab will walk you through the basics of configuring a single instance using a simple configuration file and the Terraform provider.
Prerequisites:
AWS access and secret keys are required to provision resources on AWS cloud.
- Open Visual Code Studio then click on File > Preferences > Extensions then search and install Terraform extension
- Login to AWS console, click on Username on top right corner and go to My Security Credentials
- Click on Access Keys and Create New Key
Step I: Open File Explorer, navigate to Desktop and create a folder terraform_workspace.
Step II: Once folder has been created, open Visual Code Studio and add folder to workspace
Step III: Create a new file main.tf and copy the below code in yellow color
provider "aws" {
access_key = "ACCESS KEY"
secret_key = "SECRET KEY"
region = "us-east-2"
}
resource "aws_instance" "ec2" {
ami = "ami-0a91cd140a1fc148a"
instance_type = "t2.micro"
vpc_security_group_ids = [aws_security_group.ec2_sg.id]
tags = {
Name = "ec2_instance"
}
}
Add the block below in main.tf to output the Private IP, Public IP and EC2 Name after creation. (Note: This is not required)
output "ec2_ip" {
value = [aws_instance.ec2.*.private_ip]
}
output "ec2_ip_public" {
value = [aws_instance.ec2.*.public_ip]
}
output "ec2_name" {
value = [aws_instance.ec2.*.tags.Name]
}
Name = "ec2-dev-sg"
}
Execute the below command
Terraform will perform the actions described above.
Only 'yes' will be accepted to approve.
Enter a value: yes
Apply complete! Resources: 2 added, 0 changed, 0 destroyed.
