Full Stack AI DevOps + Real Projects | AWS, Azure, GCP, K8S

See how Docker solves 'works on my machine' by containerizing apps with dependencies, creating portable Docker containers, and clarifying the difference between containers and virtual machines for scalable development.

Explore core Docker concepts, defining Docker images as blueprints for containers, container runtime instances, and the Dockerfile that builds images; learn about image layers, registries, tags, and the Docker Engine.

Learn how Docker registries store container images, compare Docker Hub with cloud registries like AWS ECR, Google Artifact Registry, and Azure Container Registry, and distinguish public versus private access.

Explore Docker architecture, including the host operating system, Docker engine, daemon, API, and CLI, and learn how images and containers are built, pulled, and pushed from a registry.

Install Docker Desktop on mac, Windows, and Linux; verify with Docker version, Docker info, and Docker Compose version; sign in to enable pushing images to a registry.

Explore running docker images by pulling and launching hello world from Docker Hub, using docker run, Docker Desktop, and understanding images, containers, and the daemon.

Learn to run nginx in Docker, map host ports to container ports with -p, run in detached mode with -d, name containers, and access containerized web pages via localhost.

Explore docker hub images from embark x, pull and run hello-spring, hello-node, and hello-python. Practice port mapping and detached mode while learning how to manage containers.

Docker solves the it works on my machine problem by packaging apps and all dependencies into containers, delivering platform independence across languages like Node.js, Python, and Spring Boot.

Explore the docker container lifecycle from create to remove, including container id, running state, and key commands like docker ps, create, run, start, stop, restart, and rm.

Learn how docker image tags label versions and how the latest tag defaults when none is specified. Use specific semantic tags like 1.0.0 for predictable production deployments.

Learn to view and follow container logs with docker ps and docker logs, using IDs or names, then diagnose inside containers via docker exec.

Master essential docker commands for images and containers, including pull, list, remove, run, start, and prune. Explore inspecting, logs, exec, and cleanup via system prune and image prune.

Understand how a dockerfile builds images with from, workdir, copy, and run instructions, plus how layers and caching speed builds; review java, python, and node examples.

Explore how Visual Studio Code supports docker-based containerization across Node.js, Python, and Spring Boot, with extensions and workflows for Windows, Mac, and Linux.

Explore the public GitHub repository, clone the Docker-based project, and understand containerizing a hello world app across Node.js, Python, and Spring Boot microservices within a local workspace.

Containerize a Python Flask app by creating a Dockerfile, installing dependencies from requirements.txt, building and running the image with port 3000, and pushing the image to Docker Hub.

Containerize a spring boot app using a Dockerfile and base image, build the jar with Maven, expose port 8080, run the container, and push the image to Docker Hub.

Learn how the Docker ignore file mirrors gitignore to trim build context, speeding Docker builds, shrinking image size, and avoiding secret files and unnecessary folders like node_modules, logs, and envs.

Learn to use environment variables in Docker containers to inject runtime values like database URLs and secret keys across dev, prod, and QA without hardcoding.

Learn to manage environment variables with dot env files for containerized apps, pass values via docker using env-file, and override with hyphen e for flexible deployment.

Define and run multi-container applications with docker compose using a yaml file, and start in the correct order while networking containers and monitoring with logs and up and down commands.

Create and run a multi-service docker compose setup for node, python, and spring boot apps, building images via dockerfile, mapping ports, and passing environment values.

Docker Compose rebuilds images when the image doesn't exist locally, when the Dockerfile changes, or when the build context changes; use the build flag to force a rebuild.

Externalize docker compose environment variables using a dot env file, avoiding hardcoding and exposure of secrets in version control, and reference them across three services.

Debug docker compose apps by viewing running containers with docker compose ps, managing up and down, and following logs with docker compose logs -f; inspect services via docker compose exec.

Tag images in Docker Compose, build them, and push to Docker Hub with docker login and docker push using explicit tags such as 1.0 for multiple images.

Pull your images from a remote docker registry with docker compose to run your apps on any machine, using image tags and optional environment variables.

