Hiba N.
Sample Health checks fixed our flaky setup
Our API always crashed on first start because the database was not ready. The service_healthy lesson solved it.
Docker for developers: images, containers and Compose
Package your applications into small, secure images, run multi service projects with Docker Compose and use containers in daily development
Created by Lena Fischer
- Updated September 2026
- English
- Beginner
What you will learn
- Explain images, containers, layers and registries in plain words
- Write efficient multi stage Dockerfiles for Python and Node.js apps
- Persist data with volumes and connect containers with networks
- Run multi service applications with Docker Compose and Compose Watch
- Debug failing containers using logs, exec and inspect
- Scan, tag and push images to a registry safely
Course content
Containers from first principles
Building better images
- Video: Multi stage builds 12 min
- Video: Running as a non root user 9 min
- Article: Faster builds with BuildKit cache 10 min
- Video: Choosing base images 9 min
Networking between containers
- Video: Bridge networks and DNS 10 min
- Article: Ports, localhost and host access 9 min
- Video: Debugging connectivity problems 10 min
Docker Compose for real projects
- Video: Your first compose.yaml 12 min
- Article: Startup order and health checks 10 min
- Video: Environment files and configuration 9 min
- Video: Live development with Compose Watch 11 min
- Article: Profiles and overrides 8 min
Debugging and day two skills
- Video: Logs, exec and inspect 9 min
- Video: Containers that crash or restart 10 min
- Article: Resource limits 8 min
- Video: Cleaning up disk space safely 7 min
Sharing images safely
- Video: Tags, registries and pushing images 10 min
- Article: Scanning images for vulnerabilities 10 min
- Video: Building for several CPU architectures 9 min
- Video: Where to go next: Kubernetes and cloud services 7 min
- Quiz: Final check 6 min
Requirements
- Basic command line skills
- Some experience building a web application in any language
- A computer that can run Docker Desktop or Docker Engine
Description
"It works on my machine" stops being a problem when your machine and every other machine run the same container. This course teaches Docker from the ground up for developers: what containers really are, how to build good images, and how to run an application with its database, cache and worker using Docker Compose.
What you will learn
- The difference between images and containers, and what isolation they provide
- Writing Dockerfiles that build fast, produce small images and avoid common security mistakes
- Volumes, bind mounts and networks, and when to use each
- Docker Compose for multi service projects, including live reload during development
- Debugging containers that crash, hang or cannot reach each other
- Scanning images for vulnerabilities and pushing them to a registry
The project
We containerise a small web application with an API, a PostgreSQL database, a Redis cache and a background worker. You can follow along with the Python or Node.js version of the app. By the end, a new teammate can clone the repository and run the whole stack with one command.
You need Docker Desktop, Docker Engine on Linux or a compatible alternative such as OrbStack or Podman. Commands are shown for a terminal on macOS, Linux and Windows with WSL 2.
Who this course is for
- Developers who want a consistent local environment
- Students and juniors who see Docker in every job listing
- Backend developers preparing to deploy to Kubernetes or a cloud container service
Instructor
Lena Fischer
Container and Kubernetes trainer. Docker, clusters and production operations without the jargon
- 4.4 instructor rating
- 23 reviews
- 7,770 students
- 3 courses
- Sample
I run Kubernetes clusters and help development teams move their services into containers. Before that I was a backend developer, so I remember how confusing images, volumes and networking felt the first time.
My courses start from what you already know, a process on your laptop, and add one idea at a time: an image, a container, a Compose file, a Deployment, a Service. Every lesson has commands you can type and an explanation of what changed.
The advanced material comes from real incidents: crash loops, memory limits, failing probes and slow rollouts. I teach the debugging habits that help when the dashboard is red and you need answers.
Student reviews
Lara M.
Sample Finally understand what a container is
The first lesson on namespaces and cgroups made everything else make sense. No magic, just processes.
Bilal K.
Sample Compose Watch changed my workflow
Our local setup used slow bind mounts. Compose Watch with sync and rebuild rules made development much faster.
Dmitri O.
Sample Great Dockerfile habits
Copying requirements first, .dockerignore and multi stage builds cut our image from over a gigabyte to a fraction of that.
Jenny P.
Sample Clear and practical
The 0.0.0.0 tip fixed a bug I had spent an afternoon on. The networking section was very useful.
Jonas F.
Sample Useful security content
Non root users and image scanning are covered properly, which many beginner courses skip.
Ama S.
Sample Good for beginners
Starts gently and builds up well. A few more Windows specific notes would help, but WSL 2 instructions worked.
Ricardo V.
Sample Solid but slow at the start
I already knew docker run, so section one was slow for me. Sections two and four were excellent.
Keep exploring
All Docker and Kubernetes courses
More in Docker and Kubernetes
$34.99
Enroll now