I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione. Per saperne di più.

La creazione di un'API REST è spesso un'attività meccanica, che comporta un sacco di progettazione standard e programmazione meccanica. Per fortuna, strumenti come FastAPI possono alleviare molti noiosi dettagli.

Utilizzando FastAPI, puoi creare rapidamente un'API REST efficiente e completa per la tua applicazione CRUD. Con MongoDB come origine dati, questo tutorial ti guiderà verso la configurazione della tua API in pochissimo tempo.

Che cos'è FastAPI?

API veloce è un framework web Python veloce e open source per la creazione di API. Fornisce supporto integrato per richieste asincrone, convalida automatica dei dati e documentazione automatica degli endpoint API.

I vantaggi di FastAPI rispetto ad altri framework Python

  • FastAPI è relativamente più veloce di altri framework come Django e Flask. Questo perché FastAPI si basa su asyncio, una libreria I/O asincrona per Python in grado di elaborare richieste simultanee più rapidamente.
    instagram viewer
  • FastAPI fornisce un modo pulito e semplice per creare API con il minimo sforzo poiché richiede meno codice rispetto a Flask o Django.
  • Infine, FastAPI semplifica la generazione della documentazione per gli endpoint. Utilizza Swagger per produrre la documentazione che puoi utilizzare per testare gli endpoint eseguendo richieste e visualizzando le risposte.

Imposta un database MongoDB

Per iniziare, dovrai farlo configurare il database MongoDB in locale. In alternativa, puoi optare per l'opzione più semplice di configurare un cluster MongoDB nel Cloud.

Quindi, utilizzando lo strumento dell'interfaccia utente grafica MongoDB installato, Compass, creare una connessione al database. Clicca il Nuova connessione pulsante e fornire l'URI di connessione per stabilire una connessione con il server MongoDB in esecuzione in locale.

Infine, crea un nuovo database e una nuova raccolta per conservare i dati dell'API di test.

Configura un server FastAPI

Usando un terminale, crea una cartella di progetto e inserisci quella nuova directory.

Puoi trovare il codice di questo progetto nel suo file Deposito GitHub.

Quindi, verifica di eseguire Python versione 3.6+. In caso contrario, installa l'ultima versione Pitone versione.

python --versione

Successivamente, installa Virtualenv per creare un ambiente di sviluppo virtuale isolato. Questo è altamente raccomandato perché ti consente di evitare conflitti, soprattutto se stai utilizzando versioni diverse di pacchetti per progetti diversi.

pip installa virtualenv

Quindi, crea un ambiente virtuale chiamato "venv" all'interno della tua directory corrente:

virtualenv venv

Infine, attiva l'ambiente virtuale.

# Su Unix o MacOS: 
sorgente venv/bin/activate
# Su Windows:
 .\venv\Scripts\activate

Dopo aver configurato l'ambiente virtuale, installa i pacchetti FastAPI, PyMongo e Uvicorn.

pip installa fastapi pymongo uvicorn

PyMongo è una libreria basata su Python per lavorare con il database MongoDB. Fornisce un'API che supporta tutte le funzionalità di MongoDB e ti consente di interagire con MongoDB senza dover scrivere query MongoDB non elaborate.

Uvicorn, invece, è un web server asincrono basato sul modulo Python asyncio. La sua caratteristica principale è ricaricare a caldo i tuoi server FastAPI mentre sei in movimento. Usando Uvicorn, è simile a lavorando con Nodemon.

Creare il server FastAPI

Infine, crea un semplice server FastAPI che ascolta le richieste provenienti dalla home route. Nella directory principale della cartella del progetto, crea un file server.py e aggiungi il codice seguente.

da fastapi importare API veloce
app = FastAPI()
@app.get("/")
asincronodefcasa():
ritorno {"Messaggio": "Ciao mondo"}

Infine, esegui il comando seguente per avviare il server di sviluppo. Uvicorn servirà la tua applicazione sulla porta 8000.

server uvicon: app --reload

Vai avanti e visualizza la risposta del server sul tuo browser all'indirizzo http://localhost: 8000.

Crea l'API REST con le operazioni CRUD

Ora crea l'API REST che implementa i metodi CRUD (crea, leggi, aggiorna ed elimina). Nella directory principale della cartella del progetto, crea quattro cartelle: config, models, route e schemi.

├── config
├── modelli
├── percorsi
├── schemi
└── server.py

1. Configurare la connessione al database

Nella directory config, crea un nuovo file, db.py, e aggiungi il codice qui sotto.

da pymongo importare MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_connection.database_name
raccolta = db["nome_raccolta"]
  • Usa il metodo MongoClient() per creare una connessione a un database MongoDB. Accetta una stringa URI di connessione come argomento che specifica l'host e la porta del server MongoDB.
  • Le due variabili specificano a quale database e raccolta nel server MongoDB deve accedere il server.

2. Definire un modello di dati

