Terraform on AWS EKS Kubernetes IaC SRE- 50 Real-World Demos

Install the Terraform binary on macOS by downloading, unzipping, and moving it to a local bin, then verify with terraform version and update your PATH.

Install Visual Studio Code and the HashiCorp Terraform plugin, then download and set up the AWS CLI, verify versions, and configure credentials to prepare for Terraform on AWS.

Configure AWS CLI credentials by creating an IAM user, generating access keys, and setting the default region to us east one. Verify access by listing S3 buckets.

Install Terraform and AWS CLI on Windows, set up environment variables for the terraform bins directory, verify versions, and configure credentials for AWS access in Windows-based IaC demos.

Install Terraform on Linux OS by following the Linux installation guide for Ubuntu, Fedora, and Amazon Linux, using the provided link, then proceed to the next lecture.

Master the Terraform core workflow by learning init, validate, plan, apply, and destroy to provision and manage infrastructure across cloud or on-prem environments.

Master Terraform basics by running init, validate, plan, apply, and destroy, then update the manifest with the ami id and region for the default vpc.

Execute Terraform core commands to initialize, validate, plan, and apply configurations, resulting in an EC2 instance creation. Manage provider plugins and the Terraform manifest folder to ensure reproducible infrastructure.

Master terraform language syntax by learning blocks, arguments, identifiers, and comments, and structure terraform configuration files in the working directory to provision infrastructure using resource and other top-level blocks.

Discover how Terraform resources use arguments and attributes, learn to reference them, and explore meta-arguments like count, depends_on, and lifecycle to control resource behavior.

Master Terraform top level blocks by exploring fundamental blocks (settings, provider, resources), variable blocks (input, output, local values), and calling blocks (data sources, modules) for AWS EKS IaC.

Explore Terraform top level blocks: settings, required version, remote backend, and DynamoDB state locking, with providers, variables, outputs, locals, data sources, and modules.

Learn the fundamental Terraform blocks—the Terraform block, provider block, and resource block—and how they configure backends, root modules, and providers to provision infrastructure.

Learn how to define the Terraform settings block in Visual Studio Code, specify the required Terraform version and providers, and configure the backend to manage state (including S3 backend).

Define the Terraform provider block in the settings, set the local name, source, and version constraints, and use terraform init, validate, plan, and apply to provision resources via the registry.

Configure the Terraform provider block by setting the region and profile. Initialize with terraform init to download provider plugins and authenticate using credentials or a named profile.

Learn how Terraform resource blocks define an EC2 instance, including resource type, local name, and arguments, and implement a first EC2 instance with a hard-coded instance type.

Provision an ec2 resource with terraform, configure user data to install apache and serve a web app, and master argument versus attribute references, plan, and apply with security group checks.

Learn how Terraform state serves as the underlying database that maps your configuration to real infrastructure, defining the desired state versus the current state and local versus remote storage.

learn to clean up aws resources with terraform destroy, view destroy plans, and terminate instances, while exploring key name parameters, variables, data sources, and meta arguments like count and depends_on.

Learn Terraform concepts such as input variables, outputs, and data sources, and implement dynamic AMI fetch to provision an EC2 instance with VPC security group and key pair.

Explore Terraform input variables, output values, and local values, and master ten ways to pass input variables, including prompts, -var, TF_VAR, and -var-file.

Learn to implement Terraform input variables for AWS resources by defining region and instance type with descriptions, types, defaults, and validation, and apply variables to replace hardcoded values.

Define and configure aws_security_group resources in Terraform, detailing inbound (ingress) rules for port 22 and web traffic, and outbound (egress) rules in a default or specified VPC.

Learn to create an ami data source to fetch the latest amazon linux 2 image using filters for name, owner, root_device_type, virtualization, and architecture, for use in other terraform resources.

Create an ec2 instance resource in Terraform by leveraging a data source for the Amazon Linux AMI, setting the instance type, key name, and security groups, and preparing for outputs.

Define and expose Terraform outputs for an AWS instance, such as public IP and public DNS, and show how root and module outputs propagate to remote state.

Execute Terraform commands to initialize the local backend, validate configurations, generate a plan, apply changes, verify outputs like public DNS and IP, then destroy resources and clean up.

Master Terraform basics by implementing variable lists and maps, using the count meta-argument, and applying for loops with lists, maps, and splat operators for dynamic resource configurations.

Learn to implement terraform outputs with for loops over lists and maps, and apply legacy and latest splat operators to extract instance public DNS from resources.

Execute terraform init, validate, and plan to provision two instances, observing lists, maps, and for loops. Learn to comment with single-line and multi-line syntax and review outputs.

Learn to use the availability zones data source and the for_each meta-argument in Terraform on AWS EKS IaC to spawn an instance per availability zone using the set function.

Master Terraform outputs with toset, tomap, and for_each to surface public IPs and DNS for AWS instances across availability zones.

Build a Terraform utility to list region availability zones that support the b3.micro instance type, excluding unsupported zones, using a data source for instance type offerings.

