Ultimate Docker Bootcamp For Absolute Beginners

Discover how computing devices evolve from physical servers to virtualization and containers, and why containers emerged. Learn how servers scale with CPUs, RAM, storage, NICs, GPUs, and cloud scaling.

Explore how data centers host servers and how virtualization splits a single server into isolated virtual machines. Enable isolation, resolve dependency conflicts, and improve portability and resource utilization with hypervisors.

Explore why containers emerged from virtualization and how they provide lightweight, isolated processes that share a host kernel. Learn how the container engine, notably Docker, enables portable, reproducible applications.

Build an image from a Dockerfile that runs containers across environments using Docker build and Docker run, and compare containers to virtual machines in terms of portability and speed.

Explore the Docker architecture, including the Docker client, Docker daemon, host, images, and containers, and learn how registries like Docker Hub enable pulling, building, and pushing images.

Explore how the docker engine on the host coordinates the command-line interface, the docker daemon, containerd, and runc to build, push, pull images and manage containers, volumes, storage, and networking.

Learn how Linux namespaces and cgroups enable containers through isolation and resource control. See how processes get a pid and how CPU, memory, storage, I/O, and network are allocated.

Set up a real world Docker host in AWS to run labs, compare cloud versus local VM options, and explore Docker Desktop, VirtualBox, and alternatives.

Learn how to create a free AWS account by signing up, verifying email and phone, adding a billing method, and selecting the basic support plan to access the management console.

Learn to set up AWS cost budgets with alerts, configure threshold-based notifications, and create a secure admin IAM user with proper sign-in and password management.

Explore the AWS free tier, focusing on 12 months of free EC2 usage (750 hours per month) with Linux or Windows t2/t3 micro instances and 30 GB of EBS storage.

Launch an Ubuntu EC2 instance as a Docker host on AWS, configure security group and IAM role for SSM, and manage key pairs and public IPs.

learn how to connect to an ubuntu EC2 instance from macOS or linux using ssh, locate and secure the private key, and verify connectivity with the public DNS.

Connect to the Ubuntu EC2 instance using SSM session manager or EC2 instance connect, verify connectivity with ping, and switch to root to access the Docker host.

Learn to connect to a Linux instance on AWS from a Windows laptop using Mobaxterm, including installing Mobaxterm, generating a key pair, and SSH access.

Learn to connect from Windows 10+ to a Linux EC2 instance on AWS using OpenSSH. Install and start the service, manage private keys, and configure security groups for SSH access.

Install and configure Docker on an Ubuntu EC2 instance, connect via SSM or SSH, install Docker packages and enable auto start, then verify with hello world.

Master docker pull, docker images, and docker ps to manage images and containers, including all or running states, and explore docker hub tags and latest versions.

Create containers from images with docker create using a name and optional tag; then start or stop them with docker start and docker stop; containers run as Linux processes.

Discover how to use docker exec to run commands in a running container, attach a tty for interactive shells, and pass input with -i and -t options.

Learn to run commands inside containers with docker exec, including interactive bash sessions (-it) and formatted output (-t). Manage containers and images with docker rm and docker rmi.

Execute docker run to pull, create, and start containers; it enables detached or interactive mode, pulls images from Docker Hub if needed, and supports --rm to remove containers.

Master docker run by exploring interactive and detached modes, container naming, exec access, and lifecycle commands like ps, stop, rm, and one-off executions.

master docker inspect to reveal low-level details of containers, images, volumes, and networks, including ids, creation times, image layers, volume sizes, and ip addresses.

Turn a customized container into a golden image with docker commit, install tools like curl, nano and ip, tag versions, and attach metadata for production use.

Modify a running ubuntu container, install curl, nano, and ip utilities, and save changes as a new image with docker commit. This manual process contrasts with using dockerfiles later.

Discover how the docker diff command shows added, changed, and deleted files in a container's filesystem compared to its original image, aiding debugging and auditing before committing a new image.

Discover how to manage Docker rm, rmi, prune, and logs to handle containers and images, including force removal of running containers, and use Docker help for guidance.

Learn to clean up docker images and containers with rm, rmi, and prune, handle dependencies with force, and explore logs and help to master common commands.

Discover how container startup relies on the image’s default command or a supplied command, and how -it and -d affect whether nginx containers stay up or exit.

Map host ports to container ports to expose dockerized apps like nginx, using docker run -p to publish port 80 to 3000, enabling external access.

Install Visual Studio Code from the official site and enable the Docker extension to streamline writing Docker scripts in VS Code.

Customize a dockerfile to build an image from a base, using from and run to install dependencies. Learn how layers, authors, and versioning affect image creation and migration.

Learn how the dockerfile cmd instruction sets the container start command. Understand build time versus run time and how docker build uses build context.

Explore docker build versus docker commit, showing how building from a Dockerfile yields automated, reproducible images with layers, while commit relies on manual changes.

Follow a hands-on lab to create docker files with alpine and ubuntu bases, and build images. Inspect layers with docker history and verify vim and git are installed in containers.

