During a long-running process, will Flask be insensitive to new requests?

user_11015241 0
Viewed 1624

My Flask project takes in orders as POST requests from multiple online stores, saves those orders to a database, and forwards the purchase information to a service which delivers the product. Sometimes, the product is not set up in the final service and the request sits in my service's database in an "unresolved" state.

When the product is set up in the final service, I want to kick off a long-running (maybe a minute) process to send all "unresolved" orders to the final service. During this process, will Flask still be able to receive orders from the stores and continue processing as normal? If not, do I need to offload this to a task runner like rq?

I'm not worried about speed as much as I am about consistency. The items being purchased are tickets to a live event so as long as the order information is passed along before the event begins, it should make no difference to the customer.

flask http python
2 Answers

There's a few different answers that are all valid in different situations. The quick answer is that a job queue like RQ is usually the right solution, especially in the long run as your project grows.

As long as the WSGI server has workers available, another request can be handled. Each worker handles one request at a time. The development server uses threads, so an unlimited number of workers are available (with the performance constraints of threads in Python). Production servers like Gunicorn can use multiple workers, and different types of workers such as threads, processes, or eventlets. If you want to run a task in response to an HTTP request and wait until the task is finished to send a response, you'll need enough workers to block on those tasks along with handling regular requests.

@app.route("/admin/send-purchases")
def send_purchases():
    ...  # do stuff, wait for it to finish
    return "success"

However, the task you're describing seems like a cleanup task that should be run regardless of HTTP requests from a user. In that case, you should write a Flask CLI command and call it using cron or another scheduling system.

@app.cli.command()
def send_purchases():
    ...
    click.echo("done")

# crontab hourly job
0 * * * * env FLASK_APP=myapp /path/to/venv/bin/flask send-purchases

If you do want a user to initiate the task, but don't want to block a worker waiting for it to finish, then you want a task queue such as RQ or Celery. You could make a CLI command that submits the job too, to be able to trigger it on request and on a schedule.

@rq.job
def send_purchases():
    ...

@app.route("/admin/send-purchases", endpoint="send_purchases")
def send_purchases_view():
    send_purchases.queue()
    return "started"

@app.cli.command("send-purchases")
def send_purchases_command():
    send_purchases.queue()
    click.echo("started")
user_4006170

Flask's development server will spawn a new thread for each request. Similary, production servers can be started with multiple workers.

You can run your app with gunicorn or similar with multiple processes. For example with four process workers:

gunicorn -w 4 app:app

For example with eventlet workers:

gunicorn -k eventlet app:app

See the docs on deploying in production as well: https://flask.palletsprojects.com/en/1.1.x/deploying/

user_88067590
Related