Kubernetes and Docker: The Container Masterclass

Explore how containers are built, shipped, and run with Docker, and preview dockerfiles as blueprints, docker images, and the Docker architecture.

Explore how Docker works by examining the architecture and core components: Docker client, Docker host, and Docker registry, plus Docker daemon, Dockerfile, images, and containers.

Understand how dockerfile instructions, processed by the docker daemon, build layered images, with Dockerfile naming, and three instruction categories: fundamental, configuration, and execution.

Learn to write a Dockerfile, define ARG and FROM, use Ubuntu 16.04 as the base image, and build and tag your image with docker build.

Explore dockerfile configuration on an ubuntu 16.04 base image, using run and env to shape the environment and codes directory, then build and tag as img_run-env.

Create a docker image from Ubuntu trusty with labels and an exec-form entrypoint that pings localhost five times; cmd provides localhost as its parameter, and build as img_entry-cmd.

Build and tag a docker image as img_expose from ubuntu:16.04, install nginx, expose port 80, and run the container with port 8080 mapping.

Discover how multiple dockerfiles in a directory work, use the onbuild instruction for inheritance, and build base and child images with docker build -f to propagate changes like greetings.txt.

Demonstrates implementing a Dockerfile healthcheck and stop signal, and containerizing a sample Flask application, building and running the container, and verifying its health status.

Explore Docker Hub, a cloud-based service for building, linking, and managing Docker images, and learn to set up automated builds with Dockerfile and code repositories.

Explore how Docker images stack read-only layers from a Dockerfile with a read-write top layer, identified by image ID or tag, and pushed to Docker Hub.

Search docker hub with docker search, filter official images, and format results; list images with docker images, and pull, tag, and push nginx variants to a repo-nginx on docker hub.

Explore how to inspect docker images with docker inspect, view metadata like image id, repository name, and image tag, and trace intermediate layers and history using docker history.

Learn to clean Docker host by listing images, removing a 1-alpine-perl tagged image and its intermediate layers, then verify, and use rmi with image IDs for forceful removal.

Define containers as running instances of docker images, with read-only layers and a writable top layer via copy-on-write, using linux namespaces and isolated file systems.

Track the container lifecycle from created to deleted, using Docker run, start, pause, unpause, stop, and restart, with Copy-on-Write preserving read-only layers while enabling read-write changes.

Compare Docker container create and run commands using a BusyBox image. Observe container IDs, the docker ps -a output, and how -d and --rm flags influence lifecycle and resource allocation.

Start, stop, restart and rename containers using docker commands; verify with docker ps -a; restart cc-busybox-A with a 5-second buffer and rename it to my-busybox.

Attach a running container to your terminal and explore its root filesystem with docker attach, then learn how docker exec keeps the container alive while you run commands like pwd.

Inspect the ubuntu container to retrieve its ip address with docker inspect and a format flag. Commit the container to a docker hub image, ubuntu 1.0, with a read-only layer.

Learn container exposure by mapping host port 8080 to container port 80 with -p, using the expose instruction for -P mapping, then verify by accessing localhost and the nginx homepage.

Learn practical docker container clean-up techniques, including removing stopped containers by name or id, force deleting running containers, using docker container kill with SIGTERM, and pruning to free resources.

Explore how multi-container apps communicate using docker network drivers and IPAM, from single-host setups to multi-host clusters. Learn to create and manage networks with docker network commands.

Explore the Docker container networking model, from host network infrastructure and Linux stack to Docker network and IPAM drivers, Docker engine networks, and container endpoints enabling DNS and external communication.

Explore native docker network drivers, including host, bridge, and overlay networks, and how they enable cross-host container communication with IPs and isolation in swarm mode.

Create docker networks using docker network create with the bridge driver, naming networks as my-bridge and my-bridge-1, then list, filter by bridge, and view default networks and IDs.

Learn to connect and manage docker networks, using docker network connect and inspect to attach containers to bridge and host networks, view endpoints and IP addresses, and practice disconnecting networks.

Explore docker networking by creating a custom bridge network net-bridge, attaching cont_database (redis) and server-A (busybox), and pinging them to demonstrate IPC and network isolation.

Identify which container data to back up by examining the read-only and read-write layers. Choose appropriate storage—volumes, bind mounts, or tmpfs—to persist data across restarts with isolation and security.

Demonstrate creating Docker volumes, listing and inspecting them, and removing volumes, including filtering with dangling=true and handling in-use errors when a volume is mounted by a container.

Demonstrates mounting the vol-ubuntu docker volume to an ubuntu container, making changes in /var/log, and backing up data to the host via the local volume driver.

Demonstrates testing and using bind mounts between a docker host and a container, showing source and destination paths, read-write access, and bind propagation with rprivate default.

Host a containerized open-source 2048 game by cloning the repo, bind-mounting it into the nginx container's html directory, and exposing port 80 to 8080 for localhost play.

Discover how Docker Compose defines a multi-container application in a single file and starts the app with one command, translating definitions into Docker Engine containers, networks, and services.

This demo guides installing Docker Compose on Linux by downloading the binary from the official GitHub release with curl and verifying the installation with docker-compose --version.

Explore the docker-compose file structure in a multi-container setup with services, volumes, and environment variables using docker-compose version 3.3, including a mysql database and wordpress frontend.

