Docker DevOps Bootcamp: Projects, CI/CD, Interview Prep-2026

Explore docker installation methods across cloud servers (linux with yum or apt on AWS, Azure, and GCP), on-premises terminals, and docker desktop for Windows and macOS, emphasizing setup and visualization.

Learn how to install Docker on Amazon Linux in AWS EC2, set up security groups and access, configure Docker, start the service, and verify Docker is running.

Create a Docker Hub account to browse and download images from hub.docker.com. Sign up with email, username, and password, then log in to explore images and repositories.

Master containers and containerization, delivering a portable, isolated package with all dependencies that runs consistently across environments. Explore docker, container runtimes, and kubernetes for scalable deployment in microservices.

Explore how virtual machines emulate full computers with guest OS and a hypervisor. Compare them with containers that share the host kernel via Docker and offer lightweight, fast portability.

Explore Docker architecture as a client-server system, detailing the Docker client, Docker daemon, images, containers, and registry, and how commands like docker run and docker pull orchestrate the container lifecycle.

Discover the five main stages of a Docker container lifecycle—create, start, run (the running state), stop, and remove—plus how pause, kill, and restart commands manage containers.

Discover Docker benefits - lightweight and fast startup, portability, scalability, isolation, and CI/CD friendly deployment - while noting orchestration with Docker Swarm and Kubernetes and alternatives like Portman, virtual machines, Cryo, and Containerd.

Understand Docker images as portable blueprints that include the base operating system, dependencies, and app code to run containers, with official and custom images stored in registries.

Explore essential docker images commands by learning how to list local images, pull from registries (Docker hub and private), view image history, and understand registry, repository, and tag naming.

Master docker image management by listing images, pulling with modern syntax, and inspecting image history to see how each image was built.

tag, inspect, and remove docker images, and learn to retrieve detailed image metadata such as id, creation date, size, environment variables, and configuration settings.

Tag Docker images with specific names, remove images via docker rmi or docker image rm, and inspect images to view id, repository tags, digest, architecture, and size.

Explore the Docker images command suite, including version search, help, and manual, and learn to use Docker version and Docker search to find and manage image versions on the CLI.

Learn to pull a specific docker image version using tags, compare latest vs named versions. Search images via the docker cli for apache httpd, JDK 17, and Jenkins variants.

Explore Docker health and manual commands to navigate documentation swiftly. Use help to list all commands and image-specific options, and consult the manual for in-depth, white-paper style details.

Learn to authenticate with docker login via the cli using a password or personal access tokens, resolve docker login required errors (including limit exceeded), and manage token permissions securely.

Learn the basics of docker container commands, including run, ps, stop, and rm, with options like detached mode, port mapping, and interactive terminals.

Learn to run containers with docker run, list active and completed containers with docker ps and docker ps -a, and explore images such as hello world and BusyBox.

Learn how to stop and remove docker containers using docker stop, docker rm, and docker rm -f, including checking containers with docker ps and using IDs or names.

Run a Docker container in the background with docker run -d, keeping servers like nginx running while you work. Verify with docker ps and learn to stop and remove.

Explore removing a docker image from a running container: untagging occurs and the image may remain as none, while force removal untags and removes the image.

Compare graceful exit code 0 with forceful kill code 137, and learn to kill a Docker container using Docker container kill, with practical commands.

Compare docker create, run, start, and restart to understand their differences, use cases, and how they prepare, start, resume, or refresh containers.

Explore the real-time differences between Docker container create, run, start, and restart, with practical guidance on when to use each.

Use docker inspect for detailed container information, including IPs, volumes, and networking, rename containers with docker rename, and view logs with docker logs for debugging and troubleshooting.

Name a docker container for clarity, run it in the background with a specific name using nginx image, then inspect it to view id, state, image, ports, and network addresses.

rename containers like nginx server to apache server using docker container rename, and view their logs with docker container logs and tail five to monitor activity.

Pause Docker containers to suspend processes temporarily with Docker pause, then resume using the Docker Compose command during maintenance to free resources or handle disk input/output tasks without shutting down.

Learn to temporarily pause and resume docker containers with the pause and unpause commands, observe containers in the paused state using docker ps, and understand practical use cases.

Learn two ways to enter a docker container: use docker run -it ubuntu bash at startup, or docker exec -it container bash inside a running container.

Learn how to run a docker container with a specific command, use batch (-b) and detach (-d) modes, and view container output with logs, distinguishing foreground and background execution.

Bring a background docker container to the foreground using docker attach to enable real-time output.

Explore dangling images and the prune command in Docker, explain why unused untagged image layers waste space, and demonstrate how Docker image prune frees space and keeps environments clean.

Learn how to reclaim space with docker prune, applying docker container prune and docker image prune to remove stopped containers and unused images.

Back up and restore containers with docker export and docker import, creating a container filesystem tar archive and reconstructing an image for migration between hosts and sharing without Docker Hub.

Learn how to back up Docker containers (running or exited) using export and import, creating tar or compressed files and converting them into images to run new containers.

Master offline sharing of Docker images by saving to a tar with docker save and loading with docker load, enabling backups and transfers in air-gapped environments.

