Hur man skapar ett REST API med FastAPI och MongoDB

Att bygga ett REST-API är ofta en mekanisk uppgift, som involverar massor av design och rote-programmering. Tack och lov kan verktyg som FastAPI avlasta mycket av de tråkiga detaljerna.

Med FastAPI kan du snabbt bygga ett effektivt, komplett REST API för din CRUD-applikation. Med MongoDB som datakälla kommer den här handledningen att guida dig mot att ställa in ditt eget API på nolltid.

Vad är FastAPI?

FastAPI är ett snabbt Python-webbramverk med öppen källkod för att bygga API: er. Det ger inbyggt stöd för asynkrona förfrågningar, automatisk validering av data och automatisk dokumentation av API-slutpunkter.

Fördelarna med FastAPI framför andra Python-ramverk

• FastAPI är relativt snabbare än andra ramverk som Django och Flask. Detta beror på att FastAPI bygger ovanpå asyncio, ett asynkront I/O-bibliotek för Python som kan behandla samtidiga förfrågningar snabbare.
instagram viewer
• FastAPI ger ett rent och enkelt sätt att bygga API: er med minimal ansträngning eftersom det kräver mindre kod än Flask eller Django.
• Slutligen gör FastAPI det enkelt att generera dokumentation för endpoints. Den använder Swagger för att producera dokumentation som du kan använda för att testa slutpunkter genom att köra förfrågningar och visa svar.

Konfigurera en MongoDB-databas

För att komma igång måste du göra det ställ in MongoDB Database lokalt. Alternativt kan du välja det enklare alternativet sätta upp ett MongoDB-kluster i molnet.

Skapa sedan en databasanslutning med det installerade MongoDB grafiska användargränssnittsverktyget Compass. Klicka på Ny anslutning knappen och tillhandahåll anslutnings-URI för att upprätta en anslutning med MongoDB-servern som körs lokalt.

Slutligen, skapa en ny databas och samling för att hålla dina test-API-data.

Konfigurera en FastAPI-server

Använd en terminal, skapa en projektmapp och ange den nya katalogen.

Du kan hitta detta projekts kod i dess GitHub-förråd.

Kontrollera sedan att du kör Python version 3.6+. Om inte, installera den senaste Pytonorm version.

python --version

Installera sedan Virtualenv för att skapa en isolerad virtuell utvecklingsmiljö. Detta rekommenderas starkt eftersom det gör att du kan undvika konflikter, särskilt om du använder olika versioner av paket för olika projekt.

pip installera virtualenv

Skapa sedan en virtuell miljö som heter "venv" i din nuvarande katalog:

virtualenv venv

Slutligen, aktivera den virtuella miljön.

# På Unix eller MacOS: 
source venv/bin/activate
# På Windows:
 .\venv\Scripts\aktivera

När du har konfigurerat den virtuella miljön installerar du FastAPI-, PyMongo- och Uvicorn-paketen.

pip installera fastapi pymongo uvicorn

PyMongo är ett Python-baserat bibliotek för att arbeta med MongoDB-databasen. Det tillhandahåller ett API som stöder alla funktioner i MongoDB och låter dig interagera med MongoDB utan att behöva skriva råa MongoDB-frågor.

Uvicorn, å andra sidan, är en asynkron webbserver baserad på Python asyncio-modulen. Dess huvudsakliga funktion är att ladda om dina FastAPI-servrar när du är på språng. Att använda Uvicorn, liknar arbetar med Nodemon.

Skapa FastAPI-servern

Slutligen, skapa en enkel FastAPI-server som lyssnar på förfrågningar som kommer från hemvägen. Skapa en server.py-fil i rotkatalogen i din projektmapp och lägg till koden nedan.

från fastapi importera FastAPI
app = FastAPI()
@app.get("/")
asynkrondefHem():
lämna tillbaka {"meddelande": "Hej världen"}

Slutligen, kör kommandot nedan för att snurra upp utvecklingsservern. Uvicorn kommer att servera din ansökan på port 8000.

uvicon server: app -- ladda om

Gå vidare och se serversvaret i din webbläsare på http://localhost: 8000.

Skapa REST API med CRUD Operations

Bygg nu REST API som implementerar CRUD-metoderna (skapa, läs, uppdatera och ta bort). Skapa fyra mappar i rotkatalogen i din projektmapp: config, modeller, rutter och scheman.

├── konfig
├── modeller
├── rutter
├── scheman
└── server.py

1. Konfigurera databasanslutningen

Skapa en ny fil, db.py, i config-katalogen och lägg till koden nedan.

från pymongo importera MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_anslutning.databasnamn
samling = db["samlingsnamn"]

