AWS EKS Kubernetes-Masterclass | DevOps, Microservices

Install and use three CLIs—AWS CLI, kubectl, and eksctl—to manage AWS EKS clusters, Kubernetes objects, node groups, and Fargate profiles from the command line.

Install the AWS EKS vendor kubectl binary matched to your cluster version, download the 1.16 binary, set executable permissions, and update PATH. Verify the version v1.16.8-EKS to confirm compatibility.

Install the eksctl command line interface on macOS using Homebrew, verify the version, and note cross‑platform setup for Windows or Linux; next, learn to create the eks cluster.

Explore how AWS manages the EKS control plane while you provision clusters, worker node groups, Fargate profiles, and VPC design considerations for secure, scalable production workloads.

Verify the EKS cluster, node groups, and nodes, including public subnets and routes. Inspect eksctl setup and cluster context for management.

Understand EKS cluster pricing and the control plane costs in us-east-1, learn how to delete and recreate clusters to save on expenses, and review worker node costs for t3-medium instances.

Learn to safely delete an EKS cluster and node groups with eksctl, rollback manual edits, and clean up resources like NAT gateways, network load balancers, and related CloudFormation items.

Master Docker fundamentals, from what Docker is and its architecture to installation on Windows and Mac, learn flows: pull from Docker hub and build, run, and push images.

Explore how Docker solves traditional infra problems by packaging apps into portable containers and images, using the Docker daemon, client, and registry for consistent, scalable deployments across environments.

Explore Docker architecture and terminology, including Docker host and daemon, Docker client, images, containers, networks, volumes, registries, and the flow of pulling, running, and pushing images.

learn how to pull a docker image from docker hub, run it as a container locally with port mapping, manage containers, and remove images.

Build a custom nginx Docker image locally, test it on port 80, and push to Docker Hub using a Dockerfile, tagging, and verification steps.

Master essential docker commands for managing images and containers, including ps, stop, run, remove, pull, and exec. Learn to login, view stats, and connect to a container terminal.

Explore Kubernetes architecture, master and worker nodes, etcd, kube-api server, and scheduler. Learn how container runtimes, kubelet, and kube-proxy enable service discovery, load balancing, and storage orchestration.

Understand how AWS EKS architecture abstracts Kubernetes master components and worker node groups, with Fargate integration, while AWS ensures control plane availability so you focus on designing and deploying applications.

Explore Kubernetes fundamentals, including parts, replica sets, deployments, and services, and learn imperative QCTL and declarative manifest workflows to create and manage scalable, reliable microservices.

Launch and inspect a Kubernetes pods demo with kubectl, verify node readiness, create a pod from a public image, and describe the pod to review its ip and events.

Explain how the NodePort service exposes a pod to the internet using a static port on each worker node, routing to the ClusterIP port 80.

Create and expose a Kubernetes NodePort service to the internet, explaining port, targetPort, and NodePort, and access the service via a worker node public IP using the node port.

Delete pods and services with kubectl delete and verify cleanup with kubectl get all in the default namespace, practicing step-by-step pod and service removal.

define a replica set in kubernetes with a yaml manifest to create three pods for my-helloworld-rs using the stacksimplify/kube-helloworld:1.0.0 image, and verify ownership with kubectl and ownerReferences.

Expose a Kubernetes replica set as a node-port service and access the hello world app in a browser; demonstrate reliability, scaling, and the role of labels and selectors.

Create a deployment with kubectl, scale from 1 to 20 then down to 10, expose it as a service, and test updates and rollbacks on nginx versions.

Update Kubernetes deployments with kubectl set image and verify rollout status and pod replacement. Compare rolling update versus recreate strategy and review rollout history to understand deployment behavior.

Update a Kubernetes deployment from v2 to v3 using kubectl edit deployment, track changes with --record, and verify rollout history and replica sets to confirm version 3 is live.

Learn to rollback a Kubernetes deployment using kubectl, undo to the previous or a specific revision, inspect rollout history, and perform a rolling restart to apply changes.

