Flask par exemple – Configuration de projet – Real Python

By | avril 19, 2021

Cours Python en ligne

Bienvenue! Aujourd'hui, nous allons commencer à créer une application Flask qui calcule les paires mot-fréquence en fonction du texte d'une URL donnée. Ceci est un didacticiel complet.

Mises à jour:

  • 08/02/2020: Mise à jour vers Python version 3.8.1 et utilisation python -m venv à la place de pyvenv.
  • 22/03/2016: mise à niveau vers Python version 3.5.1 et ajout de la version autoenv 1.0.0.
  • 22/02/2015: Ajout du support Python 3.

  1. Première partie: mettre en place un environnement de développement local, puis déployer à la fois un environnement de préparation et de production sur Heroku. (actuel)
  2. Deuxième partie: configurer une base de données PostgreSQL avec SQLAlchemy et Alembic pour gérer les migrations.
  3. Troisième partie: ajoutez la logique back-end pour gratter puis traiter le nombre de mots à partir d'une page Web à l'aide des bibliothèques requests, BeautifulSoup et Natural Language Toolkit (NLTK).
  4. Quatrième partie: implémenter une file d'attente de tâches Redis pour gérer le traitement de texte.
  5. Cinquième partie: Configurez Angular sur le front-end pour interroger en permanence le back-end pour voir si le traitement de la demande est terminé.
  6. Sixième partie: Push vers le serveur intermédiaire sur Heroku – configuration de Redis et explication de la manière d'exécuter deux processus (Web et worker) sur un seul Dyno.
  7. Septième partie: Mettez à jour le front-end pour le rendre plus convivial.
  8. Huitième partie: créez une directive angulaire personnalisée pour afficher un graphique de distribution de fréquence à l'aide de JavaScript et de D3.

Besoin du code? Récupérez-le dans le repo.

Configuration du projet

Nous allons commencer par un application de base «Hello World» sur Heroku avec des environnements de préparation (ou de pré-production) et de production.

Pour la configuration initiale, vous devez avoir une certaine familiarité avec les outils suivants:

Tout d'abord, mettons en place un répertoire de travail:

$ mkdir flacon par exemple && CD flacon par exemple

Initialisez un nouveau dépôt git dans votre répertoire de travail:

Configurez un environnement virtuel à utiliser pour notre application:

$ python3 -m venv env
$ la source env / bin / activer

Tu devrais maintenant te voir (env) à gauche de l'invite dans le terminal, indiquant que vous travaillez maintenant dans un environnement virtuel.

Pour quitter votre environnement virtuel, exécutez simplement désactiver, puis exécutez source env / bin / activer lorsque vous êtes prêt à travailler à nouveau sur votre projet.

Ensuite, nous allons configurer la structure de base de notre application. Ajoutez les fichiers suivants à votre dossier «flask-by-example»:

$ touchez app.py .gitignore README.md requirements.txt

Cela vous donnera la structure suivante:

├── .gitignore
├── app.py
├── LISEZMOI.md
└── requirements.txt

Assurez-vous de mettre à jour le .gitignore fichier du repo.

Installez ensuite Flask:

$ python -m pip installer Ballon==1.1.1

Ajoutez les bibliothèques installées à notre requirements.txt déposer:

$ python -m pip freeze> requirements.txt

S'ouvrir app.py dans votre éditeur préféré et ajoutez le code suivant:

de ballon importer Ballon
appli = Ballon(__Nom__)


@app.route('/')
def Bonjour():
    revenir "Bonjour le monde!"

si __Nom__ == '__principale__':
    appli.Cours()

Exécutez l'application:

Et vous devriez voir votre application de base «Hello world» en action sur http: // localhost: 5000 /. Tuez le serveur lorsque vous avez terminé.

Ensuite, nous allons configurer nos environnements Heroku pour notre application de production et de mise en scène.

Configuration Heroku

Si vous ne l’avez pas déjà fait, créez un compte Heroku, téléchargez et installez Heroku Toolbelt, puis dans votre terminal, exécutez connexion heroku pour vous connecter à Heroku.

Une fois terminé, créez un Procfile dans le répertoire racine de votre projet:

Ajoutez la ligne suivante à votre fichier nouvellement créé

Assurez-vous d'ajouter gunicorn à votre requirements.txt déposer

