Thangavel PrasanthTP

Docker

5 min read

What is Docker?

Docker packages your application and its dependencies into a container that runs consistently across different machines.

The Problem Docker Solves

Without Docker:

  • “It works on my machine” — different Python/Node versions, missing dependencies, OS differences
  • Setup is manual — install Python, Node.js, dependencies, configure environment
  • Deployment is risky — production may differ from development

With Docker:

  • Consistent environment — same setup on your laptop, teammate’s machine, and production
  • One command to run — docker-compose up handles everything
  • Isolated — your app runs in its own container, separate from other software

How Docker Works

1. Dockerfile = Recipe

Your Dockerfile is a recipe that builds your app’s environment:

# Use Python 3.11 slim base image for smaller size
FROM python:3.11-slim
 
# Install Node.js and npm for Tailwind CSS build
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
    && apt-get install -y --no-install-recommends nodejs \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*
 
# Install Tailwind CSS CLI globally
RUN npm install -g tailwindcss
 
# Create non-root user for security
RUN useradd -m -u 1000 user
ENV PATH="/home/user/.local/bin:$PATH"
ENV FLASK_APP=app.py
ENV FLASK_ENV=production
 
# Set working directory for app
WORKDIR /app
 
# Copy requirements with correct ownership first for better layer caching
COPY --chown=user requirements.txt .
 
# Install Python dependencies
RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
# Copy application code with correct ownership (all files from current directory to container)
COPY --chown=user . .
 
# Build Tailwind CSS (run as root to ensure proper permissions, then fix ownership)
RUN tailwindcss -i ./input.css -o ./static/output.css --minify && \
    chown user:user ./static/output.css || true
 
# Switch to non-root user
USER user
 
# Expose port 7860 (Hugging Face Spaces default)
EXPOSE 7860
 
# Run gunicorn server on port 7860 with proper configuration
# Use exec form for better signal handling
# Add workers for better performance (2 workers is a good default)
# Add timeout for long-running requests
# Log to stdout/stderr so logs appear in HF Spaces
CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "2", "--timeout", "120", "--access-logfile", "-", "--error-logfile", "-", "app:app"]

What it does:

  • Starts with Python 3.11
  • Installs Node.js (for Tailwind CSS)
  • Installs Python packages from requirements.txt
  • Copies your code
  • Builds Tailwind CSS
  • Runs your Flask app with Gunicorn

2. Docker Compose = Orchestrator

Your docker-compose.yml configures how the container runs:

version: '3.8'
 
services:
  music-player:
    build: .
    ports:
      - "7860:7860"
    volumes:
      - ./data:/app/data
      - ./static/audio:/app/static/audio
    env_file:
      - .env
    environment:
      - FLASK_ENV=production
      - DATABASE_PATH=/app/data/music_player.db
    restart: unless-stopped

What it does:

  • Builds the image from your Dockerfile
  • Maps port 7860 (host) to 7860 (container)
  • Mounts local folders (./data, ./static/audio) into the container
  • Loads environment variables from .env
  • Restarts the container if it stops

Key Concepts

Container vs Image

  • Image: the built package (like a class)
  • Container: a running instance of that image (like an object)

Layers

Each RUN, COPY, etc. in the Dockerfile creates a layer. Docker caches layers, so rebuilds are faster.

Volumes

volumes:
  - ./data:/app/data

This maps your local ./data folder to /app/data in the container, so data persists even if the container is deleted.

Real-World Analogy

Think of Docker like a shipping container:

  • Standardized — same container works on ships, trucks, trains
  • Self-contained — everything needed is inside
  • Isolated — what’s inside doesn’t affect what’s outside
  • Portable — move it anywhere and it works the same

For Your Music Player

When you run docker-compose up --build:

  1. Docker reads your Dockerfile
  2. Builds an image with Python, Node.js, and your code
  3. Creates a container from that image
  4. Runs your Flask app inside the container
  5. Makes it accessible at http://localhost:7860

On HuggingFace Spaces:

  • They use the same Dockerfile
  • They build the same image
  • They run it in their infrastructure
  • Your app behaves the same as locally

Benefits for You

  1. Consistency — same environment everywhere
  2. Simplicity — one command to run everything
  3. Isolation — doesn’t interfere with other projects
  4. Portability — works on any machine with Docker
  5. Reproducibility — anyone can run your app the same way

Want more detail on any part?

Docker vs VMware (Virtualization)

Docker is closer to virtualization (like VMware) than to Python virtual environments, but with important differences.

Similarities:

  • Both isolate applications from the host OS
  • Both can run different operating systems
  • Both provide isolated environments

Differences:

AspectVMware (Full Virtualization)Docker (Containerization)
What it virtualizesEntire OS (kernel + apps)Just the application layer
Resource usageHeavy (runs full OS)Lightweight (shares host kernel)
Startup timeSlow (minutes)Fast (seconds)
Disk spaceLarge (GBs per VM)Small (MBs per container)
Isolation levelComplete (separate kernel)Process-level (shared kernel)

Docker vs Python Virtual Environments

These are different:

AspectPython venv/condaDocker
What it isolatesPython packages onlyEntire application + OS dependencies
ScopeJust Python librariesEverything (OS, libraries, system tools)
OS independenceNo (still uses host OS)Yes (can run different OS)
Use caseManaging Python dependenciesRunning complete applications

How Docker Actually Works

Docker uses containerization, not full virtualization:

VMware Approach:
┌─────────────────────────────────┐
│  Host OS (macOS/Windows)        │
│  ┌───────────────────────────┐  │
│  │ Hypervisor (VMware)       │  │
│  │ ┌───────────────────────┐ │  │
│  │ │ Guest OS (Linux)      │ │  │
│  │ │ ┌─────────────────┐   │ │  │
│  │ │ │ Your App        │   │ │  │
│  │ │ └─────────────────┘   │ │  │
│  │ └───────────────────────┘ │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘

Docker Approach:
┌─────────────────────────────────┐
│  Host OS (macOS/Windows)        │
│  ┌───────────────────────────┐  │
│  │ Docker Engine             │  │
│  │ ┌───────────────────────┐ │  │
│  │ │ Container (Linux)     │ │  │
│  │ │ ┌─────────────────┐   │ │  │
│  │ │ │ Your App        │   │ │  │
│  │ │ └─────────────────┘   │ │  │
│  │ └───────────────────────┘ │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘

Real-World Analogy

  • VMware: Like renting a separate apartment (full isolation, more resources)
  • Docker: Like a studio apartment in a shared building (lightweight, shares infrastructure)
  • Python venv: Like organizing your bookshelf (just Python packages)

This is why Docker is popular for deployment: it’s lighter than VMs but more isolated than virtual environments.

In summary: Docker is closer to virtualization (VMware) but uses containers instead of full VMs, making it faster and lighter while still providing good isolation.

Graph View