Come costruire un'API REST con il database Flask e Postgres

Le interfacce di programmazione delle applicazioni (API) sono una parte fondamentale della creazione e della connessione di sistemi diversi, consentendo alle tue applicazioni di comunicare e scambiare dati con altri servizi.

Sebbene lo sviluppo back-end riguardi più della semplice scrittura di API, copre anche la scrittura della logica aziendale lato server, la progettazione di un sistema efficiente architetture e altre funzioni chiave, continua a leggere per imparare a creare una semplice API CRUD REST con Flask (un framework Python leggero) e Postgres Banca dati.

Utilizzo di Flask per creare API di back-end

Borraccia è un peso leggero quadro pitone che fornisce una serie di funzionalità per semplificare la scrittura di API back-end per client Web scritti utilizzando diverse tecnologie come React e Angular.

Puoi trovare il codice sorgente di questo progetto in questo Deposito GitHub.

Questa guida ti guiderà attraverso la scrittura di un API REST che implementa le quattro operazioni CRUD: creare, leggere, aggiornare ed eliminare per gestire i dati utente archiviati in un database Postgres.

Imposta un database Postgres

Per iniziare, vai su ElephantSQL, una soluzione di hosting di database basata su cloud che fornisce una piattaforma per creare e gestire database Postgres sul cloud, registrarsi e accedere alla pagina di panoramica del proprio account.

Clicca il Crea nuova istanza pulsante per creare una nuova istanza per la tua applicazione.

Fornisci il nome della tua istanza e seleziona il piano gratuito, quindi seleziona la regione in cui verrà ospitata l'istanza per completare il processo di configurazione.

Una volta creata l'istanza, vai alla pagina delle impostazioni e copia il file URL della banca dati, lo utilizzerai per stabilire una connessione con il database.

Configura un server Flask

Sul tuo terminale, crea una cartella di progetto e cambia la directory corrente in quella nuova cartella.

Prima di installare Flask, conferma di eseguire Python versione 3.6+ sul tuo computer. In caso contrario, è necessario installare l'ultima versione Pitone versione.

python --versione

Successivamente, installa virtualenv, per creare un ambiente di sviluppo virtuale isolato.

pip installa virtualenv

Successivamente, esegui il comando seguente per creare un ambiente virtuale.

virtualenv venv

Infine, attiva l'ambiente virtuale.

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

Installa i pacchetti richiesti

Nella directory principale della cartella del progetto, crea un file requisiti.txt file e aggiungere questi pacchetti.

borraccia
python-dotenv
psycopg2-binario

Successivamente, installa i pacchetti.

pip install -r requisiti.txt

IL psycopg2-binario è una libreria Python che funge da middleware, per permetterti di stabilire connessioni con il tuo database Postgres ed eseguire varie operazioni sul database.

Infine, crea un file .env file e incolla l'URL del tuo database.

DATABASE_URL= l'URL del tuo database

Crea il server Flask

Infine, crea un file app.py file nella directory principale e aggiungere il codice seguente.

importare os 
importare psycopg2
da dotenv importare load_dotenv
da borraccia importare Boccetta, richiesta, jsonify
load_dotenv()
app = Boccetta (__name__)
url = os.getenv("URL_DATABASE")
connessione = psycopg2.connect (url)
@app.get("/")
defcasa():
ritorno"Ciao mondo"

Questo codice configura un'istanza dell'applicazione Flask. Quindi crea una connessione al database specificato nella stringa dell'URL e, infine, imposta una home route che restituisce una stringa come risposta.

Creare l'API REST Abilitazione delle operazioni CRUD

Ora, crea l'API REST che implementa le quattro operazioni CRUD.

Crea una tabella dimostrativa

Creare una tabella utente all'interno del database.

Nel file app.py, aggiungi il codice qui sotto.

CREATE_USERS_TABLE = "CREA TABELLA SE NON ESISTE utenti (id SERIAL PRIMARY KEY, nome TEXT);"
con connessione:
con connessione.cursore() COME cursore:
 cursor.execute (CREATE_USERS_TABLE)

• Questo codice crea una nuova tabella PostgreSQL chiamata utenti con due colonne.
• Utilizza il metodo di connessione psycopg2 per stabilire la connessione con il database e crea un nuovo oggetto cursore utilizzando il file connection.cursor metodo utilizzato per l'esecuzione query SQL.

1. Definire il metodo POST

Crea il percorso post per aggiungere dati.

INSERT_USER_RETURN_ID = "INSERT INTO users (name) VALUES (%s) RETURNING id;"
@app.route("/api/user", metodi=["POST"])
defcreare un utente():
 dati = richiesta.get_json()
 nome = dati["nome"]
con connessione:
con connessione.cursore() COME cursore:
 cursor.execute (INSERT_USER_RETURN_ID, (nome,))
 user_id = cursor.fetchone()[0]
