Skip to main content

Redis: The Complete Developer's Guide

15h 32m 52s
English
Paid

Course description

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. 

Read more about the course
  • 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

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Node JS Cluster with PM2, RabbitMQ, Redis and Nginx

Node JS Cluster with PM2, RabbitMQ, Redis and Nginx

Sources: udemy
As we all know, Node JS is single threaded event-driven JavaScript runtime. When we run any CPU intensive operation, Node will not be able to take an advantage
2 hours 24 minutes 39 seconds
React and Laravel: Breaking a Monolith to Microservices

React and Laravel: Breaking a Monolith to Microservices

Sources: udemy
Microservices Architecture, React, Next.js, Laravel, Docker, RabbitMQ, Event Driven Microservices, Internal APIs, Redis. Learn how to create a Monolith using React and Laravel t...
15 hours 7 minutes 45 seconds
SocketIO v4, with websockets - the details.

SocketIO v4, with websockets - the details.

Sources: udemy
This course is meant to alleviate that! It is not a quick start guide to socket.IO. There are loads of those all over the Internet. You should definitely look elsewhere if you a...
24 hours 34 minutes 57 seconds
Redis Stack Tutorial

Redis Stack Tutorial

Sources: Net Ninja
Redis Stack is a collection of modules and tools built around the core Redis functions that simplify and make working with Redis more efficient. In this...
1 hour 55 minutes 45 seconds
Redis Caching Concepts with Node.js

Redis Caching Concepts with Node.js

Sources: Codedamn
Redis is an open-source in-memory data store used as a database, cache, and message broker. It is incredibly fast and suitable for a variety of tasks.
1 hour 52 minutes 26 seconds