Redis: The Complete Developer's Guide

15h 41m 24s
English
Paid
November 20, 2023

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. 

More
  • 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!

Watch Online Redis: The Complete Developer's Guide

Join premium to watch
Go to premium
# Title Duration
1 Hello and Welcome! 01:07
2 Why Use Redis? 04:16
3 Initial Setup 02:53
4 A Touch More Setup 04:52
5 Basic Commands 04:10
6 Documentation on Commands 05:52
7 Variations of SET 05:25
8 Use Case of Expiration Options 06:56
9 Setting Multiple Keys 04:59
10 GET and MGET 00:50
11 String Ranges 03:36
12 Are These Commands Even Useful? 09:40
13 Dealing with Numbers 05:13
14 Again... Why do These Commands Exist? 08:57
15 Using a Completed Notebook 02:16
16 A Few Exercises 00:52
17 Exercise Solutions 03:21
18 Don't Skip This Video 07:40
19 Redis Client Libraries 09:47
20 First Implementation Task 03:31
21 Redis Design Methodology 09:12
22 Key Naming Methodology 06:10
23 Adding Page Caching 06:48
24 Better Key Generation 05:03
25 Hashes in Redis 02:02
26 Storing and Retrieving Hashes 04:44
27 Creating, Updating, and Retrieving Hashes 04:24
28 Deleting Hash Data 02:44
29 Numbers in Hashes 04:46
30 Slightly Unpredictable HSET and HGETALL 04:09
31 Issues with HSET 06:43
32 Issues with HGETALL 06:17
33 App Overview 09:06
34 Reducing the Design to Queries 07:21
35 What Data Type for Each Resource 06:08
36 Create User Implementation 10:15
37 Serialization and Deserialization 10:44
38 Adding Serialize 01:18
39 Fetching a User 03:56
40 Implementing Sessions 06:57
41 Fetching a Saved Session 07:24
42 Creating Sessions 03:23
43 Serializing Date Times 04:28
44 Storing Items 07:17
45 Fetching a Single Item 08:00
46 Batching Commands with Pipelines 03:45
47 Running Multiple Commands at the Same Time 06:16
48 Executing a Pipeline 04:29
49 Basics of Sets 04:21
50 Union of Sets 03:27
51 Intersection of Sets 01:18
52 Difference of Sets 01:35
53 Store Variations 02:14
54 Checking for an Element in a Set 02:27
55 Scanning a Set 05:29
56 Most Common Use Cases of Sets 06:01
57 Requiring Unique User Names 06:29
58 Adding a Like System 05:27
59 How to Count the Number of Likes? 05:32
60 Updating Like Quantities 05:11
61 Showing Liked Items 03:30
62 Showing Common Liked Items 02:14
63 Sorted Sets 02:57
64 Adding and Removing Members 03:51
65 Finding a Range of Scores 05:23
66 Removing the Highest and Lowest Members 01:53
67 Updating Scores 02:16
68 Querying a Sorted Set 08:59
69 Sorted Set Use Cases 09:30
70 Reminder on the Auth Flow 05:08
71 Storing Usernames 04:12
72 Kind of Storing Strings in Sorted Sets 02:41
73 Converting User IDs 06:06
74 Plan for Showing Most Viewed Items 05:01
75 Initializing Views on Item Creation 04:44
76 Incrementing View Counters 04:21
77 Items by Ending Soonest 07:00
78 Querying for Ending Soonest 11:02
79 Loading Relational Data 06:45
80 Relational Data with SORT 05:15
81 The Sort Command 05:42
82 Terminology Around Sort 08:00
83 Specifying the BY Argument 05:56
84 Joining Data with Sort 09:01
85 A Few More Arguments 08:39
86 Parsing SORT Output 08:15
87 HyperLogsLogs 04:43
88 When to use HyperLogsLogs 06:45
89 HyperLogsLogs in Action 04:33
90 Lists 02:59
91 Reading and Writing Data to a List 03:46
92 Ranges and Searches 05:53
93 Trimming Lists 04:47
94 Removing Elements 04:55
95 List Use Cases 10:13
96 Using Lists in Our App 04:03
97 Serializing and Deserializing Bids 06:27
98 Retrieving Bid Histories 13:19
99 More on Bids 04:02
100 Validating Bids 04:44
101 Updating Items with Bids 03:27
102 Issues with Bids 04:23
103 Understanding Concurrency Issues 10:13
104 Applying Atomic Updates 07:43
105 Transactions 04:53
106 Watching a Key with Transactions 03:09
107 Isolated Connections for Transactions 03:55
108 Solving Multiple Bids with a Transaction 06:05
109 Items by Price 09:25
110 More on Items by Price 02:46
111 Lua Scripting 03:17
112 Basics of Lua 06:25
113 Handling Arrays 02:50
114 Handling Tables 04:13
115 Loading and Executing Scripts 04:31
116 Providing Arguments 06:22
117 Providing Key lists 06:36
118 When to Use Scripts 04:30
119 Custom Scripts with Node-Redis 04:32
120 Lua Script Integration 12:02
121 Creating a View-Incrementing Script 19:58
122 Code Cleanup 00:19
123 Concurrency Revisited 07:42
124 Issues with WATCH 04:44
125 Overview of a Lock 06:02
126 Understanding the Goal 04:23
127 Implementing WithLock 10:31
128 Using WithLock 02:46
129 It Works! 02:54
130 Automatically Expiring Locks 08:07
131 Another Lock Issue 07:48
132 Solving Accidental Unlocks 03:05
133 Adding an Unlock Script 04:46
134 One Last Issue 03:47
135 Providing Expiration Signals 06:00
136 Alternate Expiration Solution 07:27
137 Redis Modules 02:34
138 Redis Core vs Redis Stack 02:20
139 Using Modules in Production 05:40
140 Overview on Search 03:40
141 Creating and Using an Index 06:37
142 Details on Indexes 07:33
143 Index Field Types 05:47
144 Numeric Queries 05:34
145 Tag Queries 03:08
146 Text Queries 05:13
147 Fuzzy Search 03:14
148 Prefix Search 02:08
149 Pre-Processing Search Criteria 05:24
150 Search Implementation 04:56
151 The Create Index Function 04:21
152 When to Create the Index? 05:27
153 Parsing the Search Term 06:11
154 Executing the Search 07:06
155 Seeding Some Fake Data 02:36
156 RediSearch and TF-IDF 07:18
157 Applying Weights to Fields 05:58
158 Understanding Queries with EXPLAIN 04:54
159 Query Performance with PROFILE 02:32
160 Sorting and Searching 04:26
161 Updating an Existing Index 05:29
162 Executing the Search 07:26
163 Deserializing Search Results 03:06
164 Streams 01:32
165 Use Case of Streams 07:00
166 Adding Messages to a Stream 02:37
167 Consuming Streams with XREAD 04:00
168 Blocking Reads 06:34
169 An XREAD Shortcut 01:31
170 A Little Gotcha Around Streams 04:40
171 Reading Streams with XRANGE 04:23
172 Issues with Standard Streams 02:27
173 Consumer Groups 04:51
174 Creating and Inspecting Consumer Groups 06:51
175 Consumer Groups in Action 08:31
176 Claiming Expired Messages 05:10

Similar courses to Redis: The Complete Developer's Guide

Complete SQL + Databases Bootcamp: Zero to Mastery

Complete SQL + Databases Bootcamp: Zero to Mastery

Duration 24 hours 6 minutes 52 seconds
Node JS: Advanced Concepts

Node JS: Advanced Concepts

Duration 16 hours 3 minutes 30 seconds
SocketIO v4, with websockets - the details.

SocketIO v4, with websockets - the details.

Duration 24 hours 34 minutes 57 seconds
React and Laravel: Breaking a Monolith to Microservices

React and Laravel: Breaking a Monolith to Microservices

Duration 15 hours 7 minutes 45 seconds
Vue 3 and Laravel: Breaking a Monolith to Microservices

Vue 3 and Laravel: Breaking a Monolith to Microservices

Duration 14 hours 4 minutes 43 seconds