Docker, Kubernetes & AWS with GitHub Actions for DevOps

Learn the basics of AWS networking and how it supports deploying Docker and Kubernetes on AWS, combining theory and practical understanding to enable end-to-end troubleshooting with a prerequisite AWS account.

Explore how VPC provides an isolated AWS network and how subnets create public and private segments. Put websites in public subnets and databases in private subnets to limit exposure.

Explore how IP addresses identify devices on private networks and the internet, how private vs public IPv4 addresses interact with routers, and how CIDR notation defines VPC address ranges.

Learn how security groups act as virtual firewalls for EC2 instances, controlling inbound and outbound traffic at the instance level with only allow rules and stateful behavior.

Compare NACL and security groups in AWS networking. NACL is subnet-level and stateless, with ordered allow and deny rules; security groups are instance-level and stateful.

Explain how a nat gateway lets private subnets access the internet for updates and downloads while preventing inbound exposure by translating private ip addresses to a public ip.

Learn to create an IAM user in AWS with administrator access, avoiding root credentials, and sign in via the console URL to manage services while restricting billing.

Launch a web server on an EC2 instance within a VPC, create a custom VPC with two public subnets, configure a public route table and internet gateway for internet access.

Launch an EC2 instance in the VPC, configure security groups and NACLs to expose a Node.js web app on port 5000, then run it in the background with PM2.

Demonstrates creating a private subnet in a VPC, configuring private and public route tables, launching EC2s, enabling internal SSH, and using a NAT gateway for outbound internet access.

Explore how DNS translates domain names to IP addresses and how the DNS lookup flows from the resolver to root, TLD, and authoritative servers to load a web page.

Learn how dns records, stored as zone files on authoritative dns servers, map domains to ip addresses and TTL-driven caches, including A, AAAA, CNAME, MX, NS, and SOA records.

Launch an ec2 instance with a user data script to install git and node, clone repo, install dependencies, start the app with pm2 on port 5000, via a custom domain.

Configure nginx as a reverse proxy to route root requests to the node.js backend on port 5000, enabling access by IP without a port. Edit the config and restart nginx.

Allocate a static elastic IP, associate it with a Node.js app, and map your naked domain to that IP via an A record, with a low TTL for DNS updates.

Enable https by installing an ssl certificate with certbot on an ec2 instance, configure nginx for https, and redirect http to https to secure browser-server communication.

Terminate the EC2 instance, disassociate and release the elastic IP to avoid charges, then delete all AWS resources after the exercise.

AWS elastic load balancer distributes traffic across targets, boosting availability and scalability with health checks and auto scaling, and supports ALB for content-based routing, plus NLB and gateway load balancer.

Explore elastic load balancer components, including listeners, target groups, and health checks, and learn how rules enable content-based, host-based, and path-based routing.

Explore external and internal load balancers, including public facing ELBs for internet traffic and private ELBs for VPC traffic, plus security groups for load balancers and EC2.

Compare ALB and NLB by layer and listener protocols, noting ALB handles HTTP/HTTPS with content-based routing and NLB supports elastic IPs and high performance, with ALB free tier details.

Configure Route 53 to manage DNS for AWS workloads by creating a public hosted zone and updating name servers at GoDaddy, with pricing explained.

Understand an architecture diagram and deploy a VPC with two public and two private subnets, using an internet-facing load balancer to distribute traffic to private web servers.

Launch two EC2 instances in public subnets, install httpd, and create two custom AMI images (India and US); then deploy them in a private subnet and deregister snapshots when done.

Launch two ec2 instances in private subnets, configure a web security group, and create an application load balancer with a target group for http traffic and health checks.

Learn how stickiness lets a load balancer bind a user session to a single target during a sensitive transaction, with a configurable duration like 10 seconds, demonstrated on web servers.

Improve security groups by restricting web server access to traffic from the load balancer's security group, then verify connectivity remains intact.

Learn to map a custom domain to an application behind an application load balancer using route 53, via a public hosted zone and simple routing policy.

Set up https by obtaining a free SSL certificate from AWS ACM, attach it to the load balancer, and update the listener to https for encrypted client traffic.

Delete all demo resources after use: hosted zone, EC2 instances, AMI, snapshots, and load balancer; consider deleting the target group, and keep VPC and subnets (free to create).

Explore how GitHub Actions automates repository tasks from push events to deployments, cover CI/CD basics with workflows, jobs, steps, and artifacts, and implement tests and quality checks.

Demonstrates setting up pull requests and integrating sonarcloud for code quality checks before merging to main. Configures a ci/cd pipeline with tests, build, and deployment to GitHub Pages.

Learn to automate with GitHub actions by building a hello world workflow for a sample project, pushing code to GitHub, and printing messages in Actions.

Clone project code to a remote runner with the checkout action, using GitHub contexts to reference the repository, then run npm run test in a deploy test workflow.

Set up node.js on a remote runner, install dependencies with npm, and run tests using npm run test, verifying node version and handling test failures within a GitHub Actions workflow.

Configure GitHub Actions to run test before build, making jobs execute sequentially using needs. Demonstrate building production-grade files in a dist folder and deploying them, with skip CI on push.

Speed up GitHub actions workflows by caching the node_modules folder with the cache action, creating a key from package-lock.json, and installing dependencies only when the cache misses.

Learn how artifacts are produced during automated workflows, such as a dist folder from npm run build, and how to upload, download, and deploy these artifacts with GitHub Actions.

Apply push filters in GitHub Actions to deploy only on the main or feature branches, ignore specific paths like readme.md or the YAML file, and use manual workflow dispatch.

Learn how to create a composite action in GitHub workflows to remove duplicate steps, by packaging setup node, caching dependencies, and npm install into a reusable action.

