जीरो टू हीरो: फ्लास्क प्रोडक्शन रेसिपी

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

ऑपरेटिंग सिस्टम का चयन करें प्रक्षेपण का एक कार्यक्रम चुनें (वैकल्पिक रूप से)

अपनी समस्या का वर्णन करें

फ्लास्क पायथन अनुप्रयोगों के साथ जल्दी से उठने और चलने का एक शानदार तरीका है, लेकिन क्या होगा यदि आप कुछ और अधिक मजबूत बनाना चाहते हैं? इस लेख में, Toptal Freelance Python Developer Ivan Poleschyuk एक पूर्ण उत्पादन-तैयार फ्लास्क एप्लिकेशन बनाने के लिए कुछ टिप्स और उपयोगी व्यंजनों को साझा करता है।

हम निम्नलिखित विषयों को कवर करेंगे:

विन्यास प्रबंधन। किसी भी वास्तविक जीवन के एप्लिकेशन में विशिष्ट चरणों के साथ एक जीवनचक्र होता है - बहुत कम से कम, यह विकास, परीक्षण और परिनियोजन होगा। प्रत्येक चरण पर, एप्लिकेशन कोड को थोड़े अलग वातावरण में काम करना चाहिए, जिसके लिए अलग-अलग सेटिंग्स की आवश्यकता होती है, जैसे डेटाबेस कनेक्शन स्ट्रिंग्स, बाहरी एपीआई कुंजी और यूआरएल।
Gunicorn के साथ सेल्फ-होस्टिंग फ्लास्क एप्लिकेशन। हालाँकि फ्लास्क में एक अंतर्निहित वेब सर्वर है, जैसा कि हम सभी जानते हैं, यह उत्पादन के लिए उपयुक्त नहीं है और इसे WSGI प्रोटोकॉल के माध्यम से फ्लास्क के साथ संचार करने में सक्षम एक वास्तविक वेब सर्वर के पीछे रखने की आवश्यकता है। उसके लिए एक आम पसंद है गनिकोर्न —एक पायथन WSGI HTTP सर्वर।
के साथ स्थिर फ़ाइलें और प्रॉक्सी अनुरोध प्रस्तुत करना nginx . एक HTTP वेब सर्वर होने के बावजूद, Gunicorn, बदले में, एक एप्लिकेशन सर्वर है जो वेब का सामना करने के लिए उपयुक्त नहीं है। इसलिए हमें Nginx को एक रिवर्स प्रॉक्सी के रूप में और स्थिर फ़ाइलों की सेवा के लिए चाहिए। यदि हमें अपने एप्लिकेशन को कई सर्वरों तक बढ़ाने की आवश्यकता है, तो Nginx लोड संतुलन का भी ध्यान रखेगा।
एक समर्पित लिनक्स सर्वर पर डॉकर कंटेनरों के अंदर एक ऐप को तैनात करना। कंटेनरीकृत परिनियोजन काफी लंबे समय से सॉफ्टवेयर डिजाइन का एक अनिवार्य हिस्सा रहा है। हमारा आवेदन अलग नहीं है और इसे अपने कंटेनर (वास्तव में कई कंटेनर) में बड़े करीने से पैक किया जाएगा।
एप्लिकेशन के लिए PostgreSQL डेटाबेस को कॉन्फ़िगर और परिनियोजित करना। डेटाबेस संरचना और माइग्रेशन को प्रबंधित किया जाएगा भबका साथ एसक्यूएलकीमिया ऑब्जेक्ट-रिलेशनल मैपिंग प्रदान करना।
एक की स्थापना अजमोदा लंबे समय से चल रहे कार्यों को संभालने के लिए कार्य कतार। बाहरी कर्मचारियों पर वेब सर्वर थ्रेड्स से प्रत्येक एप्लिकेशन को अंततः समय या गणना गहन प्रक्रियाओं को लोड करने की आवश्यकता होगी - चाहे वह मेल भेजना, स्वचालित डेटाबेस हाउसकीपिंग या अपलोड की गई छवियों का प्रसंस्करण हो।

फ्लास्क ऐप बनाना

आइए एक एप्लिकेशन कोड और संपत्ति बनाकर शुरू करें। कृपया ध्यान दें कि मैं इस पोस्ट में उचित फ्लास्क एप्लिकेशन संरचना को संबोधित नहीं करूंगा। संक्षिप्तता और स्पष्टता के लिए डेमो ऐप में न्यूनतम संख्या में मॉड्यूल और पैकेज होते हैं।

