Table of Contents
Getting Ready for Practical Projects
This part of the course moves from theory to practice. Up to now you learned what Docker is, how to run containers, how to build images, how to work with networks, volumes, and Compose, and how Docker fits into development and deployment. In the Practical Projects section you will use those skills to build small but realistic setups that resemble real development work.
Here you will not learn new Docker features in isolation. Instead, you will combine what you already know into complete workflows. Each project focuses on a different kind of application and a different way of structuring containers.
What You Should Already Be Comfortable With
Before starting these projects you should already know how to run a basic container, how to read and roughly understand a simple Dockerfile, and how to use Docker Compose at least at a basic level. You also should have a working Docker installation on your machine and be able to run a simple container from Docker Hub without issues.
If any of this still feels unfamiliar, it is worth revisiting earlier chapters first. The projects assume you can already perform basic actions and will not re explain them.
How the Project Chapters Are Structured
Each project chapter will walk through a specific scenario. You will see how to think about container boundaries, what belongs inside an image and what is better mounted as a volume, and when to introduce Docker Compose instead of a single docker run command.
The project chapters will not try to cover every possible language or framework. Instead, they will show representative patterns that apply across many stacks. For example, the way you dockerize a simple web app in one language is conceptually similar to how you would do it in another. The same is true for a backend API and a full stack application that combines multiple services.
What You Will Practice Across Projects
As you go through the projects, you will repeatedly practice a few core ideas. You will define images using Dockerfiles, then build, tag, and run them. You will attach volumes where application code or persistent data should live outside the image. You will add networking and port mappings so services are reachable from your browser or from other containers. You will describe multi container setups using Docker Compose and run them with a single command.
You will also see how the practices from earlier best practices and optimization chapters appear in real examples, such as avoiding unnecessarily large images, separating build and runtime concerns, and keeping configuration outside the image.
How to Approach the Projects
The goal of these projects is not to copy and paste commands without understanding them. The goal is to learn how to reason about containerized applications on your own. As you work through each chapter, take time to predict what will happen before you run a command, then compare your expectation with the actual result.
Try to adapt each project slightly to your own environment. For example, change a port, modify an environment variable, or add another small service. This will help you move from following instructions to designing your own setups.
Common Patterns You Will See
Across all projects you will notice a few recurring patterns. Simple applications can often run as a single container built from a straightforward Dockerfile. Once you introduce a database or an external dependency, Docker Compose becomes helpful so that you can describe the whole system in one file. Full stack applications tend to require separate containers for frontend, backend, and database, plus one or more shared networks and volumes for data.
You will also see how health, logs, and restart behavior start to matter more when you move from a quick test container to something that looks more like a real application.
What Comes After the Projects
After completing the project chapters, you should feel comfortable taking a small non containerized application and planning how to dockerize it. You will know how to split concerns into services, define images, wire them together with networks, and keep data where it belongs. From there, you will be ready to apply Docker to your own projects or to follow more advanced material that builds on these foundations.
The next chapters in this section present concrete examples. Each one focuses on a particular style of application and shows how to assemble the necessary Docker pieces into a working whole.