Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

Het bouwen van een REST API is vaak een mechanische taak, waarbij veel standaardontwerp en rote-programmering betrokken zijn. Gelukkig kunnen tools zoals FastAPI veel van de vervelende details verlichten.

Met FastAPI bouwt u snel een efficiënte, complete REST API voor uw CRUD-applicatie. Met MongoDB als gegevensbron, zal deze tutorial u helpen om in een mum van tijd uw eigen API op te zetten.

Wat is FastAPI?

Snelle API is een snel en open-source Python-webframework voor het bouwen van API's. Het biedt ingebouwde ondersteuning voor asynchrone verzoeken, automatische validatie van gegevens en automatische documentatie van API-eindpunten.

De voordelen van FastAPI ten opzichte van andere Python-frameworks

  • FastAPI is relatief sneller dan andere frameworks zoals Django en Flask. Dit komt doordat FastAPI voortbouwt op asyncio, een asynchrone I/O-bibliotheek voor Python die gelijktijdige verzoeken sneller kan verwerken.
    • instagram viewer
  • FastAPI biedt een schone en eenvoudige manier om met minimale inspanning API's te bouwen, omdat er minder code voor nodig is dan Flask of Django.
  • Ten slotte maakt FastAPI het gemakkelijk om documentatie voor endpoints te genereren. Het gebruikt Swagger om documentatie te produceren die u kunt gebruiken om eindpunten te testen door verzoeken uit te voeren en antwoorden te bekijken.

Zet een MongoDB-database op

Om te beginnen, moet u MongoDB Database lokaal opzetten. U kunt ook kiezen voor de gemakkelijkere optie van het opzetten van een MongoDB-cluster in de Cloud.

Maak vervolgens met behulp van de geïnstalleerde grafische gebruikersinterface van MongoDB, Compass, een databaseverbinding. Klik op de Nieuwe verbinding knop en geef de verbindings-URI op om een ​​verbinding tot stand te brengen met de MongoDB-server die lokaal draait.

Maak ten slotte een nieuwe database en verzameling om uw test-API-gegevens te bewaren.

Stel een FastAPI-server in

Maak met behulp van een terminal een projectmap en voer die nieuwe map in.

U kunt de code van dit project vinden in de bijbehorende GitHub-opslagplaats.

Controleer vervolgens of u Python versie 3.6+ gebruikt. Zo niet, installeer dan de nieuwste Python versie.

python --versie

Installeer daarna Virtualenv om een ​​geïsoleerde virtuele ontwikkelomgeving te creëren. Dit wordt ten zeerste aanbevolen omdat u hierdoor conflicten kunt vermijden, vooral als u verschillende versies van pakketten voor verschillende projecten gebruikt.

pip virtualenv installeren

Maak vervolgens een virtuele omgeving met de naam "venv" in uw huidige map:

virtualenv venv

Activeer ten slotte de virtuele omgeving.

# Op Unix of MacOS: 
source venv/bin/activeren
# Op Windows:
 .\venv\Scripts\activeren

Nadat u de virtuele omgeving hebt geconfigureerd, installeert u de FastAPI-, PyMongo- en Uvicorn-pakketten.

pip installeer fastapi pymongo uvicorn

PyMongo is een op Python gebaseerde bibliotheek voor het werken met de MongoDB-database. Het biedt een API die alle functies van MongoDB ondersteunt en waarmee u met MongoDB kunt communiceren zonder onbewerkte MongoDB-query's te hoeven schrijven.

Uvicorn daarentegen is een asynchrone webserver gebaseerd op de Python asyncio-module. Het belangrijkste kenmerk is het onderweg herladen van uw FastAPI-servers. Het gebruik van Uvicorn is vergelijkbaar met werken met Nodemon.

Maak de FastAPI-server

Maak ten slotte een eenvoudige FastAPI-server die luistert om verzoeken te ontvangen die afkomstig zijn van de thuisroute. Maak in de hoofdmap van uw projectmap een server.py-bestand en voeg de onderstaande code toe.

van snel importeren Snelle API
app = SnelleAPI()
@app.get("/")
asynchroondefthuis():
opbrengst {"bericht": "Hallo Wereld"}

Voer ten slotte de onderstaande opdracht uit om de ontwikkelingsserver te laten draaien. Uvicorn zal uw applicatie bedienen op poort 8000.

uvicon-server: app --reload

Ga je gang en bekijk de serverreactie in je browser op http://localhost: 8000.

Maak de REST API met CRUD-bewerkingen

Bouw nu de REST API die de CRUD-methoden implementeert (maken, lezen, bijwerken en verwijderen). Maak in de hoofdmap van uw projectmap vier mappen: config, modellen, routes en schema's.

├── configuratie
├── modellen
├── routes
├── schema's
└── server.py

1. Configureer de databaseverbinding

Maak in de configuratiemap een nieuw bestand, db.py, en voeg de onderstaande code toe.

van pymongo importeren MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_verbinding.databasenaam
verzameling = db["collectie_naam"]
  • Gebruik de methode MongoClient() om een ​​verbinding met een MongoDB-database te maken. Het neemt een verbindings-URI-tekenreeks op als argument dat de host en poort van de MongoDB-server specificeert.
  • De twee variabelen specificeren tot welke database en verzameling in uw MongoDB-server de server toegang moet hebben.

2. Definieer een gegevensmodel

Dit model definieert de structuur van uw gegevens in de database, inclusief de velden en gegevenstypen.

Maak in de modeldirectory een nieuw bestand, user_model.py, en voeg de onderstaande code toe.