Learn how Docker networks enable seamless communication between multiple containers, and how to create a network, attach containers, and use port mapping to connect app and database services.

Explore Docker networks: bridge, host, and none default networks, and how containers communicate by IP in the bridge network, when to use host for performance, and none for isolation.

Explore a three-tier microservices project with a React frontend, service A computing price using tax data from service B, and containerization with inter-service communication and environment variables.

Learn how to containerize a Spring Boot app with two microservices, A and B, exposing tax endpoints, configuring ports, and wiring them with docker compose and docker networks.

Define a custom network in Docker Compose, assign services to it, and manage isolation and cross-container communication on a bridge network named tax network.

Explore how AI accelerates devops with tools like ChatGPT and Claude to optimize Docker images, review Dockerfiles, and assess CVEs using Docker Scout for secure, smaller, non-root deployments.

Master Kubernetes as a container orchestration platform that manages containers at scale. Automate deployment, scaling, healing, and networking to ensure zero downtime deployment and high availability.

Explain the Kubernetes cluster architecture with a control plane and worker nodes, and show how API server, scheduler, controller manager, etcd, kubelet, and kube-proxy coordinate pod execution.

Set up a local Kubernetes cluster on your machine using Docker Desktop, with options like minikube and kind, and learn to use kubectl to interact with the cluster.

Create a deployment with kubectl to run the nginx image, then verify that a pod appears and is created by the Kubernetes controller manager.

Explore how Kubernetes services give pods a permanent IP, enable internal and external access, and expose applications via cluster IP, NodePort, load balancer, or external name.

learn how replica sets enable self-healing in Kubernetes by automatically recreating pods to match the deployment’s desired state, keeping one instance running, as shown when deleting a pod triggers recreation.

Scale deployments with replicas to five to handle more traffic, then observe the replica set and scale back to one as traffic subsides.

Execute rolling updates in Kubernetes with zero downtime by updating the deployment image and monitoring rollout status as old pods terminate and new pods come up.

Learn to debug pods in Kubernetes using kubectl to view logs, exec into containers, and inspect ports and nginx configurations for production issues.

Learn to define Kubernetes deployments and services with yaml, including replicas, images, labels, selectors, and node ports, and apply configurations with kubectl.

Learn how Kubernetes passes environment variables to containers with configmaps and secrets, storing non-sensitive config and sensitive data, using base64 encoding, and referencing keys in deployments.

Engage in a hands-on Kubernetes deployment challenge by running a hello world app from Docker Hub images, configuring env variables, and wiring deployment, service, configmap, and secret.

Deploy two microservices in Kubernetes, wiring service A and service B for tax calculation, and enable inter-service communication via cluster IP and node port with YAML deployments.

Explore how cloud computing delivers processing and storage over the internet, eliminating local ownership. Understand cloud service models, SaaS, PaaS, and IaaS, and see Gmail, Google Drive, and AWS EC2.

Understand why cloud computing emerged to replace physical servers. It enables scalable, pay-per-use computing from a cloud provider like AWS, with easy upscaling and downscaling during peak demand.

Discover Amazon Web Services, navigate the generous free tier, and learn core services such as EC2, S3, DynamoDB, IAM, and RDS, plus regions and pricing.

Create an AWS account by entering your email, verifying it, and adding contact and payment details, then explore the AWS console with billing insights and a free plan.

Explore the AWS ecosystem, including data centers, availability zones, and regions, and learn how replication across zones ensures high availability while choosing regions by proximity, services, cost, and compliance.

Explore identity and access management in AWS, defining who can do what through IAM users, groups, roles, and policies to control console access, access keys, and billing visibility.

Create and manage aws iam users, groups, roles, and policies hands-on, enabling secure access with MFA, least privilege, and policy-based permissions for S3 and other services.

Learn to harden the AWS root account by enabling multi-factor authentication, deleting root access keys, and securing billing and security contacts to reduce risk.

