Come utilizzare un database PostgreSQL in un’applicazione Flask

Tutorial
Flask PostgreSQL Python

L’autore ha selezionato il Fondo per il Software Libero e Open Source per ricevere una donazione come parte del programma Scrivi per le Donazioni.

Introduzione

Nelle applicazioni web, di solito è necessario un database, che è una raccolta organizzata di dati. Si utilizza un database per memorizzare e mantenere dati persistenti che possono essere recuperati e manipolati in modo efficiente. Ad esempio, in un’applicazione di social media, si dispone di un database in cui i dati degli utenti (informazioni personali, post, commenti, follower) sono memorizzati in modo che possano essere manipolati efficientemente. Si possono aggiungere dati a un database, recuperarli, modificarli o eliminarli, a seconda di diversi requisiti e condizioni. In un’applicazione web, questi requisiti potrebbero essere un utente che aggiunge un nuovo post, elimina un post o elimina il proprio account, che potrebbe o potrebbe non eliminare i propri post. Le azioni che si eseguono per manipolare i dati dipenderanno dalle specifiche funzionalità della tua applicazione. Ad esempio, potresti non volere che gli utenti aggiungano post senza titoli.

Flask è un framework web leggero per Python che fornisce strumenti utili e funzionalità per la creazione di applicazioni web nel linguaggio Python. PostgreSQL, o Postgres, è un sistema di gestione di database relazionali che fornisce un’implementazione del linguaggio di interrogazione SQL. È conforme agli standard e ha molte funzionalità avanzate come transazioni affidabili e concorrenza senza blocchi di lettura.

In questo tutorial, costruirai una piccola applicazione web di recensioni di libri che dimostra come utilizzare la libreria psycopg2, un adattatore di database PostgreSQL che ti permette di interagire con il tuo database PostgreSQL in Python. Lo userai con Flask per eseguire compiti di base, come la connessione a un server di database, la creazione di tabelle, l’inserimento di dati in una tabella e il recupero di dati da una tabella.

Prerequisiti

Passo 1 — Creazione del Database e Utente PostgreSQL

In questo passaggio, creerai un database chiamato flask_db e un utente del database chiamato sammy per la tua applicazione Flask.

Durante l’installazione di Postgres, è stato creato un utente del sistema operativo chiamato postgres per corrispondere all’utente amministratore di PostgreSQL postgres. Devi utilizzare questo utente per eseguire le attività amministrative. Puoi utilizzare sudo e passare il nome utente con l’opzione -iu.

Accedi a una sessione interattiva di Postgres utilizzando il seguente comando:

  1. sudo -iu postgres psql

Ti verrà fornito un prompt di PostgreSQL dove puoi configurare i tuoi requisiti.

Prima di tutto, crea un database per il tuo progetto:

  1. CREATE DATABASE flask_db;

Nota: Ogni istruzione Postgres deve terminare con un punto e virgola, quindi assicurati che il tuo comando termini con uno se stai riscontrando problemi.

Successivamente, crea un utente del database per il nostro progetto. Assicurati di selezionare una password sicura:

  1. CREATE USER sammy WITH PASSWORD 'password';

Quindi concedi a questo nuovo utente l’accesso per amministrare il tuo nuovo database:

  1. GRANT ALL PRIVILEGES ON DATABASE flask_db TO sammy;

Per confermare che il database sia stato creato, ottieni l’elenco dei database digitando il seguente comando:

  1. \l

Vedrai flask_db nell’elenco dei database.

Quando hai finito, esci dal prompt di PostgreSQL digitando:

  1. \q

Postgres è ora configurato in modo che tu possa connetterti e gestire le informazioni del database tramite Python utilizzando la libreria psycopg2. Successivamente, installerai questa libreria insieme al pacchetto Flask.

Passaggio 2 — Installazione di Flask e psycopg2

In questo passaggio, installerai Flask e la libreria psycopg2 in modo da poter interagire con il tuo database usando Python.

Con il tuo ambiente virtuale attivato, utilizza pip per installare Flask e la libreria psycopg2:

  1. pip install Flask psycopg2-binary

