Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon. Les mer.

Å bygge et REST API er ofte en mekanisk oppgave, som involverer massevis av kjeledesign og rote-programmering. Heldigvis kan verktøy som FastAPI avlaste mye av de kjedelige detaljene.

Ved å bruke FastAPI kan du raskt bygge en effektiv, komplett REST API for CRUD-applikasjonen din. Med MongoDB som datakilde, vil denne opplæringen guide deg mot å sette opp din egen API på kort tid.

Hva er FastAPI?

FastAPI er et raskt og åpen kildekode Python-nettverk for å bygge APIer. Den gir innebygd støtte for asynkrone forespørsler, automatisk validering av data og automatisk dokumentasjon av API-endepunkter.

Fordelene med FastAPI fremfor andre Python-rammer

  • FastAPI er relativt raskere enn andre rammeverk som Django og Flask. Dette er fordi FastAPI bygger på toppen av asyncio, et asynkront I/O-bibliotek for Python som kan behandle samtidige forespørsler raskere.
    • instagram viewer
  • FastAPI gir en ren og enkel måte å bygge APIer med minimal innsats siden den krever mindre kode enn Flask eller Django.
  • Til slutt gjør FastAPI det enkelt å generere dokumentasjon for endepunkter. Den bruker Swagger til å produsere dokumentasjon som du kan bruke til å teste endepunkter ved å kjøre forespørsler og se svar.

Sett opp en MongoDB-database

For å komme i gang må du sette opp MongoDB-database lokalt. Alternativt kan du velge det enklere alternativet sette opp en MongoDB-klynge i skyen.

Deretter, ved å bruke det installerte MongoDB grafiske brukergrensesnittverktøyet, Compass, oppretter du en databasetilkobling. Klikk på Ny tilkobling knappen og oppgi tilkoblings-URI for å etablere en forbindelse med MongoDB-serveren som kjører lokalt.

Til slutt oppretter du en ny database og samling for å holde test-API-dataene dine.

Sett opp en FastAPI-server

Bruk en terminal, opprett en prosjektmappe og skriv inn den nye katalogen.

Du kan finne dette prosjektets kode i sin GitHub-depot.

Deretter kontrollerer du at du kjører Python versjon 3.6+. Hvis ikke, installer den nyeste Python versjon.

python --versjon

Installer deretter Virtualenv for å lage et isolert virtuelt utviklingsmiljø. Dette anbefales sterkt fordi det lar deg unngå konflikter, spesielt hvis du bruker forskjellige versjoner av pakker for forskjellige prosjekter.

pip installer virtualenv

Deretter oppretter du et virtuelt miljø kalt "venv" i din nåværende katalog:

virtualenv venv

Til slutt, aktiver det virtuelle miljøet.

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

Når du har konfigurert det virtuelle miljøet, installer FastAPI-, PyMongo- og Uvicorn-pakkene.

pip installer fastapi pymongo uvicorn

PyMongo er et Python-basert bibliotek for arbeid med MongoDB-databasen. Det gir en API som støtter alle funksjonene til MongoDB og lar deg samhandle med MongoDB uten å måtte skrive rå MongoDB-spørringer.

Uvicorn, derimot, er en asynkron webserver basert på Python asyncio-modulen. Hovedfunksjonen er varm omlasting av FastAPI-serverne mens du er på farten. Å bruke Uvicorn, ligner på jobber med Nodemon.

Opprett FastAPI-serveren

Til slutt, lag en enkel FastAPI-server som lytter for å få forespørsler som kommer fra hjemmeruten. Opprett en server.py-fil i rotkatalogen til prosjektmappen din og legg til koden nedenfor.

fra fastapi import FastAPI
app = FastAPI()
@app.get("/")
asynkrondefhjem():
komme tilbake {"beskjed": "Hei Verden"}

Til slutt, kjør kommandoen nedenfor for å spinne opp utviklingsserveren. Uvicorn vil servere søknaden din på port 8000.

uvicon server: app -- last på nytt

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

Lag REST API med CRUD-operasjoner

Bygg nå REST API som implementerer CRUD-metodene (opprett, les, oppdater og slett). Opprett fire mapper i rotkatalogen til prosjektmappen: konfigurasjon, modeller, ruter og skjemaer.

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

1. Konfigurer databasetilkoblingen

I konfigurasjonskatalogen, opprett en ny fil, db.py, og legg til koden nedenfor.

fra pymongo import MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_tilkobling.databasenavn
samling = db["samlingsnavn"]
  • Bruk MongoClient()-metoden for å opprette en tilkobling til en MongoDB-database. Den tar inn en tilkoblings-URI-streng som et argument som spesifiserer verten og porten til MongoDB-serveren.
  • De to variablene spesifiserer hvilken database og samling i MongoDB-serveren serveren skal ha tilgang til.

