Полное руководство по кешированию Django – CodesCode

Узнайте, что такое кэширование, его преимущества, как настроить кэширование в Django, поддерживаемые бэкэнд-системы Django и лучшие практики кэширования.

В этой статье вы получите всеобъемлющее понимание кэширования в Django и веб-разработке в целом. Вы узнаете, что такое кэширование, каковы его преимущества, как настроить кэширование в Django, какие системы поддерживает Django, а также лучшие практики кэширования.

К концу статьи вы, как веб-разработчик backend, будете иметь четкое представление о кэшировании и о том, как его можно реализовать в ваших проектах Django для лучшей производительности.

Фреймворк Django – один из самых популярных бэкэнд-фреймворков, используемых веб-разработчиками в наше время. В качестве разработчика создание веб-приложений с высокой производительностью должно быть одной из целей, о которых вы думаете. Таким образом, создание веб-приложения в Django для максимальной производительности не должно вызывать трудностей, поскольку Django поставляется с фреймворком кэширования, который позволяет использовать различные кэширующие бэкэнды, такие как кэш в памяти, кэш на основе файлов, кэш в базе данных и другие.

• Введение в кэширование Django
  • Общие сценарии кэширования и использования
  • Преимущества кэширования Django
• Настройка проекта Django
• Настройка различных параметров кэширования в settings.py
  • Кэширование в локальной памяти
  • Кэширование на основе файлов
  • Базовое кэширование
  • Кэширование в Memcached
  • Redis
• Выполнение кэширования в Django с использованием Redis
  • Кэширование представления
  • Кэширование фрагментов шаблона
  • Кэширование для каждого сайта
• Заключение

Введение в кэширование Django

Кэширование в веб-разработке – это метод, используемый веб-разработчиками для повышения производительности веб-приложений. Каждое веб-приложение содержит ресурсы, которые пользователи регулярно хотят использовать. Ресурсом может быть что угодно – от простой веб-страницы до данных, хранящихся в базе данных. Кэширование играет значительную роль в максимизации скорости доступа к ресурсам.

Общие сценарии кэширования и использования

Фреймворк кэширования Django предоставляет широкий спектр сценариев и случаев использования, которые позволяют разработчику кэшировать часто запрашиваемые данные. Вот некоторые общие сценарии кэширования:

• Кэширование страниц. В этом сценарии часто посещаемые страницы на сайте полностью кэшируются. Приложение извлекает закэшированные версии страниц и рендерит их при получении запроса, вместо того чтобы создавать содержимое страницы с нуля.

• Кэширование запросов к базе данных. Кэширование запросов к базе данных – это хороший подход для приложений, которые часто запрашивают данные из базы данных. Одна и та же запрошенная информация может быть удовлетворена с использованием одних и тех же закэшированных данных, без необходимости обращаться к базе данных, что позволяет снизить нагрузку на базу данных и ускорить время ответа сервера.

• Кэширование сеанса и аутентификации. Кэширование может использоваться для предложения удобного пользовательского опыта и более быстрого времени ответа. Поскольку закэшированные данные позволят пользователям легко перемещаться по аутентифицированным разделам приложения, кэширование аутентификации и деталей сеанса может помочь сократить избыточные операции аутентификации.

Преимущества кэширования Django

В современной среде, где данные играют важную роль, и скорость является ключевым аспектом, кэширование становится все более выгодным для веб-разработчиков. Вот некоторые преимущества кэширования:

• Улучшенная производительность. Кэширование повышает производительность веб-приложений путем снижения нагрузки на сервер. Когда сервер получает запросы от приложения, кэширование позволяет удовлетворить некоторые запросы с использованием ранее закэшированных данных. Это позволяет избежать выполнения этих операций с нуля. В результате пользовательский опыт улучшается в целом, и время реакции ускоряется.

