Docker Tutorial for Beginners 2026

Install Docker:

1. Go to https://docs.docker.com/get-docker/
2. Download Docker Desktop for your OS
3. Run installer and follow the wizard
4. Start Docker Desktop
5. Open terminal and verify:

$ docker --version
Docker version 26.x.x, build ...

$ docker info
Server:
  Containers: 0
  Images: 0
  ...

You're ready to go.

Run your first container:

$ docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
...
Hello from Docker!
This message shows that your installation appears to be working correctly.

# Pull and run an nginx web server
$ docker run -d -p 8080:80 nginx

# Open http://localhost:8080 in your browser — nginx page loads.

# List running containers
$ docker ps

# Run nginx detached on port 8080
docker run -d -p 8080:80 --name webserver nginx

# List running containers
docker ps

# Show all containers (running + stopped)
docker ps -a

# View logs
docker logs webserver
docker logs -f webserver

# Open an interactive shell
docker exec -it webserver bash

# Stop and remove
docker stop webserver
docker rm webserver

# Interactive shell into a container
$ docker run -it ubuntu bash

root@container:/# ls
root@container:/# apt-get update
root@container:/# exit

# Run a command and exit
$ docker run --rm ubuntu echo "hello from ubuntu"

# Useful: cleanup
docker stop $(docker ps -q)
docker rm $(docker ps -aq)
docker system prune -a

# Dockerfile — Python Flask app
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

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

# Build the image
$ docker build -t my-flask-app:v1 .

# Check images
$ docker images

# Run the container
$ docker run -d -p 5000:5000 --name myapp my-flask-app:v1

# Push to Docker Hub (optional)
$ docker login
$ docker tag my-flask-app:v1 yourname/my-flask-app:v1
$ docker push yourname/my-flask-app:v1

# docker-compose.yml — Flask + Postgres + Redis
version: "3.9"

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/app
    depends_on:
      - db
      - redis

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: app
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

volumes:
  postgres_data:

# Start all services
docker compose up -d

# View logs from all services
docker compose logs -f

# View logs from one service
docker compose logs -f web

# Rebuild after Dockerfile changes
docker compose up -d --build

# Stop and remove containers + networks
docker compose down

# Stop and remove containers + volumes (deletes data!)
docker compose down -v

# Run a command in a service
docker compose exec web bash

Where to deploy Docker containers:

Simple / beginner-friendly:
□ Render, Railway, Fly.io (git-push deploy)
□ DigitalOcean App Platform
□ Docker Hub + a single VM (docker run)

Intermediate:
□ AWS ECS / Fargate
□ Google Cloud Run
□ Azure Container Apps

Advanced:
□ Kubernetes (EKS, GKE, AKS)
□ Self-managed clusters
□ Helm charts

Start simple. Move to Kubernetes when
your app actually needs it.

Docker best practices:

Images:
□ Use slim/alpine base images
□ Multi-stage builds for smaller images
□ Pin versions (python:3.12-slim, not latest)
□ Don't run as root — use USER

Dockerfile:
□ Order layers by change frequency
□ Combine RUN commands with &&
□ Use .dockerignore (exclude node_modules, .git)

Runtime:
□ Mount volumes for data
□ Set resource limits (--memory, --cpus)
□ Use env vars for config, never hardcode secrets
□ Log to stdout/stderr

Security:
□ Scan images (docker scout, trivy)
□ Keep images updated
□ Don't leak secrets into image layers

Daily practice tracker:
Date: _________
☐ Pull and run a new image (15 min)
☐ Read Dockerfile of a public image (15 min)
☐ Practice 3 commands (10 min)
☐ Write notes / screenshot

Today's learnings:
1. 
2. 
3. 

Tomorrow's target:
1. 
2.