Docker Actually Explained (No Fluff)

Docker tutorials love to start with a 20-minute explanation of containerization theory, kernel namespaces, and the history of Linux cgroups.

You don’t need any of that to use Docker effectively.

Here’s what actually matters: Docker lets you package software so it runs the same way everywhere. Your laptop. A server in AWS. Your coworker’s machine that somehow has different versions of everything. Same code, same behavior, every time.

If you’ve ever spent hours debugging something that “works on my machine,” Docker exists to make that phrase obsolete. If you’ve been avoiding containers because the ecosystem seems overwhelming—Kubernetes, Docker Compose, orchestration—you’re in the right place. This guide covers what you need to work with Docker, without the stuff you don’t. (And if you’re still figuring out whether IT is the right career path, container skills are one of the most transferable you can build.)

Why IT Pros Keep Putting Off Docker

The real barrier isn’t complexity. It’s how Docker gets taught.

Most tutorials assume you’re a developer who needs to understand every layer of the technology. They start with abstractions, move to architecture diagrams, and only get to practical commands twenty minutes in. By then, you’re drowning in terminology before running your first container.

For IT professionals—sysadmins, support engineers, cloud practitioners—the path is different. You need to:

• Spin up services quickly for testing
• Understand what developers are deploying
• Run applications without dependency conflicts
• Build home labs without VM overhead

None of that requires deep container theory. It requires knowing which commands to run and why.

The other problem? Docker content assumes you’re building applications from scratch. Most IT work involves running, maintaining, and troubleshooting existing containers—someone else’s code, someone else’s images. That’s a different skill set, and it’s what we’re covering here.

What Docker Actually Does (The 2-Minute Version)

A Docker container is a self-contained package with everything needed to run an application: the code, runtime, libraries, and system tools. Unlike a virtual machine, it doesn’t need its own operating system. Containers share the host’s kernel, making them lightweight and fast.

Think of it like this:

Virtual Machines = Separate apartments in a building. Each has its own kitchen, bathroom, plumbing, electrical. Lots of overhead, but completely isolated.

Containers = Rooms in a house. They share the kitchen and bathrooms (the host OS kernel) but have their own locked doors and personal space. Lighter weight, still isolated enough for most purposes.

That’s genuinely the core concept. Everything else is implementation details.

Why Containers Beat VMs for Most IT Tasks

If you’ve built a home lab, you’ve probably noticed how resource-hungry VMs can be. Running three or four VMs for testing? Your laptop fans start sounding like a jet engine.

Containers flip this equation:

Aspect	Virtual Machine	Docker Container
Startup time	Minutes	Seconds
Memory overhead	GBs per VM	MBs per container
Disk space	10-50 GB per VM	Typically under 1 GB
Isolation	Complete (own kernel)	Process-level (shared kernel)
Use case	Different OS requirements	Application deployment

This doesn’t mean VMs are obsolete. If you need to run Windows Server for Active Directory testing or want complete isolation for security research, VMs remain the right tool. But for running applications, testing configurations, and learning new tools? Containers are faster and lighter.

Installing Docker: Pick Your Path

Docker installation varies by platform. Here’s the quick version:

Linux (Recommended for Learning)

If you’re on Ubuntu or another Debian-based distro, the official install is straightforward:

# Update packages
sudo apt update

# Install prerequisites
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# Add Docker's GPG key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Install Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

# Add your user to the docker group (avoid needing sudo for every command)
sudo usermod -aG docker $USER

Log out and back in for the group change to take effect.

If you’re still building your Linux fundamentals, Docker is actually a great way to practice—you’ll be running Linux commands constantly.

macOS and Windows

Docker Desktop handles everything on these platforms. Download from docker.com, run the installer, and you’re done.

One caveat: Docker Desktop runs a lightweight Linux VM behind the scenes on Mac and Windows. This adds some overhead compared to running Docker natively on Linux. For learning and development, it’s fine. For production workloads, Linux remains the standard.

Verify Installation

docker --version
docker run hello-world

If you see a “Hello from Docker!” message, you’re set.

Your First Container: Actually Doing Something Useful

Forget hello-world. Let’s run something practical.

Example 1: Spinning Up a Web Server

docker run -d -p 8080:80 --name my-nginx nginx

