Docker Essentials: Containerizing Apps for Beginners

Docker enables containerization by packaging apps as standardized containers that bundle code and dependencies. These containers isolate each other and share a host OS kernel, delivering fast software across environments.

On Mac, Docker runs a Linux virtual machine to enable Linux container features. Windows uses WSL or a VM depending on edition, exposing Docker client and server via Docker Desktop.

Understand how the host operating system runs processes, with the hypervisor and virtual machines as child processes. Note OCI guidelines, Docker’s popularity, Podman as an alternative, and Docker’s daemon requirement.

Install Docker Desktop on mac by downloading the correct edition for Intel or Apple Silicon, then run the app and verify the docker command in the terminal with docker --help.

Learn how Docker images pre-fill containers with needed runtimes and tools, so docker run creates an isolated container from an image, often sourced from Docker Hub or private registries.

Learn how to create Docker images for Tomcat and Node.js, run containers from those images, and use Artifactory as a repository for images and artifacts.

Pull the alpine image from docker hub, run a container to execute a command in a minimal linux environment, and remember a container ends when its process ends.

Learn how to run a long‑running Java process inside a container as a daemon, and explore Alpine images, docker ps, and container lifecycle.

Explore how Docker run pulls and starts containers from Docker Hub, using httpd as a web server example, and examine images, tags, and the Docker daemon in Docker Desktop.

Explore how the docker cli talks to the docker daemon via gRPC, run java apps in alpine images, and understand docker architecture including daemon, engine, and containers.

Learn how the Docker CLI on Windows manages images and containers, pulls from Docker Hub, and runs Alpine or Ubuntu with the appropriate shell, illustrating container lifecycles.

Run Java without installing it by using a Docker container with the official OpenJDK image; launch an interactive shell, verify Java version, and compile or run code inside the container.

Learn to run Node.js without installing node by pulling the official node image from Docker Hub and executing node commands or a .js file inside a container.

Learn how Docker images are deployed in production on cloud platforms like AWS and GCP, run via container hosting and Kubernetes, and stored with Docker Hub defaults.

Images are starting points and templates, while containers are instance environments spun from them. Immutability keeps changes inside a container from altering the image, ensuring predictable deployments.

Learn to manage running containers with the Docker CLI, listing with docker ps, stopping or killing containers, naming new ones, and removing them with docker rm, understanding container lifecycles.

Explain how Docker stores container and image data in Linux files inside WSL or a VM, and why you must stop a container before removal.

Learn to detach from running containers with -d, keep them in the background, and attach from outside using docker exec to run commands or open an interactive shell.

Run a MySQL server in Docker, set the root password via environment variables, connect with the MySQL client, and explore how container data persists when stopping or removing.

Learn how to persist data from containers by mounting a host folder with docker volumes using the -v flag, exposing a host directory to the container for writable, persistent storage.

Use a Docker volume mount to persist MySQL data across container restarts by mapping the host directory to /var/lib/mysql, enabling seamless data retention when you recreate the container.

Mount your host Java code via a volume mount into a Docker container with an OpenJDK image to compile and run without installing Java locally.

Explore docker volumes to persist data across containers by creating and attaching named volumes, inspecting mount points, and mounting volumes in containers for stateful workloads.

Map container ports to the host to access web applications from a browser, using docker run -p 8080:80 for nginx and repeat for additional containers.

Map volume mounts and port mappings to run a Docker nginx container, serving host html files via localhost:8080 for a streamlined development workflow.

Explore Docker architecture: the client communicates with the Docker daemon via gRPC, containerd creates containers, runc starts them, and shim hands them off to a daemonless container workflow.

Explore the anatomy of a Docker image and its layers, from base images to caching, and see how Docker pull, inspect, and RMI manage images.

Persist container state by using docker commit to save a modified container as a new image, such as hello ubuntu with hello.txt, though this approach is not recommended.

The golden image problem arises when fixes from a running container are hard to reproduce later. Use a Dockerfile to build reproducible, updatable images from the base.

Create Docker images by layering your app on a base image with a Dockerfile, using alpine as the base, then build and run containers with docker build and docker run.

Explore how to use RUN to chain commands like mkdir, cd, and echo to create a code directory and Hello world.txt, and how WORKDIR sets the container’s working directory.

The cmd command runs when a container starts and is saved in the image, unlike run which executes during image creation, and you can override it at container start.

Use the copy command to embed hello.java into a Docker image at build time, then rebuild to update changes. Run the container to execute the Hello class with OpenJDK.

Understand shell versus exec forms in Docker CMD. The exec form runs the binary directly as PID 1 using a JSON array of tokens, avoiding shell pitfalls.

Understand the difference between entrypoint and cmd in Docker, and how runtime arguments are appended to the entrypoint to start a container.

Master essential Dockerfile commands such as maintainer, add, copy, env, expose, volume, and user to build and run Docker images and manage environment, ports, and volumes.

Discover how a Dockerfile builds a Docker image by creating layers and using cache. See how containers, Docker commit, and environment variables shape each new layer in the final image.

Containerize a spring boot app by packaging it as a fat jar with the maven wrapper, then run it in an openjdk docker container using a dockerfile and port mapping.

Explore how docker virtualizes networks with a bridge by default, why ports must be exposed, and how port mapping enables localhost access to httpd (port 80) and tomcat (port 8080).

Docker networking demonstrates running an httpd container, mapping port 80 to the host, and accessing containers via the bridge network. Learn to inspect containers and use port forwarding.

Explore docker network types, from the default bridge to host, none, overlay for swarms, and specialized ipvlan and macvlan networks, plus third-party drivers, with security considerations.

Explore docker networking by examining the bridge, host, and none networks. Create and connect containers to a custom bridge network to enable inter-container communication.

learn how docker compose lets you start, stop, and manage multiple containers with a yaml file and the compose cli.

launch docker compose by defining version and services, spin up mongodb and readers containers with ports and env vars, and manage them with docker compose up and stop.

Configure a docker compose workflow to run a spring boot app alongside a Postgres database, ensuring both are up and reachable.