Come installare il framework Django Python su Ubuntu 22.04

Django è un framework Python utilizzato per sviluppare siti web e applicazioni dinamiche. Segue l’architettura MVC (Model-View-Controller). Utilizzare Django accelera il processo di sviluppo poiché la maggior parte delle attività sottostanti sono gestite da esso.

Questo tutorial ti insegnerà come installare il framework Django su un server Ubuntu 22.04. Creerai anche un progetto demo e lo testerai.

Prerequisiti

• Un server che esegue Ubuntu 22.04.
• Un utente sudo non root.
• Assicurati che tutto sia aggiornato. $ sudo apt update $ sudo apt upgrade

Installa Django

Ci sono diversi metodi per installare Django. Decidere quale funziona meglio per te dipende da come vuoi configurare il tuo ambiente di sviluppo e dalle tue esigenze. Ogni metodo ha il proprio insieme di pro e contro. Esaminiamo tutti questi metodi.

Installa dai repository di Ubuntu

Il metodo più semplice per installare Django è utilizzare i repository di Ubuntu. Ubuntu 22.04 include Python 3.10. Puoi verificarlo utilizzando il seguente comando.

$ python3 -V
Python 3.10.4

Installa Django utilizzando il seguente comando.

$ sudo apt install python3-django

Esegui il seguente comando per verificare l’installazione riuscita.

$ django-admin --version
3.2.12

La versione di Django fornita con Ubuntu è l’attuale versione LTS supportata fino al 2024. Tuttavia, non è l’ultima versione. Se desideri installare una versione recente, questo metodo non fa per te.

Installa utilizzando pip

Questo è il modo più comune per installare Django. Il modo raccomandato per farlo è creare un ambiente virtuale Python. Questo ti consente di installare pacchetti Python senza influenzare il sistema.

Installa i moduli pip e venv. venv è utilizzato per creare ambienti virtuali Python e pip installa pacchetti Python.

$ sudo apt install python3-pip python3-venv

Creiamo una directory per il progetto demo.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Crea un ambiente virtuale utilizzando il seguente comando. Sostituisci sample_env con il nome che vuoi dare al tuo ambiente virtuale.

$ python3 -m venv sample_env

Questo installa una versione portatile di Python, pip all’interno della tua directory di progetto. Per installare pacchetti nel progetto, devi attivare l’ambiente utilizzando il seguente comando.

$ source sample_env/bin/activate

Il tuo prompt della shell cambierà per riflettere l’ambiente virtuale.

(sample_env) navjot@django:~/sampleproject$

Ora che l’ambiente virtuale è attivato, usa pip per installare Django. Esegui il seguente comando per installare Django.

(sample_env) $ pip install django

Verifica l’installazione.

(sample_env) $ django-admin --version
4.0.5

A seconda delle esigenze del tuo progetto, puoi installare una versione diversa di Django nel seguente modo.

(sample_env) $ pip install django==3.2.1

Verifica l’installazione.

(sample_env) $ django-admin --version
3.2.1

Come puoi vedere, questo metodo installa una versione più recente di Django rispetto alla versione ottenuta dal repository di Ubuntu.

Per uscire dall’ambiente virtuale, esegui il seguente comando.

(sample_env) $ deactivate

Installa la versione di sviluppo

Puoi anche utilizzare pip per installare la versione di sviluppo di Django. Per questo, prenderemo la versione di sviluppo dal repository Github di Django.

Clona il repository nella directory ~/django-dev utilizzando il seguente comando.

$ git clone https://github.com/django/django ~/django-dev

Passa alla directory appena creata.

$ cd ~/django-dev

Crea l’ambiente virtuale.

$ python3 -m venv dev_django_env

Attiva l’ambiente.

$ source dev_django_env/bin/activate

Installa Django utilizzando pip. Il flag -e lo installa in modalità modificabile, necessaria se stai installando dal controllo di versione.

(dev_django_dev) $ pip install -e ~/django-dev

Verifica l’installazione.

(dev_django_dev) $ django-admin --version
4.2.dev20220628195651

