Come creare un’app Django e collegarla a un database

Introduzione

Django è un framework web gratuito e open-source scritto in Python. Questo strumento permette la scalabilità, la riutilizzabilità e lo sviluppo rapido.

In questo tutorial, imparerai come impostare le fondamenta iniziali per un sito web di blog con connessioni a un database MySQL. Ciò comporterà la creazione della struttura scheletrica dell’applicazione web di blog utilizzando django-admin, la creazione del database MySQL e la connessione dell’applicazione web al database.

Django ti fornirà un ambiente di sviluppo per lavorare sulla tua applicazione web di blog, ma dovrai compiere ulteriori passaggi prima di rendere il tuo blog disponibile su Internet.

Prerequisiti

Per seguire questo tutorial, avrai bisogno di:

• Un server Ubuntu 22.04 con un utente non root abilitato a sudo e un firewall. Segui la nostra guida all’installazione iniziale del server Ubuntu 22.04 per configurarlo.
• MySQL è stato installato per servire come database. Puoi configurarlo seguendo il nostro tutorial su Come Installare MySQL su Ubuntu 22.04.
• A Python environment set up. For this, follow our tutorial on How To Install Python 3 and Set Up a Programming Environment on Ubuntu 22.04
  .

Una volta che tutto è installato e configurato, puoi passare al primo passaggio.

Passaggio 1 — Creare il Database

Django supporta diversi sistemi di gestione di database popolari, ma questa guida si concentra sulla connessione di Django a un database MySQL. Per fare questo, è necessario creare un database sulla tua istanza MySQL e un profilo utente MySQL che Django può utilizzare per connettersi al database.

Per configurare questo, connettiti al tuo database MySQL come utente MySQL root con il seguente comando:

sudo mysql

Saprai di essere nel server MySQL quando cambierà il prompt:

Ispeziona i database correnti con il seguente comando:

SHOW DATABASES;

Il tuo output sarà simile al seguente, supponendo che tu non abbia ancora creato alcun database:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| mysql         	|
| performance_schema |
| sys            	|
+--------------------+
4 rows in set (0.00 sec)

Per impostazione predefinita, avrai già creati 4 database: information_schema, MySQL, performance_schema e sys. Non sarà necessario toccarli, poiché contengono informazioni importanti per il server MySQL stesso.

Invece, crea il database iniziale che conterrà i dati per il tuo blog.

Per creare un database in MySQL esegui il seguente comando, utilizzando un nome significativo per il tuo database:

CREATE DATABASE blog_data;

Al completamento della creazione del database, l’output sarà il seguente:

Output
Query OK, 1 row affected (0.00 sec)

Verifica che il database ora sia elencato tra quelli disponibili:

SHOW DATABASES;

Il database blog_data dovrebbe ora essere elencato tra i database inclusi nell’output:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| blog_data      	|
| mysql             	|
| performance_schema |
| sys            	|
+--------------------+
5 rows in set (0.00 sec)

Successivamente, crea un account utente separato in MySQL che Django utilizzerà per operare sul nuovo database. La creazione di database e account specifici può supportarti dal punto di vista della gestione e della sicurezza. Utilizzeremo il nome djangouser in questa guida. Puoi utilizzare qualsiasi nome preferisci, ma può essere utile scegliere un nome descrittivo.

Creerai questo account, imposterai una password e concederai l’accesso al database che hai creato. Per prima cosa, crea l’utente e imposta la loro password digitando il seguente comando. Ricorda di scegliere una password sicura per il tuo database sostituendo password in questo esempio:

CREATE USER 'djangouser'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Fai sapere al database che djangouser dovrebbe avere completo accesso al database che hai configurato:

GRANT ALL ON blog_data.* TO 'djangouser'@'localhost';

Ora hai un database e un account utente, ognuno creato appositamente per Django. Esegui il flush dei privilegi in modo che l’istanza corrente di MySQL sia a conoscenza delle modifiche recenti apportate:

FLUSH PRIVILEGES;

Con questo completato, puoi uscire dal server MySQL scrivendo EXIT; o premendo CTRL + D.

Passo 2 — Creazione di un File di Opzioni MySQL

Invece di specificare i dettagli della connessione MySQL nel file di configurazione di Django, puoi memorizzarli in un file di opzioni. Molti programmi MySQL possono leggere file di opzioni — anche noti come file di configurazione — per informazioni come le opzioni di avvio o i dettagli della connessione. Questo può essere comodo, poiché devi memorizzare solo le credenziali di accesso al database in un unico posto.

Apri il file di configurazione my.cnf con il tuo editor di testo preferito per aggiornare le tue credenziali MySQL. Qui useremo nano:

sudo nano /etc/mysql/my.cnf

Aggiungi le seguenti righe e includi le tue informazioni pertinenti:

…

[client]
database = blog_data
user = djangouser
password = your_actual_password
default-character-set = utf8

Nota che utf8 è impostato come codifica predefinita. Questo è un modo comune per codificare i dati unicode in MySQL. Quando sei sicuro che i tuoi dettagli siano corretti, salva e chiudi il file. Se hai usato nano per modificare il file, puoi farlo premendo CTRL + O per salvare il file e poi CTRL + X per chiudere l’editor.

Una volta che il file è stato modificato, riavvia MySQL affinché le modifiche abbiano effetto:

sudo systemctl daemon-reload
sudo systemctl restart mysql

Nota che riavviare MySQL richiede alcuni secondi, quindi sii paziente.

Passaggio 3 — Creazione dello Schema Iniziale del Progetto Django

In questo passaggio, preparerai il terreno per la tua applicazione generando lo schema del progetto usando il comando django-admin.

Naviga nella directory in cui desideri creare la tua app di blog. All’interno di quella directory, crea una directory specifica per costruire l’app. Chiama la directory con un nome significativo per l’app che stai costruendo. Come esempio, chiameremo la nostra my_blog_app:

mkdir my_blog_app

Ora, naviga nella directory appena creata:

cd my_blog_app

Successivamente, passa all’ambiente di programmazione che desideri utilizzare per lavorare in Django. Puoi utilizzarne uno esistente o crearne uno nuovo. Il seguente comando crea un nuovo ambiente chiamato env, ma dovresti usare un nome che abbia significato per te:

python3 -m venv env

Una volta creato, puoi attivarlo:

. env/bin/activate

Ora installa Django in questo ambiente se non lo hai già fatto:

pip install django

Mentre sei nella directory my_blog_app, genera un progetto eseguendo il seguente comando:

django-admin startproject blog

Verifica che abbia funzionato navigando nella directory blog/:

cd blog

Poi esegui ls per verificare che siano stati creati i file e le directory necessari all’interno della cartella del progetto:

ls

L’output elencherà la directory blog e un file manage.py:

Output
blog manage.py

Ora che hai creato una directory del progetto contenente l’avvio iniziale della tua applicazione di blog, puoi procedere al passaggio successivo.

Passaggio 4 — Installazione del connettore del database MySQL

Per utilizzare MySQL nel tuo progetto, hai bisogno di una libreria del connettore del database Python 3 compatibile con Django. Questo passaggio descrive come installare un tale connettore del database, mysqlclient, che è una versione forkata di MySQLdb.

Prima, installa gli header di sviluppo e le librerie MySQL necessarie:

sudo apt install libmysqlclient-dev default-libmysqlclient-dev

Successivamente, usa pip per installare il pacchetto wheel. Wheel è un formato di confezionamento utilizzato in Python per installare moduli dall’Indice dei pacchetti Python. L’installazione di programmi Python dai pacchetti wheel è generalmente più veloce e più efficiente in termini di risorse rispetto alla compilazione dei pacchetti dal codice sorgente. Per installare e lavorare con programmi confezionati come wheel, devi prima assicurarti che il pacchetto wheel sia installato:

pip install wheel

Quindi procedi con l’installazione di mysqlclient:

pip install mysqlclient

La tua output sarà simile al seguente, verificando che il client sia stato correttamente installato:

Output
...
Successfully installed mysqlclient-2.1.1

Hai ora installato con successo il client MySQL utilizzando la libreria del connettore mysqlclient di PyPi.

Passaggio 5 — Modifica delle Impostazioni

Quando hai eseguito django-admin in precedenza, ha creato un file di configurazione per Django chiamato settings.py. Devi modificare alcune delle impostazioni predefinite in questo file per far funzionare tutto correttamente.

Per modificare il file, apri il percorso del file con il tuo editor di testo preferito:

nano ~/my_blog_app/blog/blog/settings.py

Perché il tuo blog abbia l’orario corretto associato alla tua area, puoi modificare il file settings.py in modo che utilizzi il fuso orario corrente. Puoi utilizzare questo elenco dei fusi orari come riferimento. Per il nostro esempio, useremo l’orario America/New_York.

All’interno del file, vai al campo TIME_ZONE vicino alla sezione inferiore del file:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True
...

Modifica la riga TIME_ZONE, in modo che sia impostata sul tuo fuso orario corrente. Useremo il fuso orario per New York in questo esempio:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'America/New_York'

USE_I18N = True
...

Tieni aperto il file perché successivamente devi aggiungere un percorso per i tuoi file statici. I file che vengono serviti dalla tua applicazione web Django sono definiti come file statici. Questo potrebbe includere qualsiasi file necessario per rendere completa la pagina web, inclusi JavaScript, CSS e immagini.

Vai alla fine del file settings.py e aggiungi STATIC_ROOT:

…

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
...

Ora che hai aggiunto il fuso orario e il percorso per i file statici, aggiungi il tuo IP all’elenco degli host consentiti. Passa alla riga del file settings.py dove si trova ALLOWED_HOSTS, sarà verso l’inizio del file settings.py. Aggiungi l’indirizzo IP del tuo server, circondato da singoli apici, tra le parentesi quadrate:

...
ALLOWED_HOSTS = ['your_server_IP_address']
...

Successivamente, aggiungi il modulo OS di Python che fornisce varie funzionalità per le directory. Senza questo modulo, riceverai un errore durante la configurazione dell’utente amministrativo per iniziare a utilizzare l’interfaccia di Django. Per fare ciò, devi importare il modulo os che funzionerà sul tuo sistema operativo rispettivo. Aggiungi la riga import os sopra la riga from pathlib import Path:

...
import os
from pathlib import Path
...

Fino ad ora hai modificato il tuo file settings.py in modo che il fuso orario corretto sia stato configurato. Hai anche aggiunto il percorso per i tuoi file statici, impostato il tuo indirizzo IP come ALLOWED_HOST per la tua applicazione, e importato il modulo OS di Python per aiutarti a configurare in seguito l’utente amministrativo.

L’ultimo snippet da aggiungere al tuo file sono le credenziali di connessione al database per collegare la tua applicazione blog Django a MySQL. A tal fine, trova il dizionario DATABASES all’interno del file. Avrà l’aspetto seguente per impostazione predefinita:

…

DATABASES = {
	'default': {
    	'ENGINE': 'django.db.backends.sqlite3',
    	'NAME': BASE_DIR / 'db.sqlite3',
	}
}
...

Sostituisci le opzioni ENGINE e NAME del dizionario DATABASES con le seguenti righe:

...

DATABASES = {
	'default': {
    	'ENGINE': 'django.db.backends.mysql',
    	'OPTIONS': {
        	'read_default_file': '/etc/mysql/my.cnf',
    	},
	}
}
...

La linea 'ENGINE': 'django.db.backends.mysql' dice a Django di utilizzare il backend del database MySQL incorporato. L’opzione read_default_file punta a /etc/mysql/my.cnf, il file di opzioni MySQL che hai modificato in precedenza. Questo dice a Django dove può trovare i dettagli di connessione rilevanti per connettersi al database MySQL creato nel Passaggio 1.

