Terraform & IaC Bootcamp

Discover Terraform, an open source infrastructure as code tool by HashiCorp, and see how its providers, state management, dry runs, and reusable modules enable cloud-agnostic infrastructure on AWS.

Explore infrastructure as code by writing and managing infrastructure with code, leveraging GitHub and JIRA for documentation, pull-request reviews, and auditability, while using Terraform for scalable deployments with dry runs.

Discover how Terraform remains open source and free, with enterprise options and Terraform Cloud for organization-wide workspaces, state management, and versioning, supported by a large community.

Download the Windows Terraform binary from the releases link, unzip it, and add its folder to your path environment variable. Then run Terraform version to confirm 1.2.4 is installed.

Install Terraform on Mac or Linux by downloading the single binary, unzipping it, moving it to /usr/local/bin, updating PATH, and running Terraform version to confirm 1.2.4 is active.

Create an AWS IAM user with programmatic access, generate an access key and secret key, and configure a credentials profile for Terraform to read state and manage infrastructure.

Learn to use the Terraform core workflow—init, plan, apply, and destroy—via the CLI to provision and manage AWS infrastructure, validate changes, and track state with code and GitHub workflows.

Terraform workflows by inspecting provider and locals files, initializing projects, planning and applying changes, and destroying resources to align AWS EC2 infrastructure with code.

Terraform and IaC code serve as the source of truth for infrastructure, documenting the desired state and preventing drift from manual changes.

Master the init process in Terraform by understanding backend setup, provider plugins, and local state management, and learn when to run init for new projects and modules.

Discover how Terraform plan uses a dry run and execution plan to preview in-place updates, complete updates, or new resource creation, guided by the state file and provider.

Apply permanently commits infrastructure changes by running a plan in the background, comparing code to the current state, updating the state file, and confirming before applying.

Learn how to use Terraform destroy to permanently remove infrastructure and update the state file, with confirmation prompts, planning options, and targeted cleanup of resources.

Explore taint and refresh in Terraform, including taint's deprecation since 0.15, the replace flag for immediate resource recreation, and how refresh checks drift in state file without altering the environment.

Explore how resource addressing uniquely identifies resources in Terraform, enabling targeted plan, apply, or destroy operations, attribute extraction, and dependency management across resources, data sources, locals, and modules.

Master advanced terraform init by understanding reconfigure, upgrade, and migrate state flags, how init caches providers and modules, initializes the state backend, and manages the dependency log.

Master using Terraform plan with the target flag to focus on specific resources and the out flag to save execution plans for reliable apply in automation, while respecting internal dependencies.

Master advanced Terraform apply flags, including target and auto approved, to automate changes and control execution against an execution plan with confidence.

Explore Terraform destroy behavior with target and auto-approve flags, and generate a destroy plan to review interdependencies across resources.

Discover how Terraform providers act as plug-ins that connect Terraform to cloud platforms and tools, exposing resources, enabling multi cloud, and managing provider versions, binaries, and the HashiCorp registry.

Configure terraform providers with the required providers and provider blocks, using the local name, source, and version constraints, set the AWS region to us west, and authenticate with a profile.

Use terraform provider aliases to run resources across multiple regions or accounts by extending the default provider with named aliases, and reference them at the top for readability.

Terraform dependency lock file records the provider version downloaded on the first Terraform init to ensure consistent, shared builds across teams by storing it in the GitHub repository.

Understand Terraform state: the state file maps resources, stores metadata, and enables drift checks and performance; contrast local versus remote state and how S3 remote storage enhances collaboration and security.

Store Terraform state remotely in a centralized S3 backend to enable versioning, state locking with DynamoDB, fine-grained IAM policies, and secure collaboration across teams.

Configure terraform to use remote state in an s3 back end by defining bucket, key, region, in the top-level terraform block, then init and apply to store the state remotely.

Explore how to safely inspect, move, remove, and import resources in Terraform state using state commands, back up and push changes to a remote backend, and avoid resource duplication.

Import resources into the Terraform state to manage infrastructure created manually, using the proper resource address and import syntax to update the state without recreation.

Organize Terraform projects with scalable structures as your infrastructure and team grow, comparing simple, flat, and segmented layouts and their impact on state file, environments, and automation.

Learn to write Terraform code in the HashiCorp Configuration Language, understand resource blocks and inputs, and apply best practices for readable, reusable infrastructure on AWS.