Una volta completata l’installazione con successo, vedrai una riga simile alla seguente alla fine dell’output:

Output

Successfully installed Flask-2.0.2 Jinja2-3.0.3 MarkupSafe-2.0.1 Werkzeug-2.0.2 click-8.0.3 itsdangerous-2.0.1 psycopg2-binary-2.9.2

Adesso hai installato i pacchetti richiesti nel tuo ambiente virtuale. Successivamente, ti connetterai e configurerai il tuo database.

Passaggio 3 — Configurazione di un Database

In questo passaggio, creerai un file Python nella directory del tuo progetto flask_app per connetterti al database flask_db, creare una tabella per memorizzare i libri e inserire alcuni libri con recensioni al suo interno.

Prima di tutto, con il tuo ambiente di programmazione attivato, apri un nuovo file chiamato init_db.py nella tua directory flask_app.

  1. nano init_db.py

Questo file aprirà una connessione al database flask_db, creerà una tabella chiamata books e popolerà la tabella utilizzando dati di esempio. Aggiungi il seguente codice:

flask_app/init_db.py
import os
import psycopg2

conn = psycopg2.connect(
        host="localhost",
        database="flask_db",
        user=os.environ['DB_USERNAME'],
        password=os.environ['DB_PASSWORD'])

# Apri un cursore per eseguire operazioni sul database
cur = conn.cursor()

# Esegui un comando: questo crea una nuova tabella
cur.execute('DROP TABLE IF EXISTS books;')
cur.execute('CREATE TABLE books (id serial PRIMARY KEY,'
                                 'title varchar (150) NOT NULL,'
                                 'author varchar (50) NOT NULL,'
                                 'pages_num integer NOT NULL,'
                                 'review text,'
                                 'date_added date DEFAULT CURRENT_TIMESTAMP);'
                                 )

# Inserisci dati nella tabella

cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('A Tale of Two Cities',
             'Charles Dickens',
             489,
             'A great classic!')
            )


cur.execute('INSERT INTO books (title, author, pages_num, review)'
            'VALUES (%s, %s, %s, %s)',
            ('Anna Karenina',
             'Leo Tolstoy',
             864,
             'Another great classic!')
            )

conn.commit()

cur.close()
conn.close()

Salva e chiudi il file.

In questo file, importi innanzitutto il modulo os che userai per accedere alle variabili d’ambiente dove memorizzerai il nome utente e la password del database in modo che non siano visibili nel tuo codice sorgente.

Importi la libreria psycopg2. Successivamente apri una connessione al database flask_db utilizzando la funzione psycopg2.connect(). Specifici l’host, che in questo caso è localhost. Passi il nome del database al parametro database.

Fornisci il tuo nome utente e la password tramite l’oggetto os.environ, che ti dà accesso alle variabili d’ambiente impostate nel tuo ambiente di programmazione. Memorizzerai il nome utente del database in una variabile d’ambiente chiamata DB_USERNAME e la password in una variabile d’ambiente chiamata DB_PASSWORD. Ciò ti consente di memorizzare il nome utente e la password al di fuori del tuo codice sorgente, in modo che le tue informazioni sensibili non vengano divulgate quando il codice sorgente viene salvato nel controllo del codice sorgente o caricato su un server su Internet. Anche se un attaccante ottiene accesso al tuo codice sorgente, non avrà accesso al database.

Crei un cursore chiamato cur utilizzando il metodo connection.cursor(), che consente al codice Python di eseguire comandi PostgreSQL in una sessione di database.

Si utilizza il metodo execute() del cursore per eliminare la tabella books se esiste già. Questo evita la possibilità che esista un’altra tabella chiamata books, il che potrebbe causare un comportamento confuso (ad esempio, se ha colonne diverse). Questo non è il caso qui, perché non hai ancora creato la tabella, quindi il comando SQL non verrà eseguito. Nota che questo eliminerà tutti i dati esistenti ogni volta che esegui questo file init_db.py. Per i nostri scopi, eseguirai questo file solo una volta per inizializzare il database, ma potresti volerlo eseguire di nuovo per eliminare i dati inseriti e ricominciare con i dati di esempio iniziali.