That’s it. Visit http://localhost:8080 in your browser. You’re running a full Nginx web server.

Let’s break down what happened:

• docker run - Create and start a container
• -d - Run in the background (detached mode)
• -p 8080:80 - Map port 8080 on your machine to port 80 in the container
• --name my-nginx - Give the container a memorable name
• nginx - The image to use (Docker pulls it automatically from Docker Hub)

Example 2: Running a Database

Need a MySQL instance for testing? Don’t install MySQL locally and deal with version conflicts:

docker run -d \
  --name test-mysql \
  -e MYSQL_ROOT_PASSWORD=testpassword \
  -e MYSQL_DATABASE=myapp \
  -p 3306:3306 \
  mysql:8.0

You now have MySQL 8.0 running. When you’re done, docker stop test-mysql shuts it down. docker rm test-mysql removes it entirely. No uninstall process, no leftover configuration files.

Example 3: Testing Different Software Versions

This is where Docker shines for IT professionals. If you’re learning Python, need to test something against multiple versions?

# Python 3.9
docker run -it --rm python:3.9 python --version

# Python 3.11
docker run -it --rm python:3.11 python --version

# Python 3.12
docker run -it --rm python:3.12 python --version

The -it flag gives you an interactive terminal. The --rm flag automatically removes the container when it exits. You just tested three Python versions without installing any of them.

Essential Commands: The 20% That Handles 80% of Work

Docker has hundreds of commands and options. Here’s what you’ll actually use:

Container Lifecycle

# See running containers
docker ps

# See ALL containers (including stopped)
docker ps -a

# Stop a container
docker stop container_name

# Start a stopped container
docker start container_name

# Remove a container (must be stopped first)
docker rm container_name

# Force remove a running container
docker rm -f container_name

# Remove all stopped containers
docker container prune

Getting Inside Containers

Sometimes you need to troubleshoot what’s happening inside:

# Open a shell in a running container
docker exec -it container_name /bin/bash

# If bash isn't available (minimal images), try sh
docker exec -it container_name /bin/sh

# Run a single command
docker exec container_name cat /etc/hosts

This is essentially SSH-ing into your container, but without actual SSH.

Viewing Logs

# View container logs
docker logs container_name

# Follow logs in real-time (like tail -f)
docker logs -f container_name

# Show last 100 lines
docker logs --tail 100 container_name

When a container isn’t behaving, logs are your first stop. If you’re comfortable with bash scripting, you can pipe these to grep for filtering.

Managing Images

# List downloaded images
docker images

# Pull an image without running it
docker pull nginx:latest

# Remove an image
docker rmi image_name

# Remove unused images
docker image prune

Disk Space Management

Docker can accumulate cruft. Periodically clean up:

# See how much space Docker is using
docker system df

# Remove everything unused (containers, images, networks, cache)
docker system prune -a

Be careful with prune -a—it removes all images not currently used by containers. Make sure you don’t need them first.

Understanding Images and Tags

Docker images come from registries—Docker Hub being the most common. When you run docker pull nginx, you’re downloading the official Nginx image.

Image Tags

Tags specify versions:

nginx:latest    # Most recent version (can change unexpectedly)
nginx:1.25      # Specific version
nginx:1.25.3    # Even more specific
nginx:alpine    # Smaller image based on Alpine Linux

Pro tip: Avoid latest in anything resembling production. “Latest” today and “latest” next month might behave differently. Pin to specific versions when reliability matters.

Where Images Come From

• Docker Hub - The default registry. Most official images live here.
• GitHub Container Registry (ghcr.io) - Common for open-source projects
• AWS ECR, Azure ACR, Google GCR - Cloud provider registries
• Private registries - For internal/proprietary images

To pull from a non-default registry:

docker pull ghcr.io/some-org/some-image:tag

Data Persistence: Volumes and Bind Mounts

Containers are ephemeral by default. When you remove a container, its data disappears. For databases, configuration files, or anything you want to keep, you need persistence.

Volumes (Docker-Managed Storage)

# Create a volume
docker volume create my-data

# Use it with a container
docker run -d \
  --name postgres-db \
  -v my-data:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:15

The -v my-data:/var/lib/postgresql/data part maps the Docker volume my-data to the PostgreSQL data directory inside the container. Stop the container, remove it, start a new one with the same volume—your data persists.

