AWS EKS (Elastic Kubernetes Service)

Define containers as isolated, portable environments and trace their evolution from hardware and virtualization to docker daemon and lightweight, isolated processes.

Explore how monolithic apps evolved into microservices and how containers realize those components as lightweight, isolated units. Scale individual functionalities independently, use multiple languages, and enjoy fast container startup.

Examine Docker containers and the Docker daemon, showing how images are built, stored in registries, and run as containers via docker run, pull, and push, including multi-container hosting.

Understand the docker working architecture, where the docker daemon runs images to create containers. See how docker clients on laptops and instances pull images from docker hub and run containers.

Install and configure Docker on Red Hat Enterprise Linux, including the Docker daemon and client, set up Docker Hub registry, and connect to Docker Hub for pushing and pulling images.

Learn Dockerfile basics to build images and run containers. Package Python, Flask, or Java apps with their dependencies into images, then deploy to a registry and launch containers.

Create a dockerfile for a flask app, build an ubuntu-based image, install dependencies with pip, run the container locally, and push the image to elastic container registry for eks deployment.

Build docker images with docker build from your project directory, using -f when needed and tagging with v1. Explore Docker Hub to locate official images and basic container run steps.

Learn how to inspect and tag docker images, push them to Docker Hub, and pull to run containers. Understand login, repository naming, and basics of docker image commands.

Learn docker container management with commands such as run, start, stop, logs, inspect, rename, rm, and exec, including port mapping and troubleshooting via logs.

Explore Docker network basics and how containers communicate within and across networks using Docker network, bridge and overlay drivers, container names, and subnets and IP addresses.

Learn to create and run containers with docker container run, using environment variables, port publishing, container naming, and volumes to persist data in a lab.

Explore how Docker volumes persist container data beyond lifecycles, using named volumes and volume drivers, then bind mounts map host directories for real-time data sharing.

Discover how Kubernetes orchestrates containers across multi-node clusters with a master and worker nodes. Use the control plane and kubectl to deploy Docker images from Docker Hub.

Explore the Kubernetes architecture, detailing the master node with API server, scheduler, controller manager, and etcd, and the worker nodes running kubelet and kube-proxy to manage containers.

Set up a three-node Kubernetes cluster with kubeadm, installing Docker, kubeadm, and kubectl on the master and workers, initialize the control plane, join workers, and install a Flannel network plugin.

Restart an AWS EKS cluster after stopping two compute instances by starting the docker service on all nodes (master and worker), then verify status and retry kubectl to list nodes.

Add a new worker node to the eks cluster by creating a join token. Run the join command on the new node using the master ip 6443 and the token.

Learn to set up a two-node Kubernetes cluster on cloud instances by installing Docker and Kubernetes tools, configuring hostnames, installing the weave network, and joining workers to the master.

Discover how Kubernetes pods, the basic execution unit, encapsulate containers, define storage with volumes via a YAML manifest, and deploy pods across a cluster using kubectl and the API server.

Learn to build, test, and push docker images, then deploy a two-container pod on a kubernetes cluster using a simple manifest, and troubleshoot with describe to fetch pod details.

In this lab, troubleshoot container issues in pods by using kubectl logs and describe, then fix environment variables in the manifest with EMV and re-create pods.

Label the nodes and use a node selector in the pod manifest to assign pods to specific nodes, illustrating scheduler decisions and API server coordination in AWS EKS.

Review pod networking basics by tracing Docker Bridge and NAT, mapping container IPs to node addresses for external communication, and using Kube Bridge for cross-node routing.

Explore how pod networking across multiple ports on separate nodes uses queue bridge, CU Bridge, and tunnel overlay to enable container-to-container communication without NAT, simplifying port mappings.

Examine how box containers on master and worker nodes manage network communication across ports, and view these system containers with docker to see api server, scheduler, and flannel.

Demonstrate inter-container communication inside a pod using localhost and a shared port. Log into each container, curl the other, adjust the Dockerfile, rebuild the image, and test with localhost.

Explore intra-pod and inter-pod communication in AWS EKS by demonstrating container-to-container calls across ports on the same node and across nodes, using port IP addresses.

Explore container networking with the container network interface (CNI) standard, including network namespaces, Docker bridge, and plug-ins like Flannel and Weave Net for Kubernetes clusters.

Explore Kubernetes networking with network plugins, inter-node communication, and DNS service discovery. Learn how a manifest file declares the desired state and pods scale via labels and selectors.

Explore the complete Kubernetes picture by linking the API server, scheduler, and controller with the kubelet, kube-proxy, and the network plugin used in the cluster.

Explore how labels attach metadata to objects and how selectors use these labels via equality-based and match expressions to drive controllers like replica sets and deployments.

Explore labels and selectors in an aws eks cluster, showing how to create pods with labels via yaml manifests and manage them with imperative kubectl commands, and filter resources using selectors.

Examine replica sets using labels and selectors to manage multiple pods; a manifest with apiVersion, kind, metadata, and spec ensures scalable, identical replicas via template and selector.

Deploy five pods with a replica set using a manifest and templated pod, leveraging labels, selectors, and environment variables; scale and self-heal while noting non-templated pods.

Learn to create a replica set with non-templated pods using labels and selectors, ensuring template matches, to prevent stray pods and illustrate the declarative model and self-healing.

Learn how deployments in AWS EKS manage rolling updates and rollbacks by automatically creating replica sets, enabling zero-downtime upgrades, and supporting recreate, rolling update, and blue-green strategies.

