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

Почему кэширование имеет значение в полных приложениях стека

• Что такое Redis? Простой обзор
• Как работает Redis за кулисами
• Когда вы должны использовать Redis?
• Общие варианты использования кэширования Redis
• Настройка Redis: Quick Start Guide
• Как подключить Redis к вашему приложению
  • Фронтальная интеграция
  • Бэкэнд интеграция
• Шаблоны кэширования с Redis
  • Кэш-АСДАЙСКИЙ ОПЕРАТ
  • Программа записи
  • Написать-и-бейдж
• Обработка кеша срок годности и недействительность
• Измерение производительности кэша

Почему кэширование имеет значение в полных приложениях стека

Большинство полных приложений стека полагаются на базу данных. Это означает, что каждый раз, когда пользователь нажимает, прокручивает или загружает страницу - ваше приложение создает запрос базы данных. Но вот проблема: базы данных медленны по сравнению с хранением в памяти. Каждый запрос базы данных добавляет миллисекунд (иногда секунды) во время ответа вашего приложения.

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

Кэширование решает это.

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

Результат: → более быстрое время загрузки → меньше загрузки базы данных → счастливые пользователи → более масштабируемое приложение

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

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

Вот почему кэширование имеет значение в полных приложениях стека.

Что такое Redis? Простой обзор

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

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

Первоначально он был построен, чтобы быть магазином ключей (подумайте о словаре или карте). Но сегодня Redis может справиться с гораздо большим: → Strings→ Списки → Наборы → Хэши → Сортированные наборы → потоки → Геопространственные данные

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

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

Но помните: → Данные в Redis обычно не являются постоянными (если вы не настраиваете их на то, чтобы быть). → Он предназначен для дополнения вашей основной базы данных, а не заменить ее.

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

Как работает Redis за кулисами

На первый взгляд, Redis выглядит как база данных. Но под капюшоном все по -другому.

Большинство баз данных хранят данные на диске. Когда вы запускаете запрос, они читают с диска, который требует времени. Redis быстрее, потому что он хранит данные полностью в памяти (RAM). Доступ к оперативной памяти в тысячи раз быстрее, чем доступ к диску.

Когда вы устанавливаете ключ в Redis, он живет в памяти.

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

Он поддерживает многие структуры данных:→ Строки → Списки → Наборы → Сортированные наборы → хэши → растровые карты → потоки → Гиперлог.

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

Другая ключевая деталь: Redis однопоточный, но очень быстрый. Он использует цикл событий для обработки одной команды за раз, избегая сложности замков резьбы и условий гонки.

Для настойчивости Redis предлагает варианты: → снимки (RDB) - сохраняет набор данных на диск с интервалами. → Файл только для приложения (AOF)-регистрирует каждую операцию записи, чтобы набор данных можно было восстановить.

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

Короче говоря, Redis работает так:

• Клиент отправляет команду
• Redis обрабатывает его в оперативной памяти
• При желании записывает изменения в диск для долговечности
• Возвращает результат мгновенно

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

Когда вы должны использовать Redis?

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

Ключ - это знать, когда его использовать.

Вот несколько простых сигналов:

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

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

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

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

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

Но будьте осторожны - не все кэшируйте. Используйте Redis, когда:

→ Данные читают часто, но изменяются редко → Данные дорого в расчета или извлекать → Вы можете переносить слегка устаревшие данные (поскольку кэши могут быть немного не синхронизированы с базой данных)

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

Короче говоря: используйте Redis, когда оно ускоряет ваше приложение, не нарушая точность ваших данных.

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

Не все в вашем приложении нуждается в кэшировании. Но некоторые вещи извлекают выгоду из этого.

Вот наиболее распространенные способы, которыми команды используют Redis для кэширования:

1. Ускорение запросов базы данных

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

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

2. Кэширование ответов API

Иногда ваше приложение зависит от сторонних API. Проблема? Они могут быть медленными или ограниченными.

Решение: кэшируйте ответы API в Redis. Если пользователь снова запрашивает тот же прогноз погоды или валютную скорость, подайте его из кэша, а не от API.

3. Сессия хранения

Пользовательские сеансы (логины, предпочтения) часто доступны. Хранение их в Redis имеет смысл.

