Jak nainstalovat Flask s Pythonem 3 na Ubuntu 18.04

Flask je velmi jednoduchý, ale extrémně flexibilní rámec, který má vašim aplikacím poskytnout funkčnost, aniž by byl příliš omezující, pokud jde o strukturu a design. Obecný zásobník popsaný v tomto článku můžete použít k obsluhování aplikací baňky, které navrhujete.

V tomto článku nastavíme jednoduchou aplikaci Python pomocí mikrorámce Flask na Ubuntu 18.04.

Většina tohoto článku bude o tom, jak nastavit aplikační server Gunicorn pro spouštění aplikace a Nginx, aby fungoval jako front-end reverzní proxy.

Předpoklady

Než začnete s tímto článkem, měli byste mít na svém serveru nakonfigurovaného uživatele bez oprávnění root. Tento uživatel musí mít oprávnění sudo, aby mohl provádět administrativní funkce.

Vytvořte uživatele bez oprávnění root s nakonfigurovanými právy sudo:
1- Přihlášení jako root
2- Vytvoření nového uživatele

# adduser bobby

3- Udělení správní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 součásti z repozitářů Ubuntu

Prvním krokem bude instalace všech částí, které potřebujeme z repozitářů. Nainstalujeme pip, správce balíčků Pythonu 3, abychom mohli nainstalovat a spravovat naše komponenty Python 3. Získáme také vývojové soubory Pythonu 3 potřebné k sestavení některých komponent Gunicorn. Nyní nainstalujeme také Nginx.
Aktualizujte svůj lokální index balíčků a poté balíčky nainstalujte. Konkrétní balíčky, které potřebujete, budou záviset na verzi Pythonu, kterou pro svůj projekt používáte.
Při instalaci Pythonu 3 zadejte:

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev nginx

Vytvořte virtuální prostředí Python 3

Dále nastavíme virtuální prostředí, abychom izolovali naši aplikaci Flask od ostatních souborů Pythonu v systému.
Začněte instalací balíčku virtualenv pomocí pip.
Pokud používáte Python 3, napište:

sudo pip3 install virtualenv

Nyní můžeme vytvořit nadřazený adresář pro náš projekt Flask. Po vytvoření se přesuňte do adresáře:

mkdir ~/flaskproject
cd ~/flaskproject

Můžeme vytvořit virtuální prostředí pro uložení požadavků Pythonu našeho projektu Flask zadáním:

virtualenv flaskprojectenv

Tím se nainstaluje místní kopie Pythonu a pip do adresáře s názvem flaskprojectenv v adresáři vašeho projektu.
Než nainstalujeme aplikace v rámci virtuálního prostředí, musíme je aktivovat. Můžete tak učinit zadáním:

source flaskprojectenv/bin/activate

Vaše výzva se změní, aby indikovala, že nyní pracujete ve virtuálním prostředí. Bude to vypadat nějak takto (flaskprojectenv)user@host:~/flaskproject$ .

Nastavení aplikace baňky

Nyní, když jste ve svém virtuálním prostředí, můžeme nainstalovat Flask a Gunicorn a začít s návrhem naší aplikace:

Nainstalujte Flask and Gunicorn

Můžeme použít lokální instanci pip k instalaci Flask a Gunicorn. Tyto dvě součásti získáte zadáním následujících příkazů:

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

(flaskprojectenv) $ pip install gunicorn flask

Vytvořte ukázkovou aplikaci

Nyní, když máme Flask k dispozici, můžeme vytvořit jednoduchou aplikaci. Baňka je mikrorámeček. Neobsahuje mnoho nástrojů, které by mohly mít plnohodnotnější frameworky, a existuje hlavně jako modul, který můžete importovat do svých projektů, aby vám pomohl s inicializací webové aplikace.
I když vaše aplikace může být složitější, vytvoříme naši aplikaci Flask v jediném souboru, který budeme nazývat flaskproject.py:

(flaskprojectenv) $ nano ~/flaskproject/flaskproject.py

Do tohoto souboru umístíme kód naší aplikace. V podstatě potřebujeme importovat baňku a vytvořit instanci objektu Flask. Můžeme to použít k definování funkcí, které by se měly spustit, když je požadována konkrétní trasa:

~/flaskproject/flaskproject.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def greeting():
    return "<h1 style='color:green'>Hello World!</h1>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

To v podstatě definuje, jaký obsah se má prezentovat při přístupu ke kořenové doméně. Po dokončení uložte a zavřete soubor.

Pokud jste postupovali podle úvodního průvodce nastavením serveru, měli byste mít povolený firewall UFW. Abychom mohli otestovat naši aplikaci, musíme povolit přístup k portu 5000.

Otevřete port 5000 zadáním:

(flaskprojectenv) $ sudo ufw allow 5000

Nyní můžete svou aplikaci Flask otestovat zadáním:

(flaskprojectenv) $ python flaskproject.py

Navštivte název domény nebo IP adresu vašeho serveru následovaný :5000 ve vašem webovém prohlížeči:

http://server_domain_or_IP:5000

Měli byste vidět něco takového:

Až budete hotovi, stiskněte CTRL-C v okně vašeho terminálu několikrát zastavit vývojový server Flask.

Vytvořte vstupní bod WSGI

Dále vytvoříme soubor, který bude sloužit jako vstupní bod pro naši aplikaci. To našemu serveru Gunicorn řekne, jak s aplikací komunikovat.

Soubor budeme nazývat wsgi.py :

(flaskprojectenv) $ nano ~/flaskproject/wsgi.py

Soubor je neuvěřitelně jednoduchý, můžeme jednoduše importovat instanci Flask z naší aplikace a poté ji spustit:

~/flaskproject/wsgi.py
from flaskproject import app

if __name__ == "__main__":
    app.run()

Po dokončení uložte a zavřete soubor.

Testování Gunicornovy schopnosti sloužit projektu

Než budeme pokračovat, měli bychom zkontrolovat, zda Gunicorn umí správně. Můžeme to udělat tak, že mu jednoduše předáme název našeho vstupního bodu. Toto je vytvořeno jménem modulu (minus .py rozšíření, jako obvykle) plus název volaného v rámci aplikace. V našem případě by to bylo wsgi:app .

Také určíme rozhraní a port, ke kterému se má vázat, aby se spouštělo na veřejně dostupném rozhraní:

(flaskprojectenv) $ cd ~/flaskproject
(flaskprojectenv) $ gunicorn --bind 0.0.0.0:5000 wsgi:app

Navštivte ve webovém prohlížeči znovu název domény nebo IP adresu vašeho serveru s :5000 připojeným na konec:

http://server_domain_or_IP:5000

Měli byste znovu vidět výstup vaší aplikace:

Až se ujistíte, že funguje správně, stiskněte CTRL-C v okně vašeho terminálu.
Nyní jsme s naším virtuálním prostředím hotovi, takže jej můžeme deaktivovat:

(flaskprojectenv) $ deactivate

Jakékoli příkazy Pythonu budou nyní znovu používat systémové prostředí Pythonu.

Vytvořte soubor systemd Unit

Další částí, o kterou se musíme postarat, je soubor servisní jednotky systemd. Vytvoření souboru systemd unit umožní inicializačnímu systému Ubuntu automaticky spouštět Gunicorn a obsluhovat naši aplikaci Flask, kdykoli se spustí server.

Vytvořte soubor jednotky končící na .service v /etc/systemd/system adresář na začátek:

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

Uvnitř začneme [Unit] sekce, která se používá ke specifikaci metadat a závislostí. Zde vložíme popis naší služby a sdělíme init systém to spustí až po dosažení cíle sítě

Dále otevřeme [Service] sekce. Zadáme uživatele a skupinu, pod kterými chceme proces spustit. 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 procesy Gunicorn.

Poté zmapujeme pracovní adresář a nastavíme proměnnou prostředí PATH tak, aby init systém ví, kde jsou umístěny naše spustitelné soubory pro proces (v našem virtuálním prostředí). Poté určíme příkaz ke spuštění služby. Systemd vyžaduje, abychom poskytli úplnou cestu ke spustitelnému souboru Gunicorn, který je nainstalován v našem virtuálním prostředí.

