Quick recap and practice

Key concepts summary

• Docker packages an application so it runs consistently across environments.
• An image is the blueprint. A container is the running instance.
• A Dockerfile tells Docker how to build the image.
• docker build creates images. docker run starts containers.
• RUN happens at build time. CMD happens at start time.
• Lesson 3 turns the theory into a simple real app workflow.
• Lesson 4 explains how Docker volumes protect data from being lost with container changes.
• Lesson 5 explains how containers talk to each other using Docker networks.
• Lesson 6 explains how Docker Compose manages multi-container setups in one file.
• Lesson 7 explains how to pass configuration into containers without hardcoding values in app code.
• Lesson 8 combines Dockerfile, Compose, volumes, networks, and environment variables into one small real project flow.
• Lesson 9 explains how to debug containers using logs, inspection, runtime checks, and better troubleshooting habits.
• Lesson 10 explains why running is not always the same as healthy, and how readiness checks improve Docker reliability.
• Lesson 11 explains how to make Docker images smaller, faster, and cleaner through better base images, file copying, and caching.
• Lesson 12 explains how to write Dockerfiles that stay readable, stable, and easier to maintain.
• Lesson 13 explains when bind mounts fit development better and when volumes fit persistence better.
• Lesson 14 explains how multi-stage builds separate build tools from runtime images.
• Lesson 15 explains how Docker images are tagged, pushed, pulled, and shared through registries.
• Lesson 16 explains the first security habits for users, permissions, secrets, and cleaner images.
• Lesson 17 explains how Docker usage changes between development convenience and production stability.
• Lesson 18 explains how Docker apps move from local systems to deployed server or cloud environments.
• Lesson 19 explains why Nginx is often placed in front of application containers.
• Lesson 20 explains how frontend, backend, and database services combine in a larger Dockerized application.
• Lesson 21 explains why databases in Docker need stronger attention to persistence, backups, and migrations.
• Lesson 22 explains how Docker fits into CI/CD automation workflows.
• Lesson 23 explains why logs and monitoring are necessary after deployment.
• Lesson 24 explains how Compose patterns become more structured in larger projects.
• Lesson 25 explains how teams benefit from consistent shared Docker workflows.
• Lesson 26 explains why Kubernetes becomes relevant after Docker fundamentals and larger deployment needs appear.
• Lesson 27 explains what scaling means once one container is no longer enough.
• Lesson 28 explains orchestration ideas like scheduling, recovery, and desired state.
• Lesson 29 explains how production hardening goes beyond basic local container safety habits.
• Lesson 30 explains how Docker fits into broader real-world deployment architectures.

Practice questions

1. What is the difference between a Docker image and a Docker container?
2. Why do developers use Docker?
3. What does port mapping do?
4. What is the role of a Dockerfile?
5. Why are Docker layers useful?
6. What are the steps to build and test your first Dockerized app?
7. Why are Docker volumes needed?
8. Why should containers on the same network use names instead of `localhost` or changing IPs?
9. What problem does Docker Compose solve?
10. Why are environment variables better than hardcoded configuration?
11. How do Dockerfile, Compose, volumes, and service names work together in one real project?
12. What is the best order to debug a broken Docker container?
13. What is the difference between a running container and a healthy container?
14. Why do `.dockerignore`, base image choice, and Dockerfile order matter for optimization?
15. Why are bind mounts usually better for local development while volumes fit persistent data better?
16. Why do multi-stage builds improve final production images?
17. Why do image tags and registries matter in team workflows?
18. Why is a container not automatically secure just because it is isolated?
19. Why should Docker setups differ between development and production?
20. What changes when Docker moves from a laptop environment to a deployed server setup?
21. Why is Nginx often placed in front of app containers?
22. Why do databases need extra care in containerized systems?
23. Why does Docker become even more useful in CI/CD and team workflows?
24. Why do scaling and orchestration become necessary after basic Docker deployment patterns?
25. Why is production hardening stricter than beginner local security habits?
26. How does Docker fit into a larger real-world system architecture instead of acting alone?