Come configurare l'ambiente di sviluppo Django su Ubuntu 18.04

Django è un potente framework web che può aiutarti a far decollare la tua applicazione Python o il tuo sito web. Django include un server di sviluppo semplificato per testare il codice in locale, ma per qualsiasi cosa, anche solo leggermente legata alla produzione, è necessario un server web più sicuro e potente (Nginx - Apache).

In questa guida dimostreremo come installare e configurare alcuni componenti su Ubuntu 18.04 per supportare e servire le applicazioni Django. Configurare un database PostgreSQL invece di utilizzare il database SQLite predefinito. Configurare il server delle applicazioni Gunicorn per interfacciarsi con le nostre applicazioni. Quindi imposteremo Nginx per invertire il proxy su Gunicorn, dandoci accesso alle sue funzionalità di sicurezza e prestazioni per servire le nostre app.

Crea utente non root con privilegi sudo configurati

1. Accesso come root
2. Creazione di un nuovo utente

   # adduser bobby

3. Concessione di privilegi amministrativi
   Per aggiungere questi privilegi al nostro nuovo utente, dobbiamo aggiungere il nuovo utente al gruppo sudo. Per impostazione predefinita, su Ubuntu 18.04, gli utenti che appartengono al gruppo sudo possono utilizzare il comando sudo.

   # usermod -aG sudo bobby

Installa i pacchetti dai repository di Ubuntu

Per iniziare il processo, scaricheremo e installeremo tutti gli elementi di cui abbiamo bisogno dai repository di Ubuntu. Useremo il gestore di pacchetti Python pip per installare componenti aggiuntivi un po' più tardi.
Dobbiamo aggiornare l'indice del pacchetto apt locale e quindi scaricare e installare i pacchetti. I pacchetti che installiamo dipendono dalla versione di Python che verrà utilizzata dal tuo progetto.
Installando Django con Python 3, digita :

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx

Questo installerà pip, i file di sviluppo Python necessari per costruire Gunicorn in seguito, il sistema di database Postgres e le librerie necessarie per interagire con esso e il server web Nginx.

Crea il database e l'utente PostgreSQL

Andremo subito a creare un database e un utente di database per la nostra applicazione Django. Per impostazione predefinita, Postgres utilizza uno schema di autenticazione chiamato autenticazione peer per le connessioni locali. Fondamentalmente, ciò significa che se il nome utente del sistema operativo dell'utente corrisponde a un nome utente Postgres valido, quell'utente può accedere senza ulteriore autenticazione.

Durante l'installazione di Postgres, è stato creato un utente del sistema operativo chiamato postgres per corrispondere all'utente amministrativo postgres PostgreSQL. È necessario utilizzare questo utente per eseguire attività amministrative. Possiamo usare sudo e passare il nome utente con l'opzione -u.

Accedi a una sessione interattiva di Postgres digitando :

$ sudo -u postgres psql

Ti verrà fornito un prompt di PostgreSQL in cui possiamo impostare i nostri requisiti.

Innanzitutto, crea un database per il tuo progetto

Postgres=# CREATE DATABASE newproject;

Nota: Ogni istruzione Postgres deve terminare con un punto e virgola

Quindi, crea un utente del database per il nostro progetto. Assicurati di selezionare una password sicura

Postgres=# CREATE USER newprojectuser WITH PASSWORD 'password';

Successivamente, modificheremo alcuni dei parametri di connessione per l'utente che abbiamo appena creato. Ciò accelererà le operazioni del database in modo che i valori corretti non debbano essere richiesti e impostati ogni volta che viene stabilita una connessione.

Stiamo impostando la codifica predefinita su UTF-8, che Django si aspetta. Stiamo anche impostando lo schema di isolamento delle transazioni predefinito su read commit, che blocca le letture dalle transazioni non vincolate. Infine, stiamo impostando il fuso orario. Per impostazione predefinita, i nostri progetti Django saranno impostati per utilizzare UTC. Questi sono tutti consigli del progetto Django stesso.

Postgres=# ALTER ROLE newprojectuser SET client_encoding TO 'utf8';
Postgres=# ALTER ROLE newprojectuser SET default_transaction_isolation TO 'read committed';
Postgres=# ALTER ROLE newprojectuser SET timezone TO 'UTC';

