python pour débutant
Vous avez écrit un script Python dont vous êtes fier et vous souhaitez maintenant le montrer au monde entier. Mais Comment? La plupart des gens ne savent pas quoi faire de votre .py
fichier. Conversion de votre script en un Application Web Python est une excellente solution pour rendre votre code utilisable par un large public.
Dans ce didacticiel, vous apprendrez à passer d'un script Python local à une application Web Flask entièrement déployée que vous pouvez partager avec le monde entier.
En plus de parcourir un exemple de projet, vous trouverez un certain nombre de des exercices tout au long du didacticiel. Ils vous donneront une chance de consolider ce que vous apprenez grâce à une pratique supplémentaire. Vous pouvez également télécharger le code source que vous utiliserez pour créer votre application Web en cliquant sur le lien ci-dessous:
Révisez les bases
Dans cette section, vous aurez une base théorique sur les différents sujets sur lesquels vous travaillerez pendant la partie pratique de ce didacticiel:
- Quels types de distribution de code Python existent
- Pourquoi créer une application Web peut être un bon choix
- Qu'est-ce qu'une application Web
- Comment le contenu est diffusé sur Internet
- Qu'est-ce que l'hébergement Web signifie
- Quels hébergeurs existent et lequel utiliser
La mise à jour de ces sujets peut vous aider à vous sentir plus en confiance lors de l'écriture de code Python pour le Web. Cependant, si vous les connaissez déjà, n'hésitez pas à aller de l'avant, installez le SDK Google Cloud et commencez à créer votre application Web Python.
Distribuez votre code Python
Apporter votre code à vos utilisateurs s'appelle Distribution. Traditionnellement, il existe trois approches différentes que vous pouvez utiliser pour distribuer votre code afin que d'autres puissent travailler avec vos programmes:
- Bibliothèque Python
- Programme autonome
- Application Web Python
Vous examinerez de plus près chacune de ces approches ci-dessous.
Bibliothèque Python
Si vous avez travaillé avec le vaste écosystème de packages de Python, vous avez probablement installé des packages Python avec pépin
. En tant que programmeur, vous souhaiterez peut-être publier votre package Python sur PyPI pour permettre aux autres utilisateurs d'accéder et d'utiliser votre code en l'installant à l'aide de pépin
:
$ python3 -m pip installer
Une fois que vous avez publié avec succès votre code sur PyPI, cette commande installe votre package, y compris ses dépendances, sur l’un des ordinateurs de vos utilisateurs, à condition qu’ils disposent d’une connexion Internet.
Si vous ne souhaitez pas publier votre code en tant que package PyPI, vous pouvez toujours utiliser Python intégré sdist
pour créer une distribution source ou une roue Python pour créer une distribution intégrée à partager avec vos utilisateurs.
En distribuant votre code de cette manière, il reste proche du script original que vous avez écrit et n’ajoute que ce qui est nécessaire aux autres pour l’exécuter. Cependant, l'utilisation de cette approche signifie également que vos utilisateurs devront exécuter votre code avec Python. De nombreuses personnes souhaitant utiliser les fonctionnalités de votre script ne disposeront pas de Python ou ne seront pas familiarisées avec les processus nécessaires pour travailler directement avec votre code.
Une manière plus conviviale de présenter votre code aux utilisateurs potentiels consiste à créer un programme autonome.
Programme autonome
Les programmes informatiques se présentent sous différentes formes et formes, et il existe plusieurs options pour transformer vos scripts Python en programmes autonomes. Ci-dessous, vous découvrirez deux possibilités:
- Emballer votre code
- Construire une interface graphique
Des programmes tels que PyInstaller, py2app, py2exe ou Briefcase peuvent vous aider à empaqueter votre code. Ils transforment les scripts Python en programmes exécutables pouvant être utilisés sur différentes plates-formes sans que vos utilisateurs exécutent explicitement l'interpréteur Python.
Bien que l'empaquetage de votre code puisse résoudre les problèmes de dépendance, votre code ne s'exécute toujours que sur la ligne de commande. La plupart des gens sont habitués à travailler avec des programmes qui fournissent une interface utilisateur graphique (GUI). Vous pouvez rendre votre code Python accessible à plus de personnes en créant une interface graphique pour celui-ci.
Bien qu'un programme de bureau GUI autonome puisse rendre votre code accessible à un public plus large, il présente toujours un obstacle pour les gens à démarrer. Avant d'exécuter votre programme, les utilisateurs potentiels ont quelques étapes à suivre. Ils doivent trouver la bonne version pour leur système d'exploitation, la télécharger et l'installer avec succès. Certains peuvent abandonner avant de faire tout le chemin.
Il est logique que de nombreux développeurs créent à la place des applications Web accessibles rapidement et exécutées sur un navigateur Internet.
Application Web Python
L’avantage des applications Web est qu’elles sont indépendantes de la plate-forme et peuvent être exécutées par toute personne ayant accès à Internet. Leur code est implémenté sur un back-end serveur, où le programme traite les demandes entrantes et répond via un protocole partagé compris par tous les navigateurs.
Python alimente de nombreuses applications Web volumineuses et constitue un choix courant en tant que langage back-end. De nombreuses applications Web pilotées par Python sont conçues dès le départ en tant qu'applications Web et sont créées à l'aide de frameworks Web Python tels que Flask, que vous utiliserez dans ce didacticiel.
Cependant, au lieu de l'approche axée sur le Web décrite ci-dessus, vous allez prendre un angle différent. Après tout, vous n'étiez pas Planification pour créer une application Web. Vous venez de créer un script Python utile et vous souhaitez maintenant le partager avec le monde entier. Pour le rendre accessible à un large éventail d'utilisateurs, vous allez le refactoriser dans une application Web, puis le déployer sur Internet.
Il est temps d’examiner ce qu’est une application Web et en quoi elle est différente des autres contenus sur le Web.
En savoir plus sur les applications Web Python
Historiquement, les sites Web avaient un contenu fixe qui était le même pour chaque utilisateur qui accédait à cette page. Ces pages Web sont appelées statique car leur contenu ne change pas lorsque vous interagissez avec eux. Lors de la diffusion d'une page Web statique, un serveur Web répond à votre demande en renvoyant le contenu de cette page, indépendamment de qui vous êtes ou des autres actions que vous avez entreprises.
Vous pouvez parcourir un exemple de site Web statique à la première URL jamais mise en ligne, ainsi que les pages auxquelles il renvoie:
Ces sites Web statiques ne sont pas considérés comme des applications car leur contenu n’est pas généré dynamiquement par le code. Alors que les sites statiques constituaient auparavant tout Internet, la plupart des sites Web actuels sont vrais des applications Web, qui offre dynamique des pages Web qui peuvent modifier le contenu qu'elles fournissent.
Par exemple, une application de messagerie Web vous permet d'interagir avec elle de plusieurs manières. En fonction de vos actions, il peut afficher différents types d'informations, souvent en restant sur une seule page:
Applications Web pilotées par Python utilisez le code Python pour déterminer les actions à entreprendre et le contenu à afficher. Votre code est exécuté par le serveur Web qui héberge votre site Web, ce qui signifie que vos utilisateurs n'ont rien à installer. Tout ce dont ils ont besoin pour interagir avec votre code est un navigateur et une connexion Internet.
Faire fonctionner Python sur un site Web peut être compliqué, mais il existe un certain nombre de frameworks Web différents qui prennent automatiquement en charge les détails. Comme mentionné ci-dessus, vous allez créer une application Flask de base dans ce didacticiel.
Dans la section à venir, vous aurez une perspective de haut niveau sur les principaux processus qui doivent se produire pour exécuter votre code Python sur un serveur et fournir une réponse à vos utilisateurs.
Examiner le cycle de requête-réponse HTTP
Servir du contenu dynamique sur Internet implique de nombreux éléments différents, et ils doivent tous communiquer entre eux pour fonctionner correctement. Voici un aperçu général de ce qui se passe lorsqu'un utilisateur interagit avec une application Web:
-
Envoi en cours: Tout d'abord, votre utilisateur effectue une demande pour une page Web particulière sur votre application Web. Ils peuvent le faire, par exemple, en tapant une URL dans leur navigateur.
-
Réception: Cette demande est reçue par le serveur Web qui héberge votre site Web.
-
Correspondant à: Votre serveur Web utilise désormais Google App Engine pour consulter le fichier de configuration de votre application. Google App Engine fait correspondre la demande de l'utilisateur à une partie particulière de votre script Python.
-
Fonctionnement: Le code Python approprié est appelé par Google App Engine. Lorsque votre code s'exécute, il écrit une page Web en tant que réponse.
-
Livrer: Google App Engine renvoie cette réponse à votre utilisateur via le serveur Web.
-
Affichage: Enfin, l’utilisateur peut consulter la réponse du serveur Web. Par exemple, la page Web résultante peut être affichée dans un navigateur.
Il s'agit d'un processus général de diffusion du contenu sur Internet. Le langage de programmation utilisé sur le serveur, ainsi que les technologies utilisées pour établir cette connexion, peuvent différer. Cependant, le concept utilisé pour communiquer via HTTP demandes et réponses reste le même et s'appelle le Cycle requête-réponse HTTP.
Remarque: Flask gérera la majeure partie de cette complexité à votre place, mais cela peut vous aider à garder une compréhension vague de ce processus à l'esprit.
Pour permettre à Flask de gérer les requêtes côté serveur, vous devez trouver un endroit où votre code Python peut vivre en ligne. Le stockage de votre code en ligne pour exécuter une application Web s'appelle hébergement Web, et il existe un certain nombre de fournisseurs offrant à la fois un hébergement Web payant et gratuit.
Choisissez un fournisseur d'hébergement: Google App Engine
Lors du choix d'un fournisseur d'hébergement Web, vous devez confirmer qu'il prend en charge l'exécution du code Python. Beaucoup d'entre eux coûtent de l'argent, mais ce tutoriel restera avec une option gratuite, professionnelle et hautement évolutive, mais néanmoins raisonnable à configurer: Google App Engine.
Remarque: Google App Engine applique des quotas quotidiens pour chaque application. Si votre application Web dépasse ces quotas, Google commencera à vous facturer. Si vous êtes un nouveau client Google Cloud, vous pouvez bénéficier d'un avoir promotionnel gratuit lors de votre inscription.
Il existe un certain nombre d'autres options gratuites, telles que PythonAnywhere, Repl.it ou Heroku, que vous pourrez explorer plus tard. L'utilisation de Google App Engine vous donnera un bon départ pour apprendre à déployer du code Python sur le Web, car il établit un équilibre entre l'abstraction de la complexité et la personnalisation de la configuration.
Google App Engine fait partie de Google Cloud Platform (GCP), qui est géré par Google et représente l'un des principaux fournisseurs de cloud, avec Microsoft Azure et Amazon Web Services (AWS).
Pour commencer avec GCP, téléchargez et installez le SDK Google Cloud pour votre système d'exploitation. Pour obtenir des conseils supplémentaires au-delà de ce que vous trouverez dans ce didacticiel, vous pouvez consulter la documentation de Google App Engine.
Remarque: Vous travaillerez avec l'environnement standard Python 3. L'environnement standard de Google App Engine prend en charge les environnements d'exécution Python 3 et propose un niveau gratuit.
L'installation du SDK Google Cloud comprend également un programme de ligne de commande appelé gcloud
, que vous utiliserez ultérieurement pour déployer votre application Web. Une fois l'installation terminée, vous pouvez vérifier que tout a fonctionné en tapant la commande suivante dans votre console:
Vous devriez recevoir une sortie de texte dans votre terminal qui ressemble à celle ci-dessous:
app-engine-python 1.9.91
bq 2.0.62
émulateur cloud-datastore 2.1.0
noyau 2020.11.13
gsutil 4.55
Vos numéros de version seront probablement différents, mais tant que le gcloud
programme a été trouvé sur votre ordinateur, votre installation a réussi.
Avec cette présentation de haut niveau des concepts à l'esprit et le SDK Google Cloud installé, vous êtes prêt à configurer un projet Python que vous déploierez plus tard sur Internet.
Créer une application Web Python de base
Google App Engine vous oblige à utiliser un framework Web pour créer votre application Web dans un environnement Python 3. Puisque vous essayez d'utiliser une configuration minimale pour obtenir votre code Python local sur Internet, un microframework tel que Flask est un bon choix. Une implémentation minimale de Flask est si petite que vous ne remarquerez peut-être même pas que vous utilisez un framework Web.
Remarque: Si vous avez déjà travaillé avec Google App Engine dans un environnement Python 2.7, vous remarquerez que le processus a considérablement changé.
Deux changements notables sont que webapp2 a été retiré et que vous ne pouvez plus spécifier d'URL pour le contenu dynamique dans le app.yaml
fichier. La raison de ces deux changements est que Google App Engine vous oblige désormais à utiliser un framework Web Python.
L’application que vous allez créer dépendra de plusieurs fichiers différents. La première chose à faire est donc de créer un dossier de projet contenant tous ces fichiers.
Configurez votre projet
Créez un dossier de projet et donnez-lui un nom descriptif de votre projet. Pour ce projet pratique, appelez le dossier bonjour-app
. Vous aurez besoin de trois fichiers dans ce dossier:
main.py
contient votre code Python enveloppé dans une implémentation minimale du framework Web Flask.requirements.txt
répertorie toutes les dépendances dont votre code a besoin pour fonctionner correctement.app.yaml
aide Google App Engine à décider des paramètres à utiliser sur son serveur.
Bien que trois fichiers puissent sembler beaucoup, vous verrez que ce projet utilise moins de dix lignes de code dans les trois fichiers. Cela représente la configuration minimale que vous devez fournir à Google App Engine pour tout projet Python que vous pouvez lancer. Le reste sera votre propre code Python. Vous pouvez télécharger le code source complet que vous utiliserez dans ce didacticiel en cliquant sur le lien ci-dessous:
Ensuite, vous examinerez le contenu de chacun des fichiers en commençant par le plus complexe, main.py
.
Créer main.py
main.py
est le fichier que Flask utilise pour diffuser votre contenu. En haut du fichier, vous importez le Ballon
classe sur la ligne 1, puis vous créez une instance d'une application Flask sur la ligne 3:
1de ballon importer Ballon
2
3app = Ballon(__Nom__)
4
5@app.route("/")
6def indice():
sept revenir "Félicitations, c'est une application Web!"
Après avoir créé le flacon app
, vous écrivez un décorateur Python sur la ligne 5 appelé @ app.route
que Flask utilise pour connecter les points de terminaison d'URL avec le code contenu dans les fonctions. L'argument pour @ app.route
définit le composant du chemin de l'URL, qui est le chemin racine ("/"
) dans ce cas.
Le code des lignes 6 et 7 constitue indice()
, qui est enveloppé par le décorateur. Cette fonction définit ce qui doit être exécuté si le point de terminaison URL défini est demandé par un utilisateur. Sa valeur de retour détermine ce qu'un utilisateur verra lorsqu'il chargera la page.
Remarque: La dénomination de indice()
n'est qu'une convention. Cela concerne la façon dont la page principale d'un site Web est souvent appelée index.html
. Vous pouvez choisir un nom de fonction différent si vous le souhaitez.
En d'autres termes, si un utilisateur tape l'URL de base de votre application Web dans son navigateur, Flask s'exécute indice()
et l'utilisateur voit le texte renvoyé. Dans ce cas, ce texte n'est qu'une phrase: Félicitations, c'est une application web!
Vous pouvez rendre un contenu plus complexe et vous pouvez également créer plusieurs fonctions afin que les utilisateurs puissent visiter différents points de terminaison d'URL dans votre application pour recevoir différentes réponses. Cependant, pour cette mise en œuvre initiale, il est bien de s'en tenir à ce message de réussite court et encourageant.
Créer requirements.txt
Le prochain fichier à regarder est requirements.txt
. Étant donné que Flask est la seule dépendance de ce projet, c'est tout ce que vous devez spécifier:
Si votre application comporte d'autres dépendances, vous devrez les ajouter à votre requirements.txt
fichier ainsi.
Google App Engine utilisera requirements.txt
pour installer les dépendances Python nécessaires à votre projet lors de sa configuration sur le serveur. Ceci est similaire à ce que vous feriez après avoir créé et activé un nouvel environnement virtuel localement.
Créer app.yaml
Le troisième fichier, app.yaml
, aide Google App Engine à configurer le bon environnement de serveur pour votre code. Ce fichier ne nécessite qu'une seule ligne, qui définit le runtime Python:
La ligne ci-dessus précise que le bon moteur d'exécution pour votre code Python est Python 3.8. Cela suffit à Google App Engine pour effectuer la configuration nécessaire sur ses serveurs.
Vous pouvez utiliser Google App Engine app.yaml
fichier pour une configuration supplémentaire, telle que l'ajout de variables d'environnement à votre application. Vous pouvez également l'utiliser pour définir le chemin d'accès au contenu statique de votre application, comme des images, des fichiers CSS ou JavaScript. Ce didacticiel n'aborde pas ces paramètres supplémentaires, mais vous pouvez consulter la documentation de Google App Engine sur le app.yaml
Fichier de configuration si vous souhaitez ajouter une telle fonctionnalité.
Ces neuf lignes de code complètent la configuration nécessaire pour cette application. Votre projet est maintenant prêt pour le déploiement.
Cependant, il est recommandé de tester votre code avant de le mettre en production afin de détecter les erreurs potentielles. Ensuite, vous vérifierez si tout fonctionne comme prévu localement avant de déployer votre code sur Internet.
Tester localement
Flask est livré avec un serveur Web de développement. Vous pouvez utiliser ce serveur de développement pour vérifier que votre code fonctionne comme prévu. Pour pouvoir exécuter le serveur de développement Flask localement, vous devez effectuer deux étapes. Google App Engine effectuera les mêmes étapes sur ses serveurs une fois que vous aurez déployé votre code:
- Configurez un environnement virtuel.
- Installez le
ballon
paquet.
Pour configurer un environnement virtuel Python 3, accédez au dossier de votre projet sur votre terminal et tapez la commande suivante:
Cela créera un nouvel environnement virtuel nommé venv
en utilisant la version de Python 3 que vous avez installée sur votre système. Ensuite, vous devez activer l'environnement virtuel en recherchant le script d'activation:
$ la source venv / bin / activer
Après avoir exécuté cette commande, votre invite changera pour indiquer que vous travaillez maintenant à partir de l’environnement virtuel. Une fois que vous avez correctement configuré et activé votre environnement virtuel, vous êtes prêt à installer Flask:
$ python3 -m pip install -r requirements.txt
Cette commande récupère tous les packages répertoriés dans requirements.txt
de PyPI et les installe dans votre environnement virtuel. Dans ce cas, le seul package installé sera Flask.
Attendez la fin de l'installation, puis ouvrez main.py
et ajoutez les deux lignes de code suivantes au bas du fichier:
si __Nom__ == "__principale__":
app.courir(hôte="127.0.0.1", Port=8080, déboguer=Vrai)
Ces deux lignes indiquent à Python de démarrer le serveur de développement de Flask lorsque le script est exécuté à partir de la ligne de commande. Il ne sera utilisé que lorsque vous exécuterez le script localement. Lorsque vous déployez le code sur Google App Engine, un processus de serveur Web professionnel, tel que Gunicorn, servira l'application à la place. Vous n’avez pas besoin de changer quoi que ce soit pour que cela se produise.
Vous pouvez maintenant démarrer le serveur de développement de Flask et interagir avec votre application Python dans votre navigateur. Pour ce faire, vous devez exécuter le script Python qui démarre l'application Flask en tapant la commande suivante:
Flask démarre le serveur de développement et votre terminal affichera une sortie similaire au texte ci-dessous:
* Application Flask "principale" (chargement paresseux)
* Environnement: production
AVERTISSEMENT: il s'agit d'un serveur de développement.
Ne l'utilisez pas dans un déploiement de production.
Utilisez plutôt un serveur WSGI de production.
* Mode de débogage: activé
* En cours d'exécution sur http://127.0.0.1:8080/ (Appuyez sur CTRL + C pour quitter)
* Redémarrage avec stat
* Le débogueur est actif!
* Code PIN du débogueur: 315-059-987
Cette sortie vous indique trois informations importantes:
-
ATTENTION
: Il s'agit du serveur de développement de Flask, ce qui signifie que vous ne souhaitez pas l'utiliser pour diffuser votre code en production. Google App Engine s'en chargera à votre place. -
Exécution sur http://127.0.0.1:8080/
: Il s'agit de l'URL où vous pouvez trouver votre application. Il s'agit de l'URL de votre hôte local, ce qui signifie que l'application s'exécute sur votre propre ordinateur. Accédez à cette URL dans votre navigateur pour voir votre code en direct. -
Appuyez sur CTRL + C pour quitter
: La même ligne vous indique également que vous pouvez quitter le serveur de développement en appuyant sur Ctrl+C sur votre clavier.
Suivez les instructions et ouvrez un onglet de navigateur sur http://127.0.0.1:8080/
. Vous devriez voir une page affichant le texte renvoyé par votre fonction: Félicitations, c'est une application web!
Remarque: L'URL 127.0.0.1
s'appelle aussi le localhost, ce qui signifie qu'il pointe vers votre propre ordinateur. Le nombre 8080
qui suit après le colon (:
) s'appelle le numéro de port. Le port peut être considéré comme un canal particulier, similaire à la diffusion d'une chaîne de télévision ou de radio.
Vous avez défini ces valeurs dans app.run ()
dans ton main.py
fichier. Exécution de l'application sur le port 8080
signifie que vous pouvez vous connecter à ce numéro de port et recevoir des communications du serveur de développement. Port 8080
est couramment utilisé pour les tests locaux, mais vous pouvez également utiliser un numéro différent.
Vous pouvez utiliser le serveur de développement de Flask pour inspecter toutes les modifications que vous apportez au code de votre application Python. Le serveur écoute les modifications que vous apportez au code et se recharge automatiquement pour les afficher. Si votre application ne s'affiche pas comme prévu sur le serveur de développement, elle ne fonctionnera pas non plus en production. Assurez-vous donc qu'il a l'air bien avant de le déployer.
Gardez également à l'esprit que même s'il fonctionne bien localement, il peut ne pas fonctionner de la même manière une fois déployé. En effet, d'autres facteurs interviennent lorsque vous déployez votre code sur Google App Engine. Cependant, pour une application de base telle que celle que vous créez dans ce didacticiel, vous pouvez être sûr qu'elle fonctionnera en production si elle fonctionne bien localement.
Changer la valeur de retour de indice()
et confirmez que vous pouvez voir le changement reflété dans votre navigateur. Jouez avec. Que se passe-t-il lorsque vous modifiez la valeur de retour de indice()
au code HTML, tel que "
Bonjour
", au lieu d'utiliser une chaîne de texte brut?
Après avoir vérifié votre configuration et la fonctionnalité du code sur votre serveur de développement local, vous êtes prêt à le déployer sur Google App Engine.
Déployez votre application Web Python
Il est enfin temps de mettre votre application en ligne. Mais d'abord, votre code a besoin d'un endroit pour vivre sur les serveurs de Google, et vous devez vous assurer qu'il y parvient en toute sécurité. Dans cette section du didacticiel, vous travaillerez sur la réalisation des configurations de déploiement nécessaires à la fois dans le cloud et localement.
Configurer sur Google App Engine
Lisez le processus de configuration ci-dessous étape par étape. Vous pouvez comparer ce que vous voyez dans votre navigateur avec les captures d'écran. Le nom du projet utilisé dans les exemples de captures d'écran est bonjour-app
.
Commencez par vous connecter à Google Cloud Platform. Accédez à la vue du tableau de bord, où vous verrez une barre d'outils en haut de la fenêtre. Sélectionnez le bouton fléché orienté vers le bas vers le côté gauche de la barre d'outils. Cela fera apparaître un modal contenant une liste de vos projets Google:
Le modal affiche une liste de vos projets. La liste peut être vide si vous n’avez pas encore créé de projet. En haut à droite de ce modal, recherchez le NOUVEAU PROJET bouton et cliquez dessus:
En cliquant NOUVEAU PROJET vous redirigera vers une nouvelle page où vous pourrez choisir un nom pour votre projet. Ce nom apparaîtra dans l'URL de votre application, qui ressemblera à http://your-application-name.nw.r.appspot.com
. Utilisation bonjour-app
comme nom de ce projet pour rester cohérent avec le didacticiel:
Vous pouvez voir votre ID de projet sous le Nom du projet champ de saisie. L'ID de projet se compose du nom que vous avez entré et d'un numéro ajouté par Google App Engine. Dans le cas de ce tutoriel, vous pouvez voir que l'ID du projet est bonjour-app-295110
. Copiez votre ID de projet personnel car vous en aurez besoin plus tard pour le déploiement.
Remarque: Comme l'ID de projet doit être unique, votre numéro sera différent de celui indiqué dans ce didacticiel.
Vous pouvez maintenant cliquer CRÉER et attendez que le projet soit configuré du côté de Google App Engine. Une fois cela fait, une notification apparaîtra pour vous informer qu'un nouveau projet a été créé. Il vous donne également la possibilité de le sélectionner. Allez-y et faites-le en cliquant sur CHOISIR LE PROJET:
En cliquant CHOISIR LE PROJET vous redirigera vers la page principale de votre nouveau projet Google Cloud Platform. Cela ressemble à ceci:
À partir de là, vous souhaitez basculer vers le tableau de bord de Google App Engine. Vous pouvez le faire en cliquant sur le menu hamburger en haut à gauche, en faisant défiler vers le bas pour sélectionner App Engine dans la première liste, puis en sélectionnant Tableau de bord en haut de la liste contextuelle suivante:
Cela vous redirigera enfin vers la vue du tableau de bord Google App Engine de votre nouveau projet. Puisque le projet est vide jusqu'à présent, la page ressemblera à ceci:
Lorsque vous voyez cette page, cela signifie que vous avez terminé la configuration d'un nouveau projet sur Google App Engine. Vous êtes maintenant prêt à retourner au terminal sur votre ordinateur et à suivre les étapes locales nécessaires pour déployer votre application dans ce projet.
Configurer localement pour le déploiement
Après avoir installé avec succès le SDK Google Cloud, vous avez accès au gcloud
interface de ligne de commande. Ce programme est livré avec des instructions utiles qui vous guident tout au long du déploiement de votre application Web. Commencez par saisir la commande qui vous a été suggérée lors de la création d'un nouveau projet sur le site Web de Google App Engine:
Comme vous pouvez le voir dans le coin inférieur droit de la page, Google App Engine suggère une commande de terminal pour déployer votre code dans ce projet. Ouvrez votre terminal, accédez au dossier de votre projet, puis exécutez la commande suggérée:
Lorsque vous exécutez cette commande sans aucune configuration précédente, le programme répondra avec un message d'erreur:
ERREUR: (gcloud.app.deploy)
Vous n'avez actuellement pas de compte actif sélectionné.
Veuillez exécuter:
$ gcloud auth login
pour obtenir de nouvelles informations d'identification.
Si vous vous êtes déjà connecté avec un autre compte:
Compte de jeu de configuration $ gcloud
pour sélectionner un compte déjà authentifié à utiliser.
Vous recevez ce message d'erreur, car vous ne pouvez déployer aucun code sur votre compte Google App Engine à moins que vous ne prouviez à Google que vous êtes le propriétaire de ce compte. Vous devrez vous authentifier avec votre compte Google App Engine à partir de votre ordinateur local.
La gcloud
L'application de ligne de commande vous a déjà fourni la commande que vous devez exécuter. Tapez-le dans votre terminal:
Cela lancera le processus d'authentification en générant une URL de validation et en l'ouvrant dans votre navigateur. Terminez le processus en sélectionnant votre compte Google dans la fenêtre du navigateur et en accordant au SDK Google Cloud les privilèges nécessaires. Après cela, vous pouvez retourner à votre terminal, où vous verrez des informations sur le processus d'authentification:
Votre navigateur a été ouvert pour visiter:
https://accounts.google.com/o/oauth2/auth?client_id=
Vous êtes maintenant connecté en tant que[[[[].
Votre projet actuel est [None]. Vous pouvez modifier ce paramètre en exécutant:
Projet de jeu de configuration $ gcloud PROJECT_ID
Si vous voyez ce message, cela signifie que l'authentification a réussi. Vous pouvez également voir que le programme de ligne de commande vous offre à nouveau des informations utiles sur votre prochaine étape.
Il vous indique qu'il n'y a actuellement aucun ensemble de projets et que vous pouvez en définir un en exécutant gcloud config set project PROJECT_ID
. Vous aurez maintenant besoin de l'ID de projet que vous avez noté précédemment.
Remarque: Vous pouvez toujours obtenir votre ID de projet en vous rendant sur le site Web de Google App Engine et en cliquant sur la flèche orientée vers le bas qui affiche le modal affichant tous vos projets Google. L'ID de projet est répertorié à droite du nom de votre projet et se compose généralement du nom du projet et d'un numéro à six chiffres.
Assurez-vous de remplacer bonjour-app-295110
avec votre propre ID de projet lors de l'exécution de la commande suggérée:
$ configuration de gcloud ensemble projet hello-app-295110
Votre terminal imprimera un court message indiquant que la propriété du projet a été mise à jour. Après avoir correctement authentifié et défini le projet par défaut sur votre ID de projet, vous avez terminé les étapes de configuration nécessaires.
Exécutez le processus de déploiement
Vous êtes maintenant prêt à essayer la commande de déploiement initial une deuxième fois:
La gcloud
app récupère vos informations d'authentification ainsi que les informations d'ID de projet de la configuration par défaut que vous venez de configurer et vous permet de continuer. Ensuite, vous devez sélectionner une région où votre application doit être hébergée:
Vous créez une application pour le projet [hello-app-295110].
AVERTISSEMENT: la création d'une application App Engine pour un projet est
irréversible et la région ne peut pas être modifiée.
Pour plus d'informations sur les régions, consultez
.
Veuillez choisir la région dans laquelle vous souhaitez votre application App Engine
situé:
[1] asia-east2
[2] asie-nord-est1
[3] asie-nord-est2
[4] asie-nord-est3
[5] asie-sud1
[6] asie-sud-est2
[7] australie-sud-est1
[8] europe-ouest
[9] europe-west2
[10] europe-west3
[11] europe-west6
[12] northamerica-nord-est1
[13] sudhamerica-east1
[14] us-central
[15] us-east1
[16] us-east4
[17] us-west2
[18] us-west3
[19] us-west4
[20] Annuler
Veuillez saisir votre choix numérique:
Entrez l'un des numéros répertoriés sur le côté gauche et appuyez sur Entrer.
Remarque: Peu importe la région que vous choisissez pour cette application. Cependant, si vous créez une application volumineuse qui génère un trafic important, vous souhaiterez la déployer sur un serveur physiquement proche de l'endroit où se trouvent la plupart de vos utilisateurs.
Une fois que vous avez entré un nombre, la CLI continuera le processus de configuration. Avant de déployer votre code sur Google App Engine, il vous montrera un aperçu de ce à quoi ressemblera le déploiement et vous demandera une confirmation finale:
Créer une application App Engine dans un projet [hello-app-295110]
et région [europe-west]....terminé.
Services à déployer:
descripteur: [/Users/realpython/Documents/helloapp/app.yaml]
la source: [/Users/realpython/Documents/helloapp]
projet cible: [hello-app-295110]
service cible: [default]
version cible: [20201109t112408]
Cible URL: [https://hello-app-295110.ew.r.appspot.com]
Voulez-vous continuer (O / n)?
Après avoir confirmé la configuration en tapant Oui, votre déploiement sera enfin en cours. Votre terminal vous montrera plus d'informations et une petite animation de chargement pendant que Google App Engine configure votre projet sur ses serveurs:
Début du déploiement du service [default]...
Création du fichier .gcloudignore. Voir `gcloud topic gcloudignore` pour plus de détails.
╔═════════════════════════════════════════════════ ═══════════╗
╠═ Téléchargement de 3 fichiers sur Google Cloud Storage ═╣
╚═════════════════════════════════════════════════ ═══════════╝
Téléchargement de fichier terminé.
Service de mise à jour [default]... ⠼
Comme il s'agit du premier déploiement de votre application Web, cela peut prendre quelques minutes. Une fois le déploiement terminé, vous verrez une autre sortie utile dans la console. Il ressemblera à celui ci-dessous:
Service déployé [default] à [https://hello-app-295110.ew.r.appspot.com]
Vous pouvez diffuser les journaux depuis la ligne de commande en exécutant:
$ gcloud app logs tail -s default
Pour afficher votre application dans le navigateur Web, exécutez:
Parcourir l'application $ gcloud
Vous pouvez maintenant accéder à l'URL mentionnée dans votre navigateur ou saisir la commande suggérée parcourir l'application gcloud
pour accéder à votre application Web en direct. Vous devriez voir la même courte réponse textuelle que vous avez vue précédemment lors de l'exécution de l'application sur votre hôte local: Félicitations, c'est une application web!
Notez que ce site Web a une URL que vous pouvez partager avec d'autres personnes, et ils pourront y accéder. Vous avez maintenant une application Web Python en direct!
Changer la valeur de retour de indice()
à nouveau et déployez votre application une deuxième fois en utilisant le déploiement d'application gcloud
commander. Confirmez que vous pouvez voir le changement reflété sur le site Web en direct dans votre navigateur.
Avec cela, vous avez terminé les étapes nécessaires pour obtenir votre code Python local sur le Web. However, the only functionality that you’ve put online so far is printing out a string of text.
Time to step it up! Following the same process, you’ll bring more interesting functionality online in the next section. You’ll refactor the code of a local temperature converter script into a Flask web app.
Convert a Script Into a Web Application
Since this tutorial is about creating and deploying Python web applications from code you already have, the Python code for the temperature converter script is provided for you here:
def fahrenheit_from(celsius):
"""Convert Celsius to Fahrenheit degrees."""
try:
fahrenheit = float(celsius) * 9 / 5 + 32
fahrenheit = round(fahrenheit, 3) # Round to three decimal places
revenir str(fahrenheit)
except ValueError:
revenir "invalid input"
if __name__ == "__main__":
celsius = input("Celsius: ")
impression("Fahrenheit:", fahrenheit_from(celsius))
This is a short script that allows a user to convert a Celsius temperature to the equivalent Fahrenheit temperature.
Save the code as a Python script and give it a spin. Make sure that it works as expected and that you understand what it does. Feel free to improve the code.
With this working script in hand, you’ll now need to change the code to integrate it into your Flask app. There are two main points to consider for doing that:
- Execution: How will the web app know when to run the code?
- User input: How will the web app collect user input?
You already learned how to tell Flask to execute a specific piece of code by adding the code to a function that you assign a route to. Start by tackling this task first.
Add Code as a Function
Flask separates different tasks into different functions that are each assigned a route through the @app.route
decorator. When the user visits the specified route via its URL, the code inside the corresponding function gets executed.
Start by adding fahrenheit_from()
to your main.py
file and wrapping it with the @app.route
decorator:
from flask import Flask
app = Flask(__name__)
@app.route("/")
def index():
revenir "Congratulations, it's a web app!"
@app.route("/")
def fahrenheit_from(celsius):
"""Convert Celsius to Fahrenheit degrees."""
try:
fahrenheit = float(celsius) * 9 / 5 + 32
fahrenheit = round(fahrenheit, 3) # Round to three decimal places
revenir str(fahrenheit)
except ValueError:
revenir "invalid input"
if __name__ == "__main__":
app.run(host="127.0.0.1", port=8080, debug=True)
So far, you’ve only copied the code of your Python script into a function in your Flask app and added the @app.route
decorator.
However, there’s already a problem with this setup. What happens when you run the code in your development server? Give it a try.
Currently, both of your functions are triggered by the same route ("/"
). When a user visits that route, Flask picks the first function that matches it and executes that code. In your case, this means that fahrenheit_from()
never gets executed because index()
matches the same route and gets called first.
Your second function will need its own unique route to be accessible. Additionally, you still need to allow your users to provide input to your function.
Pass Values to Your Code
You can solve both of these tasks by telling Flask to treat any remaining part of the URL following the base URL as a value and pass it on to your function. This requires only a small change to the parameter of the @app.route
decorator before fahrenheit_from()
:
@app.route("/" )
def fahrenheit_from(celsius):
# -- snip --
The angle bracket syntax (<>
) tells Flask to capture any text following the base URL ("/"
) and pass it on to the function the decorator wraps as the variable celsius
. Note that fahrenheit_from()
requires celsius
as an input.
Note: Make sure that the URL path component you’re capturing has the same name as the parameter you’re passing to your function. Otherwise, Flask will be confused and will let you know about it by presenting you with an error message.
Head back to your web browser and try out the new functionality using Flask’s development server. You’re now able to access both of your functions through your web app using different URL endpoints:
- Index (
/
): If you go to the base URL, then you’ll see the short encouraging message from before. - Celsius (
/42
): If you add a number after the forward slash, then you’ll see the converted temperature appear in your browser.
Play around with it some more and try entering different inputs. Even the error handling from your script is still functional and displays a message when a user enters a nonnumeric input. Your web app handles the same functionality as your Python script did locally, only now you can deploy it to the Internet.
Refactor Your Code
Flask is a mature web framework that allows you to hand over a lot of tasks to its internals. For example, you can let Flask take care of type checking the input to your function and returning an error message if it doesn’t fit. All this can be done with a concise syntax inside of the parameter to @app.route
. Add the following to your path capturer:
@app.route("/" )
Adding int:
before the variable name tells Flask to check whether the input it receives from the URL can be converted to an integer. If it can, then the content is passed on to fahrenheit_from()
. If it can’t, then Flask displays a Not Found
error page.
Note: La Not Found
error means that Flask attempted to match the path component it snipped off from the URL with any of the functions it knows about.
However, the only patterns it currently knows about are the empty base path (/
) and the base path followed by a number, such as /42
. Since a text like /hello
doesn’t match any of these patterns, it tells you that the requested URL was not found on the server.
After applying Flask’s type check, you can now safely remove the try
… except
block in fahrenheit_from()
. Only integers will ever be passed on to the function by Flask:
from flask import Flask
app = Flask(__name__)
@app.route("/")
def index():
revenir "Congratulations, it's a web app!"
@app.route("/" )
def fahrenheit_from(celsius):
"""Convert Celsius to Fahrenheit degrees."""
fahrenheit = float(celsius) * 9 / 5 + 32
fahrenheit = round(fahrenheit, 3) # Round to three decimal places
revenir str(fahrenheit)
if __name__ == "__main__":
app.run(host="127.0.0.1", port=8080, debug=True)
With this, you’ve completed converting your temperature conversion script into a web app. Confirm that everything works as expected locally, then deploy your app again to Google App Engine.
Refactor index()
. It should return text that explains how to use the temperature converter web app. Keep in mind that you can use HTML tags in the return string. The HTML will render properly on your landing page.
After successfully deploying your temperature conversion web app to the Internet, you now have a link that you can share with other people and allow them to convert Celsius temperatures to Fahrenheit temperatures.
However, the interface still looks quite basic and the web app functions more like an API than a front-end web app. Many users might not know how to interact with your Python web application in its current state. This shows you the limitations of using pure Python for web development.
If you want to create more intuitive interfaces, then you’ll need to start using at least a little bit of HTML.
In the next section, you’ll keep iterating over your code and use HTML to create an input box that allows users to enter a number directly on the page rather than through the URL.
Improve the User Interface of Your Web Application
In this section, you’ll learn how to add an HTML
Conclusion
You covered a lot of ground in this tutorial! You started with a local Python script and transformed it into a user-friendly, fully deployed Flask application that’s now hosted on Google App Engine.
While working through this tutorial, you learned:
- Comment web applications provide data over the Internet
- How to refactor your Python script so you can host it online
- How to create a basic Flask application
- How to manually escape user input
- How to deploy your code to Google App Engine
You can now take your local Python scripts and make them available online for the whole world to use. If you’d like to download the complete code for the application you built in this tutorial, then you can click the link below:
If you want to learn more about web development with Python, then you’re now well equipped to experiment with Python web frameworks such as Flask and Django. Keep up the good work!
[ad_2]