Running a container with docker run - Deep Dive

Overview - Running a container with docker run

What is it?

Running a container with docker run means starting a small, isolated program environment using Docker. Docker run is a command that tells Docker to create and start a container from an image, which is like a blueprint for the program. This lets you quickly launch applications without installing them directly on your computer. It is the main way to use Docker to run software.

Why it matters

Without docker run, you would have to manually set up software environments on your computer, which is slow and error-prone. Docker run solves this by automating the process of creating isolated spaces for programs, making it easy to test, develop, and deploy applications consistently. This saves time, avoids conflicts, and helps teams work together smoothly.

Where it fits

Before learning docker run, you should understand what Docker images and containers are. After mastering docker run, you can learn about advanced container management, networking, volumes, and Docker Compose for multi-container setups.

Mental Model

Core Idea

Docker run is the command that launches a container, creating a fresh, isolated environment from an image to run your application instantly.

Think of it like...

It's like ordering a meal at a restaurant: the menu (image) lists dishes, and when you order (docker run), the kitchen prepares a fresh plate (container) just for you to enjoy without affecting others.

┌───────────────┐
│ Docker Image  │
│ (Blueprint)   │
└──────┬────────┘
       │ docker run
       ▼
┌───────────────┐
│ Docker Container│
│ (Running Meal) │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is a Docker Container

Concept: Introduce the idea of a container as a lightweight, isolated environment.

A Docker container is like a mini-computer inside your computer. It runs programs separately so they don't interfere with each other. Containers share your computer's system but keep their files and settings private.

Result

You understand that containers isolate applications to avoid conflicts and make running software easier.

Understanding containers as isolated environments helps you see why docker run creates a safe space for your app.

2

Foundation

Docker Images as Blueprints

Concept: Explain that images are the starting point for containers.

A Docker image is a saved snapshot of an application and its environment. Think of it as a recipe or blueprint. When you run docker run, Docker uses this image to build a container.

Result

You know that images are static files that containers start from.

Knowing images are blueprints clarifies why you need an image before running a container.

3

Intermediate

Basic docker run Command Usage

🤔Before reading on: do you think docker run needs an image name every time, or can it run without one? Commit to your answer.

Concept: Learn the simplest form of docker run with an image name.

The basic command is: docker run For example, docker run hello-world runs a container from the hello-world image. Docker downloads the image if you don't have it yet, then starts the container.

Result

You can start a container from an image with one command and see its output.

Knowing that docker run automatically downloads images if missing makes running containers seamless.

4

Intermediate

Running Containers Interactively

🤔Before reading on: do you think docker run can let you type commands inside the container, or is it only for running fixed programs? Commit to your answer.

Concept: Use docker run with options to interact with the container's shell.

Add -it flags to run interactively: docker run -it ubuntu bash This starts an Ubuntu container and opens a command prompt inside it. You can type commands as if on a separate computer.

Result

You can control the container live and explore its environment.

Interactive mode lets you experiment inside containers, which is key for debugging and learning.

5

Intermediate

Mapping Ports to Access Services

🤔Before reading on: do you think containers can be accessed from your computer's browser by default, or do you need extra setup? Commit to your answer.

Concept: Expose container services to your computer by mapping ports.

Use -p to map ports: docker run -p 8080:80 nginx This runs an Nginx web server inside the container and makes it available on your computer's port 8080. You can open http://localhost:8080 in your browser to see it.

Result

You can access container apps from your computer or network.

Port mapping bridges the container's isolated network with your computer, enabling real use of containerized services.

6

Advanced

Running Containers with Volume Mounts

🤔Before reading on: do you think container files are saved permanently by default, or do they disappear when the container stops? Commit to your answer.

Concept: Use volumes to save or share data between your computer and containers.

Add -v to mount folders: docker run -v /host/path:/container/path busybox ls /container/path This shares files between your computer and the container. Changes in the container affect your files and vice versa.

Result

You can persist data and share files with containers safely.

Volumes solve the problem of containers losing data when stopped, enabling real-world workflows.

7

Expert

Understanding Container Lifecycle with docker run

🤔Before reading on: do you think containers keep running after you close your terminal, or do they stop? Commit to your answer.

Concept: Learn how docker run manages container start, stop, and removal automatically or manually.

By default, docker run starts a container and attaches your terminal to it. When you exit, the container stops but remains on your system. Use --rm to remove it automatically after exit. Example: docker run --rm busybox echo hello This runs and deletes the container immediately after finishing.

Result

You control container lifetime and cleanup, avoiding clutter or keeping containers as needed.

