Overview

Docker is a platform for building, packaging, and running applications inside isolated environments called containers. Docker helps solve the common problem:

“The application works on my machine but not on another machine.”

A container packages the application along with its dependencies and configuration.

Application
    +
Dependencies
    +
Runtime
    +
Configuration
    ↓
Docker Container

1. Why Docker?

Without Docker:

Developer Machine
    ↓
Python Version
Libraries
Operating System Differences
Environment Variables
    ↓
Application Issues

With Docker:

Application
    +
Dependencies
    +
Docker Image
    ↓
Runs Consistently

Benefits:

Consistent environments
Easy application deployment
Dependency isolation
Portability
Faster setup
Reproducible builds
Easy scaling
Better development and deployment workflows

2. Important Docker Concepts

The main Docker concepts are:

Dockerfile
    ↓
Docker Build
    ↓
Docker Image
    ↓
Docker Run
    ↓
Docker Container

Concept	Description
Dockerfile	Instructions for building an image
Image	Read-only application template
Container	Running instance of an image
Docker Engine	Runs and manages containers
Docker Hub	Registry for Docker images
Volume	Persistent data storage
Network	Communication between containers
Docker Compose	Run multi-container applications
Registry	Storage location for Docker images

3. Docker Architecture

Docker follows a client-server architecture.

Docker Client
     │
     │ Commands
     ▼
Docker Engine
     │
     ├── Images
     │
     ├── Containers
     │
     ├── Networks
     │
     └── Volumes

Example command:

docker run hello-world

The Docker client sends the command to the Docker Engine. The engine:

Checks whether the image exists locally.
Downloads the image if necessary.
Creates a container.
Runs the container.

4. Docker Image

A Docker image is a packaged template containing everything required to run an application. Example:

Docker Image

├── Operating System Components
├── Runtime
├── Libraries
├── Dependencies
└── Application Code

Images are immutable. A Docker image can create multiple containers.

        Docker Image
             │
      ┌──────┼──────┐
      ▼      ▼      ▼
Container Container Container

Example:

docker images

5. Docker Container

A container is a running instance of a Docker image.

Docker Image
      ↓
docker run
      ↓
Docker Container

Example:

docker run hello-world

Useful commands:

docker ps

Shows running containers.

docker ps -a

Shows all containers, including stopped containers.

6. Dockerfile

A Dockerfile is a text file containing instructions for building a Docker image. Example:

FROM python:3.11

WORKDIR /app

COPY . .

RUN pip install -r requirements.txt

CMD ["python", "app.py"]

The Dockerfile tells Docker:

Start with Python
      ↓
Create Working Directory
      ↓
Copy Application Files
      ↓
Install Dependencies
      ↓
Run Application

7. Important Dockerfile Instructions

`FROM`

Defines the base image.

FROM python:3.11

Example:

Base Image
    ↓
Python Runtime

Other examples:

FROM node:20

FROM ubuntu:22.04

Every Dockerfile usually starts with a FROM instruction.

`WORKDIR`

Sets the working directory inside the container.

WORKDIR /app

After this:

Container
│
└── app/

Commands run relative to this directory.

`COPY`

Copies files from the local machine into the container.

COPY . .

Conceptually:

Local Machine
    ↓
Application Files
    ↓
Container /app

A more optimized approach:

COPY requirements.txt .
COPY app.py .

`RUN`

Executes commands while building the image.

RUN pip install -r requirements.txt

Other examples:

RUN apt-get update

RUN mkdir data

RUN executes during:

docker build

`CMD`

Defines the default command when the container starts.

CMD ["python", "app.py"]

CMD executes when:

docker run

`EXPOSE`

Documents the port used by the application.

EXPOSE 8000

For example:

Container Application
        │
        │ Port 8000
        ▼
EXPOSE 8000

Important: EXPOSE does not automatically publish the port to the host. Port publishing requires:

docker run -p 8000:8000 image-name

`ENV`

Sets environment variables.

ENV APP_ENV=production

Example usage:

import os

