Docker, From Zero To Hero: Become a DevOps Docker Master

Install docker on ubuntu by updating packages, installing dependencies, and adding the docker repository and gpg key. Verify installation with hello from docker and enable docker to start at boot.

Install docker on Debian 9 or 10, set up a Debian VM, update packages, add docker key, install docker, add admin to the docker group, and enable docker at boot.

Install Docker on CentOS seven and Fedora by provisioning a CentOS instance, installing dependencies, adding the Docker repository, and using Docker CE.

Learn how official Docker images from Docker Hub provide ready to run packages like Nginx or Apache, pull them with tags, and understand image layers and versioning.

Pull and manage Docker images, selecting latest or specific tags like MySQL 5.7. List local images with Docker images and remove unwanted images using docker rmi with tags or IDs.

Create a basic docker container from an official image using docker run in detached mode with port mapping, then pull, test on port 9090, and remove containers and images.

Create a custom image with a Dockerfile by starting from an official base such as CentOS, using the run instruction to install packages, and building layered images.

Use docker build to turn a dockerfile into an image named CentOS Apache version one, then observe how docker pulls base images, installs httpd, and caches layers for faster rebuilds.

Learn how to test a Docker image by running a container, configuring a foreground Apache process with CMD, exposing port 9090, and verifying a live webserver.

apply the from instruction to select a base image, and learn to build a docker image using a custom dockerfile name, context, and tagging.

Explore how the run instruction in Docker executes commands to overwrite nginx index.html. Build a versioned image and test in a container to verify the updated home page.

Master the Docker copy instruction by moving files from host to the image. Build CentOS image with httpd, copy html code to /var/www/html, and run a container to serve it.

Learn how the Docker ADD instruction downloads files from the internet into an image, compares ADD with COPY, and unzips content into the web root.

Learn to define and use environment variables in a dockerfile with the ENV instruction, reference them with $HTML, and echo them to an EMF.html file to verify output.

Use the working directory to define where commands run in a Dockerfile, so subsequent steps automatically operate in that folder, enabling tasks like unzipping code and moving files.

Learn how Docker labels add metadata to images using the label instruction, capturing maintainer, vendor, and version information, and apply these labels when building and viewing your images.

Explore how to browse and inspect a Docker image by running a container, entering it with docker exec -ti, and navigating its working directory to view files.

Add and switch to a dedicated application user in a Dockerfile, then change ownership of the html folder recursively to grant permissions before removing files as that user.

Use ARG in dockerfiles to parameterize builds with values like a user name. Define defaults and reference them with $var to control image creation, user, and packages during testing.

Learn how the CMD instruction keeps a container alive by running a foreground process. See why missing CMD causes the container to exit and how to run Apache in foreground.

Learn how the cmd keeps a Docker container alive in the foreground, view its logs with docker logs, and build a simple bash script as the cmd to start httpd.

Learn how the docker build context defines the files sent to build an image, including the current directory and its subdirectories; use the correct Dockerfile path and context.

Learn how dockerignore reduces build context by excluding folders, keeping the context small and improving performance. Place a dockerignore at the root and list folders to ignore.

master Docker image best practices: run one service per container, keep build context small with a .dockerignore, avoid unnecessary packages, and minimize layers by combining runs and using environment variables.

Build a docker image with apache, SSL, and PHP on CentOS seven, installing httpd and PHP, then test with a PHP info page.

Build a Docker image that runs Apache with PHP and SSL using self-signed certificates. Copy the certs into the image, configure SSL, and run a container on HTTPS port 443.

Learn what dangling images are, how they form when you build without a tag, and to locate and remove them from docker images. Use unique tags to prevent dangling images.

Learn to identify and remove dangling Docker images efficiently by filtering on the dangling attribute, using docker rmi to delete multiple images, and keeping tagged images.

Learn to build a Docker image with Nginx and PHP 7 on CentOS 7 by defining a minimal context, creating a Dockerfile, and installing via dedicated repos.

Finish configuring a docker image with nginx and php-fpm, applying nginx.conf and setting a web root, then build and run the container with a startup script.

Debug and solve a docker-based challenge by serving a php info page and html content with nginx and php-fpm, diagnose via logs, adjust fastcgi port, and rebuild images.

Learn how Docker multi-stage builds reduce final image sizes by copying only needed artifacts from a build stage to a lightweight final image, such as Alpine, using from aliases.

Build a multi-stage Docker image with a Maven build stage and an OpenJDK runtime stage, copying the jar and shrinking the final image.

Understand that a Docker container is the runtime representation of an image, a temporary writable layer where changes vanish on destruction, and that permanent changes require building a new image.

Learn to list and create containers with docker run and docker ps, using images like nginx alpine; understand detach mode, all containers, and the equivalent docker container commands.

Explore managing containers with docker ps to view container id, image, cmd, creation time, status, ports, and name, then delete or rename containers with docker rm and docker rename.

Map container ports to the host to access services in a browser, using docker run -p and docker ps, then manage containers with docker stop and docker start.

Learn how the docker container file system differs from the docker host file system, illustrating isolation and running a Jenkins container on port 8080.

Learn how to set environment variables in Docker images and containers, use docker run -e to inject runtime variables, and override image values with container-specific settings.

