Docker Deep Dive · Prerequisites · P1 of 7

The Terminal & the Shell

Docker and Kubernetes are driven from one place: a shell. Every docker command, every Dockerfile RUN line, every kubectl exec lands you here — so before the whale, meet the three programs hiding behind your blinking cursor.

⏱ ~25 min hands-on · repo chapter p1-terminal-and-shell · cheatsheet: Linux & Shell · works on macOS, Windows, and Linux

cd docker-deep-dive
git pull
cd p1-terminal-and-shell

1Three programs pretending to be one

What you casually call "the terminal" is a sandwich of three very different programs:¹

• The terminal emulator (Terminal.app or iTerm on macOS, Windows Terminal, GNOME Terminal or Konsole on Linux…) draws text on screen and forwards your keystrokes. It understands nothing about commands.
• The shell is the interpreter: it reads a line, splits it into words, finds the program you named, asks for it to be run, then reports how it went. Which one you have depends on your OS — zsh on modern macOS, bash on most Linux distros, PowerShell on Windows — and bash (or sh) inside almost every container.²
• The kernel is the one program that actually runs programs and touches hardware — disk, network, memory. Everything above it must ask.

Prompt anatomy. The shell signals who and where you are before every command. The convention survives across systems: zsh ends its prompt in %, bash in $ for a normal user — and # when you are root, the all-powerful admin user. (PowerShell writes PS C:\Users\you> — different costume, same job.) Inside containers you'll see # a lot; P2 explains why that matters.

2The 40 milliseconds after you press Enter

Type ls -l /var/log and hit Enter. Here's the round trip — step through it:²

3Command anatomy, and how to ask for help

command -f --long-flag argument1 argument2
# ls        -l          /var/log   → short flags stack: ls -lah = -l -a -h

Help systems, by where you're standing:

ls --help        # quick flag list — works in every container
man ls           # the full manual — on macOS & Linux hosts (Windows: Get-Help dir)
type ls          # what IS this command, really? (section 5 shows why this matters)

But try man ls inside a container and you get a surprise — images are stripped to stay small, so the manual pages simply aren't in there:

man ls

This system has been minimized by removing packages and content that are
not required on a system that users do not log into.

To restore this content, including manpages, you can run the 'unminimize'
command. You will still need to ensure the 'man-db' package is installed.

Rule of thumb: --help inside containers; man on a macOS/Linux host; Get-Help if you're in PowerShell.⁵

4Lab A — move around, inside your Linux box

docker run -it --name linuxbox ubuntu:24.04 bash

Your prompt changes to something like root@bd5ceeacf242:/# — user root (that trailing #!), hostname = the container's ID. You are the admin of this tiny machine; P2 explores what that means. First, look at the land:

ls /

bin   dev  home  media  opt   root  sbin  sys  usr
boot  etc  lib   mnt    proc  run   srv   tmp  var

That's the standard Linux tree — /etc for config, /var for logs and data, /root is root's home. P2 gives you the guided tour; it's also exactly what a Docker image is. Now learn to move. The filesystem is one tree growing from the root, /. An absolute path starts there (/var/log); a relative path starts from where you are. Three shorthands: . here · .. up one · ~ your home.¹

pwd              # where am I? trust this, not the prompt
cd /var/log      # absolute: same result from anywhere
pwd
cd ~             # home again (plain cd does the same)
pwd
cd -             # bounce back to wherever you just were

/
/var/log
/root

Now build something. You'll make a small notes project, reorganize it, and tear part of it down — the exact moves you'll later do inside images:

cd ~
mkdir -p harbor-notes/docs harbor-notes/drafts    # -p makes parents too
cd harbor-notes
touch docs/setup.md docs/commands.md drafts/idea.txt
find .                                            # show the whole tree

.
./docs
./docs/commands.md
./docs/setup.md
./drafts
./drafts/idea.txt

cp -r docs docs-backup       # -r = recursive, needed for directories
mv drafts/idea.txt docs/idea.md   # mv moves AND renames — same command
rm -r docs-backup            # gone. no trash. no undo. read twice, then Enter
ls -l docs

total 0
-rw-r--r-- 1 root root 0 Jul 17 03:12 commands.md
-rw-r--r-- 1 root root 0 Jul 17 03:12 idea.md
-rw-r--r-- 1 root root 0 Jul 17 03:12 setup.md

