Mastering Docker & Kubernetes: Hands-On Guide with AWS

Explore the Kubernetes architecture with master and worker nodes, API server as the entrance, and components like etcd, controller manager, scheduler, kubelet, and kube-proxy, plus pods and Docker-based containers.

Understand how a Kubernetes cluster handles an nginx deployment, from the API server and etcd to the scheduler and kubelet, with pod recreation on failure and IP allocation by kube-proxy.

Learn to work with Kubernetes by creating manifests in VML or JSON, applying them via the API server to deploy pods on worker nodes and understand the master’s control plane.

Explore the master node components—api server, etcd database, scheduler, and controller manager—and how the api server handles user interactions via yaml or json manifests.

Explore how the Kube scheduler selects the best node for pods, coordinating with the API server and controller manager to schedule resources based on node capacity.

Ensure the cluster's actual state matches the desired state by coordinating manifests, api server, and scheduler on the master node; cloud controller manager handles cloud, kube controller manager handles non-cloud.

Provision a three-node Kubernetes cluster on AWS with one master (t2.medium) and two workers (t2.micro), install Docker and Kubernetes packages, configure networking with Flannel, and initialize and join nodes.

Launch a Kubernetes cluster on AWS by provisioning a master node and two worker nodes with Ubuntu, and configure access via a private key using Mobaxterm.

Complete Kubernetes cluster setup across master and two worker nodes by logging in as root, updating systems, installing Docker, and configuring Kubernetes packages with GPG keys.

Initialize the Kubernetes cluster on the master node with cubeadm init, join worker nodes using the provided join command, and verify the master node while next lab will configure workers.

Configure worker nodes by running the command to join the kubernetes cluster, fix firewall port issues in the security group, and prepare for troubleshooting in the next lecture.

Resolve worker node join issues by configuring security group inbound rules to allow all traffic for master and worker nodes, then observe kubelet progress until all nodes show ready.

Explore Kubernetes cluster types from a single-node all-in-one minikube to high-availability multi-master setups with Etcd and multiple workers. See how minikube enables local Kubernetes for learning, development, and testing.

Launch an aws ubuntu minikube server on ec2, install docker and kubectl, then install minikube with vm driver none to run a single-node kubernetes cluster.

Create your first pod with YAML by defining kind pod, API version v1, and a single Ubuntu container running a while loop, then apply with kubectl and verify pods.

Create a pod from yaml by specifying kind, apiVersion, pod name, and container image, with a command. Use kubectl describe to see the pod IP, node, and events.

Learn to check pods and describe them, then stream container logs with kubectl logs -f, using -c for specific containers, and delete pods when needed.

Create a pod with two containers using yaml, apply configurations with kubectl, and verify with get pods, describe, and logs to confirm both containers run inside the pod.

Explore Kubernetes annotations to attach metadata to pods using yaml, including who created, purpose, and creation time; learn to define annotations in metadata and apply with kubectl.

Create a pod with two Ubuntu containers, then enter each container with kubectl exec -it bash to explore the environment. Explore pod ip, container details, and the Ubuntu os inside.

Define environment variables for multiple containers in a pod, assign names and values, verify with env and echo inside each container, and manage the pod with kubectl commands.

Define a container port and forward traffic to the container on port 80 using kubectl and curl verification. Learn practical port mapping with a httpd image in a Kubernetes pod.

Learn how Kubernetes uses restart policies to automatically restart containers, enabling self-healing, with three options: always, on-failure, and never, based on exit codes and liveness probes.

Demonstrate the always restart policy in Kubernetes by running a BusyBox pod that sleeps 10 seconds, then observe containers cycling between running and completed.

The on failure restart policy restarts containers only if the process exits with an error or is unhealthy, as shown by a pod finishing with zero restarts.

Explore how the never restart policy in Kubernetes prevents a container from restarting after exit or a failed liveliness probe, ideal for single-run applications.

Learn how to use labels and selectors to organize Kubernetes pods by environment and department. Explore declarative labeling, interactive label updates, and equality- and set-based selectors with kubectl commands.

Practice lab demonstrates creating a pod with a manifest and labels, applying it with kubectl, and using kubectl get pods and kubectl get pods --show-labels and -l for label-based searches.

Compare declarative and imperative methods to define and query pod labels and selectors with kubectl, including adding labels, filtering by values, and not equal searches.

Lab covers applying yaml manifests to create pods with different labels, querying pods with label selectors, performing equality and set-based searches, and deleting pods by label.

Use node selectors to run a pod on a specific node by labeling that node and applying label selectors; the scheduler usually handles placement.

Learn to govern pod placement with a node selector by labeling a node (hardware=t2.medium), applying a yaml manifest, and verifying pod status with kubectl.

Replication controller creates and maintains a specified number of pod replicas to keep the application available, recreating crashed pods via a manifest with a selector, labels, and template.

Define a replication controller with a selector and pod template, set desired replicas, and apply with kubectl to create and manage multiple pods.

Scale up or down pods in a Kubernetes cluster by adjusting the replication controller replicas with kubectl, from five to eight or two as load changes.

Master how a replica set maintains a stable set of replica pods and guarantees a specified number of identical pods, using set-based selectors over equality-based replication controllers.

Practice creating and managing replica sets in Kubernetes by defining api version app/v1, env selectors, and pod templates; scale replicas from four to six and verify pods with kubectl.

Learn how Kubernetes deployment objects supervise pods, enable rolling updates and rollbacks, replace replica sets, and provide self-healing by recreating pods when failures occur.

Create and manage a Kubernetes deployment with two pods using a replica set and label selectors, then verify deployment status with kubectl get deploys, get pods, and logs.

Upgrade the app from version 1 to 2 using a Kubernetes deployment: modify the manifest, apply changes, and verify new replica sets, pods, and logs.

Master the rollback of a Kubernetes deployment by undoing a rollout with kubectl, switching between version three and version two, while watching pods, replica sets, and logs.

Learn to roll back your application to a specific deployment revision using kubectl rollout history and kubectl rollout undo, verify active pods, replica sets, and logs.

Explore Kubernetes networking by learning how pods assign ip addresses and enable container-to-container communication inside a pod using localhost, including a two-container pod example with port 80.

Open port 8081 on one container with netcat, verify it with netstat, then test inter-container communication from another container using telnet to localhost 8081.

Explore pod to pod communication within a Kubernetes cluster by using pod IPs on the same worker node, and test access with curl between Nginx and Apache pods.

Learn how the service object uses a selector to connect frontend and backend pods, providing a stable IP address and DNS name even as pods recreate with new IPs.

Demonstrates deploying a single pod via deployment, managing replicas with a replica set, and exposing the app inside the cluster with a cluster IP service for port 80 access.

Create and apply a service that exposes the deployment inside the cluster via a stable cluster IP on port 80, routing to the labeled pod.

Use a node port to access a Kubernetes app from outside the cluster, mapping to a public IP and port 80.

Understand how volumes in Kubernetes attach a storage medium to a pod and share data between containers within the same pod, with empty volumes created on pod assignment.

Perform a hands-on kubernetes lab to create a pod with two containers sharing an emptyDir volume, mounting the volume at synchronized paths and verifying file reflection across containers.

Deploy a deployment with a test volume attached to the container, then delete the pod to show a new pod starts with a clean state and no previous data.

Demonstrates creating a pod with a hostpath volume that is shared across containers and accessible from the host, ensuring data persists across pod recreation.

Delete a pod to see the deployment recreate it through the replica set, then verify that data on the host path volume remains accessible from the new pod.