TOC

Bereitstellen von Python-Webanwendungen mit dem Bottle Micro Framework unter CentOS 7

Einführung

Python ist aufgrund seiner Flexibilität und hohen Funktionalität eine ausgezeichnete Sprache für die Webprogrammierung. Web-Frameworks können die Programmierung von Webanwendungen erheblich vereinfachen, da sie viele der für eine robuste Webschnittstelle erforderlichen Komponenten miteinander verbinden.

Während einige Web-Frameworks versuchen, alles bereitzustellen, versuchen andere, sich aus dem Weg zu räumen und sich um die wichtigen, schwer umsetzbaren Probleme zu kümmern. * Bottle * ist ein Python-Framework, das in die zweite Kategorie fällt. Es ist extrem leicht, macht es aber auch einfach, Anwendungen schnell zu entwickeln.

In diesem Handbuch wird erläutert, wie Sie Bottle zum Erstellen einfacher Webanwendungen auf einem CentOS 7-Server einrichten und verwenden.

Voraussetzungen

Bevor Sie mit diesem Handbuch beginnen, benötigen Sie Folgendes:

  • Ein CentOS 7-Tröpfchen

  • Grundkenntnisse zum Bearbeiten von Textdateien über die Befehlszeile

  • Ein sudo user

Schritt 1 - Installieren Sie eine virtuelle Umgebung für Python

Python, die Programmiersprache, für die Bottle entwickelt wurde, ist standardmäßig auf CentOS installiert.

Wir werden das Paket "+ python-virtualenv +" installieren, um unser Python-Projekt von der Python-Umgebung des Systems zu isolieren. Mit der virtualenv-Software können wir eine separate, geschlossene Umgebung für unsere Python-Projekte erstellen, die sich nicht auf das gesamte Betriebssystem auswirkt.

Aktualisieren Sie Ihre Paketlisten:

sudo yum update

Installieren Sie + python-virtualenv + aus den Repositorys:

sudo yum install python-virtualenv

Wir werden einen Ordner "+ projects +" in unserem Ausgangsverzeichnis erstellen und dann eine virtuelle Umgebung in diesem Ordner erstellen:

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

Dadurch wird ein Verzeichnis mit dem Namen "+ venv " im Verzeichnis " projects +" erstellt. Es installiert einige Python-Dienstprogramme in diesem Ordner und erstellt eine Verzeichnisstruktur, um zusätzliche Tools zu installieren.

Schritt 2 - Aktivieren Sie die virtuelle Umgebung für Python

Wir müssen die virtuelle Umgebung aktivieren, bevor wir an unserem Projekt arbeiten können:

source venv/bin/activate

Die Eingabeaufforderung ändert sich, um die Tatsache widerzuspiegeln, dass wir jetzt in einer virtuellen Umgebung arbeiten.

Schritt 3 - Installieren Sie die Flasche

Eines der Tools, die das virtualenv-Programm installiert hat, war + pip +.

Mit diesem Tool können wir Python-Pakete einfach aus dem Python-Paketindex, einem Online-Repository, installieren.

Wenn wir nach Python-Paketen suchen möchten, die mit Bottle zu tun haben, können wir Folgendes ausführen:

pip search bottle

Wir werden mit der Installation des Flaschenpakets beginnen:

pip install bottle

Nach Abschluss des Vorgangs sollten wir in der Lage sein, das Bottle-Framework in unseren Anwendungen zu verwenden.

Schritt 4 - Erstellen Sie Ihre erste Flaschenapplikation

Bottle implementiert, wie die meisten Frameworks, eine Version des MVC-Softwaremusters. MVC steht für Model, View und Controller und beschreibt die Entscheidung, die verschiedenen Funktionen einer Benutzeroberfläche zu trennen.

Das Modell ist eine Darstellung eines Datensatzes und ist für das Speichern, Abfragen und Aktualisieren von Daten verantwortlich. Die Ansicht beschreibt, wie Informationen an den Benutzer ausgegeben werden sollen. Es wird verwendet, um die Darstellung von Daten zu formatieren und zu steuern. Der controller ist das Hauptverarbeitungszentrum der App, das entscheidet, wie auf Benutzeranforderungen reagiert wird.

Flaschenapplikationen können unglaublich einfach sein. In ihrer einfachsten Form können sie alle diese Komponenten in einer einzigen Datei implementieren. Wir werden eine "Hallo Welt" -Anwendung erstellen, um zu zeigen, wie dies gemacht wird.

