47.2 Virtual machines vs containers

Example 1: See that an EC2 instance is a VM

Type this:

cat /sys/class/dmi/id/sys_vendor

You will see:

Amazon EC2

What it means: Every EC2 server you rent from AWS is a virtual machine. The hardware is shared with other customers, but you get your own full operating system.

Example 2: See the VM's own kernel

Type this:

uname -r

You will see:

6.1.112-122.189.amzn2023.x86_64

What it means: uname -r prints the kernel version. This VM booted its own kernel when it started.

Example 3: See how long the VM has been up

Type this:

uptime -p

You will see:

up 3 days, 4 hours, 12 minutes

What it means: A VM boots like a real computer, which takes about a minute. Then it stays up for days. Starting a new VM for every small task is too slow.

Example 4: See memory used by the OS alone

Type this:

free -h | head -2

You will see:

               total        used        free
Mem:           1.9Gi       410Mi       1.2Gi

What it means: The VM is doing nothing yet, but about 400 MB is already used by its own operating system.

Example 5: Count the background programs

Type this:

ps -e --no-headers | wc -l

You will see:

112

What it means: More than 100 programs run before your app even starts. Each VM has its own copy of all of them.

Example 6: See the disk size of the OS

Type this:

df -h / | tail -1

You will see:

/dev/nvme0n1p1   8.0G  1.8G  6.2G  23% /

What it means: The operating system alone takes almost 2 GB of disk. Ten VMs means about 18 GB just for ten copies of the same OS.

Example 7: Compare kernels inside and outside

Type this:

uname -r
docker run --rm alpine uname -r

You will see:

6.1.112-122.189.amzn2023.x86_64
6.1.112-122.189.amzn2023.x86_64

What it means: Both lines are the same. The container is using the host kernel. A VM would print its own different kernel.

Example 8: Even a different Linux shares the kernel

Type this:

docker run --rm ubuntu:24.04 uname -r
docker run --rm debian:12 uname -r

You will see:

6.1.112-122.189.amzn2023.x86_64
6.1.112-122.189.amzn2023.x86_64

What it means: Ubuntu and Debian files are inside the containers, but the kernel is still the host kernel. Only the files change, not the kernel.

Example 9: See which Linux files a container has

Type this:

docker run --rm ubuntu:24.04 grep PRETTY /etc/os-release
docker run --rm alpine grep PRETTY /etc/os-release

You will see:

PRETTY_NAME="Ubuntu 24.04.1 LTS"
PRETTY_NAME="Alpine Linux v3.20"

What it means: Each container has its own set of Linux files (called a userland), so it looks like Ubuntu or Alpine. Underneath, one shared kernel does the work.

Example 10: Time one container

Type this:

time docker run --rm alpine echo ready

You will see:

ready
real    0m0.58s

What it means: The container was created, ran, and was removed in about half a second.

Example 11: Time ten containers

Type this:

time (for i in 1 2 3 4 5 6 7 8 9 10; do docker run --rm alpine true; done)

You will see:

real    0m5.40s

What it means: Ten full containers in about five seconds. Ten VMs would take several minutes to boot.

Example 12: Compare with a VM boot

Type this:

aws ec2 run-instances --image-id ami-0abcd1234example --instance-type t3.micro --count 1 --query 'Instances[0].State.Name'

You will see:

"pending"   (about 40-90 seconds until running)

What it means: An EC2 VM sits in "pending" while it boots. This is fine for long-lived servers, but too slow for fast scaling of small apps.

Example 13: See image sizes

Type this:

docker images --format '{{.Repository}}:{{.Tag}}  {{.Size}}' | grep -E 'alpine|nginx|python'

You will see:

alpine:latest  7.8MB
nginx:1.27  192MB
python:3.12-slim  124MB

What it means: Alpine Linux is under 8 MB. A VM disk is usually 8 GB or more, about a thousand times bigger.

Example 14: Count how many containers fit

Type this:

for i in $(seq 1 20); do docker run -d --name n$i nginx:1.27 >/dev/null; done
docker stats --no-stream --format '{{.Name}} {{.MemUsage}}' | head -3

You will see:

n1 3.1MiB / 1.9GiB
n2 3.0MiB / 1.9GiB
n3 3.2MiB / 1.9GiB

What it means: Twenty web servers on a small 2 GB machine, each using about 3 MB of memory. Twenty VMs would never fit.

Example 15: Clean up the twenty containers

Type this:

docker rm -f $(docker ps -aq --filter name=n)

You will see:

n1
n2
...
n20

What it means: docker ps -aq --filter name=n prints the IDs of every container whose name has "n" in it, and docker rm -f removes them all.

Example 16: A container cannot see host processes

Type this:

docker run --rm alpine ps

You will see:

PID   USER     TIME  COMMAND
    1 root      0:00 ps

What it means: Inside the container only one process is visible: ps itself. The 100+ host programs are hidden.

Example 17: The host can see the container's process

Type this:

docker run -d --name sleeper alpine sleep 300
ps -ef | grep 'sleep 300' | grep -v grep

You will see:

root   48211  48190  0 10:02 ?  00:00:00 sleep 300

What it means: From outside, the container is just a normal process on the host. That is why it is so light. Remove it with docker rm -f sleeper.

Example 18: Limit what a container may use

Type this:

docker run --rm --memory 64m --cpus 0.5 alpine sh -c 'cat /sys/fs/cgroup/memory.max'

You will see:

67108864

What it means: --memory 64m caps memory at 64 MB and --cpus 0.5 gives half a CPU. The number printed is 64 MB in bytes. One greedy container cannot starve the others. Lesson 47.4 explains how this works.

Example 19: Containers inside a VM, the common setup

Type this:

cat /sys/class/dmi/id/sys_vendor
docker ps --format '{{.Names}}'

You will see:

Amazon EC2
api
worker
nginx

What it means: This EC2 VM runs three containers. Flipkart and Netflix work like this: VMs give servers, containers pack apps.

Example 20: A Windows app needs a VM on Linux

Type this:

docker run --rm mcr.microsoft.com/windows/servercore:ltsc2022 cmd /c ver

You will see:

docker: no matching manifest for linux/amd64 in the manifest list entries.

What it means: A Windows container needs a Windows kernel. A Linux host cannot give it one. For this, you need a Windows VM.

Example 21: A throwaway test database

Type this:

docker run -d --name testdb -e POSTGRES_PASSWORD=example postgres:16
docker rm -f testdb

You will see:

8c2e...
testdb

What it means: For a quick test, a container wins easily: seconds to create, one command to delete. A VM would take minutes and cost money per hour.

Example 22: The VM way: install Redis by hand

Type this:

sudo dnf install -y redis6
sudo systemctl start redis6
redis6-cli ping

You will see:

Installed: redis6-6.2.14-1.amzn2023.x86_64
PONG

What it means: Three commands, root access, and Redis is now installed into the server itself. Removing it later means uninstalling packages and leftover files.

Example 23: The container way: one command

Type this:

docker run -d --name cache -p 6380:6379 redis:7
docker exec cache redis-cli ping

You will see:

5d1e...
PONG

What it means: Same answer, PONG, with nothing installed on the host. We used outside port 6380 so it does not clash with the Redis we installed by hand.

Example 24: Remove both and compare

Type this:

sudo dnf remove -y redis6
docker rm -f cache

You will see:

Removed: redis6-6.2.14-1.amzn2023.x86_64
cache

What it means: The container left no trace on the host. With many apps and many versions, this clean add and remove is why teams at Razorpay and Zomato prefer containers for apps.