Bind Mounts (Host Directory Mapping)

For development or when you need direct access to files:

docker run -d \
  --name web-server \
  -v /path/on/host:/usr/share/nginx/html \
  -p 8080:80 \
  nginx

Now changes to /path/on/host immediately reflect in the container. Edit files on your machine, see changes in the running container.

This is powerful for development workflows but slightly less portable than volumes.

Docker Compose: Multi-Container Applications

Real applications rarely run in single containers. A typical web app might need:

• The application itself
• A database
• A cache (Redis)
• A reverse proxy

Docker Compose manages these as a unit using a YAML file.

Example: WordPress with MySQL

Create a file named docker-compose.yml:

version: "3.8"

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppassword
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    depends_on:
      - db

  db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppassword
      MYSQL_ROOT_PASSWORD: rootpassword
    volumes:
      - db_data:/var/lib/mysql

volumes:
  wordpress_data:
  db_data:

Then run:

docker compose up -d

Both containers start, properly networked, with persistent storage. To stop everything: docker compose down. To stop and delete volumes: docker compose down -v.

This is how you should run multi-container setups. Individual docker run commands get unwieldy fast.

Building Your Own Images: Dockerfile Basics

Eventually, you’ll need to create custom images—maybe adding tools to an existing image or packaging your own application.

A Dockerfile is a recipe:

# Start from an existing image
FROM ubuntu:22.04

# Set environment variables
ENV DEBIAN_FRONTEND=noninteractive

