CF

Redis: The Complete Developer's Guide

15h 32m 52s
English
Paid

Redis: The Complete Developer's Guide is a 175-lesson 15 hours 32 minutes self-paced course by Stephen Grider, Udemy. In a world with hundreds of different databases, one database rises to rule them all.

Course facts

Lessons
175
Duration
15 hours 32 minutes
Level
All levels
Language
English
Updated
Instructor
Stephen Grider, Udemy
Price
Premium

In a world with hundreds of different databases, one database rises to rule them all. 

Redis is an in-memory database known for its speed and simplicity.  Originally used only for simple caching, its feature set has expanded to be one of the most versatile databases around. 

  • This course will teach you everything you need to know to integrate Redis into a new or existing project.

    • Get hands-on experience with commands used to add, update, and query data

    • Apply best practices and numerous design patterns by adding Redis to an E-Commerce app

    • Understand and extend the internals of Redis by using modules and scripts

    • Go beyond Redis with a deep look at fundamental concurrency issues and solutions

  • Data structures form the heart of Redis.  Rather than hiding functionality behind complex abstractions, Redis exposes several powerful data structures that developers use to store and query data.  Learning about these different data structures is the key to mastering Redis.  This course focuses on making sure that you understand the difference between a sorted set and a hash.  After completing this course, you'll understand when to use each structure and the benefits and drawbacks to each.  Don't have a background in algorithms or data structures?  That's OK!  Everything in this course assumes you have no prior knowledge.

    Almost all top companies around the world use Redis.  Twitter, GitHub, Snapchat, Craigslist, StackOverflow - they all use Redis!  Nearly every major web product you use on a daily basis utilizes Redis behind the scenes.  And its not just large companies that use Redis - small startups do as well. 

    To understand Redis, you must use Redis.  Just memorizing commands isn't enough.  You need to get your hands dirty!  With that in mind, you'll work through many exercises and quizzes.  In addition, throughout this entire course you will build a large E-Commerce application using Redis.  Don't worry - you won't need to write any frontend code.  As we learn new topics in Redis, we will add new features to our E-Commerce app.  You'll get to see why and when we use each major feature of Redis.

    Built-in cheatsheets.  Many resources about Redis show running commands in a terminal window.  This approach makes it hard to remember even the most basic commands.  In this course, you'll take a different approach.  I built a standalone webapp called RBook just for you to use in this course.  This app allows you to run commands against your own Redis instance and document them at the same time, making it easy for you to refer back to your notes in the future.  Of course, you don't have to use RBook if you don't want to!

    Effective learning. Everything in this course is designed to make your learning process as easy as possible.

    • At every step, I will teach you what Redis is doing internally, and help you understand how to twist and bend Redis to better suit your application's needs.

    • Every single video in the course has an attached ZIP file containing up-to-date code, just in case you ever get stuck.

    • Full-time teaching assistants are standing by to help answer your questions.

    • Access to a private live chat server is included. Live help whenever you need it!

  • Soooo much more.  Here's a partial of some of the things you will do in this course:

    • Write basic commands to store, update, and query data

    • Practice your skills with exercises and quizzes

    • Use almost every major feature of Redis to build an E-Commerce app

    • Enforce data constraints using sets, sorted sets, and lists

    • Understand when to use each of Redis's major data structures

    • Apply numerous design patterns to integrate Redis into an existing codebase

    • Securely deploy a Redis instance using AWS, GCP, or Azure through Redis Cloud

    • Collect stats and metrics sourced from a live API

    • Communicate between different servers using Streams

    • Master the concept of transactions to safely store data

    • Implement a standard locking algorithm to solve concurrency issues

  • Redis is known for being simple, but it is still hard to learn. You're given a huge toolbox with tons of features, but no clear guidance on when to use each feature.  This course aims to give you direction.  You'll understand why each feature exists, and when to use them in real apps.  You will find learning Redis a delightful experience and pick up a tremendous amount of knowledge along the way.

    Sign up today and join me in mastering Redis!

Who teaches Redis: The Complete Developer's Guide?

Stephen Grider

Stephen Grider thumbnail

