Docker for Professionals: The Practical Guide

Introduces dev ops and compares waterfall and agile, explains iterative sprints and client feedback, and highlights infrastructure needs, virtualization, and cloud computing for rapid environments.

Cloud computing enables agile development by providing adaptable infrastructure and on-demand environments for rapid iterations, supporting IaaS, PaaS, and SaaS through automation and DevOps practices.

Explore devops misconceptions and show how collaboration between development and operations, supported by automation tools for continuous integration, containerisation, and version control, speeds up deployment.

Explore how Docker creates lightweight containers that isolate applications from the host system, using images and registries to ship consistent software across environments.

Explore common docker use cases, including isolating applications from host libraries and kernel changes, enabling software portability across Linux, Windows, and macOS, and securing untrusted software with containers.

Install Docker on Windows, macOS, or Linux, then run a container from an image downloaded from Docker Hub to print hello world, illustrating daemon operation and container isolation.

Learn to navigate the Docker command line, use Docker --help for subcommands, and run linked BusyBox containers to simulate a server and monitor its status.

Learn to create a service monitor by starting server and checker containers, viewing logs with docker logs, and managing container lifecycles with start, stop, and restart commands.

Explore pid namespaces and container isolation in Docker, showing how container processes have independent pids apart from the host in busybox examples.

Learn how docker handles multiple containers with isolation, descriptive naming, and unique ids, including short ids, full ids, and using cidfile to store container ids.

Explore how Docker assigns human-friendly container names and why naming conventions matter, then learn to build environment-agnostic containers using a read-only file system, environment variable injection, and volumes.

Learn to run WordPress in Docker by linking the WordPress container to a database, using environment variables for credentials, and handling write access with selective volumes on a read-only filesystem.

Learn how to bundle and override environment variables in containers, customize hostnames and paths, and pass variables for repeatable, agnostic deployments.

Learn how Docker restarts containers after failures using back-off restart policies, including always, on failure, unless-stopped, and default restart behaviors, with practical examples.

Learn how an init or process manager (pid 1) starts and continually restarts container processes to minimize downtime, with practical Docker examples showing syslog-like services auto-restarting.

Learn how a container's entry point runs the primary command to keep the container alive, override it with --entrypoint, and properly stop or remove containers with docker rm.

Identify and pull the correct Docker image by name, tag, and version from repositories and registries, then run containers while understanding image IDs, multiple tags, and the latest version concept.

Explore how to install and use images from Docker Hub, including reading a Dockerfile, building locally, pushing to a repository, and pulling from other registries; understand trusted versus automated images.

Learn to build your own Docker image from scratch by creating a Dockerfile, copying scripts, configuring a user and permissions, and running a server container with a simple infinite loop.

Explore how Docker persistent storage works by using volumes as mount points to decouple container data from images, enabling data backup, sharing, and scalable databases.

Learn when to use Docker volumes for persistent storage, separating data from the container, and optimize performance with SSD-backed volumes for databases and logs.

Learn to create and use Docker volumes for persistent data. Share a volume between containers to enable a simple database to store and retrieve records.

Learn how bind mount volumes provide persistent storage by mounting host directories into a Docker container, enabling live updates to data like CSP files without rebuilding the image.

Create a docker python script image to parse a csv file and generate insert statements for a database, using bind mounts and read-only volumes for persistent, protected storage.

Demonstrate sharing volumes via a host-dependent bind mount to synchronize a python-generated insert file with a database container, mounting a host path to /mount for data insertion.

Mastering generalized volume sharing with Docker, this lecture explains using bind and managed volumes for persistent storage, sharing data across containers via volumes-from, and handling mount points, conflicts, and inheritance.

Explore essential networking concepts for Docker, including protocols, IP addresses, network interfaces, the loopback (local host) interface, ports, and how HTTP and FTP enable local and remote communication.

Explore the docker network model, showing how containers connect via a private host interface to a bridge network and how routing and subnets enable container communication with external networks.

Explore creating a closed container and a bridged container, using loopback and host interfaces to control access, with busybox, netcat, port 10000, and 8.8.8.8.

Explore how container hostname and DNS configurations enable name resolution, using the --hostname flag and custom DNS servers to connect by hostnames rather than IP addresses.

Configure container name resolution by specifying dns servers, dns search, and fully qualified domain names to resolve hosts. Map hostnames to ips with add-host and restart to apply changes.

Discover how to control inbound access to containers using port publishing, map container ports to host ports, and test access on localhost or specific host interfaces.

Discover how joined containers share a network interface to enable inter-container communication, contrast this model with bridge networks and open containers, while noting potential port conflicts and security considerations.

Learn how Docker containers discover each other by linking, exposing ports, using the hosts file, and inspecting environment variables that expose container addresses, ports, and aliases for seamless communication.

Explore security and isolation by setting memory limits for containers with the -m flag, learn how memory and swap affect performance, and apply restart policies to prevent outages.

Learn how cpu allowance limits container resources, distinguishing out-of-cpu waits from memory exhaustion, and set cpu shares or restrict a container to specific CPUs to control performance.

Assign a cpu set to a Docker container to cap or grant cpu resources, explore cpu affinity across multiple cores, and learn practical commands for limiting resources and mapping devices.

Explore why containers run as root by default, the security risks, and how to determine and set the container user with id and --user options.

Explore docker volume permissions by mounting a shared file, then practice access control with container users and the --user flag to reveal read or denial outcomes.

Learn how to package software with Docker by turning container changes into reusable images through commit, building from a busybox base, adding files, and testing new containers.

Determine container changes before committing to an image using docker diff to list added, changed, and deleted files, then commit with a descriptive message and signature.

Learn how docker commit options attach messages and author signatures, preserving environment, entry point, and ports when creating new images, and how the union file system uses layers and copy-on-write.

Use the commit command to save container changes as an image, updating the top layer and its parent to form an image ID, while tags and repositories track versions.

Explore how Docker image layers are immutable and shared, how commits create new top layers, and how tags, history, and branching manage image sizes and versions.

Learn how to work with flat file systems in Docker, export and import images, and optimize changes by using containers and commits instead of editing image files directly.

Automate Docker image creation with a Dockerfile, choose a base image, install packages via apt-get, set a custom entrypoint, and test with docker run for multi-image builds.

Write clear dockerfiles to build images with python preinstalled and an entry point. Understand how from and from scratch bases, comments, and no-cache options affect build speed.

Learn to build a Python-based base image, optimize with .dockerignore, configure env vars, labels, and workdir, and use exec form entrypoints to run as a non-root worker user.

Explore building a base image that acts as a foundation for child images. Use Dockerfile concepts like copy, entrypoint, and cmd to pass arguments.

Discover how the ONBUILD instruction creates a base image with triggers that execute only in derived images, enabling layered docker builds.