Docker from beginner to the master

Explore Docker engine editions—community and enterprise—and learn how dockerd, REST API, and CLI enable scalable, secure containers, with Kubernetes or Swarm, and quarterly versus monthly versions.

Learn how Docker runs Linux and Windows programs in containers across architectures, with stable, test, and nightly update channels, and supports desktop and server deployments on macOS, Windows, and Linux.

Learn how Docker operates in the cloud, as Docker is available across many cloud platforms, on virtual or physical machines, and in almost every cloud environment.

Install Ubuntu server on VirtualBox by creating a VM with 8 GB RAM and 40 GB disk, enabling OpenSSH, and selecting Docker runtime, AWS CLI, and Google Cloud SDK snaps.

Install the docker engine on ubuntu by updating package indices, adding the docker repository, and installing docker-ce. Start and enable the daemon, create the docker group, and verify with hello-world.

install docker engine on centos 7 via the docker-ce repository, then start docker and verify with hello world. configure post-install steps for non-root users and enable docker on boot.

Open the firewall port on a Red Hat Linux machine using firewall-cmd, confirm the port is enabled, and reload to apply the configuration.

Deploy rootless Docker from a low-privileged user to securely manage containers without root access, and explore configuring the environment, executing Docker commands, and verifying daemon behavior.

Explore docker concepts hands-on in an online sandbox with the docker playground, learning container deployment, management commands, and running redis containers in a configurable web preview environment.

Install docker desktop on windows with wsl 2, update the linux kernel, then build and run a container using alpine, nginx, and python, and push the image to docker hub.

Install Docker Desktop on Windows by enabling Hyper-V through PowerShell, running as administrator, and choosing to restart when prompted.

Explore docker client–daemon architecture, where the docker client communicates with the docker daemon to build, run, and distribute containers via a REST API over unique sockets or a network interface.

Explore the Docker daemon, dockerd, which listens for Docker API requests, manages images, containers, networks, and volumes, and coordinates with other daemons across laptops, data centers, and the cloud.

Build and run containers from read-only images, defining steps in a Dockerfile with layers, and publish or pull images from registries like Docker Hub, demonstrated with Grafana on port 3000.

Learn to pull grafana images with docker pull grafana/grafana:8.0.4, run containers with port mappings to 3000 and 3001, and manage them with docker ps and docker rm.

Run BusyBox to experience a tiny container image, about 1 MB on-disk, and compare it with Ubuntu, Debian, and Fedora sizes. Create a Dockerfile for the BusyBox binary.

Explore the docker command line, learn how to list commands, view usage and version information with docker help, -v, and --version, and access the docker command reference.

learn how docker create builds a container layer from an image and pulls it if needed. docker create prints container id and prepares container for starting with docker start.

Understand how docker run creates and starts a new container from an image, with interactive (-i) and detach (-d) modes, and how it pulls images if missing.

Assign a name, allocate a pseudo-tty, and run a Docker test container with Debian latest; interact with a bash shell and verify exit code 13.

Capture container id with the --cidfile flag during docker run, which writes id to a file and prints test to the console; if the file exists Docker returns an error.

Explore full container capabilities in docker by running an interactive container with privileged mode. Observe that mounting tmpfs is blocked by default but allowed with the --privileged flag.

Learn how to set the working directory in Docker using the -w flag, run commands inside /path/to/dir, and create the directory in the container if it doesn't exist.

Mount a tmpfs into a docker container using --tmpfs, creating a read-write, noexec, no set uid /run with a defined size; verify inside with mount | grep run.

Learn how docker ps lists containers, with default behavior showing only running ones, and use options like -a for all containers and -q for bare IDs.

Learn to use docker images to list images by repository and tag, view IDs and digests, and filter with time and reference, while formatting output with -q, --no-trunc, and --format.

Learn how to remove multiple containers with docker rm, containers must be stopped to remove, force with -f, remove volumes with --volumes, and IDs via docker ps -a -q.