सबसे पहले, एक निर्देशिका संरचना बनाएं और एक खाली Git रिपॉजिटरी को इनिशियलाइज़ करें।

माइक्रोसॉफ्ट आउटलुक उत्पाद सक्रियण विफल

mkdir flask-deploy cd flask-deploy # init GIT repo git init # create folder structure mkdir static tasks models config # install required packages with pipenv, this will create a Pipfile pipenv install flask flask-restful flask-sqlalchemy flask-migrate celery # create test static asset echo 'Hello World!' > static/hello-world.txt

इसके बाद, हम कोड जोड़ेंगे।

विन्यास/ इस में .py

कॉन्फ़िगरेशन मॉड्यूल में, हम अपने छोटे कॉन्फ़िगरेशन प्रबंधन ढांचे को परिभाषित करेंगे। विचार यह है कि ऐप को |_+_| . द्वारा चुने गए कॉन्फ़िगरेशन प्रीसेट के अनुसार व्यवहार करना है पर्यावरण चर, साथ ही, यदि आवश्यक हो तो एक विशिष्ट पर्यावरण चर के साथ किसी भी कॉन्फ़िगरेशन सेटिंग को ओवरराइड करने के लिए एक विकल्प जोड़ें।

APP_ENV

config/settings.py

यह विन्यास वर्गों का एक समूह है, जिसमें से एक का चयन |_+_| . द्वारा किया जाता है चर। जब एप्लिकेशन चलता है, तो कोड |_+_| यदि वे मौजूद हैं, तो विशिष्ट पर्यावरण चर के साथ फ़ील्ड मानों को ओवरराइड करने वाले इन वर्गों में से एक को तुरंत चालू कर देगा। फ्लास्क और सेलेरी कॉन्फ़िगरेशन को बाद में प्रारंभ करते समय हम अंतिम कॉन्फ़िगरेशन ऑब्जेक्ट का उपयोग करेंगे।

import os import sys import config.settings # create settings object corresponding to specified env APP_ENV = os.environ.get('APP_ENV', 'Dev') _current = getattr(sys.modules['config.settings'], '{0}Config'.format(APP_ENV))() # copy attributes to the module for convenience for atr in [f for f in dir(_current) if not '__' in f]: # environment can override anything val = os.environ.get(atr, getattr(_current, atr)) setattr(sys.modules[__name__], atr, val) def as_dict(): res = {} for atr in [f for f in dir(config) if not '__' in f]: val = getattr(config, atr) res[atr] = val return res

कार्य/ इस में .py

टास्क पैकेज में सेलेरी इनिशियलाइज़ेशन कोड होता है। कॉन्फिग पैकेज, जिसमें इनिशियलाइज़ेशन पर मॉड्यूल स्तर पर पहले से ही कॉपी की गई सभी सेटिंग्स होंगी, का उपयोग सेलेरी कॉन्फ़िगरेशन ऑब्जेक्ट को अपडेट करने के लिए किया जाता है, अगर हमारे पास भविष्य में कुछ सेलेरी-विशिष्ट सेटिंग्स होंगी - उदाहरण के लिए, शेड्यूल किए गए कार्य और वर्कर टाइमआउट।

APP_ENV

कार्य/celery_worker.py

सेलेरी वर्कर को शुरू करने और इनिशियलाइज़ करने के लिए इस मॉड्यूल की आवश्यकता होती है, जो एक अलग डॉकटर कंटेनर में चलेगा। यह एप्लिकेशन के समान वातावरण तक पहुंच के लिए फ्लास्क एप्लिकेशन संदर्भ को इनिशियलाइज़ करता है। यदि इसकी आवश्यकता नहीं है, तो इन पंक्तियों को सुरक्षित रूप से हटाया जा सकता है।

init .py

आग/ इस में .py

अगला एपीआई पैकेज जाता है, जो फ्लास्क-रेस्टफुल पैकेज का उपयोग करके आरईएसटी एपीआई को परिभाषित करता है। हमारा ऐप सिर्फ एक डेमो है और इसमें केवल दो एंडपॉइंट होंगे:

|_+_| - सेलेरी वर्कर पर डमी लॉन्ग ऑपरेशन शुरू करता है और नए टास्क की आईडी लौटाता है।
|_+_| - कार्य आईडी द्वारा कार्य की स्थिति लौटाता है।

