Python is een van de populairste ontwikkeltalen van vandaag de dag. De eenvoudige syntaxis en lage instapdrempel maken het een goede kandidaat voor beginnende programmeurs die willen beginnen in de wereld van softwaredevelopment.
Een groot aantal frameworks en bibliotheken maken het eenvoudiger om een Python applicatie op te starten. Dit zijn onder andere Django, FastAPI en Flask. Het Flask framework is populair onder Python developers aan door de ondersteuning van eenvoudige prototyping en de hoge aanpasbaarheid.
Dit praktische artikel laat zien hoe je een eenvoudige aan een database verbonden Python applicatie ontwikkelt met Flask.
Python applicaties gemakkelijker maken dankzij Flask
Flask, ontwikkeld in 2010, is zeer geschikt voor het ontwikkelen van Python webapplicaties dankzij het gebruiksgemak en de flexibiliteit. De slanke architectuur richt zich op het leveren van de basis, terwijl het eenvoudig is om bibliotheken toe te voegen voor de functionaliteit die je nodig hebt. Deze aanpak maakt Flask ideaal voor veel projecten, van eenvoudige toepassingen tot complexe systemen.
Flask biedt verschillende tools en mogelijkheden om de ontwikkeling van webapps te ondersteunen, waaronder:
- Bibliotheken en hulpmiddelen om HTTP verzoeken en -responses te beheren
- De mogelijkheid om verzoeken te routen naar aangewezen functies
- Ondersteuning voor rendering templates
- Ondersteuning voor databases
- Authenticatie- en autorisatiesystemen
Hoe maak je een Python Flask app?
Je kunt de voordelen van het gebruik van Flask voor het ontwikkelen van webapps ontdekken door een Python webapp te maken met Flask. Vervolgens kun je de applicatie bouwen en deployen met behulp van Kinsta’s Web Applicatie Hosting dienst en deze verbinden met een Managed Database op het Kinsta platform.
Voorwaarden Python Flask app
Om deze tutorial te volgen heb je nodig:
- Python versie 3 of hoger
- MySQL Workbench
- Python’s pip en virtualenv pakketten geïnstalleerd
- Een code-editor
- Een account bij Bitbucket, GitHub of GitLab om je Git repository te hosten
- Een MyKinsta account (gratis) om de applicatie te leveren
Flask voor Python installeren
Ga naar je terminal (Linux of macOS) of Command Prompt (Windows). Begin met het aanmaken van een map met de naam flask_demo.
Ga naar de nieuwe map en maak een Python virtuele omgeving met het commando python3 -m venv venv. In dit geval gebruiken we venv als naam voor de map die de virtuele omgeving zal ondersteunen.
Activeer de virtuele omgeving met een van deze commando’s:
venvScriptsactivatein Windowssource venv/bin/activatein Linux of macOS
Installeer nu Flask met pip door pip install flask uit te voeren.
Het werk in je terminal tot nu toe zou er ongeveer zo uit moeten zien:
Een basisapplicatie bouwen
Maak vervolgens de basisapplicatie en bekijk de functionaliteit ervan door inhoud naar de browser te renderen.
Maak in de flask_demo directory een bestand genaamd demo.py en voeg de volgende code toe:
from flask import Flask
app = Flask(__name__)
# Routes
@app.route('/')
def index():
return "Happy Coding!"
if __name__ == '__main__':
app.run(debug=True)Deze code importeert Flask uit de module flask en maakt er een instance van met de naam app. De code maakt vervolgens een route die tekst weergeeft met de tekst “Happy Coding!” wanneer gebruikers de app bezoeken in een browser. Tot slot wordt de ontwikkelingsserver uitgevoerd zodra het script start.
Start de applicatie door flask --app demo run uit te voeren in de terminal. De flag --app specificeert de locatie van de applicatie die wordt uitgevoerd – hier het bestand demo.py.
Templates toevoegen aan je Python Flask app
Het toevoegen van templates aan je app zal je inhoud versterken. Maak eerst een map genaamd templates in de root van je applicatie. Ga vervolgens naar de templates map en maak een bestand genaamd index.html met de volgende HTML code:
<!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>Importeer in demo.py render_template uit de flask module en render de index.html template in de route functie als volgt:
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)Serve vervolgens je applicatie door flask --app demo run uit te voeren in je lokale omgeving. Gebruik het lokale adres in de terminal om de app in je browser te starten. Je zou iets als dit moeten zien:
Je Flask app verbinden met een lokale database
Je gaat een verbinding maken met een lokale database – MySQL – waarin de inhoud van de applicatie wordt opgeslagen.
Om je Flask applicatie met MySQL te verbinden, installeer je het volgende:
- flask_mysqldb, de MySQL connector voor Flask, met behulp van
pip install flask_mysqldb - Python-dotenv, voor het lezen van omgevingsvariabelen, met behulp van
pip install python-dotenv - De Python MySQL-connector, met
pip install mysql-connector-python - De MySQL dependency, met
pip install mysqlclient
Ga naar MySQL Workbench om een database te maken. Zorg ervoor dat je een databasegebruiker toevoegt met rechten om toegang te krijgen tot de database en tabellen aan te maken.
Maak een .env bestand aan in de hoofdmap van je applicatie om de details van de databaseverbinding in op te slaan. Je voegt de gegevens van je databasegebruiker en de databasenaam toe aan dit template:
DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"In een herzien demo.py script importeren we nu de MySQL connector en gebruiken we Python-dotenv om de omgevingsvariabele sleutels in het .env bestand te lezen. Dit nieuwe demo.py script controleert ook op het bestaan van een tabel met de naam persons in de database en zal deze aanmaken en vullen als deze niet bestaat.
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)Na het instantiëren van Flask gebruikt de bovenstaande code omgevingsvariabelen om de database-attributen op te halen uit het .env bestand in de root van je applicatie.
Vervolgens maakt de code MySQL aan en associeert het met Flask. Er wordt een cursorobject aangemaakt in de index route. Vervolgens controleert de code of er een tabel met de naam persons in de database staat. Als die niet wordt gevonden, maakt hij hem aan met de attributen id, firstname en lastname en voegt twee rijen gegevens in.
De volgende drie regels voeren een SQL commando uit om alle rijen uit de tabel persons te selecteren en de resultaten op te halen. Het cursorobject wordt gesloten en de resultaten van de query worden doorgegeven als de contextvariabele entry voor rendering met de template.
Hier is een herzien index.html templatebestand dat de resultaten van de database query kan verwerken:
<!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>Voer de applicatie uit en ga dan terug naar MySQL Workbench om de gegevens te controleren. Het zou er als volgt uit moeten zien:
Als je de tabel opvraagt, krijg je de twee gegevens terug die door de app zijn gegenereerd. Je applicatie geeft nu de volgende van de database afgeleide inhoud weer in de browser:
Je Python Flask applicatie deployen naar Kinsta
Nu je applicatie lokaal draait, kun je hem zichtbaar maken voor de wereld door hem te hosten op Kinsta. Je kunt Kinsta’s Web Applicaten Hosting en Managed Database Hosting diensten koppelen om deze app (en je toekomstige werk) tot leven te brengen in de cloud. En je kunt ze allebei gratis uitproberen.
Je Python project voorbereiden voor deployment
Kinsta’s Web Applicatie Hosting platform zet je code uit vanaf je favoriete Git host. Je volgende stap is het configureren van je applicatieomgeving om dat pad te ondersteunen en Kinsta toe te staan je applicatie met alle vereiste dependencies te deployen.
Begin met het aanmaken van een nieuwe map binnen de flask_demo project root. Laten we deze myapp noemen. Verplaats vervolgens de templates map en het demo.py bestand naar myapp.
Maak in de myapp map een wsgi.py bestand met de volgende inhoud:
from myapp.demo import app as application
if __name__ == "__main__":
application.run(debug=True)Het bouwproces bij Kinsta zal pip ook gebruiken om je applicatie te genereren. Je kunt een lijst met dependencies van je app doorgeven aan pip aan de productiekant met behulp van een requirements.txt bestand in de rootmap van het project.
Terwijl je nog steeds in de venv virtuele omgeving en in de flask_demo hoofdmap werkt, kun je een requirements.t xt bestand genereren dat specifiek is voor jouw project met het volgende commando:
pip freeze > requirements.txtDe inhoud van het resulterende tekstbestand ziet er ongeveer zo uit:
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.1Je zult het .env bestand met zijn database-secrets niet naar de productieserver sturen. Omdat je de python-dotenv bibliotheek niet nodig hebt om .env in te lezen in productie, kun je de referentie ervan verwijderen uit requirements.txt en deze regels verwijderen (of ze wegcommenten) in demo.py:
from dotenv import load_dotenv
load_dotenv()Een Python WSGI HTTP server toevoegen aan het project
Eén ding dat ontbreekt in de bovenstaande vereisten is een manier om de applicatie via HTTP te serven in een productieomgeving. De ontwikkelserver die je op je lokale machine gebruikt is niet voldoende. Voor dit project gebruik je het Web Server Gateway Interface (WSGI) pakket Gunicorn tussen de app en Kinsta’s Nginx webservers.
Je kunt een Gunicorn vereiste aan je project toevoegen door het op deze manier in je virtuele omgeving te installeren:
pip install gunicornNadat Gunicorn is geïnstalleerd, gebruik je pip om opnieuw requirements.txt te genereren.
Een alternatief voor het lokaal installeren van Gunicorn is het bewerken van requirements.txt en simpelweg een regel als deze toe te voegen:
gunicorn==21.2.0Om het basiswerk voor de WSGI server af te ronden, maak je een bestand aan in de hoofdmap van het project met de naam Procfile en voeg je de volgende regel toe:
web: gunicorn myapp.wsgiDit zal de basis zijn van het start commando voor je app in productie.
Je project klaarmaken voor Git
De herziene mapstructuur is klaar voor deployment bij Kinsta, maar je wilt niet dat al die bestanden naar productie gaan. Maak een .gitignore bestand in de project root met een inhoud als deze:
/venv
.envDit zal voorkomen dat de bestanden in de venv map en de lokale database geheimen in .env geüpload worden naar je Git host.
Je kunt nu je lokale Git omgeving starten en de code naar je Git host pushen met de tools van je voorkeur.
Je Python Flask app deployen naar Kinsta
Log in op je MyKinsta dashboard en zorg ervoor dat je Kinsta toegang hebt gegeven tot je Git serviceprovider. Volg de stappen om een applicatie toe te voegen en selecteer de repository en branch op de Git host waar Kinsta deze Flask projectcode zal vinden.
Wanneer je de bouwomgeving configureert, selecteer dan Gebruik Buildpacks om de container image in te stellen, maar laat alle andere instellingen op de standaardwaarden staan. (Je hoeft geen Start commando op te geven omdat dat al gedefinieerd is in je Procfile)
Nadat je de factuurgegevens hebt bekeken (je kunt nog steeds gratis aan de slag!), klik je op de knop Nu bouwen en bekijk je de voortgang in de logboekviewer:
Een database toevoegen voor je Python Flask app
Kinsta heeft vier managed databaseopties om aan je behoeften en applicatie-eisen te voldoen: Redis, PostgreSQL, MariaDB en MySQL. In deze tutorial bouwen we voor de MySQL databasedienst.
Volg de officiële instructies voor het toevoegen van een database en vergeet niet om hetzelfde datacenter te kiezen dat je hebt gekozen voor je Flask applicatie.
Nadat je de database hebt gemaakt, selecteer je deze in de lijst met beschikbare DB-servers en scroll je naar beneden naar het gedeelte Interne verbindingen / Toegestane applicaties op het tabblad Overzicht. Wanneer je op de knop Verbinding toevoegen klikt, zal je Flask applicatieservice in hetzelfde datacenter beschikbaar zijn om te selecteren:
Klik op het selectievakje Omgevingsvariabelen toevoegen aan de applicatie voordat je de nieuwe verbinding maakt. Dit toont de omgevingsvariabelen die je database-secrets zullen bevatten – allemaal veilig afgehandeld zonder dat je het .env bestand nodig hebt.
Onderaan het bovenstaande dialoogvenster zijn de instellingen Beschikbaar tijdens runtime en Beschikbaar tijdens bouwproces standaard ingeschakeld – en dat is precies wat je wilt.
Nadat je uiteindelijk op de knop Verbinding toevoegen hebt geklikt, worden de omgevingsvariabelen die nodig zijn voor databasetoegang toegepast op je project Instellingen in het dashboard Applicaties van MyKinsta:
Zelfs als je je applicatie opnieuw bouwt na toekomstige uitbreidingen, blijven de gegevens van de databaseverbinding behouden.
Gefeliciteerd! Je hebt zojuist een Python Flask applicatie gemaakt en gedeployd op het Kinsta platform.
Samenvatting
Het aanpasbare framework van Flask maakt het maken van een Python applicatie veel eenvoudiger. Het gebruik van Kinsta om een Flask applicatie te deployen maakt het nog eenvoudiger en versnelt de ontwikkeling en deployment van applicaties.
Hier hebben we geleerd hoe we een eenvoudige database-verbonden applicatie kunnen bouwen binnen een lokale ontwikkelomgeving en deze vervolgens beschikbaar kunnen maken voor de rest van de wereld op Kinsta’s Web Applicatie Hosting en Database Hosting platforms.
Ontdek wat je nog meer kunt bouwen op ons platform door onze Quickstart templates te bekijken.
Steve Bonisteel is Technical Editor bij Kinsta. Hij begon zijn schrijverscarrière als verslaggever en achtervolgde ambulances en brandweerwagens. Sinds eind jaren negentig schrijft hij over internetgerelateerde technologie.
Laat een reactie achter