Redis

See how clients, the Redis server, databases, connections, and the event loop fit together. Read the shape of RESP2 and RESP3 messages and trace a command from request to response.

Follow Redis from its origin as a fast key-value server through persistence, clustering, modules, Redis Stack, cloud services, licensing changes, and compatible projects such as Valkey. This history explains why features and deployment choices differ across versions and providers.

Create, inspect, rename, scan, and delete keys without blocking a production server. Establish naming conventions, namespaces, ownership rules, and safe keyspace maintenance practices.

Store text, serialized values, integers, and floating-point counters with Redis strings. Apply conditional writes, ranges, multi-key operations, and atomic increments to practical counters and flags.

Represent records as field-value maps and update individual fields without rewriting the whole object. Compare hashes with serialized strings and use them for profiles, settings, and compact entities.

Use ordered sequences for timelines, bounded histories, stacks, and simple queues. Work with list ranges, blocking operations, and safe element movement between lists.

Model unique membership and relationships with sets. Perform union, intersection, difference, random selection, and membership checks for tags, permissions, and shared interests.

Attach scores to members and maintain ordered indexes, rankings, and priority lists. Build leaderboards and time-ordered collections with range, rank, score, and lexicographical queries.

Give keys finite lifetimes, inspect remaining TTL, and control how updates affect expiration. Apply expiration to sessions, temporary state, cache entries, and lifecycle cleanup.

Store dense boolean state and compact integer fields inside strings. Use bit operations for attendance, feature flags, daily activity, and memory-efficient counters.

Index longitude and latitude, search by radius or bounding box, and calculate distances. Build nearby-place and service-area queries while recognizing Redis geospatial limits.

Estimate cardinality with HyperLogLog and use Bloom, Cuckoo, count-min sketch, and top-k structures where supported. Choose acceptable error rates and memory settings for large-scale counting and membership problems.

Reason about atomic commands, blocking behavior, time complexity, and the cost of large values. Use SCAN instead of unsafe full-keyspace operations, and reduce network round trips with pipelining and batching.

Translate application entities and access patterns into keys and Redis data structures. Design denormalized indexes, manage relationships, estimate memory use, and plan cleanup without relying on relational joins.

Connect an application through a Redis client and configure pooling, timeouts, retries, authentication, and response decoding. Handle connection loss and avoid retrying non-idempotent commands unsafely.

Group commands with MULTI and EXEC, cancel work with DISCARD, and implement optimistic concurrency with WATCH. Identify what Redis transactions guarantee and when scripting is a better choice.

Run multi-step logic atomically on the server with EVAL and Lua. Pass keys safely, control execution time, cache scripts, and replace race-prone client sequences with small scripts.

Package server-side logic as named, versioned Redis Functions. Manage function libraries, execution permissions, replication behavior, and migration from ad hoc Lua scripts.

Deliver transient messages through channels and pattern subscriptions. Design presence, notifications, and invalidation signals while accounting for Pub/Sub’s lack of persistence and delivery guarantees.

Store durable event sequences, read by ID, and coordinate consumers with consumer groups. Handle acknowledgements, pending entries, failed consumers, trimming, and replay in a small event-processing service.

Create point-in-time snapshots, tune save triggers, and inspect RDB files. Evaluate fork overhead, data-loss windows, startup speed, and snapshot use in backups and replication.

Record writes with the append-only file and choose an fsync policy. Manage AOF rewrites, multipart AOF files, recovery, and tradeoffs between durability, latency, and storage.

Account for key, value, allocator, and replication overhead instead of judging only raw payload size. Inspect memory reports, recognize fragmentation, and use compact encodings and sensible value sizes.

Set memory limits and choose no-eviction, LRU, LFU, random, or TTL-based policies. Predict which keys may disappear and align eviction behavior with application correctness.

Use cache-aside, read-through, write-through, write-behind, and refresh-ahead patterns. Prevent stale data, cache stampedes, hot-key overload, penetration, and oversized-value problems.

Reduce repeated reads with local client caches backed by Redis tracking and invalidation messages. Configure RESP3 client-side caching and reason about stale windows, reconnects, and memory limits.

Store authenticated sessions, shopping carts, feature state, and counters with explicit ownership and expiration rules. Address serialization, logout invalidation, privacy, and multi-region consistency.