class BaseConfig(): API_PREFIX = '/api' TESTING = False DEBUG = False class DevConfig(BaseConfig): FLASK_ENV = 'development' DEBUG = True SQLALCHEMY_DATABASE_URI = 'postgresql://db_user:db_password@db-postgres:5432/flask-deploy' CELERY_BROKER = 'pyamqp://rabbit_user:rabbit_password@broker-rabbitmq//' CELERY_RESULT_BACKEND = 'rpc://rabbit_user:rabbit_password@broker-rabbitmq//' class ProductionConfig(BaseConfig): FLASK_ENV = 'production' SQLALCHEMY_DATABASE_URI = 'postgresql://db_user:db_password@db-postgres:5432/flask-deploy' CELERY_BROKER = 'pyamqp://rabbit_user:rabbit_password@broker-rabbitmq//' CELERY_RESULT_BACKEND = 'rpc://rabbit_user:rabbit_password@broker-rabbitmq//' class TestConfig(BaseConfig): FLASK_ENV = 'development' TESTING = True DEBUG = True # make celery execute tasks synchronously in the same process CELERY_ALWAYS_EAGER = True

मॉडल/ इस में .py

अब हम |_+_| . के लिए एक SQLAlchemy मॉडल जोड़ेंगे ऑब्जेक्ट, और एक डेटाबेस इंजन इनिशियलाइज़ेशन कोड। |_+_| ऑब्जेक्ट का उपयोग हमारे डेमो ऐप द्वारा किसी भी सार्थक तरीके से नहीं किया जाएगा, लेकिन हमें यह सुनिश्चित करने के लिए डेटाबेस माइग्रेशन काम करना होगा और SQLAlchemy-Flask एकीकरण सही तरीके से सेट किया गया है।

from celery import Celery import config def make_celery(): celery = Celery(__name__, broker=config.CELERY_BROKER) celery.conf.update(config.as_dict()) return celery celery = make_celery()

ध्यान दें कि डिफ़ॉल्ट अभिव्यक्ति द्वारा यूयूआईडी स्वचालित रूप से ऑब्जेक्ट आईडी के रूप में कैसे उत्पन्न होता है।

app.py

अंत में, एक मुख्य फ्लास्क एप्लिकेशन फ़ाइल बनाते हैं।

सिमेंटिक यूआई प्रतिक्रिया जीथब

from app import create_app app = create_app() app.app_context().push() from tasks import celery

यहाँ हम हैं:

बुनियादी लॉगिंग को समय, स्तर और प्रक्रिया आईडी के साथ उचित प्रारूप में कॉन्फ़िगर करना
एपीआई इनिशियलाइज़ेशन और हैलो, वर्ल्ड के साथ फ्लास्क ऐप क्रिएशन फंक्शन को परिभाषित करना! पृष्ठ
विकास समय के दौरान ऐप को चलाने के लिए एक प्रवेश बिंदु को परिभाषित करना

wsgi.py

इसके अलावा, हमें Gunicorn के साथ फ्लास्क एप्लिकेशन को चलाने के लिए एक अलग मॉड्यूल की आवश्यकता होगी। इसमें केवल दो पंक्तियाँ होंगी:

/process_data

आवेदन कोड तैयार है। हमारा अगला कदम डॉकर कॉन्फ़िगरेशन बनाना है।

डोकर कंटेनरों का निर्माण

हमारे एप्लिकेशन को चलाने के लिए कई डॉकर कंटेनरों की आवश्यकता होगी:

एप्लिकेशन कंटेनर टेम्प्लेट किए गए पृष्ठों की सेवा और एपीआई एंडपॉइंट्स को उजागर करने के लिए। उत्पादन पर इन दो कार्यों को विभाजित करना एक अच्छा विचार है, लेकिन हमारे डेमो ऐप में हमारे पास कोई टेम्पलेट पेज नहीं है। कंटेनर Gunicorn वेब सर्वर चलाएगा जो WSGI प्रोटोकॉल के माध्यम से फ्लास्क के साथ संचार करेगा।
अजवाइन कार्यकर्ता कंटेनर लंबे कार्यों को अंजाम देने के लिए। यह वही एप्लिकेशन कंटेनर है, लेकिन गनिकोर्न के बजाय सेलेरी लॉन्च करने के लिए कस्टम रन कमांड के साथ।
अजवाइन बीट कंटेनर—उपरोक्त के समान, लेकिन नियमित समय पर बुलाए गए कार्यों के लिए, जैसे उन उपयोगकर्ताओं के खातों को हटाना जिन्होंने कभी अपने ईमेल की पुष्टि नहीं की।
खरगोशएमक्यू कंटेनर। अजवाइन को श्रमिकों और ऐप के बीच संवाद करने और कार्य परिणामों को संग्रहीत करने के लिए एक संदेश दलाल की आवश्यकता होती है। RabbitMQ एक आम पसंद है, लेकिन आप Redis या Kafka का भी उपयोग कर सकते हैं।
PostgreSQL के साथ डेटाबेस कंटेनर।

