Úvod
Docker je open-source kontajnerová platforma. Ide o ľahké, virtualizované, prenosné, softvérovo definované štandardizované prostredie, ktoré umožňuje softvéru bežať v izolácii od ostatného softvéru bežiaceho na fyzickom hostiteľskom počítači. Docker ponúka ľahkú alternatívu k virtuálnym strojom. Zároveň poskytuje prenosnosť, výkon, agilitu a škálovateľnosť aplikácií. Pre komplexného sprievodcu ekosystémom Docker, pozrite si náš podrobný prehľad kontajnerizácie s Dockerom.
Flask je open-source minimálny webový framework vytvorený pomocou Python. Medzi skvelé vlastnosti Flasku patrí, že je ľahký, flexibilný a vysoko štruktúrovaný. Okrem toho na svoje spustenie nevyžaduje žiadne špecifické nástroje ani plug-iny.
Spojenie Flasku a Dockeru vám poskytne ľahkú, flexibilnú a škálovateľnú aplikáciu. Môžete ju nasadiť na mnohých serveroch a infraštruktúrach vďaka prenosnosti dockerizovaných kontajnerov. Cieľom tohto návodu je ukázať vám, ako nasadiť aplikáciu Flask pomocou Dockeru. Ukážeme si tiež, ako zabezpečiť, aby sa prejavili budúce aktualizácie vašej aplikácie.
Predpoklady
Toto bude praktický návod a mali by ste si vytvoriť prostredie, ktoré vám umožní postupovať podľa neho:
- Mali by ste mať inštaláciu Ubuntu 20.04 ako vaše počiatočné operačné prostredie. Taktiež si musíte vytvoriť non-root používateľa s privilégiami sudo.
- Okrem toho musíte nainštalovať Docker. Máme návod na ako nainštalovať a prevádzkovať Docker na Ubuntu. Postupujte podľa krokov 1, 2, 3 a 4. Toto by malo fungovať pre akúkoľvek distribúciu Ubuntu.
- Na záver musíte mať Nginx nainštalovaný. Postupujte podľa nášho návodu na inštaláciu Nginx na Ubuntu.
Teraz začnime!
Krok 1: Príprava aplikácie Flask
Začneme vytvorením adresára, ktorý bude obsahovať našu Flask aplikáciu. Môžete si vybrať názov adresára podľa vlastného výberu. Pre tento návod ho však pomenujeme flask_demo. Súbory projektu uložíme do /var/www adresára, čo je zvyčajne adresár, do ktorého Ubuntu predvolene povoľuje prístup z verejného internetu. Najprv vykonajte nasledujúce príkazy na vytvorenie adresára a prejdite doň:
|
1 2 3 |
sudo mkdir /var/www/flask_demo cd /var/www/flask_demo |
Vo vnútri tohto koreňového adresára nášho projektu vytvoríme základnú štruktúru priečinkov aplikácie Flask. Potom spustite nasledujúci príkaz na vytvorenie základnej štruktúry, pričom pridajte -p príznak na vytvorenie všetkých nadradených priečinkov:
|
1 |
sudo mkdir -p app/static app/templates |
Priečinok app obsahuje všetky súbory súvisiace s aplikáciou Flask vrátane views a blueprints. Views obsahujú kód, ktorý píšete na odpovedanie na požiadavky prichádzajúce do vašej aplikácie. Blueprints pomáhajú pri vytváraní komponentov aplikácie a podporujú bežné vzory v aplikáciách Flask.
Výstižne pomenovaný static priečinok obsahuje statické súbory, ako sú obrázky, CSS a JavaScript súbory. Adresár templates obsahuje všetky HTML šablóny pre projekt.
Teraz môžeme začať písať súbory potrebné na inicializáciu aplikácie Flask. Začnite vytvorením súboru s názvom __init__.py vo vnútri adresára app, aby ste Python interpretátoru oznámili, že adresár app by sa mal považovať za balík. Spustite nasledujúci príkaz vo svojom termináli, aby ste otvorili súbor v editore nano:
|
1 |
sudo nano app/__init__.py |
V Pythone používame balíky na zoskupenie modulov do logických menných priestorov alebo hierarchií. Modularizácia umožňuje rozdeliť kód na jednotlivé a spravovateľné bloky, ktoré vykonávajú definované funkcie.
Potom vo vnútri __init__.py súbore otvorenom vo vašom editore pridajte nasledujúci úryvok kódu na spustenie inštancie Flask a importujte logiku z views.py ktorý vytvoríte v nasledujúcich krokoch:
|
1 2 3 4 5 |
from flask import Flask app = Flask(__name__) from app import views |
Keď skončíte, stlačte Ctrl + O a ENTER na uloženie súboru, potom ho zatvorte pomocou Ctrl + X. Ďalej vytvorme views.py vo vnútri app adresára. Súbor views.py bude obsahovať väčšinu logiky aplikácie:
|
1 |
sudo nano app/views.py |
Do súboru pridajte nasledujúci úryvok kódu. Tento kód zobrazí jednoduchý reťazec, ktorý ukáže, že vaša aplikácia beží, keď používatelia navštívia vašu webovú stránku:
|
1 2 3 4 5 |
from app import app @app.route('/') def home(): return "Naša Flask aplikácia beží!" |
V tomto súbore začneme importovaním inštancie aplikácie Flask. Potom musíme pridať riadok na definovanie trasy: @app.route(/). @app.route(/) riadok sa označuje ako dekorátor vo Flasku. Dekorátory môžete použiť na vloženie ďalších funkcionalít do jednej alebo viacerých funkcií. V tomto prípade odovzdávame volanie trase / do funkcie home. Keď používateľ navštívi túto trasu, uvidí text: "Naša Flask aplikácia beží!".
Ďalej vytvoríte uwsgi.ini súbor na uchovanie uWSGI konfigurácií pre aplikáciu. uWSGI je možnosť nasadenia pre Nginx, ktorá slúži ako protokol a aplikačný server. Spustením nasledujúceho príkazu vytvorte súbor v koreňovom adresári projektu pomocou editora nano:
|
1 |
sudo nano uwsgi.ini |
Do otvoreného súboru pridajte nasledujúci úryvok kódu:
|
1 2 3 4 |
[uwsgi] module = main callable = app master = true |
Tento súbor obsahuje niekoľko direktív. Ich účel definujeme nižšie:
- module – definuje modul, z ktorého sa bude aplikácia Flask poskytovať. Modul sme nastavili ako main, čo odkazuje na main.py súbor v koreňovom adresári. Tento súbor vytvoríme v nasledujúcom kroku.
- callable – prikazuje uWSGI použiť app inštanciu exportovanú z aplikácie.
- master – zabezpečuje, že aplikácia zostane spustená, aby sa minimalizoval prestoj počas opätovného načítania celej aplikácie.
Po dokončení súbor uložte a zatvorte.
Teraz môžete vytvoriť main.py súbor na určenie vstupného bodu do vašej aplikácie. uWSGI bude čítať tento súbor, aby vedel, ako komunikovať s aplikáciou. Spustením nasledujúceho príkazu vytvorte main.py súbor pomocou nano v koreňovom adresári vášho projektu:
|
1 |
sudo nano main.py |
Do súboru pridajte nasledujúci riadok, ktorý importuje inštanciu Flask, ktorá bola vytvorená v balíku aplikácie:
|
1 |
from app import app |
Posledná vec, ktorú v tomto kroku urobíte, je definovanie závislostí potrebných na spustenie aplikácie. Tieto závislosti definujeme v súbore s názvom dependencies.txt. Keď Docker zostaví obraz vašej aplikácie, spustí príkaz pip (package manager) na inštaláciu závislostí. Otvorte súbor v koreňovom adresári pomocou nasledujúceho príkazu:
|
1 |
sudo nano dependencies.txt |
Až do tohto bodu v našom projekte chceme iba jednu závislosť: Flask. Preto môžeme pridať nasledujúci riadok, ktorý odkazuje na správnu verziu Flasku, ktorú chceme pre náš projekt:
|
1 |
Flask==2.0.1 |
Vybrali sme si Flask verziu 2.0.1 ako závislosť. Ide o najnovšiu verziu v čase písania tohto návodu. Viac o rôznych verziách sa môžete dozvedieť na stránke Flask Changes. Týmto je nastavenie aplikácie Flask dokončené. Teraz si pripravme konfigurácie Dockeru na nasadenie.
Krok 2: Konfigurácia Dockeru
Na nastavenie nasadenia Dockeru vytvoríme dva súbory, Dockerfile a start.sh. Súbor Dockerfile obsahuje deklaratívne riadky, ktoré tvoria obraz Docker. Skript start.sh je jednoduchý shell skript na zostavenie obrazu a spustenie kontajnera z Dockerfile. Keď ste v koreňovom adresári projektu, vykonajte nasledujúci príkaz na vytvorenie Dockerfile:
|
1 |
sudo nano Dockerfile |
Tento súbor obsahuje potrebné konfigurácie pre obraz Docker. Ďalej pridajte nasledujúci úryvok kódu na špecifikovanie závislostí a spôsobu zostavenia obrazu:
|
1 2 3 4 5 6 7 8 9 10 11 |
FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7 RUN apk --update add bash nano git ENV STATIC_URL /static ENV STATIC_PATH /var/www/app/static COPY ./dependencies.txt /var/www/dependencies.txt RUN pip install -r /var/www/dependencies.txt |
Prvý riadok v Dockerfile definuje základný obraz, z ktorého zostavujeme náš obraz. V tomto prípade budeme stavať na základe tiangolo/uwsgi-nginx-flask, dostupného na DockerHub. Tento konkrétny obraz sme si vybrali preto, že podporuje mnoho verzií Pythonu.
Taktiež špecifikujeme, že chceme aktualizovať obraz. Potom musíme pridať bash príkaz processo , nano textový editor, a git klienta na preberanie a odosielanie zdrojového kódu z repozitárov správy verzií, ako sú GitHub, Bitbucket, alebo Gitlab. Riadky s ENV špecifikujú premenné prostredia, ktoré sa majú použiť v kontajneri.
Príkaz COPY príkaz skopíruje závislosti do kontajnera. Príkaz RUN vyvolá správcu balíkov pip package managerna analýzu súboru dependencies.txt a inštaláciu závislostí. Po dokončení úprav súbor uložte a zatvorte.
Ďalej vytvoríte skript start.sh. Tento skript bude obsahovať príkazy Dockeru na zostavenie a spustenie obrazu. Hoci môžete tieto príkazy spúšťať v termináli postupne, mysleli sme si, že je čistejšie pridať ich do shell skriptu a jednoducho ho vyvolať z terminálu jedným príkazom.
Predtým, ako budeme môcť definovať obsah tohto súboru, musíme najprv určiť voľný port, ktorý iné služby nepoužívajú. Budeme používať port 45644. Môžete si však vybrať iný port. Spustením nasledujúceho riadku skontrolujte, či je port voľný:
|
1 |
sudo nc localhost 45644 < /dev/null; echo $? |
V závislosti od zvoleného portu, ak je výstup vyššie uvedeného príkazu 1, potom je voľný. V opačnom prípade si možno budete musieť vybrať iný port a príkaz spustiť znova:
Keďže sme vytvorili voľný port, môžeme teraz vytvoriť súbor pomocou nano v koreňovom adresári projektu spustením nasledujúceho príkazu:
|
1 |
sudo nano start.sh |
Do tohto súboru pridajte nasledujúci úryvok kódu:
|
1 2 3 4 5 6 7 |
#!/bin/bash app_name="docker-flask-demo" docker build -t ${app_name} . docker run -d -p 45644:80 --name=${app_name} -v $PWD:/app ${app_name} |
Prvý riadok, označovaný ako shebang, špecifikuje, že ide o bash súbor a mal by sa vykonať ako príkazy. Druhý riadok deklaruje premennú s názvom app_name. Túto premennú používame na nastavenie názvov obrazu a kontajnera. Tretí riadok inštruuje Docker, aby zostavil obraz na základe Dockerfile definície v aktuálnom adresári. Obraz sa bude volať docker-flask-demo podľa premennej.
Posledný riadok vytvorí kontajner s názvom docker-flask-demo podľa premennej, ktorú sme definovali. Príznak -d udržiava kontajner spustený na pozadí v odpojenom stave po dokončení vykonávania príkazu. Príznak -p príznak mapuje port na serveri na konkrétny port v kontajneri. V tomto prípade pripájame port 45644 na hostiteľskom stroji na port 80 ktorý Docker sprístupní v kontajneri.
Používame príznak -v na určenie Docker zväzku na pripojenie ku kontajneru. Premenná $PWD je predvolená premenná systému Linux, ktorá obsahuje cestu k aktuálnemu adresáru v ktorom sa v danom čase nachádzate:
V našom prípade pripájame celý adresár projektu do /var/www adresár kontajnera. Konfigurácia Dockeru je teraz pripravená. Môžete zostaviť obraz a spustiť kontajner na základe zostaveného obrazu vykonaním nasledujúceho príkazu:
|
1 |
sudo bash start.sh |
Počkajte, kým sa skript dokončí, a potom vykonaním nasledujúceho príkazu Docker vypíšte všetky spustené kontajnery:
|
1 |
sudo docker ps |
Výstup zobrazí spustené kontajnery:
Mali by ste vidieť náš kontajner s názvom docker-flask-demo v zozname spustených kontajnerov. Nájdite verejnú IP svojho servera a otvorte ju v prehliadači na špecifikovanom porte: http://your-server-public-ip:45644.
Mali by ste vidieť podobný výstup:
Ak vo svojom prehliadači vidíte vyššie uvedené, úspešne ste nasadili aplikáciu Flask. Ďalej budeme upravovať súbory a poskytovať obsah používateľom prostredníctvom šablón.
Krok 3: Poskytovanie obsahu prostredníctvom súborov šablón
Vo Flasku, Šablóny sa používajú na zobrazovanie statického a dynamického obsahu návštevníkom webových stránok. Ukážeme vám, ako vytvoriť HTML šablónu a poskytnúť ju vašim používateľom, keď navštívia určitú trasu. Môže to byť napríklad domovská stránka alebo stránka „O nás“.
Spustite nasledujúci príkaz v termináli na vytvorenie index.html súbor v app/templates adresári:
|
1 |
sudo nano app/templates/index.html |
Potom do súboru pridajte nasledujúci úryvok kódu:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Flask Demo</title> </head> <body> <h2>Nachádzate sa doma</h2> <p>Vitajte na the Flask s Docker demo stránke</p> </body> </html> |
Po dokončení súbor uložte a zatvorte. Taktiež vytvorte ďalšiu stránku, nazvime ju O nás, pomocou nasledujúceho príkazu:
|
1 |
sudo nano app/templates/about.html |
Do súboru pridajte nasledujúci útržok kódu:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<!DOCTYPE html> <html lang="sk"> <head> <meta charset="UTF-8"> <title>O Flask Demo</title> </head> <body> <h2>O stránke</h2> <p>Toto bol ukážkový projektproject. To ukazuje ako vytvoriť Flask aplikáciu s Docker a Nginxand Nginx.</p> <p>Môžete pridať toľko stránok a súborov, koľko chceteas you like</p> </body> </html> |
Po dokončení súbor uložte a zatvorte. Potom upravte app/views.py súbor, aby odkazoval na šablóny, ako aj na trasy pre samotné stránky:
|
1 |
sudo nano app/views.py |
Upravte súbor tak, aby vyzeral takto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from flask import render_template from app import app @app.route('/') def home(): return "Naša Flask aplikácia beží!" @app.route('/index') def index(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') |
Po dokončení súbor uložte a zatvorte. Vykonané zmeny sa prejavia až po zastavení a reštartovaní kontajnera. Spustite nasledujúce príkazy Docker na zastavenie a spustenie kontajnera. Poznačte si názov kontajnera, ktorý sme definovali predtým:
|
1 |
sudo docker stop docker-flask-demo && sudo docker start docker-flask-demo |
Keď už kontajner beží a je v prevádzke, navštívte Domovskú stránku a stránku O nás, aby ste videli časť nového obsahu:
|
1 |
Domovská stránka: http://your-server-public-ip:45644/index |
|
1 |
O nás stránka: http://your-server-public-ip:45644/about |
Doteraz ste vytvorili Flask aplikáciu, ktorá dokáže poskytovať obsah návštevníkom vašej webovej stránky. Tu je súborová štruktúra projektu:
Pravdepodobne ste si všimli, že sme museli reštartovať Docker kontajner, aby sa prejavili nové zmeny. V ďalšom kroku to zautomatizujeme, aby sme zabezpečili kratšie výpadky.
Krok 4: Nakonfigurujte automatické opätovné načítanie aktualizácií súborov aplikácie
Každý druhý deň robíme zmeny v aplikácii, aby sme vylepšili logiku, používateľské rozhrania alebo pridali nejaké závislosti. Aby sa tieto zmeny prejavili, môže to vyžadovať reštartovanie Docker kontajnera. Našťastie, uWSGI má funkciu nazývanú touch-reload na opätovné načítanie Python skriptu bez reštartovania kontajnera.
Už v základe má Python automatické-znovunačítanie funkcia, ktorá sleduje celý súborový systém kvôli zmenám a obnoví aplikáciu, keď nastane zmena. Hoci je automatické opätovné načítanie dobré na minimalizáciu prestojov, môže byť náročné na prostriedky. Preto sa neodporúča pre produkčné prostredia.
Pozrime sa, ako môžete použiť touch-reload na sledovanie zmien v konkrétnom súbore a opätovné načítanie aplikácie, keď dôjde k zmenám. Upravte uwsgi.ini súbor pomocou editora nano:
|
1 |
sudo nano uwsgi.ini |
Pridajte zvýraznený riadok, aby to vyzeralo takto:
|
1 2 3 4 5 |
[uwsgi] module = main callable = app master = true touch-reload = /app/uwsgi.ini |
Po dokončení súbor uložte a zatvorte. Pridaný riadok určil súbor, ktorý sa upraví, aby sa spustilo opätovné načítanie aplikácie. Aby sa však táto podmienka aktivovala pre budúce úpravy, musíte najprv reštartovať kontajner:
|
1 |
sudo docker stop docker-flask-demo && sudo docker start docker-flask-demo |
Teraz môžete upraviť app/views.py súbor na demonštráciu toho, ako funguje automatické načítanie:
|
1 |
sudo nano app/views.py |
Zmeňte reťazec vrátený funkciou home, ako je zvýraznené:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from flask import render_template from app import app @app.route('/') def home(): return "<h3>Niekoľko zmien v našej Flask aplikácii pre automatické znovunačítanie!</h3>" @app.route('/index') def index(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') |
Po dokončení súbor uložte a zatvorte.
Otvorte domovskú stránku vašej aplikácie v prehliadači: http://your-server-public-ip:45644.
Zatiaľ neuvidíte žiadne zmeny. Je to preto, že podmienka touch-reload deteguje zmenu v uwsgi.ini súbore. Môžete použiť touch na aktiváciu podmienky, čím sa celá aplikácia znova načíta pomocou nasledujúceho príkazu:
|
1 |
sudo touch uwsgi.ini |
Teraz, ak obnovíte domovskú stránku, uvidíte zobrazené nové zmeny:
V budúcnosti, ak vykonáte akékoľvek ďalšie zmeny, stačí spustiť príkaz sudo touch uwsgi.ini a celá aplikácia sa znova načíta s kratším výpadkom. Tým sme sa dostali na koniec tohto návodu.
Záver
V tomto návode ste implementovali a nasadili aplikáciu Flask pomocou Docker obrazov a kontajnerov. Aby ste minimalizovali výpadky a vyhli sa potrebe reštartovať kontajner, nakonfigurovali ste touch-reload na sledovanie zmien v konkrétnom súbore a automatické opätovné načítanie celej aplikácie. Nakoniec ste to všetko otestovali v prehliadači, aby ste sa uistili, že to funguje.
Docker zaisťuje rýchlejšie nasadenie a umožňuje jednoduché škálovanie aplikácií. Ak sa chcete dozvedieť viac o rôznych príkazoch Dockeru, pozrite si tento návod na ako nainštalovať a používať Docker na Ubuntu.
Ďalšie zdroje o Dockeri na našom blogu, si môžete pozrieť nasledujúce:
- Technológia kontajnerizácie: Typy a využitie rôznych kontajnerov na platforme PaaS spoločnosti CloudSigma
- Ako zdieľať dáta medzi Docker kontajnerom a hostiteľom
- Inštalácia a nastavenie Dockeru na CentOS 7
- Nasadenie Laravel, Nginx a MySQL pomocou Docker Compose
- Vyčistenie Docker zdrojov – obrazy, kontajnery a zväzky
Príjemnú prácu s počítačom!
Komentáre
Zatiaľ žiadne komentáre. Buďte prvý.