Python è uno dei linguaggi di sviluppo più popolari. La sua sintassi semplice e le basse barriere all’ingresso lo rendono un buon candidato per i programmatori alle prime armi che sperano di farsi strada nel panorama dello sviluppo software.

Una serie di framework e librerie rendono più facile l’avvio di un’applicazione Python. Tra questi ci sono Django, FastAPI e Flask. Il framework Flask attira gli sviluppatori Python per la facilità di prototipazione e personalizzazione.

In questo articolo vedremo come sviluppare una semplice applicazione Python collegata al database utilizzando Flask.

Applicazioni Python più facili con Flask

Sviluppato nel 2010, Flask è adatto allo sviluppo di applicazioni web in Python grazie alla sua facilità d’uso e flessibilità. La sua architettura snella si concentra sul fornire le basi e facilita l’aggiunta di librerie per le funzionalità necessarie. Questo approccio rende Flask ideale per molti progetti, da semplici applicazioni a sistemi complessi.

Flask offre diversi strumenti e funzionalità per supportare lo sviluppo di applicazioni web, tra cui:

  • Librerie e strumenti per gestire le richieste e le risposte HTTP
  • La possibilità di indirizzare le richieste a funzioni designate
  • Supporto per i template di rendering
  • Supporto per i database
  • Sistemi di autenticazione e autorizzazione

Come creare un’app Python Flask

Per esplorare i vantaggi dell’uso di Flask per lo sviluppo di applicazioni web, possiamo creare un’applicazione web in Python con Flask. In seguito, potremo costruire e distribuire l’applicazione utilizzando il servizio di Hosting di Applicazioni web di Kinsta e collegarla a un database gestito sulla piattaforma Kinsta.

Prerequisiti dell’applicazione Python Flask

Per seguire questo tutorial, è necessario:

Installare Flask per Python

Andiamo al terminale (Linux o macOS) o al Prompt dei comandi (Windows). Iniziamo creando una cartella chiamata flask_demo.

Passiamo alla nuova directory e creiamo un ambiente virtuale Python utilizzando il comando python3 -m venv venv. In questo caso, utilizzeremo anche venv come nome per la directory che supporterà l’ambiente virtuale.

Attiviamo l’ambiente virtuale utilizzando uno dei seguenti comandi:

  • venvScriptsactivate in Windows
  • source venv/bin/activate in Linux o macOS

Ora, installiamo Flask utilizzando pip eseguendo pip install flask.

Il lavoro svolto finora nel terminale dovrebbe assomigliare a questo:

Output del terminale durante la creazione di un ambiente virtuale Python e l'installazione di Flask.
Creazione delle basi di un’applicazione Python Flask nel terminale.

Creare un’applicazione di base

Successivamente, creiamo l’applicazione di base e verifichiamone la funzionalità renderizzando i contenuti nel browser.

Nella directory flask_demo, creiamo un file chiamato demo.py e aggiungiamo il seguente codice:

from flask import Flask

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return "Happy Coding!"

if __name__ == '__main__':
    app.run(debug=True)

Questo codice importa Flask dal modulo flask e ne crea un’istanza chiamata app. Il codice crea poi una route che restituisce un testo con la scritta “Happy Coding!” quando gli utenti visitano l’applicazione in un browser. Infine, esegue il server di sviluppo una volta avviato lo script.

Avviamo l’applicazione eseguendo flask --app demo run nel terminale. Il flag --app specifica la posizione dell’applicazione che verrà eseguita: in questo caso, il file demo.py.

Aggiungere template all’applicazione Python Flask

L’aggiunta di template all’applicazione migliorerà i contenuti. Per prima cosa, creiamo una directory chiamata templates nella root dell’applicazione. Quindi, spostiamoci nella directory templates e creiamo un file chiamato index.html contenente il seguente codice HTML:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    <p>My name is John Doe - learning about Application Deployment!</p>
</body>
</html>

In demo.py, importa render_template dal modulo flask e renderizza il template index.html nella funzione route in questo modo:

from flask import Flask, render_template

app = Flask(__name__)

# Routes
@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)

