
Master Terraform fundamentals and GKE automation with eight practical demos, covering providers, variables, data sources, and deploying public, private, and autopilot clusters.
Create a Google Cloud account with free credit, verify identity, provide payment details, activate full access, and set budget alerts that email at 30% and 90% of the monthly budget.
Explore Terraform fundamentals shared across the GCP, Terraform and Google Cloud, and GKE courses. Align demos one through eight across the GitHub repositories in both curricula.
Install and configure gcloud CLI, Terraform CLI, VS Code editor, and the Terraform VS Code plugin on macOS and Windows to automate Google Cloud infrastructure.
Install and verify the gcloud cli on macOS. Configure authentication, project, region, and zone, and review Google Cloud settings to enable Terraform communication.
Install the Terraform CLI on macOS using Homebrew, including arm64 and amd64 options, with manual install steps and path setup; next lecture covers the Visual Studio Code editor.
install and verify the gcloud cli on windows, run gcloud init, authenticate with your Google account, set a default project and compute region/zone, and configure application default credentials for Terraform.
Install the Terraform CLI on Windows by downloading the correct binary (amd64 or i386), unzip it, place it in C:\Terraform bins, and update PATH to verify with terraform version.
Learn the Terraform workflow by mastering init, validate, plan, apply, and destroy to create and manage Google Cloud resources, including vpc and subnet, from a working directory.
Learn how terraform state files track resources in a local backend. Explore terraform destroy with auto-approve, and review state backups and VPC-to-subnet dependency order.
Explore Terraform basics in a Google Cloud demo: define resources and providers, create a VPC with firewall rules, a subnet, and a VM with a startup script to install nginx.
Learn Terraform language basics, including file extensions (.tf, .tf.json) and the Terraform working directory, top-level blocks, and concepts like resources, providers, variables, data sources, modules, and import, mode, remote, check.
Learn Terraform's fundamental blocks—the settings, provider, and resource blocks—and how they shape configuration and state. Explore file and list functions and basic state concepts.
Create a Google Compute Network VPC and a manual subnet with Terraform, wiring the subnet to the VPC via the VPC ID, and learn about argument and attribute references and auto create subnets.
Create Google Compute firewall rules for SSH and HTTP 80 with Terraform using live template writing, setting source ranges 0.0.0.0/0 and target tags for the web server.
Define a Google Compute Engine instance with Terraform, specifying e2 micro, zone, boot disk, network, and firewall tags, and load a startup script to install nginx via Terraform file function.
Execute Terraform commands to provision a VPC, subnet, firewall rules, and a VM; validate, apply, and verify connectivity.
Understand how Terraform state maps the current state of real resources to your desired configuration using the terraform.tfstate file, and use plan, apply, and destroy with local or remote backends.
learn how meta arguments in Terraform modify resource behavior and implement the provider meta argument to use multiple configured Google providers aliases for resources in different regions.
Learn how Terraform output values expose resource attributes and arguments in CLI outputs, share information between configurations via remote state, and access those outputs across projects.
Define Terraform output values for a vm, including vm instance id and vm external ip, using attribute and argument references, then run plan and apply and clean up with destroy.
Master Terraform meta argument count to create multiple Google Compute instances with count and count.index, and learn for expressions and splat operators for naming and outputs.
Run Terraform apply with auto-approve to create two VM instances using the meta-argument count in a custom VPC, inspect outputs, and destroy all resources.
Discover how Terraform data sources use the data block to fetch available Google Compute Zones in a region and deploy VM instances across two zones using the meta argument count.
Demonstrates implementing Terraform data sources with the google_compute_zones data source to create two vm instances in two zones, using data source outputs and plan, apply, and destroy workflows.
Explore Terraform meta-argument for_each to create multiple vm instances across compute zones using maps and sets, with hands-on demos for map and set values.
Explore for_each with set inputs in Terraform by demonstrating multi-zone GCP compute instances, converting lists to sets, and using each dot key or value for instance naming.
Learn to create a GKE standard public cluster with Terraform, compare autopilot and standard modes, and deploy workloads via YAML and the Terraform Kubernetes provider using a remote backend.
Configure a remote backend with Google Cloud Storage for Terraform state, add environment and business division variables, and use a locals block to standardize resource naming and tags.
Create a standard public GKE cluster with Terraform using a dedicated service account, a separate managed node pool, a custom VPC network, and cloud platform scope with IAM roles.
Create a GKE linux node pool with Terraform using a single preemptible VM and cloud platform scope service account, then view cluster name, location, endpoint, and master version.
Execute terraform init, validate, plan, and apply to create a GKE standard public cluster with a remote GCS backend, provisioning six resources and exposing the cluster endpoint.
Course Modules
Demo-01: Install CLI Tools: gcloud CLI, Terraform CLI, VSCode Editor
Demo-02: Terraform Commands (init, validate, plan, apply and destroy)
Demo-03: Terraform Language Basics
Demo-04: Teraform Meta-Argument - Provider (Multiple Providers Demo)
Demo-05: Terraform Input Variables and Output Values
Demo-06: Terraform Meta-argument: count
Demo-07: Terraform Datasources
Demo-08: Terraform Meta-argument: for_each
Demo-09: GKE Public Standard Cluster
Demo-10: Kubernetes Resources using YAML Manifests
Demo-11: Kubernetes Resources using Terraform Manifests
Demo-12: GKE Private Standard cluster with Cluster Autoscaler
Demo-13: GKE Horizontal Pod Autoscaling
Demo-14: GKE Vertical Pod Autoscaling
Demo-15: GKE Private Standard Cluster with Private Endpoint
Demo-16: GKE Private Autopilot cluster
Demo-17: GKE Storage: Compute Engine Persistent Disk CSI Driver
Demo-18: GKE Storage: Cloud SQL MySQL Database
Demo-19: GKE Storage: Cloud Storage with FUSE CSI Driver
Demo-20: GKE Storage: Filestore CSI Driver
Demo-21: GKE Gateway API (GCP Regional Application Load Balancer)
Demo-21-01: GKE Gateway API Basics (Gateway and HTTPRoute)
Demo-21-02: GKE Gateway API Static IP (GCP External IP Address)
Demo-21-03: GKE Gateway API self-signed SSL (Kubernetes Secrets)
Demo-21-04: GKE Gateway API self-signed SSL (GCP Certificate Manager)
Demo-21-05: GKE Gateway API HTTP to HTTPS Redirect
Demo-21-06: GKE Gateway API Context path-based Routing
Demo-21-07: GKE Gateway API Domain name Routing
Demo-21-08: GKE Gateway API Traffic Splitting
Demo-21-09: GKE Gateway API Health check and Session Affinity (GKE custom policies)
Demo-21-10: Cloud Domains and Cloud DNS
Demo-21-11: GKE Gateway API Production grade SSL (GCP Certificate Manager + Cloud DNS + Cloud Domains)
Demo-21-12: GKE Gateway API Production grade SSL (GCP Certificate Manager + Cloud DNS + AWS Route53)
Demo-21-13: GKE Gateway API Global LB (GCP Global Application Load Balancer)
Demo-22: Use Pre-built Terraform Modules from Terraform Registry
Demo-23: GKE Infra: Create custom GKE Terraform Module
Demo-24: GKE Infra DevOps using GitHub and GCP Cloud Build
Demo-25: GKE Workloads: Create custom Kubernetes Deployment Terraform Module
Demo-26: GKE Workload DevOps using GitHub and GCP Cloud Build
Demo-27: GKE App: Implement Continuous Integration with GitHub, Cloud Build and GCP Artifact Registry
Demo-28: GKE App: Implement Continuous Delivery using GitHub and Cloud Build
GCP Services
Google Kubernetes Engine
Google Compute Engine VM Instances
Google Compute Engine Health Checks
Google Compute Engine Persistent Disks
Google Cloud VPC
Google Cloud Firewalls
Google Cloud Storage
Google Cloud Monitoring
Google Cloud Logging
Google Cloud Load Balancing
Google Cloud IAM
Google Cloud Domains
Google Cloud DNS
Google Cloud NAT
Google Cloud Router
Google Cloud External IP
Google Cloud Build
Google Cloud Certificate Manager
Google VPC Private Service Connection
GCP Secrets Manager
GCP Cloud Storage Buckets
Kubernetes Concepts
Google Kubernetes Engine - Standard Public Cluster
Google Kubernetes Engine - Standard Private Cluster
Google Kubernetes Engine - Autopilot Cluster
Kubernetes Cluster Autoscaler
Kubernetes Horizontal Pod Autoscaling
Kubernetes Vertical Pod Autoscaling
Kubernetes Deployments
Kubernetes Load Balancer Service
Kubernetes Storage - Storage Classes
Kubernetes Storage - Persistent Volumes
Kubernetes Storage - Persistent Volume Claims
Kubernetes Secrets
Kubernetes Gateway API (Load Balancers - 13 Important Demos)
Each of my courses comes with
Amazing Hands-on Step By Step Learning Experiences
Practical demos for each and every concept
Friendly Support in the Q&A section
"30-Day "No Questions Asked" Money Back Guaranteed by Udemy"