TOC

Comment déployer des applications Web Python avec Bottle Micro Framework sur Ubuntu 14.04

introduction

Python est un excellent langage pour la programmation Web en raison de sa flexibilité et de ses fonctionnalités de haut niveau. Les infrastructures Web peuvent simplifier considérablement la programmation des applications Web, car elles connectent de nombreux composants nécessaires à une interface Web robuste.

Alors que certains frameworks Web tentent de tout fournir, d’autres tentent de rester en dehors du processus tout en s’occupant des problèmes importants, difficiles à mettre en œuvre. * Bottle * est un framework Python qui entre dans la deuxième catégorie. Il est extrêmement léger, mais facilite également le développement rapide d’applications.

Dans ce guide, nous expliquerons comment configurer et utiliser Bottle pour créer des applications Web simples sur un serveur Ubuntu 14.04.

Conditions préalables

Avant de commencer ce guide, vous aurez besoin des éléments suivants:

  • Une goutte Ubuntu 14.04

  • Connaissance pratique de la modification de fichiers texte à partir de la ligne de commande

  • Un sudo utilisateur

Étape 1 - Installer un environnement virtuel pour Python

Python, le langage de programmation pour lequel Bottle est construit, est installé par défaut sur Ubuntu.

Nous allons installer le paquetage + python-virtualenv + pour isoler notre projet Python de l’environnement Python du système. Le logiciel virtualenv nous permet de créer un environnement séparé et contenu pour nos projets Python qui n’affectera pas l’ensemble du système d’exploitation.

Mettez à jour vos listes de paquets:

sudo apt-get update

Installez + python-virtualenv + à partir des référentiels:

sudo apt-get install python-virtualenv

Nous allons créer un dossier + projects + dans notre répertoire personnel, puis créer un environnement virtuel dans ce dossier:

mkdir ~/projects
cd ~/projects
virtualenv --no-site-packages venv

Cela crée un répertoire appelé + venv + dans le répertoire + projects +. Il installe des utilitaires Python dans ce dossier et crée une structure de répertoires pour installer des outils supplémentaires.

Étape 2 - Activer l’environnement virtuel pour Python

Nous devons activer l’environnement virtuel avant de commencer à travailler sur notre projet:

source venv/bin/activate

L’invite de commande changera pour refléter le fait que nous fonctionnons maintenant dans un environnement virtuel.

Étape 3 - Installation de la bouteille

L’un des outils installés par le programme virtualenv était + pip +.

Cet outil nous permet d’installer facilement les packages Python à partir de l’index Python, un référentiel en ligne.

Si nous voulons rechercher des paquets Python ayant un rapport avec Bottle, nous pouvons exécuter:

pip search bottle

Nous allons commencer par installer le paquet Bottle:

pip install bottle

Une fois le processus terminé, nous devrions pouvoir utiliser le cadre Bottle dans nos applications.

Étape 4 - Créez votre première application de bouteille

Bottle, comme la plupart des frameworks, implémente une version du modèle logiciel MVC. MVC signifie modèle, vue et contrôleur. Il décrit la décision de séparer les différentes fonctions d’une interface utilisateur.

Le model est une représentation d’un ensemble de données et est responsable du stockage, de l’interrogation et de la mise à jour des données. La view décrit comment les informations doivent être rendues à l’utilisateur. Il est utilisé pour formater et contrôler la présentation des données. Le controller est le principal centre de traitement de l’application, qui décide comment répondre aux demandes des utilisateurs.

Les applications en bouteille peuvent être incroyablement simples. Dans leur forme la plus simple, ils peuvent implémenter tous ces composants dans un seul fichier. Nous allons créer une application «hello world» pour montrer comment cela est fait.

Avec votre éditeur de texte préféré, créez une application Python appelée + hello.py +:

nano ~/projects/hello.py

Nous vous montrerons chaque ligne une à la fois et inclurons le fichier final à la fin de cette section.

Dans ce fichier, la première ligne que nous allons ajouter importe certaines fonctionnalités du paquet Bottle. Cela nous permettra d’utiliser les outils de framework dans notre application:

bonjour.py

from bottle import route, run

Cette ligne indique à notre programme que nous souhaitons importer la route et exécuter des modules à partir du paquet Bottle.

  • Le module + run + que nous importons peut être utilisé pour exécuter l’application sur un serveur de développement, ce qui est très utile pour visualiser rapidement les résultats de votre programme.

  • Le module + route + que nous importons est chargé de dire à l’application quelles requêtes d’URL sont gérées par les fonctions Python. Les applications en bouteille implémentent le routage en appelant une seule fonction Python pour chaque URL demandée. Il renvoie ensuite les résultats de la fonction à l’utilisateur

Nous pouvons ajouter une route maintenant qui correspondra au modèle d’URL + / hello +. Ajoutez une nouvelle ligne au bas du fichier:

bonjour.py

from bottle import route, run

Ce décorateur d’itinéraire correspond à l’URL + / hello +. Ainsi, lorsque ce chemin est demandé sur le serveur, la fonction qui suit directement sera exécutée. Ajoutez deux autres lignes à la fin du fichier:

bonjour.py

from bottle import route, run

@route('/hello')

Cette fonction est très simple, mais elle complète la seule exigence d’une fonction de routage: elle renvoie une valeur pouvant être affichée dans le navigateur Web. Dans ce cas, la valeur est une simple chaîne HTML. Nous pourrions supprimer les balises d’en-tête h1 et les mêmes informations seraient affichées de manière non décorée.

Enfin, nous devons exécuter notre application en utilisant le serveur de développement. Ajoutez la dernière ligne et votre fichier est maintenant complet:

bonjour.py

from bottle import route, run

@route('/hello')
def hello():
   return "<h1>Hello World!</h1>"

Cette ligne exécutera l’instance du serveur.

  • En passant le paramètre + host = '0.0.0.0' +, le contenu sera transmis à tout ordinateur, pas uniquement à l’ordinateur local. Ceci est important car notre application est hébergée à distance

  • Le paramètre + port + spécifie le port que cela utilisera

Enregistrez et fermez le fichier.

Nous pouvons exécuter cette application avec cette commande:

python ~/projects/hello.py

Vous pouvez visiter cette application dans votre navigateur Web en accédant à votre adresse IP, suivie du port sur lequel nous avons choisi de fonctionner (8080), puis de la route créée (/ hello):

  • + http: //: 8080 / hello +

Il ressemblera à ceci:

image: https: //assets.digitalocean.com/articles/bottle/hello_world.png [DigitalOcean Bottle hello world]

Vous pouvez arrêter le serveur à tout moment en tapant:

CTRL-C

Étape 5 - Créer un modèle de bouteille

Nous avons maintenant mis en œuvre notre première application. C’était simple, mais cela n’appliquait pas vraiment les principes de MVC, ni rien d’intéressant. Créons une application légèrement plus sophistiquée cette fois-ci.

Nous allons commencer avec notre modèle. Ceci est la partie de notre programme qui gère le stockage de données. Bottle peut facilement implémenter une variété de backends pour les données via l’utilisation de plugins.

Nous allons utiliser un fichier de base de données SQLite pour notre base de données. Ceci est une base de données extrêmement simple conçue pour des tâches légères.

Installez SQLite avec cette commande:

sudo apt-get install sqlite

Nous devons également télécharger et installer le plugin Bottle qui nous permettra d’utiliser ces bases de données:

pip install bottle-sqlite

Maintenant que nous avons les composants, nous allons créer un fichier Python qui générera une base de données SQLite avec des données. Nous pourrions faire cela dans l’interpréteur Python, mais créer un fichier facilite la répétition.

Créez le fichier:

nano ~/projects/picnic_data.py

Ajoutez ce contenu au fichier. Il créera une base de données remplie d’articles d’inventaire de pique-nique:

picnic_data.py