Stephen Grider is one of the longest-running and most prolific instructors on Udemy, with a catalog covering essentially every major JavaScript framework, plus Docker, Kubernetes, AWS, and the broader full-stack development landscape. His teaching style is patient and project-oriented — most of his courses are structured around building a substantial application from scratch rather than working through disconnected tutorial examples.

The catalog covers React, Redux, Next.js, Vue, Angular, GraphQL, Node.js, Docker / Kubernetes, AWS infrastructure, React Native and Flutter for mobile, the algorithm / data-structure interview prep track, and the modern TypeScript / Bun / Rust adjacent material that working JavaScript developers increasingly encounter. Few independent instructors have maintained Stephen's breadth this consistently for this long.

The CourseFlix listing under this source carries over 25 Stephen Grider courses spanning that range. Material is paid; Stephen Grider courses are typically sold individually on Udemy. Courses are aimed primarily at developers picking up a specific technology through working through a complete project.

Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

What lessons are included in Redis: The Complete Developer's Guide?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 175 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1.1. Hello and Welcome!
All Course Lessons (175)
#Lesson TitleDurationAccess
1
1.1. Hello and Welcome! Demo
01:07
2
1.4. Why Use Redis
04:16
3
1.5. Initial Setup
02:53
4
1.6. A Touch More Setup
04:52
5
2.1. Basic Commands
04:11
6
2.2. Documentation on Commands
05:52
7
2.4. Variations of SET
05:25
8
2.5. Use Case of Expiration Options
06:56
9
2.6. Setting Multiple Keys
04:59
10
2.7. GET and MGET
00:51
11
2.8. String Ranges
03:36
12
2.9. Are These Commands Even Useful
09:40
13
2.10. Dealing with Numbers
05:13
14
2.11. Again... Why do These Commands Exist
08:57
15
2.13. Using a Completed Notebook
02:16
16
2.15. A Few Exercises
00:52
17
2.16. Exercise Solutions
03:21
18
3.2. Don't Skip This Video
07:41
19
3.3. Redis Client Libraries
09:47
20
3.4. First Implementation Task
03:31
21
3.5. Redis Design Methodology
09:12
22
3.6. Key Naming Methodology
06:10
23
3.7. Adding Page Caching
06:48
24
3.8. Better Key Generation
05:03
25
5.1. Hashes in Redis
02:02
26
5.2. Storing and Retrieving Hashes
04:44
27
5.3. Deleting Hash Data
02:45
28
5.4. Numbers in Hashes
04:46
29
6.1. Slightly Unpredictable HSET and HGETALL
04:09
30
6.2. Issues with HSET
06:43
31
6.3. Issues with HGETALL
06:17
32
7.1. App Overview
09:06
33
7.2. Reducing the Design to Queries
07:21
34
7.3. What Data Type for Each Resource
06:08
35
7.5. Create User Implementation
10:15
36
7.6. Serialization and Deserialization
10:44
37
7.7. Adding Serialize
01:18
38
7.8. Fetching a User
03:56
39
7.9. Implementing Sessions
06:57
40
7.10. Fetching a Saved Session
07:24
41
7.11. Creating Sessions
03:23
42
7.12. Serializing Date Times
04:28
43
7.13. Storing Items
07:17
44
7.14. Fetching a Single Item
08:01
45
8.1. Batching Commands with Pipelines
03:45
46
8.2. Running Multiple Commands at the Same Time
06:16
47
8.3. Executing a Pipeline
04:29
48
9.1. Basics of Sets
04:21
49
9.2. Union of Sets
03:27
50
9.3. Intersection of Sets
01:18
51
9.4. Difference of Sets
01:36
52
9.5. Store Variations
02:14
53
9.6. Checking for an Element in a Set
02:27
54
9.7. Scanning a Set
05:29
55
9.9. Most Common Use Cases of Sets
06:01
56
10.1. Requiring Unique User Names
06:29
57
10.2. Adding a Like System
05:27
58
10.3. How to Count the Number of Likes
05:32
59
10.4. Updating Like Quantities
05:11
60
10.5. Showing Liked Items
03:30
61
10.6. Showing Common Liked Items
02:14
62
11.1. Sorted Sets
02:58
63
11.2. Adding and Removing Members
03:51
64
11.3. Finding a Range of Scores
05:23
65
11.4. Removing the Highest and Lowest Members
01:53
66
11.5. Updating Scores
02:16
67
11.6. Querying a Sorted Set
08:59
68
12.1. Sorted Set Use Cases
09:30
69
12.2. Reminder on the Auth Flow
05:08
70
12.3. Storing Usernames
04:12
71
12.4. Kind of Storing Strings in Sorted Sets
02:41
72
12.5. Converting User IDs
06:06
73
12.6. Plan for Showing Most Viewed Items
05:01
74
12.7. Initializing Views on Item Creation
04:45
75
12.8. Incrementing View Counters
04:21
76
12.9. Items by Ending Soonest
07:00
77
12.10. Querying for Ending Soonest
11:02
78
13.1. Loading Relational Data
06:45
79
13.2. Relational Data with SORT
05:15
80
13.3. The Sort Command
05:42
81
13.4. Terminology Around Sort
08:00
82
13.5. Specifying the BY Argument
05:56
83
13.6. Joining Data with Sort
09:01
84
13.7. A Few More Arguments
08:39
85
13.8. Parsing SORT Output
08:15
86
14.1. HyperLogsLogs
04:44
87
14.2. When to use HyperLogsLogs
06:45
88
14.3. HyperLogsLogs in Action
04:33
89
15.1. Lists
02:59
90
15.2. Reading and Writing Data to a List
03:46
91
15.3. Ranges and Searches
05:53
92
15.4. Trimming Lists
04:48
93
15.5. Removing Elements
04:55
94
15.6. List Use Cases
10:13
95
15.7. Using Lists in Our App
04:03
96
15.8. Serializing and Deserializing Bids
06:27
97
15.9. Retrieving Bid Histories
13:19
98
16.1. More on Bids
04:02
99
16.2. Validating Bids
04:44
100
16.3. Updating Items with Bids
03:28
101
16.4. Issues with Bids
04:23
102
16.5. Understanding Concurrency Issues
10:13
103
16.6. Applying Atomic Updates
07:43
104
16.7. Transactions
04:53
105
16.8. Watching a Key with Transactions
03:09
106
16.9. Isolated Connections for Transactions
03:55
107
16.10. Solving Multiple Bids with a Transaction
06:05
108
16.11. Items by Price
05:01
109
16.12. More on Items by Price
02:46
110
17.1. Lua Scripting
03:17
111
17.2. Basics of Lua
06:26
112
17.3. Handling Arrays
02:50
113
17.4. Handling Tables
04:13
114
17.5. Loading and Executing Scripts
04:31
115
17.6. Providing Arguments
06:22
116
17.7. Providing Key lists
06:36
117
17.8. When to Use Scripts
04:30
118
17.9. Custom Scripts with Node-Redis
04:32
119
17.10. Lua Script Integration
12:02
120
17.11. Creating a View-Incrementing Script
19:58
121
17.12. Code Cleanup
00:19
122
18.1. Concurrency Revisited
07:42
123
18.2. Issues with WATCH
04:44
124
18.3. Overview of a Lock
06:02
125
18.4. Understanding the Goal
04:23
126
18.5. Implementing WithLock
10:31
127
18.6. Using WithLock
02:46
128
18.7. It Works!
02:55
129
18.8. Automatically Expiring Locks
08:07
130
18.9. Another Lock Issue
07:48
131
18.10. Solving Accidental Unlocks
03:05
132
18.11. Adding an Unlock Script
04:46
133
18.12. One Last Issue
03:47
134
18.13. Providing Expiration Signals
06:00
135
18.14. Alternate Expiration Solution
07:27
136
19.1. Redis Modules
02:34
137
19.2. Redis Core vs Redis Stack
02:20
138
19.3. Using Modules in Production
05:40
139
19.4. Overview on Search
03:40
140
19.5. Creating and Using an Index
06:37
141
19.6. Details on Indexes
07:33
142
19.7. Index Field Types
05:47
143
19.8. Numeric Queries
05:34
144
19.9. Tag Queries
03:08
145
19.10. Text Queries
05:14
146
19.11. Fuzzy Search
03:14
147
19.12. Prefix Search
02:08
148
19.13. Pre-Processing Search Criteria
05:24
149
20.1. Search Implementation
04:56
150
20.2. The Create Index Function
04:21
151
20.3. When to Create the Index
05:28
152
20.4. Parsing the Search Term
06:11
153
20.5. Executing the Search
07:06
154
20.6. Seeding Some Fake Data
02:36
155
20.7. RediSearch and TF-IDF
07:18
156
20.8. Applying Weights to Fields
05:58
157
20.9. Understanding Queries with EXPLAIN
04:54
158
20.10. Query Performance with PROFILE
02:32
159
20.11. Sorting and Searching
04:26
160
20.12. Updating an Existing Index
05:29
161
20.13. Executing the Search
07:27
162
20.14. Deserializing Search Results
03:06
163
21.1. Streams
01:32
164
21.2. Use Case of Streams
07:00
165
21.3. Adding Messages to a Stream
02:37
166
21.4. Consuming Streams with XREAD
04:00
167
21.5. Blocking Reads
06:34
168
21.6. An XREAD Shortcut
01:31
169
21.7. A Little Gotcha Around Streams
04:40
170
21.8. Reading Streams with XRANGE
04:23
171
21.9. Issues with Standard Streams
02:27
172
21.10. Consumer Groups
04:51
173
21.11. Creating and Inspecting Consumer Groups
06:51
174
21.12. Consumer Groups in Action
08:31
175
21.13. Claiming Expired Messages
05:10
Unlock unlimited learning