Nota che Django legge le impostazioni di connessione al database nell’ordine seguente:

• OPTIONS
• NAME, USER, PASSWORD, HOST, PORT
• File di opzioni MySQL

Indirizzando Django al file di opzioni MySQL all’interno dell’impostazione OPTIONS come in questo esempio, avrà la precedenza su qualsiasi impostazione NAME, che altrimenti sovrascriverebbe il file di opzioni se tu puntassi ad esso al di fuori dell’impostazione OPTIONS.

A questo punto, puoi salvare e chiudere il file.

Successivamente, controlla le modifiche delle migrazioni eseguendo il seguente comando:

python manage.py makemigrations

Poi, esegui migrate per assicurarti che le modifiche vengano applicate:

python manage.py migrate

Ora che le tue modifiche sono state migrare, puoi creare un utente amministratore da utilizzare per l’interfaccia amministrativa di Django. Fai questo con il comando createsuperuser:

python manage.py createsuperuser

Ti verrà chiesto di fornire un nome utente, un indirizzo email e una password per il tuo utente.

Dopo aver completato queste informazioni, puoi passare all’aggiustamento delle impostazioni del firewall per consentire i test.

Passaggio 6 — Regolazione delle Impostazioni del Firewall

Prima di testare la tua applicazione web Django, devi assicurarti che le impostazioni del firewall siano state regolate. Inizia cambiando le impostazioni del tuo ufw per consentire l’accesso alla porta 8000:

sudo ufw allow 8000

Verifica lo stato per assicurarti che queste impostazioni di autorizzazione siano state aggiornate correttamente:

sudo ufw status

Output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
8000                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
8000 (v6)                  ALLOW       Anywhere (v6)

Le impostazioni del tuo firewall sono ora regolarmente aggiornate per consentire il test della connessione nel prossimo passaggio.

Passaggio 7 — Test della Connessione MySQL all’Applicazione

Ora puoi verificare che le configurazioni in Django rilevino correttamente il tuo server MySQL. Puoi farlo avviando il server. Se fallisce, significa che la connessione non funziona correttamente. Altrimenti, la connessione è valida.

Prima naviga nella seguente directory:

cd ~/my_blog_app/blog/

Da lì, esegui il seguente comando:

python manage.py runserver your-server-ip:8000

Riceverai un output simile al seguente:

Output
Performing system checks...

System check identified no issues (0 silenced).
July 19, 2022 - 13:26:08
Django version 4.0.6, using settings 'blog.settings'
Starting development server at http://your-server-ip:8000/
Quit the server with CONTROL-C.

Segui le istruzioni dall’output e visita il link suggerito, http://indirizzo-ip-del-tuo-server:8000/, per visualizzare la tua applicazione web e verificare che funzioni correttamente.

Se la tua pagina appare simile allo screenshot sopra, la tua applicazione Django sta funzionando come previsto.

Quando hai finito di testare la tua app, premi CTRL + C per interrompere il comando runserver. Questo ti riporterà all’ambiente di programmazione.

Quando sei pronto per uscire dall’ambiente Python, puoi eseguire il comando deactivate:

deactivate

Disattivare il tuo ambiente di programmazione ti riporterà al prompt del terminale.

Conclusione

In questo tutorial, hai creato le basi iniziali del tuo blog Django. Hai installato, configurato e collegato MySQL al backend di Django. Hai anche aggiunto alcune informazioni importanti al file settings.py della tua applicazione come TIME_ZONE, ALLOWED_HOSTS, import os, e le credenziali del database per collegare la tua applicazione Django a MySQL. Hai anche regolato le impostazioni del firewall per assicurarti che i test procedano senza intoppi.

Ora che queste impostazioni e configurazioni di base sono completate, puoi iniziare a sviluppare modelli e applicare migrazioni nella tua applicazione Django.