Je souhaitais déployer une application réalisée avec Flask dans un environnement de production. Ce n'était pas facile et j'ai fini par affronter toute la journée. Quand je le faisais avec Rails, il a démarré instantanément avec git push heroku master de heroku create.
C'est pourquoi je laisserai un mémorandum jusqu'à ce que Flask soit lancé à Heroku.
Cliquez ici pour la technologie utilisée pour le déploiement cette fois.
Dans le didacticiel Flask, la base de données est créée avec la commande db.create_all (). Cependant, pour ceux qui sont habitués aux fichiers dits de migration, il est toujours souhaitable de gérer l'état de la table. Dans ce cas, utilisez Flask Migrate.
Tout d'abord, nous ferons la construction initiale de l'application. Flask est assez personnalisable, donc différents développeurs ont des structures de répertoires différentes. Je suis toujours à la recherche de la meilleure pratique, mais au final ça ressemble à ça.
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
Ajoutez des feuilles de style et visualisez les pièces à votre guise. Cette fois, DB fonctionne correctement dans Heroku, et je le ferai jusqu'à ce que "Hello world!" Soit publié, donc seulement le back-end.
manage.py Un fichier pour démarrer et exécuter flask.
manage.py
from main import app
app.run()
main/init.py Générez l'application flask.
main/__init__.py
from flask import Flask
app = Flask(__name__)
import main.views
main/views.py La partie vue qui affiche Hello world!.
main/views.py
from flask import render_template
from main import app, db
@app.route('/')
def home():
return render_template('home/index.html')
Il y a de nombreux articles sur les meilleures pratiques ici, donc j'ai pensé qu'il serait plus facile à comprendre si vous y faites référence. Ici, je vais vous présenter ceux qui peuvent cacher les secrets une fois qu'ils se déplacent.
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 ** doit être défini comme ʻexport FLASK_ENV = development`. Ce que je dis ici, c'est que si le contenu de base de BaseConfig est utilisé en commun, le contenu variable est séparé en fonction de l'environnement (développement / production).
ʻOs.environ.get ('DATABASE_URL') `tirera automatiquement ** DATABASE_UEL ** vers la base de données avec Herkou, alors réglez-le pour la production.
main/instance/application.cfg
instance/application.cfg
SECRET_KEY='XXXXXXXXXXXXXXXXXXX'
Ici, la clé API qui ne peut pas être rendue publique est répertoriée. Assurez-vous également de l'écrire en .gitignore et de ne pas le publier.
Rendez le fichier de configuration préparé disponible dans __init __. Py.
main/__init__.py
#Ajoutez le contenu suivant
from main.config import configure_app
app = Flask(__name__, instance_relative_config=True)
configure_app(app)
Déployez sur Heroku et installez deux bibliothèques pour utiliser PostgreSQL.
$ pip install gunicorm
$ pip install psycopg2
Ajoutez des commandes pour exécuter l'application sur heroku.
web: gunicorn main:app --log-file -
pip freeze est une commande pratique qui répertorie toutes les informations de bibliothèque utilisées dans l'environnement virtuel.
$ pip freeze > requirements.txt
Le réglage de heroku est omis.
$ heroku create flask-app
$ git push heroku master
$ heroku config:set FLASK_APP=main
$ heroku config:set FLASK_ENV=production
À ce stade, si vous faites $ heroku open, vous devriez voir" Hello world! ".
Cette fois, nous allons préparer le modèle ʻUser` comme test.
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
Installez chaque bibliothèque requise pour migrer la base de données.
$ pip install flask_migrate
$ pip install flask_sqlalchemy
Ajoutez la préparation pour charger le modèle d'ensemble à __init __. Py.
main/__init__.py
#J'ajouterai ce qui suit
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
db = SQLAlchemy(app)
migrate = Migrate(app, db)
db.init_app(app)
import main.models
Migrez selon l'ordre de la commande Flask Migrate.
$ flask db init
$ flask db migrate
$ flask db upgrade
Cela générera un fichier migrations et une base de données appelée ʻapp.db`.
Comme auparavant, configurez la bibliothèque nouvellement installée afin qu'elle puisse être utilisée avec Heroku.
$ pip freeze > requirements.txt
Je suis un peu accro à cela, mais pour Heroku, je donne le fichier migrations généré localement au serveur et n'exécute pas db init ou db migrate.
$ heroku run flask db upgrade
Recommended Posts