import sqlite3
db = sqlite3.connect('picnic.db')
db.execute("CREATE TABLE picnic (id INTEGER PRIMARY KEY, item CHAR(100) NOT NULL, quant INTEGER NOT NULL)")
db.execute("INSERT INTO picnic (item,quant) VALUES ('bread', 4)")
db.execute("INSERT INTO picnic (item,quant) VALUES ('cheese', 2)")
db.execute("INSERT INTO picnic (item,quant) VALUES ('grapes', 30)")
db.execute("INSERT INTO picnic (item,quant) VALUES ('cake', 1)")
db.execute("INSERT INTO picnic (item,quant) VALUES ('soda', 4)")
db.commit()

Dans ce fichier, nous:

  • Importer le package SQLite

  • Exécuter une commande qui crée notre table et insère des données

  • Enfin, nous engageons les modifications

Enregistrez et fermez le fichier.

Exécutez le fichier, ce qui créera un fichier de base de données nommé + picnic.db + dans notre répertoire actuel:

python ~/projects/picnic_data.py

Si vous le souhaitez, vous pouvez + ls + le répertoire pour confirmer que le fichier de base de données a été créé.

La partie modèle de notre programme est maintenant assez complète. Nous pouvons voir que notre modèle dictera un peu comment notre partie de contrôle doit fonctionner pour interagir avec nos données.

[[6---create-a-bottle-controller]] === 6 - Créer un contrôleur de bouteille

Maintenant que nous avons une base de données, nous pouvons commencer à développer notre application principale. Cela implémentera principalement les fonctionnalités de notre contrôleur. Ce sera également le fichier qui ressemble le plus à notre première application.

Créez un fichier nommé + picnic.py + pour stocker notre application principale:

nano ~/projects/picnic.py

Comme auparavant, nous allons expliquer le fichier ligne par ligne et afficher le fichier terminé à la fin de l’étape.

Dans ce fichier, nous devons importer certaines choses du paquet Bottle, comme avant. Nous avons besoin de modules supplémentaires que nous n’avons jamais utilisés auparavant. De plus, nous devons importer la fonctionnalité SQLite:

pique-nique.py

import sqlite3
from bottle import route, run, template

Ensuite, nous définirons un itinéraire qui correspond au chemin d’URL + / picnic +:

pique-nique.py

import sqlite3
from bottle import route, run, template

Nous allons implémenter la fonction qui se connecte à notre base de données, extrait nos données de la table et appelle notre vue pour restituer la page.

pique-nique.py

import sqlite3
from bottle import route, run, template

@route('/picnic')

  • La commande qui se connecte à la base de données est la commande + db = sqlite3.connect ('picnic.db') +

  • Nous interrogeons la base de données et sélectionnons toutes nos valeurs avec les quatre lignes suivantes

  • La ligne où nous appelons la vue pour formater vos données est + output = template ('bring_to_picnic', rows = data) +. Cela appelle un modèle (vue) appelé + bring_to_picnic.tpl + pour formater les données. Il transmet la variable + data in en tant que variable de modèle` + rows`

  • Enfin, il renvoie la sortie formatée à notre utilisateur

Enfin, nous devons ajouter notre commande + run + pour exécuter le serveur actuel:

pique-nique.py

import sqlite3
from bottle import route, run, template

@route('/picnic')
def show_picnic():
   db = sqlite3.connect('picnic.db')
   c = db.cursor()
   c.execute("SELECT item,quant FROM picnic")
   data = c.fetchall()
   c.close()
   output = template('bring_to_picnic', rows=data)
   return output

Enregistrez et fermez le fichier.

