27 docs tagged with "redis"

Amazon ElastiCache for DVA-C02. Redis vs Memcached comparison, caching strategies (lazy loading, write-through, session store), cluster modes, Multi-AZ, and common exam patterns.

In-depth guide to caching strategies including cache-aside, write-through, write-behind, eviction policies, cache stampede prevention, hotkeys, Redis data structures, and multi-level caching.

A comprehensive guide to preventing duplicate message processing across Kafka, Kafka Streams, RabbitMQ, SQS, and Redis — covering EOS internals, Kafka Streams State Store vs Redis architecture, idempotent consumers, and production deduplication patterns for senior engineers.

Implementation of Distributed Locks using Redis, Redisson, and the Redlock algorithm for senior engineers.

Deep dive into high-concurrency inventory reservation architectures — why Redis dual-writes cause overselling and underselling, how MySQL 8 SKIP LOCKED eliminates row contention, and how Shopify scaled to $5.1M GMV/minute during Black Friday.

Master guide to multi-device JWT authentication, isolated single-device logout, global session eviction, password updates, account locking, and token theft containment.

From first principles to production — key-value, document, wide-column, and graph databases with deep dives into MongoDB and Cassandra for Java/Spring engineers.

Exhaustive analysis of the 5 lock types: version column, SELECT FOR UPDATE, advisory locks, lock columns, and Redis locks; physical lifespans, failure modes, and why optimistic retry storms crush high-contention ticketing systems.

A comprehensive guide to proximity search and geospatial indexing — covering spatial trees, encoded key indexes, production Java/Spring implementation, and senior deep dives on trade-offs and failure modes.

A complete guide to rate limiting — from beginner fundamentals to senior-level distributed design. Covers all algorithms, Redis implementations, decision frameworks, failure modes, and production patterns.

A senior deep dive into Redis advanced data types — Bitmaps, HyperLogLog, Geospatial, Streams, Sorted Sets, and Bloom Filters — with internals, memory math, production patterns, and when to use each.

Distributed caching patterns with Redis — cache-aside, write-through, write-behind, read-through — and production concerns like stampede, warming, invalidation, and Spring Cache integration.

Redis as a primary in-memory database — persistence mechanisms (RDB, AOF), durability guarantees, data modeling patterns, and when to use Redis as your primary store vs cache.

Redis replication mechanics, Sentinel for HA failover, Redis Cluster sharding, and production deployment patterns for senior engineers.

Complete guide to Redis data types — Strings, Hashes, Lists, Sets, Sorted Sets, Bitmaps, HyperLogLog, Geospatial, and Streams — with senior-level use cases and encoding internals.

Comprehensive guide to Redis maxmemory algorithms (LRU, LFU, Random) and how Redis approximates caching algorithms at scale for senior engineers.

Senior-level Redis interview questions covering data structures, persistence, clustering, cache patterns, distributed systems, and production failure scenarios.

Deep dive into Redis Lua script execution: solving data corruption between batch imports and point updates, production-grade distributed lock release, Redis TIME as a monotonic cluster clock, cooperative pod handovers, and the network RTT math.

Advanced Redis patterns — distributed locking, rate limiting, session management, leaderboards, search, and production performance tuning for senior engineers.

Deep dive into Redis pipelining for throughput optimization, MULTI/EXEC transactions, optimistic locking with WATCH, and atomic Lua scripting — with production patterns and pitfalls.

Redis Pub/Sub messaging — channels, patterns, fire-and-forget semantics, delivery guarantees, and production comparison with Redis Streams.

Complete guide to Redis Streams — append-only logs, consumer groups, message acknowledgement, and comparison with Kafka for senior engineers.

Redis TTL mechanics, expiry policies (lazy vs active), memory eviction strategies (LRU, LFU, volatile, allkeys), and senior-level memory management patterns.

Redis architecture internals, single-threaded model, I/O multiplexing, and use case decision guide for senior engineers.

Strategies for handling high read QPS including caching layers, read replicas, CDN, CQRS, and database indexing. Covers Redis patterns, cache invalidation, consistency models, fan-out strategies, and senior-level deep dives into coherence, hot keys, and tail latency.

Managing distributed sessions with Redis and Spring Session, including security best practices and programmatic control.

Deep dive into distributed counting and ranking architectures — hot-key mitigation, sharded counters, CRDT PN-Counters, HyperLogLog, and Redis Sorted Set (ZSET) skiplist leaderboards with tie-breaking bit-packing.