Poi si utilizza CREATE TABLE books per creare una tabella chiamata books con le seguenti colonne:

  • id: Un ID del tipo serial, che è un intero autoincrementante. Questa colonna rappresenta una chiave primaria specificata utilizzando le parole chiave PRIMARY KEY. Il database assegnerà un valore univoco a questa chiave per ogni voce.
  • title: Il titolo del libro di tipo varchar, che è un tipo di carattere di lunghezza variabile con un limite. varchar(150) significa che il titolo può essere lungo fino a 150 caratteri. NOT NULL indica che questa colonna non può essere vuota.
  • author: L’autore del libro, con un limite di 50 caratteri. NOT NULL indica che questa colonna non può essere vuota.
  • pages_num: Un intero che rappresenta il numero di pagine del libro. NOT NULL indica che questa colonna non può essere vuota.
  • review: La recensione del libro. Il tipo text indica che la recensione può essere un testo di qualsiasi lunghezza.
  • date_added: La data in cui il libro è stato aggiunto alla tabella. DEFAULT imposta il valore predefinito della colonna su CURRENT_TIMESTAMP, che è l’ora in cui il libro è stato aggiunto al database. Proprio come per id, non è necessario specificare un valore per questa colonna, poiché verrà compilato automaticamente.

Dopo aver creato la tabella, si utilizza il metodo execute() del cursore per inserire due libri nella tabella, A Tale of Two Cities di Charles Dickens e Anna Karenina di Leo Tolstoy. Si utilizza il segnaposto %s per passare i valori alla dichiarazione SQL. psycopg2 gestisce l’inserimento in background in modo da evitare attacchi di SQL Injection.

Una volta terminato l’inserimento dei dati del libro nella tabella, si utilizza il metodo connection.commit() per confermare la transazione e applicare le modifiche al database. Quindi si puliscono le cose chiudendo il cursore con cur.close() e la connessione con conn.close().

Per stabilire la connessione al database, impostare le variabili di ambiente DB_USERNAME e DB_PASSWORD eseguendo i seguenti comandi. Ricordarsi di utilizzare il proprio nome utente e password:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Ora eseguire il file init_db.py nel terminale utilizzando il comando python:

  1. python init_db.py

Una volta che il file termina l’esecuzione senza errori, verrà aggiunta una nuova tabella books al tuo database flask_db.

Accedi a una sessione interattiva di Postgres per esaminare la nuova tabella books.

  1. sudo -iu postgres psql

Connettiti al database flask_db utilizzando il comando \c:

  1. \c flask_db

Successivamente, utilizza una dichiarazione SELECT per ottenere i titoli e gli autori dei libri dalla tabella books:

  1. SELECT title, author FROM books;

Vedrai un output simile al seguente:

        title         |      author
----------------------+------------------
 A Tale of Two Cities | Charles Dickens
 Anna Karenina        | Leo Tolstoy

Esci dalla sessione interattiva con \q.

Successivamente, creerai un piccolo’applicazione Flask, ti collegherai al database, recupererai le due recensioni dei libri inserite nel database e le visualizzerai sulla pagina iniziale.

Passaggio 4 — Visualizzazione dei libri

In questo passaggio, creerai un’applicazione Flask con una pagina indice che recupera i libri presenti nel database e li visualizza.

Con il tuo ambiente di programmazione attivato e Flask installato, apri un file chiamato app.py per la modifica all’interno della tua directory flask_app:

  1. nano app.py

Questo file imposterà la connessione al tuo database e creerà un singolo percorso Flask per utilizzare quella connessione. Aggiungi il seguente codice al file:

flask_app/app.py
import os
import psycopg2
from flask import Flask, render_template

app = Flask(__name__)

def get_db_connection():
    conn = psycopg2.connect(host='localhost',
                            database='flask_db',
                            user=os.environ['DB_USERNAME'],
                            password=os.environ['DB_PASSWORD'])
    return conn