कई कंटेनरों को आसानी से प्रबंधित करने का एक प्राकृतिक तरीका डॉकर कंपोज़ का उपयोग करना है। लेकिन सबसे पहले, हमें अपने एप्लिकेशन के लिए एक कंटेनर इमेज बनाने के लिए एक Dockerfile बनाने की आवश्यकता होगी। इसे प्रोजेक्ट डायरेक्टरी में डालते हैं।

/tasks/

यह फ़ाइल डॉकर को निर्देश देती है:

Pipenv का उपयोग करके सभी निर्भरताएँ स्थापित करें
कंटेनर में एप्लिकेशन फ़ोल्डर जोड़ें
मेजबान को टीसीपी पोर्ट 5000 का पर्दाफाश करें
कंटेनर के डिफ़ॉल्ट स्टार्टअप कमांड को Gunicorn कॉल पर सेट करें

आइए अधिक चर्चा करें कि अंतिम पंक्ति में क्या होता है। यह कार्यकर्ता वर्ग को निर्दिष्ट करते हुए Gunicorn चलाता है बाहर निकलने देना . सहकारी मल्टीटास्किंग के लिए गीवेंट एक हल्का समवर्ती कार्य है। यह थ्रेड के लिए OS प्रीमेप्टिव मल्टीटास्किंग की तुलना में बेहतर CPU उपयोग प्रदान करते हुए I/O बाउंड लोड पर काफी प्रदर्शन लाभ देता है। |_+_| पैरामीटर कार्यकर्ता प्रक्रियाओं की संख्या है। इसे सर्वर पर कई कोर के बराबर सेट करना एक अच्छा विचार है।

एक बार जब हमारे पास एप्लिकेशन कंटेनर के लिए डॉकरफाइल होता है, तो हम एक |_+_| . बना सकते हैं फ़ाइल, जो उन सभी कंटेनरों को परिभाषित करेगी जिन्हें एप्लिकेशन को चलाने की आवश्यकता होगी।

import time from flask import jsonify from flask_restful import Api, Resource from tasks import celery import config api = Api(prefix=config.API_PREFIX) class TaskStatusAPI(Resource): def get(self, task_id): task = celery.AsyncResult(task_id) return jsonify(task.result) class DataProcessingAPI(Resource): def post(self): task = process_data.delay() return {'task_id': task.id}, 200 @celery.task() def process_data(): time.sleep(60) # data processing endpoint api.add_resource(DataProcessingAPI, '/process_data') # task status endpoint api.add_resource(TaskStatusAPI, '/tasks/')

हमने निम्नलिखित सेवाओं को परिभाषित किया है:

|_+_| - एक RabbitMQ संदेश ब्रोकर कंटेनर। कनेक्शन क्रेडेंशियल पर्यावरण चर द्वारा परिभाषित किए गए हैं
|_+_| - एक पोस्टग्रेएसक्यूएल कंटेनर और इसकी साख
|_+_| - एक ऐप कंटेनर जो फ्लास्क-माइग्रेट और एग्जिट के साथ डेटाबेस माइग्रेशन करेगा। एपीआई कंटेनर इस पर निर्भर हैं और बाद में चलेंगे।
|_+_| - मुख्य अनुप्रयोग कंटेनर
|_+_| और |_+_| - एपीआई और अनुसूचित कार्यों से प्राप्त कार्यों के लिए अजवाइन श्रमिकों को चलाने वाले कंटेनर

प्रत्येक ऐप कंटेनर को |_+_| . भी प्राप्त होगा |_+_| . से चर आदेश।

एक बार जब हमारे पास सभी एप्लिकेशन एसेट तैयार हो जाएं, तो उन्हें गिटहब पर डाल दें, जो हमें सर्वर पर कोड को तैनात करने में मदद करेगा।

User

सर्वर को कॉन्फ़िगर करना