Launch WordPress with docker compose up, creating a default bridge network and volumes for wordpress_files and db_data. Observe mysql container linkage, port mapping 8000:80, and a functioning WordPress database.

Explore Docker Compose CLI by viewing the compose with config, listing images, tailing logs, inspecting containers with ps and top, and cleaning up with down, using MySQL and WordPress services.

Explore how a container orchestrator coordinates multi-host deployments with Docker Swarm, balancing replicas, services, and resources from a single HTTP API endpoint.

Docker swarm handles failure by reassigning tasks when a worker fails and promoting a new master through mutual election, keeping the cluster running with more than half the nodes online.

Install a hypervisor to set up a docker swarm cluster by installing Oracle VirtualBox on the host. Update sources, add the GPG key, and install virtualbox-5.2 via apt.

Install docker-machine from the official git repo, curl it into /usr/local/bin, and verify the setup with docker-machine --version to create hosts for a swarm cluster.

Create the first manager node with docker-machine using boot2docker on VirtualBox, assign the dedicated ip 192.168.99.100, then add worker nodes and inspect their details with ls, ip, inspect, and ssh.

Initialize docker swarm on the manager with docker swarm init, advertise its IP, then join workers with docker swarm join and the generated token, forming a functional swarm cluster.

Verify swarm status with Docker node ls, confirming one leader manager and two workers. Inspect nodes with Docker node inspect self for id, hostname, joining, engine version 18.06.1, community edition.

Create and manage a docker swarm service with three replicas of nginx:latest, using port 8080 mapping, inspect tasks and service state, and verify nginx pages across manager and worker nodes.

Drain a node in the swarm with docker node update --availability drain to safely reschedule containers to other nodes. Remove it with docker swarm leave and verify cluster status.

Scale a docker swarm service from three to six replicas, verify with docker service ps, perform docker service update to nginx:alpine, then docker service rm and leave the swarm.

Compare Docker Swarm and Kubernetes, detailing setup ease, command line interface differences, monitoring, and fault tolerance, and explain why Kubernetes dominates cloud platforms for large-scale orchestration.

Trace the origin story of Kubernetes, from Google's early infrastructure and the rise of Linux containers using namespaces and cgroups, to the need for large-scale orchestration.

Explore kubernetes architecture by examining the master and node roles, kube-apiserver, etcd, kube-controllermanager, kube-scheduler, and the reconciliation loop that maintains desired and current states.

Bootstraps a Kubernetes cluster on Google Cloud Platform by provisioning VMs, installing Docker and Kubernetes components, initializing the master, deploying a pod network, and joining worker nodes.

Explore how pods encapsulate containers in Kubernetes, making pods the smallest unit of orchestration and the main interface to interact with containers, with the default restart policy set to always.

Explore how to operate Kubernetes with imperative and declarative approaches, managing objects through commands and files, and apply YAML-based workflows to create, update, and scale across batch processes.

Demonstrates creating a pod imperatively and declaratively in Kubernetes using yaml, then compares kubectl create -f and kubectl apply, and analyzes pods with get and describe.

Understand the pod life cycle from pending to running, then to succeeded or failed, including scheduling on a node, kubelet signals, and possible re-scheduling and unknown states.

Explore Kubernetes container lifecycle hooks postStart and preStop on a lifecyc-pod nginx pod, showing postStart echoes after created and preStop before termination, and verify with kubectl exec.

Demonstrate adding a container command and arguments in a pod using a command-pod.yaml, printing hostname and Kubernetes port with printenv, and verify via kubectl describe, get pods, and logs.

Demonstrates configuring container environment variables in Kubernetes pods via a YAML file and kubectl commands, with Google container registry images and the POD_GREETING and POD_FAREWELL variables.

Explore how Kubernetes uses labels to group pods and selectors to find them. See a demo with pink and blue pods across namespaces, showing isolation and identical names.

Explore Kubernetes namespaces and pod isolation by inspecting default, kube-system, and kube-public, listing pods across all namespaces, creating my-namespace, and launching a pod inside it.

Learn how pod resource requests and limits affect container scheduling and stability, illustrated by a two-container pod (MySQL and WordPress) adjusted from 128 MB to 1 GB to prevent OOMKilled.

Explore Kubernetes controllers as parent objects that supervise pods. Identify replica sets, deployments, statefulsets, and jobs: replication, updates, service exposure, pod ordering, and termination after execution.

Explore replicasets as the higher-level controller that supervises pods, scales their replicas, and uses labels and selectors to manage pod creation via a pod template, under deployment supervision.

Demonstrates creating a replica set (apps/v1) named replicaset-guestbook with 3 replicas, using selectors and a pod template, and shows how deleted pods are automatically recreated to maintain the desired state.

Explore deployments as all-round Kubernetes objects that create their own replicasets to manage pods using labels and selectors, support rolling updates, and expose services for stateless applications.

Deployments in Kubernetes orchestrate nginx pods using a deployment.yaml with apps/v1, replicas, and rolling updates, controlling replica sets and pod templates to ensure scalable, controlled updates.

Learn how jobs in Kubernetes supervise pods with time- and iteration-limited containers, creating completed tasks for batch or parallel processing, including cron jobs for periodic checks.

Demonstrate creating and verifying a Kubernetes batch job from a jobs.yaml that prints pi to 2000 decimals, including backoff limits, status, and logs.