Déployez votre script en tant qu'application Flask – Real Python

By | février 1, 2021

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:

  1. Bibliothèque Python
  2. Programme autonome
  3. 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:

  1. Emballer votre code
  2. 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:

Capture d'écran de l'une des premières pages Web statiques, affichant l'historique du projet tel qu'envisagé au CERN
L'histoire du WWW

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:

Une page d'application Web de messagerie Web comme exemple de page Web dynamique
Une application Webmail d'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:

  1. 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.

  2. Réception: Cette demande est reçue par le serveur Web qui héberge votre site Web.

  3. 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.

  4. 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.

  5. Livrer: Google App Engine renvoie cette réponse à votre utilisateur via le serveur Web.

  6. 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.

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.

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.

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.

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:

  1. main.py contient votre code Python enveloppé dans une implémentation minimale du framework Web Flask.
  2. requirements.txt répertorie toutes les dépendances dont votre code a besoin pour fonctionner correctement.
  3. 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.

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:

  1. Configurez un environnement virtuel.
  2. 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:

  1. 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.

  2. 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.

  3. 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!

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:

Liste déroulante pour afficher tous 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:

Bouton pour créer un nouveau projet sur Google App Engine

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:

Champ de saisie pour attribuer un nom de projet à un projet GAE

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.

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:

Capture d'écran montrant l'option de sélectionner un projet

En cliquant CHOISIR LE PROJET vous redirigera vers la page principale de votre nouveau projet Google Cloud Platform. Cela ressemble à ceci:

Vue du tableau de bord de Google Cloud Platform

À 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:

Instructions visuelles sur la façon de passer du tableau de bord Cloud Platform au tableau de bord App Engine

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:

Nouvelle page de projet sur GAE après avoir créé un nouveau projet avec succès

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:

Nouvelle page de projet avec la commande CLI gcloud suggérée en surbrillance

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.

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.

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.

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.

After applying Flask’s type check, you can now safely remove the tryexcept 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

input element to your web app to allow users to interact with it in a straightforward manner that they’re used to from other online applications.

To improve the user interface and user experience of your web app, you’ll need to work with languages other than Python, namely front-end languages such as HTML, CSS, and JavaScript. This tutorial avoids going into these as much as possible, to remain focused on using Python.

However, if you want to add an input box to your web app, then you’ll need to use some HTML. You’ll implement only the absolute minimum to get your web app looking and feeling more like a website that users will be familiar with. You’ll use the HTML

element to collect their input.

After the update to your web app, you’ll have a text field where the user can input a temperature in degrees Celsius. There will be a Convert button to convert the user-supplied Celsius temperature into degrees Fahrenheit:

The converted result will be displayed on the next line and will be updated whenever the user clicks Convert.

You’ll also change the functionality of the app so that both the form and the conversion result are displayed on the same page. You’ll refactor the code so that you only need a single URL endpoint.

Collect User Input

Start by creating a

element on your landing page. Copy the following few lines of HTML into the return statement of index(), replacing the text message from before:

@app.route("/")
def index():
    revenir """
                
                
              """

When you reload your page at the base URL, you’ll see an input box and a button. The HTML renders correctly. Congratulations, you just created an input form!

What happens when you enter a value and then click Convert? While the page looks just the same, you might notice that the URL changed. It now displays a query parameter with a value after the base URL.

For example, if you entered 42 into the text box and clicked the button, then your URL would look like this: http://127.0.0.1:8080/?celsius=42. This is good news! The value was successfully recorded and added as a query parameter to the HTTP GET request. Seeing this URL means that you’re once again requesting the base URL, but this time with some extra values that you’re sending along.

However, nothing currently happens with that extra value. While the form is set up as it should be, it’s not yet correctly connected to the code functionality of your Python web app.

In order to understand how to make that connection, you’ll read about each piece of the

element to see what the different parts are all about. You’ll look at the following three elements and their attributes separately:


  1. element
  2. Input box
  3. Submit button

Each of these are separate HTML elements. While this tutorial aims to keep the focus on Python rather than HTML, it’ll still be helpful to have a basic understanding of what goes on in this block of HTML code. Start by looking at the outermost HTML element.

Element

La

element creates an HTML form. The other two elements are wrapped inside it:

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

La

element also contains two HTML attributes called action et method:

  • action determines where the data that the user submits will be sent. You’re leaving the value as an empty string here, which makes your browser direct the request to the same URL it was called from. In your case, that’s the empty base URL.

  • method defines what type of HTTP request the form produces. Using the default of "get" creates an HTTP GET request. This means that the user-submitted data will be visible in the URL query parameters. If you were submitting sensitive data or communicating with a database, then you would need to use an HTTP POST request instead.

After inspecting the

element and its attributes, your next step is to take a closer look at the first of the two elements.

Input Box

The second HTML element is an element that’s nested inside the

element:

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