Come puoi vedere, la versione qui è l’ultima versione di sviluppo. La versione di sviluppo di Django non è utile per ambienti di produzione.

Crea un progetto di esempio

Costruiamo un progetto Django di esempio. Crea una directory per il progetto di esempio.

$ mkdir ~/dj-sample
$ cd ~/dj-sample

Crea un ambiente virtuale Python.

$ python3 -m venv sample_proj

Attiva l’ambiente.

$ source sample_proj/bin/activate

Installa Django.

(sample_proj) $ pip install django

Per costruire il progetto, dobbiamo utilizzare il comando startproject. Questo comando crea un’altra directory che include:

• Uno script di gestione, manage.py, utilizzato per amministrare compiti specifici di Django.
• Una directory con lo stesso nome del progetto che include il codice del progetto.

Creeremo la directory del progetto nella nostra directory di lavoro attuale. Per farlo, usa il carattere punto (.) alla fine del seguente comando.

(sample_proj) $ django-admin startproject demoproject .

Successivamente, dobbiamo migrare il database utilizzando il comando migrate. Le migrazioni in Django propagano le modifiche che apporti ai tuoi modelli nel tuo schema di database. Python utilizza il database SQLite per impostazione predefinita.

(sample_proj) $ python manage.py migrate

Otterrai il seguente output.

Operazioni da eseguire:
  Applica tutte le migrazioni: admin, auth, contenttypes, sessions
Esecuzione delle migrazioni:
  Applicazione contenttypes.0001_initial... OK
  Applicazione auth.0001_initial... OK
  Applicazione admin.0001_initial... OK
  Applicazione admin.0002_logentry_remove_auto_add... OK
  Applicazione admin.0003_logentry_add_action_flag_choices... OK
  Applicazione contenttypes.0002_remove_content_type_name... OK
  Applicazione auth.0002_alter_permission_name_max_length... OK
  Applicazione auth.0003_alter_user_email_max_length... OK
  Applicazione auth.0004_alter_user_username_opts... OK
  Applicazione auth.0005_alter_user_last_login_null... OK
  Applicazione auth.0006_require_contenttypes_0002... OK
  Applicazione auth.0007_alter_validators_add_error_messages... OK
  Applicazione auth.0008_alter_user_username_max_length... OK
  Applicazione auth.0009_alter_user_last_name_max_length... OK
  Applicazione auth.0010_alter_group_name_max_length... OK
  Applicazione auth.0011_update_proxy_permissions... OK
  Applicazione auth.0012_alter_user_first_name_max_length... OK
  Applicazione sessions.0001_initial... OK

Successivamente, crea un utente amministrativo per accedere all’interfaccia di amministrazione di Django.

(sample_proj) $ python manage.py createsuperuser

Ti verrà chiesto un nome utente, un’email e una password.

Nome utente (lascia vuoto per usare 'navjot'):
Indirizzo email: [email protected]
Password:
Password (di nuovo):
Superutente creato con successo.

Testa il server di sviluppo

È tempo di testare l’applicazione. Per farlo, devi modificare la direttiva ALLOWED_HOSTS nelle impostazioni di Django. Questa direttiva definisce l’elenco degli indirizzi IP e dei nomi di dominio che hanno accesso all’applicazione Django.

Apri il file delle impostazioni utilizzando il seguente comando.

(sample_proj) $ nano demoproject/settings.py

Trova la seguente voce.

ALLOWED_HOSTS = []

Inserisci il tuo indirizzo IP del server tra le parentesi quadre. Ogni voce deve essere racchiusa tra virgolette e più voci devono essere separate da virgole. Inserire www.example.com corrisponderà esattamente. Tuttavia, .example.com corrisponderà a example.com e www.example.com, e qualsiasi altro sottodominio di example.com. Pertanto, si consiglia di utilizzare il punto per prefissare un nome di dominio per corrispondere a esso e ai suoi sottodomini.

ALLOWED_HOSTS = ['']

Abbiamo utilizzato l’indirizzo IP per corrispondere al nostro server. Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Prima di testare il server di sviluppo, devi configurare il firewall per consentire a Django di funzionare. Django utilizza la porta 8000 per impostazione predefinita. Apri la porta utilizzando il Firewall Semplice (UFW).