Use save and load for images, preserving tags and layers and transferring full image history. Use import and export for containers, yielding a file system snapshot rather than image history.

Explore backing up and sharing Docker images and containers using save, load, export, and import commands, creating tar backups, and using SCP to distribute custom images.

Learn hands-on how to back up and load docker images, install docker, configure post installation steps, fix docker socket permissions, and use docker load to create images from tar backups.

Copy files between host and container with docker cp and review changes using docker diff. Apply use cases like retrieving logs, injecting files, and backup or restore.

Copy files from your local to the container using docker cp, and inspect changes with docker diff.

Explore docker restart policies to automatically restart containers after exits or failures. Learn when to use no, always, on-failure with retries, and unless-stopped to improve availability.

Learn how to use Docker restart policy to automatically restart a container on failure, including setting three restart attempts and inspecting with Docker inspect and logs.

Learn how port mapping connects a host port to a container port to expose dockerized services outside, using docker run -p syntax with examples like nginx.

Learn to access applications running in docker containers by inspecting containers, using curl to their IPs, and exposing nginx via host port mappings.

Access the dockerized application from a browser using port mapping (-p host port:container port) to map host ports 8080 or 81 to container port 80, and avoid conflicts.

Learn how to remove docker containers automatically after they exit using the --rm option, and distinguish manual removal with docker rm from automatic cleanup after completion, useful for testing.

Understand docker file components, from run copy add workdir cmd expose env entrypoint and how to build a reproducible, consistent image for easy sharing and deployment.

Create a basic ubuntu-based dockerfile using a from instruction and a cmd to echo hello world, then build with docker build and run the image to see the output.

Learn to build a dockerfile from scratch, focusing on the from, working dir, and copy instructions, and demonstrate copying files from different paths into /app and running the image.

Run an external script from a dockerfile by creating a shell script and executing it with CMD. Build and run the ubuntu-based image to see the script output.

Explore how the run command installs dependencies in a dockerfile, updating the ubuntu image with apt-get, installing git, and building and running the image with docker build and docker run.

Learn how to declare and use environment variables and labels in a Dockerfile, attach metadata with labels, and inspect and run containers to verify environment and label data.

Learn to set a docker file path from another folder using docker build -f, specify the build context with dot, and run to see hello world.

Create a dockerfile, add a user, switch to that user with the user instruction, verify with whoami, then build and run the container to confirm the user.

Learn how arg dockerfile provides runtime variables and how env persists build-time values, with hands-on examples using Ubuntu and Docker.

Compare docker cmd and entrypoint, learn how entrypoint provides a fixed command while cmd supplies arguments, and apply these concepts in practical Dockerfile build and run scenarios.

Learn how the expose command declares container ports, how -p maps ports to the host, and why exposure alone may not expose them to the outside world.

Master docker build context by copying files from a separate project folder into an image, using a Dockerfile with a base Ubuntu image and a specified context path.

Compare copy and add commands: copy moves local files into the container. Add supports external URLs and compressed archives, demonstrated with creating a tar archive and copying archive.tar into /app.

Learn practical steps to reduce docker image size: use minimal base images like alpine, adopt multi-stage builds, copy only necessary files, clean up packages, and apply a dockerignore file.

Master multi-stage docker builds to shrink image size and boost security by separating build and runtime in a Dockerfile, copying only what's needed into the base image.

Build and run a Node.js app using a two-stage Dockerfile, install dependencies with npm install, and expose port 3000 to display hello from Docker tutorial multi-stage build.

Explore docker hub, a cloud-based registry to store official and user images with automated builds, CI/CD integration, and private repositories; perform login, pull, and push workflows.

Learn secure Docker login using passwords or personal access tokens to authenticate with Docker Hub, then create a custom image and push it.

Push docker images to Docker Hub using a Dockerfile, build and tag versions, log in with access tokens, push images, and manage multiple versions for version control.

Learn to pull a custom image from Docker Hub, manage images with docker ps, rm, and rmi, and use tags and versions to pull specific variants.

Explore Docker storage types including volumes, bind mounts, and temps, and learn how to persist data beyond containers, enable data sharing, and back up with practical use cases.

Explore docker's default container storage, inspect the overlay directory for created files, and observe how ephemeral containers delete data when stopped unless persisted.

Explore Docker volumes, including named, anonymous, and read-only types, and learn how to create, attach, and manage persistent storage outside container lifecycles.

Explore docker volumes for data persistence by creating and listing volumes, mapping them to containers, and inspecting volume contents to persist files beyond container lifecycles.

Mount docker volumes using the mount option by specifying type, source, and destination. Compare this with the hyphen v method and learn about creating, inspecting, and read-write behavior.

Learn how anonymous volumes in Docker are created when no volume name is specified, how random names are generated, and how to inspect mounts and manage containers.

Mount docker volumes in read-only mode to safeguard secrets and project files from container writes. Verify by running a container with the read-only option and observing write attempts fail.

Demonstrates how multiple containers sharing a single docker volume expose files at a common level, and shows how to isolate data by creating per-container directories inside the volume.

