Setting Up a Complete Development Environment

Docker Integration

Docker ensures that your application runs the same way everywhere. It's like shipping your entire kitchen along with the meal you cooked—the recipient gets exactly the same experience you intended.

VS Code Docker Extension Setup

The Docker extension for VS Code provides seamless Docker integration:

1. Open the Extensions view (Ctrl+Shift+X)
2. Search for "Docker" and install the Microsoft Docker extension
3. After installation, you'll see a new Docker icon in the Activity Bar

This extension provides:

• Syntax highlighting for Dockerfiles
• IntelliSense for Docker commands
• A visual interface for managing containers, images, and volumes
• Commands for building, running, and stopping containers

Creating a Development Dockerfile

Let's create a development-focused Dockerfile that includes all the tools we need:

# Dockerfile.dev
FROM python:3.10-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
ENV PYTHONPATH=/app

# Set working directory
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    curl \
    git \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Install development tools
RUN pip install --no-cache-dir black flake8 pytest isort mypy pre-commit

# Keep container running
CMD ["bash"]

Explanation: This Dockerfile:

• Starts from a slim Python 3.10 image to keep the size down
• Sets environment variables for better Python behavior in containers
• Installs system-level dependencies needed for many Python packages
• Installs your project's dependencies
• Adds development tools for linting, formatting, and testing
• By default, just starts a bash shell so we can work interactively

Docker Compose for Development

Docker Compose makes it easy to run multi-container applications. Create a docker-compose.yml file:

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.dev
    volumes:
      - .:/app
    ports:
      - "5000:5000"
    command: bash -c "flask run --host=0.0.0.0"
    environment:
      - FLASK_APP=app.py
      - FLASK_ENV=development
      - FLASK_DEBUG=1
    
  db:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=app_dev

volumes:
  postgres_data:

Analogy: Docker Compose is like a restaurant recipe that includes not just how to cook each dish, but also how all the dishes work together to create a complete meal. It orchestrates all your containers to work as a unified system.

VS Code Remote Development with Docker

One of the most powerful features of VS Code is its ability to develop inside a container:

1. Install the "Remote - Containers" extension
2. Create a .devcontainer/devcontainer.json file:

{
    "name": "Python Development",
    "dockerComposeFile": ["../docker-compose.yml"],
    "service": "app",
    "workspaceFolder": "/app",
    "extensions": [
        "ms-python.python",
        "ms-python.vscode-pylance",
        "ms-azuretools.vscode-docker",
        "streetsidesoftware.code-spell-checker",
        "eamodio.gitlens"
    ],
    "settings": {
        "python.linting.enabled": true,
        "python.linting.pylintEnabled": true,
        "python.formatting.provider": "black",
        "editor.formatOnSave": true,
        "python.linting.flake8Enabled": true
    }
}

3. Use the Command Palette to run "Remote-Containers: Reopen in Container"

Real-world benefit: This setup eliminates the "it works on my machine" problem. New team members can be productive immediately—they just clone the repo, open it in VS Code, and all the tools and dependencies are automatically set up inside the container.