Terraform on AWS with SRE & IaC DevOps | Real-World 20 Demos

Install the Terraform CLI on macOS by downloading, unzipping, and moving the binary to /usr/local/bin. Set up AWS CLI and the Terraform plugin for VS Code to write configurations.

install VS Code, the HashiCorp Terraform plugin, and the AWS CLI; download, install, and verify the tools, then configure AWS credentials for Terraform workflows.

Configure AWS credentials for the AWS CLI using IAM access keys, then run aws configure with the key, secret, region us-east-1, and output json to verify by listing S3 buckets.

Install terraform and the AWS CLI on Windows, configure the PATH, verify the installed versions, and set up AWS credentials to support real-world iac workflows.

Discover Linux installation steps for Terraform, with OS-specific guidance for CentOS, Fedora, and Amazon Linux, plus a provided link to install across Linux environments.

Learn the Terraform core workflow using init, validate, plan, apply, and destroy to provision infrastructure and manage resources, including EC2 instances and providers.

Master the basic terraform commands—init, validate, plan, apply, and destroy—and verify default vpc, ami id, region us-east-1, and aws credentials for the ec2 manifest.

Execute terraform core commands to initialize, validate, plan, and apply, provisioning an AWS EC2 instance and then destroy it to verify the lifecycle and provider plugin setup.

Master Terraform language basics, including blocks, top-level blocks, and blocks inside blocks, along with arguments, attributes, meta-arguments, identifiers, and comments in .tf configuration files within the working directory.

Explore Terraform resource arguments and attributes to configure AWS instances and export outputs. Examine meta-arguments like count and depends on, and reference resource attributes as resourcetype.resourcename.attributename.

Understand Terraform top level blocks, including fundamental blocks like settings, provider, and resource blocks, plus variables, data sources, and modules blocks, to master modular infrastructure.

Gain a high-level look at Terraform top-level blocks, including required version and providers, remote backend with Dynamo DB state locking, plus provider, resource, variable, output, locals, data sources, and modules.

Explore the Terraform fundamental blocks—the Terraform block, provider block, and resource block—along with root and child modules, backend, required providers, and provisioners for AWS infrastructure.

Define the Terraform settings block in VS Code, learn the three names for the block, enforce version constraints, and configure required providers and backends for AWS and other providers.

Define the AWS provider in the Terraform settings, including required_providers, and the provider block, download it from the registry, and manage versions while understanding official, verified, and community badges.

Configure the AWS provider block with region us-east-1 and the default profile, then use AWS configure to store credentials in ~/.aws/credentials so Terraform can authenticate.

Master Terraform resources and meta arguments, then create an AWS EC2 instance resource with a hard-coded AMI and instance type, preparing for data sources and user data in subsequent lessons.

Provision an EC2 instance with Terraform on AWS, bootstrap Apache via app one install.sh, serve index and metadata pages, and learn argument references versus attribute references.

Understand Terraform state as the underlying database that maps real-world resources to your configuration and stores remote object identities after apply in terraform.tfstate, with local or remote storage.

Clean up resources and unnecessary files by using terraform plan -destroy and terraform destroy, with optional auto-approve, to terminate the EC2 instance you created.

Explore Terraform input variables, output values, and data sources as you dynamically fetch the latest AWS AMI and launch an EC2 with two security groups, using an existing key pair.

Explore how Terraform input variables parameterize modules, distinguish input, output, and local values, and learn ten ways to pass variables during apply, including var files and environment variables.

Implement input variables in Terraform for AWS region, instance_type, and instance_key_pair, including descriptions, types, defaults, sensitive, and validation, replacing hard coded values with var references.

Define aws_security_group resources in Terraform to create VPC SSH and VPC Web rules, including ingress for port 22, 80, and 443 and default egress with optional tags.

Define an aws_ami data source to fetch the latest Amazon Linux 2 AMI using most_recent with Amazon as owner and filters for name, architecture x86_64, root_device_type ebs, and hvm.

