Redis: The Complete Developer's Guide

15h 41m 24s
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 176 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing

Watch Online Redis: The Complete Developer's Guide

0:00
/
#1: Hello and Welcome!

All Course Lessons (176)

#Lesson TitleDurationAccess
1
Hello and Welcome! Demo
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

Unlock unlimited learning

Get instant access to all 175 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
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
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
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