Get instant access to all 174 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Redis: The Complete Developer's Guide?

Frequently asked questions

What are the prerequisites for taking this course?
The course does not specify any formal prerequisites, but a basic understanding of databases and some familiarity with command-line interfaces would be beneficial. The initial lessons cover setup and basic commands, suggesting that learners new to Redis can start from scratch. However, having prior experience with database systems and programming concepts might help in grasping the more advanced topics covered later in the course.
What projects or applications will I build during the course?
Throughout the course, students will engage in various implementation tasks such as adding page caching, creating user implementations, and managing sessions. Lessons like 'Adding Page Caching' and 'Create User Implementation' indicate practical exercises where learners apply Redis to real-world scenarios. These projects are designed to reinforce the concepts taught and provide hands-on experience with Redis in different contexts.
Who is the target audience for this course?
The course is intended for developers who want to deepen their understanding of Redis and its applications. It caters to individuals looking to implement Redis for caching, session management, and data manipulation in their projects. While beginners can start with the basics, the course also offers depth for experienced developers interested in exploring Redis's advanced features and methodologies.
How does this course compare in depth and scope to other Redis courses?
This course offers a comprehensive exploration of Redis, covering not just basic commands but also advanced topics like pipelining, session management, and data serialization. With 175 lessons, it provides a detailed look at Redis's versatility beyond simple caching. Students engage with practical exercises and implementation tasks, gaining a thorough understanding of Redis's capabilities compared to courses that might only cover basic usage.
What specific tools or platforms will I learn to use in this course?
The course focuses on Redis and its various components, such as strings, hashes, and sets. Students will learn to use Redis client libraries for different implementation tasks, manage data with commands like HSET and HGETALL, and optimize Redis usage with pipelines. Lesson titles such as 'Redis Client Libraries' and 'Batching Commands with Pipelines' highlight specific tools and techniques covered.
What topics are not covered in the course?
While the course covers a wide range of Redis functionalities, it does not delve into topics like Redis clustering, persistence options, or the use of Redis in distributed systems. The focus is primarily on using Redis as a standalone solution for caching, session management, and data manipulation, rather than exploring its integration into larger, distributed architectures.
How much time should I expect to commit to complete the course?
The course is extensive, with 175 lessons, but the total runtime is not specified. Given the detailed nature of the lessons and the practical exercises involved, students should expect to spend several weeks on the material, depending on their pace. Dedicating regular study sessions and time for hands-on practice will help in fully comprehending and applying the concepts taught.