Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission. Læs mere.

At bygge en REST API er ofte en mekanisk opgave, der involverer masser af kedeldesign og udenadsprogrammering. Heldigvis kan værktøjer som FastAPI afhjælpe en masse af de kedelige detaljer.

Ved hjælp af FastAPI kan du hurtigt bygge en effektiv, komplet REST API til din CRUD-applikation. Med MongoDB som datakilde, vil denne tutorial guide dig mod opsætning af din egen API på ingen tid.

Hvad er FastAPI?

FastAPI er en hurtig og open source Python-webramme til opbygning af API'er. Det giver indbygget support til asynkrone anmodninger, automatisk validering af data og automatisk dokumentation af API-endepunkter.

Fordelene ved FastAPI i forhold til andre Python-rammer

  • FastAPI er relativt hurtigere end andre frameworks som Django og Flask. Dette skyldes, at FastAPI bygger oven på asyncio, et asynkront I/O-bibliotek til Python, der kan behandle samtidige anmodninger hurtigere.
    • instagram viewer
  • FastAPI giver en ren og enkel måde at bygge API'er på med minimal indsats, da det kræver mindre kode end Flask eller Django.
  • Endelig gør FastAPI det nemt at generere dokumentation til slutpunkter. Den bruger Swagger til at producere dokumentation, som du kan bruge til at teste slutpunkter ved at køre anmodninger og se svar.

Opsæt en MongoDB-database

For at komme i gang skal du opsætte MongoDB Database lokalt. Alternativt kan du vælge den nemmere mulighed opsætning af en MongoDB-klynge i skyen.

Brug derefter det installerede MongoDB grafiske brugergrænsefladeværktøj, Compass, til at oprette en databaseforbindelse. Klik på Ny forbindelse knappen og angiv forbindelses-URI'en for at etablere en forbindelse med MongoDB-serveren, der kører lokalt.

Til sidst skal du oprette en ny database og samling til at opbevare dine test API-data.

Konfigurer en FastAPI-server

Brug en terminal til at oprette en projektmappe, og indtast den nye mappe.

Du kan finde dette projekts kode i dens GitHub-depot.

Derefter skal du kontrollere, at du kører Python version 3.6+. Hvis ikke, installer den nyeste Python version.

python --version

Installer derefter Virtualenv for at skabe et isoleret virtuelt udviklingsmiljø. Dette anbefales stærkt, fordi det giver dig mulighed for at undgå konflikter, især hvis du bruger forskellige versioner af pakker til forskellige projekter.

pip installer virtualenv

Opret derefter et virtuelt miljø kaldet "venv" i din nuværende mappe:

virtualenv venv

Til sidst skal du aktivere det virtuelle miljø.

# På Unix eller MacOS: 
kilde venv/bin/activate
# På Windows:
 .\venv\Scripts\aktiver

Når du har konfigureret det virtuelle miljø, skal du installere FastAPI-, PyMongo- og Uvicorn-pakkerne.

pip installer fastapi pymongo uvicorn

PyMongo er et Python-baseret bibliotek til at arbejde med MongoDB-databasen. Det giver en API, der understøtter alle funktionerne i MongoDB og giver dig mulighed for at interagere med MongoDB uden at skulle skrive rå MongoDB-forespørgsler.

Uvicorn er på den anden side en asynkron webserver baseret på Python asyncio-modulet. Dens hovedfunktion er varm genindlæsning af dine FastAPI-servere på farten. Brug af Uvicorn, ligner arbejder med Nodemon.

Opret FastAPI-serveren

Til sidst skal du oprette en simpel FastAPI-server, der lytter for at få anmodninger, der kommer fra hjemmeruten. I rodmappen til din projektmappe skal du oprette en server.py-fil og tilføje koden nedenfor.

fra fastapi importere FastAPI
app = FastAPI()
@app.get("/")
asynkrondefhjem():
Vend tilbage {"besked": "Hej Verden"}

Til sidst skal du køre kommandoen nedenfor for at skrue udviklingsserveren op. Uvicorn serverer din ansøgning på port 8000.

uvicon server: app --genindlæs

Gå videre og se serversvaret i din browser på http://localhost: 8000.

Opret REST API'et med CRUD Operations

Byg nu REST API, der implementerer CRUD-metoderne (opret, læs, opdater og slet). I rodmappen til din projektmappe skal du oprette fire mapper: config, modeller, ruter og skemaer.

├── konfig
├── modeller
├── ruter
├── skemaer
└── server.py

1. Konfigurer databaseforbindelsen

I config-mappen skal du oprette en ny fil, db.py, og tilføje koden nedenfor.

fra pymongo importere MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_forbindelse.databasenavn
samling = db["samlingsnavn"]
  • Brug MongoClient()-metoden til at oprette en forbindelse til en MongoDB-database. Den tager en forbindelses URI-streng ind som et argument, der angiver værten og porten på MongoDB-serveren.
  • De to variabler angiver hvilken database og samling i din MongoDB-server serveren skal have adgang til.

