47.1 Why Docker: works on my machine, devs vs ops

Example 1: Ask each computer for its Python version

Type this:

python3 --version

You will see:

Python 3.12.7   (on the laptop)
Python 3.8.10   (on the server)

What it means: Same command, two different answers. The two computers have different environments. That one difference is enough to break the app.

Example 2: Ask for the version of one library

Type this:

python3 -c "import flask; print(flask.__version__)"

You will see:

3.0.3                                      (on the laptop)
ModuleNotFoundError: No module named 'flask'   (on the server)

What it means: A library is extra code that your program borrows, like Flask for building web apps. The laptop has Flask 3.0.3. The server does not have Flask at all. This is the second way an environment can differ.

Example 3: See the operating system name

Type this:

cat /etc/os-release | grep PRETTY_NAME

You will see:

PRETTY_NAME="Ubuntu 24.04.1 LTS"        (on the laptop)
PRETTY_NAME="Amazon Linux 2023"         (on the server)

What it means: The operating system (OS) is the base software of the computer, like Ubuntu or Amazon Linux. Even the OS is different. Real companies like Infosys and TCS see this every week: the code is fine, the environment is not.

Example 4: Check that Docker is installed

Type this:

docker --version

You will see:

Docker version 27.3.1, build ce12230

What it means: Docker is installed and ready. If you see "command not found", install Docker first (lesson 47.5).

Example 5: Check that the engine is running

Type this:

docker version --format '{{.Server.Version}}'

You will see:

27.3.1

What it means: This asks the running engine for its own version. If you get a number, the engine is awake and listening. If you see "Cannot connect to the Docker daemon", start it with sudo systemctl start docker.

Example 6: Ask Docker for a short summary

Type this:

docker info --format 'Containers: {{.Containers}}  Images: {{.Images}}'

You will see:

Containers: 0  Images: 0

What it means: A fresh install has zero containers and zero images. Watch these numbers grow as we go through the lesson.

Example 7: Run your very first container

Type this:

docker run hello-world

You will see:

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.

What it means: docker run means "start a container". Docker started a tiny container, it printed a message, and it stopped. Notice the line "Pulling": Docker downloaded something first. That something is the image, which we meet in the next section.

Example 8: Run a container that says one line

Type this:

docker run alpine echo "Namaste from a container"

You will see:

Unable to find image 'alpine:latest' locally
latest: Pulling from library/alpine
Namaste from a container

What it means: alpine is a very small Linux. After the image name we can give a command, here echo, which prints text. The command ran inside the container, printed the line, and the container stopped.

Example 9: Prove the container has its own space

Type this:

docker run alpine ls /
ls /

You will see:

bin  dev  etc  home  lib  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
bin  boot  dev  etc  home  lib  ... snap  srv  sys  tmp  usr  var   (your computer)

What it means: The first list is the inside of the container. The second list is your own computer. They are different. The container sees its own files, not yours. That is what "separate space" means.

Example 10: List the images on your computer

Type this:

docker images

You will see:

REPOSITORY    TAG      IMAGE ID       SIZE
alpine        latest   91ef0af61f39   7.8MB
hello-world   latest   d2c94e258dcb   13.3kB

What it means: Two images are now saved. "REPOSITORY" is the image name. "TAG" is the version name; "latest" is the default when you do not give one. "SIZE" shows these are tiny.

Example 11: Start three containers from one image

Type this:

docker run alpine echo one
docker run alpine echo two
docker run alpine echo three

You will see:

one
two
three

What it means: No "Pulling" this time, because the image is already on disk. One image, three containers. Just like one tiffin recipe feeding three friends.

Example 12: Ask for a specific version with a tag

Type this:

docker run alpine:3.20 cat /etc/alpine-release
docker run alpine:3.19 cat /etc/alpine-release

You will see:

3.20.3
3.19.4

What it means: The part after the colon is the tag. Two tags give two different versions, side by side on the same computer, with no clash. Keep this idea in mind; it is the heart of the Swiggy fix.

Example 13: Pull Python without installing Python

Type this:

docker pull python:3.12-slim

You will see:

3.12-slim: Pulling from library/python
Status: Downloaded newer image for python:3.12-slim

What it means: Now you have an image with Python 3.12 inside. You did not install Python on your computer. It lives only inside the image. "slim" is a smaller version of the image.

Example 14: Pull a web server image

Type this:

docker pull nginx:1.27

You will see:

1.27: Pulling from library/nginx
Status: Downloaded newer image for nginx:1.27

What it means: nginx is a popular web server program. Companies like Zomato and Flipkart use it in front of their apps. Now it is on your disk, ready to run.

Example 15: Pull the same image again

Type this:

docker pull nginx:1.27

You will see:

1.27: Pulling from library/nginx
Status: Image is up to date for nginx:1.27

What it means: Docker checks first and downloads nothing, because you already have it. Pulling is safe to repeat.

Example 16: List running containers

Type this:

docker ps

You will see:

CONTAINER ID   IMAGE   COMMAND   STATUS   NAMES

What it means: Only the header line. Nothing is running now, because hello-world and the alpine containers finished their job and stopped.

Example 17: List all containers, stopped ones too

Type this:

docker ps -a

You will see:

CONTAINER ID   IMAGE         STATUS                     NAMES
7c1d0e2f3a45   alpine        Exited (0) 1 minute ago    happy_hopper
4f1c2a9b7e10   hello-world   Exited (0) 2 minutes ago   eager_lamport

What it means: Stopped containers are still on disk. "Exited (0)" means it finished with no error. Docker gave each a random name because we did not give one.

Example 18: Count all containers

Type this:

docker ps -a -q | wc -l

You will see:

6

What it means: -q (quiet) prints only the IDs, and wc -l counts lines. You ran six small containers in this lesson so far, and all six are still lying around.

Example 19: Remove one container by name

Type this:

docker rm eager_lamport

You will see:

eager_lamport

What it means: Use the name from your own output, because your random name will be different. Docker prints the name back to confirm.

Example 20: Remove all stopped containers at once

Type this:

docker container prune -f

You will see:

Deleted Containers:
7c1d0e2f3a45...
Total reclaimed space: 0B

What it means: prune cleans every stopped container. -f (force) skips the yes/no question. Running containers are never touched by this command.

Example 21: Run and remove automatically with --rm

Type this:

docker run --rm alpine echo "I clean up after myself"
docker ps -a

You will see:

I clean up after myself
CONTAINER ID   IMAGE   STATUS   NAMES

What it means: --rm deletes the container as soon as it stops. The list stays empty. Use --rm for quick one-time commands.

Example 22: Start nginx in the background

Type this:

docker run -d --name web nginx:1.27

You will see:

9a8b7c6d5e4f3a2b1c0d...

What it means: Docker prints the long container ID and gives your prompt back. The website is running quietly in the background.

Example 23: See it running

Type this:

docker ps

You will see:

CONTAINER ID   IMAGE        STATUS         PORTS    NAMES
9a8b7c6d5e4f   nginx:1.27   Up 5 seconds   80/tcp   web

What it means: "Up" means it is still running. "80/tcp" is its door, called a port. A port is a numbered door on a computer where a program listens. This door is inside the container, so your browser cannot reach it yet.

Example 24: Stop and start it again

Type this:

docker stop web
docker ps -a --filter name=web
docker start web

You will see:

web
CONTAINER ID   IMAGE        STATUS                     NAMES
9a8b7c6d5e4f   nginx:1.27   Exited (0) 2 seconds ago   web
web

What it means: docker stop stops it but keeps it. docker start starts the same container again. Using the name web is much easier than typing the ID.

Example 25: Replace the container with one that has a door

Type this:

docker rm -f web
docker run -d --name web -p 8080:80 nginx:1.27
curl -s localhost:8080 | grep title

You will see:

web
3e4f5a6b7c8d...
<title>Welcome to nginx!</title>

What it means: docker rm -f stops and removes the old container in one go. The new one has the door joined. curl asks for the web page, just like a browser does. You can also open http://localhost:8080 in your browser.

Example 26: Two websites side by side

Type this:

docker run -d --name web2 -p 8081:80 nginx:1.27
docker ps --format 'table {{.Names}}\t{{.Ports}}'

You will see:

NAMES   PORTS
web2    0.0.0.0:8081->80/tcp
web     0.0.0.0:8080->80/tcp

What it means: Both containers use door 80 inside, but different doors outside. This is how one server at Paytm can run many copies of an app.

Example 27: What happens if the outside door is busy

Type this:

docker run -d --name web3 -p 8080:80 nginx:1.27

You will see:

docker: Error response from daemon: ... Bind for 0.0.0.0:8080 failed: port is already allocated.

What it means: Door 8080 already belongs to web. Pick a free number such as 8082. Then clean up with docker rm -f web web2 web3.

Example 28: Two Python versions on one computer

Type this:

docker run --rm python:3.12-slim python --version
docker run --rm python:3.8-slim python --version

You will see:

Python 3.12.7
Python 3.8.20

What it means: The two images give two different versions on the same computer. The computer's own Python does not matter.

Example 29: Run the Swiggy-style code that broke

Type this:

printf 'import sys\nmatch sys.argv[1]:\n    case "menu":\n        print("Menu OK on Python", sys.version.split()[0])\n' > app.py
docker run --rm -v "$PWD":/app -w /app python:3.8-slim python app.py menu
docker run --rm -v "$PWD":/app -w /app python:3.12-slim python app.py menu

You will see:

  File "/app/app.py", line 2
    match sys.argv[1]:
          ^
SyntaxError: invalid syntax
Menu OK on Python 3.12.7

What it means: printf writes a tiny app into app.py. match only exists in Python 3.10 and newer. -v "$PWD":/app shares your folder with the container, and -w /app makes it the working folder. On 3.8 it fails, exactly like the server. On 3.12 it works. We just reproduced the bug and the fix on one laptop.

Example 30: The same image on another machine

Type this:

ssh ec2-user@test-server 'docker run --rm python:3.12-slim python --version'

You will see:

Python 3.12.7

What it means: Any server with Docker gives the same answer from the same image. So if Swiggy ships the app inside the 3.12 image, every server runs Python 3.12. In chapter 48 you will pack your own app into your own image.

Example 31: Node.js, the language behind many web apps

Type this:

docker run --rm node:22-slim node --version

You will see:

v22.11.0

What it means: Zomato and Uber use Node.js for many services. You got Node.js without installing it.

Example 32: Java, used by banks and by Netflix

Type this:

docker run --rm eclipse-temurin:21-jre java -version

You will see:

openjdk version "21.0.5" 2024-10-15 LTS

What it means: Java services at HDFC Bank or Netflix run in images like this, so every server runs the exact same Java.

Example 33: A database for testing

Type this:

docker run -d --name db -e POSTGRES_PASSWORD=example postgres:16
docker exec db psql -U postgres -c 'select version();' | head -3
docker rm -f db

You will see:

...
 PostgreSQL 16.4 on x86_64-pc-linux-gnu ...
db

What it means: -e passes a setting into the container; example is a practice value, never a real password. docker exec runs a command inside a running container. A full database in seconds, removed in one command.