Guida all'installazione del framework web Django su Debian 12

Django è un framework web Python gratuito e open source utilizzato per sviluppare siti web e applicazioni dinamiche. Viene utilizzato per lo sviluppo di applicazioni Python complesse e basate su database.

Django segue l’architettura MVC (Model-View-Controller), che consente agli sviluppatori di scrivere meno codice e creare un nuovo sito web in breve tempo. Django può essere installato su qualsiasi sistema operativo che esegue Python, inclusi Windows, macOS, Linux/Unix e Solaris.

Questa guida ti mostrerà come installare il framework web Django su un server Debian 12. Inizierai con Django creando il tuo primo progetto Django utilizzando PostgreSQL come database predefinito, il server WSGI Gunicorn e Nginx come proxy inverso.

Prerequisiti

Per iniziare, assicurati di avere quanto segue:

• Una macchina Debian 12.
• Un utente non root con privilegi di amministratore sudo.

Installazione delle dipendenze

Nel primo passaggio, installerai le dipendenze dei pacchetti per l’installazione del framework web Django, che includono i seguenti pacchetti:

• Server PostgreSQL: Per impostazione predefinita, Django utilizza SQLite, e questo esempio ti mostrerà come utilizzare PostgreSQL come database per il tuo progetto Django.
• Supervisor: È un gestore di processi, e eseguirai la tua applicazione Django con Gunicorn e Supervisor.
• Server web Nginx: Questo esempio ti mostrerà come utilizzare Nginx come proxy inverso per il tuo progetto Django. Questo consente al tuo progetto Django di essere accessibile tramite un nome di dominio locale.

Per prima cosa, esegui il comando apt qui sotto per aggiornare e aggiornare l’indice dei pacchetti.

sudo apt update

Ora installa le dipendenze dei pacchetti come l’ambiente virtuale Python, il gestore di pacchetti pip, PostgreSQL e il driver libpq5, Nginx e Supervisor.

sudo apt install build-essential python3-dev python3-pip python3-venv nginx supervisor postgresql libpq5 libpq-dev

Digita y per confermare e procedere con l’installazione.

Una volta installate le dipendenze, esegui i seguenti comandi per verificare i servizi PostgreSQL, Nginx e Supervisor e assicurati che quei servizi siano in esecuzione e abilitati.

Controlla il servizio PostgreSQL utilizzando il comando qui sotto.

sudo systemctl is-enabled postgresql  
sudo systemctl status postgresql

Se PostgreSQL è in esecuzione e abilitato, sotto l’output dovresti ottenere.

Controlla il servizio Nginx utilizzando il comando qui sotto.

sudo systemctl is-enabled nginx  
sudo systemctl status nginx

Se Nginx è in esecuzione e abilitato, di seguito è l’output che dovresti ottenere.

Infine, controlla il Supervisor utilizzando il comando qui sotto.

sudo systemctl is-enabled supervisor  
sudo systemctl status supervisor

Dovresti vedere che il Supervisor è in esecuzione e abilitato.

Installazione di Django tramite Pip

Il framework web Django può essere installato in diversi modi, incluso manualmente tramite Git, tramite il gestore di pacchetti Pip Python, o combinato con un ambiente isolato con il modulo venv e Pip. In questo esempio, installerai Django tramite il gestore di pacchetti Pip nell’ambiente Python isolato.

Accedi al tuo utente tramite il comando qui sotto.

su - username

Ora crea una nuova directory di progetto ~/testdjango e spostati in essa.

mkdir -p ~/testdjango; cd ~/testdjango

Successivamente, esegui il seguente comando per creare un nuovo ambiente virtuale Python chiamato venv nella tua attuale directory di progetto.

python3 -m venv venv

Poi attivalo utilizzando il comando qui sotto. Una volta attivato l’ambiente virtuale, il tuo prompt attuale diventerà come (venv) bob@hostname:.

source venv/bin/activate

All’interno dell’ambiente virtuale venv, esegui il comando pip qui sotto per installare il framework web Django. Questo installerà Django sotto il tuo ambiente virtuale Python, non a livello di sistema.

pip install django  
  
or  
  
pip install django==4.2.4

Di seguito l’installazione di Django è in esecuzione.

Verifica la tua versione di Django una volta terminata l’installazione utilizzando il comando django-admin qui sotto.

django-admin --version

Il seguente output conferma che Django 4.2.4 è installato all’interno dell’ambiente virtuale venv tramite il gestore di pacchetti Pip Python.

Creazione del primo progetto Django

Questa sezione ti insegnerà come creare il primo progetto Django e utilizzare il server PostgreSQL come database predefinito. Per raggiungere questo obiettivo, completa i seguenti passaggi:

• Preparare il database e l’utente.
• Creare il progetto Django tramite django-admin.
• Migrare il database e generare file statici.
• Creare utenti amministratori ed eseguire Django.

