Flask par exemple – Configuration de projet – Real Python

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.

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

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

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

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

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

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()

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

$ python app.py
config.DevelopmentConfig

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

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

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.