Optimize image layers by combining commands in a single dockerfile run, and compare docker history across builds. Build with local context using -f, and prune cache with docker builder prune.

Discover how the entrypoint defines the main command at container start, how it coexists with cmd, and how runtime arguments and overrides affect execution.

Explore how docker entrypoint and cmd interact, override, and conflict in dockerfiles; learn practical behavior by building images, running containers, and overriding entrypoints from the command line.

Explore how Dockerfile expose and copy instructions define runtime ports and copy code from the build context into the image, with emphasis on informational exposure and build-layer caching.

Explore expose and copy instructions in dockerfiles by building an nginx image, testing port publishing, and using copy to place test data and app code inside containers.

Explore Dockerfile workdir and copy to define and navigate the container file system, set environment variables with env, override them with docker run -e, and add metadata with label.

Create a ubuntu-based dockerfile that uses env action and target, installs ping, and sets a maintainer label. Build and run the image to ping 8.8.8.8 and inspect the labels.

Explore the dockerfile add instruction and how it differs from copy. Learn to copy from build context or remote URLs, with automatic extraction of tar and gzip archives.

Create a docker image using add with a URL or build context content, build app and remote directories, copy files, unzip and untar archives, and verify the container file structure.

Learn how to build docker images with dockerfile and docker build, tag and push to public or private registries, and optimize image layers for fast builds, smaller size, and maintainability.

Explore docker registries and how to push images to Docker Hub or private registries, using docker tag to rename with registry, account, repo, and tag, and docker push after login.

Create a Docker Hub account, verify your email, and sign in to access the dashboard; then create public or private repos and tag and push images to docker.io.

Push and pull images to a public Docker Hub registry, tag versions, build from a Dockerfile, log in, and verify digests in a hands-on lab.

Create and manage a private docker repository, tag images, and push them to private repos. Learn authentication, versioning, pulling, running containers, and repository management including deleting repos and removing images.

Explore Docker Hub image digests as immutable fingerprints that ensure production stability and security. Use a digest rather than a tag in the Dockerfile from line to guarantee reproducible builds.

Build a simple Dockerfile to create an nginx image and run a container on port 80. Verify the digest remains consistent and note potential Docker Hub updates and security scans.

Explore Docker networking fundamentals, including Docker zero bridge, container communication inside a host and with external networks, and modes like bridge, host, none, overlay, ipvlan, macvlan, and user defined networks.

Explore Docker bridge mode, where containers on the default Docker zero bridge communicate, while custom bridges isolate networks, with NAT enabling outbound access between containers and the internet.

Explore essential docker networking commands to view, create, and inspect networks, connect containers to custom networks, and manage subnet ranges using docker networks and docker run --network.

Explore docker bridge mode and the default bridge network, verifying container outbound access and the 172.17.0.0/16 ip scheme with docker0 and veth connections.

Create a user-defined bridge network, inspect its IP range and endpoints, attach containers, and learn that cross-bridge containers require a connection to the target bridge.

Explain docker bridge mode port mapping, including static mappings with -p and dynamic mappings with -P. Show how to avoid port conflicts and view mappings with docker port or docker ps.

Explore Docker bridge networking and host-to-container port mapping by publishing nginx ports, observing iptables NAT, and using the Docker port command to verify mappings across multiple containers.

Explore docker networking modes, including host mode, with 1:1 port mapping to the host IP stack, and none mode, which isolates containers for batch or file processing.

Explore docker host and none networking modes by examining the shared host IP stack, 1-to-1 port mapping, and configuring ports such as nginx on 80 and 8000 in lab scenarios.

Learn how to persist data in Docker by using volumes or bind mounts to survive container restarts, deletions, or failures, and to share data between containers.

Discover how named docker volumes persist data on the host, survive container restarts or deletions, and can be mounted into multiple containers from /var/lib/docker/volumes.

Learn how named Docker volumes persist data across containers by creating and mounting volumes, writing files, and validating read-write and read-only access across multiple containers.

Learn to use the Dockerfile volume instruction to create and mount volumes for a container, including anonymous volumes and named volumes, with data stored outside the container writable layer.

Create a docker volume with the volume instruction in a Dockerfile, build an image, run a container that mounts the volume, and verify by writing a test.txt in data directory.

Explore docker bind mounts, mapping a host path or file into a container with changes reflecting immediately. Use docker run for bind mounts in development, and prefer volumes for production.

Learn to mount volumes and bind mounts in Docker using the new --mount option, with source and target paths explained through practical examples.

Learn how bind mounts cause host path data to prevail in the container, potentially hiding container files and breaking apps; follow best practices to mount specific files and verify results.

Explore bind mount default behavior by comparing an empty host directory with a populated one, showing how mounts mask container files and reflect host directory contents in nginx.

Understand how named Docker volumes behave by default when mounted: empty volumes copy the container's content, while populated volumes overwrite the mount path.

Explores how named docker volumes behave when mounted to a container path; empty volumes copy image defaults, while volumes with data overwrite container files, revealing the mounted content.