Python ist eine der beliebtesten Entwicklungssprachen. Ihre einfache Syntax und die niedrigen Einstiegshürden machen sie zu einem guten Kandidaten für Programmieranfänger, die sich einen Namen in der Softwareentwicklungslandschaft machen wollen.

Zahlreiche Frameworks und Bibliotheken erleichtern den Einstieg in die Entwicklung von Python-Anwendungen. Dazu gehören Django, FastAPI und Flask. Das Flask-Framework ist für Python-Entwickler/innen attraktiv, weil es einfaches Prototyping und Anpassungsmöglichkeiten bietet.

Dieser praktische Artikel zeigt dir, wie du mit Flask eine einfache Python-Anwendung mit Datenbankanbindung entwickelst.

Python-Anwendungen einfacher gemacht mit Flask

Flask wurde 2010 entwickelt und eignet sich dank seiner Benutzerfreundlichkeit und Flexibilität hervorragend für die Entwicklung von Python-Webanwendungen. Seine schlanke Architektur konzentriert sich auf die Bereitstellung der Grundlagen und macht es einfach, Bibliotheken für die von dir benötigten Funktionen hinzuzufügen. Dieser Ansatz macht Flask ideal für viele Projekte, von einfachen Anwendungen bis hin zu komplexen Systemen.

Flask bietet verschiedene Werkzeuge und Funktionen zur Unterstützung der Entwicklung von Webanwendungen, darunter:

  • Bibliotheken und Werkzeuge zur Verwaltung von HTTP-Anfragen und -Antworten
  • Die Möglichkeit, Anfragen an bestimmte Funktionen weiterzuleiten
  • Unterstützung für Rendering-Vorlagen
  • Unterstützung für Datenbanken
  • Authentifizierungs- und Autorisierungssysteme

Wie du deine Python Flask Anwendung erstellst

Du kannst die Vorteile von Flask für die Entwicklung von Webanwendungen kennenlernen, indem du eine Python-Webanwendung mit Flask erstellst. Anschließend kannst du die Anwendung mit dem Web Anwendungs-Hosting-Dienst von Kinsta erstellen und bereitstellen und sie mit einer verwalteten Datenbank auf der Kinsta-Plattform verbinden.

Python Flask Anwendungs-Voraussetzungen

Um diesem Tutorial zu folgen, brauchst du:

Installation von Flask für Python

Gehe zu deinem Terminal (Linux oder macOS) oder zur Eingabeaufforderung (Windows). Beginne damit, ein Verzeichnis namens flask_demo zu erstellen.

Wechsle in das neue Verzeichnis und erstelle mit dem Befehl python3 -m venv venv eine virtuelle Python-Umgebung. In diesem Fall verwenden wir auch venv als Namen für das Verzeichnis, das die virtuelle Umgebung unterstützt.

Aktiviere die virtuelle Umgebung mit einem der folgenden Befehle:

  • venvScriptsactivate unter Windows
  • source venv/bin/activate unter Linux oder macOS

Installiere nun Flask mit pip, indem du pip install flask ausführst.

Die bisherige Arbeit in deinem Terminal sollte in etwa so aussehen:

Terminalausgabe während der Erstellung einer virtuellen Python-Umgebung und der Installation von Flask.
Erstellen der Grundlage einer Python-Flask-Anwendung im Terminal

Erstellen einer Basisanwendung

Als Nächstes erstellst du die Basisanwendung und überprüfst ihre Funktionalität, indem du Inhalte im Browser wiedergibst.

Erstelle im Verzeichnis flask_demo eine Datei namens demo.py und füge den folgenden Code hinzu:

from flask import Flask

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return "Happy Coding!"

if __name__ == '__main__':
    app.run(debug=True)

Dieser Code importiert Flask aus dem Modul flask und erstellt eine Instanz davon mit dem Namen app. Der Code erstellt dann eine Route, die den Text „Happy Coding!“ zurückgibt, wenn Nutzer die Anwendung in einem Browser besuchen. Schließlich führt er den Entwicklungsserver aus, sobald das Skript startet.