Řekneme mu, aby spustil 3 pracovní procesy (upravte to podle potřeby). Také mu řekneme, aby vytvořil a navázal soubor soketu Unix v adresáři našeho projektu s názvem flaskproject.sock . Nastavíme hodnotu umask 007 takže je vytvořen soubor soketu, který poskytuje přístup vlastníkovi a skupině a zároveň omezuje jiný přístup. Nakonec musíme předat název souboru vstupního bodu WSGI a volatelný Python.

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/flaskproject.service
[Unit]
Description=Gunicorn instance to serve flaskproject
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/flaskproject
Environment="PATH=/home/bobby/flaskproject/flaskprojectenv/bin"
ExecStart=/home/bobby/flaskproject/flaskprojectenv/bin/gunicorn --workers 3 --bind unix:flaskproject.sock -m 007 wsgi:app

[Install]
WantedBy=multi-user.target

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

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 flaskproject
$ sudo systemctl enable flaskproject

Konfigurace požadavků Nginx na proxy

Náš aplikační server Gunicorn by nyní měl být spuštěn a čekat na požadavky na soubor soketu v adresáři projektu. Musíme nakonfigurovat Nginx tak, aby předával webové požadavky tomuto soketu tím, že do jeho konfiguračního souboru přidáme několik malých doplňků.

Začněte vytvořením nového konfiguračního souboru bloku serveru v sites-available Nginx adresář. Tento flaskproject budeme jednoduše nazývat, aby byl v souladu se zbytkem článku:

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

Otevřete server zablokovat a říct Nginxu, aby naslouchal na výchozím portu 80. Musíme mu také říct, aby použil tento blok pro požadavky na název domény nebo IP adresu našeho serveru.

Jediná další věc, kterou musíme přidat, je location blok, který odpovídá každému požadavku. Do tohoto bloku zahrneme proxy_params soubor, který specifikuje některé obecné parametry proxy, které je třeba nastavit. Poté předáme požadavky do soketu, který jsme definovali pomocí proxy_pass směrnice:

/etc/nginx/sites-available/flaskproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/flaskproject/flaskproject.sock;
    }
}

To je vlastně vše, co potřebujeme k obsluze naší aplikace. Po dokončení uložte a zavřete soubor.

Chcete-li povolit server Nginx konfiguraci bloku, kterou jsme právě vytvořili, propojte soubor s sites-enabled adresář:

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

Se souborem v tomto adresáři můžeme otestovat syntaktické chyby zadáním:

$ sudo nginx -t

Pokud se to vrátí bez uvedení jakýchkoli problémů, můžeme restartovat proces Nginx a přečíst si naši novou konfiguraci:

$ sudo systemctl restart nginx

Poslední věc, kterou musíme udělat, je znovu upravit náš firewall. Již nepotřebujeme přístup přes port 5000, takže toto pravidlo můžeme odstranit. Poté můžeme povolit přístup k serveru Nginx:

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

Nyní byste měli být schopni přejít na název domény nebo IP adresu vašeho serveru ve vašem webovém prohlížeči:

http://server_domain_or_IP

Měli byste vidět výstup vaší aplikace:

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. Nejjednodušší způsob, jak získat certifikát SSL pro zabezpečení vašeho provozu, je pomocí Let's Encrypt.

Přečtěte si také

• Jak nainstalovat Let's Encrypt SSL certifikáty na Ubuntu 18.04
• Jak nastavit vývojové prostředí Django na Ubuntu 18.04
• Jak nainstalovat LEMP na Ubuntu 18.04

Závěr: V tomto článku jsme vytvořili jednoduchou aplikaci Flask ve virtuálním prostředí Pythonu. Vytváříme vstupní bod WSGI, aby se s ním mohl propojit jakýkoli aplikační server s podporou WSGI, a poté jsme nakonfigurovali aplikační server Gunicorn, aby tuto funkci poskytoval. Poté jsme vytvořili soubor systemd unit pro automatické spuštění aplikačního serveru při bootování. Vytvořili jsme blok serveru Nginx, který předává provoz webového klienta aplikačnímu serveru a přenáší externí požadavky.