Use docker rmi to remove one or more images, including tagged and untagged. Force removal with -f for images in multiple repositories, and remove all images with docker images -q.

Create and run a docker container from a loaded image in detached mode, verify with docker ps, then force remove containers and delete the image to observe web app disconnection.

Deploy your first container by running the official Redis image in detached mode and exposing port 6379. Inspect and monitor containers with docker ps, docker inspect, and docker logs.

Attach to a running docker container to view and interact with its input, output, and errors using container id or name, and learn the detach sequence and exit statuses.

Learn to run a new command in a running container with docker exec, using options, container name, and command, while noting default workdir, environment variables, and interactive sessions.

Learn to run and manage a docker container in detach mode, expose ports, attach and exec inside, inspect the container filesystem, and remove containers with force using the npm-static-app image.

Build a Docker image from a base nginx image by writing a Dockerfile, copy html content, expose port 80, and run with docker build and docker run.

Create a new image from a container's changes with docker commit, applying Dockerfile instructions via --change (CMD, ENV, EXPOSE). By default, the commit pauses the container and excludes mounted volumes.

Learn how to save docker images to a tar archive with docker save, using --output or -o to specify the tar file, with BusyBox examples.

Load docker images from an archive or standard input with docker load, using -i/--input or -q/--quiet to share containers without a registry.

Run docker containers in detached mode with port mappings, then create a secret file inside the container. Commit changes to a new image (3.1) and save it for sharing.

Master docker export by understanding how it exports a container's file system and why it excludes mounted volumes. Learn how to redirect output to a tar file.

Import a tarball or remote archive to create a filesystem image with docker import, from file or input, naming the repository and applying cmd, entrypoint, env, expose, volume, and workdir.

Create data containers in Docker to store persistent data and configuration, copy files into them, share volumes with containers via --volumes-from, and export or import to move data between machines.

Learn to fetch real-time Docker events and apply local and scope filters, view the last thousand logs, and use filters to narrow by event type, container, volume, or network.

Learn to run dot net framework in docker using Windows Server Core images, with simple console and web app deployments, and manage production versus development container runs.

Learn to build docker images with a Dockerfile, starting from Ubuntu 14.04, installing apache2, adding index.html, and exposing port 80. Build, run, and test the container.

build docker images with docker build using a dockerfile and build context, running apt-get updates and installing apache. explore adding files, exposing port 80, and building from git repositories.

Explore Dockerfile instructions, including the from instruction and parent images, how to pull and build images, and the role of comments and argument directives in Dockerfiles.

Create and manage docker labels as key-value pairs to attach metadata to images, including multi-labels, quoting rules, and inheritance from base images, with inspect --format to view details.

Explore how docker metadata and labels attach to containers and images, enabling querying and filtering by keys and values, and supporting dns-style notation and consistent guidelines.

Explore how the run instruction creates a new layer by executing commands in a Docker image, comparing shell form and exec form via a JSON array and environment variable expansion.

Understand the docker cmd instruction and its forms—exec form, shell form, and json array defaults—and how it provides defaults for an executing container, often alongside the entry point.

Explore how the dockerfile shell instruction selects and overrides the default shell across Linux and Windows, with PowerShell, CMD, and other shells, including practical examples and behavior.

In this lab, build your first Docker image from a Dockerfile on Alpine, install Python and a simple http server, run the container, and test port 5000 exposure.

Discover how docker build cache works by comparing instructions to base images, using checksums to invalidate cache when files change, and how add, copy, and run commands influence caching.

Learn how the Docker expose directive marks a container listening on a port, expose port 80, publish it externally, run the image, and curl its IP to verify access.

Demonstrate using entrypoint to specify the default app inside a container and how Docker run passes arguments to it, with examples showing the home directory and the print working directory.

Discover how ENV defines docker environment variables, override them at runtime with the -e option, and build and run images using docker build and docker run to observe echoed values.

Learn how the ARG instruction sets variables at build time, how defaults work, and how to override them with --build-arg during docker build.

Copy files or directories from a source into the container's filesystem at the destination, demonstrating how the Dockerfile copies home directories during image build.