Starte die Anwendung, indem du flask --app demo run im Terminal ausführst. Das Flag --app gibt den Speicherort der Anwendung an, die ausgeführt werden soll – hier die Datei demo.py.

Hinzufügen von Vorlagen zu deiner Python-Flask-Anwendung

Wenn du deiner Anwendung Vorlagen hinzufügst, kannst du deinen Inhalt erweitern. Erstelle zunächst ein Verzeichnis namens templates im Stammverzeichnis deiner Anwendung. Wechsle dann in das templates-Verzeichnis und erstelle eine Datei namens index.html, die den folgenden HTML-Code enthält:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    <p>My name is John Doe - learning about Application Deployment!</p>
</body>
</html>

Importiere in demo.py render_template aus dem Flask-Modul und rendere die Vorlage index.html in der Funktion route wie folgt:

from flask import Flask, render_template

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)

Als Nächstes rufst du deine Anwendung unter flask --app demo run in deiner lokalen Umgebung auf. Verwende die im Terminal angegebene lokale Adresse, um die Anwendung in deinem Browser zu starten. Du solltest etwas wie das hier sehen:

Screenshot eines Webbrowsers, der die Anfangsphase der Flask-Anwendung anzeigt.
Die Anfänge einer Python-Flask-Anwendung in einem Webbrowser

Verbinden deiner Flask-Anwendung mit einer lokalen Datenbank

Du wirst eine Verbindung zu einer lokalen Datenbank – MySQL – herstellen, in der die Inhalte der Anwendung gespeichert werden.

Um deine Flask-Anwendung mit MySQL zu verbinden, installiere Folgendes:

  • flask_mysqldb, den MySQL-Konnektor für Flask, mit pip install flask_mysqldb
  • Python-dotenv, zum Lesen von Umgebungsvariablen, mit pip install python-dotenv
  • Den Python-MySQL-Konnektor, mit pip install mysql-connector-python
  • Die MySQL-Abhängigkeit, mit pip install mysqlclient

Gehe zur MySQL Workbench, um eine Datenbank zu erstellen. Vergewissere dich, dass du einen Datenbankbenutzer mit der Berechtigung zum Zugriff auf die Datenbank und zum Erstellen von Tabellen hinzufügst.

Erstelle eine .env-Datei im Hauptverzeichnis deiner Anwendung, in der du die Verbindungsdaten zur Datenbank speicherst. In diese Vorlage fügst du die Anmeldedaten deines Datenbankbenutzers und den Namen der Datenbank ein:

DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"

In einem überarbeiteten demo.py-Skript importieren wir nun den MySQL-Konnektor und verwenden Python-dotenv, um die Umgebungsvariablenschlüssel in der .env-Datei zu lesen. Dieses neue demo.py-Skript prüft auch, ob eine Tabelle mit dem Namen Personen in der Datenbank vorhanden ist, und legt sie an, wenn sie nicht existiert.

import os
from flask import Flask, render_template
from flask_mysqldb import MySQL

from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

app.config['MYSQL_HOST'] = os.getenv("DB_HOST")
app.config['MYSQL_USER'] = os.getenv("DB_USER")
app.config['MYSQL_PASSWORD'] = os.getenv("DB_PASSWORD")
app.config['MYSQL_DB'] = os.getenv("DB_NAME")

mysql = MySQL(app)

@app.route('/')
def index():
    cursor = mysql.connection.cursor()

    cursor.execute("SHOW TABLES LIKE 'persons'")
    result = cursor.fetchone()

    if not result:
        cursor.execute(''' CREATE TABLE persons (id INTEGER, firstname VARCHAR(20), lastname VARCHAR(20)) ''')
        cursor.execute(''' INSERT INTO persons VALUES(1, 'John', 'Doe') ''')
        cursor.execute(''' INSERT INTO persons VALUES(2, 'Milly', 'Winfrerey') ''')
        mysql.connection.commit()

    cursor.execute('SELECT * FROM persons')
    entry = cursor.fetchall()
    cursor.close()
    return render_template('index.html', entry=entry)

