Django är en vanlig plattform för att utveckla webbplatser, webbapplikationer och webb-API: er. Det finns många fördelar med att använda Django-ramverket för ditt projekt som ditt verktyg och om du inte är säker på att det är rätt passform behöver du bara titta på de många stora varumärkena som använder Django i sin stack.

Att distribuera Django till en produktionsmiljö för första gången kan vara en skrämmande uppgift. Ofta kommer utvecklare att starta en Linux-instans i molnet för sin produktionsmiljö.

I den här handledningen visar vi dig hur du startar Django i produktion med en ny Ubuntu-instans.

Vi antar att all din redigering sker på servern och att du kör kommandona som root.

För den här guiden använder vi Ubuntu 18.04.2 LTS

Skapa en användare för projektet

Vi skapar en ny användare, django, för att köra vår applikation. Detta ger en liten säkerhetsfördel.

Så här skapar du den nya användaren:

useradd -m django

De -m flagga skapar en ny hemkatalog: / hem / django.

Konfigurera Python-miljön

Första saker först: uppdatera dina paketlistor med apt-get-uppdatering

Ubuntu 18.04 levereras med Python 3.6, men den levereras inte med pip, vilket du måste installera dina beroenden.

apt-get install python3-pip

Nu när vi har pip, låt oss skapa en virtuell miljö. Virtuella miljöer hjälper till att undvika konflikter med Python-paket som används av Linux.

pip3 installera virtualenv
cd / home / django
virtualenv env

Nu har du skapat en virtuell Python 3.6 miljö i / home / django / env mapp som kan aktiveras med följande kommando: Nu när vi har pip, låt oss skapa en virtuell miljö. Virtuella miljöer hjälper till att undvika konflikter med Python-paket som används av Linux.

källa / hem / django / env / bin / aktivera

Upprättande av Django-projektet

För denna handledning skapar vi ett tillfälligt Django-projekt. Om du distribuerar din egen kod måste du ladda upp den till servern istället. Vi arbetar i hemkatalogen / home / django.Upprättande av Django-projektet

Låt oss skapa Django-projektet:

cd / home / django
källa env / bin / aktivera
pip installera django
django-admin startprojekthandledning

Verifiera att saker fungerar genom att köra:

cd-handledning
hantera python.py runserver 0.0.0.0:80

Vår Ubuntu-instans körs 178.128.229.34 så vi ansluter till http: // 178.128.229.34.Verifiera att saker fungerar genom att köra:

Du kommer sannolikt att se något så här:

För att åtgärda detta redigerar vi / home / django / tutorial / tutorial / settings.py. Hitta ALLOWED_HOSTS = [] och ställ in den till:

ALLOWED_HOSTS = [
178.128.229.34 '# ersätt detta med din serverns IP-adress
eller det domännamn du använder för att ansluta
]

Låt oss nu gå tillbaka till http: // 178.128.229.34:

Bra! Vi är online!

Konfigurera PostgreSQL, databasen

Som standard använder Django en SQLite3-databas. Tyvärr tillåter inte SQLite3 samtidiga skrivningar. Om din webbplats bara har en användare som redigerar data och resten av besökarna bara läser sidor, kan det vara lämpligt. Men om du har flera personer som redigerar data samtidigt vill du sannolikt använda en annan backend.

Vanliga val är PostgreSQL och Mysql. Vi följer med PostgreSQL för den här guiden.

Börja med att installera PostgreSQL:

apt-get install postgresql

Starta sedan psql, ett databaskal. Som standard kan bara postgresanvändaren ansluta till databasen så att vi först måste verifiera som den användaren:

su - postgres
psql

Därefter behöver vi en databas och en användare för att komma åt databasen:

skapa databashandledning;
skapa användarhandledning_användare med krypterat lösenord 'tutorial_password';
bevilja alla behörigheter i databashandledning till tutorial_user;

Skriv nu exit eller tryck Ctrl-D två gånger: en gång för att avsluta psql och en gång för att logga ut från postgresusern skal.

Bra! Nu har vi konfigurerat vår databas och användare. Låt oss verifiera att vi kan logga in i vår databas.

Vi försöker öppna ett databaskal, den här gången loggar vi in i databasen vi skapade med användaren som vi skapade:

psql -Ututorial_user -handledning -h127.0.0.1 -W

Ange lösenordet som vi skapade vid uppmaningen: tutorial_password.

Om du ser ett databaskal har du lyckats. Om du ser några fel måste du gå tillbaka och ta reda på vad som är fel.

Ansluter Django till databasen

För att få Django ansluten till databasen måste vi först installera Python PostgreSQL-adaptern:

pip installera psycopg2-binär

Låt oss sedan öppna / home / django / tutorial / tutorial / settings.pyoch konfigurera anslutningen.

Hitta din nuvarande databasanslutning; om du inte ändrade det kan det se ut så här:

DATABASER =
'standard':
'MOTOR': 'django.db.backends.sqlite3 ',
'NAMN': os.väg.gå med (BASE_DIR, 'db.sqlite3 '),

För att ansluta till PostgreSQL ersätter vi den med följande:

DATABASER =
'standard':
'MOTOR': 'django.db.backends.postgresql_psycopg2 ',
'NAME': 'tutorial',
'USER': 'tutorial_user',
'LÖSENORD': 'tutorial_password',
'VÄST': '127.0.0.1 ',
'PORT': '5432',

Låt oss testa anslutningen:

cd / home / django / tutorial
python hantera.py runserver 0.0.0.0:80