Launch a MySQL container from an official image, set the root password via environment variables, and verify startup using the container's logs and IP address.

Publish the MySQL container port 3306 and expose it to the docker host, create a database and a non-root user via environment variables, and verify connectivity from the host IP.

Learn to create a Docker Postgres container using the official image, configure with environment variables, map ports, and verify access via psql.

Learn to create a Jenkins container from the official Jenkins image on docker hub. Run it with docker run, map the port, and retrieve the initial password via docker exec.

Limit container memory and CPU usage to prevent overload, using docker run memory limits and CPU set CPUs, and verify with docker stats.

Copy files between a running Docker container and the host using docker cp. Copy into and out of an Apache server container, and remember persistence comes from the Dockerfile.

Turn a running container into a reusable image using Docker commit, acknowledging that containers are read-write layers and only image-defined configurations persist.

Learn to override a container's cmd at runtime without a dockerfile by passing a foreground command after the image, map ports, and verify with docker ps.

Learn to automatically destroy a container after you exit, using --rm and -it to inspect a temporary Docker container and validate image contents during builds.

Learn how Docker stores images and containers and how to move the Docker root directory to a new mounted disk by updating the Docker data root and restarting the service.

Explore how Docker volumes persist data after a container dies, saving database information on the host, like a MySQL container's data. Understand why volumes matter.

Learn why Docker volumes are essential for persisting data in a MySQL container and how to map volumes to host so data survives container recreation.

Learn how to use bind volumes to map host folders to a container, preserving data after the container dies and how to restore it with a new MySQL container.

Create and map normal Docker volumes with docker volume create to a container path such as /var/lib/mysql, persisting data, and contrast this with bind volumes that map local folders.

Explore what anonymous volumes are in Docker, how they’re created, and how to manage them, including the -v flag’s impact and dangling volumes.

Explore the differences between anonymous volumes, named docker volumes, and bind volumes, including how data persists, naming, and how removal affects data.

Explore how the Dockerfile volume instruction creates anonymous volumes, how -v affects volume creation, and how to manage data persistence with anonymous and bind volumes.

Identify dangling volumes and understand how anonymous volumes are created with docker run -v. Remove volumes with docker volume ls -f dangling=true and docker volume rm to reclaim space.

Learn how to persist data in a MongoDB docker container by mapping a host directory to /data/db, using bind mounts and port 27017, and verifying data persists across container recreation.

Learn to persist Jenkins data with docker volumes by mapping host folders to /bar/jenkins_home, fix permissions with user id 1000, and restart containers to preserve jobs and configs.

Map a host folder to the nginx container in Docker to persist web data, enable live updates, and serve pages on port 8080.

Share a directory between two containers by using a shared Docker volume, so one container generates HTML content while the other serves it with Nginx.

Explore Docker networks, including bridged, host, and default networks, and learn to create your own network, manage, and deploy networks to connect containers like web servers and databases.

Learn about Docker's default bridge network and how containers automatically attach to it, using the Docker zero interface as the gateway and subnet for IPs.

Explore the default bridge network, learn how containers attach to it, and ping peers by IP addresses, while noting that name-based pinging and --link are deprecated.

Create your own Docker network using the bridge driver, set a subnet and gateway, inspect and remove networks, and learn how to bind containers to this network.

Attach containers to a user-defined docker network with docker run --network, instead of the default bridge. Ping by name within this network for dns-style resolution and easier container communication.

Learn to assign a static IP to a container within a user defined network using the --ip flag, and see how to inspect the resulting IP with docker inspect.

Explore the docker host network and the host driver, showing how containers on the host network inherit the docker host's IP, interfaces, and DNS with the same host name.

Explore the none network in Docker, a default network with no driver that isolates a container with no subnet, IP address, interfaces, or gateway.

Discover how docker compose simplifies building multi-container applications by defining web server and database services in a single yaml file and launching them with one command.

Learn how to install Docker Compose on Linux by copying the official command, setting executable permissions, and verifying the installation with Docker Compose version.

Learn to use docker compose to define multi-container apps with docker-compose.yaml, create an nginx service from nginx:alpine, map ports, and manage lifecycles with docker compose up and down.

Master how to set environment variables in docker compose using the environment section or an emf file, applied to a mysql service with correct indentation.

Explore volumes in Docker Compose, including bind volumes that map a local folder to a container path and normal volumes defined at the top level, with practical examples.

Learn how to define and use networks in a Docker Compose file, create a test net, connect web and db services, and ping containers by service name to enable communication.

Learn to build images with Docker Compose by configuring the build context and Dockerfile name, and running docker compose build to create images from a Dockerfile.

Override a container's cmd using Docker Compose by defining a command in a version 3 compose file for a CentOS image, then run docker compose up -d to apply it.

Learn to run Drupal with Postgres using Docker Compose, persisting data with volumes and a shared network, connect Drupal to Postgres by service name, and expose port 8080 for setup.

Learn to install Joomla with Docker Compose, connect a MySQL 5.7 database, map volumes for persistence, and verify setup by recreating containers.

Learn to deploy a Prestashop e-commerce site with MySQL using Docker Compose, configure volumes and networks, expose ports, and troubleshoot container startup to run the store.

Install WordPress with Docker Compose by wiring MySQL and WordPress services, mapping data and HTML volumes, and setting root, user, and password environment variables.