• Снижение времени ответа. Кэширование сокращает время ответа за счет снижения обращений к базе данных. Кэширование позволяет получать данные из удобного места, а не напрямую из базы данных каждый раз, когда это требуется. Поскольку некоторые данные требуют дорогостоящих вычислений, которые могут занимать время, забирать данные каждый раз из базы данных может быть не лучшим выбором для всех данных. Сохраняя данные и мгновенно делая их доступными при необходимости, кэширование спасает ситуацию.

• Оптимизация ресурсов. Кэширование данных или ресурсов в веб-приложении позволяет получать доступ и извлекать ресурсы без выполнения повторяющихся операций, которые дают одинаковые результаты.

Настройка проекта Django

Основные задачи в этом разделе – создать виртуальное окружение и установить необходимые модули для проекта. Чтобы создать виртуальное окружение, выполните эту команду в терминале:

$ python -m venv project

Все модули для проекта будут установлены внутри этого окружения, поэтому для начала его использования нам нужно его активировать.

В Windows используйте это:

$ .\project\Scripts\activate

А в macOS или Linux, используйте это:

$ source project/bin/activate

Прежде чем мы реализуем кэширование, первое, что нужно сделать, – это настроить проект Django. Давайте сначала установим Django. Откройте терминал и выполните эту команду:

$ pip install django

После успешной установки Django создадим проект и приложение Django. Для создания проекта Django выполните:

$ django-admin startproject cachedproject

Перейдите в папку проекта. Здесь мы создадим приложение Django. Выполните эту команду:

$ cd cachedproject

Затем выполните это:

$ python manage.py startapp cachedapplication

После успешного создания проекта и приложения мы должны зарегистрировать приложение в проекте. Откройте файл settings.py и добавьте строку в список INSTALLED_APPS следующим образом:

INSTALLED_APPS = [    'django.contrib.admin',    'django.contrib.auth',    'django.contrib.contenttypes',    'django.contrib.sessions',    'django.contrib.messages',    'django.contrib.staticfiles',    # добавлено новое приложение    'cachedapplication',]

Примечание: чтобы использовать приложение в проекте Django, оно должно быть зарегистрировано в списке INSTALLED_APPS.

Теперь, чтобы убедиться, что фреймворк Django успешно установлен, давайте протестируем его. В терминале выполните эту команду:

$ python manage.py runserver

Убедитесь, что вы получаете вывод, изображенный ниже.

Теперь скопируйте URL и вставьте его в веб-браузер. Ожидаемый вывод показан ниже.

Примечание: вы можете прочитать больше о быстром запуске проекта Django и приложения Django на CodesCode.

Настройка различных параметров кэширования в settings.py

Чтобы использовать кэширование, нам нужно настроить его в нашем проекте Django, поэтому в этом разделе мы рассмотрим, как можно настроить различные системы кэширования, доступные в Django.

Кэширование в локальной памяти

Как следует из названия, Local Memory Cache, иногда сокращенно называемый locmem, хранит кэшированные данные в ОЗУ хостинг-машины.

Django автоматически использует кэширование в локальной памяти в качестве системы кэширования по умолчанию, если вы не предоставляете альтернативный механизм кэширования в файле settings.py. Его потокобезопасная, быстрая и отзывчивая техника кэширования заслуживает внимания.

Local Memory Cache менее подходит для использования в производственных средах, так как он включает механизм на уровне процесса, который предотвращает любое кэширование между процессами и заставляет отдельные процессы поддерживать отдельные частные экземпляры кэша. Однако он по-прежнему хороший выбор для разработки.

Чтобы настроить кэширование в локальной памяти в вашем приложении, добавьте следующий код в файл settings.py:

# CACHES, содержащий конфигурации кэширования.CACHES = {    # псевдоним или имя кэша. В этом случае используется "default" как псевдоним.    "default": {        # Здесь мы используем кэширование в памяти.        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",        # Параметр LOCATION задает уникальное имя или идентификатор этого экземпляра кэша.        "LOCATION": "unique-snowflake",    }}

Кэширование на основе файлов

При кэшировании на основе файлов каждое кэшированное значение сериализуется и отдельно хранится в файле. Оно полезно для небольших приложений или когда кэширование в памяти непрактично.

Недостатком этой системы кэширования является относительная медлительность по сравнению с кэшированием на основе памяти.

Для настройки кэширования на основе файлов в вашем приложении добавьте следующий код в файл settings.py:

# Словарь CACHES, содержащий конфигурации кэширования.CACHES = {    # Используем "default" в качестве псевдонима.    "default": {        # Здесь мы используем кэш на основе файлов.        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",        # Параметр LOCATION для указания пути файловой системы, где будет храниться кэшированные данные.        "LOCATION": "/var/tmp/django_cache",    }}

Если вы используете Windows, убедитесь, что вы начинаете путь расположения с соответствующей буквы диска, как показано ниже:

CACHES = {    "default": {        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",        "LOCATION": "C:/my/path-to/file",    }}

Кэширование в базе данных

Помимо хранения кэшей в файлах и в оперативной памяти сервера, Django также предоставляет возможность хранить кэш в базе данных.

Это работает лучше всего, если у вас есть быстрый и хорошо проиндексированный сервер баз данных.

Чтобы использовать кэширование в базе данных в вашем приложении, добавьте следующий код внутри файла settings.py:

# Словарь CACHES, содержащий конфигурации кэширования.CACHES = {    # Используем "default" в качестве псевдонима.    "default": {        # Здесь мы используем кэш на основе базы данных.        "BACKEND": "django.core.cache.backends.db.DatabaseCache",        # Предоставьте параметр LOCATION для указания имени таблицы базы данных, где будут храниться кэшированные данные.        "LOCATION": "my_cache_table",    }}

Для создания упомянутой выше базы данных таблицы в правильном формате, ожидаемом системой кэша базы данных Django, используйте следующую команду перед использованием кэша:

python manage.py createcachetable

Команда выше создает таблицу в базе данных в правильном формате, ожидаемом системой кэша базы данных Django. Название таблицы берется из LOCATION. В этом случае название таблицы будет my_cache_table.

Кэширование Memcached

Memcached – это система кэширования в памяти, которую используют веб-разработчики даже в нескольких популярных компаниях для снижения доступа к базе данных и увеличения производительности сайта.

В отличие от кэша locmem, Memcached работает как демон, что означает, что сервер Memcached работает в качестве фонового процесса, независимо от любого прямого взаимодействия с пользователем. Поэтому Memcached должен быть установлен отдельно на вашей машине. Затем в вашем Django-приложении установите и настройте одну из его привязок, таких как pylibmc или pymemcache, для использования Memcached.

Приложение Django может быть связано с демоном Memcached, добавив настройки кэша, расположение, IP-адрес и другие детали, как показано ниже:

# Словарь с именем CACHES, содержащий конфигурации кэширования.CACHES = {    # "default" - это псевдоним.    "default": {        # Здесь мы используем кэш Memcached.        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",        # Параметр LOCATION для указания IP-адреса и порта сервера Memcached.        "LOCATION": "127.0.0.1:11211",    }}

Технология Memcached особенно подходит для приложений с высокими нагрузками на чтение или запросы, так как она была разработана для быстрого хранения и извлечения данных.

Недостатком Memcached является то, что, поскольку данные хранятся в памяти, они будут потеряны при сбое сервера.

Redis

Redis – это база данных в памяти, которую можно использовать для кэширования. Она кэширует данные с использованием хранилища данных Redis в памяти. Redis славится своей быстротой и адаптивностью, что делает его отличным выбором для распределенных систем и кэширования высокой производительности.

Чтобы кэшировать данные с использованием Redis в вашем приложении, вам нужен запущенный сервер Redis, либо локально, либо на удаленной машине. Чтобы настроить Redis на вашей машине, прочтите руководство по началу работы с Redis.

После настройки сервера Redis вам потребуется установить привязки Python для Redis. Используйте эту команду для установки:

$ pip install django-redis

Интерфейс redis-py является привязкой, которая поддерживается нативно Django или с помощью пакетов django-redis и redis.

Для настройки кэширования Redis в вашем приложении, если ваш сервер Redis работает на localhost (127.0.0.1) и port=6379, добавьте следующий код в файл settings.py:

# Словарь под названием CACHES, который содержит конфигурации кэширования. CACHES = {    # "default" - псевдоним.    "default": {        # Здесь мы используем кэш на основе Redis.        "BACKEND": "django.core.cache.backends.redis.RedisCache",        # Параметр LOCATION для указания адреса и порта сервера Redis.        "LOCATION": "redis://127.0.0.1:6379",    }}

Сложность Redis и его зависимость от внешних сервисов – это его недостатки. Установка и настройка Redis могут быть сложнее, чем у некоторых других кэш-бекендов. Он требует второго сервера и обслуживания при работе в сети. Использование Redis создает зависимость от внешнего сервиса. Возможности кэширования вашего приложения могут быть затронуты, если у Redis возникнут проблемы или он выйдет из строя.

Выполнение кэширования в Django с использованием Redis

Хорошо, этого достаточно теории. В этом разделе мы продемонстрируем, как выполнять кэширование в приложении Django. Мы сосредоточимся на трех формах кэширования:

• кэширование представления
• кэширование фрагментов шаблона
• кэширование для всего сайта

Но перед тем, как подробно рассмотреть каждую форму кэширования, давайте сначала правильно настроим проект. Мы создадим, зарегистрируем и заполним модели, настроим URL-адреса приложения, создадим шаблон, установим панель отладки Django и настроим ее.

Внутри приложения cachedapplication откройте файл models.py и сделайте его таким:

from django.db import modelsclass Programmer(models.Model):    name = models.CharField(max_length=50)    dob = models.CharField(max_length=20)    language = models.CharField(max_length=20)    quote = models.CharField(max_length=150)    def __str__(self):        return f"{self.name}"

Затем откройте файл admin.py и вставьте этот код:

from django.contrib import adminfrom .models import Programmeradmin.site.register(Programmer)

Этот фрагмент кода регистрирует модель Programmer в панели управления администратора Django.

Перед заполнением моделей давайте выполним некоторые миграции. В терминале выполните следующую команду:

$ python manage.py makemigrations

И также выполните это:

$ python manage.py migrate

В Django мы можем заполнять наши модели двумя способами: через терминал и через панель администратора. Но для упрощения мы будем использовать панель администратора. Поскольку панель администратора предназначена только для суперпользователя, нам нужно создать суперпользователя. В терминале выполните следующую команду:

$ python manage.py createsuperuser

Эта команда запросит вас ввести данные суперпользователя, такие как имя пользователя, электронная почта и два пароля.

После успешного создания суперпользователя запустите локальный сервер и в вашем браузере введите этот URL: http://127.0.0.1:8000/admin/. На изображении ниже показана страница, на которую вы будете перенаправлены.

Для входа введите учетные данные суперпользователя, и после входа заполните модели данными, как показано ниже.

Внутри приложения создайте папку templates, а внутри нее создайте файл list_all.html. Пока оставьте HTML-файл пустым. Откройте файл views.py и сделайте его таким:

from django.shortcuts import renderfrom .models import Programmerdef home(request):    programmers = Programmer.objects.all()    context = {        'programmers': programmers    }    return render(request, 'list_all.html', context)

Теперь зарегистрируем представление home в файле urls.py проекта. Внутри папки cachedproject откройте файл urls.py и вставьте этот код:

from django.contrib import adminfrom django.urls import path, includefrom cachedapplication import viewsurlpatterns = [    path('admin/', admin.site.urls),    # представление home из cachedapplication    path('home/', views.home, name='home'),]

Теперь откройте файл list_all.html и вставьте следующий код:

<!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <meta name="viewport" content="width=device-width, initial-scale=1.0">    <title>Кеширование</title>    <link href="https://cdnjs.cloudflare.com/ajax/libs/mdb-ui-kit/6.4.2/mdb.min.css" rel="stylesheet"/></head><body>    <div class="container py-5">        <table class="table">           <thead>              <tr>                 <th>Имя</th>                 <th>Дата рождения</th>                 <th>Язык программирования</th>                 <th>Цитата</th>              </tr>           </thead>           <tbody>              {% for programmer in programmers %}              <tr>                 <td>{{programmer.name}}</td>                 <td>{{programmer.dob}}</td>                 <td>{{programmer.language}}</td>                 <td>{{programmer.quote}}</td>              </tr>              {% endfor %}           </tbody>        </table>     </div></body></html>

Установим панель отладки Django. Это пакет Python, который помогает разработчикам отслеживать производительность их приложений Django, предоставляя подробную информацию о запросах к базе данных, HTTP-запросах, времени рендеринга шаблонов и многом другом. Поэтому введите эту команду в вашем терминале:

pip install django-debug-toolbar

Чтобы настроить django-debug-toolbar, откройте файл settings.py и отредактируйте список INSTALLED_APPS следующим образом:

# Определение приложенийINSTALLED_APPS = [    'django.contrib.admin',    'django.contrib.auth',    'django.contrib.contenttypes',    'django.contrib.sessions',    'django.contrib.messages',    'django.contrib.staticfiles',    # добавленное приложение    'cachedapplication',    # панель отладки    'debug_toolbar',]

Добавьте панель отладки в список MIDDLEWARE:

MIDDLEWARE = [    # промежуточное ПО панели отладки    'debug_toolbar.middleware.DebugToolbarMiddleware',]

Разместите промежуточное ПО панели отладки сразу после этого:

django.middleware.csrf.CsrfViewMiddleware

Оно также должно располагаться перед этим:

django.contrib.auth.middleware.AuthenticationMiddleware

Добавьте конфигурации кэша Redis следующим образом:

CACHES = {    "default": {        "BACKEND": "django_redis.cache.RedisCache",        "LOCATION": "redis://127.0.0.1:6379/1",        "OPTIONS": {            "CLIENT_CLASS": "django_redis.client.DefaultClient",        }    }}

Также добавьте этот код в файл settings.py:

INTERNAL_IPS = [    # ...    '127.0.0.1',  # Добавьте IP-адрес вашей разработочной машины сюда]

Наконец, настроим URL-адреса панели отладки в файле urls.py. Прямо под импортами добавьте эту строку кода:

import debug_toolbar

Внутри списка urlpatterns добавьте этот код:

urlpatterns = [    # URL-адреса панели отладки    path('__debug__/', include(debug_toolbar.urls)),]

Достигнув этого этапа, мы готовы к работе. Запустите сервер и вставьте этот URL в ваш браузер: http://127.0.0.1:8000/home/. Ниже показана страница, которую мы получаем.

Всякий раз, когда вы запускаете приложение с помощью этого представления, происходят SQL-запросы. В данном случае выполнено три запроса за 2.60 мс. Чтобы избежать повторения SQL-запросов для одних и тех же данных при каждом запуске, мы реализуем кэширование представления.

Кеширование представления

Как следует из названия, кеширование представления включает кеширование результатов отдельных представлений Django. В этом разделе мы реализуем кеширование представления. Для этого внесем несколько изменений в файл view.py. Откройте его и добавьте этот импорт:

from django.views.decorators.cache import cache_page

Прямо перед представлением также добавьте этот декоратор:

@cache_page(60*15)

(60*15) – это аргумент, переданный @cache_page. Он представляет собой время ожидания кеша в секундах. Представление домашней страницы будет кешироваться в течение 15 минут.

Теперь посетите то же представление и обновите страницу. Мы получим следующий результат:

На изображении выше мы видим, что выполнено 0 SQL-запросов, так как данные извлекаются из кеша. Это помогает снизить нагрузку на сервер, предоставляя пользователям кешированное содержимое.

Кеширование фрагментов шаблона

Это кеширование включает кеширование конкретных частей шаблона в вашем проекте. Когда в вашем шаблоне есть участки с тяжелыми вычислениями, кеширование фрагментов шаблона пригодится. Для реализации этого кеширования мы используем следующие теги: {% load cache %}, {% cache %} и {% endcache %}. Тег {% cache %} принимает два аргумента: время ожидания кеша и уникальный ключ кеша для идентификации конкретного кешированного фрагмента.

Теперь попробуйте запустить проект перед применением этой техники кеширования. Изображение ниже показывает, что мы получим.

Общее время составляет 220.26мс, и выполнено три SQL-запроса за 7.75мс.

Теперь давайте реализуем технику кеширования. Мы закешируем часть <div> шаблона. Откройте templates/list_all.html и измените его следующим образом:

{% load cache %}<!DOCTYPE html><html lang="en"><head>    <meta charset="UTF-8">    <meta name="viewport" content="width=device-width, initial-scale=1.0">    <title>Caching</title>    <link href="https://cdnjs.cloudflare.com/ajax/libs/mdb-ui-kit/6.4.2/mdb.min.css" rel="stylesheet"/></head><body>     {% cache 500 programmers %}    <div class="container py-5">        <table class="table">           <thead>              <tr>                 <th>Name</th>                 <th>DOB</th>                 <th>Language</th>                 <th>Quote</th>              </tr>           </thead>           <tbody>              {% for programmer in programmers %}              <tr>                 <td>{{programmer.name}}</td>                 <td>{{programmer.dob}}</td>                 <td>{{programmer.language}}</td>                 <td>{{programmer.quote}}</td>              </tr>              {% endfor %}           </tbody>        </table>     </div>   {% endcache %}</body></html>

Вверху файла мы загружаем кеш с помощью {% load cache %}, а внутри тега {% cache 500 programmers %} и {% endcache %} мы обрамляем часть div.

Если вы снова запустите проект, вы получите следующий результат:

На изображении выше мы можем видеть, что результаты улучшились после внедрения кэширования.

Кэширование для всего сайта

Кэширование для всего сайта также известно как кэширование всего сайта. Оно включает кэширование страниц всего сайта. Чтобы его реализовать, вам нужно добавить эти конфигурации middleware в файле settings.py:

MIDDLEWARE = [    # …    'django.middleware.cache.UpdateCacheMiddleware',    'django.middleware.common.CommonMiddleware',    'django.middleware.cache.FetchFromCacheMiddleware',    # …]

Также добавьте эти строки:

CACHE_MIDDLEWARE_ALIAS  = ' ' # псевдоним кэшаCACHE_MIDDLEWARE_SECONDS = 600 # количество секунд, на которое должна кэшироваться каждая страница.CACHE_MIDDLEWARE_KEY_PREFIX = ''  # имя сайта, если используются несколько сайтов

Заключение

В заключение, для веб-разработчиков, стремящихся создавать высокопроизводительные веб-приложения, понимание кэширования в Django является необходимым. В этой статье мы предоставили исчерпывающее руководство по кэшированию в Django, рассмотрев такие темы, как преимущества кэширования, настройка кэширования в Django и лучшие практики реализации. Вооружившись этими знаниями, разработчики бэкэнда могут уверенно внедрять кэширование в свои проекты Django для оптимизации производительности.

Если вам понравилась эта статья, ознакомьтесь с другими статьями по Django на сайте CodesCode.

Поделиться этой статьей

---

• caching
• django