Learn how to use the Docker ADD and copy commands to manage compressed archives in a container, unpack them, and run tests to verify the build.

Learn how the Docker workdir instruction sets the working directory inside a container, with examples showing the DMP and the effect when the directory is set to empty.

Explain how the user instruction sets the container's current user and group, using user or uid and gid parameters, and show how id reflects the configured user.

Explore how the onbuild instruction adds metadata triggers to a base image that flow into a later from build, demonstrated with unbuilt instructions, image labels, and Docker inspect checks.

Learn how the healthcheck runs a command inside a container to test health, updating status from starting to healthy or unhealthy via retries, interval, timeouts, and start-period.

Learn to build more complex docker images by using the index file, entry point, workdir, copy, env, and expose, then map ports and run containers.

Learn to use a .dockerignore file to control docker build by excluding files and folders, preventing development or temporary data from being copied into the container.

Learn to safeguard Docker images by ignoring sensitive files with a .dockerignore, speed up builds with directory patterns, and share ignore rules in source control.

Identify dockerfile mistakes, such as using latest tags and external services, and avoid placing expose or env at the top or running multiple services in one container.

explain how the Alpine base image, a tiny Linux image around 5.5 MB, reduces size and costs versus Ubuntu, with a quick runtime comparison.

Discover how the Docker builder pattern creates small, secure images with a two-stage build, reducing image size from 900 MB to 12 MB and improving performance and security.

Learn to use multi-stage builds to create smaller production images by building in a large base and packaging in a minimal runtime image in a single Dockerfile.

Compare two Docker build approaches, showing that fewer layers and copying needed files preserve cache. Avoid cache invalidation and reduce image size with a single-run strategy that copies select files.

Learn to manage containers with docker stop, stopping one or more containers by name. Use the --time or -D option to set a grace period (default 10 seconds) before termination.

Learn how to terminate running docker containers with docker kill by sending signals such as hang up or kill, using container id, name, or image.

Learn to use docker start and docker stop to manage containers, toggle between detached and interactive modes, and customize the detach key for attaching container input.

Restart and manage Docker containers using the Docker restart command, exploring options like wait times, container names, and sequential shutdown and startup behaviors.

Pause a Docker container by suspending all processes with the freezer cgroup on Linux, making them unaware of suspension, while Windows supports pause only for Hyper-V containers.

Learn how Docker unpause resumes all processes in a paused container on Linux, using the freezer subsystem.

Learn to use docker info with --format to display kernel version, container and image counts, and details, then switch Docker Desktop between Linux and Windows containers with no data loss.

Learn to use Docker stats to monitor live container resource usage, filter by container names or IDs, and control streaming and formatting with options like --all, --format, --no-stream, and --no-trunc.

Monitor container performance with docker stats, tracking cpu usage, memory usage (memory percentage), network i/o, and block i/o across one or more containers using built-in metrics and live data.

Learn how docker top reveals running processes inside a container, view pids from inside and outside, and attach to a container to inspect processes with ps -e.

Learn how to use docker cp to copy files between a container and the host, including source path, standard input, and container name, with piping and tar archives.

Explore Docker history to view the creation timeline of a container image and use the --no-trunc option to reveal full information.

Inspect docker objects to retrieve low-level details for containers, including names, IDs, and network settings, and format output with JSON or Go templates to extract IP addresses, ports, and images.

Learn to format docker ps output with the --format option, using template syntax and table helpers, and extract extra data with docker inspect for container ids and ip addresses.

Learn to monitor a BusyBox container's standard output and standard error in real time with docker logs, using -f to follow and -t for timestamps.

Explore managing container logs with various log drivers, including syslog, and redirecting output to external systems; inspect configurations with docker inspect and disable logging when needed.

Docker diff teaches how to inspect changes in a container’s filesystem, tracking added, deleted, and changed files since container creation, using docker diff by container name or id.

Learn to manage Docker containers by running, stopping, restarting, and inspecting them, and monitor resource usage and logs, and export container file systems or remove containers.

