Django è una piattaforma comune per lo sviluppo di siti Web, applicazioni Web e API Web. Ci sono molti vantaggi nell'utilizzo del framework Django per il tuo progetto come strumento e se non sei sicuro che sia la soluzione giusta, devi solo guardare ai numerosi grandi marchi che utilizzano Django nel loro stack.

La distribuzione di Django in un ambiente di produzione per la prima volta può essere un compito arduo. Spesso gli sviluppatori lanceranno un'istanza Linux sul cloud per il loro ambiente di produzione production.

In questo tutorial, ti mostreremo come avviare Django in produzione, utilizzando una nuova istanza di Ubuntu.

Supponiamo che tutte le tue modifiche vengano eseguite sul server e che tu stia eseguendo i comandi come root.

Per questo tutorial, stiamo usando Ubuntu 18.04.2 LTS

Creazione di un utente per il progetto

Creeremo un nuovo utente, django, per eseguire la nostra applicazione. Ciò fornisce un leggero vantaggio in termini di sicurezza.

Per creare il nuovo utente:

useradd -m django

Il -m bandiera crea una nuova directory home: /home/django.

Configurazione dell'ambiente Python

Per prima cosa: aggiorna i tuoi elenchi di pacchetti con apt-get update

Ubuntu 18.04 viene fornito con Python 3.6, ma non viene fornito con pip, di cui avrai bisogno per installare le tue dipendenze.

apt-get install python3-pip

Ora che abbiamo pip, creiamo un ambiente virtuale. Gli ambienti virtuali aiutano a evitare conflitti con i pacchetti Python utilizzati da Linux.

pip3 installa virtualenv
cd /home/django
ambiente virtuale

Ora hai creato un Python virtuale 3.6 ambiente nel /home/django/env cartella che può essere attivata con il seguente comando:Ora che abbiamo pip, creiamo un ambiente virtuale. Gli ambienti virtuali aiutano a evitare conflitti con i pacchetti Python utilizzati da Linux.

source /home/django/env/bin/activate

Allestire il progetto Django

Per questo tutorial, creeremo un progetto Django temporaneo. Se stai implementando il tuo codice, dovrai invece caricarlo sul server. Opereremo nella directory home, /home/django.Allestire il progetto Django

Creiamo il progetto Django:

cd /home/django
source env/bin/activate
pip install django
django-admin startproject tutorial

Verifica che le cose funzionino eseguendo:

cd tutorial
Python gestireth.py runserver 0.0.0.0:80

La nostra istanza Ubuntu è in esecuzione a 178.128.229.34 quindi ci collegheremo a http://178.128.229.34.Verifica che le cose funzionino eseguendo:

Probabilmente vedrai qualcosa del genere:

Per risolvere questo problema, modificheremo /home/django/tutorial/tutorial/impostazioni.pi. Trova ALLOWED_HOSTS = [] e impostalo su:

ALLOWED_HOSTS = [
'178'.128.229.34' # sostituiscilo con l'indirizzo IP del tuo server
o il nome di dominio che stai usando per connetterti
]

Ora torniamo a http://178.128.229.34:

grande! Siamo online!

Configurare PostgreSQL, il database

Per impostazione predefinita, Django utilizza un database SQLite3. Sfortunatamente, SQLite3 non consente scritture simultanee. Se il tuo sito web ha solo un utente che modifica i dati e il resto dei visitatori sta solo leggendo le pagine, questo potrebbe essere appropriato. Ma se hai più persone che modificano i dati contemporaneamente, probabilmente vorrai utilizzare un backend diverso.

Le scelte comuni sono PostgreSQL e Mysql. Andremo con PostgreSQL per questo tutorial.

Inizia installando PostgreSQL:

apt-get install postgresql

Quindi avvia psql, una shell di database. Per impostazione predefinita, solo l'utente postgres è in grado di connettersi al database, quindi dovremo prima autenticarci come quell'utente:

su - postgres
psql

Successivamente, abbiamo bisogno di un database e un utente per accedere a quel database:

creare tutorial di database;
creare utente tutorial_user con password crittografata 'tutorial_password';
concedere tutti i privilegi sul tutorial del database a tutorial_user;

Ora, digita exit o premi Ctrl-D due volte: una volta per uscire da psql e una volta per disconnetterti dalla shell di postgresuser.

grande! Ora abbiamo il nostro database e la configurazione dell'utente. Verifichiamo di poter accedere al nostro database.

Cercheremo di aprire una shell di database, questa volta accedendo al database che abbiamo creato con l'utente che abbiamo creato:

psql -Ututorial_user -dtutorial -h127.0.0.1-W

Al prompt, inserisci la password che abbiamo creato: tutorial_password.

Se vedi una shell di database, hai avuto successo. Se vedi degli errori, dovrai tornare indietro e capire cosa c'è che non va.

Connettere Django al database

Per connettere Django al database, dobbiamo prima installare l'adattatore Python PostgreSQL:

pip install psycopg2-binary

Allora apriamo /home/django/tutorial/tutorial/impostazioni.pie configurare la connessione.

Trova la tua connessione al database corrente; se non l'hai modificato, potrebbe assomigliare a questo:

BANCHE DATI =
'predefinito':
'MOTORE': 'django.db.backend.sqlite3',
'NOME': os.sentiero.join(BASE_DIR, 'db.sqlite3'),

Per connetterci a PostgreSQL, lo sostituiremo con quanto segue:

BANCHE DATI =
'predefinito':
'MOTORE': 'django.db.backend.postgresql_psycopg2',
'NOME': 'esercitazione',
'USER': 'tutorial_user',
'PASSWORD': 'tutorial_password',
'HOST': '127.0.0.1',
'PORTA': '5432',

Proviamo la connessione:

cd /home/django/tutorial
Python gestireth.py runserver 0.0.0.0:80