ritorno {"id": ID utente, "nome": nome, "Messaggio": f"Utente {nome} creato."}, 201

• La stringa di query SQL definisce un'istruzione SQL che verrà eseguita utilizzando il file cursor.execute metodo per inserire una nuova riga con il nome di un utente nel file degli utenti tabella nel database. Restituisce l'ID dell'utente appena creato.
• IL creare un utente La funzione accetta un nome come parametro da memorizzare nel database mentre la funzione cursor.fetchone viene chiamato il metodo per recuperare l'ID dell'utente appena creato. Infine, viene restituito un dizionario contenente l'ID e il nome dell'utente appena creato, insieme a un messaggio che indica che l'utente è stato creato correttamente.

2. Definire il metodo GET

Definire due percorsi di acquisizione: uno, per recuperare tutti i dati nel database e due, per recuperare dati specifici dal database in base all'ID.

SELECT_ALL_USERS = "SELEZIONA * DA utenti;"
@app.route("/api/user", metodi=["GET"])
defget_all_users():
con connessione:
con connessione.cursore() COME cursore:
 cursor.execute (SELECT_ALL_USERS)
 utenti = cursor.fetchall()
Se utenti:
 risultato = []
per utente In utenti:
 risultato.append({"id": utente[0], "nome": utente[1]})
ritorno jsonify (risultato)
altro:
ritorno jsonify({"errore": f"Utenti non trovati."}), 404
@app.route("/api/utente/", metodi=["GET"])
defget_user(ID utente):
con connessione:
con connessione.cursore() COME cursore:
 cursore.esegui("SELEZIONA * DA utenti WHERE id = %s", (ID utente,)) 
 utente = cursor.fetchone()
Se utente:
ritorno jsonify({"id": utente[0], "nome": utente[1]})
altro:
ritorno jsonify({"errore": f"Utente con ID {ID utente} non trovato."}), 404

• Questa prima route API gestisce le richieste HTTP GET per il recupero di tutti gli utenti dal database. Recupera tutti gli utenti dal database e restituisce i risultati in formato JSON nella risposta.

• Questa seconda route API gestisce le richieste HTTP GET per il recupero dei dati per un utente specifico dal database. Ci vuole il ID utente come parametro, recupera i dati dell'utente dal database e restituisce i risultati in formato JSON nella risposta.

3. Definire il metodo PUT

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

@app.route("/api/utente/", metodi=["PUT"])
defupdate_user(ID utente):
 dati = richiesta.get_json()
 nome = dati["nome"]
con connessione:
con connessione.cursore() COME cursore:
 cursor.execute (UPDATE_USER_BY_ID, (nome, user_id))
Se cursore.rowcount == 0:
ritorno jsonify({"errore": f"Utente con ID {ID utente} non trovato."}), 404
ritorno jsonify({"id": ID utente, "nome": nome, "Messaggio": f"Utente con ID {ID utente} aggiornato”.})

• IL update_user La funzione accetta il parametro ID utente come input e lo utilizza per aggiornare il nome dell'utente specificato nel database.
• Se l'operazione di aggiornamento ha esito positivo, restituisce un oggetto JSON con l'ID utente aggiornato, il nome e un messaggio di successo nella risposta.

4. Definire il metodo DELETE

Implementare il percorso di eliminazione per eliminare i dati archiviati di un utente specifico nel database.

@app.route("/api/utente/", metodi=["CANCELLA"])
defdelete_user(ID utente):
con connessione:
con connessione.cursore() COME cursore:
 cursor.execute (DELETE_USER_BY_ID, (user_id,))
Se cursore.rowcount == 0:
ritorno jsonify({"errore": f"Utente con ID {ID utente} non trovato."}), 404
ritorno jsonify({"Messaggio": f"Utente con ID {ID utente} cancellato".})

• Questa route API gestisce la funzionalità di eliminazione di un utente specifico dal database in base al relativo ID. Se l'utente non viene trovato, restituisce un codice di stato 404 con un messaggio di errore. Tuttavia, se l'operazione di eliminazione ha esito positivo, restituisce un oggetto JSON con un messaggio di esito positivo nella risposta.

Scrittura di API REST con Flask

Questa guida mostra come utilizzare Flask e Postgres per creare una semplice API CRUD REST insieme a come per stabilire una connessione al database ed eseguire diverse query SQL per leggere e scrivere dati su a Banca dati. Ora puoi creare una semplice API REST in grado di gestire le quattro operazioni CRUD richieste in qualsiasi applicazione web.

Che tu stia costruendo un semplice blog o un'applicazione web complessa, Flask e Postgres offrono potenti funzionalità e capacità necessarie per creare un solido sistema di back-end. In alternativa, puoi utilizzare altre tecnologie come FastAPI e MongoDB per creare API RESTful.