2. Definer en datamodel

Denne model vil definere strukturen af ​​dine data i databasen, herunder felter og datatyper.

I modelbiblioteket skal du oprette en ny fil, user_model.py, og tilføje koden nedenfor.

fra pydantisk importere Basismodel 
klasseBruger(BaseModel):
 navn: str
 rolle: str
  • Koden ovenfor opretter en klasse kaldet User, som er en underklasse af BaseModel-klassen fra Pydantic-biblioteket. Brugerklassen har to felter, navn og rolle med deres datatyper sat til strenge.
  • Du kan bruge Pydantic-biblioteket med FastAPI til at oprette datamodeller. Du kan også bruge den til at validere data, serialisere dem (JSON til Python) og de-serialisere dem (Python til JSON).

3. Definer et dataskema

Fra den oprettede datamodel kan du definere skemaet for dine data. I skemabiblioteket skal du oprette en ny fil: user_schema.py, og tilføje koden nedenfor.

defuser_serializer(bruger) -> dikt:
Vend tilbage {
'id':str (bruger["_id"]),
'navn':bruger["navn"],
'rolle':bruger["rolle"]
 }
defusers_serializer(brugere) -> liste:
Vend tilbage [user_serializer (bruger) til bruger i brugere]

4. Definer API-ruterne

Til sidst definerer du ruterne for de forskellige CRUD-operationer.

I rutebiblioteket skal du oprette en ny fil: user_routes.py, og tilføje koden nedenfor.

Tilføj data med postmetoden

Opret postruten for at tilføje data.

fra fastapi importere APIRouter
fra models.user_model importere Bruger
fra skemaer.brugerskema importere users_serializer
fra bson importere ObjectId
fra config.db importere kollektion
bruger = APIRouter()
@bruger.post("/")
asynkrondefoprette_bruger(bruger: Bruger):
 _id = collection.insert_one (dict (bruger))
 user = users_serializer (collection.find({"_id": _id.inserted_id}))
Vend tilbage {"status": "Okay","data": bruger}
  • FastAPI leverer APIRouter()-metoden, der definerer et routerobjekt, som giver en grænseflade til at lave API-anmodninger til en server.
  • Angiv en postrute, der opretter et nyt brugerobjekt i databasen ved at indsætte dataene i samlingen efter serialisering. Gem og videregiv derefter inserted_id for at finde de tilknyttede data i samlingen, og returner til sidst statussen "Ok" med dataene i svaret, hvis postanmodningen er vellykket.
  • Metoderne insert_one og find er defineret af PyMongo-klienten.

Tilføj nu koden nedenfor til server.py for at initialisere ruterne.

fra ruter.bruger_ruter importere bruger
app.include_router (bruger)

Gå videre og test postruten i din browser ved hjælp af Swagger UI API-værktøjet leveret af FastAPI.

Læs data med Get-metoden

Efter at have defineret post-ruten og initialiseret ruterne, skal du definere resten af ​​de andre ruter.

@bruger.get("/")
asynkrondeffind_alle_brugere():
 brugere = users_serializer (collection.find())
Vend tilbage {"status": "Okay","data": brugere}

@bruger.get("/{id}")
asynkrondefget_one_user(id: str):
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
Vend tilbage {"status": "Okay","data": bruger}

Definer to get-ruter, der henter alle data i samlingen og henter specifikke data fra samlingen baseret på ID'et.

Opdater data med putmetoden

Opret put-ruten for at opdatere de lagrede data i databasen.

@bruger.put("/{id}")
asynkrondefupdate_user(id: str, bruger: Bruger):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dict (bruger)
 })
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
Vend tilbage {"status": "Okay","data": bruger}

Put-metoden bruger ID'et til at finde de specifikke data i samlingen og opdaterer værdien af ​​felterne i dokumentet med de nye data, der sendes fra API'en. Du kan derefter søge efter de opdaterede data efter ID og returnere dem i API-svaret.

Slet data med slettemetoden

Opret sletteruten for at slette de lagrede data i databasen.

@user.delete("/{id}")
asynkrondefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 brugere = users_serializer (collection.find())
Vend tilbage {"status": "Okay","data": []}

Sletteruten tager ID'et på det specifikke dokument, du vil slette fra samlingen.

Opret REST API'er med FastAPI

FastAPI giver en fantastisk måde til bekvemt at bygge backend Python web-API'er. Dens indbyggede værktøjer til databaseintegration og automatisk API-produktion gør processen enkel.

Du kan endda tage dette et skridt videre og bygge fuldgyldige apps. Prøv at integrere en front-end-klient ved hjælp af populære teknologier som React, Angular eller Vue.