Explore the Elastic Compute Cloud (EC2) and learn how on-demand, pay-per-second virtual servers with AMI and EBS storage power scalable hosting for apps, APIs, ML, and dev/test environments.

Understand AWS storage categories: object storage with S3, block storage with EBS, and file storage with EFS, and how buckets, objects, and metadata work in regions.

Create and manage Amazon S3 buckets, upload files, and configure storage classes and public access using bucket policies and get object permissions.

Learn to host a static website on Amazon S3 by enabling static website hosting, creating a simple index.html, uploading it to the bucket, and accessing the bucket website endpoint.

Enable S3 bucket versioning to keep multiple versions of an object, view past versions via the versions tab, and restore or undelete files while understanding cost implications.

Explore Amazon RDS, a managed relational database service that hosts SQL databases like MySQL, PostgreSQL, and Oracle in the cloud, with automated backups, high availability, and easy scaling.

Launch and configure an Amazon RDS database instance, choosing standard or easy create, exploring engines like MySQL and PostgreSQL, and selecting production, development, or free tier templates.

Connects an application to AWS RDS using Java Spring Boot with JPA and the MySQL driver, configuring the data source, endpoint, credentials, and dialect for seamless database integration.

Delete AWS resources safely by removing databases, EC2 instances, and S3 buckets to avoid unnecessary billing. Empty S3 buckets before deletion and confirm permanent deletion by typing the bucket name.

Explore how internet protocol addresses work, including IPv4 and IPv6, and how AWS uses private IP, public IP, and elastic IP for connectivity.

Explore how AWS VPC creates private, isolated networks inside your account, letting you group instances into separate virtual networks and specify IP address ranges for security.

Explore cidr, classless inter-domain routing, which uses a base ip and a prefix length to define IPv4 networks and host ranges, such as 192.168.1.0/24 with 254 addresses.

Explore how to design an AWS VPC with CIDR blocks, plan non overlapping subnets, and calculate usable IP addresses from prefix lengths.

Learn to create a custom VPC in AWS with public and private subnets, NAT gateway, internet gateway, CIDR blocks, and S3 VPC endpoints.

Install and configure the AWS CLI, authenticate with access keys, and manage AWS services from the command line using aws configure, covering Windows, Mac, and Linux setups.

Master the AWS CLI with hands-on examples for S3 and EC2, from creating buckets and key pairs to launching instances, syncing objects, and managing IAM users and groups.

Explore what serverless really means: you code and trigger events without managing servers. Learn how AWS Lambda runs code behind the scenes, with pay-per-request pricing and automatic scaling.

Create your first AWS Lambda function from scratch or a blueprint, configure a runtime and execution role, and test by invoking a sample event with auto-scaling and pay-per-use compute time.

Explore how to expose an aws lambda as a rest endpoint using a function url, deploy updates, and test it with postman to send http requests and handle json responses.

Learn to expose a Lambda via AWS API Gateway, compare function URL with API Gateway, create a rest API /contact mapped to Lambda, deploy to dev, and test with Postman.

Explore how Docker packages apps and their images into portable containers, and how AWS ECR registry and ECS with Fargate enable serverless container deployment.

Explore the AWS ECR registry, create a private repository, authenticate Docker to ECR, tag a local nginx image, and push it to the ECR repository in a hands-on demo.

Master best practices to clean up AWS ECS and ECR resources by deleting services and clusters, stopping tasks, and removing load balancers and images to avoid costs.

Explore Kubernetes on AWS using Amazon Elastic Kubernetes Service, where AWS manages the control plane, availability, and security while you deploy containers and Kubernetes configurations.

Understand how clusters, nodes, and pods work in Kubernetes, with a control plane and one or more nodes, and how local one-node setups differ from cloud multi-node deployments.

Assess the pricing of AWS EKS by examining per-hour costs for standard and extended clusters, plus the AWS free tier credits, to learn cost-aware deployment and avoid surprise bills.

Eksctl is an official AWS command-line tool that creates and manages EKS clusters with a single command, using declarative YAML configurations; install via homebrew on macOS/Linux or chocolatey on Windows.