Implement a semi dynamic version of a Terraform data source, extending v1 to v2 outputs with for loops, maps, and sets of availability zones for aws eks deployments.

Implement a fully dynamic utility project in step 08 by sourcing availability zones, filtering unsupported p3 micro instance types, and exporting keyed outputs for Terraform on AWS EKS.

Implement a fix for availability zone to instance type check in terraform. Use az lists, v3 outputs, and for loops to provision instances across azs with plan and apply validation.

Learn to build a three-tier VPC in AWS with public and private subnets, internet gateway, and routes across two availability zones, using manual setup and Terraform modules.

Build a VPC manually using the AWS management console, creating a public and private subnet with an internet gateway and NAT gateway; configure routes and associations, and clean up afterward.

Learn how Terraform modules and the public registry simplify creating a VPC with inputs and outputs. Understand root and child modules, local values, and choosing public modules vs custom resources.

Create a basic VPC module in Terraform using the AWS VPC registry, defining name, CIDR blocks, public and private subnets, database subnets, NAT gateway, and DNS options.

Execute a VPC module with Terraform to provision public and private subnets, routing tables, and an internet gateway in AWS, using public registry modules to simplify setup.

Explain how to apply version constraints in Terraform for providers and modules, using tilde and greater-than for providers, and lock public modules to exact versions for safe upgrades.

Standardize the v2 vpc module code by introducing generic variables and terraform.tfvars, organizing environment, region, and business division values, and using local values to structure production-grade Terraform.

Understand how Terraform local values and the local block simplify complex expressions by naming them for reuse, and how to define owner and environment locals to build a standardized name.

Define and review VPC variables in the VPC module, reference them in module calls, and configure outputs to share VPC details (subnets, availability zones, VPC ID) across Terraform projects.

Build a dynamic AWS bastion host in public subnets using Terraform modules, security groups, and an elastic IP, with data sources for availability zones and file and remote-exec provisioners.

Review dynamic availability zones in the VPC module using the aws_availability_zones data source to include all zones and optional local zones, and update Bastion host provisioning.

Create an AWS security group using a Terraform module, configuring a public bastion security group with VPC id, ingress from 0.0.0.0/0, and open egress, via the Terraform registry module.

Create a terraform data source to fetch the latest Amazon Linux 2 ami using filters for owner, root device type, virtualization, and architecture to select the bastion ami.

Create a bastion EC2 instance using a Terraform module and allocate an elastic IP, pinning module versions and using depends_on to ensure proper ordering.

Explore Terraform provisioners, including file provisioner, remote-exec, local-exec, and null resource with connection blocks, learn creation-time and destroy-time behavior, and bootstrap a Bastion host by copying files and running scripts.

Define a Terraform null_resource with remote-exec and local-exec provisioners, set up a connection to the Bastion host, copy keys, run inline commands, and log the created VPC ID.

Review step eight covers overriding default terraform variables for Bastion host and assembling the EKS cluster name with local values. It explains adding VPC tags to subnets to reflect cluster.

Execute terraform validate, plan, and apply to build a 28-resource AWS VPC with a bastion host, EC2 instances, and dynamic subnets, then verify outputs and destroy resources.

Learn to build an EKS guest cluster with Terraform, using resources or public modules, and configure VPC, subnets, bastion, node groups, and public API server access.

Review the EKS cluster IAM role and related Terraform variables, then configure the egress cluster, cluster security groups, and public and private Aegis node groups.

Review and configure the EKS node group IAM role by attaching the three policies—EKS worker node policy, EKS CNI policy, and ECR container registry read-only—for Kubernetes worker nodes.

Configure the EKS guest cluster with Terraform, defining the EKS cluster resource, VPC public subnets, endpoint access, and enabling control plane logging, with IAM roles and VPC controller policies.

Create EKS node groups in public and private subnets with Terraform, configuring cluster references, node group names, instance types, disk size, capacity type, remote access key, and update settings.

Review EKS variables and outputs, including cluster name, version, and API endpoint. Explain public versus private access and how outputs enable cross-project Terraform references.

Run Terraform init, validate, plan, and apply to provision the EKS cluster and 38 resources; then verify the cluster endpoint and node groups in the AWS management console.

Install kubectl, pick a binary within one minor version of your cluster, and configure kubeconfig to connect; verify connectivity by running kubectl get nodes and kubectl get services.

Connect to each worker node through the Bastion host and verify access to the Kubernetes API server endpoint using public and private IPs.

Master fundamental kubectl commands to explore an eks cluster, including listing namespaces, checking the default and cube-system namespaces, and viewing core workloads and services.

Understand how EKS cluster network interfaces (ENIs) in your VPC connect to the managed control plane, including private and public endpoint access, security groups, and multi-subnet ENIs.

Understand how the aegis cluster security group and per node group security groups auto generate for public and private nodes and govern inbound rules, including port 22 for remote access.