Explore how Kubernetes deployments create pods even when replicas are not specified and scale to three replicas when requested, with default rolling update behavior and labels managed by the deployment.

Explain how a deployment automatically creates and manages replica sets by hashing the pod template to assign a pod template hash label, while scaling maintains consistent labels.

Scale deployments by increasing or decreasing replicas in a Kubernetes deployment, verify with describe and events, and learn how deployments relate to replica sets and deployment updates.

Learn how to update a deployment in aws eks using recreate and rolling update strategies, manage replica sets, swap container images, and apply max surge and max unavailable limits.

Explore how horizontal pod autoscaling works in EKS by configuring a deployment with an HPA, setting min and max replicas, and using CPU utilization and matrix metrics to trigger scaling.

Explore Kubernetes namespaces as logical groups that isolate objects like pods and deployments within a cluster, and learn to enforce resource quotas to segment CPU, memory, and storage across environments.

Explore Kubernetes namespaces such as default, kube-public, and kube-system, see how objects default to default namespace when unspecified, and learn to create namespaces and deploy to them with cross-namespace access.

expose your Kubernetes app to the outside world with a nodeport service by mapping the service port to the container port and accessing it via a node IP and nodeport.

Learn how to add a new worker node, create a namespace, deploy a deployment and a NodePort service, and access the app via external and cluster IP.

Explore cluster IP services in AWS EKS, enabling internal pod-to-pod communication within the cluster using a cluster IP, service port, and target port, without external access.

Explore how Kubernetes services rely on kube-proxy to push port mappings into iptables, exposing a service IP and node port or cluster IP, while load balancing traffic across deployment pods.

Discover how services connect deployments and pods across a front-end, back-end, and database setup using clusterIP and nodePort for internal and external access, and loadBalancer with endpoints for external applications.

Connect an external database from a Kubernetes cluster using a Kubernetes external service and endpoint, linking a cluster IP to the external IP and using a service name for dns.

Explore how dns maps human readable service names to ip addresses and enables service-to-service communication. See how kubernetes dns resolves names within a namespace using the pattern service.namespace.svc.cluster.local.

Explore how the KUB DNS cluster IP enables DNS resolution for services, tested from busybox across default and broad namespaces with a NodePort service.

Resolve service dns in aws eks by editing the master resolv.conf to point to cluster name servers 10.32.0.2 and 10.32.0.3, and use the service cluster ip for resolution.

Explore how service names resolve to IP addresses via name servers within a Kubernetes cluster, using deployments, namespaces, and DNS for cross-service communication.

Understand how volumes are created outside pods and mounted for containers, preserving data beyond lifecycles. Explore persistent volumes, storage classes, and persistent volume claims with dynamic provisioning via cloud providers.

Learn how storage class drives dynamic provisioning of persistent volumes via the cloud provider, with aws ebs gp2 as an example and options like reclaim policy and volume binding mode.

Learn to create a persistent volume with capacity five gb, filesystem or block storage, access modes like read write once or read write many, reclaim policies, and storage classes.

Learn how persistent volume claims bind to persistent volumes in AWS EKS, using storage classes, dynamic provisioning, or manual PVs, and mount them into deployments.

Explore how Kubernetes authenticates users and authorizes access via outside-the-cluster identity providers. Learn authentication methods, static passwords avoided, and use x509 certificates, webhooks, and OIDC-based single sign-on with JWT tokens.

Discover how kubectl authenticates to the api server via the dot cube directory and its config file, and how clusters, contexts, and user certificates enable access.

Explore authenticating to an EKS API server using X.509 certificates. Create a user private key, CSR, and signed cert, configure kubeconfig, and test access.

Explore how authentication and authorization work with rbac in a cluster, using rules and role bindings to grant users access to boards, deployments, and services within namespaces.

Learn how RBAC uses cluster rules and cluster rule bindings to grant cluster-wide permissions, including non-namespace resources like nodes, persistent volumes, and secrets.

Learn how a service account authenticates an application to the Kubernetes API server and how namespace-scoped RBAC role bindings grant access to deployments within a namespace.

Learn how a Kubernetes service account creates an implicit secret and token, mounts the token into pods, and enables authentication, including default service accounts and secrets.

Explore how network policies isolate communications in an AWS EKS cluster using a board selector, a namespace selector, and IP block to define ingress and egress rules across namespaces.

Demonstrate deploying a blue board in the default namespace and applying a network policy that allows traffic from 1711 00 slash 16, with egress to the broad namespace.

Implement and test Kubernetes network policies in AWS EKS by applying ingress and egress rules across blue, orange, and green pods using namespace and pod labels, with default deny safeguards.

Use DaemonSet to run a pod on every node and leverage ConfigMap to inject environment variables, enabling dynamic updates without redeploying the application.

create and manage batch workloads with kubernetes jobs, running a container to completion and terminating, using parallelism, completions, and backoff limits, plus cron jobs for scheduled tasks.

Explore ingress in Kubernetes on EKS, using ingress resources and controllers to route external traffic to services by host and path, via gateways and virtual servers.

Configure security context to run containers as non-root users with specific group ids, optionally at board level or container level, and apply capabilities like net admin to limit root privileges.

Learn to centralize Kubernetes logs—from application to kubelet—by deploying a log agent as a daemonset and forwarding to cloud logs or stackdriver for real-time analysis.