👋Introduction

HCL, or HashiCorp Configuration Language, plays a pivotal role in the world of Infrastructure as Code (IAC) and is specifically used in conjunction with Terraform, HashiCorp's infrastructure provisioning and management tool.

In this blog, we'll explore the basics of HCL and how it facilitates the creation and configuration of infrastructure resources within Terraform.

📖Understanding HCL Syntax, blocks, parameters, and arguments

📍HCL Syntax

HCL serves as Terraform's language for defining infrastructure as code. It's a user-friendly, easily readable language that enables you to express resources and data sources declaratively.

📍Blocks

In the world of HCL, everything revolves around blocks. Blocks serve as the building blocks (pun intended) for defining resources, variables, data sources, and more. Each block is identified by its type and is enclosed in curly braces {}.

Let's start with a simple example of an AWS EC2 instance block:

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Here, "resource" signifies the block type, and "aws_instance" is the label for this block.

The block's contents, enclosed within curly braces, specify details such as the Amazon Machine Image (AMI) and instance type.

📍Parameters

Variables within Blocks Parameters are essentially variables within blocks. They offer flexibility and reusability by allowing you to define values dynamically. Think of them as placeholders that can assume various values when using the block.

Building on our previous example:

resource "aws_instance" "example" {
  ami           = var.ami_id
  instance_type = var.instance_type
}

In this updated snippet, "var.ami_id" and "var.instance_type" are parameters. Instead of hardcoding values directly, we refer to the variables "ami_id" and "instance_type" This approach makes our code more adaptable.

📍Arguments

Assigning Values to Parameters With parameters in place, we need a way to assign values to them.

Enter arguments. Arguments enable you to provide specific values to parameters within a block.

Take a look at how we assign arguments to our previous block:

module "example" {
  source      = "./modules/ec2"
  ami_id      = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

In this instance, we're using the "module" block to instantiate an EC2 instance from a reusable module located in the "./modules/ec2" directory.

We assign values to parameters "ami_id" and "instance_type" using the equals sign =.

Notice the alignment between parameter names (ami_id and instance_type) and the variable names within the block definition. This alignment is crucial for proper value assignment.

📃Variables, Data Types, and Operators in HCL

📍Defining Variables

Variables play a pivotal role in Terraform configurations, allowing you to define reusable values. In HCL, variables are declared using the "variable" block.

To define a variable, create a "variables.tf" file with the following code:

variable "server_count" {
  type    = number
  default = 3
}

📍Using Variables

To utilize a variable in your Terraform configuration, reference it using the "${var.variable_name}" syntax.

Here's an example demonstrating the use of the "server_count" variable:

resource "aws_instance" "example" {
  count = var.server_count
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

In this case, we create multiple AWS EC2 instances using the "aws_instance" resource.

The "count" attribute is set to "var.server_count," allowing us to create the specified number of instances based on the "server_count" variable.

📃Data Types and Expressions in HCL

HCL supports various data types, including strings, numbers, booleans, lists, and maps.

Expressions enable you to manipulate these data types. Let's delve into an example:

variable "age" {
  type    = number
  default = 30
}

variable "name" {
  type    = string
  default = "John Doe"
}

variable "is_adult" {
  type = bool
  default = var.age >= 18
}

output "greeting" {
  value = "Hello, ${var.name}. You are ${var.age} years old."
}

output "adult_status" {
  value = var.is_adult ? "You are an adult." : "You are not an adult."
}

In this example, we have three variables: "age," "name," and "is_adult".

"Age" is of type number with a default value of 30.

"name" is of type string with a default value of "John Doe."

"is_adult" is of type bool, and its value depends on whether "age" is greater than or equal to 18.

The first output block uses string interpolation to create a greeting that includes the values of "name" and "age."

The second output block employs a conditional expression to display a message based on the "is_adult" variable.

When you run Terraform with this configuration, it will provision the desired number of EC2 instances based on the "server_count" variable and display outputs with the interpolated values.

🖋Writing Terraform Configurations

Now that we've covered the fundamentals of HCL syntax, variables, data types, and expressions, let's dive into writing Terraform configurations using HCL.

Note: Before this, make sure the docker should be installed on your machine.

Now, Create a Docker container using Terraform. So, here first of all create one main.tf file

terraform {
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "3.0.2"
    }
  }
}

provider "docker" {}

resource "docker_image" "nginx" {

  name         = "nginx:latest"
  keep_locally = false
}

resource "docker_container" "nginx_ctr" {

  image = docker_image.nginx.name
  name  = "nginx_container"

  ports {
    internal = 80
    external = 80
  }
}

💻Testing and Debugging

Testing and debugging your Terraform configurations are pivotal steps in the development process. Here are some valuable tips and best practices:

1. Leverage the terraform validate command to check your configuration for syntax errors.

2. Ensure consistency by formatting your configuration using the terraform fmt command.

3. Use the terraform plan command to preview changes before applying them.

4. Employ the terraform apply the command to implement changes in your infrastructure.

5. Employ the terraform state command to view the current state of your infrastructure.

6. Utilize the terraform destroy command to remove resources created by your configuration.

   Finally, Check the output As we can see in the below image container is running and using public IP we can access the nginx page.

   

🌟Conclusion

Terraform is your magical wand for crafting and managing infrastructure through code.

In this blog, we've explored HCL blocks, parameters, and arguments, delved into different resource types, and created configurations for providers like Docker and AWS.

We've also underscored the importance of rigorous testing and debugging to ensure robust infrastructure.

With Terraform, you can relish reproducibility, scalability, and maintainability in your projects.

Equipped with this knowledge, you can confidently embark on crafting your infrastructure blueprints with Terraform.

So, go ahead and unleash the power of Terraform to effortlessly transform your infrastructure!

Remember, practice makes perfect, and the Terraform documentation is your steadfast guide. Happy Terraforming!

May your DevOps journey be filled with exciting discoveries!🎊

Thank you for joining us on this exciting Day 02 of the TerraWeek Challenge. I hope you found the information helpful and insightful✌

Stay tuned for Day 03 as we delve deeper into Terraform and uncover more of its incredible capabilities🌈

So please keep yourself updated with my latest insights and articles on DevOps 🚀 by following me on👇

Hashnode: vishaltoyou.hashcode.dev

LinkedIn: linkedin.com/in/vishalphadnis