Preparare il database e l’utente

Esegui il comando pip qui sotto per installare il pacchetto Python psycopg2 nel tuo ambiente virtuale. Questo è il driver Python che sarà utilizzato da Django per connettersi al server di database PostgreSQL.

pip install psycopg2  
exit

Ora esegui il seguente comando per accedere alla shell di PostgreSQL.

sudo -u postgres psql

Esegui le seguenti query per creare un nuovo database e un utente per il tuo progetto Django. Il seguente esempio creerà un nuovo database djangodb, utente django e la password p4ssw0rd.

CREATE USER django WITH PASSWORD 'p4ssw0rd';  
CREATE DATABASE djangodb OWNER django;

Successivamente, esegui le seguenti query per verificare l’elenco dei database e degli utenti sul tuo server PostgreSQL.

du  

l

Dovresti vedere che il database djangodb e l’utente django sono stati creati.

Digita quit per uscire dal server PostgreSQL.

Creazione del progetto Django

Prima di creare il progetto Django, accedi al tuo utente e attiva l’ambiente virtuale venv.

su - bob  
cd testdjango; source venv/bin/activate

Per creare un nuovo progetto Django, esegui il comando django-admin qui sotto. In questo caso, creerai un nuovo progetto testapp nella tua directory di lavoro attuale.

django-admin startproject testapp .

Una volta creato il progetto, la nuova directory testapp sarà creata nella tua directory di lavoro.

Successivamente, esegui il seguente comando per generare una chiave segreta casuale per il tuo progetto Django. Assicurati di copiare l’output, perché lo utilizzerai per proteggere la tua installazione di Django.

python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'

Ora usa il tuo editor preferito e apri il file testapp/settings.py.

nano testapp/settings.py

In cima alla riga, inserisci la seguente configurazione.

import os

Inserisci la tua chiave segreta nel parametro SECRET_KEY.

SECRET_KEY = 'fzahzbm*wrxoleqb0^-3%%tf^y!b6lsc5-c#2^@#s6gkyrl2ef'

Inserisci il tuo indirizzo IP locale e il nome di dominio locale nel parametro ALLOWED_HOSTS.

ALLOWED_HOSTS = ['127.0.0.1','192.168.10.15','first-django.dev']

Cambia la configurazione del database predefinito con i dettagli del server PostgreSQL in questo modo:

DATABASES = {  
    'default': {  
        'ENGINE': 'django.db.backends.postgresql_psycopg2',  
        'NAME': 'djangodb',  
        'USER': 'django',  
        'PASSWORD': 'p4ssw0rd',  
        'HOST': '127.0.0.1',  
        'PORT': '5432',  
    }  
}

Infine, aggiungi il parametro STATIC_ROOT per definire una directory per memorizzare i file statici.

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

Salva il file ed esci dall’editor quando hai finito.

Migrazione del database e generazione di file statici

Prima di migrare il database, esegui il seguente comando per assicurarti di avere una corretta configurazione del database.

python3 manage.py check --database default

Se non ci sono errori, esegui il seguente comando per migrare il database.

python3 manage.py makemigrations  
python3 manage.py migrate

Se tutto va bene, dovresti vedere il processo di migrazione del database in questo modo:

Infine, esegui il seguente comando per generare file statici per il tuo progetto Django. Dopo che il comando è stato eseguito, la nuova directory static sarà creata e i file statici saranno generati al suo interno.

python3 manage.py collectstatic

Di seguito è l’output quando si generano file statici.

Creazione di un utente amministratore ed esecuzione di Django

Esegui il seguente comando per creare l’utente amministratore per il tuo progetto Django.

python3 manage.py createsuperuser

Inserisci il tuo indirizzo email e la password quando richiesto.

Una volta creato l’utente amministratore, esegui il comando qui sotto per eseguire il tuo progetto Django.

python3 manage.py runserver 0.0.0.0:8080

Dopo che il comando è stato eseguito, il tuo progetto Django verrà eseguito sul tuo indirizzo IP locale sulla porta 8080.

Ora apri il tuo browser web e visita l’indirizzo IP del server seguito dalla porta 8080, http://192.168.10.15:8080/. Se la tua installazione di Django ha avuto successo, dovresti vedere la pagina predefinita index.html di Django come segue:

Ora accedi alla tua amministrazione di Django tramite il percorso URL /admin, http://192.168.10.15:8080/admin. Inserisci il tuo utente amministratore di Django e la password, quindi fai clic su Accedi.

Dovresti vedere un esempio di dashboard utente di Django come questo:

Premi Ctrl+c per terminare il processo.

Esecuzione di Django con Gunicorn e Supervisor

A questo punto, hai completato l’installazione di Django e creato il tuo primo progetto Django. Nel passaggio successivo, configurerai Django per essere eseguito in background utilizzando il server WSGI Gunicorn e il gestore di processi Supervisor.

