Cache FastAPI with Redis

A cache keeps the result of slow work, such as a report or a call to another API, so the next request reads it instead of computing it again. On Sevalla, the cache is a Redis database that the application reaches over an internal connection, so every instance of the web process shares it. FastAPI uses it through redis-py’s asyncio client.

At a glance


Source	The `storefront` project from Deploy a FastAPI application, with redis-py, a lifespan handler and three routes added
Processes	Web process and `Migrate` job, unchanged
Services	PostgreSQL, unchanged; Redis 8.6 or Valkey over an internal connection, as the cache

Environment variables

This guide adds one variable to the ones in Deploy a FastAPI application:

Variable	Required	Available during	Secret	Value
`REDIS_URL`	Yes	Runtime	Yes	`REDIS_URL` from the internal connection, `redis://:<password>@<host>:<port>/0`

Before you begin

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

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.

The Add internal connection sheet with the Service field and the Add environment variables to the application switch

Connect to Redis

Install redis-py and update requirements.txt:

pip install redis
pip freeze > requirements.txt

Open one Redis client when the application starts and close it when it stops, with a lifespan handler. In app/main.py, add the imports to the top and replace app = FastAPI() with the rest:

app/main.py

import os
from contextlib import asynccontextmanager

import redis.asyncio as redis
from fastapi import FastAPI


@asynccontextmanager
async def lifespan(app: FastAPI):
    url = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
    # A Valkey URL added before Oct 30, 2026 starts with valkey://, which redis-py doesn't accept.
    app.state.redis = redis.from_url(url.replace("valkey://", "redis://", 1), decode_responses=True)
    yield
    await app.state.redis.aclose()


app = FastAPI(lifespan=lifespan)

Cache a response

Read from the cache first, and store a fresh result for 2 minutes when it’s empty. Add the imports to the top of app/main.py and the route to the end:

app/main.py

import json
from datetime import datetime, timezone

from fastapi import Request


@app.get("/report")
async def report(request: Request):
    cache = request.app.state.redis
    cached = await cache.get("report")
    if cached:
        return json.loads(cached)
    result = {"generated_at": datetime.now(timezone.utc).isoformat()}
    await cache.set("report", json.dumps(result), ex=120)
    return result

Commit and push the changes. If Auto-deploy is off, click Deploy now on the application’s Overview tab.

Verify

Request the route twice, with your application’s domain:

curl -s https://storefront-x7k2m.sevalla.app/report
curl -s https://storefront-x7k2m.sevalla.app/report

Both responses show the same generated_at, such as {"generated_at":"2026-10-30T05:29:44.688937+00:00"}. After 2 minutes, the next request shows a new time. To look at the key, open the Redis database and click the Redis studio tab. See Database studio.

Control the CDN and edge cache

Sevalla can also cache responses at Cloudflare’s edge, in front of the application. Turn on the CDN and edge caching on the application’s Networking tab; see CDN and edge caching.

The CDN caches static files by file extension, such as .css, .js and images.
Edge caching caches pages and other responses too. It caches only GET requests, skips requests with an Authorization header, and doesn’t store responses that set a cookie.
When a response has no Cache-Control header, Sevalla adds one. With edge caching on, a 200 response without its own header can stay cached for up to 30 days, unless a deployment or a purge clears the cache first. See Control caching from your application.

So with edge caching on, set Cache-Control on every route. no-store keeps a response out of every cache, and max-age sets how long it may be kept. For example, in app/main.py:

app/main.py

from fastapi import Response


@app.get("/cart")
def cart(response: Response):
    response.headers["Cache-Control"] = "no-store"
    return {"items": []}


@app.get("/catalog")
def catalog(response: Response):
    response.headers["Cache-Control"] = "public, max-age=600"
    return {"products": []}

To check what a route sends, run curl -s -D - -o /dev/null https://storefront-x7k2m.sevalla.app/catalog and read the Cache-Control header. (curl -I sends a HEAD request, which a FastAPI GET route answers with 405.)

Deploy with the API

These calls create the Redis database, connect it and deploy the code, as the dashboard steps on this page do. APP_ID, CLUSTER_ID and DB1_ID come from Deploy with the API in the deploy guide, which also turned on auto-deploy, and SEVALLA_API_KEY holds the same API key. Commit the code from this page first, without pushing it, and run the commands in the project folder: the push comes last, so the deployment starts with REDIS_URL in place.

Create the Redis database

Create database (createDatabaseV3), with a password you choose, because the API never returns it. The API requires db_name for every engine; a Redis database reports it as 0:

REDIS_PASSWORD=$(openssl rand -hex 16)
REDIS_ID=$(curl -s -X POST https://api.sevalla.com/v3/databases \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .id
{
  "display_name": "storefront-redis",
  "type": "redis",
  "version": "8.6",
  "cluster_id": "$CLUSTER_ID",
  "resource_type_id": "$DB1_ID",
  "db_name": "storefront",
  "db_password": "$REDIS_PASSWORD"
}
EOF
)

CLI:

sevalla databases create --name storefront-redis --type redis --db-version 8.6 --cluster "$CLUSTER_ID" --resource-type "$DB1_ID" --db-name storefront --db-password "$REDIS_PASSWORD"

. MCP: create_database with type redis, connect_to_application_id set to the application and env_var_name set to REDIS_URL does this step and the next three: it generates the password, connects the database and adds REDIS_URL as redis://:<password>@<host>:<port>, which uses database 0 too.

Wait for the database

Get database (getDatabaseV3) until its status is ready, then keep its internal hostname and port:

for i in $(seq 1 90); do
  [ "$(curl -s "https://api.sevalla.com/v3/databases/$REDIS_ID" \
    -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r '.status // empty')" = ready ] && break
  sleep 10
done
REDIS_HOST=$(curl -s https://api.sevalla.com/v3/databases/$REDIS_ID \
  -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r .internal_hostname)
REDIS_PORT=$(curl -s https://api.sevalla.com/v3/databases/$REDIS_ID \
  -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r .internal_port)

CLI: sevalla databases get "$REDIS_ID" --json. MCP: get_database.

Connect the database

Create internal connection (createApplicationInternalConnectionV3):

curl -s -X POST https://api.sevalla.com/v3/applications/$APP_ID/internal-connections \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"target_id\": \"$REDIS_ID\", \"target_type\": \"database\"}"

CLI: sevalla databases connections internal-create "$REDIS_ID" --target-id "$APP_ID" --target-type app. MCP: sevalla_api_create with createApplicationInternalConnectionV3 and the same body.

Add the Redis URL

The API doesn’t add the connection’s variables. Create environment variable (createEnvironmentVariableV3) adds REDIS_URL in the dashboard’s format, available during runtime only:

curl -s -X POST https://api.sevalla.com/v3/applications/$APP_ID/env-vars \
  -H "Authorization: Bearer $SEVALLA_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -c '{key, is_runtime, is_buildtime}'
{
  "key": "REDIS_URL",
  "value": "redis://:$REDIS_PASSWORD@$REDIS_HOST:$REDIS_PORT/0",
  "is_runtime": true,
  "is_buildtime": false
}
EOF

It prints {"key":"REDIS_URL","is_runtime":true,"is_buildtime":false}. If the application already has a REDIS_URL, from another of these guides, the call fails with 400 and Environment variable with key "REDIS_URL" already exists: use that Redis database instead of a new one, or replace the value with Update environment variable (updateEnvironmentVariableV3). CLI: sevalla apps env-vars create "$APP_ID" --key REDIS_URL --value "redis://:$REDIS_PASSWORD@$REDIS_HOST:$REDIS_PORT/0", which makes it available during build and runtime. MCP: set_environment_variables with runtime true and buildtime false.

Push and find the deployment

Push the commit. Auto-deploy starts a deployment of it, and List deployments (listDeploymentsV3), newest first, returns it once it exists:

git push
COMMIT=$(git rev-parse HEAD)
for i in $(seq 1 60); do
  DEPLOYMENT_ID=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/deployments" \
    -H "Authorization: Bearer $SEVALLA_API_KEY" \
    | jq -r --arg commit "$COMMIT" 'first(.data[]? | select(.commit_sha == $commit) | .id) // empty')
  [ -n "$DEPLOYMENT_ID" ] && break
  sleep 5
done

With auto-deploy off, start it with Trigger deployment (triggerDeploymentV3) instead. CLI: sevalla apps deployments list --app-id "$APP_ID". MCP: list_deployments.

Wait for the deployment

Get deployment (getDeploymentV3) until status is success or failed:

for i in $(seq 1 120); do
  STATUS=$(curl -s "https://api.sevalla.com/v3/applications/$APP_ID/deployments/$DEPLOYMENT_ID" \
    -H "Authorization: Bearer $SEVALLA_API_KEY" | jq -r '.status // empty')
  case $STATUS in success|failed|cancelled|skipped) break ;; esac
  sleep 15
done
echo "$STATUS"

It prints success when the deployment finishes, or failed; after 30 minutes without either, it prints the status it last read. CLI: sevalla apps deployments get "$DEPLOYMENT_ID" --app-id "$APP_ID". MCP: get_deployment, then get_deployment_logs if it failed.

Then run the checks in Verify, with the domain from List application domains (listApplicationDomainsV3) as in the deploy guide.

Get started

Migrate

AI

JavaScript

Python

PHP

Ruby

Go

Rust

Java, Kotlin and Scala

.NET

Elixir

Gleam

Swift

Dart

Static site generators

Cache FastAPI with Redis

At a glance

Environment variables

Before you begin

Create a Redis database

Connect to Redis

Cache a response

Verify

Control the CDN and edge cache

Deploy with the API

​At a glance

​Environment variables

​Before you begin

​Create a Redis database

​Connect to Redis

​Cache a response

​Verify

​Control the CDN and edge cache

​Deploy with the API

At a glance

Environment variables

Before you begin

Create a Redis database

Connect to Redis

Cache a response

Verify

Control the CDN and edge cache

Deploy with the API