Erstellen Sie mit Ihrem bevorzugten Texteditor eine Python-Anwendung mit dem Namen "+ hello.py +":

nano ~/projects/hello.py

Wir zeigen Ihnen jede Zeile einzeln und fügen die endgültige Datei am Ende dieses Abschnitts hinzu.

In dieser Datei werden in der ersten Zeile einige Funktionen aus dem Flaschenpaket importiert. Auf diese Weise können wir die Framework-Tools in unserer Anwendung verwenden:

hallo.py

from bottle import route, run

Diese Zeile teilt unserem Programm mit, dass wir die Route importieren und Module aus dem Bottle-Paket ausführen möchten.

  • Mit dem von uns importierten "+ run +" - Modul können Sie die Anwendung auf einem Entwicklungsserver ausführen, um die Ergebnisse Ihres Programms schnell zu sehen.

  • Das importierte + route + - Modul teilt der Anwendung mit, welche URL-Anforderungen von welchen Python-Funktionen verarbeitet werden. Flaschenanwendungen implementieren das Routing, indem sie für jede angeforderte URL eine einzelne Python-Funktion aufrufen. Anschließend werden die Ergebnisse der Funktion an den Benutzer zurückgegeben.

Wir können jetzt eine Route hinzufügen, die dem URL-Muster "+ / hallo +" entspricht. Fügen Sie am Ende der Datei eine neue Zeile hinzu:

hallo.py

from bottle import route, run

Dieser Routendekorator stimmt mit der URL "+ / hello +" überein. Wenn dieser Pfad auf dem Server angefordert wird, wird die direkt folgende Funktion ausgeführt. Fügen Sie am Ende der Datei zwei weitere Zeilen hinzu:

hallo.py

from bottle import route, run

@route('/hello')

Diese Funktion ist sehr einfach, erfüllt jedoch die einzige Anforderung einer Routing-Funktion: Sie gibt einen Wert zurück, der im Webbrowser angezeigt werden kann. In diesem Fall ist der Wert eine einfache HTML-Zeichenfolge. Wir könnten die h1-Header-Tags entfernen und die gleichen Informationen undekoriert anzeigen.

Schließlich müssen wir unsere Anwendung auf dem Entwicklungsserver ausführen. Fügen Sie die letzte Zeile hinzu, und jetzt ist Ihre Datei fertig:

hallo.py

from bottle import route, run

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

In dieser Zeile wird die Serverinstanz ausgeführt.

  • Durch Übergabe des Parameters "+ host =" 0.0.0.0 "+" wird der Inhalt auf jedem Computer bereitgestellt, nicht nur auf dem lokalen Computer. Dies ist wichtig, da unsere Anwendung remote gehostet wird

  • Der Parameter + port + gibt den Port an, den dieser verwenden wird

Speichern und schließen Sie die Datei.

Wir können diese Anwendung mit diesem Befehl ausführen:

python ~/projects/hello.py

Sie können diese Anwendung in Ihrem Webbrowser aufrufen, indem Sie zu Ihrer IP-Adresse gehen, gefolgt von dem Port, auf dem wir ausgeführt haben (8080), gefolgt von der von uns erstellten Route (/ hello):

  • + http: //: 8080 / hallo +

Es wird so aussehen:

Bild: https://assets.digitalocean.com/articles/bottle/hello_world.png [DigitalOcean Bottle Hallo Welt]

Sie können den Server jederzeit stoppen, indem Sie Folgendes eingeben:

CTRL-C

Schritt 5 - Erstellen Sie ein Flaschenmodell

Wir haben jetzt unsere erste Anwendung implementiert. Es war einfach, aber es hat die MVC-Prinzipien nicht wirklich umgesetzt oder etwas besonders Interessantes getan. Erstellen wir diesmal eine etwas komplexere Anwendung.

Wir beginnen mit unserem Modell. Dies ist der Teil unseres Programms, der die Datenspeicherung übernimmt. Durch die Verwendung von Plugins kann Bottle problemlos eine Vielzahl von Backends für Daten implementieren.

Wir werden eine SQLite-Datenbankdatei für unsere Datenbank verwenden. Dies ist eine extrem einfache Datenbank für einfache Aufgaben.