$ python -m pip installer gunicorn==20.0.4
$ python -m pip freeze> requirements.txt

Nous devons également spécifier une version Python afin que Heroku utilise le bon Runtime Python pour exécuter notre application avec. Créez simplement un fichier appelé runtime.txt avec le code suivant:

Validez vos modifications dans git (et éventuellement poussez vers Github), puis créez deux nouvelles applications Heroku.

Un pour la production:

$ heroku créer wordcount-pro

Et un pour la mise en scène:

$ heroku créer wordcount-stage

Ces noms sont maintenant pris, vous devrez donc rendre le nom de votre application Heroku unique.

Ajoutez vos nouvelles applications à vos télécommandes git. Assurez-vous de nommer une télécommande pro (pour «production») et l'autre étape (pour «mise en scène»):

$ git remote add pro git@heroku.com: VOTRE_APP_NAME.git
$ git remote add stage git@heroku.com: VOTRE_APP_NAME.git

Maintenant, nous pouvons pousser nos deux applications en direct sur Heroku.

  • Pour la mise en scène: maître de scène git push
  • Pour la production: git push pro master

Une fois que les deux ont été poussés, ouvrez les URL dans votre navigateur Web et si tout s'est bien passé, vous devriez voir votre application en direct dans les deux environnements.

Workflow de préparation / production

Modifions notre application et passons uniquement à la mise en scène:

de ballon importer Ballon
appli = Ballon(__Nom__)


@app.route('/')
def Bonjour():
    revenir "Bonjour le monde!"


@app.route('/')
def bonjour_nom(Nom):
    revenir "Bonjour ! ".format(Nom)

si __Nom__ == '__principale__':
    appli.Cours()

Exécutez votre application localement pour vous assurer que tout fonctionne – python app.py

Testez-le en ajoutant un nom après l'URL, c'est-à-dire http: // localhost: 5000 / mike.

Essayons maintenant nos modifications sur la mise en scène avant de les mettre en production. Assurez-vous que vos modifications sont validées dans git, puis transférez votre travail vers l'environnement de test – maître de scène git push.

Désormais, si vous accédez à votre environnement de préparation, vous pourrez utiliser la nouvelle URL, c'est-à-dire "/ mike" et obtenir "Hello NAME" en fonction de ce que vous avez mis dans l'URL en tant que résultat dans le navigateur. Cependant, si vous essayez la même chose sur le site de production, vous obtiendrez une erreur. Nous pouvons donc créer des éléments et les tester dans l'environnement de préparation, puis lorsque nous sommes satisfaits des changements, nous pouvons les mettre en production.

Poussons notre site en production maintenant que nous en sommes satisfaits – git push pro master

Maintenant, nous avons la même fonctionnalité en direct sur notre site de production.

Ce flux de travail de préparation / production nous permet d'apporter des modifications, de montrer des choses aux clients, d'expérimenter, etc. – le tout dans un serveur en bac à sable sans provoquer de modifications sur le site de production en direct que les utilisateurs utilisent.

Paramètres de configuration

La dernière chose que nous allons faire est de configurer différents environnements de configuration pour notre application. Il y a souvent des choses qui vont être différentes entre vos configurations locales, de préparation et de production. Vous voudrez vous connecter à différentes bases de données, avoir différentes clés AWS, etc. Configurons un fichier de configuration pour gérer les différents environnements.

Ajouter un config.py fichier à la racine de votre projet:

Avec notre fichier de configuration, nous allons emprunter un peu la configuration de la configuration de Django. Nous aurons une classe de configuration de base dont les autres classes de configuration hériteront. Ensuite, nous importerons la classe de configuration appropriée si nécessaire.

Ajoutez ce qui suit à votre nouvellement créé config.py déposer:

importer os
basedir = os.chemin.abspath(os.chemin.dirname(__déposer__))


classer Config(objet):
    DÉBOGUER = Faux
    ESSAI = Faux
    CSRF_ENABLED = Vrai
    CLEF SECRÈTE = `` cela-a vraiment besoin d'être changé ''


classer ProductionConfig(Config):
    DÉBOGUER = Faux


classer StagingConfig(Config):
    DÉVELOPPEMENT = Vrai
    DÉBOGUER = Vrai


classer DevelopmentConfig(Config):
    DÉVELOPPEMENT = Vrai
    DÉBOGUER = Vrai