Quindi, serviamo l’applicazione eseguendo flask --app demo run nell’ambiente locale. Usiamo l’indirizzo locale riportato nel terminale per lanciare l’applicazione nel browser. Dovremmo vedere qualcosa di simile a questo:

Schermata di un browser web che visualizza la fase iniziale dell'applicazione Flask.
Fase iniziale di un’applicazione Python Flask in un browser web.

Collegare l’app Flask a un database locale

Creeremo una connessione a un database locale – MySQL – che memorizza i contenuti dell’applicazione.

Per collegare l’applicazione Flask a MySQL, installiamo quanto segue:

  • flask_mysqldb, il connettore MySQL per Flask, che utilizza pip install flask_mysqldb
  • Python-dotenv, per la lettura delle variabili d’ambiente, utilizzando pip install python-dotenv
  • Il connettore MySQL di Python, utilizzando pip install mysql-connector-python
  • La dipendenza da MySQL, utilizzando pip install mysqlclient

Andiamo su MySQL Workbench per creare un database. Assicuriamoci di aggiungere un utente del database con i permessi per accedere al database e creare tabelle.

Creiamo un file .env nella directory principale dell’applicazione per contenere i dettagli della connessione al database. A questo modello dovremo aggiungere le credenziali dell’utente del database e il nome del database:

DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"

In uno script demo.py modificato, ora importeremo il connettore MySQL e useremo Python-dotenv per leggere le chiavi delle variabili d’ambiente nel file .env. Questo nuovo script demo.py verifica anche l’esistenza di una tabella chiamata persone nel database e la crea e la popola se non esiste.

import os
from flask import Flask, render_template
from flask_mysqldb import MySQL

from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

app.config['MYSQL_HOST'] = os.getenv("DB_HOST")
app.config['MYSQL_USER'] = os.getenv("DB_USER")
app.config['MYSQL_PASSWORD'] = os.getenv("DB_PASSWORD")
app.config['MYSQL_DB'] = os.getenv("DB_NAME")

mysql = MySQL(app)

@app.route('/')
def index():
    cursor = mysql.connection.cursor()

    cursor.execute("SHOW TABLES LIKE 'persons'")
    result = cursor.fetchone()

    if not result:
        cursor.execute(''' CREATE TABLE persons (id INTEGER, firstname VARCHAR(20), lastname VARCHAR(20)) ''')
        cursor.execute(''' INSERT INTO persons VALUES(1, 'John', 'Doe') ''')
        cursor.execute(''' INSERT INTO persons VALUES(2, 'Milly', 'Winfrerey') ''')
        mysql.connection.commit()

    cursor.execute('SELECT * FROM persons')
    entry = cursor.fetchall()
    cursor.close()
    return render_template('index.html', entry=entry)

Dopo aver istanziato Flask, il codice precedente utilizza le variabili d’ambiente per catturare gli attributi del database dal file .env nella root dell’applicazione.

Quindi, il codice istanzia MySQL e lo associa a Flask. Crea poi un oggetto cursore nel percorso index. Successivamente, il codice verifica la presenza di una tabella denominata persons nel database. Se non viene trovata, la crea con gli attributi id, firstname e lastname e inserisce due righe di dati.

Le tre righe successive eseguono un comando SQL per selezionare tutte le righe della tabella persone e recuperare i risultati. L’oggetto cursore viene chiuso e i risultati della query vengono passati come variabile di contesto entry per essere resi con il modello.

Ecco un file template index.html rivisto che può elaborare i risultati della query del database:

<!DOCTYPE html><html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>HomePage</title>
</head>
<body>
    <h3>Flask Demo Application</h3>
    {% for e in entry %}
        <p>My name is {{e[1]}} {{e[2]}} - learning about Application Deployment!</p>
    {% endfor %}
</body>
</html>

Eseguiamo l’applicazione, poi torniamo a MySQL Workbench per controllare i dati. L’aspetto dovrebbe essere il seguente:

Schermata dei risultati della query in MySQL Workbench.
Risultati dell’interrogazione della tabella Persons in MySQL Workbench.

Quando interroghiamo la tabella, vengono restituite le due voci generate dall’applicazione. Ora l’applicazione visualizza nel browser il seguente contenuto derivato dal database:

Schermata che mostra il contenuto generato dal database.
Contenuti generati dal database nel browser.