SQLite ist im CentOS 7-Standardimage enthalten. Wenn Sie es jedoch jemals neu installieren müssen, ist es so einfach wie ein Befehl:

sudo yum install sqlite

Es sollte bereits installiert sein.

Wir müssen auch das Bottle-Plugin herunterladen und installieren, mit dem wir diese Datenbanken verwenden können:

pip install bottle-sqlite

Nachdem wir die Komponenten haben, werden wir eine Python-Datei erstellen, die eine SQLite-Datenbank mit einigen Daten generiert. Wir könnten dies im Python-Interpreter tun, aber das Erstellen einer Datei erleichtert das Wiederholen.

Erstellen Sie die Datei:

nano ~/projects/picnic_data.py

Fügen Sie diesen Inhalt der Datei hinzu. Es wird eine Datenbank mit Picknick-Inventargegenständen erstellt:

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

In dieser Datei haben wir:

  • Importieren Sie das SQLite-Paket

  • Führen Sie einen Befehl aus, der unsere Tabelle erstellt und Daten einfügt

  • Schließlich übernehmen wir die Änderungen

Speichern und schließen Sie die Datei.

Führen Sie die Datei aus, die eine Datenbankdatei mit dem Namen "+ picnic.db +" in unserem aktuellen Verzeichnis erstellt:

python ~/projects/picnic_data.py

Wenn Sie möchten, können Sie das Verzeichnis mit "+ ls +" markieren, um zu bestätigen, dass die Datenbankdatei erstellt wurde.

Der Modellteil unseres Programms ist nun ziemlich vollständig. Wir können sehen, dass unser Modell ein wenig vorschreibt, wie unser Kontrollbereich funktionieren muss, um mit unseren Daten zu interagieren.

[[6---create-a-bottle-controller]] === 6 - Erstellen Sie einen Flaschencontroller

Nachdem wir über eine Datenbank verfügen, können wir mit der Entwicklung unserer Hauptanwendung beginnen. Dies wird hauptsächlich unsere Steuerungsfunktionalität implementieren. Es wird auch die Datei sein, die unserer ersten Anwendung am ähnlichsten ist.

Erstellen Sie eine Datei mit dem Namen "+ picnic.py +", um unsere Hauptanwendung zu speichern:

nano ~/projects/picnic.py

Wie zuvor werden wir die Datei zeilenweise erklären und die fertige Datei am Ende des Schritts anzeigen.

In dieser Datei müssen wir wie zuvor einige Dinge aus dem Bottle-Paket importieren. Wir benötigen einige zusätzliche Module, die wir zuvor noch nicht verwendet haben. Zusätzlich müssen wir die SQLite-Funktionalität importieren:

picnic.py

import sqlite3
from bottle import route, run, template

Als Nächstes definieren wir eine Route, die mit dem URL-Pfad "+ / picknick +" übereinstimmt:

picnic.py

import sqlite3
from bottle import route, run, template

Wir werden die Funktion implementieren, die eine Verbindung zu unserer Datenbank herstellt, unsere Daten aus der Tabelle abruft und unsere Ansicht aufruft, um die Seite zu rendern.

picnic.py

import sqlite3
from bottle import route, run, template

@route('/picnic')

  • Der Befehl, der eine Verbindung zur Datenbank herstellt, ist der Befehl + db = sqlite3.connect ('picnic.db') +

  • Wir fragen die Datenbank ab und wählen alle unsere Werte mit den nächsten vier Zeilen aus

  • Die Zeile, in der wir die Ansicht zum Formatieren Ihrer Daten aufrufen, lautet "+ output = template (" bring_to_picnic ", rows = data) ". Dies ruft eine Vorlage (Ansicht) mit dem Namen " bring_to_picnic.tpl " auf, um die Daten zu formatieren. Es übergibt die Variable " data in" als Template-Variable "+ rows"

  • Schließlich wird eine formatierte Ausgabe an unseren Benutzer zurückgegeben

Schließlich müssen wir unseren Befehl + run + hinzufügen, um den eigentlichen Server auszuführen:

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

Speichern und schließen Sie die Datei.

Wir werden diese Vorlagendatei "+ bring_to_picnic.tpl +" im nächsten Abschnitt erstellen.

Schritt 7 - Erstellen Sie eine Flaschenansicht