Deploy your React app to GitHub Pages using a dedicated GitHub Actions workflow, building, uploading dist as an artifact, and deploying with the deploy pages action.

Set up SonarCloud integration with GitHub Actions to automatically analyze pull requests for code quality before merging, using a workflow, secrets, and sonar properties.

Discover how Docker solves environment inconsistencies by dockerizing your application into portable images with dependencies and startup instructions, simplifying sharing and deployment across machines and servers.

Learn how to dockerize an application by writing a Dockerfile, building an image with its instructions, and running that image in a lightweight, isolated container that contains your code.

install docker on Windows using Docker Desktop, restart your system, and verify the Docker version; resolve potential WSL 2 errors by installing the WSL2 kernel package.

learn how to dockerize a Node.js app by building a Dockerfile with a base Node.js image, copying code into /app, installing dependencies, and configuring run vs cmd and .dockerignore.

Learn to build docker images from a Dockerfile, tag and manage images, and run, detach, name, and monitor containers while handling cleanup with prune and logs.

Explore port mapping to access a container's application by exposing port 5000 and mapping it to a host port like 3000 on localhost.

Discover how Docker caches image layers to speed up builds and how copying package.json and using npm ci with package-lock.json maintain exact versions in automated environments.

Persist data outside containers with named volumes. Learn to create and manage volumes with Docker volume commands, ensuring uploaded images survive container restarts.

Identify the difference between CMD and Entrypoint: CMD can be overridden at run time, while Entrypoint cannot; combine them so CMD acts as a default argument to Entrypoint.

Learn how to push and pull Docker images to Docker Hub, create repositories, tag images, and authenticate with Docker login for streamlined DevOps workflows.

Learn how to use docker compose develop watch to sync local code changes into the container, enabling hot reloading as node restarts in watch mode for smoother development.

Explore docker networking by running a Mongo database, a Node.js application, and a front-end application in separate containers, and observe how these containers communicate in isolation.

Run and build Docker images to host MongoDB on port 7000, then connect from the Node.js container via host.docker.internal, revealing the local-environment dependency.

learn to connect a node.js app to mongodb using the container IP and docker network, address IP changes on restart, and compare methods for reliable inter-container communication.

Create a docker compose setup for a multi-container app with mongodb and a node api, using named volumes, networks, port mapping, and development live reload.

Add a client service to the docker compose setup, connect a React front end to the API, and manage networks so React, API, and MongoDB communicate securely.

Master multi-stage dockerfile workflows to build a production React app, copy the dist to an nginx server, and deploy a small image without node.js.

This lecture demonstrates creating separate docker compose and dockerfile files for prod and development, wiring an environment variable to supply the API URL, and using prod-specific port mappings and builds.

Use MongoDB Atlas managed service to scale, secure, and synchronize your database, replacing the MongoDB container; configure Atlas cluster, access control, prod URI, and deploy the app to ECS.

Compare deploying on AWS EC2 with manual docker setup and scaling to using AWS EKS for managed container deployment, noting pricing and the need to delete the cluster.

Understand ECS components by creating a task definition (docker compose style), then set up an ECS cluster and a service to run containers, with optional replicas and load balancing.

Push the Node.js image to Docker Hub and deploy to AWS ECS with Fargate. Create a task and service with a load balancer, mapping port 5000 to the host.

Fix nginx 404 issue for admin route by configuring nginx with try_files to serve index.html when the admin path is missing, enabling react routing in a docker compose setup.

Build and push the react app image to docker hub, update the ECS service and task definition, and force a deployment to run the frontend container with health checks.

Access the react app via the alb dns name by routing http traffic on port 3000 to a react target group, while node.js runs on port 80.

Create a CI/CD workflow with GitHub Actions to automatically build node and react images, push them to Docker Hub, and deploy updates to AWS ECS.

Create a GitHub Actions workflow to build and push the React client image with Docker context and prod Dockerfile, run two parallel jobs, then log in to AWS for deployment.

Modify the ECS task definition to add Node.js and React image details, then trigger a deployment via the ECS service using GitHub Actions, observing revisions and outputs.

Delete the ECS cluster to automatically remove the service and tasks, then optionally deregister the task definition and delete the load balancer and target groups, while keeping the security group.

Understand why Kubernetes provides self-healing, auto scaling, and load balancing for containerized applications, as an open source container orchestration platform that automates deployment, management, and cloud provider independence.

Enable Kubernetes in Docker Desktop to create a local single-node cluster, then verify the cluster is running with the Kubernetes control command.

Learn how to create a Kubernetes pod as the smallest deployable unit, bundle a container with a manifest file, and configure labels, image, and port for deployment.

Create a pod by applying a yaml manifest with kubectl apply -f, then verify with kubectl get pods and kubectl describe, and test access with port forwarding.

expose your Kubernetes app outside the cluster with a nodeport service, mapping port 7000 to 5000 via node port 30000.

Learn how Kubernetes namespaces isolate team resources within a cluster, create namespaces via cli or manifest, and deploy pods and services within a namespace using kubectl.

See how a Kubernetes pod self-heals after an application crash, briefly causing downtime, and learn how deployment objects prevent this by keeping the app up.

Deployments solve downtime by creating a replica set that maintains multiple pod replicas; traffic is redirected during pod failures, and rolling updates with rollback are available.

Illustrates rolling updates and rollback in Kubernetes by building and deploying a new image, then gradually replacing pods without downtime while managing replica sets.

Explore how Kubernetes horizontal pod autoscaling (HPA) uses CPU utilization and a metrics server to adjust replicas. See vertical pod autoscaler for stateful pods in a live demo.

Explore how Kubernetes uses liveness and readiness probes to monitor app health, restart unresponsive pods, and route traffic only to ready pods, even when a database like MongoDB is involved.