Learn how docker volumes persist data beyond ephemeral containers, enabling external storage for files and databases, and explore mounting options, including bind mounts and local or remote volumes.

Explains how volumes defined in a Dockerfile create persistent data on a base Debian/Ubuntu image, with three local volumes for apache2 paths like /var/log/apache2 and /var/www, using apt-get.

learn to create and manage docker volumes with docker volume create, name a volume like demo volume with the local driver, and inspect or format the output using --format.

Learn to inspect docker volumes using docker volume inspect, format output with -f/--format and go templates, and identify volume name and local scope from the results.

Learn to remove Docker volumes with Docker volume rm, including force removal with -f/--force, and removing one or more volumes, demonstrated with a demo volume.

Remove all unused local volumes with docker volume prune, using -f or --force to skip confirmation. The command deletes unused volumes and displays the total reclaimed space.

Create and inspect a local Docker volume named my volume, then mount it to BusyBox containers to persist data in the data folder.

Learn to persist data across Docker containers using volumes, map host directories for bidirectional sharing, enable upgrades and backups, and control read/write permissions with volumes from a container.

Discover how Docker networking uses network drivers to assign container IPs, override DNS on a per-container basis, and connect containers on bridge networks with isolation.

Discover how Docker engine creates three networks and launches containers on the bridge network. Use Docker network ls to view the network ID, the driver, and the local scope.

Create and configure docker networks using docker network create, selecting bridge or overlay drivers, and defining subnet, gateway, and ip address ranges for efficient network management.

Learn to delete docker networks with docker network rm, using examples to remove a single network or multiple networks, and understand the impact of network removal.

Learn to run a container on a specific network with docker run --network, naming the container as training container and using the BusyBox image on the training network.

Learn how to keep containers alive and auto restart on failure in docker, using on-failure with a retry limit and the always policy, and inspect restart logs.

Connect a running container to a named Docker network using Docker network connect, optionally assign an IP to the container, then inspect the network to verify the container’s IP.

Disconnect a container from a named network with docker network disconnect, using the network and container names. Inspect to confirm disconnection, and use --force or -f if needed.

Inspect docker networks, explore the inspection options, and identify network names with a practical demo and reference materials for beginners pursuing mastery.

Remove all unused networks using docker network prune with the --force or -F option to bypass confirmation, as shown in the example where two networks are deleted.

Explore how to create and manage a bridge docker network, connect web server containers with aliases, test with curl, and implement a simple round-robin dns lookup setup.

Explore docker networks by creating backend and frontend networks, attaching containers to them, and using an embedded DNS server with aliases to enable container discovery and communication.

Deploy and link a Redis data store to an application in another container, using friendly names, aliases, and environment variables to enable seamless cross-container communication.

Balance requests across multiple Docker containers with the Engine X proxy that dynamically updates load balancing as containers launch. Explore container communication via environment variables, host entries, and service discovery.

Explore Docker registries, including Docker Hub and private registries like Artifactory, Google Cloud Container Registry, Microsoft Azure, and Amazon Web Services, with step-by-step installation and usage guidance.

Create a Docker Hub account, sign up for the free plan, verify your email, and create a new repository to begin using containers.

Create a new repository on Docker Hub by naming it, adding a description, and selecting public or private visibility, noting free accounts allow one private repo, then create.

Explore tagging Docker images, referencing source and target images, and pushing tags to private registry and central Tokyo registry with registry hostnames and ports for deployment.

Learn to log in to docker hub via the command line using username and password options, including piping the password from standard input, and connect to a self-hosted registry.

Push Docker images to a registry and organize them with repositories and tags, demonstrating version 1.0 on Docker Hub and verifying repositories after pushing.

Learn how to pull docker images from public and private registries, use options like --all-tags, and manage local registries and credentials.

Learn to use docker search to find images such as busybox, apply filters (-f), format output, and identify official automated builds across Windows and Linux containers.