environment = os.getenv("APP_ENV")

`ARG`

Defines build-time variables.

ARG PYTHON_VERSION=3.11

Example:

FROM python:${PYTHON_VERSION}

Difference:

`ARG`	`ENV`
Build time	Runtime
Available during image build	Available inside container
Can configure builds	Can configure applications

8. Dockerfile Example

A basic Python application:

`app.py`

print("Hello from Docker!")

`Dockerfile`

FROM python:3.11

WORKDIR /app

COPY app.py .

CMD ["python", "app.py"]

Build:

docker build -t hello-python .

Run:

docker run hello-python

Output:

Hello from Docker!

9. Building an Image Locally

The basic command is:

docker build -t image-name .

Example:

docker build -t my-python-app .

Breaking it down:

docker build
    ↓
Build an image

-t
    ↓
Assign a tag

my-python-app
    ↓
Image name

.
    ↓
Current directory as build context

The workflow:

Dockerfile
    ↓
docker build
    ↓
Docker Image

Check images:

docker images

10. Running a Docker Image

Run an image:

docker run my-python-app

Run with a custom container name:

docker run --name my-container my-python-app

Run in detached mode:

docker run -d my-python-app

Detached mode means the container runs in the background.

11. Docker Layers

One of the most important Docker concepts is layers. Each Dockerfile instruction generally creates a layer. Example:

FROM python:3.11

WORKDIR /app

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

Conceptually:

Layer 1
FROM python:3.11
       ↓
Layer 2
WORKDIR /app
       ↓
Layer 3
COPY requirements.txt
       ↓
Layer 4
RUN pip install
       ↓
Layer 5
COPY application
       ↓
Layer 6
CMD

Docker combines these layers into an image.

12. Docker Layer Caching

Docker caches previously built layers. Suppose this Dockerfile exists:

FROM python:3.11

WORKDIR /app

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

During the first build:

Build Layer 1
Build Layer 2
Build Layer 3
Build Layer 4
Build Layer 5

During the next build, Docker checks whether instructions and files have changed.

Layer 1 → Cached
Layer 2 → Cached
Layer 3 → Cached
Layer 4 → Cached
Layer 5 → Rebuild if changed

This makes builds faster.

13. Why Dockerfile Order Matters

Consider this Dockerfile:

FROM python:3.11

WORKDIR /app

COPY . .

RUN pip install -r requirements.txt

CMD ["python", "app.py"]

If any application file changes:

COPY . .
    ↓
Layer Changed
    ↓
RUN pip install
    ↓
Runs Again

This is inefficient. A better version:

FROM python:3.11

WORKDIR /app

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

CMD ["python", "app.py"]

Now:

Application Code Changes
        ↓
Dependency Layer
        ↓
Cached
        ↓
Only Application Layer Rebuilds

This is an important Docker optimization technique.

14. `.dockerignore`

A .dockerignore file prevents unnecessary files from being copied into the Docker build context. Example:

__pycache__/
*.pyc
.env
.git/
venv/
node_modules/

Without .dockerignore:

Project Folder
    ↓
Everything Sent to Docker

With .dockerignore:

Project Folder
    ↓
Ignore Unnecessary Files
    ↓
Smaller Build Context
    ↓
Faster Build

Benefits:

Smaller images
Faster builds
Prevent accidental copying of secrets
Better caching

15. Docker Image Tags

Images can have tags. Example:

docker build -t my-app:1.0 .

Format:

image-name:tag

Examples:

my-app:latest
my-app:1.0
my-app:2.0
python:3.11

If no tag is specified:

latest

is generally used by default.

16. Container Lifecycle

A container has different states.

Created
   ↓
Running
   ↓
Stopped
   ↓
Removed

Commands: Create and start:

docker run my-app

Stop:

docker stop container-id

Start again:

docker start container-id

Restart:

docker restart container-id

Remove:

docker rm container-id

Remove a running container:

docker rm -f container-id

17. Useful Container Commands

List running containers:

docker ps

List all containers:

docker ps -a

