The Problem: “Works on My Machine”#

Applications depend on specific OS versions, libraries, and configurations. Virtualization and containers solve this by packaging the environment with the application.

Virtualization (Virtual Machines)#

A hypervisor creates virtual hardware — each VM runs its own complete OS:

flowchart TD
    subgraph Physical["Physical Server"]
        HV["Hypervisor"]
        subgraph VM1["VM 1"]
            OS1["Guest OS (Ubuntu)"]
            App1["App A"]
        end
        subgraph VM2["VM 2"]
            OS2["Guest OS (RHEL)"]
            App2["App B"]
        end
    end

Hypervisor Types#

VM Characteristics#

Containers#

Containers share the host kernel but isolate the application’s filesystem, processes, and network:

flowchart TD
    subgraph Physical["Physical Server"]
        Kernel["Linux Kernel"]
        Runtime["Container Runtime (Docker)"]
        subgraph C1["Container 1"]
            App1["App A + libs"]
        end
        subgraph C2["Container 2"]
            App2["App B + libs"]
        end
    end

VMs vs Containers#

Linux Kernel Features Enabling Containers#

Docker#

The most popular container platform:

Dockerfile#

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "app.py"]

Key Commands#

# Build image
docker build -t myapp:1.0 .

# Run container
docker run -d -p 8080:8000 --name myapp myapp:1.0

# List running containers
docker ps

# View logs
docker logs myapp

# Stop and remove
docker stop myapp
docker rm myapp

# List images
docker images

Image Layers#

Each Dockerfile instruction creates a layer — layers are cached and shared:

Layer 4: COPY . .              (your code — changes often)
Layer 3: RUN pip install ...   (dependencies — changes sometimes)
Layer 2: COPY requirements.txt (triggers rebuild if deps change)
Layer 1: FROM python:3.12-slim (base — rarely changes)

Best practice: Put frequently-changing instructions last to maximize cache hits.

Container Orchestration#

Running containers in production requires orchestration:

What Orchestrators Do#

• Scheduling — place containers on available hosts
• Scaling — add/remove containers based on load
• Health checks — restart failed containers
• Networking — service discovery, load balancing
• Rolling updates — deploy without downtime

Container Best Practices#

Key Takeaways#

1. VMs = full OS isolation (strong security, heavy). Containers = process isolation (lightweight, fast)
2. Containers share the host kernel — that’s why they’re fast but less isolated
3. Docker packages apps with their dependencies into portable images
4. Layer caching makes builds fast — order Dockerfile instructions wisely
5. Orchestrators (ECS, K8s) manage containers in production
6. Containers are ephemeral — don’t store state inside them