Ora possiamo concedere al nostro nuovo utente l'accesso per amministrare il nostro nuovo database

Postgres=# GRANT ALL PRIVILEGES ON DATABASE newproject TO newprojectuser;

Al termine, esci dal prompt di PostgreSQL digitando:

Postgres=# \q

Crea un ambiente virtuale Python 3 per il tuo progetto

Ora che abbiamo il nostro database, possiamo iniziare a preparare il resto dei requisiti del nostro progetto. Installeremo i nostri requisiti Python 3 in un ambiente virtuale per una gestione più semplice.

Per fare ciò, dobbiamo prima accedere al comando virtualenv. Possiamo installarlo con pip3.

Aggiorna pip3 e installa il pacchetto digitando:

  $ sudo -H pip3 install --upgrade pip
  $ sudo -H pip3 install virtualenv

Con virtualenv installato, possiamo iniziare a formare il nostro progetto. Crea e sposta in una directory in cui possiamo conservare i nostri file di progetto:

  $ mkdir ~/djangoproject
  $ cd ~/djangoproject

All'interno della directory del progetto, crea un ambiente virtuale Python digitando:

$ virtualenv djangoprojectenv

Questo creerà una directory chiamata djangoprojectenv all'interno del tuo djangoproject directory. All'interno, installerà una versione locale di Python e una versione locale di pip. Possiamo usarlo per installare e configurare un ambiente Python isolato per il nostro progetto.

Prima di installare i requisiti Python del nostro progetto, dobbiamo attivare l'ambiente virtuale. Puoi farlo digitando:

$ source djangoproject/bin/activate

Il tuo prompt dovrebbe cambiare per indicare che ora stai operando all'interno di un ambiente virtuale Python. Sarà simile a questo:(djangoprojectenv)user@host:~/djangoproject$ .
Con il tuo ambiente virtuale attivo, installa Django, Gunicorn e l'adattatore psycopg2 PostgreSQL con l'istanza locale di pip:

Nota: Indipendentemente dalla versione di Python 3 o python 2 che stai utilizzando, quando l'ambiente virtuale è attivato, dovresti usare il comando pip (non pip3).

(djangoprojectenv)$ pip install django gunicorn psycopg2-binary

Ora dovresti avere tutto il software necessario per avviare un progetto Django.

Crea e configura un nuovo progetto Django

Con i nostri componenti Python installati, possiamo creare i file di progetto Django effettivi.

Poiché abbiamo già una directory di progetto, diremo a Django di installare i file qui. Creerà una directory di secondo livello con il codice effettivo, il che è normale, e collocherà uno script di gestione in questa directory. La chiave è che stiamo definendo la directory in modo esplicito invece di consentire a Django di prendere decisioni relative alla nostra directory corrente:

(djangoprojectenv)$ django-admin.py startproject djangoproject ~/djangoproject

A questo punto, la directory del tuo progetto (~/djangoproject nel nostro caso) dovrebbe avere il seguente contenuto:

• ~/djangoproject/manage.py :Uno script di gestione del progetto Django.
• ~/djangoproject/myproject/ :Il pacchetto del progetto Django. Questo dovrebbe contenere il __init__.py , settings.py , urls.py e wsgi.py file.
• ~/djangoproject/djangoprojectenv/ :la directory dell'ambiente virtuale che abbiamo creato in precedenza.

La prima cosa che dovremmo fare con i nostri file di progetto appena creati è regolare le impostazioni. Apri il file delle impostazioni nel tuo editor di testo:

(djangoprojectenv)$ nano ~/djangoproject/djangoproject/settings.py

Inizia individuando la direttiva ALLOWED_HOSTS. Questo definisce un elenco di indirizzi del server o nomi di dominio che possono essere utilizzati per connettersi all'istanza Django. Qualsiasi richiesta in arrivo con un'intestazione Host che non è in questo elenco genererà un'eccezione. Django richiede che tu lo imposti per prevenire una certa classe di vulnerabilità della sicurezza.

