Django is een algemeen platform voor het ontwikkelen van websites, webapplicaties en web-API's. Er zijn veel voordelen aan het gebruik van het Django-framework voor uw project als uw tool en als u niet zeker weet of het de juiste keuze is, hoeft u alleen maar te kijken naar de vele grote merken die Django in hun stapel gebruiken.

Django voor het eerst in een productieomgeving implementeren kan een ontmoedigende taak zijn. Vaak lanceren ontwikkelaars een Linux-instantie in de cloud voor hun productieomgeving.

In deze zelfstudie laten we u zien hoe u Django in productie start met een nieuwe Ubuntu-instantie.

We gaan ervan uit dat al uw bewerkingen op de server worden uitgevoerd en dat u de opdrachten als root uitvoert.

Voor deze tutorial gebruiken we Ubuntu 18.04.2 LTS

Een gebruiker voor het project maken

We maken een nieuwe gebruiker, django, om onze applicatie uit te voeren. Dit biedt een klein beveiligingsvoordeel.

Om de nieuwe gebruiker aan te maken:

useradd -m django

De -m vlag maakt een nieuwe homedirectory aan: /home/django.

De Python-omgeving instellen

First things first: update uw pakketlijsten met apt-get update

Ubuntu 18.04 wordt geleverd met Python 3.6, maar het wordt niet geleverd met pip, wat je nodig hebt om je afhankelijkheden te installeren.

apt-get install python3-pip

Nu we pip hebben, gaan we een virtuele omgeving maken. Virtuele omgevingen helpen conflicten met Python-pakketten die door Linux worden gebruikt te voorkomen.

pip3 installeer virtualenv
cd /home/django
virtuele omgeving

Nu heb je een virtuele Python 3 . gemaakt.6 omgeving in de /home/django/env map die kan worden geactiveerd met de volgende opdracht:Nu we pip hebben, laten we een virtuele omgeving maken. Virtuele omgevingen helpen conflicten met Python-pakketten die door Linux worden gebruikt te voorkomen.

bron /home/django/env/bin/activate

Het Django-project opzetten

Voor deze tutorial maken we een tijdelijk Django-project. Als u uw eigen code implementeert, moet u deze in plaats daarvan naar de server uploaden. We werken in de homedirectory, /home/django.Het Django-project opzetten

Laten we het Django-project maken:

cd /home/django
bron env/bin/activeren
pip install django
django-admin startproject tutorial

Controleer of alles werkt door het volgende uit te voeren:

cd-tutorial
python beheren.py runserver 0.0.0.0:80

Onze Ubuntu-instantie draait op 178.128.229.34 dus we maken verbinding met http://178.128.229.34.Controleer of dingen werken door het volgende uit te voeren:

Je ziet waarschijnlijk zoiets als dit:

Om dit op te lossen, zullen we bewerken /home/django/tutorial/tutorial/instellingen.py. Vind ALLOWED_HOSTS = [] en stel deze in op:

ALLOWED_HOSTS = [
'178.128.229.34' # vervang dit door het IP-adres van uw server
of de domeinnaam die u gebruikt om verbinding te maken
]

Laten we nu teruggaan naar http://178.128.229.34:

Super goed! We zijn online!

PostgreSQL instellen, de database

Django gebruikt standaard een SQLite3-database. Helaas staat SQLite3 geen gelijktijdige schrijfbewerkingen toe. Als uw website slechts één gebruiker heeft die gegevens bewerkt en de rest van de bezoekers alleen pagina's leest, dan is dit misschien geschikt. Maar als meerdere mensen tegelijkertijd gegevens bewerken, wilt u waarschijnlijk een andere backend gebruiken.

Veelvoorkomende keuzes zijn PostgreSQL en Mysql. We gaan voor PostgreSQL voor deze tutorial.

Begin met het installeren van PostgreSQL:

apt-get install postgresql

Start vervolgens psql, een database-shell. Standaard kan alleen de postgres-gebruiker verbinding maken met de database, dus we moeten ons eerst verifiëren als die gebruiker:

su - postgres
psql

Vervolgens hebben we een database en een gebruiker nodig om toegang te krijgen tot die database:

zelfstudie database maken;
maak gebruiker tutorial_user met versleuteld wachtwoord 'tutorial_password';
verleen alle rechten op de database-tutorial aan tutorial_user;

Typ nu exit of druk twee keer op Ctrl-D: één keer om psql af te sluiten en één keer om uit te loggen bij de shell van de postgresuser.

Super goed! Nu hebben we onze database en gebruikersconfiguratie. Laten we controleren of we kunnen inloggen op onze database.

We zullen proberen een database-shell te openen, deze keer loggen we in op de database die we hebben gemaakt met de gebruiker die we hebben gemaakt:

psql -Ututorial_user -dtutorial -h127.0.0.1 -W

Voer bij de prompt het wachtwoord in dat we hebben gemaakt: tutorial_password.

Als je een database-shell ziet, ben je geslaagd. Als je fouten ziet, moet je teruggaan en uitzoeken wat er mis is.

Django verbinden met de database

Om Django met de database te verbinden, moeten we eerst de Python PostgreSQL-adapter installeren:

pip installeer psycopg2-binary

Laten we dan open gaan /home/django/tutorial/tutorial/instellingen.pyen configureer de verbinding.

Vind uw huidige databaseverbinding; als je het niet hebt gewijzigd, kan het er ongeveer zo uitzien:

DATABANKEN =
'standaard':
'MOTOR': 'django.db.backends.sqlite3',
'NAAM': os.pad.join(BASE_DIR, 'db').sqlite3'),

Om verbinding te maken met PostgreSQL, vervangen we het door het volgende:

DATABANKEN =
'standaard':
'MOTOR': 'django.db.backends.postgresql_psycopg2',
'NAAM': 'zelfstudie',
'USER': 'tutorial_gebruiker',
'WACHTWOORD': 'zelfstudiewachtwoord',
'HOST': '127.0.0.1',
'POORT': '5432',

Laten we de verbinding testen:

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

