Terraform on Azure

Create your first terraform configuration file for Azure by defining a terraform block with the Azure provider and version, guided by the Terraform docs and a Visual Studio Code setup.

Create a new user in Azure ID, sign in via the portal and Azure CLI, and prepare a Terraform deployment context using that user's credentials.

Review the Terraform plan to see what will be deployed, including the resource group. Apply the plan with terraform apply to deploy the resource in Azure.

Deploy an Azure Storage account with Terraform by defining a resource block, choosing account kind and tier, and running plan and apply.

Split your terraform configuration into multiple files to improve readability and maintainability. Place locals in locals.tf, provider config in terraform.tf, and use a main.tf base file.

Learn to create and attach a data disk to an Azure VM with Terraform, using a manage disk resource and plan and apply steps.

Explore how the Terraform state file tracks multiple Azure storage accounts with a single resource block using count and count.index.

Define subnet information as a map of objects variable to supply CIDR blocks for web and app subnets, replacing hard-coded values and retrieving CIDR blocks via each key in main.tf.

Read a local cloud-init file and pass its text content to a Linux VM resource in Terraform on Azure, using a data block with the local_file data source.

Restructure terraform input variables to grant each linux VM its own network interface and public IP, using a machines block and for_each to support multiple subnets and scalable deployment.

Deploy a Linux Azure VM with Terraform in app subnet zero one, assign a public IP, and configure with Ubuntu Server 22.04 and base64 cloud init data.

Use terraform provisioners to copy default.html to the remote linux server with the file provisioner, then move it to /var/www/html via remote-exec, using ssh on port 22 and depends_on.

Deploy the Azure Bastion resource with Terraform, creating a dedicated bastion subnet and a public IP, to securely connect to Windows RDP and Linux SSH via the Azure portal.

Explore using Terraform to provision Azure Web App Service and its underlying infrastructure, with an introduction to the Azure Web App Service, deployment options, and managed vs VM hosting.

Publish a simple dotnet core web app to an Azure web app, using Visual Studio Code with Azure Tools, deploy the code, and prepare to provision the infrastructure with Terraform.

Demonstrates deploying and testing versions in a staging slot, then swapping it with production using a Terraform configuration, including plan and apply steps and slot removal.

Enable and configure azure web app logs with app service logs, including application and web server logging, detailed error messages, stored in azure storage via sas, managed by terraform.

Learn how to deploy another Azure SQL database on the same server using Terraform, organizing environments and servers as maps of objects, and preparing input variables before creation.

Flatten a nested database details structure into a map of objects with database name keys, then deploy two SQL databases on Azure using Terraform with for each and local variables.

Learn how to deploy an Azure web app that pulls code from a GitHub repository, publish it with Terraform, and connect the app to an Azure SQL database.

Build an Azure VM with MySQL installed via Terraform, bootstrapped by cloud-init on Ubuntu; configure the virtual network and security, then access MySQL as root.

Publish the web application to a GitHub repository, using git init, add, commit, branch, and remote origin, then push the MySQL-enabled dotnet app to the main branch.

Learn how to import an existing Azure storage account into your Terraform state by adding a resource block, preparing a plan, and applying with an import block.

Explore Terraform data types, including string, number, bool, list, set, and map, using locals.tf and the Terraform console to access values by index and key.

Explore how the Azure load balancer distributes traffic across backend virtual machines using a frontend IP, backend pool, health probe, and load balancing rules, with Terraform for provisioning.

Learn to build reusable Terraform modules for Azure resources, starting with a resource group module, passing data via input variables, and calling modules from a root module.

Learn to build backend resources with Terraform modules by provisioning public IP addresses and network interfaces across subnets, using count and index to plan, apply, and verify resources.

Build and manage a network security group in Terraform on Azure by defining security rules, converting a list to a set, and attaching the NSG to multiple subnets.

Build and deploy two linux virtual machines on Azure using Terraform modules, passing network interface IDs from the VNet module through outputs, and using cloud init to install nginx.

Build an Azure load balancer with Terraform by creating a reusable module that defines the public IP, front-end IP config, backend pool, health probe, and load balancing rule.

Build two virtual machines behind the azure application gateway with terraform, a video-based and images-based server. Configure network interfaces, data blocks, and for_each deployment; install nginx and verify with curl.

Explore how Terraform modules organize resources, load from the registry with a source and version, and manage data with input variables and outputs, using init upgrade, count, for_each, and depends_on.

Explore monitoring on Azure using Terraform to build an Azure monitoring service setup with alerts and a Log Analytics workspace, including configuring alert rules and action groups.

Define users in Azure AD and grant permissions with role assignments, scoped to subscription, resource group, or resource, using roles like virtual machine contributor and reader.

Apply a minimal Azure landing zone with hub-and-spoke networking, Azure Bastion and Azure Firewall, dedicated application network subnets, and separate resource groups for logging, storage, security, and SQL.

Learn to deploy Azure SQL databases with Terraform: create a db app environment with two SQL servers (engineering and central) and two databases, using modular code and plan-apply workflow.

Deploy an Azure key vault and apply governance with Azure policies at subscription level or resource group level, using a module with for_each to create vaults and pull tenant ID.

Learn to use terraform workspaces to maintain separate state files for dev and prod, switch between workspaces, and dynamically name resources based on the current workspace.

Build a prod environment with Terraform workspaces alongside dev, creating prod workspace to provision a prod virtual network (10.1.0.0/16) in a prod resource group and then destroy resources and workspaces.

Install git on your local machine to manage different versions of your Terraform code, selecting the Windows 64-bit standalone installer and accepting default settings.

Master git branch strategies for multiple developers and environments, including creating a production branch from dev on GitHub and merging feature branches with admin review.

Promote dev changes to the production branch via a pull request, then apply Terraform for the production environment on Azure. Manage multiple state files to separate dev and prod configurations.

Learn to store Terraform state remotely on Azure storage accounts, using backend configuration with separate containers for prod and dev to manage multiple environments.

Organize Terraform on Azure projects using environment-specific folders for dev and production within a single repository, with modules for networking and compute.

Explore HCP Terraform, a managed cloud service that runs Terraform configurations, handles variables, state data, and plan and apply, while connecting to version control and teams.

Learn how to create and manage Terraform workspaces in Terraform Cloud, connect to GitHub, run plan and apply from the UI, and manage per-workspace state for deploying Azure resources.

Manage Terraform on Azure across dev and prod environments with automated plan and apply triggered by Git commits, using workspaces to tag public IPs and update identities.

Deploy a new resource group and an Azure Linux VM (Ubuntu 24.04) in North Europe, then install the Docker engine and run a web server container on port 80.

Create a Docker image from a PHP app, learn to build and run containers, and prepare for deploying on Azure Container Registry and Azure Container Instances, with Kubernetes clustering later.

Log in to the Azure Container Registry with admin credentials, tag the local docker image, push it, and deploy via Azure Container Instance exposing port 80.

Deploy a single Azure container instance with Terraform, pulling a PHP app container image from Azure Container Registry, and configure secure credentials.

Publish your dotnet project to a git-based Azure DevOps repository by initializing a local git repo, committing files, creating a dev branch, and pushing to Azure Repos.

Learn to automate deployment in Azure using Azure DevOps release pipelines, integrating Terraform to provision infrastructure, manage artifacts, and deploy an Azure web app.