Dovresti essere nuovamente in grado di visitare il tuo sito web (per noi all'indirizzo http://178.128.229.34/, ma sostituiscilo con il tuo IP o nome host).

Se tutto va bene, possiamo continuare.

Configurare nginx, il server web

Quando corri Python gestireth.py runserver, stai usando il server di sviluppo di Django. Questo è ottimo per lo sviluppo locale, ma come con SQLite3, non è molto adatto per la produzione.

Le scelte comuni per i server Web di produzione sono nginx e Apache. Per questo tutorial, useremo nginx.

Installa nginx usando quanto segue:

apt-get install nginx

Ora, se tutto ha funzionato bene, nginx dovrebbe essere in esecuzione sulla porta 80. Vai avanti e controlla il tuo sito web; tu dovresti vedere:

Fantastico, quindi nginx è attivo e funzionante! Successivamente dovremo configurarlo per comunicare con Django. Apri il file di configurazione di nginx, che si trova in /etc/nginx/sites-available/default. Sostituiamo il file con il seguente:

monte django
server 127.0.0.1:8000;

server
ascolta 80;
Posizione /
try_files $uri @send_to_django;

posizione @send_to_django
proxy_set_header Host $http_host;
proxy_redirect disattivato;
proxy_pass http://django;

Testa il file di configurazione eseguendo nginx -t. Se tutto è a posto, possiamo ricaricare eseguendo nginx -s reload.

Ora, se visiti il ​​tuo sito vedrai quanto segue:

Ogni volta che vedi questo, significa che nginx non è stato in grado di passare la richiesta al processo a monte. Al momento, è perché sta cercando di passare la richiesta a 127.0.0.1:8000 ma non c'è nessun processo in ascolto a quell'indirizzo.

Avviamo il server di sviluppo Django e riproviamo:

cd /home/django/tutorial
Python gestireth.py runserver 127.0.0.1:8000

e di nuovo visita il tuo sito web. Dovresti vedere la tua applicazione Django.

Montare Django su Gunicorn

Ricorda, non vogliamo utilizzare il nostro server di sviluppo Django in produzione. Invece, useremo un server Web Server Gateway Interface (WSGI) per eseguire Django. Nginx passerà la richiesta al server WSGI, che esegue Django.

Le scelte comuni per un server WSGI sono Gunicorn e uWSGI. Per questo tutorial useremo Gunicorn.

Installiamo Gunicorn:

pip installa gunicorn

Successivamente, possiamo avviare gunicorn come segue:

cd /home/django/tutorial
tutorial gunicorn.wsgi

Ora dovresti essere in grado di visitare il tuo sito Web e vedere la tua applicazione funzionare correttamente.

Gestire Gunicorn come servizio

Ci sono alcuni problemi con l'esecuzione di gunicorn in questo modo:

1. Se chiudiamo la sessione SSH, il processo gunicorn si fermerà.
2. Se il server si riavvia, il processo gunicorn non si avvia.
3. Il processo è in esecuzione come root. Se gli hacker trovano un exploit nel codice della nostra app, saranno in grado di eseguire comandi come root. Non vogliamo questo; ma è per questo che abbiamo creato il djangouser!

Per risolvere questi problemi, eseguiremo Gunicorn come servizio di sistema.

cd /home/django
mkdir bin
cd /home/django/bin
tocca start-server.sh

In start-server.sh:

cd /home/django
source env/bin/activate
cd tutorial
tutorial gunicorn.wsgi

Ora puoi testare lo script:

cd /home/django/bin
bash start-server.sh
# visita il tuo sito web, dovrebbe essere in esecuzione

Ora creiamo il servizio systemd per Gunicorn. Crea /etc/systemd/system/gunicorn.servizi come segue:

[Unità]
Description=Gunicorno
Dopo=rete.bersaglio
[Servizio]
Tipo=semplice
Utente=django
ExecStart=/home/django/bin/start-server.sh
Riavvia=in caso di errore
[Installare]
WantedBy=multiutente.bersaglio

Ora, abilitiamo il servizio e avviamolo

systemctl abilita gunicorn
systemctl avvia gunicorn

Dovresti essere in grado di vedere il tuo sito web in questo momento.

Possiamo disattivare il gunicorn come segue:

systemctl stop gunicorn

E dovresti vedere un 502 Bad Gateway.

Infine, controlliamo il ciclo di avvio:

systemctl avvia gunicorn
riavvia ora

Quando la tua macchina torna online, dovresti vedere che il tuo sito web è attivo.

File statici

Se visiti il ​​pannello di amministrazione di Django sul tuo sito web all'indirizzo /admin/ (per noi è http://178.128.229.34/admin/), noterai che i file statici non vengono caricati correttamente.

Dovremo creare una nuova cartella per i file statici:

cd /home/django
mkdir statico

Quindi, diciamo a Django che è dove dovrebbe mettere i file statici modificando /home/django/tutorial/tutorial/settings.py, e aggiungendo:

STATIC_ROOT = '/home/django/static/'

Ora possiamo raccogliere i file statici:

cd /home/django
source env/bin/activate
cd tutorial
Python gestireth.py collectstatic

Infine, dobbiamo dire a nginx di servire quei file statici.

Apriamo /etc/nginx/sites-available/default e aggiungiamo quanto segue direttamente sopra la tua posizione/blocco:

posizione /statico/
root /home/django;
try_files $uri =404;

L'intero file dovrebbe ora assomigliare a questo:

monte django
server 127.0.0.1:8000;

server
ascolta 80;
posizione /statico/
root /home/django;
try_files $uri =404;

Posizione /
try_files $uri @send_to_django;

posizione @send_to_django
proxy_set_header Host $http_host;
proxy_redirect disattivato;
proxy_pass http://django;

Possiamo ricaricare il file utilizzando nginx -s reload

E voilà! I tuoi file statici ora funzioneranno completamente.

Conclusione

A questo punto, la tua app Django funziona correttamente. Se hai dei requisiti speciali, potresti dover impostare una cache come Redis o una coda di messaggi come Rabbit MQ. Potresti anche voler impostare la distribuzione continua poiché la procedura di distribuzione potrebbe richiedere un po' di tempo.

Un altro passaggio importante è adottare le misure appropriate per proteggere il tuo computer Ubuntu. Altrimenti, potresti scoprire che il tuo server si comporta male!

In bocca al lupo!