Come configurare Django con Postgres, Nginx e Gunicorn su Ubuntu 14.04

introduzione

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 tuo codice localmente, ma per qualsiasi cosa anche leggermente correlata alla produzione, è necessario un server web più sicuro e potente.

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

Prerequisiti e obiettivi

Per completare questa guida, dovresti avere una nuova istanza del server Ubuntu 14.04 con un utente non root con i privilegi sudo configurati. Puoi imparare come configurarlo eseguendo la nostra guida alla configurazione iniziale del server.

Installeremo Django all'interno di un ambiente virtuale. L'installazione di Django in un ambiente specifico per il tuo progetto consentirà di gestire separatamente i tuoi progetti e i loro requisiti.

Una volta che il nostro database e la nostra applicazione saranno attivi e funzionanti, installeremo e configureremo il server delle applicazioni Gunicorn. Questo fungerà da interfaccia per la nostra applicazione, traducendo le richieste del client in HTTP in chiamate Python che la nostra applicazione può elaborare. Quindi configureremo Nginx davanti a Gunicorn per sfruttare i suoi meccanismi di gestione delle connessioni ad alte prestazioni e le sue funzionalità di sicurezza facili da implementare.

Iniziamo.

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.

Innanzitutto, aggiorna l'indice dei pacchetti locali, quindi scarica e installa i pacchetti:

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

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

Creare il database e l'utente PostgreSQL

Entreremo subito e creeremo un database e un utente del database per la nostra applicazione Django.

Per lavorare con Postgres nella sua configurazione predefinita, è meglio passare temporaneamente all'utente di sistema postgres. Fallo ora digitando:

sudo su - postgres

Quando si opera come utente postgres, è possibile accedere direttamente a una sessione interattiva PostgreSQL senza ulteriore autenticazione digitando:

psql

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

Innanzitutto, crea un database per il tuo progetto:

CREATE DATABASE myproject;

Ogni comando deve terminare con un punto e virgola, quindi controlla che il tuo comando termini con uno se riscontri problemi.

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

CREATE USER myprojectuser WITH PASSWORD 'password';

Ora possiamo dare al nostro nuovo accesso utente per amministrare il nostro nuovo database:

GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;

Quando hai finito, esci dal prompt di PostgreSQL digitando:

\q

Ora, esci dalla sessione della shell dell'utente postgres per tornare alla normale sessione della shell dell'utente digitando:

exit

Crea un ambiente virtuale Python per il tuo progetto

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

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

sudo pip install virtualenv

Con virtualenv installato, possiamo iniziare a formare il nostro progetto. Crea una directory in cui desideri conservare il tuo progetto e spostati nella directory in seguito:

mkdir ~/myproject
cd ~/myproject

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

virtualenv myprojectenv

Questo creerà una directory chiamata myprojectenv all'interno della tua directory myproject. 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 myprojectenv/bin/activate

Il tuo prompt dovrebbe cambiare per indicare che stai operando all'interno di un ambiente virtuale Python. Sarà simile a questo: (myprojectenv)user@host:~/myproject$< /codice>.

Con il tuo ambiente virtuale attivo, installa Django, Gunicorn e l'adattatore psycopg2 PostgreSQL con l'istanza locale di pip:

pip install django gunicorn psycopg2

Crea e configura un nuovo progetto Django

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

Crea il progetto Django

Poiché abbiamo già una directory del progetto, diremo a Django di installare i file qui. Creerà una directory di secondo livello con il codice effettivo, che è normale, e inserirà uno script di gestione in questa directory. La chiave di ciò è il punto alla fine che dice a Django di creare i file nella directory corrente:

django-admin.py startproject myproject .

Regola le impostazioni del progetto

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:

nano myproject/settings.py

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

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

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'myproject',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

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

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

Salva e chiudi il file quando hai finito.

Completa la configurazione iniziale del progetto

Ora possiamo migrare lo schema del database iniziale al nostro database PostgreSQL utilizzando lo script di gestione:

cd ~/myproject
./manage.py makemigrations
./manage.py migrate

Crea un utente amministrativo per il progetto digitando:

./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:

./manage.py collectstatic

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

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

./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 indice di Django predefinita:

Se aggiungi /admin alla fine dell'URL nella barra degli indirizzi, ti verrà richiesto il nome utente e la password dell'amministratore che hai creato con il comando createsuperuser:

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

Al termine dell'esplorazione, premi CTRL-C nella finestra del terminale per arrestare 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 facilmente digitando:

cd ~/myproject
gunicorn --bind 0.0.0.0:8000 myproject.wsgi:application

Questo avvierà Gunicorn sulla stessa interfaccia su cui era in esecuzione il server di sviluppo Django. Puoi tornare indietro e testare nuovamente l'app. Si noti che l'interfaccia di amministrazione non avrà alcuno stile applicato poiché Gunicorn non è a conoscenza del contenuto 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 alla nostra applicazione, utilizzando la sintassi del modulo di Python. All'interno di questo file è definita una funzione chiamata application, che viene utilizzata per comunicare con l'applicazione. Per ulteriori informazioni sulla specifica WSGI, fare clic qui.

Quando hai finito di testare, premi CTRL-C nella finestra del terminale per fermare Gunicorn.

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

deactivate

Crea un file Gunicorn Upstart

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 uno script Upstart.

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

sudo nano /etc/init/gunicorn.conf

Inizieremo con una semplice stringa descrittiva per indicare a cosa serve il nostro file di servizio. Passeremo quindi alla definizione dei runlevel di sistema in cui questo servizio dovrebbe essere avviato automaticamente. I normali runlevel per eseguire i servizi sono 2, 3, 4 e 5. Eseguiremo il nostro servizio quando il sistema si trova in uno di questi. Gli diremo di fermarsi quando si trova in qualsiasi altro runlevel (come quando il sistema si sta riavviando, spegnendo o in modalità utente singolo):

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

Successivamente, diremo a Upstart di riavviare automaticamente il servizio se fallisce. Vogliamo anche specificare l'utente e il gruppo con cui eseguire. Useremo il nostro utente normale poiché tutti i nostri file sono di proprietà di quell'utente. Lasceremo che il gruppo www-data a cui appartiene Nginx sia il proprietario del gruppo. Dobbiamo anche passare alla directory del nostro progetto in modo che i comandi Gunicorn vengano eseguiti correttamente:

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

respawn
setuid user
setgid www-data
chdir /home/user/myproject

Ora, dobbiamo solo dare il comando che avvierà il processo Gunicorn. Dobbiamo dare il percorso all'eseguibile Gunicorn, che è memorizzato nel nostro ambiente virtuale. Gli diremo di utilizzare un socket Unix invece di una porta di rete per comunicare con Nginx, poiché entrambi i servizi saranno in esecuzione su questo server. Questo è più sicuro e più veloce. Puoi anche aggiungere qualsiasi altra configurazione per Gunicorn qui. Ad esempio, specificheremo che vogliamo 3 processi di lavoro:

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

respawn
setuid user
setgid www-data
chdir /home/user/myproject

exec myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/user/myproject/myproject.sock myproject.wsgi:application

Quando hai finito, salva e chiudi il file.

Avvia il servizio Gunicorn digitando:

sudo service gunicorn start

Configura Nginx su Proxy Passa a Gunicorn

Ora che Gunicorn è configurato, dobbiamo configurare Nginx per trasferire il traffico al processo.

Inizia creando e aprendo un nuovo blocco server nella directory sites-available di Nginx:

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

All'interno, apri un nuovo blocco 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:

server {
    listen 80;
    server_name server_domain_or_IP;
}

Successivamente, diremo a Nginx di ignorare eventuali problemi con la ricerca di una favicon. Gli diremo anche dove trovare le risorse statiche che abbiamo raccolto nella nostra directory ~/myproject/static. Tutti questi file hanno un prefisso URI standard di \/static, quindi possiamo creare un blocco di posizione per soddisfare tali richieste:

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/user/myproject;
    }
}

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

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/user/myproject;
    }

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/user/myproject/myproject.sock;
    }
}

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

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

Testa la tua configurazione Nginx per errori di sintassi digitando:

sudo nginx -t

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

sudo service nginx restart

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

Conclusione

In questa guida, abbiamo impostato un progetto Django nel proprio ambiente virtuale. Abbiamo configurato Gunicorn per tradurre le richieste dei clienti in modo che Django possa gestirle. Successivamente, abbiamo configurato Nginx in modo che funga da proxy inverso per gestire le connessioni client e servire il progetto corretto in base alla richiesta del client.

Django semplifica la creazione di progetti e applicazioni fornendo molti dei pezzi comuni, permettendoti di concentrarti sugli elementi unici. Sfruttando la catena di strumenti generale descritta in questo articolo, puoi servire facilmente le applicazioni che crei da un singolo server.