Learn to remove unused docker volumes using docker volume rm, verify with docker volume ls, and remove blocking containers with docker rm to free the volume.

Explore bind mounts to map host paths into containers, enabling direct host filesystem access, instant changes, and seamless sharing of logs, config files, and secrets for testing and development.

Use bind mount to map a host folder into a Docker container, compare it with volumes, and apply it for development and testing with absolute paths.

Explore using EFS as a shared, scalable storage for Docker containers by mounting EFS across servers, enabling cross-server file access and persistent data.

Explore testing an nginx website without rebuilding images by using bind mounts for real-time HTML changes and volumes for production, with practical docker run steps and persist storage.

Explore tmpfs in Docker as a Linux‑only, in‑memory temporary file system in ram, not on disk, losing data when containers stop; ideal for tokens, passwords, and speed‑critical session data.

Explore tmpfs in docker as temporary in-memory storage, where data is not persisted after container stop or restart, with practical setup using docker run with mount type=tmpfs.

Explore how docker networking enables container communication, isolation, and service discovery across the host and external networks, reviewing default networks and six types including bridge, host, none, overlay, macvlan, ipvlan.

Explains the default bridge network in Docker, showing how containers get private IPs, communicate by IP, and why DNS resolution by name isn't supported, with port mapping for host access.

Create a dockerfile using the ubuntu latest image to install net-tools for ifconfig and iputils for ping, build and tag the image, and apply it to networking tasks.

Learn how the Docker host network mode shares the host network stack and uses the host IP. No port mapping is required, delivering lower latency and better performance.

Explore the none network in Docker, an isolated container network that disables external connectivity, DNS, and gateways for security testing and debugging container startup.

Learn how to create and manage Docker user defined networks, including bridge networks with customizable subnet ranges and inter-container communication via docker network connect.

Compare macvlan, ipvlan, and overlay networks in Docker, noting cloud constraints like AWS that prevent macvlan/ipvlan, while overlay supports multi-host communication for Swarm and Kubernetes.

Master Docker compose, a YAML tool for defining and running multi-container apps with services, networks, and volumes. Use Docker compose up, build, and ps to manage frontend, backend, and database.

Install Docker Compose on a Linux server by manually downloading the official package, followed by verifying the version and setting permissions for all users.

Explore the new docker compose format, including optional version removal, file naming as compose.html or compose.yaml, optional project naming, and the unified docker compose command using space (docker compose up).

Learn to set up docker compose with a node.js app and redis database, creating dockerfile and docker-compose for web and database containers, exposing port 3000.

Learn docker compose basics by mastering core commands—up, down, build, and ps—running services in detached mode, rebuilding with no cache, and managing containers.

Explore docker compose commands that mirror docker commands, using up, down, ps, logs, and images to manage containers. See practical examples of starting, stopping, and inspecting containers with compose.

Learn how to specify the absolute path to a Dockerfile inside a Docker Compose file, enabling use of Dockerfiles located in subdirectories.

Explore docker compose volumes, including named, anonymous, bind mounts, and temp volumes, and learn to map a host storage directory to a container using a Docker Compose file.

Explore a classic Docker Compose setup for WordPress with MySQL, using environment variables, volumes, and port 8080 to run and access WordPress locally.

Learn to run a single container with Docker Compose by building a Python Flask app, writing a Dockerfile and a docker-compose file, and exposing port 5000 with its network.

Explore Docker Compose with a two-container setup using a Python Flask app and Redis to track page views, including building images, defining services, and port mappings.

Learn to use docker ps, docker top, and docker stats, plus docker system df, to analyze container processes, memory and cpu usage, and overall system behavior.

Explore how Docker logging drivers control log capture and destination, including the default JSON file driver, centralized log management, and shipping to CloudWatch and Splunk.

Connect docker container logs to AWS CloudWatch by configuring IAM roles, the docker logging driver, and CloudWatch log groups, then run containers and see the logs.

Discover docker events, real-time notifications from the docker daemon that report lifecycle activities of containers, networks, volumes, and images, enabling monitoring and automated workflows.

Learn real-time container monitoring with cAdvisor, an open source tool running as a Docker daemon that tracks CPU, memory, disk, and network usage and exposes metrics via a web interface.

Learn hands-on docker monitoring with cadvisor, exploring containers, images, and system metrics using cadvisor and open-source tools like Prometheus, Grafana, and elk stack.

Set memory and CPU limits, including soft and hard limits, memory reservation, and CPU shares, to optimize resource utilization and prevent container monopolization.

Learn to set Docker memory limits with hard and soft constraints, apply memory reservation, and inspect limits with docker inspect and cadvisor.

Set hard CPU limits with --cpus and soft limits with --cpu-shares for Docker containers. Observe real-time cAdvisor metrics while running an nginx container on a one-cpu free-tier host.

Docker Scout analyzes container images to detect vulnerabilities, provides a software bill of materials (sbom), and offers image upgrade recommendations, image version comparison, and attestation for secure supply chains.

Explore Trivy, an open-source vulnerability scanner by Aqua Security, to scan docker images, filesystem, git repositories, and Kubernetes resources for OS and language-specific vulnerabilities, misconfigurations, and software bill of materials.