Course Introduction

Welcome to the Terraform on Azure course. I’m Rithin, and I’ll guide you through practical, hands-on lessons that teach you how to design, deploy, and automate Azure infrastructure using Terraform. Manual cloud provisioning quickly becomes error-prone and hard to reproduce — Terraform brings predictability, version control friendliness, and repeatability to your infrastructure workflows. Combining Terraform with Azure is a high-value skill set for engineers, DevOps practitioners, and platform teams. This course follows a learn-by-doing approach: you will write Terraform configurations, run plans and applies, build reusable modules, and wire everything into CI/CD pipelines so you can go from a local workstation to production automation. What you’ll learn

Fundamentals of Infrastructure as Code (IaC) and how Terraform Cloud integrates with your workflow.
Setting up your local environment and authenticating to Azure.
Core Azure resources and concepts that Terraform manages.
HashiCorp Configuration Language (HCL) and providers: AzureRM and AzAPI.
Iteration and logic patterns: count, for_each, expressions, conditionals, locals, dynamic blocks, and built-in functions.
Terraform state: how it works and best practices for storing state remotely in Azure Storage.
Production-ready features: lifecycle meta-arguments, data sources, provisioners, debuggers, and modules.
CI/CD: integrating Terraform with Azure DevOps (pipelines with plan, approvals, and apply).

Overview table — course focus areas

Topic	What you’ll get out of it
Environment setup	Install Terraform and enable CLI autocomplete; authenticate to Azure
Core Terraform	Learn HCL, providers, resources, expressions, state
Modularization	Create reusable modules and define stable interfaces
State management	Remote state with Azure Storage, locking, and security patterns
CI/CD	Build pipelines in Azure DevOps to plan, review, and apply changes

Getting started — install Terraform (Debian/Ubuntu) The examples in this course assume a Debian/Ubuntu environment. Use HashiCorp’s apt repository to install Terraform:

wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install terraform -y

terraform version

terraform -install-autocomplete
exec bash

These commands install Terraform and enable shell autocomplete. If you’re on macOS or Windows, follow the official installation guides for your platform.

Provider and a minimal Azure resource To provision resources in Azure, add the AzureRM provider and create a resource group. Example minimal configuration:

provider "azurerm" {
  features {}
  subscription_id = "1b228746-75fd-46ed-8a6b-6a9066d6d3a3"
}

resource "azurerm_resource_group" "rg" {
  name     = "kodekloud-tf-rg"
  location = "eastus"
}

Do not commit sensitive values (like subscription_id, client secrets, or credentials) into source control. Use environment variables, Azure managed identities, or secrets in your CI/CD provider to keep credentials secure.

Initialize, plan, and apply Workflow summary:

terraform init — installs provider plugins and initializes the working directory.
terraform plan — creates an execution plan.
terraform apply — applies the plan and creates resources.

Example console output for planning and applying:

$ terraform plan
Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply".

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # azurerm_resource_group.rg will be created
  + resource "azurerm_resource_group" "rg" {
      + id       = (known after apply)
      + location = "eastus"
      + name     = "kodekloud-tf-rg"
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only "yes" will be accepted to approve.

Enter a value: yes

$ terraform apply
azurerm_resource_group.rg: Creating...
azurerm_resource_group.rg: Creation complete after 2s [id=/subscriptions/1b228746-75fd-46ed-8a6b-6a9066d6d3a3/resourceGroups/kodekloud-tf-rg]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Iteration, logic, and example network security rule Terraform supports rich iteration and conditional constructs so you can keep code DRY and reusable. The course covers count, for_each, expressions, locals, dynamic blocks, and built-in functions. Example of a network security rule resource in HCL:

resource "azurerm_network_security_rule" "allow_https" {
  name                        = "allow-https"
  priority                    = 200
  direction                   = "Inbound"
  access                      = "Allow"
  protocol                    = "Tcp"
  source_port_range           = "*"
  destination_port_range      = "443"
  source_address_prefix       = "*"
  destination_address_prefix  = "*"
  resource_group_name         = azurerm_resource_group.rg.name
  network_security_group_name = azurerm_network_security_group.nsg.name
}

When you create multiple resource groups with for_each or count, Terraform will plan multiple creates. Example plan summary:

Plan: 6 to add, 0 to change, 0 to destroy.

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply".

Terraform state — the heart of Terraform Terraform maintains a state file that maps your configuration to real-world resources. For single-developer setups, local state is fine; for teams, remote state (Azure Storage with locking) is required. Example snippet from a terraform.tfstate file:

{
  "version": 4,
  "terraform_version": "1.5.7",
  "serial": 1,
  "lineage": "c62f9521-2fc2-a699-211f-e1f306c99896",
  "outputs": {},
  "resources": [
    {
      "mode": "managed",
      "type": "azurerm_storage_account",
      "name": "example",
      "provider": "provider[\"registry.terraform.io/hashicorp/azurerm\"]",
      "instances": [
        {
          "schema_version": 4,
          "attributes": {
            "access_tier": "Hot",
            "account_kind": "StorageV2",
            "account_replication_type": "LRS",
            "account_tier": "Standard",
            "allow_nested_items_to_be_public": true,
            "allowed_copy_scope": "",
            "azure_files_authentication": [],
            "blob_properties": []
          }
        }
      ]
    }
  ]
}

State location comparison

State location	When to use	Considerations
Local file	Single-developer experiments or demos	Simple, but no locking or team collaboration
Azure Storage remote backend	Teams and production	Provides durability and supports state locking via blob leases
Terraform Cloud/Enterprise	Centralized runs, policy enforcement	Offers state, VCS integrations, and remote execution

Production readiness: modules, lifecycle, and outputs Modularization and lifecycle controls are essential for maintainable infrastructure. You will learn to structure code into modules, use lifecycle meta-arguments, and expose outputs. Example outputs and module usage:

output "endpoint" {
  value = module.storage.endpoint
}

module "rg" {
  source = "./modules/resource_group"
  rg     = var.rg_name
  region = var.location
}

module "storage" {
  source  = "./modules/storage_account"
  storage = "stmdostorager56535"
  rg      = module.rg.rg_name
  region  = module.rg.rg_location
  rep     = "LRS"
}

Applying modules produces module-level progress output:

$ terraform apply --auto-approve
module.rg.azurerm_resource_group.main: Still creating... [20s elapsed]
module.rg.azurerm_resource_group.main: Creation complete after 27s [id=/subscriptions/1b228746-75fd-46ed-8a6b-6a9066d6d3a3/resourceGroups/rg-prod]
module.storage.azurerm_storage_account.this: Creating...
module.storage.azurerm_storage_account.this: Still creating... [10s elapsed]
module.storage.azurerm_storage_account.this: Still creating... [20s elapsed]
module.storage.azurerm_storage_account.this: Still creating... [30s elapsed]
module.storage.azurerm_storage_account.this: Still creating... [40s elapsed]
module.storage.azurerm_storage_account.this: Still creating... [50s elapsed]
module.storage.azurerm_storage_account.this: Still creating... [1m0s elapsed]
module.storage.azurerm_storage_account.this: Creation complete after 1m10s [id=/subscriptions/1b228746-75fd-46ed-8a6b-6a9066d6d3a3/providers/Microsoft.Storage/storageAccounts/stmdostorager56535]

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Outputs:
endpoint = "https://stmdostorager56535.blob.core.windows.net/"

CI/CD and pipelines — integrate Terraform with Azure DevOps The course covers adding Terraform to Azure DevOps, creating pipeline YAML for plan and apply stages, handling workspace/state locking, and securing secrets and service connections. You will learn pipeline best practices: separate plan and apply stages, use approval gates, and store sensitive variables securely.

A screenshot of the Azure DevOps "Terraform on Azure" repo file browser showing files like _azure-pipelines.yml, azure-pipelines.yml, main.tf, and README.md. In the bottom-right there's a circular inset of a man speaking.

After completing this course, you’ll be able to:

Design and deploy Azure infrastructure using Terraform.
Move from local experimentation to production-grade pipelines.
Implement secure state management, modular code, and reliable CI/CD workflows.

Community and next steps At KodeKloud we foster a supportive learning community — join the forums to ask questions, share examples, and learn from peers. Ready to master Terraform on Azure? Start the first hands-on lab and create your first resource group. Links and references

Introduction

Infrastructure as Code Fundamentals

Terraform Cloud

Setting up environment

Azure Context for Terraform

HashiCorp Configuration Language

Terraform Providers

Variables

Outputs and Dependencies

Iteration and Logic

Advanced Constructs

Terraform State Fundamentals

Remote State

Terraform Workspaces

Terraform CLI

Lifecycle Meta-Arguments

Data Sources

Provisioners

Debugging Terraform

Terraform Modules

Azure DevOps Integration

Azure Pipelines for Terraform

Course Introduction

Watch Video