Nous allons créer ce fichier modèle + + bring_to_picnic.tpl + `dans la section suivante.

Étape 7 - Créer une vue de bouteille

Maintenant que nous avons notre modèle et notre contrôleur, il ne reste plus qu’à créer notre vue. Ceci est géré facilement à l’aide du moteur de gabarit intégré à Bottle.

L’application recherchera un modèle correspondant au nom donné dans la fonction de modèle, se terminant par + .tpl +. Cela peut être soit dans le répertoire principal du projet, soit dans un répertoire appelé + view +.

Créez un fichier correspondant à celui que nous avons appelé avec la fonction template dans la ligne + output + du script précédent:

nano ~/projects/bring_to_picnic.tpl

Dans ce fichier, nous pouvons mélanger HTML et programmation. Le nôtre sera très simple. Il utilisera une boucle pour créer une table, que nous peuplerons avec nos données de modèle. Ajoutez toutes ces lignes au fichier:

bring_to_picnic.tpl

<h1>Things to bring to our picnic</h1>

<table>
   <tbody>
       <tr><th>Item</th><th>Quantity</th></tr>
       %for row in rows:
       <tr>
       %for col in row:
           <td>{{col}}</td>
       %end
       </tr>
   %end
   <tbody>
</table>

Cela rendra notre page en HTML.

  • Le langage de gabarit que nous voyons ici est essentiellement Python

  • La variable + rows + que nous avons transmise au modèle est disponible pour être utilisée lors de la conception de la sortie

  • Nous pouvons taper des lignes de Python en les précédant de +% +

  • Nous pouvons accéder aux variables du code HTML en utilisant la syntaxe + {{var}} +.

Enregistrez et fermez le fichier.

Étape 8 - Démarrer l’application de la bouteille

Notre application est maintenant complète.

Nous pouvons démarrer le programme en appelant Python sur le fichier principal:

python ~/projects/picnic.py

Nous pouvons voir les résultats en visitant notre adresse IP et notre port, suivis de la route d’URL que nous avons créée:

  • + http: //: 8080 / pique-nique +

Votre page Web devrait ressembler à ceci:

image: https: //assets.digitalocean.com/articles/bottle/mvc_example.png [Exemple de bouteille numérique mcc avec DigitalOcean]

Appuyez sur + CTRL-C + pour arrêter l’application. (+ CTRL-Z + est un signal d’arrêt plus fort.)

(Facultatif) Étape 9 - Téléchargez votre propre application

Pour télécharger votre propre application Bottle, vous devez copier tous les fichiers du projet dans ce répertoire:

~/projects/

Par exemple:

scp :~/projects/

Téléchargez * tous les fichiers * associés à ce projet de la même manière. SFTP est une autre façon de télécharger des fichiers, si vous ne sont pas familiers avec + scp +.

(Facultatif) Étape 10 - Démarrer votre propre application

Activez votre environnement virtuel (si vous ne l’avez pas déjà fait).

cd ~/projects/
source venv/bin/activate

Nous allons utiliser la commande + python pour démarrer l’application. Nous allons le rendre un peu moins rudimentaire en démarrant le processus en arrière-plan, ce qui signifie que vous pouvez fermer votre terminal et que l’application continuera à fonctionner:

nohup python ~/projects/ &

Dans la sortie, vous devriez voir votre numéro d’identification de processus et le message suivant:

Sortie

[1]
(venv)[sammy@bottle projects]$ nohup: ignoring input and appending output to ‘nohup.out’

Une fois que vous êtes prêt pour la production, nous vous recommandons vivement de créer un plan de démarrage plus robuste pour votre application. (Le fait de le démarrer en arrière-plan signifie que votre application va s’arrêter après le redémarrage du serveur.) Ubuntu 14.04 utilise https://www.digitalocean.com/community/tutorials/the-upstart-event-system-what-it-is-and. -how-to-use-it [Upstart].

Conclusion

A présent, vous devriez être capable de voir comment vous pouvez construire des applications complexes en utilisant un simple micro-framework simple comme Bottle. Bien que nos exemples soient simples, il est facile de tirer parti de fonctionnalités plus avancées.

Le système de plug-in de Bottle est également un atout important. Les plugins sont activement partagés au sein de la communauté et il est facile d’implémenter un comportement plus complexe via le système de plugin.

Par exemple, un moyen simple de rechercher des plugins compatibles Bottle consiste à utiliser la commande + pip search bottle +. Cela vous donnera une idée de certaines des options les plus populaires.

Related