Du bör åter kunna besöka din webbplats (för oss på http: // 178.128.229.34 /, men ersätt det med din IP eller värdnamn).

Om allt går bra kan vi fortsätta.

Ställa in nginx, webbservern

När du springer hantera python.py runserver, du använder Djangos utvecklingsserver. Det här är bra för lokal utveckling, men som med SQLite3 är det inte riktigt lämpligt för produktion.

Vanliga val för produktionswebbservrar är nginx och Apache. För den här handledningen använder vi nginx.

Installera nginx med följande:

apt-get install nginx

Om allt har fungerat bra bör nginx köras på port 80. Gå vidare och kolla in din webbplats; du borde se:

Bra, så nginx är igång! Därefter måste vi konfigurera den för att kommunicera med Django. Öppna konfigurationsfilen för nginx, som finns på / etc / nginx / sites-available / default. Låt oss ersätta filen med följande:

uppströms django
server 127.0.0.1: 8000;

server
lyssna 80;
plats /
try_files $ uri @send_to_django;

plats @send_to_django
proxy_set_header Värd $ http_host;
proxy_redirect av;
proxy_pass http: // django;

Testa konfigurationsfilen genom att köra nginx -t. Om allt är ok kan vi ladda om igen genom att köra nginx -s reload.

Om du besöker din webbplats kommer du att se följande:

När du ser detta betyder det att nginx inte kunde skicka begäran till uppströmsprocessen. För närvarande beror det på att det försöker skicka begäran till 127.0.0.1: 8000 men det finns ingen processlyssning på den adressen.

Låt oss starta Django-utvecklingsservern och försöka igen:

cd / home / django / tutorial
hantera python.py runserver 127.0.0.1: 8000

och besöka igen din webbplats. Du bör se din Django-applikation.

Montering av Django på Gunicorn

Kom ihåg att vi inte vill använda vår Django-utvecklingsserver i produktion. Istället använder vi en Web Server Gateway Interface (WSGI) -server för att köra Django. Nginx skickar begäran till WSGI-servern, som kör Django.

Vanliga val för en WSGI-server är Gunicorn och uWSGI. För denna handledning använder vi Gunicorn.

Låt oss installera Gunicorn:

pip installera gunicorn

Därefter kan vi starta gunicorn enligt följande:

cd / home / django / tutorial
gunicorn tutorial.wsgi

Nu ska du kunna besöka din webbplats och se att din applikation körs ordentligt.

Kör Gunicorn som en tjänst

Det finns några problem med att köra gunicorn så här:

Om vi stänger SSH-sessionen kommer gunicorn-processen att sluta.
Om servern startar om startar inte gunicorn-processen.
Processen körs som root. Om hackare hittar en exploatering i vår apps kod kan de köra kommandon som root. Vi vill inte ha det här; men det är därför vi skapade djangousern!

För att lösa dessa problem kommer vi att köra Gunicorn som en systemd-tjänst.

cd / home / django
mkdir bin
cd / home / django / bin
tryck på startservern.sh

I startservern.sh:

cd / home / django
källa env / bin / aktivera
cd-handledning
gunicorn tutorial.wsgi

Nu kan du testa skriptet:

cd / home / django / bin
bash start-server.sh
# besök din webbplats, den ska vara igång

Nu skapar vi systemtjänsten för Gunicorn. Skapa / etc / systemd / system / gunicorn.serviceas följer:

[Enhet]
Beskrivning = Gunicorn
Efter = nätverk.mål
[Service]
Typ = enkel
Användare = django
ExecStart = / home / django / bin / start-server.sh
Starta om = vid fel
[Installera]
WantedBy = fleranvändare.mål

Låt oss nu aktivera tjänsten och starta den

systemctl aktivera gunicorn
systemctl starta gunicorn

Du borde kunna se din webbplats just nu.

Vi kan stänga av gunicorn enligt följande:

systemctl stoppa gunicorn

Och du borde se en 502 Bad Gateway.

Slutligen, låt oss kontrollera startcykeln:

systemctl starta gunicorn
starta om nu

När din maskin kommer tillbaka online bör du se att din webbplats är uppe.

Statiska filer

Om du besöker Django adminpanelen på din webbplats på / admin / (för oss är det http: // 178.128.229.34 / admin /), kommer du att märka att statiska filer inte laddas ordentligt.

Vi måste skapa en ny mapp för statiska filer:

cd / home / django
mkdir statisk

Sedan berättar vi för Django att det är där den ska lägga de statiska filerna genom att redigera / home / django / tutorial / tutorial / settings.py och lägga till:

STATIC_ROOT = '/ hem / django / statisk /'

Nu kan vi samla de statiska filerna:

cd / home / django
källa env / bin / aktivera
cd-handledning
hantera python.py collectstatic

Slutligen måste vi säga till nginx att de ska servera dessa statiska filer.

Låt oss öppna / etc / nginx / sites-available / default och lägga till följande direkt ovanför din plats / block:

plats / statisk /
root / home / django;
try_files $ uri = 404;

Hela filen ska nu se ut så här:

uppströms django
server 127.0.0.1: 8000;

server
lyssna 80;
plats / statisk /
root / home / django;
try_files $ uri = 404;

plats /
try_files $ uri @send_to_django;

plats @send_to_django
proxy_set_header Värd $ http_host;
proxy_redirect av;
proxy_pass http: // django;

Vi kan ladda om filen med nginx -s reload

Och voila! Dina statiska filer fungerar nu helt.

Slutsats

Vid den här tiden fungerar din Django-app ordentligt. Om du har några speciella krav kan du behöva ställa in en cache som Redis eller en meddelandekö som Rabbit MQ. Du kanske också vill ställa in kontinuerlig distribution eftersom distributionsproceduren kan ta ett tag.

Ett annat viktigt steg är att vidta lämpliga steg för att säkra din Ubuntu-maskin. Annars kan det hända att din server inte fungerar bra!

Lycka till!

Skapa en Django-app på Ubuntu Server