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

Scopri come creare un'API RESTful utilizzando Flask e Postgres, consentendo uno scambio di dati senza interruzioni tra la tua app e i sistemi esterni.

Le API (Application Programming Interface) rappresentano una parte fondamentale della creazione e della connessione di sistemi diversi, consentendo alle applicazioni di comunicare e scambiare dati con altri servizi.

Sebbene lo sviluppo del backend coinvolga qualcosa di più della semplice scrittura di API: copre anche la scrittura della logica aziendale lato server, la progettazione di architetture di sistema efficienti e altre funzioni chiave, continua a leggere per scoprire come creare una semplice API REST CRUD con Flask (un framework Python leggero) e il database Postgres.

Utilizzo di Flask per creare API backend

Flask è un framework Python leggero che fornisce una serie di funzionalità per semplificare la scrittura di API backend per client Web scritti utilizzando tecnologie diverse come React e Angular.

Questa guida ti guiderà attraverso la scrittura di un'API REST che implementa le quattro operazioni CRUD: creazione, lettura, aggiornamento ed eliminazione per gestire i dati utente archiviati in un database Postgres.

Configura 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, registrati e accedi alla pagina di panoramica del tuo account.

Fai clic sul pulsante Crea nuova istanza 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 l'URL del database, 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 che sul tuo computer è in esecuzione Python versione 3.6+. In caso contrario, è necessario installare l'ultima versione di Python.

python --version

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

pip install virtualenv

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

virtualenv venv

Infine, attiva l'ambiente virtuale.

# On Windows: 
.\venv\Scripts\activate
# On Unix or MacOS: 
source venv/bin/activate

Installa i pacchetti richiesti

Nella directory principale della cartella del tuo progetto, crea un file requirements.txt e aggiungi questi pacchetti.

flask
python-dotenv
psycopg2-binary

Successivamente, installa i pacchetti.

pip install -r requirements.txt

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

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

DATABASE_URL= your database URL

Creare il server Flask

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

import os 
import psycopg2
from dotenv import load_dotenv
from flask import Flask, request, jsonify
load_dotenv()
app = Flask(__name__)
url = os.getenv("DATABASE_URL")
connection = psycopg2.connect(url)

@app.get("/")
def home():
    return "hello world"

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 che abilita le 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 seguente.

CREATE_USERS_TABLE = "CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT);"
with connection:
    with connection.cursor() as cursor:
        cursor.execute(CREATE_USERS_TABLE)

• Questo codice crea una nuova tabella PostgreSQL chiamata users con due colonne.
• Utilizza il metodo di connessione psycopg2 per stabilire la connessione con il database e crea un nuovo oggetto cursore utilizzando il metodo connection.cursor che viene utilizzato per eseguire query SQL.

1. Definire il metodo POST

Crea il percorso postale per aggiungere dati.

INSERT_USER_RETURN_ID = "INSERT INTO users (name) VALUES (%s) RETURNING id;"
@app.route("/api/user", methods=["POST"])
def create_user():
    data = request.get_json()
    name = data["name"]
    with connection:
        with connection.cursor() as cursor:
            cursor.execute(INSERT_USER_RETURN_ID, (name,))
            user_id = cursor.fetchone()[0]
    return {"id": user_id, "name": name, "message": f"User {name} created."}, 201

• La stringa di query SQL definisce un'istruzione SQL che verrà eseguita utilizzando il metodo cursor.execute per inserire una nuova riga con il nome di un utente nella tabella users nel database. Restituisce l'ID dell'utente appena creato.
• La funzione create_user accetta un nome come parametro da memorizzare nel database mentre il metodo cursor.fetchone viene chiamato 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 = "SELECT * FROM users;"

@app.route("/api/user", methods=["GET"])
def get_all_users():
    with connection:
        with connection.cursor() as cursor:
            cursor.execute(SELECT_ALL_USERS)
            users = cursor.fetchall()
            if users:
                result = []
                for user in users:
                    result.append({"id": user[0], "name": user[1]})
                return jsonify(result)
            else:
                return jsonify({"error": f"Users not found."}), 404
@app.route("/api/user/<int:user_id>", methods=["GET"])
def get_user(user_id):
    with connection:
        with connection.cursor() as cursor:
            cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,)) 
            user = cursor.fetchone()
            if user:
                return jsonify({"id": user[0], "name": user[1]})
            else:
                return jsonify({"error": f"User with ID {user_id} not found."}), 404

• Questa prima route API gestisce le richieste HTTP GET per recuperare 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. Prende l'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

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

@app.route("/api/user/<int:user_id>", methods=["PUT"])
def update_user(user_id):
    data = request.get_json()
    name = data["name"]
    with connection:
        with connection.cursor() as cursor:
            cursor.execute(UPDATE_USER_BY_ID, (name, user_id))
            if cursor.rowcount == 0:
                return jsonify({"error": f"User with ID {user_id} not found."}), 404
    return jsonify({"id": user_id, "name": name, "message": f"User with ID {user_id} updated."})

• La funzione update_user prende 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, il nome e un messaggio di successo aggiornati 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/user/<int:user_id>", methods=["DELETE"])
def delete_user(user_id):
    with connection:
        with connection.cursor() as cursor:
            cursor.execute(DELETE_USER_BY_ID, (user_id,))
            if cursor.rowcount == 0:
                return jsonify({"error": f"User with ID {user_id} not found."}), 404
    return jsonify({"message": f"User with ID {user_id} deleted."})

• Questa route API gestisce la funzionalità di eliminazione di un utente specifico dal database in base al suo 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 successo nella risposta.

  

Scrittura di API REST con Flask

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

Che tu stia creando un blog semplice o un'applicazione web complessa, Flask e Postgres offrono potenti funzionalità e funzionalità necessarie per creare un robusto sistema backend. In alternativa, puoi utilizzare altre tecnologie come FastAPI e MongoDB per creare API RESTful.