Cache Django with Redis

Django’s cache framework keeps computed views and values in a cache backend. On Sevalla, the backend is a Redis database that the application reaches over an internal connection, so every instance of the web process shares one cache. Django includes the Redis backend: it needs only the redis package.

Before you begin

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

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

Configure the cache

Install redis-py and update requirements.txt:

pip install redis
pip freeze > requirements.txt

In storefront/settings.py, use Django’s Redis backend with the URL from the internal connection:

storefront/settings.py

# A Valkey database's URL starts with valkey://, which redis-py doesn't accept.
REDIS_URL = env("REDIS_URL", default="redis://localhost:6379/0").replace("valkey://", "redis://", 1)

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": REDIS_URL,
    }
}

The same setting serves cache_page, template fragment caching ({% cache %}) and the low-level API (django.core.cache.cache).

Cache a view

Cache a view’s response for 2 minutes with cache_page:

storefront/views.py

from django.http import HttpResponse
from django.utils import timezone
from django.views.decorators.cache import cache_page


@cache_page(60 * 2)
def cached(request):
    return HttpResponse(f"Generated at {timezone.now():%H:%M:%S}")

storefront/urls.py

from django.contrib import admin
from django.urls import path

from storefront.views import cached

urlpatterns = [
    path("admin/", admin.site.urls),
    path("cached/", cached),
]

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

Verify

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

curl https://storefront-x7k2m.sevalla.app/cached/
curl https://storefront-x7k2m.sevalla.app/cached/

Both responses show the same time. After 2 minutes, the next request shows a new time. To look at the keys, 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. WhiteNoise’s hashed file names make them safe to cache for a long time.
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, such as pages that start a session or set the CSRF 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 view. never_cache keeps a page out of every cache, and cache_control sets how long it may be kept:

storefront/views.py

from django.views.decorators.cache import cache_control, never_cache


@never_cache
def account(request):
    ...


@cache_control(public=True, max_age=600)
def catalog(request):
    ...

Django’s admin views already use never_cache. To check what a page sends, run curl -sI https://storefront-x7k2m.sevalla.app/catalog/ and read the Cache-Control header.

Migrate

JavaScript

Python

Cache Django with Redis

Before you begin

Create a Redis database

Configure the cache

Cache a view

Verify

Control the CDN and edge cache

​Before you begin

​Create a Redis database

​Configure the cache

​Cache a view

​Verify

​Control the CDN and edge cache

Before you begin

Create a Redis database

Configure the cache

Cache a view

Verify

Control the CDN and edge cache