Bevezetés
Docker egy nyílt forráskódú konténerplatform. Ez egy könnyű, virtualizált, hordozható, szoftveresen definiált szabványosított környezet, amely lehetővé teszi a szoftverek futtatását a fizikai gazdagépen futó más szoftverektől elkülönítve. A Docker könnyű alternatívát kínál a virtuális gépekkel szemben. Ugyanakkor biztosítja az alkalmazások hordozhatóságát, teljesítményét, agilitását és skálázhatóságát. Egy átfogó útmutatóért a Docker-ökoszisztémáról, tekintse meg a Dockerrel történő konténerizációról szóló részletes áttekintésünket.
Flask egy nyílt forráskódú, minimális webes keretrendszer, amely a Python nyelvre épül. A Flask nagyszerű tulajdonságai közé tartozik, hogy könnyű, rugalmas és rendkívül strukturált. Emellett a futtatásához nincs szükség semmilyen speciális eszközre vagy beépülő modulra.
A Flask és a Docker kombinálása egy könnyű, rugalmas és skálázható alkalmazást eredményez. Az alkalmazást számos szerveren és infrastruktúrán telepítheti, a dockerizált konténerek hordozható jellegének köszönhetően. Ez az útmutató arra összpontosít, hogy bemutassa, hogyan telepíthet egy Flask alkalmazást a Docker segítségével. Azt is bemutatjuk, hogyan biztosíthatja, hogy az alkalmazás jövőbeli frissítései érvénybe lépjenek.
Előfeltételek
Ez egy gyakorlati útmutató lesz, és létre kell hoznia egy olyan környezetet, amely lehetővé teszi a lépések követését:
- Rendelkeznie kell egy Ubuntu 20.04 telepítéssel mint kezdeti operációs környezettel. Létre kell hoznia egy nem-root felhasználót sudo jogosultságokkal.
- Emellett telepítenie kell a Dockert. Van egy útmutatónk arról, hogyan kell telepíteni és működtetni a Dockert Ubuntun. Kövesse az 1., 2., 3. és 4. lépést. Ennek bármely Ubuntu disztribúció esetén működnie kell.
- Végül szüksége van a Nginx telepítésére. Kövesse az Nginx telepítése Ubuntura.
útmutatónkat. Most pedig kezdjük el!
1. lépés: A Flask alkalmazás előkészítése
Először létrehozunk egy könyvtárat, amely a Flask alkalmazásunkat fogja tárolni. Választhat tetszőleges könyvtárnevet is. Ebben az útmutatóban azonban a következő nevet adjuk neki: flask_demo. A projektfájlokat a /var/www könyvtárba mentjük, amely általában az a könyvtár, amelyhez az Ubuntu alapértelmezés szerint hozzáférést enged a nyilvános internetről. Először futtassa a következő parancsokat a könyvtár létrehozásához és a belépéshez:
|
1 2 3 |
sudo mkdir /var/www/flask_demo cd /var/www/flask_demo |
A projektünk ezen gyökérkönyvtárában létrehozzuk egy Flask alkalmazás alapvető mappaszerkezetét. Ezután futtassa a következő parancsot az alapszerkezet létrehozásához, hozzáadva a -p jelzőt, hogy az összes szülőmappa is létrejöjjön az út során:
|
1 |
sudo mkdir -p app/static app/templates |
Az app mappa tartalmazza a Flask alkalmazással kapcsolatos összes fájlt, beleértve a views és blueprints fájlokat. A nézetek (views) tartalmazzák azt a kódot, amelyet az alkalmazást érő kérések megválaszolására ír. A tervrajzok (blueprints) segítenek az alkalmazáskomponensek létrehozásában, és támogatják a Flask alkalmazásokban megszokott mintákat.
A találóan elnevezett static mappa statikus elemeket, például képeket, CSS- és JavaScript-fájlokat tartalmaz. A templates könyvtár tartalmazza a projekt összes HTML-sablonját.
Most elkezdhetjük a Flask alkalmazás inicializálásához szükséges fájlok megírását. Kezdje egy __init__.py nevű fájl létrehozásával az app könyvtárban, hogy jelezze a Python értelmezőnek, hogy az app könyvtárat csomagként kell kezelni. Futtassa a következő parancsot a terminálon a fájl megnyitásához a nano szerkesztővel:
|
1 |
sudo nano app/__init__.py |
A Pythonban csomagokat használunk a modulok logikai névterekbe vagy hierarchiákba történő csoportosítására. A modularizáció lehetővé teszi a kód felosztását egyedi és kezelhető blokkokra, amelyek meghatározott funkciókat látnak el.
Ezután a szerkesztőben megnyitott __init__.py fájlban adja hozzá a következő kódrészletet a Flask példány elindításához, és importálja a logikát a views.py fájlból, amelyet a következő lépésekben fog létrehozni:
|
1 2 3 4 5 |
from flask import Flask app = Flask(__name__) from app import views |
Ha végzett, nyomja meg a Ctrl + O és ENTER a fájl mentéséhez, majd zárja be a Ctrl + X billentyűkkel. Ezután hozzuk létre a views.py fájlt az app könyvtárban. A views.py fájl fogja tartalmazni az alkalmazás logikájának nagy részét:
|
1 |
sudo nano app/views.py |
A fájlba adja hozzá a következő kódrészletet. Ez a kód egy egyszerű karakterláncot jelenít meg, amely jelzi, hogy az alkalmazás fut, amikor a felhasználók meglátogatják a webhelyet:
|
1 2 3 4 5 |
from app import app @app.route('/') def home(): return "Our Flask application is running!" |
Ebben a fájlban először importáljuk a Flask alkalmazáspéldányt. Ezután hozzá kell adnunk egy sort az útvonal meghatározásához: @app.route(/). Az @app.route(/) sorra Flaskban úgy hivatkozunk, mint egy dekorátorra . A dekorátorok segítségével további funkciókat ágyazhat be egy vagy több függvénybe. Ebben az esetben átadunk egy hívást az útvonalnak / a home függvényre. Amikor egy felhasználó meglátogatja ezt az útvonalat, a következő szöveget fogja látni: "Our Flask application is running!".
Ezután létrehozza az uwsgi.ini fájlt, amely az alkalmazás uWSGI konfigurációit tartalmazza. Az uWSGI egy telepítési lehetőség az Nginx-hez, amely protokollként és alkalmazásszerverként szolgál. Futtassa a következő parancsot a fájl létrehozásához a projekt gyökérkönyvtárában a nano szerkesztővel:
|
1 |
sudo nano uwsgi.ini |
A megnyitott fájlba adja hozzá a következő kódrészletet:
|
1 2 3 4 |
[uwsgi] module = main callable = app master = true |
Ez a fájl néhány direktívát tartalmaz. Ezek célját az alábbiakban határozzuk meg:
- module – meghatározza azt a modult, amelyből a Flask alkalmazás kiszolgálásra kerül. A modult main-re állítottuk be, hivatkozva a gyökérkönyvtárban található main.py fájlra. Ezt a fájlt a következő lépésben fogjuk létrehozni.
- callable – utasítja az uWSGI-t, hogy az alkalmazásból exportált app példányt használja.
- master – biztosítja az alkalmazás folyamatos futását, hogy minimalizálja az állásidőt a teljes alkalmazás újratöltése során.
Ha végzett, mentse és zárja be a fájlt.
Most létrehozhatja a main.py fájlt az alkalmazás belépési pontjának meghatározásához. Az uWSGI olvasni fogja ezt a fájlt, hogy tudja, hogyan kell interakcióba lépni az alkalmazással. Futtassa a következő parancsot a main.py fájl létrehozásához a nano segítségével a projekt gyökérkönyvtárában :
|
1 |
sudo nano main.py |
A fájlba adja hozzá a következő sort, amely importálja az alkalmazáscsomagban létrehozott Flask példányt:
|
1 |
from app import app |
Az utolsó dolog, amit ebben a lépésben megtesz, az az alkalmazás futtatásához szükséges függőségek meghatározása. Ezeket a függőségeket egy dependencies.txt nevű fájlban fogjuk meghatározni. Amikor a Docker felépíti az alkalmazás rendszerképét, végrehajt egy pip (csomag kezelő) parancsot a függőségek telepítéséhez. Nyissa meg a fájlt a gyökérkönyvtárban a következő paranccsal:
|
1 |
sudo nano dependencies.txt |
A projektünkben eddig a pontig csak egy függőséget szeretnénk: Flask. Ezért hozzáadhatjuk a következő sort, hogy hivatkozzunk a projekthez szükséges megfelelő Flask verzióra:
|
1 |
Flask==2.0.1 |
A Flask verzió 2.0.1 mellett döntünk függőségként. Ez a legújabb verzió a jelen útmutató írásakor. A különböző verziókról további információt a Flask Changes oldalon találhat. Ezzel befejeződött a Flask alkalmazás beállítása. Most készítsük elő a Docker konfigurációkat a telepítéshez.
Step 2: Configure Docker
A Docker telepítés beállításához két fájlt fogunk létrehozni: Dockerfile és start.sh fájlokat. A Dockerfile deklaratív sorokat tartalmaz, amelyek egy Docker rendszerképet alkotnak. A start.sh egy egyszerű shell szkript a rendszerkép felépítéséhez és a konténer elindításához a Dockerfile fájlból. Miközben a projekt gyökérkönyvtárában tartózkodik, futtassa a következő parancsot a Dockerfile:
|
1 |
sudo nano Dockerfile |
Ez a fájl tartalmazza a Docker rendszerképhez szükséges konfigurációkat. Ezután adja hozzá a következő kódrészletet a függőségek és a rendszerkép felépítésének meghatározásához:
|
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 |
Az első sor egy Dockerfile fájlban meghatározza azt az alapképet, amelyből a saját képünket építjük. Ebben az esetben a következő kép alapján fogunk építkezni: tiangolo/uwsgi-nginx-flask, amely elérhető a DockerHub oldalon. Azért választottuk ezt a konkrét képet, mert számos Python-verziót támogat.
Azt is megadjuk, hogy frissíteni szeretnénk a képet. Ezután hozzá kell adnunk a bash parancsértelmezőt , a nano szövegszerkesztőt, valamint a git klienst a forráskód lekéréséhez és feltöltéséhez olyan verziókezelő tárhelyekről, mint a GitHub, Bitbucket, vagy Gitlab. Az ENV kezdetű sorok a konténerben használandó környezeti változókat határozzák meg.
A COPY parancs átmásolja a függőségeket a konténerbe. A RUN parancs meghívja a pip csomag kezelőt a dependencies.txt fájl feldolgozásához és a függőségek telepítéséhez. Mentse el és zárja be a fájlt, ha végzett a szerkesztéssel.
Ezután létrehozza a start.sh szkriptet. Ez a szkript tartalmazni fogja a Docker parancsokat a kép felépítéséhez és futtatásához a képet. Bár ezeket a parancsokat egymás után is végrehajthatja a terminálon, úgy gondoltuk, tisztább, ha hozzáadja őket egy shell szkripthez, és egyszerűen meghívja a terminálról egyetlen paranccsal.
Mielőtt meghatároznánk a fájl tartalmát, először keresnünk kell egy szabad portot, amelyet más szolgáltatások nem használnak. Mi a 45644 portot fogjuk használni. Választhat azonban másik portot is. Futtassa a következő sort annak ellenőrzésére, hogy a port szabad-e:
|
1 |
sudo nc localhost 45644 < /dev/null; echo $? |
A választott porttól függően, ha a fenti parancs kimenete 1, akkor szabad. Ellenkező esetben előfordulhat, hogy másik portot kell választania, és újra meg kell próbálnia a parancsot:
Mivel találtunk egy szabad portot, most létrehozhatjuk a fájlt a nano segítségével a projekt gyökérkönyvtárában a következő parancs futtatásával:
|
1 |
sudo nano start.sh |
Ebbe a fájlba adja hozzá a következő kódrészletet:
|
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} |
Az első sor, amelyet shebang-nek neveznek, meghatározza, hogy ez egy bash fájl, és parancsként kell végrehajtani. A második sor deklarál egy app_name nevű változót. Ezt a változót használjuk a kép és a konténer nevének beállítására. A harmadik sor arra utasítja a Dockert, hogy építse fel a képet az aktuális könyvtárban található Dockerfile definíció alapján. A kép neve a változónak megfelelően docker-flask-demo lesz.
Az utolsó sor létrehoz egy docker-flask-demo nevű konténert a meghatározott változónak megfelelően. A -d jelző a háttérben, leválasztott (detached) állapotban tartja a konténert a parancs végrehajtása után. A -p jelző a szerver egy portját a konténer egy adott portjához köti. Ebben az esetben a gazdagép 45644 portját csatlakoztatjuk ahhoz a 80 porthoz, amelyet a Docker elérhetővé tesz a konténerben.
A -v jelzőt használjuk egy Docker kötet megadására, amelyet a konténerhez csatolunk. A $PWD változó egy alapértelmezett Linux változó, amely az aktuális könyvtár elérési útját tartalmazza, amelyben éppen tartózkodik:
A mi esetünkben a teljes projektkönyvtárat a konténer /var/www könyvtárához csatoljuk. A Docker konfiguráció most már kész. A következő parancs végrehajtásával felépítheti a képet, és elindíthatja a konténert a felépített kép alapján:
|
1 |
sudo bash start.sh |
Várja meg, amíg a szkript futása befejeződik, majd futtassa a következő Docker parancsot a futó konténerek listázásához:
|
1 |
sudo docker ps |
A kimenet megjeleníti a futó konténereket:
Látnia kell a konténerünket a következő névvel: docker-flask-demo a futó konténerek listájában. Keresse meg a szervere nyilvános IP címét, és nyissa meg a böngészőjében a megadott porton: http://your-server-public-ip:45644.
Hasonló kimenetet kell látnia:
Ha a fentieket látja a böngészőjében, akkor sikeresen telepített egy Flask alkalmazást. Ezután módosítani fogjuk a fájlokat, és sablonokon keresztül fogunk tartalmat kiszolgálni a felhasználóknak.
3. lépés: Tartalom kiszolgálása sablonfájlokon keresztül
A Flaskban a sablonok használatosak a statikus és dinamikus tartalmak megjelenítésére a webhely látogatói számára. Megmutatjuk, hogyan hozhat létre egy HTML sablont, és hogyan szolgálhatja ki azt a felhasználóknak, amikor egy bizonyos útvonalat látogatnak meg. Ez lehet például egy Főoldal vagy egy Rólunk oldal.
Futtassa a következő parancsot a terminálon egy index.html fájl létrehozásához az app/templates könyvtárban:
|
1 |
sudo nano app/templates/index.html |
Ezután adja hozzá a következő kódrészletet a fájlhoz:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Flask bemutató</title> </head> <body> <h2>Ön a Főoldalon van</h2> <p>Üdvözöljük a the Flask és Docker bemutató oldalán</p> </body> </html> |
Mentse el és zárja be a fájlt, ha végzett. Hozzon létre egy másik oldalt is, nevezzük Rólunk oldalnak, a következő paranccsal:
|
1 |
sudo nano app/templates/about.html |
Adja hozzá a következő kódrészletet a fájlhoz:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>A Flask bemutatóról</title> </head> <body> <h2>Rólunk oldal</h2> <p>Ez egy bemutató projekt volt.. Megmutatja, hogyan építhető fel egy Flask alkalmazás Docker és Nginx segítségével ..</p> <p>Ön annyi oldalt és fájlt adhat hozzá, amennyit csak szeretnelike</p> </body> </html> |
Mentse el és zárja be a fájlt, ha végzett. Ezután módosítsa az app/views.py fájlt, hogy hivatkozzon a sablonokra, valamint a tényleges oldalak útvonalaira:
|
1 |
sudo nano app/views.py |
Módosítsa a fájlt úgy, hogy az így nézzen ki:
|
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 "A Flask alkalmazásunk fut!" @app.route('/index') def index(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') |
Mentse el és zárja be a fájlt, ha végzett. Az elvégzett módosítások nem lépnek életbe, amíg le nem állítja és újra nem indítja a konténert. Futtassa a következő Docker parancsokat a konténer leállításához és elindításához. Jegyezze meg a konténer nevét, amelyet korábban meghatároztunk:
|
1 |
sudo docker stop docker-flask-demo && sudo docker start docker-flask-demo |
Miután a konténer elindult és fut, látogasson el a Főoldalra és a Névjegy oldalra, hogy megtekinthesse az új tartalmak egy részét:
|
1 |
Főoldal oldal: http://your-server-public-ip:45644/index |
|
1 |
Névjegy oldal: http://your-server-public-ip:45644/about |
Eddig létrehozott egy Flask alkalmazást, amely képes tartalmat kiszolgálni a webhely látogatói számára. Íme a projekt fájlszerkezete:
Valószínűleg észrevette, hogy újra kellett indítanunk a Docker konténert, hogy az átvegye az új változtatásokat. A következő lépésben ezt automatizáljuk a rövidebb állásidő biztosítása érdekében.
4. lépés: Az alkalmazásfájlok frissítéseinek konfigurálása az automatikus újratöltéshez
Gyakran változtatunk egy alkalmazáson a logika, a felhasználói felületek javítása vagy függőségek hozzáadása érdekében. Ahhoz, hogy az ilyen változtatások életbe lépjenek, szükség lehet a Docker konténer újraindítására. Szerencsére uWSGI rendelkezik egy úgynevezett touch-reload funkcióval a Python szkript újratöltéséhez a konténer újraindítása nélkül.
Alapértelmezés szerint a Python rendelkezik egy auto-reloading (automatikus újratöltési) funkcióval, amely figyeli a teljes fájlrendszert a változások után, és frissíti az alkalmazást, ha változás történik. Bár az automatikus újratöltés jó az állásidő minimalizálására, erőforrás-igényes lehet. Ezért éles (production) környezetben nem ajánlott.
Lássuk, hogyan használhatja a touch-reload funkciót egy adott fájl változásainak figyelésére és az alkalmazás újratöltésére, ha változások történnek. Módosítsa a uwsgi.ini fájlt a nano szerkesztővel:
|
1 |
sudo nano uwsgi.ini |
Adja hozzá a kiemelt sort, hogy így nézzen ki:
|
1 2 3 4 5 |
[uwsgi] module = main callable = app master = true touch-reload = /app/uwsgi.ini |
Mentse el és zárja be a fájlt, ha végzett. A hozzáadott sor meghatározott egy fájlt, amelynek módosítása kiváltja az alkalmazás újratöltését. Ahhoz azonban, hogy ez a feltétel aktívvá váljon a jövőbeli módosításokhoz, először újra kell indítania a konténert:
|
1 |
sudo docker stop docker-flask-demo && sudo docker start docker-flask-demo |
Most már módosíthatja az app/views.py fájlt, hogy bemutassa az automatikus újratöltés működését:
|
1 |
sudo nano app/views.py |
Módosítsa a home függvény által visszaadott karakterláncot a kiemeltek szerint:
|
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>Some changes to Our Flask application to auto reload!</h3>" @app.route('/index') def index(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') |
Ha végzett, mentse el és zárja be a fájlt.
Nyissa meg az alkalmazás főoldalát a böngészőben: http://your-server-public-ip:45644.
Még nem fog látni semmilyen változást. Ez azért van, mert a touch-reload feltétel az uwsgi.ini fájl változását észleli. Használhatja a touch parancsot a feltétel aktiválásához, ezáltal a teljes alkalmazás újratöltéséhez a következő paranccsal:
|
1 |
sudo touch uwsgi.ini |
Most, ha újratölti a főoldalt, láthatja a megjelenő új változtatásokat:
A jövőben, ha bármilyen további változtatást eszközöl, csak a következő parancsot kell futtatnia: sudo touch uwsgi.ini és a teljes alkalmazás kevesebb állásidővel fog újraindulni. Ezzel elértünk a bemutató végéhez.
Összegzés
Ebben a bemutatóban implementált és telepített egy Flask alkalmazást Docker-képekkel és -konténerekkel. Az állásidő minimalizálása érdekében, elkerülve a konténer újraindításának szükségességét, beállította a touch-reload opciót, hogy figyelje egy adott fájl változásait, és automatikusan újraindítsa a teljes alkalmazást. Végül mindezt tesztelte a böngészőben, hogy megbizonyosodjon a működéséről.
A Docker gyorsabb telepítést biztosít, és lehetővé teszi az alkalmazások egyszerű skálázását. Ha szeretne többet megtudni a különböző Docker-parancsokról, kérjük, tekintse meg ezt a bemutatót a következő témában: hogyan kell telepíteni és használni a Dockert Ubuntun.
További Dockerrel kapcsolatos forrásokért a blogunkon, az alábbiakat tekintheti meg:
- Konténerizációs technológia: Különböző konténerek típusai és használata a CloudSigma PaaS platformján
- Hogyan osszunk meg adatokat egy Docker-konténer és a gazdagép között
- A Docker telepítése és beállítása CentOS 7 rendszeren
- Laravel, Nginx és MySQL telepítése Docker Compose segítségével
- Docker-erőforrások tisztítása – képek, konténerek és kötetek
Kellemes kódolást!
Hozzászólások
Még nincsenek hozzászólások. Legyen Ön az első.