
Discover Redis fundamentals by exploring core data types—keys, strings, hashes, and lists. The course covers prerequisites and hands-on skills for beginners.
Learn Redis keys basics by creating and deleting keys, using dump to inspect serialized values, checking existence, and understanding key naming rules and case sensitivity.
Expire keys with the expire command to automatically delete them after a set time, and move keys between databases using the move command while switching databases with select.
Explore redis keys search with key patterns, using question marks for single characters, asterisks for any length, and square brackets for specific sets, noting case sensitivity.
Discover Redis key expiration with expire and expireat in milliseconds and seconds, and inspect the object command for refcount, encoding, and idle time to understand storage behavior.
Master Redis key management by learning to remove expiry with persist, rename keys (and rename nx), fetch random keys, and check the time remaining for expirations.
Master Redis keys data type by using sorting, limiting results, and retrieving key types. Learn commands to set, expire, dump, restore, scan, and inspect lists, hashes, and other key structures.
Master Redis strings by using set to store and overwrite key values with optional expiration in seconds or milliseconds, and retrieve them with get and getrange.
Learn Redis string commands: fetch multiple keys with mget, set timed values with setex, use setnx for conditional saves, and overwrite parts with setrange.
Learn how to manage Redis string values with set and mset, including conditional msetnx, expiration with milliseconds, and various increments and appends.
Explore Redis hashes by creating and updating fields, retrieving single or all values, deleting fields, and checking existence to manage hash key-value data.
Learn to use Redis hashes for storing and updating fields, including hset, hincrby and hincrbyfloat, retrieving keys and values with hkeys, hvals, and hgetall, and conditional creation with hsetnx.
Master redis lists by using lpush to add items, lpop to remove, and lrange to view ranges; learn lpushx behavior and list existence checks.
Explore Redis lists by using rpush and lpush to add at tail or head, learn behavior for existing vs missing lists, and move items with lpush and lpop.
Explains blocking list operations in Redis, using blpop to block specific connections, remove items from lists, and brpoplpush to block, move, and reinsert items after timeout.
Explore how to manipulate Redis lists using lpush, lrange, lindex, and linsert, including adding, removing, and querying elements, handling empty lists, and index rules.
Master Redis list manipulation with lrem, lset, lrange, and ltrim by removing elements, inserting at indices, and fetching ranges while handling index bounds.
Master intermediate Redis concepts by implementing Redis sets, sorted sets, HyperLogLog, and pub sub, with practical commands and hands-on examples for advancing your database skills.
Explore Redis sets by learning the SADD and SMEMBERS commands, creating sets automatically when a key is missing, and how duplicates and case sensitivity affect added members.
Learn to use zadd to add members with scores to a sorted set, see updates when members already exist, and explore zrange and zcard with examples.
Learn to count and retrieve elements in Redis sorted sets using zcount, zrange, and zcard, applying min and max score ranges and real-world examples.
Explore how Redis sorted sets use zinterstore to intersect multiple sources, store the common elements in a new set, and adjust scores with weights and aggregate max.
Learn how to use Redis sorted sets with zadd and zincrby, view results with zrange and zrevrange, and adjust scores—including floating-point values and decrements.
Master zcount for sorted sets, counting elements between minus or plus min and max with inclusive or exclusive bounds, and learn zrange by lex with lex count on city data.
Explore z range by lex and z rem range by lex, using min and max values to retrieve or remove elements; see practical examples with Lex SK.
Explore Redis sorted sets and master zrank, zrange, and zrange by score to retrieve zero-based ranks and ranges in ascending order, with practical examples of keys and values.
Learn how to use z range by score and z rem range by rank on a Redis sorted set, including range limits, inclusion rules, and practical examples.
Learn to iterate and filter a Redis sorted set with z scan, including start from zero, count, and match patterns, plus z score key member and z range.
Explore Redis sorted sets by retrieving scores with z score for purchase and air, and merging sets with z union store using weights, aggregate max, and z rev range.
Explain z rev range by lex and z range by score in Redis sorted sets, using min and max with brackets and plus/minus, with examples like student key.
Explore Redis sorted set queries by score, including zrange and zrevrange, with inclusive and exclusive ranges, limits, and rank calculations using sample keys like student address and student name.
Learn Redis HyperLogLog to count unique elements efficiently using pfadd, pfcount, and pfmerge, achieving approximate counts with minimal memory.
Explore Redis pub/sub fundamentals, linking publishers and subscribers with channels, using publish, subscribe, and unsubscribe commands; see real-time messaging examples on a database chat app.
Explore Redis advanced topics by mastering transactions, scripting, connections, and server commands, and gain practical experience with commands like watch, exec, eval, ping, auth, and bg save.
Master Redis transactions by using multi, exec, and discard to queue, execute, or drop commands atomically, with serialized execution and all-or-nothing behavior.
Explore Redis server commands such as client set name, client list, client get name, client pause, and client kill to manage connections and inspect command output.
Master advanced Redisai server commands, including command info, config rewrite and set with authentication, db size, reset stat, and debug commands alongside flush all and flush db.
Discover how to use the info command to view Redis server details (server, clients, memory, persistence, stats, replication, key spaces) and explore commands like last save, monitor, and shutdown.
Introduction
Redis Mastery: From Basics to Advanced is a comprehensive course designed to provide learners with an in-depth understanding of Redis, from the fundamental concepts to advanced techniques. This course is perfect for anyone looking to leverage Redis for high-performance data storage and retrieval, whether for personal projects or enterprise-level applications.
Section 1: Redis Training - Beginner Level
In this section, students will be introduced to the basics of Redis, including key concepts and fundamental operations. Topics covered include the basics of Redis keys, values, and data types. Students will learn how to check key existence, manage key spaces, and perform pattern matching. This section also delves into Redis strings and hashes, providing a solid foundation for understanding how data is stored and manipulated in Redis.
Section 2: Redis Training - Intermediate
Building on the foundational knowledge, the intermediate section focuses on more complex Redis data structures and commands. Students will explore Redis sets, sorted sets, and the intricacies of these data structures. They will learn advanced commands, how to handle large datasets efficiently, and the use of Redis for real-time analytics. This section also covers Redis HyperLogLog and Pub/Sub, equipping students with the skills to handle more sophisticated use cases.
Section 3: Redis Training - Advanced Level
The advanced section takes students to the next level with a deep dive into Redis transactions, scripting, and server management. Students will learn about various commands, scripting with Lua, and how to use transactions to ensure data integrity. The section also covers advanced connection handling, server configuration, and optimization techniques to ensure high availability and performance in production environments.
Conclusion
By the end of this course, students will have a comprehensive understanding of Redis and be able to apply their knowledge to build high-performance, scalable applications. They will be proficient in managing Redis instances, optimizing performance, and leveraging advanced features to solve complex problems.