2. Definer en datamodell

Denne modellen vil definere strukturen til dataene dine i databasen, inkludert feltene og datatypene.

I modellkatalogen oppretter du en ny fil, user_model.py, og legger til koden nedenfor.

fra pydantisk import BaseModel 
klasseBruker(BaseModel):
 navn: str
 rolle: str
  • Koden ovenfor oppretter en klasse kalt User, som er en underklasse av BaseModel-klassen fra Pydantic-biblioteket. Brukerklassen har to felt, navn og rolle med datatypene satt til strenger.
  • Du kan bruke Pydantic-biblioteket med FastAPI for å lage datamodeller. Du kan også bruke den til å validere data, serialisere dem (JSON til Python) og de-serialisere dem (Python til JSON).

3. Definer et dataskjema

Fra den opprettede datamodellen kan du definere skjemaet for dataene dine. Opprett en ny fil i skjemakatalogen: user_schema.py, og legg til koden nedenfor.

defuser_serializer(bruker) -> dikt:
komme tilbake {
'id':str (bruker["_id"]),
'Navn':bruker["Navn"],
'rolle':bruker["rolle"]
 }
defusers_serializer(brukere) -> liste:
komme tilbake [user_serializer (bruker) til bruker i brukere]

4. Definer API-rutene

Definer til slutt rutene for de forskjellige CRUD-operasjonene.

Opprett en ny fil i rutekatalogen: user_routes.py, og legg til koden nedenfor.

Legg til data med postmetoden

Opprett innleggsruten for å legge til data.

fra fastapi import APIRouter
fra models.user_model import Bruker
fra schemas.user_schema import users_serializer
fra bson import ObjectId
fra config.db import samling
bruker = APIRouter()
@bruker.post("/")
asynkrondefOpprett bruker(bruker: bruker):
 _id = collection.insert_one (dict (bruker))
 user = users_serializer (collection.find({"_id": _id.inserted_id}))
komme tilbake {"status": "Ok","data": bruker}
  • FastAPI gir APIRouter()-metoden som definerer et ruterobjekt som gir et grensesnitt for å sende API-forespørsler til en server.
  • Spesifiser en postrute som oppretter et nytt brukerobjekt i databasen ved å sette inn dataene i samlingen etter serialisering. Deretter lagrer og sender du inserted_id for å finne tilknyttede data i samlingen, og til slutt returnerer du statusen "Ok" med dataene i svaret, hvis postforespørselen er vellykket.
  • Insert_one og find-metodene er definert av PyMongo-klienten.

Legg nå til koden nedenfor til server.py for å initialisere rutene.

fra ruter.brukerruter import bruker
app.include_router (bruker)

Gå videre og test ut postruten i nettleseren din ved å bruke Swagger UI API-verktøyet levert av FastAPI.

Les data med Get-metoden

Etter å ha definert postruten og initialisert rutene, definer resten av de andre rutene.

@bruker.get("/")
asynkrondeffinn_alle_brukere():
 users = users_serializer (collection.find())
komme tilbake {"status": "Ok","data": brukere}

@user.get("/{id}")
asynkrondefget_one_user(id: str):
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
komme tilbake {"status": "Ok","data": bruker}

Definer to get-ruter som henter alle dataene i samlingen og henter spesifikke data fra samlingen basert på ID.

Oppdater data med Put-metoden

Opprett puteruten for å oppdatere de lagrede dataene i databasen.

@user.put("/{id}")
asynkrondefupdate_user(id: str, bruker: bruker):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dict (bruker)
 })
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
komme tilbake {"status": "Ok","data": bruker}

Put-metoden bruker IDen til å finne de spesifikke dataene i samlingen og oppdaterer verdien av feltene i dokumentet med de nye dataene som sendes fra APIen. Du kan deretter søke etter de oppdaterte dataene etter ID og returnere dem i API-svaret.

Slett data med slettemetoden

Opprett sletteruten for å slette de lagrede dataene i databasen.

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

Sletteruten tar inn IDen til det spesifikke dokumentet du ønsker å slette fra samlingen.

Lag REST APIer med FastAPI

FastAPI gir en flott måte å enkelt bygge backend Python web-APIer. Dens innebygde verktøy for databaseintegrasjon og automatisk API-produksjon gjør prosessen enkel.

Du kan til og med ta dette et skritt videre og bygge fullverdige apper. Prøv å integrere en front-end-klient ved å bruke populære teknologier som React, Angular eller Vue.