Docker and Docker Command Cheat Sheet: Complete Beginner Guide

Oct 3, 2025 • NinjaFunction Team

DockerDevOpsContainersCheat SheetTutorial

Docker and Docker Command Cheat Sheet: Complete Beginner Guide

Introduction: The "It Works On My Machine" Problem

You have probably heard this one before. A developer writes code on their laptop, tests it, and it works perfectly. They push it to GitHub. Their teammate pulls it down, runs it — and it crashes instantly.

Why? Different operating systems. Different library versions. Different environment settings. The code was fine — the environment was not.

This problem caused countless hours of frustration for decades. Then Dockerarrived and changed everything.

Docker packages your entire application — code, libraries, dependencies, and settings — into a single, portable unit called a container. It runs the same way on your laptop, your teammate's machine, and any server in the world.

In this beginner-friendly guide, you will learn what Docker is, how it works, how to use it step by step, and get a complete Docker command cheat sheet you can come back to any time.

What is Docker?

Docker is an open source platform that lets you build, ship, and run applications inside containers.

A container is a lightweight, isolated environment that contains everything your application needs to run — code, runtime, libraries, and configurations. It is completely independent of whatever machine it runs on.

Docker was released in 2013 and quickly became the standard for modern software deployment. Today, it powers everything from small side projects to production systems at Netflix, Spotify, PayPal, and thousands of other companies.

The Shipping Container Analogy

Before shipping containers were invented, moving goods around the world was chaotic. Every item had a different shape, size, and handling requirement. Ships, trains, and trucks all had to be custom-loaded.

Then someone invented the standard shipping container — a metal box with the same dimensions, no matter what is inside. Ships, cranes, and trucks all know how to handle it.

Docker containers work the same way. Instead of packing crates with different sizes, they provide a standard unit that runs anywhere. The application inside does not care whether it is on your laptop, on AWS, or on a server in another country. The container runs the same everywhere.

Why Docker Matters

Consistency: Same environment everywhere — no more "works on my machine."
Speed: Containers start in seconds, not minutes like virtual machines.
Efficiency: Containers share the host OS kernel and use far fewer resources than VMs.
Portability: Runs on any OS, any cloud, any server.
Isolation: Each container is completely separate from others.
Scalability: Spin up 100 containers with one command.
DevOps-ready: Integrates perfectly with CI/CD pipelines.

Docker vs Virtual Machines

Docker containers are often compared to virtual machines (VMs). Both provide isolation, but they work very differently.

Aspect	Docker Container	Virtual Machine
Size	Megabytes (MB)	Gigabytes (GB)
Startup Time	Seconds	Minutes
Uses Host OS Kernel	Yes	No — runs full OS
Resource Usage	Low	High
Isolation	Process-level	Full hardware-level

Rule of thumb: Use Docker for applications. Use VMs when you need full hardware-level isolation or a completely different OS.

Key Docker Concepts

1. Image

A read-only template that contains your application and its dependencies. Think of it as a recipe or blueprint. You build an image once and use it many times.

2. Container

A running instance of an image. If an image is a class, a container is an object. If an image is a recipe, a container is the cooked meal.

3. Dockerfile

A text file with instructions for building an image. It specifies the base image, files to copy, dependencies to install, and commands to run.

4. Volume

A persistent storage that lives outside a container. Containers are temporary — when they stop, their data is gone. Volumes keep data safe between restarts.

5. Docker Hub

The official registry for Docker images. Similar to GitHub but for containers. You can pull pre-built images (like nginx, postgres, node) or push your own.

6. Docker Compose

A tool for defining and running multi-container applications with a single YAML file. Instead of running five docker run commands, you run one docker compose up.

Installing Docker

Docker runs on Windows, macOS, and Linux. The installation is simple.

Windows & macOS

Download Docker Desktop from docker.com/products/docker-desktop. It includes Docker Engine, CLI, and Docker Compose in one installer.