@app.route('/')
def index():
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('SELECT * FROM books;')
    books = cur.fetchall()
    cur.close()
    conn.close()
    return render_template('index.html', books=books)

Salva e chiudi il file.

Ecco, importi il modulo os, la libreria psycopg2, la classe Flask e il render_template() dal pacchetto flask. Crei un’istanza dell’applicazione Flask chiamata app.

Definisci una funzione chiamata get_db_connection(), che apre una connessione al database flask_db utilizzando l’utente e la password memorizzati nelle variabili di ambiente DB_USERNAME e DB_PASSWORD. La funzione restituisce l’oggetto di connessione conn che verrà utilizzato per accedere al database.

Quindi crei un percorso principale / e una funzione di visualizzazione index() utilizzando il decoratore app.route(). Nella funzione di visualizzazione index(), apri una connessione al database utilizzando la funzione get_db_connection(), crei un cursore ed esegui la query SQL SELECT * FROM books; per ottenere tutti i libri presenti nel database. Utilizzi il metodo fetchall() per salvare i dati in una variabile chiamata books. Quindi chiudi il cursore e la connessione. Infine, restituisci una chiamata alla funzione render_template() per rendere un file di modello chiamato index.html passandogli l’elenco dei libri recuperati dal database nella variabile books.

Per visualizzare i libri presenti nel tuo database sulla pagina iniziale, prima creerai un template di base, che conterrà tutto il codice HTML di base che altri template utilizzeranno anche per evitare la ripetizione del codice. Successivamente creerai il file di template index.html che renderai nella tua funzione index(). Per saperne di più sui template, vedi Come Utilizzare i Template in un’applicazione Flask.

Crea una directory templates, quindi apri un nuovo template chiamato base.html:

  1. mkdir templates

  2. nano templates/base.html

Aggiungi il seguente codice all’interno del file base.html:

flask_app/templates/base.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %}- FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Salva e chiudi il file.

Questo template di base contiene tutto il boilerplate HTML di cui avrai bisogno per riutilizzare nei tuoi altri template. Il blocco title verrà sostituito per impostare un titolo per ogni pagina, e il blocco content verrà sostituito con il contenuto di ogni pagina. La barra di navigazione ha due link, uno per la pagina di indice dove utilizzi la funzione helper url_for() per collegarti alla funzione di visualizzazione index(), e l’altro per una pagina Informazioni se scegli di includerne una nella tua applicazione.

Successivamente, apri un template chiamato index.html. Questo è il template a cui fai riferimento nel file app.py:

  1. nano templates/index.html

Aggiungi il seguente codice:

flask_app/templates/index.html