Define the EC2 instance resource in Terraform, pull the AMI id from the AWS AMI data source, and configure instance type, key pair, and security groups for deployment.

Define and export Terraform outputs in C6outputs.tf to print the EC2 public IP and public DNS after apply, and share root and child module outputs via remote state.

Execute terraform init, validate, and plan to provision three AWS resources, then apply to create an EC2 instance using data sources for the AMI, and clean up afterward.

Master Terraform loops, meta arguments like count, and list and map variables to generate and reference multiple EC2 instances using for loops and splat operators.

Implement Terraform outputs for AWS instances using for loops with list and map, plus legacy and generalized splat operators to reveal public DNS.

Execute terraform init validate plan and apply to provision two AWS EC2 instances, while learning for loops, meta arguments, lists and maps, splat operators, comments, and cleanup.

Implement for_each with the AWS availability zones data source to spawn EC2 instances across AZs. Convert the AZ list to a set to satisfy for_each requirements and reference each AZ via each.key.

Implement outputs for AWS instances using for loops with toset and tomap, outputting each instance's public IP and DNS across availability zones, and practice creating and destroying resources.

Build a Terraform utility that uses the aws_ec2_instance_type_offerings data source to list availability zones in us-east-1 where the t3.micro is supported.

Implement a semi-dynamic Terraform data source for AWS EC2 offerings, using far reach across availability zones to generate per-AZ instance type outputs and maps, including outputs v2_1 and v2_2.

Implement a fully dynamic Terraform utility project that lists availability zones, filters out unsupported ones, and exposes the valid zones via outputs using data sources.

Implement a fix for az to instance type checks and refine availability zones handling in Terraform, applying for_each with a set to create us-east-1a, 1b, 1c, 1d instances excluding 1e.

Learn to build a three-tier AWS VPC with web and DB tiers using Terraform. Start manually in the AWS console, then automate with modules, variables, and local values.

Build a VPC manually in the AWS Management Console, creating public and private subnets, an internet gateway, NAT gateway, and route tables, then clean up before Terraform in a lecture.

Explore how to use Terraform modules to provision an aws vpc from the public registry, including root and child modules, inputs, outputs, and module versus resource decisions.

Create a basic aws vpc module using the Terraform vpc module from the public registry, version 2.78.0, configuring name, cidr block, subnets, nat gateway, dns, and tags.

Initialize, validate, plan, and apply Terraform to build a VPC module with public and private subnets and routing across two AZs, highlighting the benefits of public registry modules.

Master Terraform version constraints for providers and modules, using tilde greater-than to auto-update providers while locking public modules to fixed versions to prevent breaks.

Standardize terraform code by organizing VPC modules with generic variables and a generic variables.tf, add local values, and use terraform.tfvars to override defaults for production-grade deployments.

Understand and implement local blocks in Terraform by defining local values to simplify complex expressions, reference variables, and reuse expressions across a module.

Review how the VPC variables, module, and outputs are defined and variabilized to create a cohesive VPC with name conventions, outputs for cross-project Terraform state, and modular reuse.

Learn to provision AWS EC2 instances and security groups in a VPC with Terraform modules, including a bastion host and provisioners like file, remote-exec, and local-exec.

Review VPC tf config files from the 0602 module, run terraform init and apply, and enable app1 Apache setup with security groups and local-exec outputs in the terraform-manifest.

Create a public bastion security group in Terraform using AWS modules, enabling SSH on port 22 from 0.0.0.0/0 and port 80 to private hosts across the VPC.

Define the private security group in Terraform for AWS, open http and ssh within the VPC 10.0.0.0/16, configure outputs for public and private SGs, and upgrade to Terraform registry 5.1.0.

Define and deploy EC2 bastion and private instances with Terraform, using a data source for the latest Amazon Linux AMI, variables, and module-driven configuration in a VPC.

