Mateusz Przybyła

Czym Redis nie jest

Redis nie jest klasyczną bazą danych, taką jak PostgreSQL czy MySQL, w których dane przechowywane są trwale na dysku.

Jest to baza danych działająca głównie w pamięci RAM (tzw. in-memory database), dzięki czemu operacje na danych są bardzo szybkie. Redis wykorzystuje model klucz-wartość, w którym dane są powiązane z unikalnymi kluczami, co umożliwia ich błyskawiczne wyszukiwanie.

Warto jednak pamiętać, że Redis oferuje również bardziej zaawansowane struktury danych, takie jak listy, zbiory czy hashe, dzięki czemu może być wykorzystywany w wielu scenariuszach backendowych.

W praktyce Redis jest często wykorzystywany jako element infrastruktury wspierający aplikację backendową. Poniżej przedstawiam kilka realnych zastosowań, z którymi można spotkać się w projektach.

Jak uruchomić Redis lokalnie?

Najprostszym sposobem uruchomienia Redis lokalnie jest użycie Dockera.

Utwórz plik docker-compose.yml z poniższą konfiguracją:

services:
  redis:
    image: redis:7
    ports:
      - "6379:6379"
Code language: YAML (yaml)

Następnie uruchom serwis poleceniem:

docker compose up -d

Po uruchomieniu Redis będzie dostępny lokalnie pod adresem:

localhost:6379Code language: CSS (css)

Use case #1 – JWT Blocklist

Tokeny JWT są stateless, co oznacza, że serwer nie przechowuje ich w bazie danych. Dzięki temu uwierzytelnianie jest szybkie i skalowalne, ale pojawia się problem – w jaki sposób unieważnić token przed jego naturalnym wygaśnięciem, na przykład po wylogowaniu użytkownika.

Jednym z rozwiązań jest wykorzystanie Redis jako tzw. blocklisty. Podczas wylogowania identyfikator tokenu (jti) zostaje zapisany w Redisie. Przy każdym żądaniu aplikacja sprawdza, czy dany identyfikator znajduje się na liście zablokowanych tokenów.

Klucz w Redisie otrzymuje czas życia (TTL) równy pozostałemu czasowi ważności tokenu. Dzięki temu wpis zostanie automatycznie usunięty po wygaśnięciu tokenu, co zapobiega niepotrzebnemu zajmowaniu pamięci.

Baza in-memory sprawdza się w tym scenariuszu bardzo dobrze ze względu na bardzo szybkie operacje odczytu oraz możliwość ustawiania czasu życia kluczy.

import redis

redis_client = redis.from_url("redis://localhost:6379")

def add_jti_to_blocklist(jti: str, expires_in: int) -> None:
    redis_client.setex(f"blocklist:{jti}", expires_in, "true")

def is_jti_blocked(jti: str) -> bool:
    return redis_client.exists(f"blocklist:{jti}") == 1
Code language: Python (python)

Use case #2 – Rate limiting

Bardzo często podczas tworzenia REST API pojawia się potrzeba ograniczenia liczby żądań, jakie użytkownik może wykonać w określonym przedziale czasowym. Mechanizm ten nazywany jest rate limiting.

Redis sprawdza się w tym scenariuszu szczególnie dobrze, ponieważ udostępnia proste operacje na licznikach. Za pomocą polecenia INCR możemy zwiększać licznik żądań dla danego użytkownika, natomiast EXPIRE pozwala ustawić czas życia klucza, który określa długość okna czasowego.

Dzięki temu Redis może przechowywać informację o liczbie wykonanych żądań, a po upływie zadanego czasu licznik zostanie automatycznie zresetowany. Poniższy przykład pokazuje prostą implementację rate limiting z wykorzystaniem tych mechanizmów.

import redis

redis_client = redis.from_url("redis://localhost:6379")

def is_rate_limited(user_id: str, limit: int, window: int) -> bool:
    key = f"rate_limit:{user_id}"
    current = redis_client.incr(key)

    if current == 1:
        redis_client.expire(key, window)

    return current > limit
Code language: Python (python)

Use case #3 – Kolejki i zadania w tle (RQ)

W wielu aplikacjach backendowych potrzebujemy przetwarzać zadania w tle, np. wysyłanie maili, generowanie raportów czy przetwarzanie dużych danych.

Zamiast blokować użytkownika w REST API, możemy użyć kolejek zadań. Redis świetnie się do tego nadaje, ponieważ działa w pamięci RAM i oferuje bardzo szybkie operacje zapisu i odczytu danych. Dzięki temu dodawanie i pobieranie zadań z kolejki jest praktycznie natychmiastowe.

W tym przykładzie użyjemy RQ (Redis Queue) – prostej biblioteki do kolejek w Pythonie.

# tasks.py
def send_email(to: str):
    print(f"Sending email to {to}")
Code language: Python (python)

# enqueue_job.py
import redis
from rq import Queue
from tasks import send_email

redis_client = redis.from_url("redis://redis:6379")
queue = Queue("emails", connection=redis_client)

job = queue.enqueue(send_email, "user@example.com")
print(f"Job queued: {job.id}")
Code language: Python (python)

# email_worker.py
import redis
from rq import Worker, Queue
from tasks import send_email

redis_client = redis.from_url("redis://redis:6379")
queue = Queue("emails", connection=redis_client)

worker = Worker([queue], connection=redis_client)
worker.work()
Code language: Python (python)

enqueue_job.py → Redis → Worker → wykonanie zadaniaCode language: CSS (css)

Use case #4 – Cache aplikacyjny

Ten system bardzo często wykorzystywany jest jako cache aplikacyjny, który przechowuje często odczytywane dane w pamięci RAM. Dzięki temu możemy ograniczyć liczbę zapytań do głównej bazy danych i znacząco przyspieszyć działanie aplikacji.

W tym przykładzie zastosujemy popularny wzorzec cache-aside.
Aplikacja najpierw próbuje odczytać dane z Redis, a jeśli ich tam nie ma, pobiera je z bazy danych i zapisuje w cache na określony czas.

import json
import redis

redis_client = redis.from_url("redis://localhost:6379")

def get_user(user_id: int):
    cached = redis_client.get(f"user:{user_id}")
    if cached:
        return json.loads(cached)

    user = fetch_user_from_db(user_id)
    redis_client.setex(f"user:{user_id}", 60, json.dumps(user))
    return user

def fetch_user_from_db(user_id: int):
    # symulacja kosztownego zapytania do bazy
    return {
        "id": user_id,
        "name": f"User{user_id}",
        "email": f"user{user_id}@example.com"
    }
Code language: Python (python)

Podsumowanie

Redis jest niezwykle wszechstronnym narzędziem, które może pełnić w systemach backendowych wiele różnych ról. W artykule pokazaliśmy kilka praktycznych zastosowań: przechowywanie blocklisty tokenów JWT, implementację rate limitingu, obsługę kolejek zadań w tle oraz cache aplikacyjny.

Dzięki pracy w pamięci RAM Redis oferuje bardzo szybkie operacje odczytu i zapisu, co sprawia, że świetnie sprawdza się jako element infrastruktury wspierający aplikacje backendowe.

W praktycznych systemach Redis rzadko zastępuje główną bazę danych – znacznie częściej działa jako uzupełnienie architektury, przyspieszając działanie aplikacji i odciążając inne komponenty systemu.