Jak nastavit vývojové prostředí Django na Ubuntu 18.04

Django je výkonný webový rámec, který vám může pomoci rozjet vaši Pythonovou aplikaci nebo web. Django obsahuje zjednodušený vývojový server pro testování vašeho kódu lokálně, ale pro cokoli, co se i jen trochu týká produkce, je vyžadován bezpečnější a výkonnější webový server (Nginx – Apache).

V této příručce si ukážeme, jak nainstalovat a nakonfigurovat některé součásti na Ubuntu 18.04 pro podporu a obsluhu aplikací Django. Místo použití výchozí databáze SQLite nastavíme databázi PostgreSQL. Nakonfigurujeme aplikační server Gunicorn pro rozhraní s našimi aplikacemi. Poté nastavíme Nginx, aby reverzní proxy na Gunicorn, což nám umožní přístup k jeho funkcím zabezpečení a výkonu, abychom mohli obsluhovat naše aplikace.

Vytvořit uživatele bez oprávnění root s nakonfigurovanými právy sudo

Přihlášení jako root
Vytvoření nového uživatele
```
# adduser bobby
```
Udělování administrativních oprávnění
Chcete-li přidat tato oprávnění našemu novému uživateli, musíme nového uživatele přidat do skupiny sudo. Ve výchozím nastavení na Ubuntu 18.04 mohou uživatelé, kteří patří do skupiny sudo, používat příkaz sudo.
```
# usermod -aG sudo bobby
```

Nainstalujte balíčky z repozitářů Ubuntu

Pro zahájení procesu si stáhneme a nainstalujeme všechny položky, které potřebujeme, z repozitářů Ubuntu. K instalaci dalších komponent o něco později použijeme pip správce balíčků Pythonu.
Musíme aktualizovat místní index balíčků apt a poté balíčky stáhnout a nainstalovat. Balíčky, které nainstalujeme, závisí na tom, jakou verzi Pythonu bude váš projekt používat.
Při instalaci Django pomocí Pythonu 3 zadejte :

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

Tím se nainstaluje pip, vývojové soubory Pythonu potřebné k pozdějšímu sestavení Gunicornu, databázový systém Postgres a knihovny potřebné k interakci s ním a webový server Nginx.

Vytvořte databázi PostgreSQL a uživatele

Jdeme rovnou do toho a vytvoříme databázi a databázového uživatele pro naši aplikaci Django. Ve výchozím nastavení Postgres používá schéma ověřování zvané peer authentication pro místní připojení. V zásadě to znamená, že pokud se uživatelské jméno operačního systému uživatele shoduje s platným uživatelským jménem Postgres, tento uživatel se může přihlásit bez dalšího ověřování.

Během instalace Postgres byl vytvořen uživatel operačního systému s názvem postgres, který odpovídá administrativnímu uživateli Postgres PostgreSQL. Potřebujeme tohoto uživatele použít k provádění administrativních úkolů. Můžeme použít sudo a předat uživatelské jméno s volbou -u.

Přihlaste se do interaktivní relace Postgres zadáním :

$ sudo -u postgres psql

Zobrazí se výzva PostgreSQL, kde můžeme nastavit naše požadavky.

Nejprve vytvořte databázi pro svůj projekt

Postgres=# CREATE DATABASE newproject;

Poznámka: Každý příkaz Postgres musí končit středníkem

Dále vytvořte uživatele databáze pro náš projekt. Ujistěte se, že jste vybrali bezpečné heslo

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

Poté upravíme několik parametrů připojení pro uživatele, kterého jsme právě vytvořili. To urychlí databázové operace, takže se při každém navázání spojení nebude muset dotazovat a nastavovat správné hodnoty.

Výchozí kódování nastavujeme na UTF-8, což Django očekává. Nastavujeme také výchozí schéma izolace transakcí na čtení potvrzené, které blokuje čtení z nepotvrzených transakcí. Nakonec nastavíme časové pásmo. Ve výchozím nastavení budou naše projekty Django nastaveny na používání UTC. Toto jsou všechna doporučení ze samotného projektu Django.

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';

Nyní můžeme dát našemu novému uživateli přístup ke správě naší nové databáze

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

Po dokončení ukončete výzvu PostgreSQL zadáním:

Postgres=# \q

Vytvořte pro svůj projekt virtuální prostředí Python 3

Nyní, když máme naši databázi, můžeme začít připravovat zbytek našich projektových požadavků. Naše požadavky Python 3 nainstalujeme do virtuálního prostředí pro snadnější správu.

K tomu potřebujeme nejprve přístup k příkazu virtualenv. Můžeme to nainstalovat pomocí pip3.

Upgradujte pip3 a nainstalujte balíček zadáním:

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

