Setup di un progetto Django

In questo articolo vi mostro in che modo procedo solitamente per fare il setup di un nuovo progetto Django. Per chi non lo sapesse, Django è uno dei framework Python più potenti e completi per lo sviluppo di applicazioni web. L’ultima versione stabile di Django, nel momento in cui scrivo, è la 3.0.7 e necessita della versione 3 di Python (almeno la versione 3.6). L’ultima versione di Django a supportare la versione 2 di Python è la 1.11 LTS (Long Term Support), per la quale però il supporto non è più garantito.

La versione 3.0 di Django non è una LTS; la prossima LTS della serie 3 sarà la 3.2, che però non vedrà la luce prima del prossimo anno. Se è vostra intenzione avviare ora un progetto che dovrà essere mantenuto stabilmente, l’ultima release LTS disponibile è la 2.2, che riceverà supporto almeno fino ad aprile 2022. Tutti questi dettagli li trovate nella pagina delle versioni supportate.

Tornando al nostro esempio, vogliamo avviare un progetto che faccia uso di Django 3.0.7. Sulla nostra distribuzione Linux (qualunque essa sia) ci assicuriamo di avere una versione di Python compatibile. Su Debian, Ubuntu e derivate dovrebbe essere sufficiente installare il pacchetto python3:

sudo apt install python3

Per comodità, vi conviene installare anche il pacchetto virtualenv, che ci servirà per creare degli ambienti virtuali che ci aiutino a tenere separati diversi ambienti di sviluppo con diversi pacchetti python ad essi dedicati:

sudo apt install virtualenv

Creazione dell’ambiente python virtuale

Come detto, assicuriamoci di avere python 3.6 o superiore:

gianluca@ncc-1701:~$ which python3
/usr/bin/python3
gianluca@ncc-1701:~$ python3 -V
Python 3.6.9

Decidiamo di attivare il nostro nuovo progetto nella directory chiamata my-webapp all’interno della nostra home directory; all’interno di questa nuova directory creeremo il virtualenv per il nostro progetto:

cd ~
mkdir my-webapp
cd my-webapp

virtualenv -p /usr/bin/python3 venv
Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/gianluca/my-webapp/venv/bin/python3
Also creating executable in /home/gianluca/my-webapp/venv/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

Il comando virtualenv creerà la directory venv, all’interno della quale va a mettere gli elementi che costituiscono l’ambiente virtuale Python che fa riferimento all’interprete specificato con l’opzione -p. A questo punto possiamo attivare l’ambiente virtuale ed utilizzarlo nella sessione di shell corrente:

source venv/bin/activate

Dopo aver eseguito il comando precedente, dovreste notare che il prompt della vostra shell cambia mostrando il nome del virtualenv in uso (in questo caso ‘venv’). Da qui in poi, tutti i comandi che hanno a che fare con l’interprete Python saranno quelli presenti nell’ambiente virtuale, e gli eventuali pacchetti che andiamo ad installare con il comando pip saranno installati solo all’interno di questo ambiente e non a livello di sistema. Questo ci permette di gestire con estrema facilità ambienti di sviluppo e di esecuzione Python distinti ed indipendenti tra di loro.

(venv) gianluca@ncc-1701:~/my-webapp$ which python
/home/gianluca/my-webapp/venv/bin/python
(venv) gianluca@ncc-1701:~/my-webapp$ which pip
/home/gianluca/my-webapp/venv/bin/pip

Quando non abbiamo più bisogno del nostro virtualenv e vogliamo uscirne, sarà sufficiente invocare il comando deactivate.

Installazione del framework Django 3.0.7

Ora che ci troviamo nel virtualenv dedicato alla nostra nuova applicazione, procediamo con l’installazione di Django:

pip install Django==3.0.7
Collecting Django==3.0.7
  Using cached Django-3.0.7-py3-none-any.whl (7.5 MB)
Collecting asgiref~=3.2
  Using cached asgiref-3.2.9-py3-none-any.whl (19 kB)
Collecting pytz
  Using cached pytz-2020.1-py2.py3-none-any.whl (510 kB)