• Använd MongoClient()-metoden för att skapa en anslutning till en MongoDB-databas. Den tar in en anslutnings-URI-sträng som ett argument som anger värden och porten för MongoDB-servern.
• De två variablerna anger vilken databas och samling i din MongoDB-server servern ska komma åt.

2. Definiera en datamodell

Denna modell kommer att definiera strukturen för dina data i databasen inklusive fält och datatyper.

Skapa en ny fil i modellkatalogen, user_model.py, och lägg till koden nedan.

från pydantisk importera Basmodell 
klassAnvändare(Basmodell):
 namn: str
 roll: str

• Koden ovan skapar en klass som heter User, som är en underklass till BaseModel-klassen från Pydantic-biblioteket. Användarklassen har två fält, namn och roll med deras datatyper inställda på strängar.
• Du kan använda Pydantic-biblioteket med FastAPI för att skapa datamodeller. Du kan också använda den för att validera data, serialisera den (JSON till Python) och avserialisera den (Python till JSON).

3. Definiera ett dataschema

Från den skapade datamodellen kan du definiera schemat för dina data. Skapa en ny fil i schemakatalogen: user_schema.py och lägg till koden nedan.

defuser_serializer(användare) -> dikt:
lämna tillbaka {
'id':str (användare["_id"]),
'namn':användare["namn"],
'roll':användare["roll"]
 }
defusers_serializer(användare) -> lista:
lämna tillbaka [user_serializer (användare) för användare i användare]

4. Definiera API-rutter

Definiera slutligen rutterna för de olika CRUD-operationerna.

Skapa en ny fil i ruttkatalogen: user_routes.py och lägg till koden nedan.

Lägg till data med postmetoden

Skapa postrutten för att lägga till data.

från fastapi importera APIRouter
från models.user_model importera Användare
från schemas.user_schema importera users_serializer
från bson importera ObjectId
från config.db importera samling
användare = APIRouter()
@user.post("/")
asynkrondefskapa användare(användare: användare):
 _id = collection.insert_one (dict (användare))
 user = users_serializer (collection.find({"_id": _id.inserted_id}))
lämna tillbaka {"status": "Ok","data": användare}

• FastAPI tillhandahåller metoden APIRouter() som definierar ett routerobjekt som tillhandahåller ett gränssnitt för att göra API-förfrågningar till en server.
• Ange en postrutt som skapar ett nytt användarobjekt i databasen genom att infoga data i samlingen efter serialisering. Lagra och skicka sedan inserted_id för att hitta associerade data i samlingen, och slutligen returnera statusen "Ok" med data i svaret, om postbegäran lyckas.
• Metoderna insert_one och find definieras av PyMongo-klienten.

Lägg nu till koden nedan till server.py för att initiera rutterna.

från routes.user_routes importera användare
app.include_router (användare)

Varsågod och testa inläggsrutten i din webbläsare med Swagger UI API-verktyget från FastAPI.

Läs data med Get-metoden

Efter att ha definierat postrutten och initierat rutterna, definiera resten av de andra rutterna.

@användare.get("/")
asynkrondefhitta_alla_användare():
 users = users_serializer (collection.find())
lämna tillbaka {"status": "Ok","data": användare}

@user.get("/{id}")
asynkrondefget_one_user(id: str):
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
lämna tillbaka {"status": "Ok","data": användare}

Definiera två get-rutter som hämtar all data i samlingen och hämtar specifik data från samlingen baserat på ID.

Uppdatera data med putsmetoden

Skapa putsrutten för att uppdatera lagrad data i databasen.

@user.put("/{id}")
asynkrondefupdate_user(id: str, användare: Användare):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dict (användare)
 })
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
lämna tillbaka {"status": "Ok","data": användare}

Put-metoden använder ID: t för att hitta specifika data i samlingen och uppdaterar värdet på fälten i dokumentet med den nya data som skickas från API: et. Du kan sedan söka efter den uppdaterade datan med ID och returnera den i API-svaret.

Ta bort data med raderingsmetoden

Skapa raderingsrutten för att radera lagrad data i databasen.

@user.delete("/{id}")
asynkrondefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 users = users_serializer (collection.find())
lämna tillbaka {"status": "Ok","data": []} 

Raderingsvägen tar in ID: t för det specifika dokument du vill ta bort från samlingen.

Skapa REST API: er med FastAPI

FastAPI ger ett utmärkt sätt att enkelt bygga backend Python webb-API: er. Dess inbyggda verktyg för databasintegration och automatisk API-produktion gör processen enkel.

Du kan till och med ta det här ett steg längre och bygga fullfjädrade appar. Prova att integrera en front-end-klient med populära tekniker som React, Angular eller Vue.