{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Books {% endblock %}</h1>
    {% for book in books %}
        <div class='book'>
            <h3>#{{ book[0] }} - {{ book[1] }} BY {{ book[2] }}</h3>
            <i><p>({{ book[3] }} pages)</p></i>
            <p class='review'>{{ book[4] }}</p>
            <i><p>Added {{ book[5] }}</p></i>
        </div>
    {% endfor %}
{% endblock %}

Salva e chiudi il file.

In questo file, estendi il template di base e sostituisci il contenuto del blocco content. Utilizzi un’intestazione <h1> che funge anche da titolo.

Usi un loop for di Jinja nella riga {% for book in books %} per attraversare ogni libro nella lista books. Visualizzi quindi l’ID del libro, che è il primo elemento usando book[0]. Visualizzi poi il titolo del libro, l’autore, il numero di pagine, la recensione e la data in cui il libro è stato aggiunto.

Mentre sei nella directory flask_app con il tuo ambiente virtuale attivato, comunica a Flask dell’applicazione (app.py in questo caso) utilizzando la variabile d’ambiente FLASK_APP. Quindi imposta la variabile d’ambiente FLASK_ENV su development per eseguire l’applicazione in modalità di sviluppo e ottenere accesso al debugger. Per ulteriori informazioni sul debugger di Flask, consulta Come Gestire gli Errori in un’Applicazione Flask. Utilizza i seguenti comandi per farlo:

  1. export FLASK_APP=app

  2. export FLASK_ENV=development

Assicurati di impostare le variabili d’ambiente DB_USERNAME e DB_PASSWORD se non lo hai già fatto:

  1. export DB_USERNAME="sammy"

  2. export DB_PASSWORD="password"

Successivamente, esegui l’applicazione:

  1. flask run

Con il server di sviluppo in esecuzione, visita l’URL seguente utilizzando il tuo browser:

http://127.0.0.1:5000/

Vedrai i libri che hai aggiunto al database alla prima inizializzazione.

Hai visualizzato i libri nel tuo database nella pagina indice. Ora devi consentire agli utenti di aggiungere nuovi libri. Aggiungerai una nuova route per aggiungere libri nel prossimo passaggio.

Passo 5 — Aggiunta di Nuovi Libri

In questo passaggio, creerai una nuova route per aggiungere nuovi libri e recensioni al database.

Aggiungerai una pagina con un modulo web in cui gli utenti inseriscono il titolo del libro, l’autore del libro, il numero di pagine e la recensione del libro.

Lascia il server di sviluppo in esecuzione e apri una nuova finestra del terminale.

Prima, apri il tuo file app.py:

  1. nano app.py

Per gestire il modulo web, dovrai importare alcune cose dal pacchetto flask:

  • Il oggetto request globale per accedere ai dati inviati.
  • La funzione url_for() per generare URL.
  • La funzione redirect() per reindirizzare gli utenti alla pagina dell’indice dopo aver aggiunto un libro al database.

Aggiungi queste importazioni alla prima riga nel file:

flask_app/app.py

from flask import Flask, render_template, request, url_for, redirect

# ...

Poi aggiungi la seguente route alla fine del file app.py:

flask_app/app.py

# ...


@app.route('/create/', methods=('GET', 'POST'))
def create():
    return render_template('create.html')

Salva e chiudi il file.

In questa route, passi la tupla ('GET', 'POST') al parametro methods per consentire sia richieste GET che POST. Le richieste GET vengono utilizzate per recuperare dati dal server. Le richieste POST vengono utilizzate per inviare dati a una route specifica. Per default, sono consentite solo le richieste GET. Quando l’utente richiede per la prima volta la route /create utilizzando una richiesta GET, verrà reso il file template chiamato create.html. In seguito modificherai questa route per gestire le richieste POST quando gli utenti compilano e inviano il modulo web per aggiungere nuovi libri.

Apri il nuovo template create.html:

  1. nano templates/create.html

Aggiungi il seguente codice ad esso:

flask_app/templates/create.html
{% extends 'base.html' %}

{% block content %}
    <h1>{% block title %} Add a New Book {% endblock %}</h1>
    <form method="post">
        <p>
            <label for="title">Title</label>
            <input type="text" name="title"
                   placeholder="Book title">
            </input>
        </p>

        <p>
            <label for="author">Author</label>
            <input type="text" name="author"
                   placeholder="Book author">
            </input>
        </p>

        <p>
            <label for="pages_num">Number of pages</label>
            <input type="number" name="pages_num"
                   placeholder="Number of pages">
            </input>
        </p>
        <p>
        <label for="review">Review</label>
        <br>
        <textarea name="review"
                  placeholder="Review"
                  rows="15"
                  cols="60"
                  ></textarea>
        </p>
        <p>
            <button type="submit">Submit</button>
        </p>
    </form>
{% endblock %}

Salva e chiudi il file.

Estendi il template di base, imposta un’intestazione come titolo e utilizza un tag <form> con l’attributo method impostato su post per indicare che il modulo invierà una richiesta POST.

Hai un campo di testo con il nome title, che userai per accedere ai dati del titolo nella tua route /create.

Hai un campo di testo per l’autore, un campo numerico per il numero di pagine e un’area di testo per la recensione del libro.

Infine, hai un pulsante Invia alla fine del modulo.

Adesso, con il server di sviluppo in esecuzione, utilizza il tuo browser per navigare alla route /create:

http://127.0.0.1:5000/create

Vedrai una pagina Aggiungi un Nuovo Libro con un campo di input per il titolo del libro, uno per il suo autore, uno per il numero di pagine del libro, un’area di testo per la recensione del libro e un pulsante Invia.

Se compili il modulo e lo invii, inviando una richiesta POST al server, non succede nulla perché non hai gestito le richieste POST sul percorso /create.

Apri app.py per gestire la richiesta POST inviata dall’utente:

  1. nano app.py

Modifica il percorso /create in modo che sembri quanto segue:

flask_app/app.py

# ...

@app.route('/create/', methods=('GET', 'POST'))
def create():
    if request.method == 'POST':
        title = request.form['title']
        author = request.form['author']
        pages_num = int(request.form['pages_num'])
        review = request.form['review']

        conn = get_db_connection()
        cur = conn.cursor()
        cur.execute('INSERT INTO books (title, author, pages_num, review)'
                    'VALUES (%s, %s, %s, %s)',
                    (title, author, pages_num, review))
        conn.commit()
        cur.close()
        conn.close()
        return redirect(url_for('index'))

    return render_template('create.html')

Salva e chiudi il file.

Gestisci le richieste POST all’interno della condizione if request.method == 'POST'. Estrai il titolo, l’autore, il numero di pagine e la recensione inviata dall’utente dall’oggetto request.form.

Apri un database usando la funzione get_db_connection(), e crea un cursore. Poi esegui un’istruzione SQL INSERT INTO per inserire il titolo, l’autore, il numero di pagine e la recensione inviata dall’utente nella tabella books.

Conferma la transazione e chiudi il cursore e la connessione.

Infine, reindirizza l’utente alla pagina principale dove può vedere il nuovo libro aggiunto sotto i libri esistenti.

Con il server di sviluppo in esecuzione, utilizza il tuo browser per navigare al percorso /create:

http://127.0.0.1:5000/create

Compila il modulo con alcuni dati e invialo.

Sarai reindirizzato alla pagina principale dove vedrai la tua nuova recensione del libro.

Successivamente, aggiungerai un collegamento alla pagina di Creazione nella barra di navigazione. Apri base.html:

  1. nano templates/base.html

Modifica il file in modo che sembri quanto segue:

flask_app/templates/base.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %} {% endblock %} - FlaskApp</title>
    <style>
        nav a {
            color: #d64161;
            font-size: 3em;
            margin-left: 50px;
            text-decoration: none;
        }

        .book {
            padding: 20px;
            margin: 10px;
            background-color: #f7f4f4;
        }

        .review {
                margin-left: 50px;
                font-size: 20px;
        }

    </style>
