In deze les leren we hoe we achtergrondtaken kunnen implementeren in een Flask webapplicatie. We focussen op eenvoudige voorbeelden om de basisbeginselen te begrijpen, voordat we ons in latere lessen verdiepen in complexere scenario's die geschikt zijn voor enterprise-level toepassingen.
Achtergrondtaken, ook wel asynchrone taken genoemd, zijn processen die op de achtergrond van je webapplicatie worden uitgevoerd, zonder de primaire webverzoek te blokkeren. Dit voorkomt dat gebruikers moeten wachten totdat een langdurige operatie is voltooid, zoals het verzenden van een e-mail, het genereren van een rapport of het verwerken van grote hoeveelheden data. Stel je voor: een gebruiker upload een foto naar je website. In plaats van direct de foto te verwerken (bijvoorbeeld het wijzigen van het formaat, het optimaliseren), kun je dit uitbesteden aan een achtergrondtaak. Zo blijft de website responsief voor de gebruiker.
Een eenvoudige manier om achtergrondtaken te implementeren is met behulp van de ingebouwde threading-module in Python. Dit is geschikt voor kleine taken.
Voorbeeld:
from flask import Flask, render_template
import threading
import time
app = Flask(__name__)
def background_taak():
print("Achtergrondtaak start...")
time.sleep(5) # Simuleer een langdurige taak
print("Achtergrondtaak voltooid!")
@app.route('/')
def index():
threading.Thread(target=background_taak).start()
return render_template('index.html', message="Taak gestart!")
if __name__ == '__main__':
app.run(debug=True)
In dit voorbeeld wordt een nieuwe thread gemaakt die de background_taak() uitvoert. De website blijft responsief, terwijl de taak op de achtergrond draait. Vergeet niet een index.html bestand te maken met een eenvoudig bericht (bijvoorbeeld: 'Taak gestart!').
Voor complexere situaties en wanneer je meerdere taken wilt afhandelen, is het handig om een wachtrij te gebruiken. De queue-module in Python biedt een eenvoudige manier om taken in een wachtrij te plaatsen en deze door meerdere threads te laten verwerken. Dit vermindert de kans op race conditions en zorgt voor een betere schaalbaarheid.
Voorbeeld:
from flask import Flask, render_template
import threading
import time
from queue import Queue
app = Flask(__name__)
task_queue = Queue()
def worker():
while True:
taak = task_queue.get()
print(f"Verwerken taak: {taak}...")
time.sleep(2) # Simuleer werk
print(f"Taak {taak} voltooid!")
task_queue.task_done()
# Start de worker thread
threading.Thread(target=worker, daemon=True).start()
@app.route('/')
def index():
task_queue.put("Taak 1")
task_queue.put("Taak 2")
return render_template('index.html', message="Taken verzonden!")
if __name__ == '__main__':
app.run(debug=True)
In dit voorbeeld plaatsen we taken in de task_queue. Een worker-thread pakt de taken uit de wachtrij en voert ze uit. daemon=True zorgt ervoor dat de thread stopt wanneer de applicatie afsluit.
Het gebruik van achtergrondtaken biedt verschillende voordelen:
Explore advanced insights, examples, and bonus exercises to deepen understanding.
Welkom terug! Vandaag duiken we dieper in achtergrondprocessen in Flask webapplicaties, met een focus op enterprise-niveau overwegingen. We bouwen voort op de basis die we geleerd hebben en verkennen meer geavanceerde technieken en perspectieven.
We hebben threading en queues behandeld, maar in de enterprise-wereld is dit vaak niet voldoende. Threading is prima voor eenvoudige taken, maar het heeft beperkingen, vooral in een omgeving met veel gebruikers of intensieve taken. De Global Interpreter Lock (GIL) in Python beperkt de echte parallelle uitvoering van threads (vooral voor CPU-gebonden taken). Daarom kijken we nu naar alternatieven.
Alternatieve benaderingen voor achtergrondtaken:
multiprocessing module.Contextwisseling en Overhead: Onthoud dat elke methode overhead met zich meebrengt. Threading is relatief lichtgewicht, maar processen zijn zwaarder. Task queues hebben communicatie-overhead. Kies de juiste methode voor de taak. Het is cruciaal om je applicatie te profileren en de prestaties te meten om de beste aanpak te bepalen.
Pas je vorige threading-voorbeeld aan om de `multiprocessing` module te gebruiken. Maak een eenvoudige functie die een paar seconden duurt om te voltooien (bv. time.sleep(5)) en voer deze uit als een apart proces. Meet de tijd die het duurt om meerdere taken parallel uit te voeren, en vergelijk dit met de thread-versie. (Hint: gebruik Process van de multiprocessing module.)
Maak een eenvoudige Flask-route die een taak toevoegt aan een multiprocessing.Queue. Laat een afzonderlijk proces (een 'worker') continu taken uit de queue oppikken en verwerken. De taken kunnen simpelweg berichten naar de console loggen. (Hint: gebruik Queue en Process van de multiprocessing module. Gebruik eventueel een `while True` loop in de worker).
Installeer Flask-Asyncio. Maak een simpele route die een asynchrone taak uitvoert (bv. asyncio.sleep(5)). Vergelijk de response tijd met de synchrone versie. Bekijk de resultaten met een belastingstest (bv. ab of een ander tool). (Hint: Gebruik async def voor route-functies.)
Enterprise-niveau toepassingen:
Dagelijkse voorbeelden:
Enterprise Challenge: Stel je voor dat je een systeem bouwt om grote hoeveelheden data te verwerken (bijvoorbeeld, een grote verzameling logbestanden). Implementeer een eenvoudige versie die: 1) Inkomende logbestanden ontvangt via een Flask-route. 2) De logs naar een wachtrij (met multiprocessing.Queue) stuurt. 3) Een worker-proces dat de logs uit de queue leest, een eenvoudige analyse uitvoert (bv. het tellen van foutmeldingen) en de resultaten opslaat in een database (simuleer dit eventueel met een dictionary). Voeg error handling toe om eventuele problemen met het verwerken van de logs te ondervangen. Probeer om de code zo te structureren dat deze eenvoudig kan worden geschaald (door meer workers toe te voegen).
Maak een Flask applicatie die een achtergrondtaak start wanneer de root route wordt bezocht. De achtergrondtaak moet 3 seconden slapen en vervolgens een bericht afdrukken naar de console. Gebruik de `threading` module.
Pas de vorige applicatie aan zodat je taken in een queue plaatst. De webapplicatie moet twee verschillende 'taken' in de wachtrij plaatsen. Elke 'taak' simuleert een langdurig proces (3 seconden slapen). Laat de webapplicatie een bericht weergeven dat de taken in de wachtrij zijn geplaatst.
Beschrijf in je eigen woorden de voordelen en nadelen van het gebruik van achtergrondtaken. Geef een voorbeeld van een situatie waarin achtergrondtaken essentieel zijn voor een goede gebruikerservaring.
Stel je voor dat je een webshop maakt. Wanneer een gebruiker een bestelling plaatst, moeten er meerdere taken worden uitgevoerd (e-mail verzenden, voorraad bijwerken, orderbevestiging genereren). Beschrijf hoe je achtergrondtaken zou gebruiken om de bestelprocedure soepel en efficiënt te maken, zonder de gebruiker te laten wachten.
Lees over het gebruik van andere bibliotheken zoals Celery en Redis voor het implementeren van geavanceerdere achtergrondtaken en het omgaan met asynchrone taken op enterprise-level.
We're automatically tracking your progress. Sign up for free to keep your learning paths forever and unlock advanced features like detailed analytics and personalized recommendations.