(sample_proj) $ sudo ufw allow 8000

Avvia il server di sviluppo.

(sample_proj) $ python manage.py runserver 0.0.0.0:8000

Lancia l’URL http://:8000 nel tuo browser e vedrai la seguente schermata.

Puoi accedere all’interfaccia di amministrazione seguendo l’URL http://:8000/admin/ e vedrai la seguente schermata di accesso.

Inserisci le credenziali create in precedenza per accedere al pannello di amministrazione mostrato di seguito.

Una volta terminato il tuo progetto demo, puoi chiudere il server premendo Ctrl + C nel tuo terminale.

Installa e testa Gunicorn

Esegui il server Django persistente utilizzando nohup

Finora, il servizio Django non è persistente. Per rendere il servizio persistente, ci sono due metodi. Il primo metodo prevede l’utilizzo dell’utilità nohup. Il nohup è un comando POSIX che significa no hang up. Viene utilizzato per eseguire comandi in un modo che non si ferma nemmeno quando un utente esce.

Assicurati di essere uscito dal server dal terminale premendo Ctrl + C.

Esegui il seguente comando per eseguire il server di sviluppo di Django.

(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &

Ora, il tuo server Django continuerà a funzionare fino a quando non lo uccidi manualmente. Il comando ti darà l’ID del processo e restituirà un altro comando.

[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C

Premi Ctrl + C per uscire. Il server Django originale continuerà a funzionare. Puoi verificarlo aprendo l’URL nel tuo browser.

Una volta terminato, devi uccidere il processo. Il comando nohup ti dà un ID di processo. Ma in realtà, vengono eseguiti due processi. Per trovare gli ID di entrambi i processi, esegui il seguente comando.

(sample_proj) $ ps aux | grep manage.py
navjot     42650  3.6  1.8  47792 38168 pts/0    S    02:28   0:00 python manage.py runserver 0.0.0.0.:8000
navjot     42651  7.9  2.0 344904 41708 pts/0    Sl   02:28   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot     42657  0.0  0.1   6612  2172 pts/0    S+   02:28   0:00 grep --color=auto manage.py

Come puoi vedere, vengono eseguiti due processi, uno con ID 42650 e l’altro con ID 42651.

Esegui il seguente comando per arrestare il server utilizzando gli ID di processo ottenuti sopra.

(sample_proj) $ sudo kill -9 42650 42651

Installa Gunicorn

Il secondo metodo per eseguire un server Django persistente richiede di installare Gunicorn e i server web Nginx. Gunicorn è un server HTTP WSGI Python. Si interfaccerà con l’applicazione Django e poi Nginx agirà come un proxy inverso per Gunicorn. Questo metodo ha il vantaggio aggiuntivo di fornirti la sicurezza e le prestazioni che derivano dall’utilizzo di Nginx.

Installa Gunicorn.

(sample_proj) $ pip install gunicorn

Prima di procedere, dobbiamo testare la capacità di Gunicorn di servire il progetto. Esegui il seguente comando per eseguire Gunicorn.

(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi

Questo avvierà Gunicorn sulla stessa interfaccia su cui stava funzionando Django. Per verificare, apri l’URL http://:8000 nel tuo browser e vedrai la stessa homepage di Django. Questo significa che Gunicorn sta funzionando perfettamente.

Quando hai finito di testare, premi Ctrl + C nel terminale per uscire da Gunicorn.

Disattiva l’ambiente virtuale per tornare alla tua shell normale.

(sample_proj) $ deactivate

Crea un file Socket e un file di servizio per Gunicorn

Il primo passo è creare un file socket per Gunicorn. Il socket di Gunicorn verrà creato all’avvio e ascolterà le connessioni. Quando si verifica una connessione, il systemd avvierà automaticamente il processo Gunicorn per gestirla.

Crea e apri il file socket di Gunicorn per la modifica.

$ sudo nano /etc/systemd/system/gunicorn.socket

Incolla il seguente codice in esso.

[Unit]
Description=socket gunicorn

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Successivamente, crea e apri il file di servizio di Gunicorn per la modifica.

$ sudo nano /etc/systemd/system/gunicorn.service

Incolla il seguente codice in esso.

[Unit]
Description=daemon gunicorn django
Requires=gunicorn.socket
After=network.target

[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Sostituisci navjot con il tuo nome utente di sistema. Il gruppo nginx consentirà al server Nginx di comunicare con Django.

Ricarica il demone di sistema per aggiornare i file systemd.

$ sudo systemctl daemon-reload

Abilita e avvia il file socket di Gunicorn.

$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket

Controlla lo stato del socket di Gunicorn.

$ sudo systemctl status gunicorn.socket

Riceverai un output simile.

? gunicorn.socket - socket gunicorn
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Thu 2022-06-30 01:43:24 UTC; 20s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Jun 30 01:43:24 django systemd[1]: Listening on gunicorn socket.

Il servizio Gunicorn non è ancora in esecuzione come puoi controllare.

$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn django
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
TriggeredBy: ? gunicorn.socket

Per testare il meccanismo di attivazione del socket, esegui il seguente comando.

$ curl --unix-socket /run/gunicorn.sock localhost

Riceverai l’output HTML della homepage di Django nel tuo terminale. Questo avvia anche Gunicorn per servire l’applicazione. Controlla di nuovo lo stato del servizio e vedrai che ora è in esecuzione.

$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn django
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-06-30 01:45:09 UTC; 12s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 42365 (gunicorn)
      Tasks: 4 (limit: 2241)
     Memory: 91.7M
        CPU: 1.128s
     CGroup: /system.slice/gunicorn.service
             ??42365 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42366 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42367 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42368 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application

Jun 30 01:45:09 django systemd[1]: Started django gunicorn daemon.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Starting gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Listening at: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Using worker: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Booting worker with pid: 42366
.......

Installa Nginx

L’ultimo passo è installare e configurare Nginx. Ubuntu 22.04 include una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.

Importa la chiave di firma di Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Aggiungi il repository per la versione stabile di Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.0

Configura Nginx

Crea e apri il file /etc/nginx/conf.d/django-gunicorn.conf per la modifica.

$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf

Incolla il seguente codice in esso.

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/navjot/dj-sample;
    }

    location / {
        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:/run/gunicorn.sock;
    }
}

Sostituisci la posizione radice nel file sopra con la directory sul tuo server.

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione di Nginx.

$ sudo nginx -t

Se non vedi errori, significa che sei a posto.

Dovrai anche aggiungere il nome di dominio alla tua direttiva ALLOWED_HOSTS. Apri il file settings.py.

$ nano ~/dj-sample/demoproject/settings.py

Cambia il valore per la variabile ALLOWED_HOSTS.

ALLOWED_HOSTS = ['','django.example.com']

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il socket e il servizio di Gunicorn.

$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service

Avvia il server Nginx.

$ sudo systemctl start nginx

Apri la porta HTTP. Puoi anche eliminare la porta 8000 se non intendi usarla più.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Verifica aprendo l’URL http://django.example.com e la homepage di Django verrà caricata.

Installa SSL

Finora, la tua applicazione Django viene servita tramite una connessione HTTP in chiaro. È altamente raccomandato proteggerla tramite un certificato SSL. Per questo, utilizza lo strumento Certbot utilizzando lo strumento Snapd. È già installato su un sistema Ubuntu 22.04.

Installa il repository core di Snapd.

$ sudo snap install core

Installa Certbot.

$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Genera il certificato. Il seguente comando configurerà automaticamente anche Nginx.

$ sudo certbot --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com

Apri prima la porta HTTPS.

$ sudo ufw allow https

Visita l’URL https://django.example.com nel tuo browser per confermare.

Conclusione

Questo conclude il nostro tutorial, dove hai imparato come installare Django, Gunicorn e Nginx su un server Ubuntu 22.04. Hai anche installato un certificato SSL per migliorare la sicurezza del tuo progetto Django. Se hai domande, postale nei commenti qui sotto.