View logs:

docker logs container-id

Follow logs:

docker logs -f container-id

Open a shell:

docker exec -it container-id bash

For smaller images:

docker exec -it container-id sh

Inspect container details:

docker inspect container-id

18. Port Mapping

Containers have their own network environment. Suppose a web application runs on:

Container Port: 8000

To access it from the host:

docker run -p 8000:8000 my-app

Format:

Host Port : Container Port

Example:

Browser
   ↓
localhost:8000
   ↓
Host Port 8000
   ↓
Container Port 8000
   ↓
Application

Another example:

docker run -p 8080:8000 my-app

localhost:8080
       ↓
Container:8000

19. Volumes

Containers are designed to be temporary. Data inside a container may disappear when the container is removed. Docker volumes provide persistent storage.

Container
    │
    ▼
Docker Volume
    │
    ▼
Persistent Data

Create a volume:

docker volume create my-data

Use it:

docker run -v my-data:/app/data my-app

Example:

Docker Container
       │
       ▼
/app/data
       │
       ▼
Docker Volume
       │
       ▼
Persistent Storage

20. Bind Mounts

A bind mount connects a local directory to a container directory. Example:

docker run -v $(pwd):/app my-app

Conceptually:

Local Project Folder
        │
        ▼
Mounted Into
        │
        ▼
Container /app

This is commonly used during development.

21. Docker Networking

Docker containers can communicate through networks. Create a network:

docker network create app-network

Run containers:

docker run --network app-network --name database postgres

docker run --network app-network --name backend my-backend

Architecture:

Backend Container
       │
       │ Docker Network
       ▼
Database Container

Containers in the same network can communicate using container names. Example:

backend
   ↓
database

22. Docker Compose

Docker Compose is used to manage multi-container applications. Example architecture:

Frontend
    │
    ▼
Backend
    │
    ▼
Database

Instead of running multiple commands manually, Docker Compose defines services in one configuration file. Example compose.yaml:

services:
  app:
    build: .
    ports:
      - "8000:8000"

  database:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: password

Start all services:

docker compose up

Run in background:

docker compose up -d

Stop:

docker compose down

23. Docker Registry

A registry stores Docker images. The common workflow:

Dockerfile
    ↓
Build Image
    ↓
Local Image
    ↓
Push
    ↓
Docker Registry
    ↓
Pull
    ↓
Server

Examples of registries include Docker Hub and private container registries. Basic commands:

docker login

docker push username/image-name:tag

docker pull username/image-name:tag

24. Multi-Stage Builds

Multi-stage builds help reduce final image size. Example:

FROM node:20 AS builder

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

RUN npm run build

FROM nginx:alpine

COPY --from=builder /app/dist /usr/share/nginx/html

Architecture:

Build Stage
    ↓
Install Dependencies
    ↓
Build Application
    ↓
Copy Only Final Output
    ↓
Production Image

Benefits:

Smaller production images
Fewer unnecessary dependencies
Improved security
Faster deployment

25. Image Size Optimization

Large images can cause:

Slow builds
Slow downloads
More storage usage
Larger attack surface

Best practices:

Use smaller base images

FROM python:3.11-slim

instead of unnecessarily large images.

Use `.dockerignore`

Avoid copying:

venv/
.git/
__pycache__/
node_modules/

Remove unnecessary dependencies

Install only required packages.

Use multi-stage builds

Keep build dependencies out of production images.

26. Docker Environment Variables

Environment variables help configure applications. Example:

docker run -e APP_ENV=production my-app

Inside Python:

import os

environment = os.getenv("APP_ENV")

print(environment)

Using an environment file:

docker run --env-file .env my-app

Example .env:

DATABASE_URL=database-url
APP_ENV=development

Important: secrets should not be permanently copied into Docker images.

27. Docker Image vs Container

Docker Image	Docker Container
Blueprint	Running instance
Read-only template	Executable environment
Created using Dockerfile	Created from an image
Can create multiple containers	Runs application
Immutable layers	Writable container layer