van pydantisch importeren BasisModel 
klasGebruiker(basismodel):
 naam: str
 rol: str
  • De bovenstaande code maakt een klasse met de naam User, een subklasse van de BaseModel-klasse uit de Pydantic-bibliotheek. De klasse User heeft twee velden, naam en rol, waarvan de gegevenstypen zijn ingesteld op tekenreeksen.
  • U kunt de Pydantic-bibliotheek met FastAPI gebruiken om datamodellen te maken. U kunt het ook gebruiken om gegevens te valideren, te serialiseren (JSON naar Python) en te deserialiseren (Python naar JSON).

3. Definieer een gegevensschema

Vanuit het gemaakte gegevensmodel kunt u het schema voor uw gegevens definiëren. Maak in de map schemas een nieuw bestand: user_schema.py en voeg de onderstaande code toe.

defgebruiker_serializer(gebruiker) -> dicteren:
opbrengst {
'ID kaart':str (gebruiker["_ID kaart"]),
'naam':gebruiker["naam"],
'rol':gebruiker["rol"]
 }
defgebruikers_serializer(gebruikers) -> lijst:
opbrengst [gebruiker_serializer (gebruiker) voor gebruiker in gebruikers]

4. Definieer de API-routes

Definieer ten slotte de routes voor de verschillende CRUD-operaties.

Maak in de map routes een nieuw bestand: user_routes.py en voeg de onderstaande code toe.

Voeg gegevens toe met de postmethode

Maak de postroute om gegevens toe te voegen.

van snel importeren APIRouter
van modellen.gebruiker_model importeren Gebruiker
van schema's.user_schema importeren gebruikers_serializer
van bzoon importeren Object-ID
van config.db importeren verzameling
gebruiker = APIRouter()
@gebruiker.post("/")
asynchroondefmaak_gebruiker(gebruiker: Gebruiker):
 _id = verzameling.insert_one (dict (gebruiker))
 gebruiker = gebruikers_serializer (verzameling.zoeken({"_ID kaart": _id.ingevoegd_id}))
opbrengst {"toestand": "OK","gegevens": gebruiker}
  • FastAPI biedt de methode APIRouter() die een routerobject definieert dat een interface biedt om API-verzoeken aan een server te doen.
  • Geef een postroute op die een nieuw gebruikersobject in de database maakt door de gegevens in de verzameling in te voegen nadat deze zijn geserialiseerd. Sla vervolgens de insert_id op en geef deze door om de geassocieerde gegevens in de verzameling te vinden, en retourneer ten slotte de status "Ok" met de gegevens in het antwoord, als het postverzoek succesvol is.
  • De methoden insert_one en find worden gedefinieerd door de PyMongo-client.

Voeg nu de onderstaande code toe aan de server.py om de routes te initialiseren.

van routes.user_routes importeren gebruiker
app.include_router (gebruiker)

Ga je gang en test de postroute in je browser met behulp van de Swagger UI API-tool van FastAPI.

Gegevens lezen met de Get-methode

Nadat u de postroute hebt gedefinieerd en de routes hebt geïnitialiseerd, definieert u de rest van de andere routes.

@gebruiker.get("/")
asynchroondefvind_alle_gebruikers():
 gebruikers = gebruikers_serializer (verzameling.zoeken())
opbrengst {"toestand": "OK","gegevens": gebruikers}

@gebruiker.get("/{id}")
asynchroondefget_one_user(id: str):
 gebruiker = gebruikers_serializer (verzameling.zoeken({"_ID kaart": ObjectId (id)}))
opbrengst {"toestand": "OK","gegevens": gebruiker}

Definieer twee get-routes die alle gegevens in de verzameling ophalen en specifieke gegevens uit de verzameling ophalen op basis van de ID.

Gegevens bijwerken met de Put-methode

Maak de putroute om de opgeslagen gegevens in de database bij te werken.

@gebruiker.put("/{id}")
asynchroondefupdate_gebruiker(id: str, gebruiker: gebruiker):
 collectie.find_one_and_update(
 {
"_ID kaart": ObjectId (id)
 }, 
 {
"$set": dict (gebruiker)
 })
 gebruiker = gebruikers_serializer (verzameling.zoeken({"_ID kaart": ObjectId (id)}))
opbrengst {"toestand": "OK","gegevens": gebruiker}

De put-methode gebruikt de ID om de specifieke gegevens in de verzameling te vinden en werkt de waarde van de velden in het document bij met de nieuwe gegevens die door de API zijn doorgegeven. U kunt vervolgens naar de bijgewerkte gegevens zoeken op ID en deze retourneren in het API-antwoord.

Verwijder gegevens met de verwijdermethode

Maak de verwijderroute om de opgeslagen gegevens in de database te verwijderen.

@gebruiker.delete("/{id}")
asynchroondefVerwijder gebruiker(id: str):
 collectie.find_one_and_delete({"_ID kaart": ObjectId (id)})
 gebruikers = gebruikers_serializer (verzameling.zoeken())
opbrengst {"toestand": "OK","gegevens": []}

De verwijderingsroute neemt de ID in van het specifieke document dat u uit de verzameling wilt verwijderen.

Creëer REST API's met FastAPI

FastAPI biedt een geweldige manier om gemakkelijk backend Python-web-API's te bouwen. De ingebouwde tools voor database-integratie en automatische API-productie maken het proces eenvoudig.

Je kunt zelfs een stap verder gaan en volwaardige apps bouwen. Probeer een front-endclient te integreren met behulp van populaire technologieën zoals React, Angular of Vue.