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
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
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
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
- Besuchen Sierailway.app, melden Sie sich mit GitHub an
- Neues Projekt → Von GitHub-Repo bereitstellen → flask-blog auswählen
- Railway erkennt automatisch Procfile und identifiziert den Gunicorn-Startbefehl
- Umgebungsvariablen in Variables festlegen.
- Auf Deploy klicken
Konfiguration der Umgebungsvariablen
| Variablenname | Wert | Beschreibung |
|---|---|---|
| SECRET_KEY | Zufällig generierte lange Zeichenkette | Session- und CSRF-Token verschlüsseln |
| DATABASE_URL | Automatisch von Railway injiziert | Produktionsdatenbank (von Railway bereitgestelltes PostgreSQL) |
| FLASK_ENV | production | Bezeichner 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
| Lernrichtung | Für wen es gedacht ist | Empfohlener Startpunkt |
|---|---|---|
| Flask REST API | Erstelle 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 Backend | Möchten Sie Flask für das Backend und Vue3/React für das Frontend verwenden | Flask stellt eine JSON-API bereit, und das Frontend kommuniziert über fetch |
| PostgreSQL | Produktionsreife Datenbank erforderlich | SQLite ersetzen, psycopg2 installieren, DATABASE_URL ändern |
| Docker-Bereitstellung | Containerisierte Bereitstellung | Ein Dockerfile schreiben und mit docker-compose orchestrieren |