> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sevalla.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Django - Caching

> This article explains how to set up caching for your Django application in Sevalla.

## Cache framework using Redis

Django's cache framework can be used with a Django app deployed on Sevalla by connecting a Redis service to your Django app.

To enable the cache framework, Redis needs to be installed and your settings updated.

### Install

The Python Redis library must be a dependency so that Django can connect to your Redis instance.

```shellsession theme={null}
pip install redis
pip freeze > requirements.txt
```

### Settings

You need to add the caches settings to `settings.py`.

Reference the `RedisCache` backend that is included with Django. Use your preferred method for defining configuration values for `LOCATION`, which is the URL of your Redis instance. django-environ is used for this example.

```python theme={null}
CACHES = { # [!code ++:6]
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": env('REDIS_URL'),
    }
}
```

Within Sevalla, you can [create and connect a Redis database](https://docs.sevalla.com/databases/get-started/add-a-database) to your Django app. After creating the Redis instance, go to **Networking** and then click **Add internal connection**, select the Redis instance you created, and then add the `REDIS_URL` environment variable to the application.

### Example

To use the cache on a view, you can import the `cache_page` function and decorate some of your view functions or classes. Here is an example:

1. Create an app that allows you to add a new view.

   ```shellsession theme={null}
   python manage.py startapp app
   ```
2. Create a view function and decorate it with `cache_page`. This example will cache the view for two minutes.

   ```python theme={null}
   # app/views.py
   from django.http import HttpResponse # [!code ++:7]
   from django.utils import timezone
   from django.views.decorators.cache import cache_page

   @cache_page(60 * 2)
   def cached_view(request):
       return HttpResponse(f"Cached at {timezone.now()} for two minutes")
   ```

   ```python theme={null}
   # example/urls.py
   from django.contrib import admin
   from django.urls import path

   from app.views import cached_view # [!code ++]

   urlpatterns = [
       path('admin/', admin.site.urls),
       path('cached/', cached_view, name='cached_view'), # [!code ++]
   ]
   ```
3. Navigate to the `cached/` endpoint, the time the view was added to the cache will be displayed until the cache is updated.

The settings for `RedisCache` used here will also work with template fragment caching and direct use of the cache API.

If you want to cache your entire site, consider using edge caching instead.

## CDN

If you are using WhiteNoise to serve your static files, you can [enable the CDN setting](https://docs.sevalla.com/applications/cdn#enable-or-disable-sevalla’s-cdn) to cache your static assets on Cloudflare.

To verify your static files are being cached correctly, request a file and inspect the response headers. The `cf-cache-status` header should be either `HIT` or `MISS`. `MISS` should only occur when the file needs to be set or updated in the CDN. `HIT` will be the expected value for most requests.

## Edge Caching

If your application primarily serves pages that don’t change frequently, you can use [edge caching](https://docs.sevalla.com/applications/edge-caching#enable-or-disable-edge-caching) to store and serve pre-rendered responses. This caching applies across the entire application, and only endpoints that explicitly disable caching via response headers will be excluded, resulting in faster load times and reduced server load.

You can prevent caching by decorating a view with `never_cache`.

```python theme={null}
from django.views.decorators.cache import never_cache

@never_cache
def login(request):
    ...
```

By default, all admin views in Django use the `never_cache` decorator.

To control how long a page will remain in the cache, you need to set the `max-age` response headers. One way to do that is to use the `cache_control` decorator.

```python theme={null}
from django.views.decorators.cache import cache_control

@cache_control(max_age=60*60*24)
def page(request):
   ...
```

To verify your pages are being cached correctly, request a page and inspect the response headers. The `cf-cache-status` header should be either `HIT` or `MISS`. `MISS` should only occur when the page needs to be set or updated in the CDN. `HIT` will be the expected value for most requests.