फ्लास्क में एक अतुल्यकालिक कार्य करना


96

मैं फ्लास्क में एक एप्लिकेशन लिख रहा हूं, जो वास्तव में अच्छी तरह से काम करता है सिवाय इसके कि WSGIसमकालिक और अवरुद्ध है। मेरे पास विशेष रूप से एक कार्य है जो तीसरे पक्ष के एपीआई को कॉल करता है और उस कार्य को पूरा होने में कई मिनट लग सकते हैं। मैं उस कॉल को करना चाहता हूं (यह वास्तव में कॉल की एक श्रृंखला है) और इसे चलने दें। जबकि नियंत्रण फ्लास्क में वापस आ जाता है।

मेरा विचार ऐसा लगता है:

@app.route('/render/<id>', methods=['POST'])
def render_script(id=None):
    ...
    data = json.loads(request.data)
    text_list = data.get('text_list')
    final_file = audio_class.render_audio(data=text_list)
    # do stuff
    return Response(
        mimetype='application/json',
        status=200
    )

अब, मैं जो करना चाहता हूं वह लाइन है

final_file = audio_class.render_audio()

विधि के वापस आने पर निष्पादित होने के लिए कॉलबैक प्रदान करें और चलाएं, जबकि फ्लास्क अनुरोधों को संसाधित करना जारी रख सकता है। यह एकमात्र कार्य है जिसे मुझे एसिंक्रोनस रूप से चलाने के लिए फ्लास्क की आवश्यकता है, और मैं इसे लागू करने के लिए सबसे अच्छी सलाह पर कुछ सलाह चाहूंगा।

मैंने मुड़ और क्लेन को देखा है, लेकिन मुझे यकीन नहीं है कि वे ओवरकिल हैं, क्योंकि शायद थ्रेडिंग पर्याप्त होगा। या शायद सेलेरी इसके लिए एक अच्छा विकल्प है?


मैं आमतौर पर इसके लिए अजवाइन का उपयोग करता हूं ... यह ओवरकिल हो सकता है लेकिन afaik थ्रेडिंग न करें वेब वातावरण में अच्छी तरह से काम करता है (iirc ...)
जोरन बेस्ली

सही। हाँ - मैं सिर्फ अजवाइन की जांच कर रहा था। यह एक अच्छा तरीका हो सकता है। फ्लास्क के साथ लागू करना आसान है?
डार्विन टेक

हे, मैं भी एक सॉकेट सर्वर (फ्लास्क-सॉकेटियो) का उपयोग करता हूं और हां मुझे लगा कि यह बहुत आसान था ... सबसे कठिन हिस्सा सब कुछ स्थापित हो रहा था
Joran बीस्ले

4
मैं इसकी जाँच करने की सलाह दूंगा । यह लड़का सामान्य तौर पर फ्लास्क के लिए शानदार ट्यूटोरियल लिखता है, और यह समझने के लिए बढ़िया है कि अतुल्यकालिक कार्यों को एक फ्लास्क ऐप में कैसे एकीकृत किया जाए।
एटलस्पिन

जवाबों:


100

मैं आपके लिए अतुल्यकालिक कार्य को संभालने के लिए अजवाइन का उपयोग करूंगा । अपने कार्य कतार (RabbitMQ और Redis की सिफारिश की जाती है) के रूप में सेवा करने के लिए आपको एक ब्रोकर को स्थापित करना होगा।

app.py:

from flask import Flask
from celery import Celery

broker_url = 'amqp://guest@localhost'          # Broker URL for RabbitMQ task queue

app = Flask(__name__)    
celery = Celery(app.name, broker=broker_url)
celery.config_from_object('celeryconfig')      # Your celery configurations in a celeryconfig.py

@celery.task(bind=True)
def some_long_task(self, x, y):
    # Do some long task
    ...

@app.route('/render/<id>', methods=['POST'])
def render_script(id=None):
    ...
    data = json.loads(request.data)
    text_list = data.get('text_list')
    final_file = audio_class.render_audio(data=text_list)
    some_long_task.delay(x, y)                 # Call your async task and pass whatever necessary variables
    return Response(
        mimetype='application/json',
        status=200
    )