U zou uw website weer moeten kunnen bezoeken (voor ons op http://178.128.229.34/, maar vervang dat door uw IP of hostnaam).

Als alles goed is kunnen we verder.

nginx, de webserver instellen

Wanneer je rent python beheren.py runserver, je gebruikt de ontwikkelingsserver van Django. Dit is geweldig voor lokale ontwikkeling, maar net als bij SQLite3 is het niet echt geschikt voor productie.

Veelvoorkomende keuzes voor productiewebservers zijn nginx en Apache. Voor deze tutorial gebruiken we nginx.

Installeer nginx met behulp van het volgende:

apt-get install nginx

Nu, als alles goed heeft gewerkt, zou nginx op poort 80 moeten draaien. Ga je gang en bekijk je website; Je zou moeten zien:

Geweldig, dus nginx is in de lucht! Vervolgens moeten we het configureren om met Django te communiceren. Open het nginx-configuratiebestand op /etc/nginx/sites-available/default. Laten we het bestand vervangen door het volgende:

stroomopwaarts django
server 127.0.0.1:8000;

server
luister 80;
plaats /
try_files $uri @send_to_django;

locatie @send_to_django
proxy_set_header Host $http_host;
proxy_redirect uit;
proxy_pass http://django;

Test het configuratiebestand door nginx -t . uit te voeren. Als alles in orde is, kunnen we opnieuw laden door nginx -s reload uit te voeren.

Als u nu uw site bezoekt, ziet u het volgende:

Telkens wanneer u dit ziet, betekent dit dat nginx het verzoek niet kon doorgeven aan het stroomopwaartse proces. Op dit moment is het omdat het probeert het verzoek door te geven aan 127.0.0.1:8000 maar er is geen proces dat op dat adres luistert.

Laten we de Django-ontwikkelserver starten en het opnieuw proberen:

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

en bezoek opnieuw uw website. Je zou je Django-applicatie moeten zien.

Montage van Django op Gunicorn

Onthoud dat we onze Django-ontwikkelserver niet in productie willen gebruiken. In plaats daarvan gebruiken we een WSGI-server (Web Server Gateway Interface) om Django uit te voeren. Nginx zal het verzoek doorgeven aan de WSGI-server, waarop Django . draait.

Veelvoorkomende keuzes voor een WSGI-server zijn Gunicorn en uWSGI. Voor deze tutorial gebruiken we Gunicorn.

Laten we Gunicorn installeren:

pip installeer gunicorn

Vervolgens kunnen we gunicorn als volgt starten:

cd /home/django/tutorial
gunicorn tutorial.wsgi

Nu zou u uw website moeten kunnen bezoeken en zien dat uw toepassing correct werkt.

Gunicorn draaien als een service

Er zijn een paar problemen met het uitvoeren van gunicorn zoals dit:

1. Als we de SSH-sessie sluiten, stopt het gunicorn-proces.
2. Als de server opnieuw opstart, start het gunicorn-proces niet.
3. Het proces wordt uitgevoerd als root. Als hackers een exploit vinden in de code van onze app, kunnen ze opdrachten uitvoeren als root. Dit willen we niet; maar daarom hebben we de djangouser gemaakt!

Om deze problemen op te lossen, gaan we Gunicorn gebruiken als een systemd-service.

cd /home/django
mkdir bin
cd /home/django/bin
tik op start-server.sh

In startserver.sch:

cd /home/django
bron env/bin/activeren
cd-tutorial
gunicorn tutorial.wsgi

Nu kunt u het script testen:

cd /home/django/bin
bash start-server.sh
# bezoek uw website, deze zou moeten draaien

Nu maken we de systemd-service voor Gunicorn. Maak /etc/systemd/system/gunicorn.serviceals volgt:

[Eenheid]
Beschrijving=Gunicorn
Na=netwerk.doelwit
[Onderhoud]
Type=eenvoudig
Gebruiker=django
ExecStart=/home/django/bin/start-server.sh
Opnieuw opstarten = bij falen
[Installeren]
WantedBy=meerdere gebruikers.doelwit

Laten we nu de service inschakelen en starten

systemctl gunicorn inschakelen
systemctl start gunicorn

Je zou op dit moment je website moeten kunnen zien.

We kunnen gunicorn als volgt uitschakelen:

systemctl stop gunicorn

En je zou een 502 Bad Gateway moeten zien.

Laten we tot slot de opstartcyclus controleren:

systemctl start gunicorn
herstart nu

Wanneer uw machine weer online komt, zou u moeten zien dat uw website in de lucht is.

Statische bestanden

Als u het Django-beheerderspaneel op uw website bezoekt op /admin/ (voor ons is dit http://178.128.229.34/admin/), zult u merken dat statische bestanden niet goed worden geladen.

We moeten een nieuwe map maken voor statische bestanden:

cd /home/django
mkdir statisch

Vervolgens vertellen we Django waar het de statische bestanden moet plaatsen door /home/django/tutorial/tutorial/settings te bewerken.py, en het toevoegen van:

STATIC_ROOT = '/home/django/static/'

Nu kunnen we de statische bestanden verzamelen:

cd /home/django
bron env/bin/activeren
cd-tutorial
python beheren.py collectstatic

Ten slotte moeten we nginx vertellen om die statische bestanden te serveren.

Laten we /etc/nginx/sites-available/default openen en het volgende direct boven je locatie/blok toevoegen:

locatie /statisch/
root /home/django;
try_files $uri =404;

Het hele bestand zou er nu als volgt uit moeten zien:

stroomopwaarts django
server 127.0.0.1:8000;

server
luister 80;
locatie /statisch/
root /home/django;
try_files $uri =404;

plaats /
try_files $uri @send_to_django;

locatie @send_to_django
proxy_set_header Host $http_host;
proxy_redirect uit;
proxy_pass http://django;

We kunnen het bestand opnieuw laden met nginx -s reload

En voila! Uw statische bestanden zullen nu volledig werken.

Conclusie

Op dit moment werkt je Django-app correct. Als je speciale vereisten hebt, moet je misschien een cache instellen zoals Redis of een berichtenwachtrij zoals Rabbit MQ. Mogelijk wilt u ook continue implementatie instellen, omdat de implementatieprocedure enige tijd kan duren.

Een andere belangrijke stap is het nemen van de juiste stappen om uw Ubuntu-machine te beveiligen. Anders kan uw server zich misdragen!

Succes!