</head>
<body>
    <nav>
        <a href="{{ url_for('index') }}">FlaskApp</a>
        <a href="{{ url_for('create') }}">Create</a>
        <a href="#">About</a>
    </nav>
    <hr>
    <div class="content">
        {% block content %} {% endblock %}
    </div>
</body>
</html>

Salva e chiudi il file.

Ecco, aggiungi un nuovo link <a> alla barra di navigazione che punta alla pagina Create.

Aggiorna la tua pagina di indice e vedrai il nuovo link nella barra di navigazione.

Ora hai una pagina con un modulo web per aggiungere nuove recensioni di libri. Per ulteriori informazioni sui moduli web, vedi Come Usare i Moduli Web in un’applicazione Flask. Per un metodo più avanzato e più sicuro per gestire i moduli web, vedi Come Usare e Validare i Moduli Web con Flask-WTF.

Conclusione

Hai costruito una piccola applicazione web per le recensioni dei libri che comunica con un database PostgreSQL. Hai funzionalità di base del database nella tua applicazione Flask, come l’aggiunta di nuovi dati al database, il recupero dei dati e la loro visualizzazione su una pagina.

Se desideri leggere ulteriori informazioni su Flask, consulta gli altri tutorial della serie Flask.

Source:
https://www.digitalocean.com/community/tutorials/how-to-use-a-postgresql-database-in-a-flask-application