Explore Kubernetes architecture with master and worker nodes and container runtimes. Examine core components such as API server, etcd, scheduler, controllers, cloud controller manager, kubelet, and kube-proxy.

Understand the Aegis cluster architecture and Kubernetes cluster components, including the master and scheduler. Focus on application workloads while Aegis handles the control plan and maintenance.

Explore Kubernetes core concepts, from pods and replica sets to deployments and services, and learn imperative versus declarative workflows using kubectl and yaml manifests.

Explore the core Kubernetes concept of pods, the smallest object in Kubernetes, with a 1-to-1 relationship to containers, and scale by adding ports while using sidecar containers and envoy proxy.

Create a Kubernetes pod with kubectl, pull the image from Docker Hub, and describe it to verify IP and node details, setting up external access via a future service.

Explore Kubernetes node port services, mapping a service port to a container port, exposing apps externally via the node port range 30000-32767, alongside cluster ip and load balancer options.

Explore creating and exposing a Kubernetes node port service, understand port versus target port, access the app via the external IP and node port for real-world connectivity.

Interact with Kubernetes pods by viewing and streaming logs, connecting to containers, and inspecting service ports and YAML definitions to troubleshoot deployments.

Delete Kubernetes pods and services using kubectl in the default namespace, verify cleanup by listing remaining objects, and prepare for the next lecture on replica set.

Understand Kubernetes replica sets to ensure high availability, reliability, and seamless scaling, with services, labels, and selectors enabling effective load balancing.

Learn to define a Kubernetes replica set with a YAML manifest to deploy three pods, create it with kubectl, and list, describe, and inspect ownership, including the rs alias.

Expose a replica set as a service to access the app via a browser, observe automatic pod recreation, and scale replicas by updating the spec.

Explore Kubernetes deployments as the superset of replica sets, enabling rollouts, versioned updates, rollback, and scaling, including canary deployments. Learn to create deployment objects, export services, and monitor rollout status.

Create, scale from one to twenty replicas, and expose a deployment as a node port service; test updating, pausing, resuming, and rolling back deployments across multiple versions.

Update a Kubernetes deployment with set image to 2.0.0, monitor rollout status, observe replica set changes and template hash, and explore history and rollback options.

Learn to update a Kubernetes deployment from v2 to v3 using kubectl edit deployment, modify the container image, and verify the rollup history and the app version after the change.

Explore Kubernetes deployment rollback in practice: inspect rollout history, view revisions, and undo to previous or specific versions using kubectl, with rolling restart options.

Pause a deployment to apply multiple changes, then resume to upgrade from v3 to v4 and adjust resource limits.

Explore kubernetes services such as cluster IP, node port, and ingress. Learn how cluster IP enables internal app communication, and node port or load balancer expose apps outside the cluster.

Deploy a backend rest app exposed by a cluster IP service, then deploy a frontend with a node port service to proxy to backend and demonstrate load balancing across replicas.

Learn to manage Kubernetes resources declaratively with YAML using kubectl, creating pods, replica sets, deployments, and services on AWS EKS, transitioning from imperative to declarative workflows.

Learn YAML basics for Kubernetes manifests by mastering key-value pairs, dictionaries, lists, indentation, and document separators, with examples and Visual Studio Code tips.

Create a pod definition in yaml, detailing top level apiVersion, kind, metadata, and spec; define a simple container port and test with a node port service using kubectl apply.

Learn to create a Kubernetes NodePort service using YAML, including API version, metadata, selector, ports, and optional NodePort, then access the service via its external IP.

Define a replica set in yaml, specify replicas and match labels, configure the pod template, apply with kubectl, and verify automatic pod recreation.

Create a node port service for a replica set, define ports, selectors, and a notebook service in yaml, test access via the public ip and mapped port.

Convert the replica set to a deployment, set the image to 3.0.0, update the node port to 31233, apply the manifests, and verify the deployment and service are running.

Learn to write declarative Kubernetes manifests in YAML for backend and frontend deployments, create cluster IP services, configure replicas and ports, deploy, and validate the end-to-end setup.

Create the frontend deployment and nodeport service with proper metadata and labels. Apply the manifests using kubectl, define replicas and ports, and test load balancing via the public IP.

Apply and delete kubernetes objects by referencing yaml files with kubectl apply and delete -f to manage frontend and backend deployments and services across folders.

Deploy a sample application to the ECUs Kubernetes cluster using deployment and services, including deployment.yaml and replica sets; access via node port or load balancer in the default namespace.

Review the Kubernetes deployment manifest, covering api version apps/v1, kind deployment, and the spec elements—replicas, selector, template, and containers with image and port 80.

Review node port, classic and network load balancer service manifests, including ports, selectors, and annotations, to route traffic from nodes to deployments in Kubernetes.

Deploy a sample Kubernetes manifest to create a deployment and three service types, then review the deployment, replica set, and pods with kubectl describe and get commands.

Verify k8s services and access the sample app via load balancer and node port, adjust security groups, delete the manifests, and prepare for Terraform destroy.