Docker
Deploy · Build
Package a service with its dependencies and run a repeatable local environment.
All capabilities · Cloud, deployment & production
Containerize an application with Docker
Write Dockerfiles, compose services, manage env/secrets, publish images.
Explore 2 tools for this projectMarket relevance
Which roles ask for this — and how often
Share of job postings in India, per role, that name this capability.
What employers mean
You should be able to…
- Write a Dockerfile for a Python API with a small final image (multi-stage build)
- Manage secrets/env vars for a container without baking them into the image
- Use docker compose to run an API plus its database/cache locally
- Debug a container that starts but the app inside crashes or can't reach a dependency
- Publish an image to a registry (Docker Hub/GHCR) with a versioned tag
- Reduce image size and build time with layer caching and .dockerignore
- Run a container as a non-root user for security
Needs first: Build and consume REST APIs
Learn — free, link-checked
The few resources that matter
Read · beginner · 40 min · docs.docker.com
Containerize a Python application
A Python-specific walkthrough for the exact Dockerfile patterns (deps, layers, entrypoint) you'll use to containerize an AI service. — Docker
Read · beginner · 45 min · docs.docker.com
Docker - Get Started
The official on-ramp: build, run and push your first image using Docker's own guided path. — Docker
Watch · beginner · 180 min · youtube.com
Docker Tutorial for Beginners [FULL COURSE in 3 Hours]
The most-watched free Docker course; explains images, volumes and networking with diagrams, not just commands. — TechWorld with Nana
Read · intermediate · 25 min · docs.docker.com
Dockerfile best practices
Multi-stage builds, layer caching and running as non-root — the difference between a Dockerfile that works and one that's production- and security-ready. — Docker
Watch · intermediate · 45 min · youtube.com
GitHub Actions Tutorial - Basic Concepts and CI/CD Pipeline with Docker
Walks through building, testing and pushing a Docker image on merge — the actual pipeline shape most AI-service repos use. — TechWorld with Nana
Tools for practice
Choose a tool for the job
Start with one tool for each part of your project. You don’t need to learn them all.
2 tools to explore
GitHub Actions
Test · Deploy
Run checks and deployment steps automatically when project code changes.
Practices & references
- Dockerfiles
- Compose
- .dockerignore
Practice
Multi-stage container and Compose stack for the ticket API
Containerize the FastAPI ticket service with a multi-stage Dockerfile: build deps in one stage, ship a slim runtime image in the next, and run the process as a non-root user. Then write a docker-compose.yml that brings the API up alongside Postgres and Redis with all config coming from env vars. Finish by tagging the image, pushing it to GitHub Container Registry, and pulling it back on a clean machine to prove it runs anywhere.
Start from
The FastAPI ticket API you built in build-apis — any small web service with a database dependency works
Milestones
- Write a working single-stage Dockerfile and record the image size · ~0.5h
- Split it multi-stage on a slim base and switch to a non-root user · ~2h
- Add docker-compose with Postgres and Redis, wired entirely by env vars · ~1h
- Tag and push to GHCR, then pull it fresh and prove it starts · ~1h
Done when
- Multi-stage Dockerfile produces a final image under 300MB and runs as a non-root user
- `docker compose up` starts API + Postgres + Redis and the API can reach both
- Secrets (DB password, API keys) are passed via env vars/`.env`, never hardcoded in the image
- Image is pushed to a public registry with a semver tag and pullable by anyone
Prove it
Evidence a recruiter can check
- The image-size drop before and after multi-stage, straight from `docker images` output in the README
- A `docker compose up` log showing the API connecting to both Postgres and Redis from a clean start
- The GHCR package page with semver tags anyone can `docker pull` without credentials
- `whoami` from inside the running container, next to the Dockerfile line that made it non-root
Signal it
Containerized a FastAPI service with a multi-stage build — cut the image to under 300MB, ran it as a non-root user, and published semver-tagged images to GHCR alongside a Compose stack with Postgres and Redis.
Interview
Questions you'll get asked
- Walk me through a multi-stage Dockerfile for a Python FastAPI app.
- How do you pass secrets to a container without committing them to the image?
- Your container works locally but crashes in prod — how do you debug it?
- What's the difference between `CMD` and `ENTRYPOINT`?
- How would you use docker compose to run an API with a Postgres and Redis dependency?
- Why would you run a container as a non-root user, and how do you set that up?
- How do you keep a Python image small without breaking pip installs that need build tools?