Coordinate competing workers with SET options, ownership tokens, and safe unlock scripts. Examine leases, fencing tokens, Redlock, clock and pause hazards, and cases where stronger coordination systems are required.

Build fixed-window, sliding-window, token-bucket, and leaky-bucket limiters. Use atomic operations or scripts to enforce limits correctly across many application instances.

Implement delayed work, priorities, retries, acknowledgements, and dead-letter handling with lists, sorted sets, or streams. Make workers idempotent so crashes and duplicate delivery do not corrupt results.

Test commands, scripts, expiration behavior, and failure paths with isolated Redis instances. Add integration tests for reconnects, retries, duplicate messages, partial outages, and persistence recovery.

Configure primary-replica replication and inspect offsets, backlog, and lag. Account for asynchronous data loss, full and partial synchronization, read scaling, and replication-related memory costs.

Use Sentinel to monitor primary-replica groups, elect a leader, and perform automatic failover. Configure quorum, client discovery, network placement, and operational responses to split or failed failovers.

Partition data across hash slots and operate a Redis Cluster with replicas and failover. Work with hash tags, redirects, resharding, node replacement, multi-key limits, and topology-aware clients.

Create users and least-privilege command and key rules with Redis ACLs. Rotate credentials, audit denied operations, and prevent applications from receiving dangerous administrative access.

Protect Redis with private networking, firewalls, TLS, certificate management, and secure bind settings. Build a threat model for exposed ports, untrusted tenants, configuration files, backups, and administrative endpoints.

Use INFO, SLOWLOG, latency tools, command statistics, keyspace metrics, and client lists to diagnose behavior. Build dashboards and alerts for memory pressure, lag, blocked clients, hit rate, evictions, and failed commands.

Measure throughput and latency with redis-benchmark and workload-specific tests. Separate server, network, client, persistence, and data-model bottlenecks, then tune only against representative traffic.

Define recovery point and recovery time goals, create verified backups, and practice restoration. Plan for corrupted persistence files, accidental deletion, failed nodes, lost regions, and cluster-wide recovery.

Run Redis in containers with persistent volumes, health checks, resource limits, and controlled configuration. Avoid common mistakes involving ephemeral storage, memory accounting, signal handling, and unsafe image defaults.

Operate Redis on Kubernetes using StatefulSets or suitable operators, stable identities, persistent volumes, and disruption controls. Plan scheduling, upgrades, failover testing, monitoring, and safe resource limits.

Evaluate managed Redis offerings by topology, durability, compatibility, network design, maintenance behavior, and service limits. Compare operational responsibility, cost, portability, and provider-specific restrictions before committing.

Design geographically distributed Redis deployments where local write latency and continuous availability matter. Compare active-passive replication with Redis Enterprise Active-Active CRDT behavior and resolve conflicts according to each data type’s rules.

Extend Redis with module commands and custom data types, and distinguish core-server capabilities from optional packages or integrated distributions. Check version, licensing, persistence, replication, and cluster compatibility before adopting an extension.

Store, update, and retrieve structured JSON documents with path-based commands. Model nested objects, perform partial updates, and combine JSON with indexing while controlling document size.

Create secondary indexes over hashes and JSON, then run text, numeric, geospatial, aggregation, and faceted queries. Design schemas and query plans with the Redis Query Engine while accounting for indexing cost and eventual indexing behavior.

Store embeddings, create vector indexes, and perform exact or approximate nearest-neighbor searches. Build semantic retrieval and semantic caching workflows, tune distance metrics and index parameters, and measure recall against latency.

Ingest timestamped measurements, apply retention and duplicate policies, and query aggregations over time ranges. Use labels, compaction rules, and downsampling for monitoring, IoT, and operational analytics workloads.

Take a feature from access-pattern discovery through data modeling, capacity estimates, local implementation, testing, security, deployment, monitoring, and recovery planning. Deliver a production-ready Redis-backed service and validate it under load and simulated failures.

Upgrade Redis with compatibility checks, staging tests, backups, rolling procedures, and rollback plans. Migrate among standalone, Sentinel, Cluster, managed services, Redis editions, and compatible servers without assuming identical commands or behavior.

Map Redis skills to application engineering, platform engineering, database operations, site reliability, and data infrastructure roles. Build proof-of-skill projects, choose relevant certifications or provider credentials, read release notes and security advisories, and follow the Redis community and ecosystem.