S nainstalovaným virtualenv můžeme začít tvořit náš projekt. Vytvořte a přesuňte se do adresáře, kde můžeme uchovávat soubory projektu:

  $ mkdir ~/djangoproject
  $ cd ~/djangoproject

V adresáři projektu vytvořte virtuální prostředí Pythonu zadáním:

$ virtualenv djangoprojectenv

Tím se vytvoří adresář s názvem djangoprojectenv ve vašem djangoproject adresář. Uvnitř nainstaluje místní verzi Pythonu a místní verzi pip. Můžeme to použít k instalaci a konfiguraci izolovaného prostředí Pythonu pro náš projekt.

Než nainstalujeme požadavky Pythonu našeho projektu, musíme aktivovat virtuální prostředí. Můžete to udělat zadáním:

$ source djangoproject/bin/activate

Vaše výzva by se měla změnit, aby indikovala, že nyní pracujete ve virtuálním prostředí Pythonu. Bude to vypadat nějak takto:(djangoprojectenv)user@host:~/djangoproject$ .
S aktivním virtuálním prostředím nainstalujte Django, Gunicorn a adaptér psycopg2 PostgreSQL s místní instancí pip:

Poznámka: Bez ohledu na to, kterou verzi Pythonu 3 nebo pythonu 2 používáte, při aktivaci virtuálního prostředí byste měli použít příkaz pip (ne pip3).

(djangoprojectenv)$ pip install django gunicorn psycopg2-binary

Nyní byste měli mít veškerý software potřebný ke spuštění projektu Django.

Vytvořte a nakonfigurujte nový projekt Django

S nainstalovanými komponentami Pythonu můžeme vytvořit skutečné soubory projektu Django.

Protože již máme adresář projektu, řekneme Django, aby soubory nainstaloval sem. Vytvoří adresář druhé úrovně se skutečným kódem, což je normální, a umístí do tohoto adresáře skript pro správu. Klíčem k tomu je, že definujeme adresář explicitně, místo abychom umožnili Djangu rozhodovat se ve vztahu k našemu aktuálnímu adresáři:

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

V tomto okamžiku je váš adresář projektu (~/djangoproject v našem případě) by měl mít následující obsah:

~/djangoproject/manage.py :Skript pro řízení projektu Django.
~/djangoproject/myproject/ :Balíček projektu Django. To by mělo obsahovat __init__.py , settings.py , urls.py a wsgi.py soubory.
~/djangoproject/djangoprojectenv/ :Adresář virtuálního prostředí, který jsme vytvořili dříve.

První věc, kterou bychom měli udělat s našimi nově vytvořenými soubory projektu, je upravit nastavení. Otevřete soubor nastavení v textovém editoru:

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

Začněte vyhledáním direktivy ALLOWED_HOSTS. Toto definuje seznam adres serveru nebo názvů domén, které lze použít pro připojení k instanci Django. Všechny příchozí požadavky s hlavičkou hostitele, která není v tomto seznamu, vyvolá výjimku. Django vyžaduje, abyste toto nastavili, abyste zabránili určité třídě bezpečnostní zranitelnosti.

V hranatých závorkách uveďte IP adresy nebo názvy domén, které jsou přidruženy k vašemu serveru Django. Každá položka by měla být uvedena v uvozovkách s položkami oddělenými čárkou. Pokud si přejete požadavky na celou doménu a jakékoli subdomény, vložte před začátek položky tečku. Ve úryvku níže je několik okomentovaných příkladů, které slouží k demonstraci.

~/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', . . .]

Dále vyhledejte sekci, která konfiguruje přístup k databázi. Začne to DATABÁZEMI. Konfigurace v souboru je pro databázi SQLite. Pro náš projekt jsme již vytvořili PostgreSQL databázi, takže musíme upravit nastavení.

Změňte nastavení pomocí informací o vaší databázi PostgreSQL. Řekneme Djangovi, aby použil psycopg2adaptor, který jsme nainstalovali s pip. Musíme zadat název databáze, uživatelské jméno databáze, heslo uživatele databáze a poté určit, že databáze je umístěna na místním počítači. Nastavení PORT můžete ponechat jako prázdný řetězec:

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

Dále přejděte dolů na konec souboru a přidejte nastavení označující, kam by měly být umístěny statické soubory. To je nezbytné, aby Nginx mohl zpracovávat požadavky na tyto položky. Následující řádek říká Django, aby je umístil do adresáře s názvem static v adresáři základního projektu:

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

Uložte a zavřete stisknutím Ctrl + x soubor, až budete hotovi.
Nyní můžeme migrovat počáteční schéma databáze do naší databáze PostgreSQL pomocí skriptu pro správu:

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

Vytvořte administrátora projektu zadáním:

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