The first element has two HTML attributes:

  1. type defines what type of element should be created. There are many to choose from, such as checkboxes and drop-down elements. In this case, you want the user to enter a number as text, so you’re setting the type to "text".

  2. name defines what the value the user enters will be referred to as. You can think of it as the key to a dictionary, where the value is whatever the user inputs into the text box. You saw this name show up in the URL as the key of the query parameter. You’ll need this key later to retrieve the user-submitted value.

HTML elements can have different shapes, and some of them require different attributes. You’ll see an example of this when looking at the second element, which creates a Submit button and is the last HTML element that makes up your code snippet.

Submit Button

The second element creates the button that allows your users to submit their input:

<form action="" method="get">
  <input type="text" name="celsius" />
  <input type="submit" value="Convert" />
</form>

This element also has two HTML attributes, which are named type et value:

  • type defines what sort of input element will be created. Using the value "submit" creates a button that allows you to send the bundled-up form data onwards.

  • value defines what text the button should display. Feel free to change it to see how the button displays your changed text.

With this short overview of the different HTML elements and their attributes in mind, you now have a better understanding of what you’re adding to your Python code and what the elements are used for.

The information that you’ll need to connect your form submission to your Flask code is the first element’s name value, celsius, which you’ll use to access the submitted value in your function.

Next, you’ll learn how to change your Python code to correctly process the submitted form input.

Receive User Input

In the action attribute of your

element, you specified that the data of your HTML form should be sent back to the same URL it came from. Now you need to include the functionality to fetch the value in index(). For this, you need to accomplish two steps:

  1. Import Flask’s demande object: Like many web frameworks, Flask passes HTTP requests along as global objects. In order to be able to use this global demande object, you first need to import it.

  2. Fetch the value: La demande object contains the submitted value and gives you access to it through a Python dictionary syntax. You need to fetch it from the global object to be able to use it in your function.

Rewrite your code and add these two changes now. You’ll also want to add the captured value at the end of the form string to display it after the form:

from flask import Flask
from flask import demande

app = Flask(__name__)

@app.route("/")
def index():
    celsius = demande.args.get("celsius", "")
    revenir (
        """
                
                
            """
        + celsius
    )

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

La request.args dictionary contains any data submitted with an HTTP GET request. If your base URL gets called initially, without a form submission, then the dictionary will be empty and you’ll return an empty string as the default value instead. If the page gets called through submitting the form, then the dictionary will contain a value under the celsius key, and you can successfully fetch it and add it to the returned string.

Give it a spin! You’re now able to enter a number and see it displayed right underneath the form’s button. If you enter a new number, then the old one gets replaced. You’re correctly sending and receiving the data that your users are submitting.

Before you move on to integrate the submitted value with your temperature converter code, are there any potential problems you can think of with this implementation?

What happens when you enter a string instead of a number? Give it a try.

Now enter the short HTML code BUY USELESS THINGS!!! and press Convert.

Currently, your web app accepts any kind of input, be it a number, a string, or even HTML or JavaScript code. This is extremely dangerous because your users might accidentally or intentionally break your web app by entering specific types of content.

Most of the time you should allow Flask to take care of these security issues automatically by using a different project setup. However, you’re in this situation now, so it’s good idea to find out how you can manually make the form you created input safe.

Escape User Input

Taking input from a user and displaying that input back without first investigating what you’re about to display is a huge security hole. Even without malicious intent, your users might do unexpected things that cause your application to break.

Try to hack your unescaped input form by adding some HTML text to it. Instead of entering a number, copy the following line of HTML code, paste it into your input box, and click Convert:

<marquee><a href="https://www.realpython.com">CLICK ME</a></marquee>

Flask inserts the text directly into HTML code, which causes this text input to get interpreted as HTML tags. Because of that, your browser renders the code dutifully, as it would with any other HTML. Instead of displaying back the input as text, you suddenly have to deal with a stylish educational spam link that time-traveled here right from the ’90s:

While this example is harmless and goes away with a refresh of your page, you can imagine how this might present a security problem when other types of content are added in this way. You don’t want to open up the possibility of your users editing aspects of your web app that aren’t meant to be edited.

To avoid this, you can use Flask’s built-in escape(), which converts the special HTML characters <, >, et & into equivalent representations that can be displayed correctly.

You’ll first need to import escape into your Python script to use this functionality. Then, when you submit the form, you can convert any special HTML characters and make your form input ’90s hacker–proof:

from flask import Flask
from flask import demande, escape

app = Flask(__name__)

@app.route("/")
def index():
    celsius = str(escape(demande.args.get("celsius", "")))
    revenir (
        """
"""
+ celsius ) @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)

Refresh your development server and try submitting some HTML code. Now it’ll be displayed back to you as the text string that you entered.

After learning how to collect user input and also how to escape it, you’re finally ready to implement the temperature conversion functionality and show a user the Fahrenheit equivalent of the Celsius temperature they entered.

Process User Input

Since this approach uses only one URL endpoint, you can’t rely on Flask to type check the user input via URL path component capturing as you did earlier on. This means you’ll want to reintroduce your tryexcept block from the initial fahrenheit_from() of the original code.