Linux (Ubuntu/Debian)

sudo apt update sudo apt install docker.io sudo systemctl start docker sudo systemctl enable docker

Verify Installation

docker --version docker run hello-world

If you see a friendly "Hello from Docker!" message, you are ready to go.

Your First Docker Container

Let's run a real container — an Nginx web server — with one command.

docker run -d -p 8080:80 nginx

Let's break it down:

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

Now open http://localhost:8080 in your browser. You will see the default Nginx welcome page. You just ran a web server without installing anything.

Building Your Own Image

Running existing images is useful, but the real power of Docker is packaging your own apps. Let's build a simple Node.js app.

Step 1: Create the App

Create a file called app.js:

const http = require('http'); http.createServer((req, res) => { res.end('Hello from Docker!'); }).listen(3000); console.log('Server running on port 3000');

Step 2: Create a Dockerfile

Create a file called Dockerfile (no extension):

FROM node:20-alpine WORKDIR /app COPY app.js . EXPOSE 3000 CMD ["node", "app.js"]

Here is what each line does:

FROM: Start from a base image (Node.js 20 on Alpine Linux)
WORKDIR: Set the working directory inside the container
COPY: Copy files from your machine into the container
EXPOSE: Document which port the app uses
CMD: The command to run when the container starts

Step 3: Build the Image

docker build -t my-node-app .

The -t flag tags the image with a name. The . tells Docker to use the current directory as context.

Step 4: Run Your Container

docker run -d -p 3000:3000 my-node-app

Open http://localhost:3000. You will see "Hello from Docker!". You just built and ran your own container.

Docker Compose: Managing Multiple Containers

Real applications usually need more than one container — for example, a web app plus a database. Docker Compose lets you define them all in one file.

Create a file called docker-compose.yml:

version: '3.9' services: web: build: . ports: - "3000:3000" depends_on: - db db: image: postgres:16 environment: POSTGRES_PASSWORD: secret POSTGRES_DB: myapp volumes: - db-data:/var/lib/postgresql/data volumes: db-data:

Now run everything with one command:

docker compose up -d

Docker Compose starts your app and the database, connects them, and manages volumes automatically. This is how modern development teams run entire stacks with one command.

Understanding Volumes (Data Persistence)

Containers are temporary. When you delete a container, everything inside it disappears. For databases, logs, and user uploads, that is a problem.

Volumes solve this. A volume is storage that lives outside the container and survives restarts.

Create a volume:

docker volume create my-data

Mount it to a container:

docker run -d -v my-data:/app/data my-node-app

Now even if the container is deleted, the data in my-data remains.

Docker Command Cheat Sheet

Here is your complete reference. Bookmark this section — you will come back to it often.

Image Commands

Command	Description
docker images	List all local images
docker pull nginx	Download an image from Docker Hub
docker build -t name .	Build an image from a Dockerfile
docker rmi image_id	Delete an image
docker tag source target	Tag an image with a new name
docker push user/image	Upload an image to Docker Hub
docker history image_id	View the layers of an image

Container Commands

Command	Description
docker run image	Create and start a container
docker run -d image	Run in the background (detached)
docker run -it image bash	Run interactively with a shell
docker run -p 8080:80 image	Map host port to container port
docker ps	List running containers
docker ps -a	List all containers (including stopped)
docker start container_id	Start a stopped container
docker stop container_id	Stop a running container
docker restart container_id	Restart a container
docker rm container_id	Delete a container
docker logs container_id	View container logs
docker exec -it id bash	Open a shell inside a running container
docker inspect container_id	View detailed container info
docker stats	Live CPU, memory, and I/O usage
docker top container_id	See running processes inside a container

Volume Commands

Command	Description
docker volume create name	Create a new volume
docker volume ls	List all volumes
docker volume inspect name	See volume details
docker volume rm name	Delete a volume
docker volume prune	Remove unused volumes