classer TestingConfig(Config):
    ESSAI = Vrai

Nous avons importé os puis définissez le basedir variable comme chemin relatif depuis n'importe quel endroit, nous l'appelons vers ce fichier. Nous avons ensuite mis en place une base Config () classe avec une configuration de base dont nos autres classes de configuration héritent. Nous pourrons maintenant importer la classe de configuration appropriée en fonction de l'environnement actuel. Ainsi, nous pouvons utiliser des variables d'environnement pour choisir les paramètres que nous allons utiliser en fonction de l'environnement – par exemple, local, intermédiaire, production.

Paramètres locaux

Pour configurer notre application avec des variables d'environnement, nous allons utiliser autoenv. Ce programme nous permet de définir des commandes qui s'exécuteront à chaque fois que nous entrons dans notre répertoire. Pour l'utiliser, nous devrons l'installer globalement. Tout d'abord, quittez votre environnement virtuel dans le terminal, installez autoenv, puis ajoutez un .env déposer:

$ désactiver
$ installation de pip autoenv==1.0.0
$ touchez .env

Ensuite, dans votre .env fichier, ajoutez ce qui suit:

source env / bin / activer
export APP_SETTINGS = "config.DevelopmentConfig"

Exécutez ce qui suit pour mettre à jour puis actualiser votre .bashrc:

$ écho "source` qui activate.sh` " >> ~ / .bashrc
$ la source ~ / .bashrc

Désormais, si vous montez dans un répertoire, puis que vous y accédez de nouveau, l'environnement virtuel démarre automatiquement et le APP_SETTINGS variable est déclarée.

Paramètres Heroku

De même, nous allons définir des variables d'environnement sur Heroku.

Pour la mise en scène, exécutez la commande suivante:

$ configuration heroku: définir APP_SETTINGS=config.StagingConfig --remote stage

Pour la production:

$ configuration heroku: définir APP_SETTINGS=config.ProductionConfig --remote pro

Pour nous assurer que nous utilisons le bon changement d'environnement app.py:

importer os
de ballon importer Ballon


appli = Ballon(__Nom__)
appli.config.from_object(os.environ[[[["APP_SETTINGS"])


@app.route('/')
def Bonjour():
    revenir "Bonjour le monde!"


@app.route('/')
def bonjour_nom(Nom):
    revenir "Bonjour ! ".format(Nom)

si __Nom__ == '__principale__':
    appli.Cours()

Nous avons importé os et utilisé le os.environ méthode pour importer le APP_SETTINGS variables, en fonction de notre environnement. Nous avons ensuite configuré la configuration dans notre application avec le app.config.from_object méthode.

Validez et transmettez vos modifications à la fois à la préparation et à la production (et à Github si vous l'avez configuré).

Vous voulez tester les variables d'environnement pour vous assurer qu'il détecte le bon environnement (contrôle de cohérence!)? Ajouter une instruction d'impression à app.py:

imprimer(os.environ[[[["APP_SETTINGS"])

Désormais, lorsque vous exécutez l'application, elle affichera les paramètres de configuration qu'elle importe:

Local:

$ python app.py
config.DevelopmentConfig

Engagez-vous et repoussez à nouveau la mise en scène et la production. Maintenant, testons-le…

Mise en scène:

$ heroku exécutez python app.py --app wordcount-stage
Exécution de python app.py sur wordcount-stage ... up, run.7699
config.StagingConfig

Production:

$ heroku exécutez python app.py --app wordcount-pro
Exécution de python app.py sur wordcount-pro ... up, run.8934
config.ProductionConfig

Assurez-vous de supprimer imprimer (os.environ['APP_SETTINGS']) une fois terminé, engagez-vous et repoussez vos différents environnements.

Conclusion

Une fois la configuration terminée, nous allons commencer à développer la fonctionnalité de comptage de mots de cette application. En cours de route, nous ajouterons une file d'attente de tâches pour configurer le traitement en arrière-plan pour la partie du nombre de mots, et approfondirons notre configuration Heroku en configurant la configuration et les migrations de notre base de données (partie 2) que nous utiliserons pour stocker nos résultats de comptage de mots. Meilleur!

Récupérez le code du dépôt.


Il s'agit d'une collaboration entre Cam Linke, co-fondateur de Startup Edmonton, et les gens de Real Python.

[ad_2]