Example:

Dockerfile
    ↓
Image
    ↓
Container 1

    ↓
Container 2

    ↓
Container 3

28. `RUN` vs `CMD` vs `ENTRYPOINT`

These instructions are commonly confused.

`RUN`

Executes during image build.

RUN pip install -r requirements.txt

docker build
     ↓
RUN executes

`CMD`

Defines the default command when a container starts.

CMD ["python", "app.py"]

docker run
     ↓
CMD executes

`ENTRYPOINT`

Defines the main executable for the container.

ENTRYPOINT ["python"]
CMD ["app.py"]

Result:

python app.py

Comparison:

Instruction	Purpose
`RUN`	Execute during build
`CMD`	Default runtime command
`ENTRYPOINT`	Main container executable

29. Docker Build Context

The build context is the set of files Docker can access during a build. Example:

docker build -t my-app .

The . means:

Current Directory
       ↓
Docker Build Context

Docker sends files from the build context to the Docker Engine. This is why .dockerignore is important.

30. Docker Caching Best Practices

Consider dependencies:

COPY requirements.txt .
RUN pip install -r requirements.txt

Then application code:

COPY . .

Recommended order:

Rarely Changing Files
        ↓
Dependency Installation
        ↓
Frequently Changing Files

This maximizes Docker layer caching.

31. Basic Docker Workflow

A typical development workflow:

Write Application
       ↓
Create requirements.txt
       ↓
Create Dockerfile
       ↓
Build Image
       ↓
Run Container
       ↓
Test Application
       ↓
Push Image
       ↓
Deploy

Commands:

docker build -t my-app .

docker run my-app

docker ps

docker logs container-id

32. Common Docker Commands Cheat Sheet

Images

docker images

docker build -t my-app .

docker pull python:3.11

docker rmi image-id

Containers

docker run my-app

docker run -d my-app

docker ps

docker ps -a

docker stop container-id

docker start container-id

docker restart container-id

docker rm container-id

Logs and Debugging

docker logs container-id

docker logs -f container-id

docker exec -it container-id bash

docker inspect container-id

Cleanup

Remove stopped containers:

docker container prune

Remove unused images:

docker image prune

Remove unused resources:

docker system prune

Use caution:

docker system prune -a

This can remove unused images and other Docker resources.

33. Docker Security Basics

Important practices:

Use trusted base images.
Keep base images updated.
Do not store secrets inside Dockerfiles.
Use .dockerignore.
Run containers with minimal permissions.
Avoid running applications as root when possible.
Keep images small.
Scan images for vulnerabilities.

Example of creating a non-root user:

FROM python:3.11-slim

WORKDIR /app

RUN useradd -m appuser

COPY . .

RUN pip install -r requirements.txt

USER appuser

CMD ["python", "app.py"]

34. Health Checks

A health check allows Docker to determine whether an application is healthy. Example:

HEALTHCHECK CMD python healthcheck.py

Conceptually:

Container Running
       ↓
Health Check
       ↓
Healthy / Unhealthy

This is useful for production applications.

35. Important Docker Best Practices

Use small base images
Use .dockerignore
Optimize Docker layer caching
Copy dependency files first
Avoid unnecessary dependencies
Use environment variables
Do not store secrets in images
Use specific image versions
Run applications as non-root
Use multi-stage builds
Keep one main process per container
Use volumes for persistent data
Add health checks when needed
Tag images properly
Clean unused Docker resources

36. Complete Docker Learning Roadmap

Docker Fundamentals
│
├── Docker Architecture
├── Docker Engine
├── Images
├── Containers
│
├── Dockerfile
│   ├── FROM
│   ├── WORKDIR
│   ├── COPY
│   ├── RUN
│   ├── CMD
│   ├── ENTRYPOINT
│   ├── ENV
│   ├── ARG
│   └── EXPOSE
│
├── Image Building
│   ├── Build Context
│   ├── Tags
│   ├── Layers
│   └── Caching
│
├── Container Management
│   ├── Run
│   ├── Stop
│   ├── Restart
│   ├── Logs
│   └── Exec
│
├── Storage
│   ├── Volumes
│   └── Bind Mounts
│
├── Networking
│   ├── Port Mapping
│   └── Container Networks
│
├── Docker Compose
│
├── Docker Registry
│
├── Optimization
│   ├── Small Images
│   ├── .dockerignore
│   ├── Layer Caching
│   └── Multi-Stage Builds
│
└── Security
    ├── Non-root Users
    ├── Secrets
    └── Image Updates