Network Commands

Command	Description
docker network ls	List all networks
docker network create name	Create a custom network
docker network inspect name	View network details
docker network rm name	Delete a network

Docker Compose Commands

Command	Description
docker compose up	Start all services
docker compose up -d	Start in the background
docker compose down	Stop and remove all services
docker compose ps	List services
docker compose logs	View logs from all services
docker compose logs -f web	Follow logs from a specific service
docker compose build	Rebuild images
docker compose exec web bash	Open a shell inside a service
docker compose restart	Restart all services

Cleanup Commands

Command	Description
docker system df	Show disk usage
docker system prune	Remove unused containers, networks, images
docker system prune -a	Aggressive cleanup — removes all unused images
docker container prune	Remove all stopped containers
docker image prune	Remove unused images

Dockerfile Instructions Cheat Sheet

Instruction	Purpose
FROM	Base image to start from
WORKDIR	Set working directory inside container
COPY	Copy files from host to container
ADD	Like COPY but also handles URLs and tarballs
RUN	Execute a command during build
CMD	Default command when container starts
ENTRYPOINT	Fixed command that cannot be overridden easily
ENV	Set environment variables
ARG	Build-time variables
EXPOSE	Document which port the app uses
VOLUME	Declare a mount point for external storage
USER	Switch to a non-root user
LABEL	Add metadata (author, version, description)

Best Practices

Use small base images: Prefer alpine variants to reduce size
Use multi-stage builds: Separate build and runtime stages to shrink final image
Add a .dockerignore file: Exclude node_modules, .git, and other junk
Order layers for caching: Put rarely changing instructions first
Do not run as root: Create and use a non-root user
One process per container: Keep containers focused
Tag images properly: Avoid using latest in production
Never store secrets in images: Use environment variables or secret managers
Scan images for vulnerabilities: Use docker scan or Trivy

Common Mistakes to Avoid

Confusing images and containers: Images are blueprints, containers are running instances
Forgetting -d: Without it, your terminal gets stuck running the container
Not using volumes: Your data disappears when the container stops
Rebuilding every time: Use caching by ordering instructions smartly
Huge images: A 2GB image that could be 50MB slows everything down
Ignoring cleanup: Old containers and images eat up disk space
Running as root: A security risk in production

Summary

Docker is a platform for building, shipping, and running applications inside containers.
Shipping container analogy: Docker standardizes how apps are packaged, so they run everywhere.
Key concepts: Image (blueprint), Container (running instance), Dockerfile (recipe), Volume (persistent storage), Compose (multi-container).
Containers vs VMs: Containers are lighter, faster, and share the host OS kernel.
Your first commands: docker run, docker build, docker ps, docker logs.
Compose manages multi-container apps with a single YAML file.
Cheat sheet covers images, containers, volumes, networks, Compose, and Dockerfile instructions.
Best practices: Small images, multi-stage builds, non-root users, and clean tagging.

Docker has become a fundamental skill for developers, DevOps engineers, and anyone deploying software. Once you understand images, containers, and volumes, the entire Docker ecosystem clicks. Start with one container, then move to Compose, then integrate Docker into your CI/CD pipeline. Bookmark the cheat sheet — you will use it almost daily.

Getting Started with git: A Beginner Guide

Learn the fundamentals of git and how to setup & build your first project.

GitGit Commandgit-cmd

Jun 1, 2025•NinjaFunction Team

What is digipin?

DIGIPIN, or Digital Postal Index Number, is a standardized, geo-coded, grid-based digital address system officially launched by India's Department of Posts.

DIGIPINPincodePostalcodeZipcodeDigital Postal Index Number

Jun 2, 2025•Shahid Raza

What is Cloud Computing?

Cloud computing is the on-demand availability of computing resources. such as compute power, storage, networking, databases, and analytics. over the internet, typically offered on a pay-as-you-go model.