Tag: redis

Protect APIs from abuse and ensure fair resource usage with token bucket, sliding window, and leaky bucket rate limiting.

Protect APIs from abuse using token bucket and sliding window algorithms with Redis, including burst handling, distributed coordination, and custom headers for client feedback

Implement token bucket rate limiting in Flask and FastAPI with Redis support

Cache expensive database query results in Redis with cache-aside pattern, TTL management, and invalidation on writes for Python applications.

Apply Spring's @Cacheable, @CachePut, and @CacheEvict annotations with a Redis cache manager for declarative caching in Java applications.

Implement a two-level cache combining in-memory L1 and Redis L2 for low-latency reads with cross-instance consistency

Invalidate Redis cache entries in Node.js with TTL expiry, explicit deletion, pattern-based clearing, and pub/sub-based distributed invalidation.

Use Django's built-in cache framework with per-view caching, template fragment caching, and low-level cache API for database query optimization.

Build a Python decorator that caches function return values in Redis with configurable TTL, key generation, and cache invalidation

Use the cache-aside pattern to read and write data through Redis, handling cache misses, stale reads, and write-through invalidation

Implement distributed locks with Redis for mutual exclusion across processes, using SET NX with TTL and the Redlock algorithm for reliability

Use Redis pub/sub channels to broadcast events between processes, handle subscriptions, and implement real-time notifications

Implement a distributed token bucket rate limiter using Redis atomic operations for API throttling across multiple server instances

Use Redis sorted sets to implement real-time leaderboards with rank tracking, score updates, and top-N queries in O(log N) time

How to connect to Redis and perform basic operations in Python, JavaScript, and Java.

Cache API responses in Node.js with Redis using cache-aside and TTL patterns

How to implement cache-aside, write-through, and write-behind patterns with Redis to reduce database load and improve response times

Set up Celery with Redis broker for distributed task processing including task chaining, groups, chords, retry strategies, scheduled tasks with Celery Beat, and result backends.

Build real-time pub/sub messaging with Redis and Python including pattern subscriptions, message serialization, connection pooling, and broadcast patterns for microservices.

Implement useful caching strategies for databases, APIs, and frontends using Redis, CDNs, and browser caches.

Implement distributed rate limiting in FastAPI using Redis sliding window and token bucket algorithms with per-user, per-IP, and per-endpoint limits

Load data into the cache on demand from the backing store. A caching pattern that gives the application full control over what and when to cache.

Strategies for keeping cached data fresh: TTL expiration, explicit invalidation, write-through, and event-driven cache eviction.

Prevent thundering herd cache misses with locks, single-flight, and early refresh strategies to protect the database from concurrent reloads.

Coordinate mutually exclusive access to shared resources across distributed nodes using a consensus-based lock service, preventing race conditions in scaled-out systems.

A transparent cache layer that intercepts read requests, fetches from the data source on miss, and populates the cache automatically.

Proactively refresh cache entries before they expire to eliminate cache misses on hot keys and maintain consistent read latency.

Combine an L1 in-memory cache with an L2 distributed cache to reduce latency for hot keys while maintaining cache consistency across instances.

Write to cache synchronously and persist to the database asynchronously for high-throughput write workloads with eventual consistency.

Synchronously write to both cache and backing store so the cache always has the latest data without TTL-based invalidation.

Template for documenting cache eviction rules per cache layer: LRU, LFU, TTL, FIFO, random eviction. Includes policy selection matrix, per-layer configuration, memory limits, and monitoring rules with code examples.

Decision template for choosing cache strategies per use case: no-cache, cache-aside, read-through, write-through, write-back, and refresh-ahead. Includes decision matrix, TTL guidelines, invalidation rules, and code examples.

Runbook for warming caches after deployment, restart, or incident: identify hot keys, preload strategies, progressive warmup, health checks, and rollback procedures with code examples and automation scripts.

Master Redis caching with cache-aside, read-through, write-through, write-behind, and refresh-ahead patterns. Covers eviction policies, TTL tuning, serialization, and production operations.

A practical guide to caching strategies: browser caching, CDN edge caching, application caching with Redis, and database query caching. Learn when to use each and how to avoid cache invalidation nightmares.

Run Redis in production. Covers persistence (RDB, AOF), clustering, sentinel for HA, failover handling, memory management, eviction policies, pipelining, Lua scripting, monitoring, security hardening, and backup strategies with practical examples.

A practical guide to choosing the right NoSQL database. Compare document, key-value, wide-column, and graph stores with selection criteria and migration tips.

A practical guide to NoSQL data modeling: embedding vs referencing, access pattern-driven design, and patterns for MongoDB, DynamoDB, Cassandra, and Redis.