अपना फ्लास्क ऐप चलाएं, और अपने अजवाइन कार्यकर्ता को चलाने के लिए एक और प्रक्रिया शुरू करें।

$ celery worker -A app.celery --loglevel=debug

मैं भी मिगुएल Gringberg के को उल्लेख करता है लिखने अप बोतल के साथ अजवाइन का उपयोग करने के गहराई गाइड में एक और अधिक के लिए।


34

थ्रेडिंग एक और संभव उपाय है। यद्यपि स्केलरी आधारित समाधान बड़े पैमाने पर अनुप्रयोगों के लिए बेहतर है, अगर आप प्रश्न में समापन बिंदु पर बहुत अधिक ट्रैफ़िक की उम्मीद नहीं कर रहे हैं, तो थ्रेडिंग एक व्यवहार्य विकल्प है।

यह समाधान मिगुएल ग्रिनबर्ग के PyCon 2016 फ्लास्क स्केल पर प्रस्तुति पर आधारित है , विशेष रूप से अपने स्लाइड डेक में 41 स्लाइड। मूल स्रोत में रुचि रखने वालों के लिए उसका कोड भी जीथब पर उपलब्ध है

उपयोगकर्ता के दृष्टिकोण से कोड निम्नानुसार काम करता है:

  1. आप लंबे समय तक चलने वाले कार्य को पूरा करने वाले समापन बिंदु पर कॉल करते हैं।
  2. यह समापन बिंदु 202 स्थिति कार्य पर जाँच करने के लिए एक लिंक के साथ स्वीकार किया जाता है।
  3. स्टेटस लिंक की कॉल 202 पर लौटती है जबकि टेक अभी भी चल रही है, और टास्क पूरा होने पर 200 (और रिजल्ट) पर लौटती है।

एक एपीआई कॉल को एक पृष्ठभूमि कार्य में बदलने के लिए, बस @async_api डेकोरेटर जोड़ें।

यहाँ एक पूरी तरह से निहित उदाहरण है:

from flask import Flask, g, abort, current_app, request, url_for
from werkzeug.exceptions import HTTPException, InternalServerError
from flask_restful import Resource, Api
from datetime import datetime
from functools import wraps
import threading
import time
import uuid

tasks = {}

app = Flask(__name__)
api = Api(app)


@app.before_first_request
def before_first_request():
    """Start a background thread that cleans up old tasks."""
    def clean_old_tasks():
        """
        This function cleans up old tasks from our in-memory data structure.
        """
        global tasks
        while True:
            # Only keep tasks that are running or that finished less than 5
            # minutes ago.
            five_min_ago = datetime.timestamp(datetime.utcnow()) - 5 * 60
            tasks = {task_id: task for task_id, task in tasks.items()
                     if 'completion_timestamp' not in task or task['completion_timestamp'] > five_min_ago}
            time.sleep(60)

    if not current_app.config['TESTING']:
        thread = threading.Thread(target=clean_old_tasks)
        thread.start()


def async_api(wrapped_function):
    @wraps(wrapped_function)
    def new_function(*args, **kwargs):
        def task_call(flask_app, environ):
            # Create a request context similar to that of the original request
            # so that the task can have access to flask.g, flask.request, etc.
            with flask_app.request_context(environ):
                try:
                    tasks[task_id]['return_value'] = wrapped_function(*args, **kwargs)
                except HTTPException as e:
                    tasks[task_id]['return_value'] = current_app.handle_http_exception(e)
                except Exception as e:
                    # The function raised an exception, so we set a 500 error
                    tasks[task_id]['return_value'] = InternalServerError()
                    if current_app.debug:
                        # We want to find out if something happened so reraise
                        raise
                finally:
                    # We record the time of the response, to help in garbage
                    # collecting old tasks
                    tasks[task_id]['completion_timestamp'] = datetime.timestamp(datetime.utcnow())

                    # close the database session (if any)

        # Assign an id to the asynchronous task
        task_id = uuid.uuid4().hex

        # Record the task, and then launch it
        tasks[task_id] = {'task_thread': threading.Thread(
            target=task_call, args=(current_app._get_current_object(),
                               request.environ))}
        tasks[task_id]['task_thread'].start()

        # Return a 202 response, with a link that the client can use to
        # obtain task status
        print(url_for('gettaskstatus', task_id=task_id))
        return 'accepted', 202, {'Location': url_for('gettaskstatus', task_id=task_id)}
    return new_function