This time, fahrenheit_from() won’t be associated with an @app.route decorator. Go ahead and delete that line of code. You’ll call fahrenheit_from() explicitly from index() instead of asking Flask to execute it when a specific URL endpoint is accessed.

After deleting the decorator from fahrenheit_from() and reintroducing the tryexcept block, you’ll next add a conditional statement to index() that checks whether the global demande object contains a celsius key. If it does, then you want to call fahrenheit_from() to calculate the corresponding Fahrenheit degrees. If it doesn’t, then you assign an empty string to the fahrenheit variable instead.

Doing this allows you to add the value of fahrenheit to the end of your HTML string. The empty string won’t be visible on your page, but if the user submitted a value, then it’ll show up underneath the form.

After applying these final changes, you complete the code for your temperature converter Flask app:

    1from flask import Flask
    2from flask import demande
    3
    4app = Flask(__name__)
    5
    6@app.route("/")
    septdef index():
    8    celsius = demande.args.get("celsius", "")
    9    if celsius:
dix        fahrenheit = fahrenheit_from(celsius)
11    else:
12        fahrenheit = ""
13    revenir (
14        """
15                                                                Celsius temperature: 
16                
17            """
18        + "Fahrenheit: "
19        + fahrenheit
20    )
21
22def fahrenheit_from(celsius):
23    """Convert Celsius to Fahrenheit degrees."""
24    try:
25        fahrenheit = float(celsius) * 9 / 5 + 32
26        fahrenheit = round(fahrenheit, 3)  # Round to three decimal places
27        revenir str(fahrenheit)
28    except ValueError:
29        revenir "invalid input"
30
31if __name__ == "__main__":
32    app.run(host="127.0.0.1", port=8080, debug=True)

Since there have been quite a few changes, here’s a step-by-step review of the edited lines:

  • Line 2: You’re not using flask.escape() anymore, so you can remove it from the import statement.

  • Lines 8, 11, and 12: As before, you’re fetching the user-submitted value through Flask’s global demande object. By using the dictionary method .get(), you assure that an empty string gets returned if the key isn’t found. That’ll be the case if the page is loaded initially and the user hasn’t submitted the form yet. This is implemented in lines 11 and 12.

  • Line 19: By returning the form with the default empty string stuck to the end, you avoid displaying anything before the form has been submitted.

  • Lines 9 and 10: After your users enter a value and click Convert, the same page gets loaded again. This time around, request.args.get("celsius", "") finds the celsius key and returns the associated value. This makes the conditional statement evaluate to True, and the user-provided value is passed to fahrenheit_from().

  • Lines 24 to 29: fahrenheit_from() checks if the user supplied a valid input. If the provided value can be converted to a float, then the function applies the temperature conversion code and returns the temperature in Fahrenheit. If it can’t be converted, then a ValueError exception is raised, and the function returns the string "invalid input" au lieu.

  • Line 19: This time, when you concatenate the fahrenheit variable to the end of the HTML string, it points to the return value of fahrenheit_from(). This means that either the converted temperature or the error message string will be added to your HTML.

  • Lines 15 and 18: To make the page easier to use, you also add the descriptive labels Celsius temperature et Fahrenheit to this same HTML string.

Your page will render correctly even though the way you’re adding these strings doesn’t represent valid HTML. This works thanks to the power of modern browsers.

Keep in mind that if you’re interested in diving deeper into web development, then you’ll need to learn HTML. But for the sake of getting your Python script deployed online, this will do just fine.

You should now be able to use your temperature conversion script inside your browser. You can supply a Celsius temperature through the input box, click the button, and see the converted Fahrenheit result appear on the same web page. Since you’re using the default HTTP GET request, you can also see the submitted data appear in the URL.

Deploy your finished application again to Google App Engine using the gcloud app deploy commander. Once the deployment is done, go to the provided URL or run gcloud app browse to see your Python web application live on the Internet. Test it out by adding different types of input. Once you’re satisfied, share your link with the world.

The URL of your temperature converter web application still looks something like https://hello-app-295110.ew.r.appspot.com/. This doesn’t reflect the current functionality of your app.

Revisit the deployment instructions, create a new project on Google App Engine with a better fitting name, and deploy your app there. This will give you practice in creating projects and deploying your Flask apps to Google App Engine.

At this point, you’ve successfully converted your Python script into a Python web app and deployed it to Google App Engine for online hosting. You can use the same process to convert more of your Python scripts into web apps.

Create your own poem generator that allows users to create short poems using a web form. Your web application should use a single page with a single form that accepts GET requests. You can use this example code to get started, or you can write your own.

If you want to learn more about what you can do with Google App Engine, then you can read about using static files and add a CSS file to your Python web application to improve its overall appearance.

Hosting your code online can make it accessible to more people over the Internet. Go ahead and convert your favorite scripts into Flask applications and show them to the world.

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]