Installazione di Gunicorn

All’interno dell’ambiente virtuale venv, esegui il comando pip qui sotto per installare gunicorn.

pip install gunicorn

Ora esegui il seguente comando per disattivare l’ambiente virtuale venv e tornare al tuo utente root.

deactivate  
exit

Esecuzione di Django con Gunicorn e Supervisor

Crea una nuova configurazione del supervisore /etc/supervisor/conf.d/testapp.conf utilizzando il seguente comando dell’editor nano.

sudo nano /etc/supervisor/conf.d/testapp.conf

Inserisci la seguente configurazione e assicurati di cambiare le informazioni dettagliate del nome dell’applicazione, il percorso del progetto e l’utente con le tue informazioni. In questo esempio, eseguirai il tuo progetto Django sotto il socket UNIX /home/bob/testdjango/testapp.sock.

[program:testapp]   
command=/bin/bash -c 'source /home/bob/testdjango/venv/bin/activate; gunicorn -t 3000 --workers 3 --bind unix:unix:/home/bob/testdjango/testapp.sock testapp.wsgi:application -w 2'  
directory=/home/bob/testdjango  
user=bob  
group=www-data  
autostart=true   
autorestart=true   
stdout_logfile=/home/bob/testdjango/testapp.log   
stderr_logfile=/home/bob/testdjango/error.log

Salva ed esci dal file quando hai finito.

Infine, esegui il seguente comando per riavviare il servizio del supervisore e applicare le modifiche. Quindi, verifica il servizio del supervisore per assicurarti che il servizio sia in esecuzione.

sudo systemctl restart supervisor  
sudo systemctl status supervisor

Controllo di Django tramite Supervisorctl

Esegui il comando supervisorctl qui sotto per controllare lo stato dell’applicazione che sta girando all’interno del supervisore.

sudo supervisorctl status

Dovresti vedere che l’applicazione testapp è in esecuzione con PID 2577.

Infine, controlla la tua applicazione Django tramite il comando curl qui sotto.

curl --unix-socket /home/bob/testdjango/testapp.sock 127.0.0.1

Se tutto va bene, dovresti vedere il codice sorgente della pagina index.html del tuo progetto Django.

Configurazione di Nginx come proxy inverso per Django

Ora che il tuo progetto Django è in esecuzione in background, il passaggio successivo è configurare Nginx come proxy inverso per Django. Il seguente esempio utilizzerà un nome di dominio locale.

Crea una nuova configurazione del blocco server Nginx /etc/nginx/sites-available/django utilizzando il seguente editor nano.

sudo nano /etc/nginx/sites-available/django

Inserisci la seguente configurazione e assicurati di cambiare il nome di dominio nel parametro server_name.

server {  
    listen 80;  
    server_name first-django.dev;  
  
    location = /favicon.ico { access_log off; log_not_found off; }  
    try_files $uri @django;  
    location /static {  
        alias /home/bob/testdjango/static/;  
    }  
  
    location @django {  
        proxy_set_header Host $http_host;  
        proxy_set_header X-Real-IP $remote_addr;  
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;  
        proxy_set_header X-Forwarded-Proto $scheme;  
        proxy_pass http://unix:/home/bob/testdjango/testapp.sock;  
    }  
}

Salva ed esci dal file quando hai finito.

Ora esegui il seguente comando per attivare il blocco server /etc/nginx/sites-available/django, quindi verifica la sintassi di Nginx per assicurarti di avere una sintassi corretta.

sudo ln -s /etc/nginx/sites-available/django /etc/nginx/sites-enabled/  
sudo nginx -t

Dovresti ottenere l’output syntax is ok - test is successful quando hai una sintassi corretta di Nginx.

Infine, riavvia il tuo servizio Nginx eseguendo il seguente comando e applicando le modifiche che hai effettuato.

sudo systemctl restart nginx

Con questo, il tuo progetto Django è accessibile tramite un nome di dominio locale.

Sul tuo computer locale, modifica il file /etc/hosts per Linux o C:\Windows\System32\drivers\etc\hosts per Windows. Quindi, definisci il tuo indirizzo IP del server e il nome di dominio come segue.

192.168.10.15  first-django.dev

Salva ed esci dal file quando hai finito.

Torna al tuo browser web e visita il tuo nome di dominio locale, dovresti vedere la pagina predefinita index.html del tuo progetto Django.

Conclusione

In sintesi, seguendo questa guida passo passo, hai installato il framework web Django con PostgreSQL, Nginx, Gunicorn e Supervisor su Debian 12. Hai imparato come creare un progetto Django con PostgreSQL come database predefinito e eseguire Django con Gunicorn e Supervisor. Ora puoi creare e sviluppare la tua applicazione con Django.