Build a new Terraform project to deploy serverless service that generates a random number with Lambda, stores results in Dynamo DB, and exposes a public API Gateway endpoint in us-west-2.

Initialize a new Terraform project, configure a remote S3 backend, define the AWS provider and region, set up locals with reusable tags, and format files with Terraform fmt.

Learn to create a private S3 bucket with Terraform, upload Lambda code as a zipped artifact using a data source, and manage resource dependencies end-to-end.

Define a Terraform DynamoDB table with pay-per-request mode, a single primary key random ID, and use merge to tag resources, preparing for the upcoming Lambda and API gateway steps.

Create an AWS lambda with Python 3.8, configure an IAM role with S3, DynamoDB, and CloudWatch permissions, and deploy via Terraform to test the API gateway.

Learn how to use Terraform local values to define reusable arguments such as tags, environment, and region, access them via locals, and organize them in a locals file for readability.

Explore Terraform hcl concepts, including arithmetic, comparison, and logical operators, plus string interpolation and conditional expressions. Use count to control resource creation and access built-in functions like merge, max, min.

Create a public api gateway endpoint with Lambda proxy integration using Terraform. Configure permissions, deployment, and outputs, and verify invocation by returning a random number stored in DynamoDB.

Expose resource attributes with terraform outputs stored in the state file for cross-project use, and learn how outputs flow from child modules to the root module via the outputs file.

Explore how Terraform defines resources in code, applies changes to real environments, tracks state, detects drift, and uses lifecycle blocks like create before destroy, prevent destroy, and ignore changes.

Learn how data sources bring values into Terraform, acting as a templating engine to generate JSON policy documents and to pull in state from other projects, including AWS AMI details.

Use count and for_each in Terraform to create multiple resources from a single configuration, using arrays or objects, with dynamic resource addresses and count.index or each.key.

Explore the most common Terraform built-in functions across numeric, string, collection, and file system types; learn practical usage of max, parsing, contains, and lookup for deployment tasks.

Redeploy the same infrastructure across development and production environments in multiple regions, weighing provider alias versus separate project directory for readability and separate state files.

Deploy a production Terraform environment by separating development and production folders, using remote state, and applying region-specific configurations with modules for scalable infrastructure.

Wrap up your Terraform project by deploying resources with data sources and local values, automating a Lambda to S3 via Terraform, and using destroy and apply with auto-approve.

Learn how Terraform modules group resources into reusable packages to enforce best practices, enable tested, adaptable infrastructure, and simplify deployments across networks, apps, and routing.

Explore Terraform module structure, including root and local modules, main.tf, variables.tf, and outputs.tf. Compare general purpose and service-based modules, and see how root modules orchestrate dependencies to build reusable infrastructure.

Explore how Terraform module variables drive dynamic configurations, covering root and child modules, required versus optional inputs, data types, variable blocks, defaults, validations, and attributes like sensitive and nullable.

Learn when to use Terraform variables versus local variables. Use variables for dynamic inputs in modules, and locals to store static values or complex expressions, reducing duplication and improving readability.

Learn to call Terraform modules with the module block, pass arguments, and use module outputs to establish dependencies, while choosing between local and public modules and handling init and versioning.

Explore how Terraform module provider inheritance works, define required providers with version constraints, and pass provider configurations from the root to child modules using aliases and configuration_aliases.

Explore a Terraform module project that creates a VPC with two public and two private subnets across development and production environments, deploys EC2 instances behind a load balancer, using modules.

Set up a Terraform module project by creating a modules directory with VPC, VPC subnets, and compute resources. Establish dev and prod route modules and separate state backends.

Build a Terraform VPC module creating a VPC, optional internet gateway, and public and private routing tables. Expose outputs for VPC ID and routing table IDs for development and production.

Create a Terraform VPC subnets module that generates public and private subnets from a single list of objects. Use for_each to assign CIDR, name, availability zone, and route table associations.

Build a Terraform compute module that provisions two EC2 instances in private subnets behind a public application load balancer, attached to a target group for production deployment.

Explore how to design and use Terraform modules, define root and child modules, manage dependencies, and leverage variables and outputs for scalable, multi-environment infrastructure.

Master Terraform's core workflow, state files, dependencies, and modules, and apply best practices to design scalable infrastructure and readable code within a huge community.

Continue learning TerraForm and Terraform by building your own modules, exploring advanced data types, and evaluating open source tools like TerraForm Docs, Atlantis, Space Lift, and Infocus for cost awareness.