Deploy a registry server using the official registry image, configure ports, restart policy, and bind mounts, push and pull images locally, and explore persistent storage options.

Explore how docker compose defines and runs a multi-container application with Docker, using a single file called docker-compose.yml.

Install docker compose locally by downloading the current stable release from GitHub and set executable permissions. Verify the version with docker compose --version on macOS, Windows, and 64-bit Linux.

Explore docker-compose.yml by defining services such as web service and radio service with a volume, and learn to run docker-compose up -d to pull images and create the app image.

Explore docker compose schemas and the compose file, which define services, networks, and volumes. Learn how version formats and major-minor numbers impact compatibility with the Docker engine.

Explore docker compose services by defining build from the current directory or using a public registry image, configure networks, volumes, and limits, and connect a web service to radio service.

Use Docker Compose to run postgres and adminer, inspect containers to verify environment variables and restart policy, and view running ports with Docker Compose ps.

Configure and mount local volumes with Docker Compose, inspecting them to verify mounting. Reuse volumes across runs and create external volumes with docker volume create, then reference them in Compose.

Docker Compose creates a default app network; services join it and are reachable by hostname equal to their container name. Explore networks, overlays, and file format versions.

Master docker-compose build to create service images, apply build args, manage caching and resources, and expose ports as you assemble and run containerized apps.

Explore building and running Windows nano server with the nano silver image in Docker, including creating, starting, and accessing the command line interface.

Learn to build and run a Windows IIS container using a Windows server image, copy the content folder, expose port 80, and access via the container IP while monitoring W3SVC.

Learn to run docker-compose up to start and attach to services, detach in the background, manage recreation, orphan handling, and scaling with flags like --detach, --no-deps, --force-recreate, --renew-anon-vols, --remove-orphans, --scale.

Learn how docker-compose run creates containers from images for services defined in the compose file, starts a specific service like web, and brings up the database as a dependent service.

Use docker compose stop to halt running containers of the web and database services defined in the compose file, with a note on starting via docker compose up.

Learn how to use docker-compose start and up to bring up service containers, check their status, and use docker-compose stop to pause and restart web and database containers.

Use docker-compose restart to restart all containers of a service, including the web and database containers; observe containers returning to the up state.

Learn how docker-compose builds images from a local compose file and how to view container names, repository, image id, and size by running commands in the compose directory.

Explore how to use docker-compose logs to view service output, tail a specific number of lines, enable timestamps, and gracefully bring down containers with docker-compose.

Learn how docker-compose ps lists running services, uses -q for quiet output, applies filters with key=value, and --all to include stopped containers, as two services run.

Explore docker-compose exec basics for running commands in a service. Use -e for env vars, -d to detach, -w for workdir, --privileged, and -u to set the execution user.

Use docker-compose down to stop and remove containers, networks, volumes, and images, with options for removing images, volumes, orphans, and a timeout (default 10 seconds).

Remove all containers for services defined in the docker-compose file using the docker-compose rm command, including containers created by docker-compose run or up.

Master Docker Compose by building a Python Flask app with Redis, creating a Dockerfile and docker-compose.yml, and running services to access the app at localhost:5000.

Learn to set up WordPress with MySQL using Docker Compose, start the environment, access the WordPress portal on port 80, and manage containers and volumes.

Learn to orchestrate multi-container apps with Docker compose by building a web and Redis setup, exposing ports, linking services, and scaling or stopping containers with Docker compose commands.

Learn to build, run, and deploy a two-container Docker app using a Flask backend and Elasticsearch, configure a custom food trucks network, and ensure container communication and service discovery.

Explore a streamlined development workflow with Docker Compose, enabling fast, iterative changes across multi-service apps, hot reloading, and local testing without rebuilding images for every change.

Deploy your dockerized app to AWS using Elastic Beanstalk and publish image to Docker Hub. Launch a single-container deployment with Elastic Beanstalk to scale and manage the app in cloud.

Automate continuous integration using Docker to create producible, isolated build and test environments, and push container images to Docker Hub via GitHub Actions and other ci tools.