Packaging für die Produktion — Bereitstellung auf Railway

In diesem Kapitel lernst du, wie du das Factory-Muster anwendest, die Produktionsumgebung konfigurierst und den Flask-Blog mit Railway in die Produktion bereitstellst.


Application-Factory-Muster create_app()

Bisher wurde app.py direkt erstelltapp = Flask(__name__), was für die Entwicklung ausreichend ist, aber es gibt mehrere Probleme:

  • Während des Testens kann keine unabhängige App-Instanz erstellt werden
  • Kein Wechsel zwischen verschiedenen Konfigurationen je nach Umgebung möglich (Entwicklung/Test/Produktion)
  • Die Initialisierung von Erweiterungen ist eng mit der App-Instanz gekoppelt

Application-Factory-MusterDies löst diese Probleme: Die Erstellung der App in einer Funktion kapseln.

Beispiel

# Dateipfad: app/__init__.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_migrate import Migrate
from config import Config

db = SQLAlchemy()
login_manager = LoginManager()
migrate = Migrate()

def create_app(config_class=Config):
    """Application-Factory: erstellt eine Flask-Anwendungsinstanz basierend auf der Konfigurationsklasse"""
    app = Flask(__name__)
    app.config.from_object(config_class)

    # Erweiterungen initialisieren (zuerst die App-Instanz erstellen, dann Erweiterungen an die App binden)
    db.init_app(app)
    login_manager.init_app(app)
    migrate.init_app(app, db)

    login_manager.login_view = 'auth.login'
    login_manager.login_message = 'Bitte melden Sie sich zuerst an, bevor Sie zugreifen.'

    # Blueprint registrieren
    from app.blueprints.main import main_bp
    from app.blueprints.posts import posts_bp
    from app.blueprints.auth import auth_bp
    from app.blueprints.user import user_bp
    app.register_blueprint(main_bp)
    app.register_blueprint(posts_bp)
    app.register_blueprint(auth_bp)
    app.register_blueprint(user_bp)

    # user_loader muss definiert werden, nachdem die App existiert
    from app.models import User
    @login_manager.user_loader
    def load_user(user_id):
        return User.query.get(int(user_id))

    return app

Konfigurationsdatei config.py

Beispiel

# Dateipfad: config.py
import os
from dotenv import load_dotenv

# Umgebungsvariablen aus der .env-Datei laden (nur für die Entwicklungsumgebung)
load_dotenv()

class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY', 'dev-secret-key')
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL', 'sqlite:///blog.db')
    SQLALCHEMY_TRACK_MODIFICATIONS = False

class DevelopmentConfig(Config):
    DEBUG = True

class ProductionConfig(Config):
    DEBUG = False

# Konfiguration anhand von Umgebungsvariablen auswählen
config_map = {
    'development': DevelopmentConfig,
    'production': ProductionConfig,
    'default': DevelopmentConfig
}

Neue Einstiegsdatei wsgi.py

Beispiel

# Dateipfad: wsgi.py
from app import create_app

app = create_app()

Nun wird die Startmethode:

(venv) $ flask --app wsgi run --debug      # 开发模式
(venv) $ gunicorn wsgi:app                  # 生产模式(Gunicorn)

Beachten Sie die Importreihenfolge: Blueprint und user_loader müssen innerhalb von create_app() importiert werden (nicht am Anfang der Datei), andernfalls werden zirkuläre Importe ausgelöst (Blueprint referenziert models, models referenziert db, und db ist zu diesem Zeitpunkt noch nicht an die App gebunden).


Generieren Sie requirements.txt und Procfile

(venv) $ pip freeze > requirements.txt

Stellen Sie sicher, dass die Datei die wichtigsten Abhängigkeiten enthält: Flask, Flask-SQLAlchemy, Flask-Migrate, Flask-Login, Flask-WTF, Flask-Admin, gunicorn, python-dotenv.

Im Projektstammverzeichnis erstellenProcfile:

web: gunicorn wsgi:app

Das Projekt zu GitHub pushen

$ git init
$ echo "venv/" > .gitignore
$ echo "__pycache__/" >> .gitignore
$ echo "*.pyc" >> .gitignore
$ echo "instance/" >> .gitignore
$ echo ".env" >> .gitignore
$ git add .
$ git commit -m "初始化 Flask 博客项目"
$ git branch -M main
$ git remote add origin https://github.com/你的用户名/flask-blog.git
$ git push -u origin main

Achten Sie darauf,.envhinzufügen.gitignoreDie .env-Datei enthält sensible Informationen wie SECRET_KEY. Sobald sie in GitHub committet wurde, kann sie nicht vollständig gelöscht werden (die Git-Historie behält sie).


Railway-Bereitstellung

  1. Besuchen Sierailway.app, melden Sie sich mit GitHub an
  2. Neues Projekt → Von GitHub-Repo bereitstellen → flask-blog auswählen
  3. Railway erkennt automatisch Procfile und identifiziert den Gunicorn-Startbefehl
  4. Umgebungsvariablen in Variables festlegen.
  5. Auf Deploy klicken

Konfiguration der Umgebungsvariablen

VariablennameWertBeschreibung
SECRET_KEYZufällig generierte lange ZeichenketteSession- und CSRF-Token verschlüsseln
DATABASE_URLAutomatisch von Railway injiziertProduktionsdatenbank (von Railway bereitgestelltes PostgreSQL)
FLASK_ENVproductionBezeichner der Produktionsumgebung

SECRET_KEY schnell generieren:

$ python -c "import secrets; print(secrets.token_urlsafe(50))"

Nach erfolgreichem Deployment erhalten Sie einen Link wiehttps://flask-blog.up.railway.app。


Nächste Lernrichtung

LernrichtungFür wen es gedacht istEmpfohlener Startpunkt
Flask REST APIErstelle eine API für Frontend-Frameworks (Vue3/React)Verwende jsonify anstelle von render_template, um RESTful APIs zu erstellen
Flask + Vue3/React: Trennung von Frontend und BackendMöchten Sie Flask für das Backend und Vue3/React für das Frontend verwendenFlask stellt eine JSON-API bereit, und das Frontend kommuniziert über fetch
PostgreSQLProduktionsreife Datenbank erforderlichSQLite ersetzen, psycopg2 installieren, DATABASE_URL ändern
Docker-BereitstellungContainerisierte BereitstellungEin Dockerfile schreiben und mit docker-compose orchestrieren
Weitere Erweiterungen