Come distribuire l’applicazione Python Flask su Kinsta

Ora che l’applicazione è attiva e funzionante a livello locale, possiamo renderla visibile al mondo ospitandola su Kinsta. Possiamo abbinare i servizi di Hosting di Applicazioni Web e Hosting di Database gestito di Kinsta per dare vita a questa applicazione (e ai nostri lavori futuri) nel cloud. E possiamo provarli entrambi gratuitamente.

Preparare il progetto Python per la distribuzione

La piattaforma di Hosting di Applicazioni Web di Kinsta distribuisce il codice dal nostro host Git preferito. Il passo successivo consiste nel configurare l’ambiente dell’applicazione per supportare questo percorso e permettere a Kinsta di distribuire l’applicazione con tutte le sue dipendenze necessarie.

Iniziamo creando una nuova cartella nella root del progetto flask_demo. Chiamiamola myapp. Quindi spostiamo la cartella templates e il file demo.py in myapp.

All’interno della cartella myapp, creiamo un file wsgi.py con il seguente contenuto:

from myapp.demo import app as application

if __name__ == "__main__":
    application.run(debug=True)

Il processo di build di Kinsta utilizzerà anche pip per generare l’applicazione. Possiamo passare un elenco delle dipendenze dell’applicazione a pip sul lato della produzione utilizzando un file requirements.txt nella directory principale del progetto.

Sempre lavorando nell’ambiente virtuale venv e all’interno della directory principale di flask_demo, generiamo un file requirements.txt specifico per il progetto con il seguente comando:

pip freeze > requirements.txt

Il contenuto del file di testo risultante sarà simile a questo:

blinker==1.7.0
click==8.1.7
Flask==3.0.0
Flask-MySQLdb==2.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
mysql-connector-python==8.2.0
mysqlclient==2.2.1
protobuf==4.21.12
python-dotenv==1.0.0
Werkzeug==3.0.1

Non è necessario inviare il file .env con i segreti del database al server di produzione. Poiché non avremo bisogno della libreria python-dotenv per leggere . env in produzione, possiamo rimuovere il suo riferimento dal file requirements.txt e rimuovere (o commentare) queste righe nel file demo.py:

from dotenv import load_dotenv
load_dotenv()

Aggiungere un server HTTP Python WSGI al progetto

Una cosa che manca ai requisiti di cui sopra è un modo per servire l’applicazione via HTTP in un ambiente di produzione. Il server di sviluppo utilizzato sulla nostra macchina locale non è sufficiente. Per questo progetto, utilizzeremo il pacchetto Web Server Gateway Interface (WSGI) Gunicorn tra l’applicazione e i server web Nginx di Kinsta.

Aggiungiamo un requisito Gunicorn al nostro progetto installandolo nel nostro ambiente virtuale in questo modo:

pip install gunicorn

Dopo aver installato Gunicorn, usiamo pip per generare nuovamente il file requirements.txt.

Un’alternativa all’installazione di Gunicorn in locale è quella di modificare il file requirements.txt e aggiungere semplicemente una voce come questa:

gunicorn==21.2.0

Per completare le basi del server WSGI, creiamo un file nella directory principale del progetto chiamato Procfile e aggiungiamo la seguente riga:

web: gunicorn myapp.wsgi

Questa sarà la base del comando di avvio dell’applicazione in produzione.

Preparare il progetto per Git

La struttura di directory modificata è pronta per essere distribuita su Kinsta, ma non vogliamo che tutti questi file vadano in produzione. Creiamo un file .gitignore nella root del progetto con un contenuto simile a questo:

/venv
.env

In questo modo i file della directory venv e i segreti del database locale in .env non verranno caricati sull’host Git.

Ora possiamo avviare il nostro ambiente Git locale e inviare il codice all’host Git utilizzando gli strumenti che preferiamo.

Distribuire l’applicazione Python Flask su Kinsta

Accediamo al cruscotto MyKinsta e assicuriamoci di aver autorizzato Kinsta ad accedere al provider di servizi Git. Seguiamo i passaggi per aggiungere un’applicazione, selezionando il repository e il branch sull’host Git dove Kinsta troverà il codice del progetto Flask.

