Docker for Beginners: A Hands-On Tutorial to Master Containers from Scratch

✅ Chapter 2: Working with Docker Images and Containers

🚀 Overview

After setting up Docker and understanding its basic architecture in Chapter 1, it's time to dive into its two most essential building blocks: Docker Images and Docker Containers.

• A Docker image is a snapshot or template of an application with all its dependencies.
• A Docker container is a running instance of that image.

This chapter focuses on how to create, manage, inspect, and optimize images and containers to power real-world application workflows.

🧱 What is a Docker Image?

A Docker image is a layered, read-only template used to create containers. It includes:

• Application code
• Runtime (e.g., Python, Node.js)
• Libraries and dependencies
• Environment variables
• Configuration files
• Entry commands

Images are immutable once built. Any changes made at runtime are saved as a new layer on top of the existing image.

🔍 Docker Image Lifecycle

text

Dockerfile → Build → Image → Run → Container → Modify (Optional) → Commit → New Image

🛠️ Dockerfile Basics

To build a Docker image, you write a Dockerfile. Let’s break down a sample.

Dockerfile

# Use official Python image

FROM python:3.10

# Set working directory

WORKDIR /usr/src/app

# Copy files into container

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

# Default command

CMD [ "python", "./app.py" ]

🧾 Common Dockerfile Instructions

🧪 Build Your First Image

bash

docker build -t my-python-app .

• -t assigns a name (tag) to the image.
• . means build context is the current directory.

📦 Docker Container: What Is It?

A container is a runtime instance of an image. It runs in isolation with its own file system, networking, and process space—but shares the host’s kernel.

Containers are ephemeral by default. Once stopped or deleted, their internal state is lost (unless volumes are used).

🔄 Lifecycle of a Docker Container

🔧 Working with Docker Images

✅ Listing Images

bash

docker images

✅ Removing Unused Images

bash

docker rmi <image-id>

To remove all dangling (unused) images:

bash

docker image prune

🧰 Working with Docker Containers

✅ Create and Start

bash

docker run -d --name my-container nginx

✅ View Running Containers

bash

docker ps

To include stopped containers:

bash

docker ps -a

✅ Stop and Remove

bash

docker stop my-container

docker rm my-container

🔍 Inspecting Images and Containers

Inspect metadata:

bash

docker inspect my-container

Check logs:

bash

docker logs my-container

Enter a running container:

bash

docker exec -it my-container bash

Helpful for debugging, running commands, or exploring runtime behavior.

🧱 Container vs Image: A Quick Reference

📁 Exporting and Importing Images

Save image to .tar:

bash

docker save -o myapp.tar my-python-app

Load saved image:

bash

docker load -i myapp.tar

🧹 Cleaning Up Docker

Clean up all stopped containers, unused images, networks:

bash

docker system prune

To remove everything including volumes:

bash

docker system prune -a --volumes

Use with caution!

💡 Advanced Tip: Tagging Images

Docker supports image versioning using tags.

bash

docker build -t myapp:1.0 .

docker build -t myapp:latest .

Then you can run specific versions:

bash

docker run myapp:1.0

This is critical for managing production vs development versions.

🗂️ Docker Image Layer Caching

Each instruction in a Dockerfile creates a layer. Docker caches these to speed up builds.

Dockerfile

# Efficient layering

COPY requirements.txt .

RUN pip install -r requirements.txt

COPY . .

If requirements.txt doesn’t change, Docker will cache the pip install step.

🧰 Debugging Common Errors

🔗 Docker Hub: Managing Public and Private Images

Login:

bash

docker login

Push an image:

bash

docker tag myapp username/myapp

docker push username/myapp

Pull an image:

bash

docker pull nginx

Use docker search <keyword> to find images.

🧠 Summary of Chapter 2

You’ve now explored:

• How to build Docker images using Dockerfiles
• How to run, stop, inspect, and remove containers
• The difference between images and containers
• Container lifecycle and runtime customization
• Tagging and optimizing images for caching
• Exporting, importing, and debugging containers

In the next chapter, we’ll explore networking and persistent storage with Docker.