हमारा कोड अब गिटहब पर है, और जो कुछ बचा है वह प्रारंभिक सर्वर कॉन्फ़िगरेशन करना और एप्लिकेशन को तैनात करना है। मेरे मामले में, सर्वर एक एडब्ल्यूएस उदाहरण है जो एएमआई लिनक्स चला रहा है। अन्य लिनक्स फ्लेवर के लिए, निर्देश थोड़े भिन्न हो सकते हैं। मैं यह भी मानता हूं कि सर्वर के पास पहले से ही एक बाहरी आईपी पता है, डीएनएस को इस आईपी की ओर इशारा करते हुए एक रिकॉर्ड के साथ कॉन्फ़िगर किया गया है, और एसएसएल प्रमाणपत्र डोमेन के लिए जारी किए गए हैं।

myrepeater-नेट लॉगिन

सुरक्षा युक्ति: HTTP(S) ट्रैफ़िक के लिए पोर्ट 80 और 443, अपने होस्टिंग कंसोल में SSH के लिए पोर्ट 22 (या |_+_| का उपयोग करके) और अन्य सभी पोर्ट के लिए बाहरी एक्सेस की अनुमति देना न भूलें! के लिए भी ऐसा ही करना सुनिश्चित करें आईपीवी6 मसविदा बनाना!

निर्भरता स्थापित करना

सबसे पहले, हमें सर्वर पर चलने वाले Nginx और Docker की आवश्यकता होगी, साथ ही कोड को खींचने के लिए Git की आवश्यकता होगी। आइए SSH के माध्यम से लॉगिन करें और उन्हें स्थापित करने के लिए पैकेज मैनेजर का उपयोग करें।

User

Nginx को कॉन्फ़िगर करना

अगला कदम Nginx को कॉन्फ़िगर करना है। मुख्य |_+_| कॉन्फ़िगरेशन फ़ाइल अक्सर अच्छी होती है। फिर भी, यह जांचना सुनिश्चित करें कि यह आपकी आवश्यकताओं के अनुरूप है या नहीं। हमारे ऐप के लिए, हम |_+_|फ़ोल्डर में एक नई कॉन्फ़िगरेशन फ़ाइल बनाएंगे। शीर्ष-स्तरीय कॉन्फ़िगरेशन में सभी को शामिल करने का निर्देश है |_+_| इससे फाइलें।

import uuid from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() class User(db.Model): id = db.Column(db.String(), primary_key=True, default=lambda: str(uuid.uuid4())) username = db.Column(db.String()) email = db.Column(db.String(), unique=True)

यहाँ Nginx के लिए फ्लास्क साइट कॉन्फ़िगरेशन फ़ाइल है, जिसमें बैटरी शामिल है। इसमें निम्नलिखित विशेषताएं हैं:

एसएसएल कॉन्फ़िगर किया गया है। आपके पास अपने डोमेन के लिए वैध प्रमाणपत्र होना चाहिए, उदाहरण के लिए, एक निःशुल्क आइए एन्क्रिप्ट करें प्रमाणपत्र।
|_+_| अनुरोधों को |_+_| . पर पुनर्निर्देशित किया जाता है
HTTP अनुरोधों को HTTPS पोर्ट को सुरक्षित करने के लिए पुनर्निर्देशित किया जाता है।
रिवर्स प्रॉक्सी को स्थानीय पोर्ट 5000 पर अनुरोध पास करने के लिए कॉन्फ़िगर किया गया है।
एक स्थानीय फ़ोल्डर से Nginx द्वारा स्टेटिक फ़ाइलों को परोसा जाता है।

from flask import Flask logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s]: {} %(levelname)s %(message)s'.format(os.getpid()), datefmt='%Y-%m-%d %H:%M:%S', handlers=[logging.StreamHandler()]) logger = logging.getLogger() def create_app(): logger.info(f'Starting app in {config.APP_ENV} environment') app = Flask(__name__) app.config.from_object('config') api.init_app(app) # initialize SQLAlchemy db.init_app(app) # define hello world page @app.route('/') def hello_world(): return 'Hello, World!' return app if __name__ == '__main__': app = create_app() app.run(host='0.0.0.0', debug=True)

फ़ाइल को संपादित करने के बाद, रन करें |_+_| और देखें कि क्या कोई त्रुटि है।

GitHub क्रेडेंशियल सेट करना

