WebSockets implementeren in FastAPI
Leer WebSocket-endpoints aan uw FastAPI-applicatie toevoegen en verbindingen beheren.
WebSockets implementeren in FastAPI is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 2 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.
Realtime met FastAPI WebSockets
Welkom bij het implementeren van WebSockets met FastAPI! WebSockets bieden een persistente, full-duplexcommunicatieverbinding tussen een client en een server.
- Full-duplex: Zowel de client als de server kunnen tegelijkertijd berichten verzenden en ontvangen.
- Realtime: Ideaal voor toepassingen die directe updates nodig hebben, zoals chat, live dashboards of games.
FastAPI heeft uitstekende ingebouwde ondersteuning voor WebSockets en maakt gebruik van de async/await-functies van Python.
Een WebSocket-eindpunt definiëren
Net als HTTP-eindpunten definieer je WebSocket-eindpunten met een decorator. In plaats van @app.get() of @app.post() gebruik je @app.websocket().
Je eindpuntfunctie moet async def zijn en een parameter websocket: WebSocket accepteren. Dit object van het type WebSocket is je belangrijkste hulpmiddel voor interactie.
De eerste stap binnen je functie is altijd await websocket.accept() om de verbinding tot stand te brengen.
Je eerste WebSocket-verbinding
Laten we ons eerste WebSocket-eindpunt maken. In dit eenvoudige voorbeeld accepteert het eindpunt een verbinding, verzendt het een welkomstbericht en sluit het daarna de verbinding.
Let op de decorator @app.websocket("/ws") en de functie async def. Die zijn essentieel voor het verwerken van WebSockets.
Probeer dit voorbeeld uit te voeren en bekijk de verbinding:
from fastapi import FastAPI, WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
await websocket.send_text("Welcome! Connection established.")
await websocket.close()WebSocket-verbindingen verbreken
WebSocket-verbindingen kunnen om verschillende redenen worden onderbroken, bijvoorbeeld wanneer de client het tabblad sluit of er een netwerkfout optreedt. Het is belangrijk om deze verbroken verbindingen netjes af te handelen.
FastAPI genereert een WebSocketDisconnect-uitzondering wanneer een client de verbinding verbreekt. Je kunt deze uitzondering opvangen om opruimtaken uit te voeren, zoals het verwijderen van de client uit een lijst met actieve verbindingen.
Wikkel je logica voor WebSocket-communicatie in een blok try...except WebSocketDisconnect.
Berichten van clients ontvangen
Zodra de verbinding tot stand is gebracht, kan je server berichten van de client ontvangen. Het object WebSocket biedt hiervoor methoden:
await websocket.receive_text(): voor het ontvangen van tekenreeksgegevens.await websocket.receive_bytes(): voor het ontvangen van binaire gegevens.await websocket.receive_json(): voor het ontvangen van JSON-gegevens (hiervoor ispython-multipartvereist).
Deze bewerkingen zijn asynchroon, dus gebruik altijd await.
Berichten van clients terugsturen
Dit voorbeeld laat een eenvoudige server zien die berichten terugstuurt. De server accepteert een verbinding, ontvangt voortdurend berichten van de client en stuurt ze terug.
De lus while True houdt de verbinding open en try...except WebSocketDisconnect handelt af wanneer de client weggaat.
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
app = FastAPI()
@app.websocket("/ws/echo")
async def websocket_echo(websocket: WebSocket):
await websocket.accept()
try:
while True:
data = await websocket.receive_text()
print(f"Received from client: {data}")
await websocket.send_text(f"Server echoed: {data}")
except WebSocketDisconnect:
print("Client disconnected.")Berichten naar clients verzenden
Op dezelfde manier kan je server berichten naar de client verzenden. Het object WebSocket biedt:
await websocket.send_text("your message"): om tekenreeksgegevens te verzenden.await websocket.send_bytes(b"your bytes"): om binaire gegevens te verzenden.await websocket.send_json({"key": "value"}): om JSON-gegevens te verzenden.
Vergeet niet om deze aanroepen te voorzien van await. Vaak verzend je direct na het ontvangen van een bericht een antwoord.
Werken met JSON-gegevens
Voor gestructureerde gegevens heeft het de voorkeur om JSON te verzenden en te ontvangen. Het WebSocket-object van FastAPI handelt de serialisatie en deserialisatie voor je af.
- Verzenden: geef een Python-
dictdoor aansend_json(). - Ontvangen:
receive_json()retourneert een Python-dict.
Dit vereenvoudigt de gegevensuitwisseling vergeleken met het handmatig parseren van tekenreeksen.
Eenvoudige verbindingsbeheerder
Voor toepassingen met meerdere clients moet je actieve verbindingen beheren. Een veelgebruikt patroon is een klasse gebruiken om alle verbonden objecten van het type WebSocket bij te houden.
Deze beheerder kan vervolgens worden gebruikt om verbindingen toe te voegen of te verwijderen en om berichten naar specifieke clients te verzenden of naar iedereen uit te zenden.
from fastapi import WebSocket
class ConnectionManager:
def __init__(self):
self.active_connections: list[WebSocket] = []
async def connect(self, websocket: WebSocket):
await websocket.accept()
self.active_connections.append(websocket)
def disconnect(self, websocket: WebSocket):
self.active_connections.remove(websocket)
async def send_personal_message(self, message: str, websocket: WebSocket):
await websocket.send_text(message)
# In a real app, you'd integrate 'manager' into your FastAPI endpoint
manager = ConnectionManager()Controle van WebSocket-interactie
Je hebt de basis geleerd van het instellen van en communiceren met WebSocket-verbindingen in FastAPI.
Laten we controleren of je begrijpt hoe je nieuwe verbindingen accepteert.
Samenvatting: WebSockets implementeren
Je hebt geleerd hoe je WebSockets in FastAPI implementeert!
- Gebruik
@app.websocket()om eindpunten te definiëren. - Gebruik altijd
await websocket.accept()om de verbinding tot stand te brengen. - Handel verbroken verbindingen af met
try...except WebSocketDisconnect. - Gebruik
await websocket.receive_text()enawait websocket.send_text()voor communicatie. - Voor gestructureerde gegevens zijn
send_json()enreceive_json()handig.
Vervolgens bouw je een realtime-chattoepassing om deze concepten in de praktijk te brengen!
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 implementeren in FastAPI” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “WebSockets implementeren in FastAPI”, 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 implementeren in FastAPI”?
Leer WebSocket-endpoints aan uw FastAPI-applicatie toevoegen en verbindingen beheren. 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 2 van 4.
Hoe lang duurt de les “WebSockets implementeren in FastAPI”?
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
- De basis van het WebSocket-protocol
- WebSockets implementeren in FastAPI
- Een realtime chatapplicatie bouwen
- WebSockets schalen met een pub/sub-backplane