Collecting sqlparse>=0.2.2
  Using cached sqlparse-0.3.1-py2.py3-none-any.whl (40 kB)
Installing collected packages: asgiref, pytz, sqlparse, Django
Successfully installed Django-3.0.7 asgiref-3.2.9 pytz-2020.1 sqlparse-0.3.1

Ora che abbiamo Django installato nel nostro virtualenv, abbiamo a disposizione il comando django-admin che ci permette di interagire con il framework:

which django-admin
/home/gianluca/my-webapp/venv/bin/django-admin

Creazione del nostro progetto

Bene, ora che abbiamo il nostro virtualenv e il framework Django installato al suo interno, possiamo procedere con la creazione del progetto, ovvero di quella struttura di directory, codice, librerie, ecc. che ci servirà a realizzare la nostra applicazione web. Sempre dall’interno della directory che abbiamo creato, ovvero ~/my-webapp, lanciamo questo comando:

django-admin startproject mysite .

Ora nella directory my-webapp c’è la struttura iniziale della nostra applicazione e tutto l’occorrente per gestirla, compreso un script wrapper denominato manage.py che ci permette di interagire in maniera semplificata con django-admin:

(venv) gianluca@ncc-1701:~/my-webapp$ ls -l
totale 12
-rwxr-xr-x 1 gianluca gianluca  626 giu 18 14:24 manage.py
drwxr-xr-x 2 gianluca gianluca 4096 giu 18 14:24 mysite
drwxr-xr-x 6 gianluca gianluca 4096 giu 18 13:47 venv

Il comando django-admin ha inizializzato il progetto denominato mysite all’interno della directory corrente, così da avere in un unico luogo sia i file del progetto che il virtualenv. Questa modalità non è strettamente necessaria, in quanto avremmo potuto creare il progetto in qualsiasi altra directory, oppure mettere il virtualenv altrove, ma ci permette di mantenere in un unico posto il codice e il virtualenv così da rendere più evidente la loro relazione. Questo inoltre semplifica, come vedremo, la gestione del nostro progetto tramite un IDE come PyCharm.

Apertura del progetto con PyCharm

La struttura che abbiamo appena creato, insieme alla nostra shell e a un qualunque editor di testo è tutto quello che ci occorre per sviluppare la nostra nuova applicazione web. Tuttavia è innegabile che un buon IDE può sicuramente semplificarci la vita e velocizzare lo sviluppo. Uno degli IDE Python più evoluti è PyCharm, che anche in versione Community Edition offre tantissime feature. Se vogliamo dimenticarci della shell e fare tutto dall’IDE, il tutto si risolve con l’aprire al suo interno la directory contenente il nostro progetto; PyCharm imposterà automaticamente l’interprete dell’applicazione usando il virtualenv che abbiamo messo all’interno della directory del progetto stesso, come mostrano le immagini che seguono.

Avviate PyCharm e cliccate su Open:

Scegliete di aprire la directory contenente la vostra applicazione, ovvero my-webapp:

Notate, in basso a destra, che l’IDE individua autonomamente l’interprete da usare per il progetto:

Confermate che il virtualenv in uso è effettivamente quello incluso nella directory my-webapp/venv andando a controllare le impostazioni del progetto in File –> Settings –> Project –> Project Interpreter:

Dall’interno dell’IDE, se cliccate sul tasto Terminal in basso a sinistra, potete accedere direttamente alla directory contenente il progetto Django con il corrispondente virtualenv già attivato:

Da questo terminale potete, ad esempio, avviare il server webi di sviluppo per testare il funzionamento della vostra applicazione. Digitate:

./manage.py runserver

e il server dovrebbe avviarsi e mettersi in ascolto locale sulla porta 8000. Digitando nel vostro browser l’indirizzo http://localhost:8000 dovreste vedere la pagina iniziale del vostro progetto, che vi conferma che il setup è stato eseguito con successo:

Ora non vi resta che procedere con lo sviluppo della vostra applicazione, comodamente dal vostro IDE!

Leave a Reply

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.