Docker Basics: Image vs Container

Sun, 25 Jan 2026 00:00:00 +0000

Docker Image and Container - Two Essential Concepts

When starting with Docker, the two most important concepts you need to understand are Image and Container. Beginners often confuse them, but in reality, they play different roles in the Docker ecosystem. Image is like a recipe repository (cooking instructions), while Container is the actual execution (the prepared dish). 🍳

In this article, I’ll explain the detailed differences between Image and Container, how they work together, and provide real examples for better understanding.

I. What is a Docker Image?

A Docker Image is a template used to create a Container. It contains everything needed to run an application:

Operating system — usually minimal Linux
Runtime environment — Node.js, Python, Java, etc.
Application code
Dependencies (libraries)
Configuration files
Environment variables

1. Key Characteristics of Docker Image

Read-only: Image is read-only and cannot be changed after creation
Layered structure: Image is built from layers, each layer representing a command in Dockerfile
Reusable: The same image can be used to create multiple containers
Version-controlled: Each image has tags (e.g., 1.0, latest, alpine) for version management

Example of Image Structure:

Layer	Content
Layer 1	Base OS (Alpine Linux)
Layer 2	System packages (curl, wget)
Layer 3	Node.js runtime (18.x)
Layer 4	Application code
Layer 5	Environment variables

2. Common Image Commands

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# Pull an image from Docker Hub
docker pull node:18-alpine

# List downloaded images
docker images

# Remove an unused image
docker image rm node:18-alpine

# Remove all unused images
docker image prune -a

# Build image from Dockerfile
docker build -t myapp:1.0 .

II. What is a Docker Container?

A Docker Container is a running instance created from a Docker Image. Container has:

Its own file system
Isolated network space
Independent processes and operations
Its own environment variables

1. Key Characteristics of Docker Container

Read-only base + Read-write layer: Container has a read-write layer that allows data changes
Isolated: Container is isolated from host and other containers
Stateful: Container can be in various states: running, stopped, paused, exited
Ephemeral: Containers can be created and deleted quickly (< 1 second)

Example of Container:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# Create and run container from image
docker run -d --name myapp node:18-alpine node server.js

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop container
docker stop myapp

# Restart container
docker start myapp

# Remove container
docker rm myapp

# View container logs
docker logs myapp

2. Comparing Container with Virtual Machine

Aspect	Docker Container	Virtual Machine
Operating System	Share kernel with host	Full dedicated OS
Boot Time	~ 1-2 seconds	~ 1-2 minutes
Disk Size	MB (10-100 MB)	GB (1-10 GB)
Performance	Nearly native	Needs virtualization overhead
Max Per Host	Hundreds	Tens

Docker Container Architecture

III. Detailed Comparison: Image vs Container

For easy visualization, see the comparison table below:

Complete Comparison Table

Aspect	Image	Container
Analogy	Recipe repository (cooking recipe)	Prepared dish
State	Static (read-only)	Dynamic (read-write)
Changes	Cannot change after creation	Can change while running
Quantity	1 image creates N containers	Many containers from 1 image
Creation Time	Slow (first build ~5-10 mins)	Fast (< 1 second)
Storage	Stored in Docker cache	Stored at runtime or in volumes
Portability	Easy to share (push/pull)	Only runs where Docker is installed
Version	Has tags for management (1.0, 2.0, latest)	No separate version
Network	No	Has isolated network
Storage	Stored in layers	Has read-write layer on top of image

Relationship between Image and Container

1
2
3
4
5
6
7
8
9


Docker Image (Template)
 ↓
 docker run
 ↓
Docker Container (Running Instance)
 ↓
 docker commit
 ↓
Docker Image baru (updated)

Notes:

Image is like a class in Object Oriented Programming (OOP)
Container is like an object (instance of a class)
Use docker run to create container from image
Use docker commit to save container as a new image

IV. Real-World Example from Start to Finish

For better understanding, let’s do a detailed example:

1. Create Dockerfile (to build image)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# Dockerfile
FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

CMD ["node", "server.js"]

2. Build image from Dockerfile

1
2
3
4
5
6
7
8


# Build image with name myapp and tag 1.0
docker build -t myapp:1.0 .

# View created image
docker images
# Output:
# REPOSITORY TAG IMAGE ID CREATED SIZE
# myapp 1.0 abc123def456 2 minutes ago 150MB

3. Create and run container from image

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# Run container from image myapp:1.0
docker run -d \
 --name myapp-container \
 -p 3000:3000 \
 myapp:1.0

# View running containers
docker ps
# Output:
# CONTAINER ID IMAGE COMMAND STATUS PORTS
# xyz789ghi012 myapp:1.0 "node server.js" Up 2 minutes 0.0.0.0:3000->3000/tcp

# View logs
docker logs myapp-container

4. Interact with container

1
2
3
4
5
6


# Access container shell
docker exec -it myapp-container sh

# Inside container — you can:
ls -la /app
curl http://localhost:3000

5. Remove container and image

1
2
3
4
5
6
7
8


# Stop container
docker stop myapp-container

# Remove container
docker rm myapp-container

# Remove image
docker rmi myapp:1.0

V. Best Practices with Image and Container

1. Image Management

✅ Use specific versions (e.g., node:18.12-alpine instead of node:latest)
✅ Reduce size using minimal base images (alpine, distroless)
✅ Leverage layer cache by ordering commands properly
✅ Use .dockerignore to exclude unnecessary files
✅ Regularly remove unused images with docker image prune

1
2
3
4


# Example: Use specific image version
FROM node:18.12.1-alpine
# instead of
FROM node:latest

2. Container Management

✅ Name containers clearly (--name app-container)
✅ Use -d (detached mode) to run containers in background
✅ Regularly check logs for debugging (docker logs -f)
✅ Use volumes if data persistence is needed
✅ Limit resources with --cpus, --memory

1
2
3
4
5
6
7


# Run container with resource limits
docker run -d \
 --name app \
 --cpus="1.5" \
 --memory="512m" \
 -p 8080:80 \
 myapp:1.0

Common Troubleshooting

1. Cannot create container from image

Error:

1

Error: Cannot start container from image

Causes:

Image hasn’t been built or pulled
Image is corrupted
Port is already in use by another container

Solution:

1
2
3
4
5
6
7
8


# Check if image exists
docker images | grep myapp

# Pull again if not present
docker pull myapp:1.0

# Rebuild image
docker build -t myapp:1.0 .

2. Container doesn’t persist data when stopped

Cause: Container is ephemeral, data inside will be lost when it stops or is removed.

Solution: Use Docker Volumes

1
2
3
4
5
6
7
8


# Create volume
docker volume create myapp-data

# Mount volume to container
docker run -d \
 --name app \
 -v myapp-data:/app/data \
 myapp:1.0

3. Container not accessible from outside

Error: Cannot access http://localhost:3000 when running container