Durante la configurazione dell’ambiente di build, selezioniamo Usa Buildpacks per impostare l’immagine del container, ma lasciamo tutte le altre impostazioni ai valori predefiniti. (Non dovremo fornire un comando Start perché questo è già definito nel Procfile.)

Schermata dell'interfaccia MyKinsta per la configurazione dell'ambiente di build.
Scegliere Buildpacks per impostare l’immagine del container per l’applicazione.

Dopo aver esaminato le informazioni di fatturazione (iniziando comunque gratuitamente!), clicchiamo sul pulsante Build now e osserviamo i progressi nel visualizzatore di log:

Schermata delle voci di log per la distribuzione di un'applicazione Python Flask.
Voci di log per la distribuzione di un’applicazione Python Flask.

Aggiungere un database per l’applicazione Python Flask

Kinsta offre quattro opzioni di database gestiti per soddisfare tutte le esigenze e i requisiti di un’applicazione: Redis, PostgreSQL, MariaDB e MySQL. In questo tutorial abbiamo scelto il servizio di database MySQL.

Seguiamo le istruzioni ufficiali per aggiungere un database, ricordandoci di selezionare lo stesso data center che abbiamo scelto per l’applicazione Flask.

Dopo aver creato il database, selezioniamolo dall’elenco dei server DB disponibili e scorriamo fino alla sezione Connessioni interne / Applicazioni consentite della scheda Panoramica. Facendo clic sul pulsante Aggiungi connessione, il servizio dell’applicazione Flask nello stesso data center sarà disponibile per la selezione:

Schermata della finestra di dialogo per l'aggiunta di una connessione al database interno in MyKinsta.
Aggiunta di una connessione interna a un’applicazione dopo la creazione di un database.

Facciamo clic sulla casella Aggiungi variabili d’ambiente all’applicazione prima di creare la nuova connessione. In questo modo vengono visualizzate le variabili d’ambiente che riporteranno i segreti del database, il tutto gestito in modo sicuro senza la necessità di un file .env.

Schermata della finestra di dialogo per l'aggiunta di variabili d'ambiente per le credenziali del database.
Aggiunta di variabili d’ambiente per una connessione interna al database.

Nella parte inferiore della finestra di dialogo, le impostazioni Disponibile durante il runtime e Disponibile durante il processo di build saranno abilitate per impostazione predefinita, ed è esattamente quello che vogliamo.

Dopo aver cliccato sul pulsante Aggiungi connessione, le variabili d’ambiente necessarie per l’accesso al database saranno applicate alle Impostazioni del progetto nella cruscotto delle Applicazioni di MyKinsta:

Schermata di una finestra di dialogo di MyKinsta che mostra le variabili d'ambiente passate dal database a un'applicazione.
Variabili d’ambiente del database passate all’applicazione Python Flask.

In questo modo, anche quando eseguiremo nuovamente la build dell’applicazione in seguito a futuri miglioramenti, i dati di connessione al database persisteranno.

Schermata dell'applicazione Python Flask live sulla piattaforma Kinsta.
L’applicazione Python Flask vive sulla piattaforma Kinsta.

Ed è fatta! Abbiamo appena creato un’applicazione Python Flask e l’abbiamo distribuita sulla piattaforma Kinsta.

Riepilogo

Il framework personalizzabile di Flask semplifica notevolmente la creazione di un’applicazione Python. L’utilizzo di Kinsta per distribuire un’applicazione Flask rende le cose ancora più semplici, accelerando lo sviluppo e la distribuzione dell’applicazione.

In questo caso, abbiamo imparato a costruire una semplice applicazione collegata a un database all’interno di un ambiente di sviluppo locale e poi a renderla disponibile al resto del mondo sulle piattaforme di Hosting di Applicazioni web e di Hosting di Database di Kinsta.

Date un’occhiata a cos’altro potete costruire sulla nostra piattaforma sfogliando i nostri template di avvio rapido.

Steve Bonisteel Kinsta

Steve Bonisteel è un Technical Editor di Kinsta che ha iniziato la sua carriera di scrittore come giornalista della carta stampata, inseguendo ambulanze e camion dei pompieri. Dalla fine degli anni '90 si occupa di tecnologia legata a Internet.