Terraform Tutorial for Beginners - Azure Certification Training in Kolkata

Are you looking for Terraform Tutorials? Are you beginners in Azure and want to implement Terraform for your Azure Project? You are in right place. Here I am going to discuss how you can implement IaC with Terraform for your Azure Infrastructure Project.

Table of Contents

What is Terraform?

Terraform is a popular Infrastructure as Code (IaC) tool that simplifies the management of cloud infrastructure by automating resource deployment, configuration, and monitoring.

What Is Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) is a software engineering approach that treats infrastructure as if it were code. It is the practice of automating the management and provisioning of infrastructure resources, such as virtual machines, servers, networks, and storage, using software tools and programming languages.

In IaC, infrastructure resources are defined in a configuration file, just like software code, and this file is then used to provision the resources in a consistent and repeatable manner. Changes to the infrastructure are made by editing the configuration file, which can then be applied using the IaC tool.

IaC is beneficial because it enables the automation of infrastructure provisioning and management, which reduces the potential for errors and makes it easier to manage complex infrastructure. It also makes it easier to collaborate on infrastructure changes and allows for easier versioning and tracking of changes. Additionally, IaC allows for more efficient scaling of infrastructure resources and can help reduce costs by automating resource allocation and deallocation.

Terraform is a popular IaC tool that simplifies the management of cloud infrastructure by automating resource deployment, configuration, and monitoring.

Some IaC Tools

Here are some examples of Infrastructure as Code (IaC) tools with short descriptions:

Terraform: A popular IaC tool for cloud infrastructure management, supporting multiple cloud providers.
Ansible: A simple and agentless IaC tool that automates software deployment, configuration management, and orchestration.
Chef: An IaC tool that automates infrastructure management by defining infrastructure as code, using a domain-specific language.
Puppet: An IaC tool that automates the configuration and management of infrastructure resources, supporting multiple platforms and cloud providers.
CloudFormation: An IaC tool from Amazon Web Services that automates the provisioning and management of infrastructure resources on AWS.
SaltStack: An IaC tool that automates infrastructure management using a simple and flexible YAML-based language.
Pulumi: An IaC tool that enables the creation, deployment, and management of cloud infrastructure resources using popular programming languages.

A Brief History of Terraform

In 2011 Mitchell Hashimoto, the co-creator of HashiCorp Terraform posted an article in Tumblr mentioning the need for an opensource, cloud independent IaC solutions. Being un answered over 3 years he decided to solve the problem. In July of 2014, Terraform 0.1, an open source, cloud-agnostic infrastructure as code solution was released. In 2017 first major cloud partnership — with Microsoft was announced.

Terraform was created to address the challenges of managing infrastructure in a cloud-based environment, which can be complex and time-consuming. The tool simplifies infrastructure management by automating the deployment, configuration, and monitoring of cloud resources.

Since its release, Terraform has gained popularity in the DevOps community and has become a standard tool for managing infrastructure resources in a cloud-based environment. It has continued to evolve and improve, with regular updates and enhancements that improve its functionality and usability.

What are the benefits of Terraform?

Multi-Cloud Support: Terraform supports multiple cloud providers such as AWS, Azure, and Google Cloud Platform, allowing for seamless integration and management across different cloud environments.
Infrastructure Versioning: Terraform allows for versioning of infrastructure changes, making it easy to track and manage infrastructure configurations over time.
Automation: Terraform automates infrastructure provisioning and management, saving time and reducing the risk of human error.
Consistency: Terraform ensures consistency in infrastructure configuration, reducing the risk of configuration drift and simplifying infrastructure management.
Modular Architecture: Terraform’s modular architecture allows for easier management of complex infrastructure configurations, making it easier to maintain and update infrastructure resources.
Collaboration: Terraform allows multiple team members to collaborate on infrastructure projects, enabling better communication and faster deployment of infrastructure changes.
Resource Graph: Terraform’s resource graph provides a visual representation of infrastructure resources, making it easy to understand and manage complex infrastructure configurations.
Reusability: Terraform modules can be reused across multiple infrastructure configurations, saving time and reducing duplication of effort.
Scalability: Terraform supports the creation and management of large-scale infrastructure configurations, making it easy to scale infrastructure resources up or down as needed.
Cost Optimization: Terraform can help optimize infrastructure costs by automating resource management and ensuring that resources are only provisioned when needed.

Terraform Lifecycle

The Terraform lifecycle consists of several stages that are followed when managing infrastructure as code. These stages are:

Initialization: The first stage of the lifecycle is initialization, where Terraform is initialized for a specific project or configuration. During this stage, Terraform installs any required plugins and sets up the initial state for the infrastructure configuration. Command: terraform init
Planning: In the planning stage, Terraform analyzes the configuration and generates an execution plan. This plan includes a list of changes that will be made to the infrastructure and any resources that will be created, modified, or deleted. Command: terraform plan
Execution: Once the plan is generated, the execution stage begins, where Terraform applies the changes to the infrastructure. During this stage, Terraform creates new resources, modifies existing resources, and removes resources that are no longer needed. Command: terraform apply
Verification: After the execution stage, Terraform verifies the changes that were made to the infrastructure. This includes checking the status of resources, ensuring that they are in the desired state, and validating any changes made to the infrastructure. Command: terraform show
Destruction: Finally, if the infrastructure is no longer needed, the destruction stage removes all resources created by Terraform. This ensures that there are no residual resources left running, reducing the risk of unnecessary costs or security vulnerabilities. Command: terraform destroy

Terraform Core Concepts

Here are brief descriptions of some key Terraform concepts:

Providers: A provider is a plugin that Terraform uses to interact with a specific infrastructure platform or service, such as AWS, Azure, or GCP. Each provider has its own set of resources and data sources.
Resources: A resource is a declarative representation of an infrastructure object, such as a virtual machine, network interface, or database instance. Terraform uses resources to manage the creation, modification, and deletion of infrastructure objects.
Modules: A module is a collection of Terraform resources and other objects that can be used as a reusable component in different Terraform configurations. Modules enable infrastructure to be abstracted and modularized.
Variables: A variable is a named value that can be used throughout a Terraform configuration. Variables enable dynamic and reusable configurations, as values can be passed in from the command line, environment variables, or other sources.
Outputs: An output is a value that is produced by a Terraform configuration and can be referenced by other configurations or scripts. Outputs enable the sharing of data between different parts of an infrastructure.
State: State is a snapshot of the current infrastructure managed by Terraform. It includes information about resources, such as their current state, metadata, and dependencies. Terraform uses state to determine what changes are necessary and to track the progress of infrastructure updates.
Plans: A plan is a list of changes that Terraform will make to the infrastructure. Plans are generated during the planning phase of the Terraform lifecycle and can be used to preview changes before they are applied to the infrastructure.

Terraform Configuration Files

Terraform configuration files are the heart of Terraform’s infrastructure as code approach. These files describe the desired infrastructure and the resources required to create it. Terraform uses configuration files to plan, apply, and manage infrastructure resources.

Terraform configuration files are written in the HashiCorp Configuration Language (HCL) or JSON. HCL is a simple and human-readable configuration language that enables you to express complex infrastructure as code. HCL files are easy to read, write, and understand, making it accessible to both developers and operations teams.

Terraform configuration files consist of multiple blocks that define different aspects of the infrastructure, including providers, resources, modules, variables, and outputs. These blocks are organized in a logical and modular fashion to enable reuse and maintainability.

Terraform configuration files are designed to be version-controlled and shared, enabling teams to collaborate and review changes before applying them to the infrastructure. This approach ensures that infrastructure changes are consistent, transparent, and easily managed over time.

Brief description of each Terraform Configuration Files

Terraform configuration files consist of several blocks that define various aspects of the infrastructure. Here’s a brief description of each block and its use:

Provider block: The provider block is used to define the cloud platform or service that Terraform will use to create and manage resources. Providers include AWS, Azure, Google Cloud, and many others.
Resource block: The resource block defines the type of infrastructure resource that Terraform will create and manage. Resources can be anything from virtual machines to databases and storage accounts. Each resource block defines the resource type, configuration, and any dependencies.
Module block: The module block enables the reuse of Terraform configurations by creating a standalone set of resources that can be used in multiple environments. Modules can be used to encapsulate complex infrastructure setups, making them easier to manage and reuse.
Data block: The data block enables Terraform to retrieve data from an existing resource, such as a virtual network or database, and use it in a configuration. This enables Terraform to build infrastructure based on existing resources and ensure consistency across environments.
Variable block: The variable block is used to define variables that can be used throughout the configuration files. Variables can be used to pass in values from outside the configuration file or to define values that are reused across multiple resources.
Output block: The output block defines the output values that Terraform will produce after applying the configuration. These values can be used for debugging or to pass data to other systems.

Sample main.tf file to create a Vnet in Azure Cloud

# Define the Azure provider 
terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0.2"
    }
  }

  required_version = ">= 1.1.0"
}

provider "azurerm" {
  features {}
}

# Define variables for the Vnet name and address space
variable "vnet_name" {
  default = "myvnet"
}

variable "vnet_address_space" {
  default = "10.0.0.0/16"
}

# Create the resource group
resource "azurerm_resource_group" "myrg" {
  name     = "my-resource-group"
  location = "eastus2"
}

# Create the virtual network
resource "azurerm_virtual_network" "myvnet" {
  name                = var.vnet_name
  address_space       = [var.vnet_address_space]
  location            = azurerm_resource_group.myrg.location
  resource_group_name = azurerm_resource_group.myrg.name
}

# Create the subnet
resource "azurerm_subnet" "mysubnet" {
  name                 = "my-subnet"
  address_prefixes     = ["10.0.1.0/24"]
  virtual_network_name = azurerm_virtual_network.myvnet.name
  resource_group_name  = azurerm_resource_group.myrg.name
}