Ich wollte eine mit Flask erstellte App in einer Produktionsumgebung bereitstellen. Es war nicht einfach und ich stand den ganzen Tag vor der Tür. Als ich es mit Rails gemacht habe, hat es sofort mit "git push heroku master" von "heroku create" gestartet.
Deshalb werde ich ein Memorandum hinterlassen, bis Flask in Heroku veröffentlicht wird.
Klicken Sie hier, um die Technologie anzuzeigen, die dieses Mal für die Bereitstellung verwendet wird.
Im Flask-Tutorial wird die Datenbank mit dem Befehl db.create_all () erstellt. Für diejenigen, die an sogenannte Migrationsdateien gewöhnt sind, ist es jedoch weiterhin wünschenswert, den Status der Tabelle zu verwalten. Verwenden Sie in diesem Fall "Flask Migrate".
Zunächst werden wir die erste Konstruktion der Anwendung durchführen. Flask ist ziemlich anpassbar, so dass verschiedene Entwickler unterschiedliche Verzeichnisstrukturen haben. Ich bin immer noch auf der Suche nach der besten Praxis, aber am Ende sieht es so aus.
app/
├── manage.py
├── main
│ ├── __init__.py
│ ├── views.py
│ ├── config.py
│ ├── models.py
│ ├── app.db
│ ├── static/
│ ├── templates/
│ └── instance
│ └──application.cfg
├── Procfile
├── requirements.txt
├── migrations/
└── venv/
$ cd APP
$ mkdir -p main/{static,templates,instance}
$ cd main
$ touch manage.py requirements.txt Procfile
$ touch main/{__init__,views,models,config}.py
Fügen Sie Stylesheets hinzu und zeigen Sie Teile nach Belieben an. Dieses Mal funktioniert DB in Heroku ordnungsgemäß, und ich werde es tun, bis "Hallo Welt!" Ausgegeben wird, also nur das Backend.
manage.py Eine Datei zum Starten und Ausführen des Kolbens.
manage.py
from main import app
app.run()
main/init.py Kolben-App generieren.
main/__init__.py
from flask import Flask
app = Flask(__name__)
import main.views
main/views.py Der Ansichtsteil, in dem Hello world! Angezeigt wird.
main/views.py
from flask import render_template
from main import app, db
@app.route('/')
def home():
return render_template('home/index.html')
Es gibt hier viele Artikel zu Best Practices, daher dachte ich, es wäre einfacher zu verstehen, wenn Sie sich darauf beziehen. Hier werde ich diejenigen vorstellen, die die geheimen verbergen können, sobald sie sich bewegen.
main/config.py
main/config.py
import os
class BaseConfig(object):
SQLALCHEMY_TRACK_MODIFICATIONS = False
class DevelopmentConfig(BaseConfig):
DEBUG = True
TESTING = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///app.db'
class ProductionConfig(BaseConfig):
DEBUG = True
TESTING = True
SQLALCHEMY_DATABASE_URI=os.environ.get('DATABASE_URL')
config = {
"default": "main.config.BaseConfig",
"development": "main.config.DevelopmentConfig",
"production": "main.config.ProductionConfig",
}
def configure_app(app):
config_name= os.getenv('FLASK_ENV')
app.config.from_object(config[config_name])
app.config.from_pyfile('application.cfg', silent=True)
** FLASK_ENV ** sollte als "export FLASK_ENV = development" festgelegt werden. Was ich hier sage ist, dass während die grundlegenden BaseConfig-Inhalte gemeinsam verwendet werden, die variablen Inhalte nach der Umgebung (Entwicklung / Produktion) getrennt werden.
os.environ.get ('DATABASE_URL') zieht automatisch ** DATABASE_UEL ** mit Herkou in die Datenbank, also stellen Sie dies für die Produktion ein.
main/instance/application.cfg
instance/application.cfg
SECRET_KEY='XXXXXXXXXXXXXXXXXXX'
Hier wird der API-Schlüssel aufgelistet, der nicht veröffentlicht werden kann. Stellen Sie außerdem sicher, dass Sie es in ".gitignore" schreiben und nicht veröffentlichen.
Stellen Sie die vorbereitete Einstellungsdatei in "__init __. Py" zur Verfügung.
main/__init__.py
#Fügen Sie den folgenden Inhalt hinzu
from main.config import configure_app
app = Flask(__name__, instance_relative_config=True)
configure_app(app)
Stellen Sie es in Heroku bereit und installieren Sie zwei Bibliotheken, um "PostgreSQL" zu verwenden.
$ pip install gunicorm
$ pip install psycopg2
Fügen Sie Befehle hinzu, um die App auf Heroku auszuführen.
web: gunicorn main:app --log-file -
pip freeze ist ein praktischer Befehl, der alle in der virtuellen Umgebung verwendeten Bibliotheksinformationen aufzeichnet.
$ pip freeze > requirements.txt
Die Einstellung von Heroku wird weggelassen.
$ heroku create flask-app
$ git push heroku master
$ heroku config:set FLASK_APP=main
$ heroku config:set FLASK_ENV=production
Wenn Sie zu diesem Zeitpunkt "$ heroku open" ausführen, sollten Sie "Hallo Welt!" Sehen.
Bereiten Sie diesmal das Benutzermodell als Test vor.
main/models.py
from main import db
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
email = db.Column(db.String, unique=True)
def __repr__(self):
return '<User %r>' % self.name
Installieren Sie jede Bibliothek, die für die Migration der Datenbank erforderlich ist.
$ pip install flask_migrate
$ pip install flask_sqlalchemy
Fügen Sie die Vorbereitung zum Laden des festgelegten Modells zu "__init __. Py" hinzu.
main/__init__.py
#Ich werde folgendes hinzufügen
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
db = SQLAlchemy(app)
migrate = Migrate(app, db)
db.init_app(app)
import main.models
Migrieren Sie gemäß der Reihenfolge des Befehls Flask Migrate.
$ flask db init
$ flask db migrate
$ flask db upgrade
Dadurch werden eine "Migrations" -Datei und eine Datenbank mit dem Namen "app.db" generiert.
Richten Sie die neu installierte Bibliothek wie zuvor so ein, dass sie mit Heroku verwendet werden kann.
$ pip freeze > requirements.txt
Ich bin ein wenig süchtig danach, aber für Heroku gebe ich die lokal generierte "Migrations" -Datei an den Server und führe "db init" oder "db migrate" nicht aus.
$ heroku run flask db upgrade
Recommended Posts