Nach der Instanziierung von Flask verwendet der obige Code Umgebungsvariablen, um die Datenbankattribute aus der .env-Datei im Stammverzeichnis deiner Anwendung zu erfassen.

Dann instanziiert der Code MySQL und verbindet es mit Flask. Er erstellt ein Cursor-Objekt in der index Route. Als Nächstes sucht der Code in der Datenbank nach einer Tabelle namens Personen. Wenn sie nicht gefunden wird, erstellt er sie mit den Attributen id, firstname und lastname und fügt zwei Datenzeilen ein.

Die nächsten drei Zeilen führen einen SQL-Befehl aus, um alle Zeilen aus der Personentabelle auszuwählen und die Ergebnisse abzurufen. Das Cursor-Objekt wird geschlossen und die Ergebnisse der Abfrage werden als Kontextvariable entry übergeben, um mit der Vorlage gerendert zu werden.

Hier ist eine überarbeitete index.html-Vorlagendatei, die die Ergebnisse der Datenbankabfrage verarbeiten kann:

<!DOCTYPE html><html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    {% for e in entry %}
        <p>My name is {{e[1]}} {{e[2]}} - learning about Application Deployment!</p>
    {% endfor %}
</body>
</html>

Führe die Anwendung aus und kehre dann zur MySQL Workbench zurück, um die Daten zu überprüfen. Sie sollte wie die folgende aussehen:

Abfrageergebnisse für die <strong>Personentabelle</strong> in MySQL Workbench
Abfrageergebnisse für die Personentabelle in MySQL Workbench

Wenn du die Tabelle abfragst, werden die beiden von der Anwendung erzeugten Einträge zurückgegeben. Deine Anwendung zeigt nun die folgenden von der Datenbank abgeleiteten Inhalte im Browser an:

Screenshot des aus der Datenbank generierten Inhalts.
Datenbank-generierte Inhalte im Browser

So stellst du deine Python-Flask-Anwendung auf Kinsta bereit

Jetzt, wo deine Anwendung lokal läuft, kannst du sie für die Welt sichtbar machen, indem du sie auf Kinsta hostest. Du kannst die Kinsta-Dienste Web Anwendungs-Hosting und Managed Datenbank-Hosting kombinieren, um diese Anwendung (und deine zukünftigen Projekte) in der Cloud zum Leben zu erwecken. Und du kannst beides kostenlos testen.

Dein Python-Projekt für die Bereitstellung vorbereiten

Die Web Anwendungs-Hosting-Plattform von Kinsta stellt deinen Code von deinem bevorzugten Git-Host bereit. Im nächsten Schritt musst du deine Anwendungsumgebung so konfigurieren, dass sie diesen Weg unterstützt und Kinsta deine Anwendung mit allen erforderlichen Abhängigkeiten bereitstellen kann.

Beginne damit, ein neues Verzeichnis im Stammverzeichnis deines flask_demo-Projekts zu erstellen. Nennen wir es myapp. Verschiebe dann das Verzeichnis templates und die Datei demo.py in myapp.

Im myapp-Verzeichnis erstellst du eine wsgi.py-Datei mit folgendem Inhalt:

from myapp.demo import app as application

if __name__ == "__main__":
    application.run(debug=True)

Der Build-Prozess bei Kinsta wird auch pip verwenden, um deine Anwendung zu erstellen. Du kannst eine Liste der Abhängigkeiten deiner Anwendung an pip auf der Produktionsseite übergeben, indem du eine requirements.txt-Datei im Hauptverzeichnis des Projekts erstellst.

Wenn du noch in der virtuellen Umgebung venv und im Stammverzeichnis von flask_demo arbeitest, kannst du mit folgendem Befehl eine für dein Projekt spezifische requirements.txt-Datei erstellen:

pip freeze > requirements.txt

