🐳 Mastering the Dockerfile: The Complete Beginner’s Guide

Docker is one of the most essential tools in DevOps and cloud-native development. At the heart of Docker is the Dockerfile — a simple text file with instructions to build a Docker image.

This guide will walk you through everything you need to know about Dockerfiles, from basics to best practices.

📦 What is a Dockerfile?

A Dockerfile is like a recipe 🧑‍🍳.

• Each line is an instruction.
• Docker processes it top to bottom.
• The result is a Docker image, which you can run as a container.

Flow:

 Dockerfile ➝ Docker Image ➝ Container 

🛠️ Basic Structure of a Dockerfile

Here’s a template:

FROM <base-image> WORKDIR <directory> COPY <src> <dest> RUN <command> CMD ["executable", "param1", "param2"] 

🔑 Key Instructions Explained

1. FROM

Sets the base image to start with.

FROM python:3.9-slim 

👉 Every Dockerfile must start with a base image (unless you’re building completely from scratch).

2. WORKDIR

Defines the working directory inside the container.

WORKDIR /app 

3. COPY

Copies files from your local machine into the container.

COPY requirements.txt . COPY . . 

4. RUN

Executes commands at build time.

RUN pip install -r requirements.txt 

5. CMD

Specifies the default command to run when the container starts.

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

6. ENTRYPOINT (advanced)

Defines the main process of the container. Unlike CMD, it cannot be overridden easily.

ENTRYPOINT ["python"] CMD ["app.py"] 

👉 This runs as python app.py.

7. EXPOSE

Documents which ports the container will use.

EXPOSE 5000 

8. ENV

Sets environment variables.

ENV APP_ENV=production 

9. ARG

Sets build-time variables.

ARG VERSION=1.0 

📄 Full Example: Python Flask App

# Step 1: Start from base image FROM python:3.9-slim # Step 2: Set working directory WORKDIR /app # Step 3: Copy requirements and install dependencies COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt # Step 4: Copy the rest of the code COPY . . # Step 5: Expose port EXPOSE 5000 # Step 6: Default command CMD ["python", "app.py"] 

⚡ Build and Run

# Build the image docker build -t myapp:1.0 . # Run the container docker run -p 5000:5000 myapp:1.0 

Now open 👉 http://localhost:5000

📸 Visual Overview

Dockerfile ➝ Image ➝ Container

✅ Best Practices

• Use lightweight base images (e.g., alpine, slim).
• Always use a .dockerignore file to avoid copying unnecessary files.
• Combine commands to reduce layers:

 RUN apt-get update && apt-get install -y curl 

• Pin versions of dependencies for reproducibility.
• Use multi-stage builds to keep images small:

 FROM golang:1.18 as builder WORKDIR /src COPY . . RUN go build -o app FROM alpine:3.16 COPY --from=builder /src/app /app CMD ["/app"] 

🚀 Wrap-up

A Dockerfile is the blueprint of your containerized application.
With a few simple instructions, you can package your code and run it anywhere.

In upcoming posts, we’ll explore multi-stage builds, caching, and security best practices for Dockerfiles.

💡 Question for you:
👉 What’s the most challenging part you faced when writing your first Dockerfile?

Drop your thoughts in the comments 👇