Debian Python Web Development Guide

This guide walks through setting up a Python web development environment on Debian, creating a simple web application, and deploying it to production with best practices.

1. Prerequisites

Ensure your Debian system is updated:

sudo apt update && sudo apt upgrade -y

2. Install Python and pip

Debian includes Python 3 by default, but you need to install pip (Python’s package manager) and python3-venv (for virtual environments):

sudo apt install python3 python3-pip python3-venv -y

Verify installations:

python3 --version  # Should show Python 3.x.x  
pip3 --version     # Should show pip x.x.x

3. Set Up a Virtual Environment

Virtual environments isolate project dependencies. Create and activate one in your project directory:

mkdir my_python_web_app && cd my_python_web_app  
python3 -m venv venv  
source venv/bin/activate  # Activates the environment (your shell prompt will change)

To deactivate later, run deactivate.

4. Install a Web Framework

Choose a framework based on your project needs:

Flask: Lightweight, great for small to medium apps (e.g., APIs, microservices).
Django: Full-featured, ideal for large applications (e.g., e-commerce sites, CMS).
FastAPI: Modern, high-performance framework for building APIs with Python type hints.

Install your chosen framework (here are examples for each):

# Flask  
pip install Flask  

# Django  
pip install Django  

# FastAPI + Uvicorn (ASGI server)  
pip install fastapi uvicorn[standard]

5. Create a Simple Web Application

Flask Example: “Hello World” with a Form

Create app.py in your project directory:

from flask import Flask, render_template, request  

app = Flask(__name__)  
messages = []  # In-memory storage for demo  

@app.route("/")  
def index():  
    return render_template("index.html", messages=messages)  

@app.route("/submit", methods=["POST"])  
def submit():  
    name = request.form.get("name")  
    message = request.form.get("message")  
    if name and message:  
        messages.append({"name": name, "message": message})  
    return index()  

if __name__ == "__main__":  
    app.run(debug=True)  # Debug mode for development

Create a templates directory and add index.html (Flask uses Jinja2 for templating):

<!DOCTYPE html>  
<html lang="en">  
<head>  
    <meta charset="UTF-8">  
    <meta name="viewport" content="width=device-width, initial-scale=1.0">  
    <title>Message Board</title>  
    <style>  
        body { font-family: Arial, sans-serif; margin: 40px; }  
        form { margin-bottom: 20px; }  
        input, textarea { display: block; margin: 10px 0; width: 100%; max-width: 500px; }  
    </style>  
</head>  
<body>  
    <h1>Message Board</h1>  
    <form action="/submit" method="post">  
        <input type="text" name="name" placeholder="Your Name" required>  
        <textarea name="message" placeholder="Your Message" required></textarea>  
        <button type="submit">Submit</button>  
    </form>  
    <h2>Messages:</h2>  
    <ul>  
        {% for msg in messages %}  
            <li><strong>{{ msg.name }}</strong>: {{ msg.message }}</li>  
        {% endfor %}  
    </ul>  
</body>  
</html>

Run the app:

python app.py

Visit http://127.0.0.1:5000 in your browser to see the message board.

Django Example: Quick Start

For Django, use the CLI to create a project and app:

django-admin startproject myproject  
cd myproject  
python manage.py startapp myapp

Follow Django’s official tutorial to define models, views, and templates.

6. Deploy to Production

For production, use Gunicorn (WSGI server) and Nginx (reverse proxy).

Install Gunicorn

In your activated virtual environment:

pip install gunicorn

Test Gunicorn with your app (replace app:app with your module and app name):

gunicorn -w 4 -b 0.0.0.0:8000 app:app  # 4 workers, listening on port 8000

Configure Nginx

Install Nginx:

sudo apt install nginx -y

Create a new Nginx config file (e.g., /etc/nginx/sites-available/myapp):

server {  
    listen 80;  
    server_name your_domain_or_ip;  # Replace with your domain/IP  

    location / {  
        proxy_pass http://127.0.0.1:8000;  # Forward requests to Gunicorn  
        proxy_set_header Host $host;  
        proxy_set_header X-Real-IP $remote_addr;  
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;  
        proxy_set_header X-Forwarded-Proto $scheme;  
    }  
}

Enable the config:

sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/  
sudo nginx -t  # Test config syntax  
sudo systemctl restart nginx

Configure Firewall

Allow HTTP (80) and HTTPS (443) traffic:

sudo ufw allow 'Nginx Full'

Optional: Set Up HTTPS with Let’s Encrypt

Install Certbot:

sudo apt install certbot python3-certbot-nginx -y

Obtain a free SSL certificate:

sudo certbot --nginx -d your_domain_or_ip

Follow prompts to complete the setup. Certbot will automatically configure Nginx for HTTPS.

7. Additional Tips

Systemd Service: Use systemd to manage Gunicorn as a background service (recommended for production). Create a file like /etc/systemd/system/myapp.service:

[Unit]  
Description=Gunicorn daemon for myapp  
After=network.target  

[Service]  
User=your_user  
Group=www-data  
WorkingDirectory=/path/to/your/app  
ExecStart=/path/to/your/app/venv/bin/gunicorn -c /path/to/your/app/gunicorn_config.py app:app  

[Install]  
WantedBy=multi-user.target

Start and enable the service:

sudo systemctl start myapp  
sudo systemctl enable myapp

Dependencies: Store project dependencies in requirements.txt (Flask example):

pip freeze > requirements.txt  # Generate file  
pip install -r requirements.txt  # Install from file

Debugging: Disable debug mode (debug=False) in production to avoid exposing sensitive information.

This guide provides a solid foundation for Python web development on Debian. Adapt the steps to your chosen framework and project requirements.

Debian Python Web开发指南