Как кэшировать используя Redis в приложениях Django

Russian (Pусский) translation by Masha Kolesnikova (you can also view the original English article)

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

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

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

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

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

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

Установка Redis

Первый шаг - получить Redis и запустить локально на вашем компьютере. Самый простой способ установить Redis через диспетчер пакетов операционной системы:

sudo apt-get install redis-server

Вы также можете следовать инструкциям официального сайта Redis.

Загрузите и извлеките Redis 4.0.6 tar следующим образом:

$ wget http://download.redis.io/releases/redis-4.0.6.tar.gz 
$ tar xzf redis-4.0.6.tar.gz 
$ cd redis-4.0.6 $ make

Бинарные файлы, которые теперь компилируются, доступны в каталоге src. Запустите Redis с помощью:

$ src/redis-server

Вы можете взаимодействовать с Redis с помощью встроенного клиента:

$ src/redis-cli
redis set foo bar OK redis
get foo "bar"

Чтобы проверить, запущен ли сервер redis, выполните в терминале следующую команду:

$ sudo redis-server
* Ready to accept connections

Пример API Django

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

Чтобы использовать Redis в нашем приложении, нам нужно сделать следующее:

Проверить, существуют ли результаты для текущего запроса в кеше.
Если результаты есть в кеше, извлеките их.
Если результатов не существует, извлеките их, сохраните их в кеше и затем пересылайте их запрашивающему объекту.

Требования

Django
django-redis
Redis
loadtest

Создаем свой проект

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

mkdir myprojects

cd myprojects

Затем активируйте виртуальное окружение и установите требования к проекту.

 source venv/bin/activate
 
 pip install django==1.9
 
 pip install django-redis
 
 pip install djangorestframework

Создание проекта Django

django-admin startproject django_cache

Создайте новое приложение под названием store, которое будет обрабатывать управление продуктами в нашем магазине.

cd django_cache

python manage.py startapp store

Добавьте приложение store и rest_framework в список установленных приложений в файле settings.py.

# settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'store', # add here
    'rest_framework', # add here too
]

Создание моделей

В store/models.py мы начинаем с создания модели продукта для хранения сведений о продукте следующим образом:

from __future__ import unicode_literals
from django.db import models
import datetime

# Create your models here.


class Product(models.Model):

    name = models.CharField(max_length=255)
    description = models.TextField(null=True, blank=True)
    price = models.IntegerField(null=True, blank=True)
    date_created = models.DateTimeField(auto_now_add=True, blank=True)
    date_modified = models.DateTimeField(auto_now=True, blank=True)

    def __unicode__(self):
        return self.name

    def to_json(self):
        return {
            'id': self.id,
            'name': self.name,
            'desc': self.description,
            'price': self.price,
            'date_created': self.date_created,
            'date_modified': self.date_modified
        }

Миграции

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

python manage.py makemigration store

python manage.py migrate

Создание суперпользователя

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

python manage.py createsuperuser

Настройка Redis в приложениях Python

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

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

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

В файле store/views.py добавьте следующий код, который извлекает все продукты, существующие в базе данных.

from django.shortcuts import render
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status

# Create your views here.



@api_view(['GET'])
def view_books(request):

    products = Product.objects.all()
    results = [product.to_json() for product in products]
    return Response(results, status=status.HTTP_201_CREATED)

Настройка URL-адресов

Создайте файл store/urls.py и добавьте в него следующий код.

# store/urls.py
from django.conf.urls import url
from .views import view_books


urlpatterns = [
    url(r'^$', view_books),
]

Нам также необходимо импортировать URL-адреса из приложения users в основной файл django_cache/urls.py.

# django_cache/urls.py

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^store/', include('store.urls'))
]

Давайте проведем тест и посмотрим, как у нас все получилось. Мы будем использовать loadtest. Если вы не знакомы с loadtest, то это инструмент для тестирования производительности.

Установка loadtest как root довольна простая:

sudo npm install -g loadtest

$ loadtest -n 100 -k  http://localhost:8000/store/

# result
INFO Requests per second: 55

Как видно из вышеизложенного, 55 запросов обрабатываются за секунду.

Давайте создадим еще один ендпоинт для извлечения данных после кэширования с помощью Redis. Измените файл users/views.py, чтобы в нем был следующий код:

from rest_framework.decorators import api_view
from rest_framework import status
from rest_framework.response import Response
from django.core.cache import cache
from django.conf import settings
from django.core.cache.backends.base import DEFAULT_TIMEOUT

CACHE_TTL = getattr(settings, 'CACHE_TTL', DEFAULT_TIMEOUT)
from .models import Product


# Create your views here.


@api_view(['GET'])
def view_books(request):
    # rest of the code


@api_view(['GET'])
def view_cached_books(request):
    if 'product' in cache:
        # get results from cache
        products = cache.get('product')
        return Response(products, status=status.HTTP_201_CREATED)

    else:
        products = Product.objects.all()
        results = [product.to_json() for product in products]
        # store data in cache
        cache.set(product, results, timeout=CACHE_TTL)
        return Response(results, status=status.HTTP_201_CREATED)

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

Обновите store/urls.py следующим образом.

from django.conf.urls import url
from .views import view_books, view_cached_books


urlpatterns = [
    url(r'^$', view_books),
    url(r'^cache/', view_cached_books),

]

Давайте проведем тесты.

$ loadtest -n 100 -k  http://localhost:8000/store/cache/

# results
INFO Requests per second: 233

В первый раз, когда вы запросите ендпоинт localhost:8000/store/cache, приложение будет запрашивать данные из базы данных и возвращать их, но последующие вызовы на этот URL будут обходить базу данных и делать запрос в кеш, поскольку данные уже доступны будут доступны в нем ,

Заключение

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

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

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