परियोजना और सीआई/सीडी प्रणाली को लागू करने के लिए एक अलग परिनियोजन वीसीएस खाता रखना एक अच्छा अभ्यास है। इस तरह आप अपने स्वयं के खाते की साख को उजागर करके जोखिम नहीं उठाते हैं। प्रोजेक्ट रिपॉजिटरी को और सुरक्षित रखने के लिए, आप ऐसे खाते की अनुमतियों को केवल-पढ़ने के लिए एक्सेस तक सीमित कर सकते हैं। GitHub रिपॉजिटरी के लिए, आपको ऐसा करने के लिए एक संगठन खाते की आवश्यकता होगी। हमारे डेमो एप्लिकेशन को तैनात करने के लिए, हम सर्वर पर एक सार्वजनिक कुंजी बनाएंगे और इसे हर बार क्रेडेंशियल दर्ज किए बिना हमारी परियोजना तक पहुंच प्राप्त करने के लिए गिटहब पर पंजीकृत करेंगे।

हम में सेल्सियस का सिक्का कैसे खरीदें

एक नई SSH कुंजी बनाने के लिए, चलाएँ:

from app import create_app app = create_app()

फिर GitHub पर लॉग इन करें और अपनी सार्वजनिक कुंजी जोड़ें से |_+_| खाता सेटिंग्स में।

एक ऐप तैनात करना

अंतिम चरण बहुत सरल हैं - हमें GitHub से एप्लिकेशन कोड प्राप्त करने और Docker Compose के साथ सभी कंटेनरों को शुरू करने की आवश्यकता है।

FROM python:3.7.2 RUN pip install pipenv ADD . /flask-deploy WORKDIR /flask-deploy RUN pipenv install --system --skip-lock RUN pip install gunicorn[gevent] EXPOSE 5000 CMD gunicorn --worker-class gevent --workers 8 --bind 0.0.0.0:5000 wsgi:app --max-requests 10000 --timeout 5 --keep-alive 5 --log-level info

|_+_| . को छोड़ना एक अच्छा विचार हो सकता है (जो कंटेनर को अलग मोड में शुरू करता है) पहले रन के लिए टर्मिनल में प्रत्येक कंटेनर के आउटपुट को देखने और संभावित मुद्दों की जांच करने के लिए। एक अन्य विकल्प के साथ प्रत्येक व्यक्तिगत कंटेनर का निरीक्षण करना है |_+_| बाद में। आइए देखें कि क्या हमारे सभी कंटेनर |_+_| . के साथ चल रहे हैं

महान। सभी पांच कंटेनर ऊपर और चल रहे हैं। docker-compose.yml में निर्दिष्ट सेवा के आधार पर डॉकर कंपोज़ असाइन किए गए कंटेनर नाम स्वचालित रूप से। अब अंत में यह परीक्षण करने का समय है कि संपूर्ण कॉन्फ़िगरेशन कैसे काम करता है! यह सुनिश्चित करने के लिए कि सर्वर में सही नेटवर्क सेटिंग्स हैं, बाहरी मशीन से परीक्षण चलाना सबसे अच्छा है।

--workers

इतना ही। हमारे पास एडब्ल्यूएस इंस्टेंस पर चलने वाले हमारे ऐप का एक न्यूनतर, लेकिन पूरी तरह से उत्पादन-तैयार कॉन्फ़िगरेशन है। आशा है कि यह आपको वास्तविक जीवन में जल्दी से एक एप्लिकेशन बनाना शुरू करने और कुछ सामान्य गलतियों से बचने में मदद करेगा! पूरा कोड उपलब्ध है एक गिटहब भंडार पर .

निष्कर्ष

इस लेख में, हमने उत्पादन के लिए फ्लास्क एप्लिकेशन की संरचना, विन्यास, पैकेजिंग और तैनाती की कुछ सर्वोत्तम प्रथाओं पर चर्चा की। यह एक बहुत बड़ा विषय है, एक ब्लॉग पोस्ट में पूरी तरह से कवर करना असंभव है। यहां उन महत्वपूर्ण प्रश्नों की सूची दी गई है जिन पर हमने ध्यान नहीं दिया:

यह लेख शामिल नहीं है:

निरंतर एकीकरण और निरंतर तैनाती
स्वचालित परीक्षण
लॉग शिपिंग
एपीआई निगरानी
एक एप्लिकेशन को कई सर्वरों पर स्केल करना
स्रोत कोड में क्रेडेंशियल की सुरक्षा

#पायथन #फ्लास्क #वेब-विकास