Jetzt, da wir unser Modell und unseren Controller haben, müssen wir nur noch unsere Sicht schaffen. Dies ist mit der in Bottle integrierten Vorlagen-Engine einfach zu erledigen.

Die Anwendung sucht nach einer Vorlage, die dem in der Vorlagenfunktion angegebenen Namen entspricht und mit + .tpl + endet. Dies kann entweder im Hauptverzeichnis des Projekts oder in einem Verzeichnis mit dem Namen "+ view +" erfolgen.

Erstellen Sie eine Datei, die mit der Template-Funktion in der Zeile "+ output +" des vorherigen Skripts übereinstimmt:

nano ~/projects/bring_to_picnic.tpl

In dieser Datei können wir HTML und Programmierung mischen. Unsere werden sehr einfach sein. Es wird eine Schleife verwendet, um eine Tabelle zu erstellen, die wir mit unseren Modelldaten füllen werden. Fügen Sie der Datei alle folgenden Zeilen hinzu:

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>

Dadurch wird unsere Seite in HTML gerendert.

  • Die Template-Sprache, die wir hier sehen, ist im Grunde Python

  • Die Variable + rows +, die wir an die Vorlage übergeben haben, kann beim Entwerfen der Ausgabe verwendet werden

  • Wir können Python-Zeilen eingeben, indem wir ihnen "+% +" voranstellen

  • Wir können auf Variablen im HTML zugreifen, indem wir die Syntax + {{var}} + verwenden.

Speichern und schließen Sie die Datei.

Schritt 8 - Starten Sie die Flaschenapplikation

Unsere Bewerbung ist jetzt vollständig.

Wir können das Programm starten, indem wir Python in der Hauptdatei aufrufen:

python ~/projects/picnic.py

Wir können die Ergebnisse anzeigen, indem wir unsere IP-Adresse und unseren Port aufrufen, gefolgt von der von uns erstellten URL-Route:

  • + http: //: 8080 / picknick +

Ihre Webseite sollte folgendermaßen aussehen:

image: https: //assets.digitalocean.com/articles/bottle/mvc_example.png [DigitalOcean Bottle mvc example]

Drücken Sie "+ STRG-C +", um die Anwendung zu beenden.

(Optional) Schritt 9 - Laden Sie Ihre eigene Anwendung hoch

Um Ihre eigene Bottle-Anwendung hochzuladen, müssen Sie alle Projektdateien in dieses Verzeichnis kopieren:

~/projects/

Zum Beispiel:

scp :~/projects/

Laden Sie * alle mit diesem Projekt verbundenen * Dateien auf ähnliche Weise hoch. SFTP ist eine andere Möglichkeit, Dateien hochzuladen, wenn Sie sind nicht vertraut mit + scp +.

(Optional) Schritt 10 - Starten Sie Ihre eigene Anwendung

Aktivieren Sie Ihre virtuelle Umgebung (falls Sie dies noch nicht getan haben).

cd ~/projects/
source venv/bin/activate

Wir werden den Befehl "+ python" verwenden, um die Anwendung zu starten. Wenn Sie den Vorgang im Hintergrund starten, können Sie Ihr Terminal schließen und die App wird weiterhin ausgeführt:

nohup python ~/projects/ &

In der Ausgabe sollten Sie Ihre Prozess-ID-Nummer und die folgende Meldung sehen:

Ausgabe

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

Sobald Sie für die Produktion bereit sind, empfehlen wir dringend, einen stabileren Startplan für Ihre App zu erstellen. (Wenn Sie die App nur im Hintergrund starten, wird sie nach einem Neustart des Servers beendet.) CentOS 7 verwendet systemd.

Fazit

Inzwischen sollten Sie in der Lage sein zu sehen, wie Sie komplexe Anwendungen mit einem einfachen, nackten Mikro-Framework wie Bottle erstellen können. Obwohl unsere Beispiele einfach waren, ist es einfach, die erweiterten Funktionen zu nutzen.

Das Plug-in-System von Bottle ist ebenfalls ein wichtiger Vorteil. Plugins werden aktiv in der Community geteilt und es ist einfach, komplexeres Verhalten über das Pluginsystem zu implementieren.

Eine einfache Möglichkeit, flaschenkompatible Plugins zu finden, ist beispielsweise die Verwendung des Befehls + pip search bottle +. Dies gibt Ihnen einen Überblick über einige der beliebtesten Optionen.

Related