Peek at details with ls -lah (long, all, human sizes) — for now read just names, sizes, dates. The cryptic rw-r--r-- column on the left is the entire subject of P2. To page through any long file: less filename — space scrolls, /word searches, q quits. Stay in the box (or hop back in with the same docker run line after an exit) — Lab B uses it.

5Your own terminal — three dialects, one common ground

Everything in Lab A also works natively on macOS and Linux, because their shells and tools come from the same POSIX family. But "the same family" is not "identical" — and Windows speaks a different language entirely. Ask your own shell what ls really is:

type ls          # bash/zsh (PowerShell: Get-Command ls)

# macOS (the instructor's themed zsh):
ls is an alias for eza --icons --grid --group-directories-first

# ubuntu:24.04 container (interactive bash):
ls is aliased to `ls --color=auto'

# Windows PowerShell (documented default):
Alias   ls -> Get-ChildItem

On all three systems, ls isn't plain ls. macOS setups often alias it to a modern tool like eza; Ubuntu quietly adds color flags; Windows PowerShell maps it to a completely different program, Get-ChildItem, whose flags share nothing with Unix ls.⁶ type (or Get-Command) is the truth-teller: it reveals aliases, builtins, and real binaries — ask it whenever a command behaves unlike the tutorial you're reading.

Even the "real" ls (aliases aside) differs by host — same name, three different programs:³

You only own one of those rows — no need to test the others. The check everyone can run, because every learner has the same container:

ls --version

ls (GNU coreutils) 9.4
Copyright (C) 2023 Free Software Foundation, Inc.

This is the point of the whole section: your host is a dialect; the container is the standard. Whatever terminal you own — zsh on a Mac, bash on Fedora, PowerShell on Windows — the linuxbox gives every learner the identical GNU/Linux environment, and that's the dialect Dockerfiles and Kubernetes manifests speak.

6Lab B — disposability, and your first graded exercise

exit                     # leave the shell → the container stops
docker rm linuxbox       # throw the whole machine away
docker run -it --name linuxbox ubuntu:24.04 bash
ls /root                 # … empty. your tree is gone

Fresh box, no harbor-notes. Containers forget — you met this in Lesson 1, and it's why anything worth keeping lives in an image (Lesson 3) or a volume (Lesson 5). Here it's a feature: you can never wreck this machine in a way docker rm won't fix.

Finish with the feedback loop. The chapter ships check.sh, a grader for the tree you built. Exit the box, then — from the chapter folder — start one that can see it (-v shares the folder at /labs; lesson 5 explains):

exit
docker rm linuxbox
docker run -it --rm -v "$PWD":/labs ubuntu:24.04 bash

docker run -it --rm -v "${PWD}:/labs" ubuntu:24.04 bash

cd /root
mkdir -p harbor-notes/docs harbor-notes/drafts
cd harbor-notes
touch docs/setup.md docs/commands.md drafts/idea.txt
cp -r docs docs-backup
mv drafts/idea.txt docs/idea.md
rm -r docs-backup
sh /labs/check.sh /root/harbor-notes

PASS  harbor-notes/ exists
PASS  docs/ exists
PASS  drafts/ exists
PASS  docs/setup.md exists
PASS  docs/commands.md exists
PASS  docs/idea.md exists (moved from drafts/ and renamed)
PASS  drafts/idea.txt is gone (it moved)
PASS  docs-backup/ is gone (rm -r cleaned it up)
----
8 passed, 0 failed
All good — tree matches the lab. ✔

Any FAIL line tells you which move to redo — fix it and run the grader again. (On a macOS/Linux/WSL host you can also do the whole lab natively and grade it with sh check.sh ~/harbor-notes — the grader is the same either way.)

7Check yourself

8Go deeper

Primary source: The Linux Command Line by William Shotts — free book at linuxcommand.org. Chapters 1–4 cover this lesson's ground with more leisure: what shells are, navigation, and file manipulation. It's the book this whole phase leans on. (Windows readers: everything in it applies inside your linuxbox or WSL.)

Next: that rw-r--r-- column you were told to ignore, the mysterious root, and the guided tour of /etc and friends — P2: Files, Permissions & root. The Linux tree you just glimpsed with ls / is, byte for byte, what a Docker image contains.