Tra parentesi quadre, elenca gli indirizzi IP o i nomi di dominio associati al tuo server Django. Ogni articolo deve essere elencato tra virgolette con voci separate da una virgola. Se desideri richieste per un intero dominio ed eventuali sottodomini, anteponi un punto all'inizio della voce. Nello snippet qui sotto, ci sono alcuni esempi commentati usati per dimostrare.

~/djangoproject/djangoproject/settings.py
. . .
# The simplest case: just add the domain name(s) and IP addresses of your Django server
# ALLOWED_HOSTS = [ 'example.com', '203.0.113.5']
# To respond to 'example.com' and any subdomains, start the domain with a dot
# ALLOWED_HOSTS = ['.example.com', '103.25.111.5']
ALLOWED_HOSTS = ['your_server_domain_or_IP', 'second_domain_or_IP', . . .]

Quindi, trova la sezione che configura l'accesso al database. Inizierà con DATABASE. La configurazione nel file è per un database SQLite. Abbiamo già creato un database PostgreSQL per il nostro progetto, quindi dobbiamo modificare le impostazioni.

Modifica le impostazioni con le informazioni del tuo database PostgreSQL. Diciamo a Django di usare psycopg2adaptor che abbiamo installato con pip. È necessario fornire il nome del database, il nome utente del database, la password dell'utente del database e quindi specificare che il database si trova sul computer locale. Puoi lasciare l'impostazione PORT come una stringa vuota:

~/djangoproject/djangoproject/settings.py
. . .
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'newproject',
        'USER': 'newprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
. . .

Quindi, vai in fondo al file e aggiungi un'impostazione che indica dove devono essere posizionati i file statici. Ciò è necessario affinché Nginx possa gestire le richieste per questi elementi. La riga seguente dice a Django di metterli in una directory chiamata static nella directory del progetto di base:

~/djangoproject/djangoproject/settings.py
. . .
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Salva e chiudi digitando Ctrl + x il file quando hai finito.
Ora possiamo migrare lo schema del database iniziale nel nostro database PostgreSQL utilizzando lo script di gestione:

(djangoprojectenv)$ ~/djangoproject/manage.py makemigrations
(djangoprojectenv)$ ~/djangoproject/manage.py migrate

Crea un utente amministrativo per il progetto digitando:

(djangoprojectenv)$ ~/djangoproject/manage.py createsuperuser

Dovrai selezionare un nome utente, fornire un indirizzo e-mail e scegliere e confermare una password.
Possiamo raccogliere tutto il contenuto statico nella posizione della directory che abbiamo configurato digitando:

(djangoprojectenv)$ ~/djangoproject/manage.py collectstatic

Dovrai confermare l'operazione. I file statici verranno quindi inseriti in una directory chiamata static all'interno della directory del progetto.

Se hai seguito la guida all'installazione iniziale del server, dovresti avere un firewall UFW che protegge il tuo server. Per testare il server di sviluppo, dovremo consentire l'accesso alla porta che utilizzeremo.

Crea un'eccezione per la porta 8000 digitando:

(djangoprojectenv)$ sudo ufw allow 8000

Infine, puoi testare il tuo progetto avviando il server di sviluppo Django con questo comando:

(djangoprojectenv)$ ~/djangoproject/manage.py runserver 0.0.0.0:8000

Nel tuo browser web, visita il nome di dominio o l'indirizzo IP del tuo server seguito da :8000:

http://server_domain_or_IP:8000

Dovresti vedere la pagina dell'indice di Django predefinita per Django 2.0.7:

Se digiti http://server_domain_or_IP:8000/admin nella barra degli indirizzi, ti verrà chiesto il nome utente e la password di amministratore che hai creato con il comando createsuperuser:

Dopo l'autenticazione, puoi accedere all'interfaccia di amministrazione di Django predefinita:

Al termine dell'esplorazione, premi CTRL-C nella finestra del terminale per spegnere il server di sviluppo.

Testare la capacità di Gunicorn di servire il progetto

L'ultima cosa che vogliamo fare prima di lasciare il nostro ambiente virtuale è testare Gunicorn per assicurarci che possa servire l'applicazione. Possiamo farlo entrando nella nostra directory del progetto e usando gunicorn per caricare il modulo WSGI del progetto:

(djangoprojectenv)$ cd ~/djangoproject
(djangoprojectenv)$ gunicorn --bind 0.0.0.0:8000 djangoproject.wsgi

Questo avvierà Gunicorn sulla stessa interfaccia su cui era in esecuzione il server di sviluppo Django. Puoi tornare indietro e testare di nuovo l'app.

Nota: L'interfaccia di amministrazione non avrà nessuno degli stili applicati poiché Gunicorn non è a conoscenza del contenuto CSS statico responsabile di ciò.

Abbiamo passato a Gunicorn un modulo specificando il percorso della directory relativa al file wsgi.py di Django, che è il punto di ingresso della nostra applicazione, usando la sintassi del modulo di Python. All'interno di questo file viene definita una funzione chiamata applicazione, che viene utilizzata per comunicare con l'applicazione.

Al termine del test, premi CTRL-C nella finestra del terminale per interrompere Gunicorn.

Ora abbiamo finito di configurare la nostra applicazione Django. Possiamo uscire dal nostro ambiente virtuale digitando:

(myprojectenv)$ deactivate

L'indicatore dell'ambiente virtuale nella tua richiesta verrà rimosso.

Crea un file di servizio di sistema Gunicorn

Abbiamo testato che Gunicorn può interagire con la nostra applicazione Django, ma dovremmo implementare un modo più robusto per avviare e arrestare il server delle applicazioni. Per fare ciò, creeremo un file di servizio systemd.

Crea e apri un file di servizio systemd per Gunicorn con privilegi sudo nel tuo editor di testo:

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

Inizia con il [Unit] sezione, che viene utilizzata per specificare metadati e dipendenze. Metteremo qui una descrizione del nostro servizio e diremo al sistema init di avviarlo solo dopo che l'obiettivo di rete è stato raggiunto.

Successivamente, apriremo il [Service] sezione. Specifichiamo l'utente e il gruppo che vogliamo elaborare per l'esecuzione. Daremo al nostro account utente regolare la proprietà del processo poiché possiede tutti i file pertinenti. Daremo la proprietà del gruppo ai www-data gruppo in modo che Nginx possa comunicare facilmente con Gunicorn.

Quindi mapperemo la directory di lavoro e specificheremo il comando da utilizzare per avviare il servizio. In questo caso, dovremo specificare il percorso completo dell'eseguibile Gunicorn, che è installato all'interno del nostro ambiente virtuale. Lo legheremo a un socket Unix all'interno della directory del progetto poiché Nginx è installato sullo stesso computer. Questo è più sicuro e veloce rispetto all'utilizzo di una porta di rete. Possiamo anche specificare eventuali modifiche opzionali di Gunicorn qui. Ad esempio, in questo caso abbiamo specificato 3 processi di lavoro.

Infine, aggiungeremo un [Install] sezione. Questo dirà a systemd a cosa collegare questo servizio se lo consentiamo per l'avvio all'avvio. Vogliamo che questo servizio venga avviato quando il normale sistema multiutente è attivo e funzionante:

/etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/djangoproject
ExecStart=/home/bobby/djangoproject/djangoproject/bin/gunicorn --access-logfile - --workers 3 --bind unix:/home/bobby/djangoproject/djangoproject.sock djangoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Con ciò, il nostro file di servizio systemd è completo. Salvalo e chiudilo ora.

dovremmo aggiungere l'utente bobby al gruppo www-data:

$ sudo usermod –a –G www-data bobby

Ora possiamo avviare il servizio Gunicorn che abbiamo creato e abilitarlo in modo che si avvii all'avvio:

$ sudo systemctl start gunicorn
$ sudo systemctl enable gunicorn

Possiamo confermare che l'operazione è andata a buon fine controllando il file socket.

Controlla lo stato del processo per scoprire se è stato in grado di iniziare:

$ sudo systemctl status gunicorn

Quindi, controlla l'esistenza di djangoproject.sock file all'interno della directory del tuo progetto:

$ ls /home/bobby/djangoproject
Output
manage.py  djangoproject  djangoprojectenv  djangoproject.sock  static

Se il comando systemctl status indica che si è verificato un errore o se non trovi il djangoproject.sock file nella directory, è un'indicazione che Gunicorn non è stato in grado di avviarsi correttamente. Controlla i registri del processo Gunicorn digitando:

$ sudo journalctl -u gunicorn

Dai un'occhiata ai messaggi nei registri per scoprire dove ha avuto problemi Gunicorn. Ci sono molte ragioni per cui potresti aver riscontrato problemi, ma spesso, se Gunicorn non è stato in grado di creare il file socket, è per uno di questi motivi:

• I file di progetto sono di proprietà dell'utente root invece di un utente sudo
• La WorkingDirectory percorso all'interno di /etc/systemd/system/gunicorn.service il file non punta alla directory del progetto
• Le opzioni di configurazione fornite al processo gunicorn in ExecStart direttiva non sono corrette. Controllare i seguenti elementi:
  • Il percorso del binario gunicorn punta alla posizione effettiva del binario all'interno dell'ambiente virtuale
  • Il --bind definisce un file da creare all'interno di una directory a cui Gunicorn può accedere
  • Il djangoproject.wsgi:application è un percorso accurato per il callable WSGI. Ciò significa che quando sei in WorkingDirectory, dovresti essere in grado di raggiungere l'applicazione denominata richiamabile cercando in djangoproject.wsgi module (che si traduce in un file chiamato ./djangoproject/wsgi.py )

Se apporti modifiche al file /etc/systemd/system/gunicorn.service, ricarica il demone per rileggere la definizione del servizio e riavvia il processo Gunicorn digitando:

$ sudo systemctl daemon-reload
$ sudo systemctl restart gunicorn

Assicurati di risolvere i problemi di cui sopra prima di continuare.

Configura Nginx per passare proxy a Gunicorn

Ora che Gunicorn è impostato, dobbiamo configurare Nginx per passare il traffico al processo. Inizia creando e aprendo un nuovo blocco server nella directory dei siti disponibili di Nginx:

$ sudo nano /etc/nginx/sites-available/djangoproject

All'interno, apri un nuovo blocco di server. Inizieremo specificando che questo blocco dovrebbe essere in ascolto sulla normale porta 80 e che dovrebbe rispondere al nome di dominio o all'indirizzo IP del nostro server.

Successivamente, diremo a Nginx di ignorare qualsiasi problema con la ricerca di una favicon. Gli diremo anche dove trovare le risorse statiche che abbiamo raccolto nel nostro ~/djangoproject/static directory. Tutti questi file hanno un prefisso URI standard di "/static" , in modo da poter creare un blocco di località che corrisponda a tali richieste.

Infine, creeremo un blocco posizione / {} per abbinare tutte le altre richieste. All'interno di questa posizione, includeremo lo standard proxy_params file incluso con l'installazione di Nginx e quindi passeremo il traffico al socket creato dal nostro processo Gunicorn:

/etc/nginx/sites-available/djangoproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/bobby/djangoproject;
    }
    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/djangoproject/djangoproject.sock;
    }
}

Salva e chiudi il file quando hai finito. Ora possiamo abilitare il file collegandolo a sites-enabled directory:

$ sudo ln -s /etc/nginx/sites-available/djangoproject /etc/nginx/sites-enabled

Verifica la configurazione di Nginx per errori di sintassi digitando:

$ sudo nginx -t

Se non vengono segnalati errori, vai avanti e riavvia Nginx digitando:

$ sudo systemctl restart nginx

Infine, dobbiamo aprire il nostro firewall al traffico normale sulla porta 80. Poiché non abbiamo più bisogno di accedere al server di sviluppo, possiamo rimuovere la regola per aprire anche la porta 8000:

$ sudo ufw delete allow 8000
$ sudo ufw allow 'Nginx Full'

Ora dovresti essere in grado di accedere al dominio o all'indirizzo IP del tuo server per visualizzare la tua applicazione.

Leggi anche

• Come configurare UFW Firewall su Ubuntu 18.04
• Come installare lo stack LAMP su Ubuntu 18.04

Nota:dopo aver configurato Nginx, il passaggio successivo dovrebbe essere la protezione del traffico verso il server tramite SSL/TLS. Questo è importante perché senza di essa, tutte le informazioni, comprese le password, vengono inviate sulla rete in testo normale.