Create your first Amazon EKS cluster using X control and the AWS CLI, set region ap-south-1 and two nodes, and follow CloudFormation driven provisioning and kubectl readiness.

Deploy your app to a Kubernetes cluster on AWS by configuring deployment and service, using a Docker Hub image, and exposing it via a load balancer on port 80.

Scale your Kubernetes app by increasing replicas and verify load balancing across multiple pods, using deployment updates with kubectl apply and testing with a service URL.

See how Kubernetes self-healing preserves availability by automatically replacing crashed pods to match the desired replica state, with load balancing and round-robin traffic.

Learn to clean up AWS resources to avoid costly bills, deleting Kubernetes deployments and services with kubectl and app.yaml, then remove all resources across namespaces and the EKS cluster.

Deploy a full stack microservices app on EKS, wiring price service A with tax services A and B to compute final prices by country code (in, us) for front end.

Deploy and test microservices to a remote AWS cluster using YAML deployments, kubectl, and a load balancer, with services A and B communicating via environment variables.

Design a full stack architecture with frontend, service a (tax calculator), and service b (tax service) behind a single public url. Route root to frontend and /api to internal services.

Expose multiple Kubernetes services with a single public endpoint using ingress, a traffic manager that routes HTTP/HTTPS requests to the correct service and pod.

Understand how ingress controllers in Kubernetes read ingress rules and route http traffic through a single entry point, with a web traffic engine and Kubernetes-aware controller.

Update the front end and rebuild the image so the app points to the API at the new host via /api, with build-time environment variables bound.

Explore ingress configurations in Kubernetes using YAML to route http and https traffic to services and pods via nginx ingress controllers and path rules.

Deploy a front-end and backend on Kubernetes with ingress, configure cluster IPs and front-end service, and set ingress rules to route API to service A, all on AWS EKS.

Explore how continuous integration and continuous deployment automate code testing, building, and packaging into Docker images and software artifacts, then deploy and verify production for fast, stable releases.

Discover how GitHub Actions enables zero setup ci/cd by defining YAML workflows triggered by events like pushes, and learn to use official docs for guidance.

Discover how to use the GitHub Actions extension in Visual Studio Code to manage workflows, sign in to GitHub, and view branches and actions in a built-in UI.

Explore the anatomy of a CI pipeline using a simple sample, including name, on triggers, jobs, and steps, and learn how runs on a runner with YAML syntax.

Learn the difference between running commands with run and using prebuilt actions in CI pipelines, including when to check out code, set up runtimes, and safeguard security.

Learn to use environment variables and secrets in GitHub Actions workflows with workflow dispatch. Understand step, job, and global env levels and how repository and organization secrets are secured.

Use the upload artifact action to save test reports from the runner before it is destroyed. Define inputs like name and path to specify the artifact.

Define dependencies in the pipeline file so the test job runs only after the build job completes. Use the needs keyword to enforce execution order between build and test jobs.

Learn how GitHub Actions context objects expose workflow environment data, including GitHub, env, and runner details, and use them to access actor, repository, branch, and event information.

Build and test a Spring Boot app with a GitHub Actions CI pipeline, generate a jar, upload test reports, and automatically push a Docker image to Docker Hub.

Learn to containerize a Node.js app with a two-job GitHub Actions pipeline that builds, tests, then builds and pushes a Docker image to Docker Hub.

Build and test a Python app with GitHub actions, featuring jobs for build test and docker push, using reusable actions, docker hub login, secrets, and triggers on push or dispatch.

Understand how CI/CD talks to Kubernetes using kube-config and kubectl. See how kube-config stores cluster endpoints, credentials, and contexts, and how CI runners update it to deploy to clusters.

Create an AWS EKS cluster with eksctl for deploying your app via CI-CD, naming it hello cluster in ap-south-1 with nodes-2; provisioning takes minutes, and delete clusters to avoid costs.

Deploy a HelloSpring application to an AWS EKS cluster using a CI/CD pipeline that builds, tests, pushes the Docker image to Docker Hub, and deploys via kubectl.

