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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.