Summary

The fundamental Docker workflow is:

Application Code
       +
Dependencies
       ↓
Dockerfile
       ↓
docker build
       ↓
Docker Image
       ↓
docker run
       ↓
Docker Container

The most important concepts to master first are:

Dockerfile
    ↓
Images
    ↓
Containers
    ↓
Layers
    ↓
Caching
    ↓
Volumes
    ↓
Networking
    ↓
Docker Compose
    ↓
Registries
    ↓
Multi-Stage Builds

​Overview

​1. Why Docker?

​2. Important Docker Concepts

​3. Docker Architecture

​4. Docker Image

​5. Docker Container

​6. Dockerfile

​7. Important Dockerfile Instructions

​FROM

​WORKDIR

​COPY

​RUN

​CMD

​EXPOSE

​ENV

​ARG

​8. Dockerfile Example

​app.py

​Dockerfile

​9. Building an Image Locally

​10. Running a Docker Image

​11. Docker Layers

​12. Docker Layer Caching

​13. Why Dockerfile Order Matters

​14. .dockerignore

​15. Docker Image Tags

​16. Container Lifecycle

​17. Useful Container Commands

​18. Port Mapping

​19. Volumes

​20. Bind Mounts

​21. Docker Networking

​22. Docker Compose

​23. Docker Registry

​24. Multi-Stage Builds

​25. Image Size Optimization

​Use smaller base images

​Use .dockerignore

​Remove unnecessary dependencies

​Use multi-stage builds

​26. Docker Environment Variables

​27. Docker Image vs Container

​28. RUN vs CMD vs ENTRYPOINT

​RUN

​CMD

​ENTRYPOINT

​29. Docker Build Context

​30. Docker Caching Best Practices

​31. Basic Docker Workflow

​32. Common Docker Commands Cheat Sheet

​Images

​Containers

​Logs and Debugging

​Cleanup

​33. Docker Security Basics

​34. Health Checks

​35. Important Docker Best Practices

​36. Complete Docker Learning Roadmap

​Summary

Overview

1. Why Docker?

2. Important Docker Concepts

3. Docker Architecture

4. Docker Image

5. Docker Container

6. Dockerfile

7. Important Dockerfile Instructions

`FROM`

`WORKDIR`

`COPY`

`RUN`

`CMD`

`EXPOSE`

`ENV`

`ARG`

8. Dockerfile Example

`app.py`

`Dockerfile`

9. Building an Image Locally

10. Running a Docker Image

11. Docker Layers

12. Docker Layer Caching

13. Why Dockerfile Order Matters

14. `.dockerignore`

15. Docker Image Tags

16. Container Lifecycle

17. Useful Container Commands

18. Port Mapping

19. Volumes

20. Bind Mounts

21. Docker Networking

22. Docker Compose

23. Docker Registry

24. Multi-Stage Builds

25. Image Size Optimization

Use smaller base images

Use `.dockerignore`

Remove unnecessary dependencies

Use multi-stage builds

26. Docker Environment Variables

27. Docker Image vs Container

28. `RUN` vs `CMD` vs `ENTRYPOINT`

`RUN`

`CMD`

`ENTRYPOINT`

29. Docker Build Context

30. Docker Caching Best Practices

31. Basic Docker Workflow

32. Common Docker Commands Cheat Sheet

Images

Containers

Logs and Debugging

Cleanup

33. Docker Security Basics

34. Health Checks

35. Important Docker Best Practices

36. Complete Docker Learning Roadmap

Summary