Knowing container lifecycle options prevents resource waste and helps manage many containers efficiently.

Under the Hood

Docker run tells the Docker Engine to create a container from an image by setting up a new isolated filesystem, network, and process space. It uses Linux kernel features like namespaces and cgroups to isolate the container. The Docker Engine downloads the image if missing, creates a writable container layer, and starts the main process inside it. The terminal attaches to the container's input/output streams if requested.

Why designed this way?

Docker run was designed to simplify container creation and execution with one command. It combines image fetching, container creation, and process start to reduce manual steps. Using Linux kernel features ensures lightweight isolation without full virtual machines. This design balances speed, isolation, and usability.

┌───────────────┐
│ docker run    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Docker Engine │
│  - Checks image
│  - Downloads if needed
│  - Creates container
│  - Sets namespaces & cgroups
│  - Starts process
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Container     │
│  - Isolated FS
│  - Isolated Network
│  - Running app
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does docker run automatically remove containers after they stop? Commit yes or no.

Common Belief: Docker run deletes containers automatically after they finish running.

Reality: By default, containers remain stopped on your system after running. You must add --rm to remove them automatically.

Why it matters: Without removing containers, your system fills with stopped containers, wasting disk space and cluttering management.

Quick: Can you run multiple containers from the same image at the same time? Commit yes or no.

Common Belief: You can only run one container from an image at a time.

Reality: You can run many containers from the same image simultaneously, each isolated and independent.

Why it matters: Believing you can run only one container limits your ability to scale and test multiple instances.

Quick: Does docker run expose container ports to your computer automatically? Commit yes or no.

Common Belief: Container ports are accessible from your computer by default without extra setup.

Reality: You must explicitly map ports with -p to access container services from your computer.

Why it matters: Without port mapping, you cannot reach container apps from outside, causing confusion when services seem unreachable.

Quick: Does running docker run -it always keep the container running after you close the terminal? Commit yes or no.

Common Belief: Interactive containers keep running in the background after you close the terminal.

Reality: When you exit an interactive container, it stops unless you start it detached or with special flags.

Why it matters: Misunderstanding this leads to lost work or stopped services unexpectedly.

Expert Zone

1

docker run's default network mode isolates containers but can be changed to share host networking for performance or compatibility.

2

The writable container layer created by docker run is temporary and discarded unless volumes are used, which affects data persistence.

3

Using --rm with docker run is great for short-lived containers but risky for debugging since the container disappears immediately.

When NOT to use

For complex applications with multiple containers, use Docker Compose or Kubernetes instead of multiple docker run commands. Also, for persistent data, rely on volumes or external storage rather than container filesystems.

Production Patterns

In production, docker run is often wrapped by orchestration tools that manage container lifecycle, scaling, and networking. However, it remains essential for quick testing, debugging, and one-off tasks.

Connections

Virtual Machines

Both provide isolated environments but differ in resource use and startup speed.

Understanding docker run helps grasp how containers are lightweight compared to full virtual machines, enabling faster and more efficient deployment.

Process Isolation in Operating Systems

Docker containers use OS-level process isolation features like namespaces and cgroups.

Knowing how OS isolates processes clarifies how docker run creates separate environments without full virtualization.

Restaurant Ordering Systems

docker run is like placing an order that triggers a fresh meal preparation from a recipe.

This connection helps understand the immediacy and repeatability of container creation from images.

Common Pitfalls

#1 Trying to access a web app in a container without mapping ports.

Wrong approach:

docker run nginx

Correct approach:

docker run -p 8080:80 nginx

Root cause:

Not understanding that container ports are isolated and need explicit mapping to be accessible from the host.

#2 Expecting container data to persist after container removal.

Wrong approach:

docker run --rm -v /host/data:/data busybox sh -c 'echo hello > /data/file.txt'

Correct approach:

docker run -v /host/data:/data busybox sh -c 'echo hello > /data/file.txt'

Root cause:

Using --rm removes the container and its writable layer immediately, so data is lost if not properly saved in volumes.

#3 Running docker run without specifying an image name.

Wrong approach:

docker run

Correct approach:

docker run hello-world

Root cause:

Not knowing that docker run requires an image name to know what to run.

Key Takeaways

Docker run is the main command to start containers from images, creating isolated environments for applications.

Images are blueprints, and containers are running instances created from these blueprints on demand.

Options like -it, -p, and -v extend docker run to interactive use, network access, and data sharing.

Understanding container lifecycle and cleanup options prevents resource waste and clutter.

Mastering docker run is essential before moving to advanced container orchestration and management.