Learn to build a private EC2 module in Terraform, deploying in private subnets with subnet IDs and user data, and use depends_on to wait for VPC and NAT gateway creation.

Upgrade the ec2 instance module to the latest terraform 5.5.0 and switch from instance count to for_each, mapping per-instance subnets with element and tonumber, and update security group references.

Create outputs for ec2 public and private instances, list private IDs and private IPs with for_each, and configure a bastion elastic IP using aws_eip with domain vpc.

Define a null resource with file, remote-exec, and local-exec provisioners; connect via SSH to the bastion EC2 using a private key; and depend on the public IP resource.

Execute and manage file, remote-exec, and local-exec provisioners in Terraform on AWS, using connection blocks and SSH to copy keys, run remote scripts, and log creation and destroy times.

Learn how to apply the depends_on meta-argument to coordinate VPC, NAT gateway, Elastic IP, and EC2 deployments, ensuring user data executes after network resources are ready.

Execute Terraform init, validate, plan, and apply to provision a VPC, security groups, NAT gateway, and private and public EC2 instances, using provisioners and establishing a bastion host.

Execute a real-world Terraform workflow to verify EC2, VPC, and security groups, connect via SSH, test web servers, and destroy resources after validating a three-tier architecture.

Learn to deploy a classic aws load balancer with terraform using the elb module, set security group rules for ports 80 and 81, and test via the dns name.

Configure a classic load balancer in AWS with a Terraform module, a public HTTP security group, two subnets, and an ELB attachment to two EC2 instances.

Define outputs for the AWS classic load balancer in the Terraform module, including elb_id and elb_dns_name, then run init, validate, plan, and apply to test the load balancer.

Apply a new security group ingress rule for port 81 using the Terraform security group module, validate with plan and apply, and test access via the load balancer.

Learn how to set up an AWS application load balancer with Terraform, connect a public-subnet ALB to private-subnet EC2 instances, and implement path-based, host-based, http header, and query-string routing.

Learn to manually build two EC2 instances behind an Application Load Balancer using a target group, health checks, and prep for Terraform.

Create an application load balancer using the Terraform AWS ALB module, specifying name, VPC ID, subnets, security groups, and tags, and inspect the outputs.

Create an application load balancer with a target group and HTTP listener, using health check /app1/index.html, and disable create_attachment while registering EC2 instances via target group attachment with for each.

Create an application load balancer with a http listener and a forward to the mytg1 target group, and define alb outputs (id, arn, dns_name, zone_id, listeners, target_groups) for Terraform deployment.

Execute terraform init, validate, and plan to deploy AWS resources, including a load balancer, target groups, and EC2 instances, verify health checks and UI outputs, then destroy with terraform destroy.

Implement context path-based routing on an application load balancer using Terraform in AWS, provisioning two app EC2s with /app1 and /app2 routes, AWS Certificate Manager, and Route 53 DNS.

Register a custom domain in AWS Route 53 to enable ALB path-based routing for the Terraform on AWS course, covering domain search, registration, hosting zones, and billing.

Review the tf folder structure, update the load balancer security group to allow https 443, and create the aws_route53_zone data source to retrieve the devopsincloud.com hosted zone ID.

Review and upgrade EC2 private app1 and app2 modules to use for_each with latest 5.5.0, configure ACM certificate with DNS validation via Route 53, and update outputs.

Build a terraform managed application load balancer with two listeners, http to https redirect, fixed root response, and /app1 and /app2 routing to two target groups via acm.

Create a Route 53 alias record for apps.devopsincloud.com that routes to the application load balancer using Terraform, referencing module.alb.dns_name and module.alb.zone_id, within a VPC with SSL, listeners, and target groups.

Execute terraform to create 60 resources, including app1 and app2 EC2 instances, ALB with path-based routing, VPC, certificate manager, and Route 53 records; validate, plan, apply, verify, and destroy.