Почему?

• Редис быстр.
• Redis поддерживает TTL (Time-To-Live), что облегчает истечение сессии.
• Многие веб-фреймворки поддерживают сеансы Redis, вылеченные из коробки.

4. Таблицы лидеров и счетчики

Создание таблицы лидеров для игры? Отслеживание сообщений лайков или подсчетов просмотра? Реджис сияет здесь.

Он поддерживает простые операции, такие как приращение и уменьшение. Это делает его идеальным для: → лидеров в реальном времени → вроде кнопок → Счетчики просмотра

5. Полная страница или частичная кэширование страницы

Для приложений с тяжелыми контентами (блоги, новости, электронная коммерция), рендеринг полных страниц требует времени.

Хитрость: кэшируйте всю страницу (или ее части) в Redis. В следующий раз, когда кто -то посетит, мгновенно подайте кэшированную версию.

6. Очереди и ограничение ставок

Redis не только для кэширования данных - он может помочь управлять трафиком.

Пример вариантов использования:

• Предотвращение действий по спамству (ограничение скорости)
• Оставка простых очередей задач

Его быстрый природа в памяти делает Redis отличным для этих сценариев.

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

Вот раздел, написанный в стиле и тоне предоставленных примеров - чистый, простой, человеческий, без пуха:

Настройка Redis: Quick Start Guide

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

Вот простой путь, чтобы начать.

1. Установите Redis

Если вы находитесь на Mac:

brew install redis

Если вы на Linux (Ubuntu):

sudo apt update

sudo apt install redis-server

Если вы находитесь в Windows: Windows официально не поддерживает Redis.

Но вы можете использовать Redis Inside WSL (подсистема Windows для Linux) или использовать контейнер:

docker run --name redis -p 6379:6379 -d redis

2. Запустить сервер Redis

После установки запуск Redis прост:

redis-server

Вы должны увидеть журналы, показывающие, что Redis готов принять соединения в порту 6379 (по умолчанию).

3. Тестируйте Redis локально

Откройте еще одно окно терминала и запустите:

redis-cli

Теперь вы находитесь в инструменте командной строки Redis. Попробуйте простой тест:

set mykey "Hello Redis"

get mykey

Если вы видите Hello Redis, ваш экземпляр Redis работает.

4. Подключите ваше приложение к Redis

Теперь, когда Redis работает, вы можете подключить свое приложение. Вот пример в node.js с использованием популярногоioredisбиблиотека:

const Redis = require('ioredis'); const redis = new Redis();