Der Inhalt der resultierenden Textdatei sieht dann etwa so aus:

blinker==1.7.0
click==8.1.7
Flask==3.0.0
Flask-MySQLdb==2.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
mysql-connector-python==8.2.0
mysqlclient==2.2.1
protobuf==4.21.12
python-dotenv==1.0.0
Werkzeug==3.0.1

Du wirst die .env-Datei mit ihren Datenbankgeheimnissen nicht an den Produktionsserver senden. Da du die Bibliothek python-dotenv nicht brauchst, um .env in der Produktion zu lesen, kannst du ihren Verweis aus der Datei requirements.txt entfernen und diese Zeilen in der Datei demo.py löschen (oder auskommentieren):

from dotenv import load_dotenv
load_dotenv()

Hinzufügen eines Python WSGI HTTP Servers zum Projekt

Was in den obigen Anforderungen noch fehlt, ist eine Möglichkeit, die Anwendung über HTTP in einer Produktionsumgebung bereitzustellen. Der Entwicklungsserver, den du auf deinem lokalen Rechner benutzt, reicht nicht aus. Für dieses Projekt wirst du das Web Server Gateway Interface (WSGI) Paket Gunicorn zwischen der Anwendung und den Nginx Webservern von Kinsta verwenden.

Du kannst eine Gunicorn-Anforderung zu deinem Projekt hinzufügen, indem du es wie folgt in deiner virtuellen Umgebung installierst:

pip install gunicorn

Nachdem Gunicorn installiert ist, generierst du mit pip erneut die requirements.txt.

Eine Alternative zur lokalen Installation von Gunicorn ist es, die requirements.txt zu bearbeiten und einfach einen Eintrag wie diesen hinzuzufügen:

gunicorn==21.2.0

Um die Grundlagen für den WSGI-Server zu schaffen, erstellst du im Hauptverzeichnis des Projekts eine Datei namens Procfile und fügst die folgende Zeile hinzu:

web: gunicorn myapp.wsgi

Dies wird die Grundlage für den Startbefehl deiner Anwendung in der Produktion sein.

Dein Projekt für Git bereit machen

Die überarbeitete Verzeichnisstruktur ist bereit für die Bereitstellung bei Kinsta, aber du willst nicht, dass alle diese Dateien in die Produktion gehen. Erstelle eine .gitignore-Datei im Stammverzeichnis des Projekts mit folgendem Inhalt:

/venv
.env

Dies verhindert, dass die Dateien im Verzeichnis venv und die lokalen Datenbankgeheimnisse in .env auf deinen Git-Host hochgeladen werden.

Jetzt kannst du deine lokale Git-Umgebung einrichten und den Code mit deinen bevorzugten Tools auf deinen Git-Host hochladen.

Bereitstellen deiner Python-Flask-Anwendung auf Kinsta

Melde dich in deinem MyKinsta-Dashboard an und vergewissere dich, dass du Kinsta für den Zugriff auf deinen Git-Dienstanbieter autorisiert hast. Folge den Schritten zum Hinzufügen einer Anwendung und wähle das Repository und den Zweig auf dem Git-Host aus, in dem Kinsta den Code des Flask-Projekts finden soll.

Wenn du die Build-Umgebung konfigurierst, wähle Buildpacks verwenden, um das Container-Image einzurichten, aber lass alle anderen Einstellungen auf den Standardwerten. (Du gibst keinen Start-Befehl an, da dieser bereits in deinem Procfile definiert ist)

Screenshot der MyKinsta-Oberfläche zum Konfigurieren einer Build-Umgebung.
Wähle Buildpacks, um das Container-Image für die Anwendung einzurichten

Nachdem du die Rechnungsinformationen geprüft hast (du kannst immer noch kostenlos loslegen!), klickst du auf die Schaltfläche Jetzt bauen und beobachtest den Fortschritt im Log Viewer:

Screenshot der Log-Einträge für eine Python-Flask-Anwendung.
Log-Einträge für die Bereitstellung deiner Python-Flask-Anwendung