Budete si muset vybrat uživatelské jméno, zadat e-mailovou adresu a zvolit a potvrdit heslo.
Můžeme shromáždit veškerý statický obsah do umístění adresáře, které jsme nakonfigurovali, zadáním:

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

Budete muset operaci potvrdit. Statické soubory pak budou umístěny do adresáře s názvem static v adresáři vašeho projektu.

Pokud jste postupovali podle úvodního průvodce nastavením serveru, měli byste mít UFW firewall, který chrání váš server. Abychom mohli otestovat vývojový server, budeme muset povolit přístup k portu, který budeme používat.

Vytvořte výjimku pro port 8000 zadáním:

(djangoprojectenv)$ sudo ufw allow 8000

Nakonec můžete svůj projekt otestovat spuštěním vývojového serveru Django pomocí tohoto příkazu:

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

Ve webovém prohlížeči navštivte název domény nebo IP adresu vašeho serveru a za ním :8000:

http://server_domain_or_IP:8000

Měli byste vidět výchozí stránku indexu Django pro Django 2.0.7:

Pokud do adresního řádku zadáte http://server_domain_or_IP:8000/admin, budete vyzváni k zadání administrátorského uživatelského jména a hesla, které jste vytvořili pomocí příkazu createuperuser:

Po ověření získáte přístup k výchozímu administrátorskému rozhraní Django:

Po dokončení průzkumu stiskněte CTRL-C v okně terminálu k vypnutí vývojového serveru.

Testování Gunicornovy schopnosti sloužit projektu

Poslední věc, kterou chceme udělat, než opustíme naše virtuální prostředí, je otestovat Gunicorn, abychom se ujistili, že může aplikaci sloužit. Můžeme to udělat tak, že vstoupíme do našeho projektového adresáře a pomocí gunicorn nahrajeme modul WSGI projektu:

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

Tím se spustí Gunicorn na stejném rozhraní, na kterém běžel vývojový server Django. Můžete se vrátit a aplikaci znovu otestovat.

Poznámka: V administrátorském rozhraní nebude použit žádný styl, protože Gunicorn neví o statickém obsahu CSS, který je za to zodpovědný.

Gunicornovi jsme předali modul zadáním relativní cesty k adresáři k souboru wsgi.py Djanga, který je vstupním bodem do naší aplikace, pomocí syntaxe modulu Pythonu. Uvnitř tohoto souboru je definována funkce zvaná aplikace, která slouží ke komunikaci s aplikací.

Až skončíte s testováním, stiskněte CTRL-C v okně terminálu, abyste zastavili Gunicorn.

Nyní jsme dokončili konfiguraci naší aplikace Django. Z našeho virtuálního prostředí můžeme vycouvat zadáním:

(myprojectenv)$ deactivate

Indikátor virtuálního prostředí ve vaší výzvě bude odstraněn.

Vytvořte soubor služby Gunicorn systemd

Testovali jsme, že Gunicorn může komunikovat s naší aplikací Django, ale měli bychom implementovat robustnější způsob spouštění a zastavování aplikačního serveru. Abychom toho dosáhli, vytvoříme servisní soubor systemd.

Vytvořte a otevřete servisní soubor systemd pro Gunicorn s právy sudo ve vašem textovém editoru:

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

Začněte s [Unit] sekce, která se používá ke specifikaci metadat a závislostí. Zde uvedeme popis naší služby a řekneme init systému, aby ji spustil až po dosažení cíle sítě.

Dále otevřeme [Service] sekce. Zadáme uživatele a skupinu, pod kterou chceme zpracovat. Vlastníkem procesu dáme náš běžný uživatelský účet, protože vlastní všechny relevantní soubory. www-data přiřadíme vlastnictví skupiny skupina, aby Nginx mohl snadno komunikovat s Gunicornem.

Poté zmapujeme pracovní adresář a určíme příkaz, který se má použít ke spuštění služby. V tomto případě budeme muset zadat úplnou cestu ke spustitelnému souboru Gunicorn, který je nainstalován v našem virtuálním prostředí. Připojíme jej k Unixovému soketu v adresáři projektu, protože Nginx je nainstalován na stejném počítači. To je bezpečnější a rychlejší než použití síťového portu. Můžeme zde také specifikovat libovolné volitelné vylepšení Gunicornu. V tomto případě jsme například specifikovali 3 pracovní procesy.

Nakonec přidáme [Install] sekce. To řekne systemd, s čím má tuto službu propojit, pokud jí povolíme spouštění při startu. Chceme, aby se tato služba spustila, až bude spuštěn běžný systém pro více uživatelů:

/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

Tím je náš servisní soubor systemd kompletní. Uložte a zavřete jej.

měli bychom přidat uživatele bobby do skupiny www-data:

$ sudo usermod –a –G www-data bobby

Nyní můžeme spustit službu Gunicorn, kterou jsme vytvořili, a povolit ji, aby se spouštěla při startu:

$ sudo systemctl start gunicorn
$ sudo systemctl enable gunicorn

Úspěšnost operace můžeme potvrdit kontrolou souboru soketu.

Zkontrolujte stav procesu a zjistěte, zda bylo možné jej spustit:

$ sudo systemctl status gunicorn

Dále zkontrolujte existenci djangoproject.sock soubor v adresáři vašeho projektu:

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

Pokud příkaz systemctl status signalizoval, že došlo k chybě nebo pokud nenajdete soubor djangoproject.sock soubor v adresáři, je to známka toho, že Gunicorn nebyl schopen správně spustit. Zkontrolujte protokoly procesů Gunicorn zadáním:

$ sudo journalctl -u gunicorn

Podívejte se na zprávy v protokolech a zjistěte, kde Gunicorn narazil na problémy. Existuje mnoho důvodů, proč jste se mohli dostat do problémů, ale často, pokud Gunicorn nebyl schopen vytvořit soubor soketu, je to z jednoho z těchto důvodů:

Soubory projektu jsou vlastněny uživatelem root, nikoli uživatelem sudo
WorkingDirectory cestu v rámci /etc/systemd/system/gunicorn.service soubor neukazuje na adresář projektu
Možnosti konfigurace dané procesu gunicorn v ExecStart směrnice nejsou správné. Zkontrolujte následující položky:
- Cesta k binárnímu gunicornu ukazuje na skutečné umístění binárky ve virtuálním prostředí
- Položka --bind směrnice definuje soubor, který se má vytvořit v adresáři, ke kterému má Gunicorn přístup
- djangoproject.wsgi:application je přesná cesta k callable WSGI. To znamená, že když jste v WorkingDirectory, měli byste být schopni dosáhnout volatelnou pojmenovanou aplikaci pohledem v djangoproject.wsgi modul (což se překládá do souboru s názvem ./djangoproject/wsgi.py )

Pokud provedete změny v souboru /etc/systemd/system/gunicorn.service, znovu načtěte démona, aby si znovu přečetl definici služby, a restartujte proces Gunicorn zadáním:

$ sudo systemctl daemon-reload
$ sudo systemctl restart gunicorn

Než budete pokračovat, ujistěte se, že jste vyřešili některý z výše uvedených problémů.

Nakonfigurujte Nginx na Proxy Pass do Gunicorn

Nyní, když je Gunicorn nastaven, musíme nakonfigurovat Nginx tak, aby předával provoz do procesu. Začněte vytvořením a otevřením nového bloku serveru v adresáři webů Nginx:

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

Uvnitř otevřete nový blok serveru. Začneme zadáním, že tento blok by měl naslouchat na normálním portu 80 a že by měl odpovídat na název domény nebo IP adresu našeho serveru.

Dále řekneme Nginxu, aby ignoroval jakékoli problémy s nalezením favicon. Také mu řekneme, kde najde statická aktiva, která jsme shromáždili v našem ~/djangoproject/static adresář. Všechny tyto soubory mají standardní předponu URI "/static" , takže můžeme vytvořit blok umístění, který bude odpovídat těmto požadavkům.

Nakonec vytvoříme umístění / blok {}, který bude odpovídat všem ostatním požadavkům. Uvnitř tohoto umístění zahrneme standardní proxy_params soubor, který je součástí instalace Nginx a poté předáme provoz do soketu, který náš proces Gunicorn vytvořil:

/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;
    }
}

Po dokončení uložte a zavřete soubor. Nyní můžeme soubor povolit tak, že jej propojíme s sites-enabled adresář:

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

Otestujte svou konfiguraci Nginx na chyby syntaxe zadáním:

$ sudo nginx -t

Pokud nejsou hlášeny žádné chyby, pokračujte a restartujte Nginx zadáním:

$ sudo systemctl restart nginx

Nakonec musíme otevřít náš firewall pro normální provoz na portu 80. Protože již nepotřebujeme přístup k vývojovému serveru, můžeme odstranit pravidlo pro otevření portu 8000 také:

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

Nyní byste měli být schopni přejít na doménu nebo IP adresu vašeho serveru a zobrazit vaši aplikaci.

Přečtěte si také

Jak nastavit UFW Firewall na Ubuntu 18.04
Jak nainstalovat LAMP Stack na Ubuntu 18.04

Poznámka:Po konfiguraci Nginx by dalším krokem mělo být zabezpečení provozu na server pomocí SSL/TLS. To je důležité, protože bez něj jsou všechny informace, včetně hesel, odesílány přes síť v prostém textu.

Jak nainstalovat Flask s Pythonem 3 na Ubuntu 18.04 Jak nainstalovat a nakonfigurovat DHCP na Ubuntu 18.04

Ubuntu