Run Flask background tasks

A background task is work that runs outside the request, such as sending email or resizing images. On Sevalla, Celery runs the tasks in a background worker process, built from the same image as the web process, and a Redis database holds the queue between them. The setup follows Flask’s own Celery pattern, so every task runs inside the Flask application context, with access to db and the configuration.

Before you begin

A Flask project deployed on Sevalla, as in Deploy Flask.

Create a Redis database

Create the database

In the sidebar, click Databases, then click Create database. Under Database, choose Redis, or Valkey: the code in this guide works with both. Enter storefront-redis as the Display name, choose the same Data center as the application and a Size, then click Create database.

Connect it to the application

In the sidebar, click Applications, then click the application. Click the Networking tab. Under Connected services, click Add internal connection. Choose storefront-redis as the Service, turn on Add environment variables to the application, and click Add internal connection. Sevalla adds REDIS_HOST, REDIS_PORT, REDIS_PASSWORD and REDIS_URL. See Connect an application.

Add Celery to the project

Install Celery with its Redis support, and update requirements.txt:

pip install "celery[redis]"
pip freeze > requirements.txt

Add the function that creates the Celery application from the Flask one:

storefront/celery.py

from celery import Celery, Task
from flask import Flask


def celery_init_app(app: Flask) -> Celery:
    class FlaskTask(Task):
        def __call__(self, *args: object, **kwargs: object) -> object:
            with app.app_context():
                return self.run(*args, **kwargs)

    celery_app = Celery(app.name, task_cls=FlaskTask)
    celery_app.config_from_object(app.config["CELERY"])
    celery_app.set_default()
    app.extensions["celery"] = celery_app
    return celery_app

Add a task:

storefront/tasks.py

from celery import shared_task


@shared_task
def send_order_confirmation(order_id: int) -> None:
    print(f"Sending the confirmation for order {order_id}")

Configure Celery with the Redis URL in the application factory, and add a route that queues the task:

storefront/__init__.py

def create_app() -> Flask:
    app = Flask(__name__)
    app.config["SQLALCHEMY_ENGINES"] = {"default": database_url()}
    # A Valkey database's URL starts with valkey://, which Celery doesn't accept.
    redis_url = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
    app.config["CELERY"] = {
        "broker_url": redis_url.replace("valkey://", "redis://", 1),
        "broker_connection_retry_on_startup": True,
        "task_ignore_result": True,
    }
    app.config.from_prefixed_env()

    db.init_app(app)
    alembic.init_app(app)
    celery_init_app(app)

    from storefront.tasks import send_order_confirmation

    @app.post("/orders/<int:order_id>/confirm")
    def confirm_order(order_id):
        send_order_confirmation.delay(order_id)
        return {"status": "queued"}

    # ...the other routes...
    return app

Import celery_init_app at the top with from storefront.celery import celery_init_app. Then create the worker’s entry point in the repository root:

make_celery.py

from storefront import create_app

flask_app = create_app()
celery_app = flask_app.extensions["celery"]

Commit and push the changes.

Run the worker on Sevalla

Create the background worker

On the application’s Processes tab, click Create process. Choose Background worker, enter Celery worker as the Name and this Custom start command:

celery -A make_celery worker --loglevel INFO --concurrency 2

Choose a Resource and click Create process.

Deploy

Click Deploy in the undeployed changes bar at the bottom of the page.

Set --concurrency to match the size. Without it, Celery starts one worker process per CPU of the machine it runs on, which can be more than the process’s memory holds. Two processes fit in H1 (0.3 GB of memory). To process more tasks at once, add instances in the process’s Scaling section, or choose a larger size and raise --concurrency. See Scaling.

The Create process sheet with Background worker selected, the Name and Custom start command fields, the resource and the scaling settings

Run tasks on a schedule

Run scheduled work as a cron job: add a command to the Flask CLI with @app.cli.command(), then create a Cron job process with a Schedule in cron syntax, such as 0 3 * * * for every day at 03:00 UTC, and the command as its Custom start command, such as flask --app storefront cleanup. See Cron jobs.

Verify

Queue a task, with your application’s domain:
curl -X POST https://storefront-x7k2m.sevalla.app/orders/42/confirm
The response is {"status":"queued"}.
Click the Logs tab and look at the worker’s runtime logs. They show Task storefront.tasks.send_order_confirmation[...] received, the line Sending the confirmation for order 42, and Task storefront.tasks.send_order_confirmation[...] succeeded.

On the Processes tab, the Celery worker process shows Running. If it shows Crashed, the logs show why, for example Error 111 connecting when REDIS_URL is missing or wrong.

Migrate

JavaScript

Python

Run Flask background tasks

Before you begin

Create a Redis database

Add Celery to the project

Run the worker on Sevalla

Run tasks on a schedule

Verify

​Before you begin

​Create a Redis database

​Add Celery to the project

​Run the worker on Sevalla

​Run tasks on a schedule

​Verify

Before you begin

Create a Redis database

Add Celery to the project

Run the worker on Sevalla

Run tasks on a schedule

Verify