# Run commands to customize the image
RUN apt-get update && apt-get install -y \
    curl \
    vim \
    net-tools \
    && rm -rf /var/lib/apt/lists/*

# Copy files into the image
COPY config.txt /app/config.txt

# Set the working directory
WORKDIR /app

# Default command when container starts
CMD ["bash"]

Build it:

docker build -t my-custom-image:1.0 .

The -t tags your image with a name. The . tells Docker to look for the Dockerfile in the current directory.

Dockerfile Best Practices

Keep images small and secure:

1. Use specific base image tags - ubuntu:22.04 not ubuntu:latest
2. Combine RUN commands - Each RUN creates a layer; combine related commands with &&
3. Clean up in the same layer - Install and remove package manager cache in one RUN
4. Use .dockerignore - Exclude files that shouldn’t be in the image

For IT operations work, you’ll often modify existing images slightly rather than building from scratch. Understanding the Dockerfile format helps you understand what images contain and how to customize them.

Networking: How Containers Talk

By default, Docker creates a bridge network. Containers on the same network can reach each other by name.

# Create a custom network
docker network create my-network

# Run containers on that network
docker run -d --name web --network my-network nginx
docker run -d --name app --network my-network python:3.11

# From the 'app' container, you can now reach 'web' by name
docker exec app curl http://web

Docker’s built-in DNS resolves container names to IP addresses automatically. No hardcoding IPs, no manual /etc/hosts editing.

Port Mapping Explained

The -p flag maps ports between host and container:

-p 8080:80     # Host 8080 → Container 80
-p 127.0.0.1:8080:80  # Only accessible from localhost
-p 8080:80/udp  # UDP instead of TCP

If you skip -p, the container’s ports are not accessible from outside. The service runs but can’t be reached.

Practical Scenarios for IT Professionals

Scenario 1: Testing Application Updates

Before updating an application in production, test in a container:

# Current production version
docker run -d -p 8080:80 --name app-current myapp:2.1

# New version for testing
docker run -d -p 8081:80 --name app-test myapp:2.2

Compare both side-by-side without affecting anything.

Scenario 2: Isolated Troubleshooting Environments

Need to reproduce a user’s issue with a specific software version?

docker run -it --rm ubuntu:20.04 bash

You’re in a clean Ubuntu 20.04 environment. Install what you need, test, exit. No impact on your system.

Scenario 3: Quick Security Tool Access

Many security and networking tools come as Docker images. If you’re exploring cybersecurity careers, Docker gives you instant access to common tools:

# Nmap scanning
docker run --rm -it instrumentisto/nmap -A target.com

# Network troubleshooting
docker run --rm -it nicolaka/netshoot

No installation, immediate access to specialized tools.

Scenario 4: Learning New Technologies

Docker Hub has official images for nearly everything. Want to explore Redis? MongoDB? PostgreSQL? Elasticsearch?

docker run -d -p 6379:6379 redis
docker run -d -p 27017:27017 mongo
docker run -d -p 9200:9200 -e "discovery.type=single-node" elasticsearch:8.11.0

Instant learning environments with zero commitment.

Common Mistakes and How to Avoid Them

Mistake 1: Forgetting Containers Are Ephemeral

You make changes inside a container, restart it, and everything’s gone. If data matters, use volumes.

Mistake 2: Running Everything as Root

By default, processes in containers run as root. For production, specify a non-root user in your Dockerfile or with --user:

docker run --user 1000:1000 nginx

Mistake 3: Ignoring Resource Limits

Containers can consume unlimited host resources by default. Set limits:

docker run -d --memory="512m" --cpus="1.0" nginx

Mistake 4: Not Cleaning Up

Old containers and images accumulate. Schedule periodic cleanup:

# Remove stopped containers and unused images
docker system prune -f

Mistake 5: Using latest Tags in Automation

Your script works today, breaks next month when latest points to a new version. Always pin versions for reproducibility.

What’s Next: Docker in the Broader Ecosystem

Docker is the foundation, but it connects to larger systems:

Kubernetes - Container orchestration for running containers at scale across multiple machines. If you’re heading toward cloud engineering or DevOps, Kubernetes is the next step.

CI/CD Pipelines - Docker enables consistent build and test environments. Same container locally and in your pipeline. If you’re coming from a technical interview prep background, expect Docker questions in DevOps and cloud roles.

Cloud Container Services - AWS ECS, Azure Container Instances, Google Cloud Run—ways to run containers without managing servers. An AWS certification covers container basics as part of the exam.

For IT professionals, proficiency with Docker bridges traditional infrastructure and modern deployment patterns. It’s increasingly expected for roles beyond pure development—sysadmins moving toward DevOps, cloud practitioners, and anyone managing modern applications.

Building Docker Skills: Practical Next Steps

Theory only goes so far. Here’s how to build real competency:

1. Containerize something you use - Take a script or tool you run regularly, package it in Docker
2. Replace local services with containers - Run your development database in Docker instead of installing it natively
3. Build a home lab stack - Use Docker Compose for services like Pi-hole, Portainer, monitoring tools
4. Practice troubleshooting - Intentionally break things. Figure out why containers won’t start, why networking fails
5. Read Dockerfiles - Browse popular images on GitHub. See how production-quality images are built

If you’re building command-line fundamentals alongside Docker, platforms like Shell Samurai provide hands-on Linux practice that directly applies to container work.

Frequently Asked Questions

Is Docker free to use?

Docker Engine (the core technology) is free and open source. Docker Desktop is free for personal use, education, and small businesses (under 250 employees AND under $10M revenue). Larger organizations require a paid subscription for Docker Desktop, though they can still use Docker Engine directly on Linux for free.

Do I need Linux to learn Docker?

No. Docker Desktop runs on Mac and Windows. However, since production Docker environments are almost always Linux-based, building Linux skills alongside Docker makes you more effective.

How does Docker relate to DevOps?

Docker is a foundational DevOps tool. It enables consistent environments across development, testing, and production—a core DevOps principle. Most DevOps career paths expect Docker proficiency.

Should I learn Docker before Kubernetes?

Yes. Kubernetes orchestrates containers—you need to understand containers first. Master Docker basics before adding Kubernetes complexity.

Is Docker replacing virtual machines?

Not entirely. Docker containers and VMs serve different purposes. Containers excel for application deployment; VMs remain necessary when you need different operating systems or stronger isolation. Most environments use both.

How do I add Docker to my resume?

If you’ve built projects with Docker, include them in a projects section or on your home lab resume entry. For IT roles, demonstrating container experience—even from personal projects—shows you’re keeping current with modern infrastructure practices.

The Bottom Line

Docker isn’t complicated—it’s just taught that way.

The core concept is simple: package applications so they run identically everywhere. The commands are learnable in an afternoon. The deeper understanding comes from using it repeatedly on real problems.

If you’ve been putting off containers because they seemed intimidating, start with a single docker run command. Spin up Nginx. Run a database. Break something and figure out why.

That’s how you actually learn Docker—not from theory, but from doing.