Hinzufügen einer Datenbank für deine Python Flask Anwendung

Kinsta bietet vier verwaltete Datenbankoptionen an, um deinen Bedürfnissen und Anwendungsanforderungen gerecht zu werden: Redis, PostgreSQL, MariaDB und MySQL. In diesem Lernprogramm haben wir uns für den MySQL-Datenbankdienst entschieden.

Folge den offiziellen Anweisungen zum Hinzufügen einer Datenbank und vergiss nicht, das gleiche Rechenzentrum auszuwählen, das du für deine Flask-Anwendung gewählt hast.

Nachdem du die Datenbank erstellt hast, wählst du sie aus der Liste deiner verfügbaren DB-Server aus und scrollst auf der Registerkarte Übersicht zum Abschnitt Interne Verbindungen / Erlaubte Anwendungen herunter. Wenn du auf die Schaltfläche Verbindung hinzufügen klickst, wird dein Flask-Anwendungsdienst im selben Rechenzentrum zur Auswahl stehen:

Screenshot des Dialogs zum Hinzufügen einer internen Datenbankverbindung in MyKinsta.
Hinzufügen einer internen Verbindung zu einer Anwendung nach dem Erstellen einer Datenbank

Klicke auf das Kontrollkästchen Umgebungsvariablen zur Anwendung hinzufügen, bevor du die neue Verbindung erstellst. Dadurch werden die Umgebungsvariablen angezeigt, die deine Datenbankgeheimnisse enthalten – und das alles auf sichere Weise, ohne dass die .env-Datei benötigt wird.

Screenshot des Dialogs zum Hinzufügen von Umgebungsvariablen für Datenbankanmeldeinformationen.
Hinzufügen von Umgebungsvariablen für eine interne Verbindung zu deiner Datenbank

Unten im obigen Dialog sind die Einstellungen Während der Laufzeit verfügbar und Während des Build-Prozesses verfügbar standardmäßig aktiviert – und genau das willst du ja auch.

Nachdem du auf die Schaltfläche Verbindung hinzufügen geklickt hast, werden die Umgebungsvariablen, die für den Datenbankzugriff erforderlich sind, auf die Projekteinstellungen im MyKinsta-Dashboard Anwendungen angewendet:

Screenshot eines MyKinsta-Dialogs mit Umgebungsvariablen, die von der Datenbank an eine Anwendung übergeben werden.
Datenbank-Umgebungsvariablen, die an die Python-Flask-Anwendung übergeben werden

Auch wenn du deine Anwendung nach zukünftigen Erweiterungen neu erstellst, bleiben die Angaben zur Datenbankverbindung erhalten.

Screenshot of the Python Flask application live on the Kinsta platform.Screenshot der Python-Flask-Anwendung live auf der Kinsta-Plattform.
Die Python-Flask-Anwendung läuft auf der Kinsta-Plattform

Herzlichen Glückwunsch! Du hast soeben eine Python-Flask-Anwendung erstellt und sie auf der Kinsta-Plattform bereitgestellt.

Zusammenfassung

Das anpassbare Framework von Flask macht die Erstellung einer Python-Anwendung deutlich einfacher. Die Nutzung von Kinsta zur Bereitstellung einer Flask-Anwendung macht alles noch einfacher und beschleunigt die Anwendungsentwicklung und -bereitstellung.

Hier haben wir gelernt, wie man eine einfache datenbankgestützte Anwendung in einer lokalen Entwicklungsumgebung erstellt und diese dann auf den Webanwendungs- und Datenbank-Hosting-Plattformen von Kinsta für den Rest der Welt bereitstellt.

Entdecke, was du sonst noch auf unserer Plattform bauen kannst, indem du unsere Schnellstartvorlagen durchsuchst.

Steve Bonisteel Kinsta

Steve Bonisteel is a Technical Editor at Kinsta who began his writing career as a print journalist, chasing ambulances and fire trucks. He has been covering Internet-related technology since the late 1990s.