Questo modello definirà la struttura dei tuoi dati nel database inclusi i campi e i tipi di dati.

Nella directory del modello, crea un nuovo file, user_model.py, e aggiungi il codice seguente.

da pidantico importare BaseModel 
classeUtente(Modello base):
 nome: str
 ruolo: str
  • Il codice sopra crea una classe chiamata User, che è una sottoclasse della classe BaseModel dalla libreria Pydantic. La classe User ha due campi, name e role con i loro tipi di dati impostati su stringhe.
  • Puoi utilizzare la libreria Pydantic con FastAPI per creare modelli di dati. Puoi anche usarlo per convalidare i dati, serializzarli (da JSON a Python) e deserializzarli (da Python a JSON).

3. Definire uno schema di dati

Dal modello di dati creato, puoi definire lo schema per i tuoi dati. Nella directory degli schemi, crea un nuovo file: user_schema.py e aggiungi il codice seguente.

defuser_serializer(utente) -> dettato:
ritorno {
'id':str (utente["_id"]),
'nome':utente["nome"],
'ruolo':utente["ruolo"]
 }
defutenti_serializzatore(utenti) -> elenco:
ritorno [user_serializer (utente) per utente In utenti]

4. Definire le rotte API

Infine, definisci i percorsi per le diverse operazioni CRUD.

Nella directory route, crea un nuovo file: user_routes.py e aggiungi il codice seguente.

Aggiungi dati con il metodo Post

Crea il percorso post per aggiungere dati.

da fastapi importare APIRouter
da modelli.modello_utente importare Utente
da schemi.user_schema importare utenti_serializzatore
da bson importare ID oggetto
da config.db importare collezione
utente = APIRouter()
@utente.post("/")
asincronodefcreare un utente(utente: utente):
 _id = collection.insert_one (dict (utente))
 utente = users_serializer (raccolta.find({"_id": _id.inserted_id}))
ritorno {"stato": "OK","dati": utente}
  • FastAPI fornisce il metodo APIRouter() che definisce un oggetto router che fornisce un'interfaccia per effettuare richieste API a un server.
  • Specificare un post-route che crea un nuovo oggetto utente nel database inserendo i dati nella raccolta dopo averla serializzata. Successivamente, archivia e passa l'id_inserito per trovare i dati associati nella raccolta e, infine, restituisci uno stato "Ok" con i dati nella risposta, se la richiesta di pubblicazione ha esito positivo.
  • I metodi insert_one e find sono definiti dal client PyMongo.

Ora, aggiungi il codice seguente a server.py per inizializzare i percorsi.

da percorsi.percorsi_utente importare utente
app.include_router (utente)

Vai avanti e prova il percorso del post sul tuo browser utilizzando lo strumento API dell'interfaccia utente di Swagger fornito da FastAPI.

Leggere i dati con il metodo Get

Dopo aver definito il percorso post e aver inizializzato i percorsi, definire il resto degli altri percorsi.

@utente.get("/")
asincronodeffind_all_users():
 utenti = utenti_serializzatore (raccolta.find())
ritorno {"stato": "OK","dati": utenti}

@utente.get("/{id}")
asincronodefget_one_user(id: str):
 utente = users_serializer (raccolta.find({"_id": ObjectId (id)}))
ritorno {"stato": "OK","dati": utente}

Definire due percorsi di acquisizione che recuperano tutti i dati nella raccolta e recuperano dati specifici dalla raccolta in base all'ID.

Aggiornare i dati con il metodo Put

Creare il percorso put per aggiornare i dati archiviati nel database.

@utente.put("/{id}")
asincronodefupdate_user(id: str, utente: Utente):
 collection.find_one_and_update(
 {
"_id": IDoggetto (id)
 }, 
 {
"$insieme": dict (utente)
 })
 utente = users_serializer (raccolta.find({"_id": ObjectId (id)}))
ritorno {"stato": "OK","dati": utente}

Il metodo put utilizza l'ID per trovare i dati specifici nella raccolta e aggiorna il valore dei campi nel documento con i nuovi dati passati dall'API. Puoi quindi cercare i dati aggiornati in base all'ID e restituirli nella risposta API.

Elimina i dati con il metodo di eliminazione

Creare il percorso di eliminazione per eliminare i dati archiviati nel database.

@user.delete("/{id}")
asincronodefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 utenti = utenti_serializzatore (raccolta.find())
ritorno {"stato": "OK","dati": []}

Il percorso di eliminazione include l'ID del documento specifico che desideri eliminare dalla raccolta.

Crea API REST con FastAPI

FastAPI offre un ottimo modo per creare comodamente API Web Python di back-end. I suoi strumenti integrati per l'integrazione del database e la produzione automatica di API rendono il processo semplice.

Puoi anche fare un ulteriore passo avanti e creare app complete. Prova a integrare un client front-end utilizzando tecnologie popolari come React, Angular o Vue.