class GetTaskStatus(Resource):
    def get(self, task_id):
        """
        Return status about an asynchronous task. If this request returns a 202
        status code, it means that task hasn't finished yet. Else, the response
        from the task is returned.
        """
        task = tasks.get(task_id)
        if task is None:
            abort(404)
        if 'return_value' not in task:
            return '', 202, {'Location': url_for('gettaskstatus', task_id=task_id)}
        return task['return_value']


class CatchAll(Resource):
    @async_api
    def get(self, path=''):
        # perform some intensive processing
        print("starting processing task, path: '%s'" % path)
        time.sleep(10)
        print("completed processing task, path: '%s'" % path)
        return f'The answer is: {path}'


api.add_resource(CatchAll, '/<path:path>', '/')
api.add_resource(GetTaskStatus, '/status/<task_id>')


if __name__ == '__main__':
    app.run(debug=True)

जब मैं इस कोड का उपयोग करता हूं, तो मेरे पास त्रुटि werkzeug.rout.BuildError: मूल्यों के साथ समापन बिंदु 'gettaskstatus' के लिए url नहीं बना सका ['task_id'] क्या मुझे कुछ याद आ रहा है?
निकोलस दुफौर

9

आप के multiprocessing.Processसाथ प्रयोग करके भी देख सकते हैं daemon=True; process.start()विधि ब्लॉक नहीं करता और आप कॉलर, जबकि पृष्ठभूमि में अपने महंगा फ़ंक्शन निष्पादित करने के लिए तुरंत एक प्रतिक्रिया / स्थिति लौट सकते हैं।

फाल्कन फ्रेमवर्क के साथ काम करने और उपयोग करने के दौरान मैंने इसी तरह की समस्या का अनुभव कियाdaemon प्रक्रिया करने में ।

आपको निम्नलिखित करने की आवश्यकता होगी:

from multiprocessing import Process

@app.route('/render/<id>', methods=['POST'])
def render_script(id=None):
    ...
    heavy_process = Process(  # Create a daemonic process with heavy "my_func"
        target=my_func,
        daemon=True
    )
    heavy_process.start()
    return Response(
        mimetype='application/json',
        status=200
    )

# Define some heavy function
def my_func():
    time.sleep(10)
    print("Process finished")

आपको तुरंत प्रतिक्रिया मिलनी चाहिए और 10 के बाद आपको कंसोल में एक मुद्रित संदेश देखना चाहिए।

नोट: ध्यान रखें कि daemonicप्रक्रियाओं को किसी भी बच्चे की प्रक्रियाओं को स्पॉन करने की अनुमति नहीं है।


एसिंक्रोनस एक निश्चित प्रकार की संगामिति है जो न तो थ्रेडिंग है और न ही मल्टीप्रोसेसिंग है। थ्रेडिंग हालांकि, async कार्य के रूप में उद्देश्य के अधिक करीब है,
tortal

3
मैं आपकी बात नहीं समझता। लेखक एक अतुल्यकालिक कार्य के बारे में बात कर रहा है, जो कि "पृष्ठभूमि में" चलने वाला कार्य है, जैसे कि कॉल करने वाले को प्रतिक्रिया नहीं मिलने तक ब्लॉक नहीं करता है। एक बहरा प्रक्रिया को पैदा करना एक उदाहरण है जहां इस तरह के अतुल्यकालिकता को प्राप्त किया जा सकता है।
टॉमस बर्टकोविआक

क्या होगा अगर /render/<id>समापन बिंदु के परिणामस्वरूप कुछ की उम्मीद है my_func()?
विल गु

आप my_funcउदाहरण के लिए कुछ अन्य बिंदुओं पर प्रतिक्रिया / दिल की धड़कन भेज सकते हैं । या आप कुछ संदेश कतार स्थापित कर सकते हैं और साझा कर सकते हैं, जिसके माध्यम से आप संवाद कर सकते हैंmy_func
टॉमस बर्टकोविआक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.