-
- Joined
- Mar 22, 2026
-
- Messages
- 283
-
- Reaction score
- 0
-
- Points
- 0
Containerization has revolutionized how we develop, deploy, and manage applications. For developers, Docker offers an unparalleled way to create isolated, reproducible, and portable development environments. This guide will walk you through setting up a typical Dockerized development environment using Docker Compose, focusing on a common web application stack.
Why Docker for Development?
Traditional development setups often suffer from "it works on my machine" syndrome due to differing OS versions, library dependencies, or conflicting software. Docker solves this by:
Key Docker Concepts for Dev Environments
Before diving into an example, let's touch upon the core components:
1. Dockerfile: A text file that contains instructions for building a Docker image. This image serves as the blueprint for your application's container.
2. Docker Image: A lightweight, standalone, executable package that includes everything needed to run a piece of software, including the code, a runtime, system tools, libraries, and settings.
3. Docker Container: A runnable instance of a Docker image. You can create, start, stop, move, or delete a container.
4. Docker Compose: A tool for defining and running multi-container Docker applications. With a single YAML file (
5. Volumes: Used to persist data generated by Docker containers. Without volumes, data inside a container is lost when the container is removed. Volumes allow you to share data between the host and the container, which is crucial for development (e.g., live code reloading).
6. Networks: Docker provides networking capabilities to allow containers to communicate with each other. Docker Compose automatically sets up a default network for your services.
Example: Dockerizing a Python Flask App with PostgreSQL
Let's set up a simple environment with a Python Flask web application and a PostgreSQL database.
Project Structure:
1.
This is a minimal Flask app that connects to a PostgreSQL database.
2.
List your Python dependencies.
3.
This defines how to build your Flask application's image.
4.
This file brings everything together.
*
*
*
*
*
*
*
*
*
Running Your Dockerized Environment
1. Navigate to your project root: Open your terminal and
2. Build and run the services:
*
*
*
3. Verify:
* Check running containers:
* Access your application: Open
4. View logs:
* For the web service:
5. Stop the environment:
This stops and removes the containers and networks created by
Conclusion
Dockerizing your development environment significantly improves consistency, reduces setup time, and eliminates "works on my machine" issues. By leveraging
Why Docker for Development?
Traditional development setups often suffer from "it works on my machine" syndrome due to differing OS versions, library dependencies, or conflicting software. Docker solves this by:
- Isolation: Each application component (database, backend, frontend) runs in its own isolated container.
- Reproducibility: Everyone on the team uses the exact same environment, from OS-level dependencies down to specific library versions.
- Portability: Your environment can run anywhere Docker is installed – local machine, CI/CD, staging, production.
- Simplified Onboarding: New team members can spin up the entire development stack with a single command.
Key Docker Concepts for Dev Environments
Before diving into an example, let's touch upon the core components:
1. Dockerfile: A text file that contains instructions for building a Docker image. This image serves as the blueprint for your application's container.
2. Docker Image: A lightweight, standalone, executable package that includes everything needed to run a piece of software, including the code, a runtime, system tools, libraries, and settings.
3. Docker Container: A runnable instance of a Docker image. You can create, start, stop, move, or delete a container.
4. Docker Compose: A tool for defining and running multi-container Docker applications. With a single YAML file (
docker-compose.yml), you configure your application's services, networks, and volumes, then manage them with a single command.5. Volumes: Used to persist data generated by Docker containers. Without volumes, data inside a container is lost when the container is removed. Volumes allow you to share data between the host and the container, which is crucial for development (e.g., live code reloading).
6. Networks: Docker provides networking capabilities to allow containers to communicate with each other. Docker Compose automatically sets up a default network for your services.
Example: Dockerizing a Python Flask App with PostgreSQL
Let's set up a simple environment with a Python Flask web application and a PostgreSQL database.
Project Structure:
Code:
my_flask_app/
├── app.py
├── requirements.txt
├── Dockerfile
└── docker-compose.yml1.
app.py (Flask Application)This is a minimal Flask app that connects to a PostgreSQL database.
Python:
# app.py
import os
from flask import Flask
import psycopg2
app = Flask(__name__)
@app.route('/')
def hello():
try:
conn = psycopg2.connect(
host=os.environ.get("DB_HOST", "db"),
database=os.environ.get("DB_NAME", "mydatabase"),
user=os.environ.get("DB_USER", "user"),
password=os.environ.get("DB_PASSWORD", "password")
)
cur = conn.cursor()
cur.execute("SELECT 1")
cur.close()
conn.close()
return "Hello from Flask! Connected to PostgreSQL successfully!"
except Exception as e:
return f"Hello from Flask! Failed to connect to PostgreSQL: {e}"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)2.
requirements.txtList your Python dependencies.
Code:
Flask==2.3.2
psycopg2-binary==2.9.93.
Dockerfile (for the Flask App)This defines how to build your Flask application's image.
Code:
# Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]FROM python:3.9-slim-buster: Starts with a lightweight Python base image.WORKDIR /app: Sets the working directory inside the container.COPY requirements.txt .: Copies the requirements file.RUN pip install ...: Installs Python dependencies.COPY . .: Copies all remaining files from the current directory (your Flask app) into the container's/appdirectory.EXPOSE 5000: Informs Docker that the container listens on port 5000 at runtime (doesn't publish it).CMD ["python", "app.py"]: Defines the default command to run when the container starts.
4.
docker-compose.yml (Orchestrating Services)This file brings everything together.
YAML:
# docker-compose.yml
version: '3.8'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- .:/app # Mounts your local project directory into the container
environment:
DB_HOST: db
DB_NAME: mydatabase
DB_USER: user
DB_PASSWORD: password
depends_on:
- db
db:
image: postgres:13
environment:
POSTGRES_DB: mydatabase
POSTGRES_USER: user
POSTGRES_PASSWORD: password
volumes:
- db_data:/var/lib/postgresql/data # Persist database data
volumes:
db_data:version: '3.8': Specifies the Docker Compose file format version.services:: Defines the different components of your application.
web service:*
build: .: Tells Docker Compose to build an image from the Dockerfile in the current directory.*
ports: - "5000:5000": Maps port 5000 on your host machine to port 5000 in the web container. This allows you to access your Flask app via http://localhost:5000.*
volumes: - .:/app: This is crucial for development. It mounts your local my_flask_app directory into the /app directory inside the container. Any changes you make to app.py on your host will instantly reflect inside the container (if your app supports hot-reloading).*
environment:: Sets environment variables inside the container for connecting to the database.*
depends_on: - db: Ensures the db service starts before the web service.*
db service:*
image: postgres:13: Uses the official PostgreSQL 13 Docker image.*
environment:: Sets environment variables required by the PostgreSQL image to configure the database.*
volumes: - db_data:/var/lib/postgresql/data: Creates a named volume db_data to persist PostgreSQL's data. Even if you stop and remove the db container, your data will remain.volumes:: Defines the named volumes used by your services.
Running Your Dockerized Environment
1. Navigate to your project root: Open your terminal and
cd into the my_flask_app directory.2. Build and run the services:
Code:
bash
docker-compose up -d --buildup: Starts the services defined in docker-compose.yml.*
-d: Runs containers in detached mode (in the background).*
--build: Builds (or re-builds) images before starting containers. This is important if you've changed your Dockerfile.3. Verify:
* Check running containers:
docker-compose ps* Access your application: Open
http://localhost:5000 in your browser. You should see "Hello from Flask! Connected to PostgreSQL successfully!".4. View logs:
* For the web service:
docker-compose logs web5. Stop the environment:
Code:
bash
docker-compose downup. The db_data volume (and thus your database data) will persist by default. To remove volumes as well:
Code:
bash
docker-compose down --volumesConclusion
Dockerizing your development environment significantly improves consistency, reduces setup time, and eliminates "works on my machine" issues. By leveraging
Dockerfile for individual service images and docker-compose.yml for orchestrating your entire stack, you create a robust, portable, and efficient development workflow. Start integrating Docker into your projects today and experience the difference!