Learn how Kubernetes services enable internal and external access with cluster ip, node port, load balancer, ingress, and external name, and see front end and back end use cases.

Learn the declarative approach to Kubernetes by replacing imperative commands with yaml manifests and kubectl to create pods, ReplicaSets, deployments, and services.

Master YAML basics for Kubernetes manifests by defining key-value pairs, dictionaries, and lists; follow indentation rules, comments, and document separators, with practical sample files.

Create and test a port definition in YAML for Kubernetes, covering api version, kind, metadata, and spec, then build a node port service with containers and labels in kube manifests.

Create a node port service from a yaml definition to expose a Kubernetes app, using the label app: my app and port 31231 to access it in a browser.

Create and deploy a ReplicaSet using a YAML definition, verify the replicas and template, and prepare a NodePort service to access the app in the browser.

Create a NodePort service for the replica set with YAML, set type NodePort, port 80, node port 31232, and selector myapp2. Apply with kubectl and access via the browser.

Convert a replica set to a deployment using YAML and update the container image to 3.0.0. Expose it via a node port on 31233, then apply and verify in Kubernetes.

Write Kubernetes YAML manifests for a backend deployment and cluster IP service, then deploy, test, and verify end-to-end connectivity from the frontend, moving from imperative commands to declarative workflows.

Enable AWS S3 access from an EKS pod with the EKS pod identity agent. Create an IAM role for S3, install the daemonset, and bind it to a service account.

install the EKS pod identity agent, verify it runs on nodes, then deploy an AWS CLI pod without pod identity, test S3 access, and note the upcoming pod identity association.

Explore AWS EKS storage options, focusing on the EBS and EFS CSI drivers for persistent volumes, storage classes, and dynamic provisioning in a Myer scale deployment with note port service.

Create Kubernetes manifests for a storage class, PVC, and ConfigMap to enable Maya scale on AWS with the EBS CSI driver, wait-for-first-consumer, and a 4Gi PVC.

Explore the EBS CSI driver's features, including dynamic and static provisioning, block volumes, and volume snapshots. Understand beta and alpha states and how to enable storage class expansion.

Create the user management microservice deployment and a kubernetes node port service manifest, wiring the environmental variables to connect to the mysql database and reuse prior storage components.

Test the user management microservice in the AWS EKS Kubernetes masterclass using Postman by importing the collection, configuring the environment, and performing create, list, update, and delete operations.

Explore key Kubernetes concepts for application deployments, including secrets, initialization containers, and liveness and readiness probes. Implement resource requests and limits and use namespaces to isolate environments.

Explore Kubernetes probes—liveness, readiness, and startup—and how kubelet uses them to restart containers, control traffic, and handle slow-start apps, with command, http get, or tcp socket checks.

Set resource requests and limits for containers to guide scheduling and enforce bounds with the kubelet, using 500m cpu and 128mi memory as examples. Explore horizontal, vertical, and cluster autoscaling to handle high traffic and capacity.

Discover how Kubernetes namespaces act as virtual clusters that isolate objects, enabling multi-team environments, with default and system namespaces like kube-system, and per-namespace resource quotas.

Create a namespace manifest and a limit range manifest, update all manifests to the dev3 namespace, and apply with kubectl apply -f to enforce default cpu and memory limits.

Create Kubernetes objects from the manifest, including namespace, limit range, storage class, PVC, config map, deployments, services, and secrets in DEV-3; verify, view YAML, and clean up.

learn how to connect a Kubernetes on EKS cluster to an Amazon RDS MySQL database using an external name service, gaining automatic backups, high availability, monitoring, and managed upgrades.

Review the EKS cluster VPC, create a DB subnet group and a security group, deploy an RDS database in private subnets, and configure the endpoint for Kubernetes workloads.

Demonstrate deploying classic load balancers on Kubernetes, compare AWS load balancer types, and configure Kubernetes services to expose apps via public subnets and DNS URL, with SSL and 80–443 redirection.

Learn to deploy a network load balancer (NLB) in AWS EKS by applying a Kubernetes service manifest with NLB annotations, validate TCP-based load balancing and health status endpoints.