Comment savoir si votre application s'exécute correctement avec un minimum d'erreurs après sa création et son déploiement ? Le moyen le plus rapide et le plus simple de surveiller votre application Web Flask opérationnelle consiste à intégrer l'un des nombreux outils de surveillance hébergés fantastiques disponibles.
Dans cet article, nous ajouterons rapidement la surveillance Rollbar pour détecter les erreurs et visualiser que notre application fonctionne correctement. Il existe également de nombreux autres excellents outils de surveillance hébergés, que vous pouvez consulter sur la page de surveillance.
Nos outils
Nous pouvons utiliser Python 2 ou 3 pour construire ce tutoriel, mais Python 3 est fortement recommandé pour toutes les nouvelles applications. J'ai utilisé Python 3.6.2 pour exécuter mon code. Nous utiliserons également les dépendances d'application suivantes tout au long de l'article :
- Frame Web Flask, version 0.12.2
- bibliothèque d'instrumentation de surveillance de la barre de pyrolyse, version 0.13.12
- clignotant pour la prise en charge de la signalisation dans les applications Flask afin que le pyrollbar puisse signaler toutes les erreurs
- Un compte Rollbar gratuit où nous enverrons les données d'erreur et les afficherons lorsqu'elles seront capturées
- pip et thevirtualenv virtual environmentlibrary, qui sont fournis avec Python 3, pour installer et isoler les bibliothèques Flask et Rollbar des autres projets Python sur lesquels vous travaillez
Si vous avez besoin d'aide pour configurer votre environnement de développement avant d'exécuter ce code, consultez ce guide pour configurer Python 3 et Flask sur Ubuntu 16.04 LTS.
Tout le code de cet article de blog est disponible en open source sous licence MIT sur GitHub sous le répertoire monitor-flask-apps du référentiel blog-code-examples. Utilisez et abusez du code source comme vous le souhaitez pour vos propres applications.
Installation des dépendances
Accédez au répertoire dans lequel vous conservez vos virtualenvs Python.Créez un nouvel environnement virtuel pour ce projet à l'aide de la commande suivante.
python3 -m venv monitorflask
Activez l'environnement virtuel.
source monitorflask/bin/activate
L'invite de commande changera après l'activation de virtualenv :
N'oubliez pas que vous devez activer le virtualenv dans chaque nouvelle fenêtre de terminal où vous souhaitez utiliser le virtualenv pour exécuter le projet.
Flask, Rollbar et Blinker peuvent maintenant être installés dans le virtualenv maintenant activé.
pip install flask==0.12.2 rollbar==0.13.12 blinker==1.4
Nos dépendances requises doivent être installées dans notre environnement virtuel après une courte période d'installation. Recherchez une sortie comme celle-ci pour confirmer que tout a fonctionné.
Installing collected packages: blinker, itsdangerous, click, MarkupSafe, Jinja2, Werkzeug, Flask, idna, urllib3, chardet, certifi, requests, six, rollbar Running setup.py install for blinker ... done Running setup.py install for itsdangerous ... done Running setup.py install for MarkupSafe ... done Running setup.py install for rollbar ... done Successfully installed Flask-0.12.2 Jinja2-2.9.6 MarkupSafe-1.0 Werkzeug-0.12.2 blinker-1.4 certifi-2017.4.17 chardet-3.0.4 click-6.7 idna-2.5 itsdangerous-0.24 requests-2.18.1 rollbar-0.13.12 six-1.10.0 urllib3-1.21.1
Maintenant que nos dépendances Python sont installées dans notre environnement virtuel, nous pouvons créer la version initiale de notre application.
Construire notre application Flask
Créez un dossier pour votre projet nommé monitor-flask-apps . Allez dans le dossier puis créez un fichier nommé app.py avec le code suivant.
import re
from flask import Flask, render_template, Response
from werkzeug.exceptions import NotFound
app = Flask(__name__)
MIN_PAGE_NAME_LENGTH = 2
@app.route("/<string:page>/")
def show_page(page):
try:
valid_length = len(page) >= MIN_PAGE_NAME_LENGTH
valid_name = re.match('^[a-z]+$', page.lower()) is not None
if valid_length and valid_name:
return render_template("{}.html".format(page))
else:
msg = "Sorry, couldn't find page with name {}".format(page)
raise NotFound(msg)
except:
return Response("404 Not Found")
if __name__ == "__main__":
app.run(debug=True)
Le code d'application ci-dessus contient des importations Flask standard afin que nous puissions créer une application Web Flask et rendre les fichiers de modèle. Nous avons une seule fonction nommée show_page pour desservir une seule route Flask. show_page vérifie si le chemin de l'URL ne contient que des caractères alpha minuscules pour un nom de page potentiel. Si le nom de la page se trouve dans le templates dossier, la page est rendue, sinon une exception est levée indiquant que la page est introuvable. Nous devons créer au moins un fichier de modèle si notre fonction doit renvoyer une réponse sans erreur.
Enregistrer app.py et créez un nouveau sous-répertoire nommé templates sous le répertoire de votre projet. Créez un nouveau fichier nommé battlegrounds.html et placez-y le balisage de modèle Jinja2 suivant.
<!DOCTYPE html>
<html>
<head>
<title>You found the Battlegrounds GIF!</title>
</head>
<body>
<h1>PUBG so good.</h1>
<img src="https://media.giphy.com/media/3ohzdLMlhId2rJuLUQ/giphy.gif">
</body>
</html>
Le modèle Jinja2 ci-dessus est un code HTML de base sans aucune balise de modèle intégrée. Le modèle crée une page très simple avec une description d'en-tête de "PUBG so good" et un GIF de cet excellent jeu vidéo.
Il est temps d'exécuter et de tester notre code. Passez dans le répertoire de base de votre projet où app.py fichier est localisé. Exécutez app.py en utilisant le python commande comme suit (assurez-vous que votre virtualenv est toujours activé dans le terminal où vous exécutez cette commande) :
python app.py
Le serveur de développement Flask devrait démarrer et afficher quelques lignes de sortie.
Que se passe-t-il lorsque nous accédons à l'application exécutée sur le port 5000 de l'hôte local ?
Page de statut HTTP 404 introuvable, ce à quoi nous nous attendions car nous n'avons défini qu'un seul itinéraire et il n'existe pas sur le chemin de base.
Nous avons créé un modèle nommé battlegrounds.html qui devrait être accessible lorsque nous allons sur localhost :5000/battlegrounds/.
L'application a trouvé avec succès le battlegrounds.html modèle mais c'est le seul disponible. Et si nous essayions localhost:5000/fullstackpython/?
Erreur HTTP 500. Ce n'est pas bon.
Les erreurs 404 et 500 sont évidentes pour nous en ce moment car nous testons l'application localement. Cependant, que se passe-t-il lorsque l'application est déployée et qu'un utilisateur reçoit l'erreur dans son propre navigateur Web ? Ils abandonneront généralement par frustration et vous ne saurez jamais ce qui s'est passé, à moins que vous n'ajoutiez un suivi des erreurs et une surveillance des applications.
Nous allons maintenant modifier notre code pour ajouter Rollbar pour détecter et signaler les erreurs qui se produisent pour nos utilisateurs.
Gestion des erreurs
Rendez-vous sur la page d'accueil de Rollbar afin que nous puissions ajouter leurs outils de surveillance hébergés à notre application Flask souvent erronée.
Cliquez sur le bouton "S'inscrire" dans le coin supérieur droit. Entrez votre adresse e-mail, un nom d'utilisateur et le mot de passe que vous souhaitez sur la page d'inscription.
Après la page d'inscription, vous verrez le flux d'intégration où vous pourrez entrer un nom de projet et sélectionner un langage de programmation. Pour le nom du projet, entrez "Battlegrounds" et sélectionnez que vous surveillez une application Python.
Appuyez sur le bouton "Continuer" en bas pour avancer. L'écran suivant nous montre quelques instructions rapides pour ajouter la surveillance à notre application Flask.
Modifions notre application Flask pour tester si nous pouvons nous connecter correctement au service de Rollbar. Modifier app.py pour inclure les lignes en surbrillance suivantes.
import os
import re
import rollbar
from flask import Flask, render_template, Response
from werkzeug.exceptions import NotFound
app = Flask(__name__)
MIN_PAGE_NAME_LENGTH = 2
@app.before_first_request
def add_monitoring():
rollbar.init(os.environ.get('ROLLBAR_SECRET'))
rollbar.report_message('Rollbar is configured correctly')
@app.route("/<string:page>/")
def show_page(page):
try:
valid_length = len(page) >= MIN_PAGE_NAME_LENGTH
valid_name = re.match('^[a-z]+$', page.lower()) is not None
if valid_length and valid_name:
return render_template("{}.html".format(page))
else:
msg = "Sorry, couldn't find page with name {}".format(page)
raise NotFound(msg)
except:
return Response("404 Not Found")
if __name__ == "__main__":
app.run(debug=True)
Nous avons ajouté quelques nouvelles importations, os et rollbar . os nous permet de saisir les valeurs des variables d'environnement, telles que notre clé secrète Rollbar. rollbar est la bibliothèque que nous avons installée plus tôt. Les deux lignes sous l'instanciation de l'application Flask permettent d'initialiser Rollbar à l'aide du jeton secret Rollbar et d'envoyer un message au service indiquant qu'il a démarré correctement.
Le ROLLBAR_SECRET le jeton doit être défini dans une variable d'environnement. Enregistrez et quittez le app.py . Exécutez export ROLLBAR_SECRET='token here' sur la ligne de commande où votre virtualenv est activé. Ce jeton se trouve sur l'écran d'accueil du Rollbar.
Je stocke généralement toutes mes variables d'environnement dans un fichier commetemplate.env et l'invoque depuis le terminal en utilisant le . ./template.env commande. Assurez-vous d'éviter de valider vos jetons secrets dans un référentiel de contrôle de code source, en particulier si le référentiel est public !
Après avoir exporté votre ROLLBAR_SECRET key en tant que variable d'environnement, nous pouvons tester que Rollbar fonctionne lorsque nous exécutons notre application. Exécutez-le maintenant en utilisant python :
python app.py
De retour dans votre navigateur Web, appuyez sur le bouton "Terminé ! Aller au tableau de bord". Ne vous inquiétez pas du code de la section "Signaler une erreur", nous pouvons y revenir dans un instant.
Si l'événement n'a pas encore été signalé, nous verrons un écran d'attente comme celui-ci :
Une fois Flask démarré, le premier événement sera renseigné sur le tableau de bord.
D'accord, notre premier événement de test a été rempli, mais nous voulons vraiment voir toutes les erreurs de notre application, pas un événement de test.
Test de la gestion des erreurs
Comment s'assurer que de vraies erreurs sont signalées plutôt qu'un simple événement le plus simple ? Nous avons juste besoin d'ajouter quelques lignes de code supplémentaires à notre application.
import os
import re
import rollbar
import rollbar.contrib.flask
from flask import Flask, render_template, Response
from flask import got_request_exception
from werkzeug.exceptions import NotFound
app = Flask(__name__)
MIN_PAGE_NAME_LENGTH = 2
@app.before_first_request
def add_monitoring():
rollbar.init(os.environ.get('ROLLBAR_SECRET'))
## delete the next line if you dont want this event anymore
rollbar.report_message('Rollbar is configured correctly')
got_request_exception.connect(rollbar.contrib.flask.report_exception, app)
@app.route("/<string:page>/")
def show_page(page):
try:
valid_length = len(page) >= MIN_PAGE_NAME_LENGTH
valid_name = re.match('^[a-z]+$', page.lower()) is not None
if valid_length and valid_name:
return render_template("{}.html".format(page))
else:
msg = "Sorry, couldn't find page with name {}".format(page)
raise NotFound(msg)
except:
rollbar.report_exc_info()
return Response("404 Not Found")
if __name__ == "__main__":
app.run(debug=True)
Le code surligné ci-dessus modifie l'application afin qu'elle signale toutes les Flaskerrors ainsi que nos problèmes HTTP 404 introuvables qui se produisent dans le show_page fonction.
Assurez-vous que votre serveur de développement Flask est en cours d'exécution et essayez d'accéder à localhost:5000/b/. Vous recevrez une exception HTTP404 et elle sera signalée à Rollbar. Allez ensuite sur localhost:5000/fullstackpython/ et une erreur HTTP 500 se produira.
Vous devriez voir une agrégation d'erreurs lorsque vous testez ces erreurs :
Woohoo, nous avons enfin notre application Flask qui signale toutes les erreurs qui se produisent pour n'importe quel utilisateur au service de surveillance hébergé Rollbar !
Quelle est la prochaine ?
Nous venons d'apprendre à détecter et à gérer les erreurs avec Rollbar en tant que plate-forme de surveillance hébergée dans une simple application Flask. Ensuite, vous voudrez ajouter la surveillance à vos applications Web plus complexes. Vous pouvez également consulter certaines des fonctionnalités les plus avancées de Rollbar telles que :
- suivi et débogage des problèmes de déploiement
- tri et affichage des erreurs par utilisateur
- configuration de règles personnalisées pour regrouper les erreurs
Il y a beaucoup plus à apprendre sur le développement et les déploiements Web, alors continuez à apprendre en lisant Flask et d'autres frameworks Web tels que Django, Pyramid et Sanic. Vous pouvez également en savoir plus sur l'intégration de Rollbar avec les applications Python via leur documentation Python.
Des questions? Faites-le moi savoir via un ticket de problème GitHub sur le référentiel Full Stack Python, sur Twitter@fullstackpythonou @mattmakai.
Vous voyez quelque chose qui ne va pas dans cet article de blog ? La source de cette page sur GitHuband soumet une demande d'extraction avec un correctif.
