WebSockets voor realtimecommunicatie
Bouw realtimefuncties in FastAPI met WebSockets: accepteer verbindingen, wissel berichten uit, broadcast naar meerdere clients en handel verbroken verbindingen netjes af met async-patronen.
WebSockets voor realtimecommunicatie is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Van verzoek en antwoord naar realtime
Normaal HTTP werkt met verzoek en antwoord: de client vraagt, de server antwoordt en de verbinding wordt gesloten. WebSockets houden één verbinding open voor volledige duplexcommunicatie en realtimeberichten. Ideaal voor chats, live dashboards en meldingen.
Waarom async goed past bij WebSockets
Een WebSocket-verbinding blijft lang bestaan en wacht meestal inactief op berichten. Met het async-model van FastAPI kan één worker duizenden gelijktijdige verbindingen afhandelen zonder te blokkeren.
Een minimaal WebSocket-eindpunt
Declareer een @app.websocket-route. Accepteer de verbinding en blijf vervolgens berichten ontvangen en verzenden in een lus.
from fastapi import FastAPI, WebSocket
app = FastAPI()
@app.websocket('/ws')
async def ws(websocket: WebSocket):
await websocket.accept()
while True:
msg = await websocket.receive_text()
await websocket.send_text(f'echo: {msg}')JSON verzenden
Je kunt gestructureerde gegevens uitwisselen met receive_json en send_json in plaats van met onbewerkte tekst.
data = await websocket.receive_json()
await websocket.send_json({'received': data, 'status': 'ok'})Verbindingen verbreken afhandelen
Clients kunnen de verbinding verbreken. Vang WebSocketDisconnect op om bronnen op te ruimen in plaats van de handler te laten crashen.
from fastapi import WebSocketDisconnect
try:
while True:
await websocket.receive_text()
except WebSocketDisconnect:
print('client left')Een verbindingsbeheerder
Houd actieve verbindingen bij in een beheerdersklasse om berichten naar iedereen te verzenden. Voeg een verbinding toe bij het verbinden en verwijder deze bij het verbreken.
class Manager:
def __init__(self):
self.active = []
async def connect(self, ws):
await ws.accept()
self.active.append(ws)
def disconnect(self, ws):
self.active.remove(ws)Naar iedereen verzenden
Loop door de actieve verbindingen en stuur elk ervan het bericht. Dit vormt de kern van een chatruimte.
async def broadcast(self, message):
for connection in self.active:
await connection.send_text(message)Verzendlogica in gewone Python
De beheerder houdt alleen een lijst bij. Hier wordt de stroom van verbinden, verbreken en verzenden naar iedereen synchroon nagebootst.
active = []
def connect(c): active.append(c)
def disconnect(c): active.remove(c)
def broadcast(msg): return [f'{c}<-{msg}' for c in active]
connect('alice'); connect('bob')
print(broadcast('hi'))
disconnect('alice')
print(broadcast('bye'))Een eindpunt voor een chatruimte
Combineer de onderdelen: verbind, verzend elk ontvangen bericht naar iedereen en verbreek de verbinding wanneer deze wegvalt.
manager = Manager()
@app.websocket('/chat')
async def chat(ws: WebSocket):
await manager.connect(ws)
try:
while True:
text = await ws.receive_text()
await manager.broadcast(text)
except WebSocketDisconnect:
manager.disconnect(ws)Schalen voorbij één proces
Een beheerder in het geheugen kent alleen de verbindingen van zijn worker. Gebruik een pub/sub-backend zoals Redis om berichten naar meerdere workers of servers te verspreiden.
Beveiliging en limieten
Beveilig WebSocket-eindpunten:
- Authenticeer tijdens de handshake (bijvoorbeeld met een token in de query of header).
- Valideer binnenkomende berichten en beperk hun grootte.
- Gebruik een heartbeat/ping om verbroken verbindingen te detecteren.
Korte controle
Waarom kan een verbindingsbeheerder in het geheugen niet correct naar iedereen verzenden wanneer je meerdere Uvicorn-workers uitvoert?
Samenvatting
Je hebt realtimecommunicatie toegevoegd:
- WebSocket-verbindingen geaccepteerd en tekst/JSON uitgewisseld.
WebSocketDisconnectnetjes afgehandeld.- Een verbindingsbeheerder gebouwd om naar veel clients te verzenden.
- Geleerd hoe je met Redis pub/sub schaalt en verbindingen beveiligt.
Leer Bootcamp backendontwikkeling met FastAPI met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 21
- Lessen
- 84
Veelgestelde vragen
Is de les “WebSockets voor realtimecommunicatie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “WebSockets voor realtimecommunicatie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Wat leer ik in “WebSockets voor realtimecommunicatie”?
Bouw realtimefuncties in FastAPI met WebSockets: accepteer verbindingen, wissel berichten uit, broadcast naar meerdere clients en handel verbroken verbindingen netjes af met async-patronen. Je oefent met Bootcamp backendontwikkeling met FastAPI door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Bootcamp backendontwikkeling met FastAPI te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “WebSockets voor realtimecommunicatie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met FastAPI?
Ja. Elke les over Bootcamp backendontwikkeling met FastAPI bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Opfrisser: async/await in Python
- FastAPI en asynchrone bewerkingen
- Backgroundtasks uitvoeren
- WebSockets voor realtimecommunicatie