Deploy a node.js app to AWS EKS with CI/CD, configuring kubectl, workflows, and Docker images. Troubleshoot ports and container settings (3000 vs 8080) and verify deployment via the service URL.

Deploys a Python hello app to Kubernetes via CI/CD, updating Docker images, building and pushing, then deploying to AWS EKS with kubectl and kubeconfig, and verifying service health.

Create a cluster named hello cluster in the ep-south-1 region with two nodes using PowerShell and EKS control, then monitor the process until the cluster is created.

Define and deploy CI/CD pipelines for Spring Boot microservices A and B, using dockerized builds and a matrix strategy, and deploy to AWS EKS.

Define and deploy a separate frontend ci/cd pipeline using Node.js, React, and env config; build, test, dockerize, push to Docker Hub, and deploy to AWS EKS with ingress.

Deploy a full-stack python microservices app with separate backend and frontend CI/CD pipelines. Build, test, and push Docker images to Docker Hub and deploy to AWS EKS.

Define and deploy Node.js microservices to AWS EKS with fully automated CI/CD pipelines, adapting existing workflows, building Docker images, and updating Kubernetes deployments from Node.js latest tags.

Install and configure Terraform locally using the official guides across macOS, Windows with choco, and major Linux distros, then configure AWS credentials with AWS CLI to provision AWS infrastructure.

Learn to provision an AWS EC2 instance with Terraform as infrastructure as code, configuring providers, region, AMI, instance type, and tags in a main.tf file.

Learn to provision an AWS EC2 instance with Terraform by writing infrastructure as code, initializing the workspace, planning changes, applying them, and validating and destroying resources for cost control.

Terraform automates AWS resource creation using a credential resolution chain and never prompts for credentials. It supports three methods—hard-coded (not recommended), environment variables, and shared credentials files via AWS configure.

Learn how terraform state file tracks AWS resources, guiding apply and destroy, with backups and plan comparisons to ensure you modify rather than duplicate infrastructure.

Explore how to use the Terraform registry to browse provider documentation. Learn to switch between AWS, Azure, and Google Cloud Platform and read examples for VPC, S3, and EC2.

Create an IAM user with Terraform by defining a user resource named terraform demo user and tagging it with purpose. Run Terraform plan and apply to provision the user.

Explore how terraform variables make infrastructure flexible and reusable by configuring EC2 instance types across dev, staging, and prod, with defaults, descriptions, and overrides.

Learn how terraform.tfvars automatically provides real values for declared variables, overriding defaults, and how to use a dev or prod tfvars file with terraform apply for multi-environment deployments.

Explore multiple ways to pass Terraform variable values, including default values, -var flags, and variable files, as well as environment variables, and learn the precedence rules that govern them.

Learn how to use Terraform's output block to display key values after apply, such as EC2 public IP. Discover referencing resources, descriptions, and making outputs suitable for humans and scripts.

Explore separating Terraform configurations into multiple files and folders, understand that all .tf files in a directory form one configuration, and use init, apply, and destroy as needed.

Explore how Terraform treats a directory as the unit of execution, loads all .tf files to form a single configuration, builds a dependency graph, and plans or applies changes.

Learn how Terraform modules promote reusability and standardization by restructuring infrastructure code into library-like modules, using variables, environments, and provider-agnostic designs.

Learn to implement dev, test, and prod environments with Terraform modules, providers, and variables, producing reusable infrastructure such as EC2 instances and S3 buckets with clear outputs.

Implement S3 bucket versioning across dev, test, and prod by using terraform modules and variables, count, and a ternary operator to disable on dev and enable on test and prod.

Learn how remote state in Terraform uses cloud-stored state files, like an S3 bucket, to enable team collaboration and reliable CI/CD workflows.

Implement remote state management across dev, prod, and test environments using s3 for the state file and dynamodb for locking with terraform.

Learn to safely destroy cloud infrastructure with Terraform destroy, using force destroy for S3 buckets with versioning, and clean up remote state in S3 and DynamoDB.