redis.set('greeting', 'Hello World'); redis.get('greeting').then(result => { console.log(result); // Hello World });

Вот и все - вы кэшируете с Redis.

Ключевой вынос:

Не задумывайтесь от установки. Начните с малого. Запустите Redis на местном уровне первым. Подключите ваше приложение. Затем уточните по мере роста ваших потребностей.

Вот технический раздел постов в блоге, написанный в стиле и тоне предоставленной подсказки-простых, дружелюбных, ясных и структурированных (без пуха, без причудливых слов):

Как подключить Redis к вашему приложению

Добавить REDIS в ваше приложение проще, чем вы думаете.

Вам не нужно быть экспертом в базах данных или кэшировании.

Вам просто нужно знать, где его подключить.

Давайте пройдемся через как подключить Redis как к вашему бэкэнд, так и к вашему фронте.

Фронтальная интеграция

Вот первое, что нужно понять:

Frontends не подключается непосредственно с Redis.

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

Если вы откроете его, вы рискуете проблемы безопасности и сломанное приложение.

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

Простой поток выглядит так:

Frontend → API Call → Backend → Redis Cache → Backend → Frontend

Пример:

• Пользователь открывает страницу.
• Frontend отправляет запрос на ваш бэкэнд.
• Бэкэнд сначала проверяет Redis: → Если данные кэшируются, верните его быстро. → Если нет, получите его из базы данных, храните его в Redis, затем верните его.

Что это значит для вашего кода фронта: ничего не меняется. Вы по -прежнему используете Fetch или своего любимого клиента API (Axios и т. Д.), Чтобы сделать вызовы API.

Магия происходит на стороне сервера.

Бэкэнд интеграция

Здесь вы на самом деле подключаете Redis.

Вам нужно:

1. Сервер Redis (локальный или облачный, например, Redis Cloud или AWS Elasticache).
2. Клиентская библиотека Redis для вашего бэкэнда.

Допустим, ваш бэкэнд находится в node.js (очень распространенный для приложений для полного стека).

Вы бы использовали клиентскую библиотеку Redis, такую ​​как ioredis или Redis.

Вот простой пример с использованием Redis:

// install the client first:
// npm install redis

const redis = require('redis');

const client = redis.createClient({
    url: 'redis://localhost:6379'
});

client.on('error', (err) => console.log('Redis Client Error', err));

(async () => {
    await client.connect();

    // set a cache value
    await client.set('key', 'value');

    // get a cache value
    const value = await client.get('key');
    console.log(value); // 'value'
})();

Вот и все. Теперь ваш бэкэнд может:

• Кэш API ответы
• Кэш вычислял результаты
• Кэш Пользовательские сеансы
• И еще

Общий поток в маршруте:

app.get('/products', async (req, res) => { const cacheKey = 'products';

const cached = await client.get(cacheKey);
if (cached) {
    return res.send(JSON.parse(cached));
}

// If not cached, fetch from DB
const products = await db.queryProducts();

// Store in Redis for next time
await client.set(cacheKey, JSON.stringify(products), { EX: 60 }); // cache for 60 seconds

res.send(products);

});

Краткое содержание:

• Фронтальный разговоры только с бэкэнд.
• Бэкэнд подключается к Redis, кэширует правильные данные.
• Вы получаете более быстрые ответы и более плавное приложение.

Шаблоны кэширования с Redis

Кэширование может чувствовать себя сложно. Это не должно быть.

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

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

Давайте разберем 3 общих:

Кэш-АСДАЙСКИЙ ОПЕРАТ

Думайте об этом как о ленивом кэшировании.

Ваше приложение сначала спрашивает кэш: → Если данные в Redis, обслуживайте его.

→ Если нет, то есть из базы данных → сохранить его в Redis → Обслуживать его.

Этот шаблон работает хорошо, когда:

• Обновления данных редко.
• Вы хотите контролировать то, что кэшируется.
• Память ограничена.

Пример потока:

1. Пользователь запрашивает страницу продукта.
2. Приложение проверяет Redis.
3. Если у Redis это есть → сделано.
4. Если нет → Приложения Запрос базы данных → хранилище приводит к Redis → Возвращает ответ.

Ключевой вывод: кеш заполняется только по требованию.

Программа записи

Это более активно.

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

Почему? Таким образом, ваш кэш всегда синхронизируется с базой данных.

Когда использовать это:

• Когда чтение очень часто.
• Если вы хотите получить доступ к самым последним данным с низкой задержкой.

Пример потока:

1. Пользовательские обновления информации профиля.
2. Приложение записывает в базу данных и Redis одновременно.
3. Позже, чтения тянутся прямо из Redis.

Ключевой вывод: кэш всегда обновляется с каждой записи.

Написать-и-бейдж

Также называется кэширование записи.

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

Затем REDIS выбирает обновления базы данных позже.

Когда использовать это:

• Когда вам нужны быстрые записи (системы с трудом записи).
• Когда ваша база данных не может обрабатывать высокий объем записи в режиме реального времени.

Пример потока:

1. Пользователь представляет много быстрых транзакций.
2. Приложение пишет их Redis.
3. Redis обрабатывает отправку пакетных обновлений в базу данных асинхронно.

Ключевой вывод: Fast пишет сейчас → База данных догоняет позже. Но: вы должны справиться с рисками - что, если Redis вылетит перед написанием в базу данных?

Краткое содержание

→ Кэш-Айд: заполненный кэш только при необходимости.

→ Through: обновление кэша + дБ одновременно.

→ Write-behind: сначала напишите в кеш, DB позже.

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

Вот технический раздел постов в блоге о сроке срока действия кэша и признаком.

👉 Простые слова

👉 Соблюдение человека

👉 Структурированный, без пуха

👉 Нет спам -слов или громких слов

Обработка кеша срок годности и недействительность

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

Что такое срок действия кэша?

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

Когда вы сохраняете данные в Redis, вы можете установить TTL (время для жизни). Это говорит Redis: «Держите эти данные в течение X секунды, затем удалите их».

Пример:

Установите пользователь: 123 Profile_Data Ex 3600

Это хранит профиль пользователя в течение 1 часа (3600 секунд). После этого Redis удаляет его автоматически.

Почему это полезно? → Вы не хотите служить старым данным вечно. → TTL гарантирует, что ваш кэш остается свежим.

Когда вы должны установить истечение?

• Для данных, которые часто меняются → всегда устанавливайте короткий TTL
• Для полустатических данных → более длинные работы TTL
• Для постоянных данных → Нет TTL (но будьте осторожны!)

Совет: ошибки на стороне более коротких TTL, если не уверены.

Что такое недействительность кэша?

Иногда вы не можете дождаться истечения срока действия. Если ваши данные изменяются - вам нужно сразу удалить старый кэш. Это называется недействительным кеша.

Пример:

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

Вы можете сделать это легко:

Del User: 123 Profile_Data

Теперь, когда приложение снова принесет этого пользователя → оно принесет свежие данные из базы данных и обновляет кэш.

Когда вы должны смириться?

• Когда данные изменяются из -за действия пользователя (редактировать, удалить)
• Когда обновления данных из внешнего источника
• В любом случае, где старый кеш может вызвать ошибки

Паттерны для объединения истечения срока действия + недействительность

1. Используйте TTL для пассивной свежести → Данные данные автоматически.
2. Недействительность на ключевых действиях → сохраняет пользовательский опыт правильным после обновлений.

В сочетании эти два подхода дают вам быструю и безопасную стратегию кэширования.

Общие ловушки

• Забудьте о признании невидаемой → приводит к устаревшим ошибкам данных
• Установка TTL слишком долго → устаревшие данные снова
• Установка TTL слишком коротко → Слишком много пропусков кэша → замедлить приложение

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

Окончательная мысль

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

Вот технический раздел постов в блоге для «Измерения производительности кеша», написанный в стиле тона и структуры ваших приведенных примеров (простые, ясные, без пуха):

Измерение производительности кэша

Легко добавить кэширование. Труднее узнать, на самом деле это помогает.

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

Вот простой способ подумать об этом:

Вы заботитесь о двух вещах:

• Коэффициент хит → Как часто ваше приложение получает данные из кэша
• Задержка → Как быстро кэш возвращает эти данные

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

1. Коэффициент попадания: ваш метрика № 1

Коэффициент попадания - это % запросов, обслуживаемых Redis vs. вашей базы данных.

Формула проста:

Коэффициент хит = (кеш

→ Коэффициент попадания в 80% -90% является отличной целью для большинства приложений. → Если вы видите <50%, ваш кэш не очень помогает - вы можете кэшировать неправильные вещи.

Большинство клиентов Redis разоблачают это с такими командами:

Информационная статистика

Искать:

keyspace_hits keypace_misses

Затем рассчитайте свой коэффициент попадания.

2. Задержка: Как быстро достаточно быстро?

Кэш должен быть намного быстрее, чем ваша база данных. Если ответы Redis медленные, ваше приложение ничего не получает.

Цель:

• Задержка <1 мс внутри того же центра обработки данных
• <5 мс при использовании redis по сети

Вы можете измерить это с помощью инструментов, таких как:

• Redis Monitor Command
• Время уровня приложения (запись запроса redis)

Если задержка растет:

• Проверьте расстояние сети
• Проверьте использование памяти Redis
• Подумайте о переходе в Redis Cluster или Redis Cloud

3. Размер кэша и использование памяти

Это также ключ к знанию:

• Сколько предметов вы кэшируете
• Сколько памяти Redis использует

Бегать:

Информационная память

Смотрите настройки used_memory и maxmemory. Если вы превышаете память, Redis начнет выселение клавиш, что может снизить коэффициент попадания.

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

• Отслеживайте свой коэффициент хита
• Отслеживать свою задержку
• Мониторинг использования памяти

Не догадайся - измерение. Вот как вы знаете, что ваш кэш Redis - это вес.