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 this course is for:
- Developers looking to speed up their existing web app
- Engineers who want to use an extremely fast database
Chapters
01 Get Start
00:00:00 – 001 Why Use Redis
00:04:15 – 002 Initial Setup
02 Commands
00:11:59 – 004 Basic Commands
00:16:09 – 005 Documentation
00:22:00 – 006 Variations of SET
00:27:25 – 007 Expiration Options
00:34:20 – 008 Setting Multiple Keys
00:39:19 – 009 GET and MGET
00:40:09 – 010 String Ranges
00:43:44 – 011 Are These Commands Even Useful
00:53:24 – 012 Dealing with Numbers
00:58:36 – 013 Again Why do These Commands Exist
01:07:32 – 014 Using a Completed Notebook
01:09:48 – 015 A Few Exercises
01:10:40 – 016 Exercise Solutions
03 E-Commerce App Setup
01:14:00 – 017 Dont Skip This Video
01:21:40 – 018 Redis Client Libraries
01:31:27 – 019 First Implementation Task
01:34:57 – 020 Redis Design Methodology
01:44:09 – 021 Key Naming Methodology
01:50:18 – 022 Adding Page Caching
01:57:05 – 023 Better Key Generation
04 Hash Data Structures
02:02:08 – 024 Hashes in Redis
02:04:09 – 025 Storing and Retrieving Hashes
02:08:53 – 026 Creating, Updating and Retrieving Hashes
02:13:17 – 027 Deleting Hash Data
02:16:01 – 028 Numbers in Hashes
05 Redis Has Gotchas
02:20:46 – 029 HSET & HGETALL
02:24:54 – 030 Issues with HSET & HGETALL
06 Powerful Design Patterns
02:37:53 – 032 App Overview
02:46:58 – 033 Reducing Design to Queries
02:54:19 – 034 Data Type for Each Resource
03:00:27 – 035 Create User Implementation
03:10:41 – 036 Serialization and Deserialization
03:21:24 – 037 Adding Serialize
03:22:41 – 038 Fetching a User
03:26:37 – 039 Implementing Sessions
03:33:33 – 040 Fetching a Saved Session
03:40:56 – 041 Creating Sessions
03:44:18 – 042 Serializing Date Times
03:48:46 – 043 Storing Items
03:56:02 – 044 Fetching a Single Item
07 Pipelining Commands
04:04:02 – 045 Batch Commands with Pipelines
04:07:47 – 046 Running Multiple Commands at the Same Time
04:14:03 – 047 Executing a Pipeline
08 Uniqueness with Sets
04:18:31 – 048 Basics of Sets
04:22:51 – 049 Union of Sets
04:26:17 – 050 Intersection of Sets
04:27:35 – 051 Difference of Sets
04:29:10 – 052 Store Variations
04:31:23 – 053 Checking for an Element in a Set
04:33:50 – 054 Scanning a Set
04:39:18 – 055 Most Common Use Cases of Sets
09 A Little Set Implementation
04:45:18 – 056 Requiring Unique User Names
04:51:46 – 057 Adding a Like System
04:57:13 – 058 How to Count Number of Likes
05:02:44 – 059 Updating Like Quantities
05:07:55 – 060 Showing Liked Items
05:11:25 – 061 Showing Common Liked Items
10 Organizing Data with Sorted Sets
05:13:38 – 062 Sorted Sets
05:16:35 – 063 Add and Remove Members
05:20:25 – 064 Finding a Range of Scores
05:25:48 – 065 Removing Highest and Lowest Members
05:27:41 – 066 Updating Scores
05:29:57 – 067 Querying a Sorted Set
11 Practice Sorted Sets
05:38:55 – 068 Sorted Set Use Cases
05:48:25 – 069 Reminder on Auth Flow
05:53:33 – 070 Storing Usernames
05:57:44 – 071 Storing Strings in Sorted Sets
06:00:25 – 072 Converting User IDs
06:06:30 – 073 Showing Most Viewed Items
06:11:31 – 074 Initializing Views on Item Creation
06:16:15 – 075 Incrementing View Counters
06:20:35 – 076 Items by Ending Soonest
06:27:35 – 077 Querying for Ending Soonest
12 Relational Data to Redis
06:38:36 – 078 Loading Relational Data
06:45:21 – 079 Relational Data with SORT
06:50:35 – 080 The Sort Command
06:56:17 – 081 Terminology Around Sort
07:04:16 – 082 Specifying the BY Argument
07:10:11 – 083 Joining Data with Sort
07:19:12 – 084 A Few More Arguments
07:27:50 – 085 Parsing SORT Output
13 HyperLogLog Structures
07:36:05 – 086 HyperLogsLogs
07:40:48 – 087 When to use HyperLogsLogs
07:47:32 – 088 HyperLogsLogs in Action
14 Storing Collections with Lists
07:52:04 – 089 Lists
07:55:03 – 090 Read Write Data to a List
07:58:48 – 091 Ranges and Searches
08:04:41 – 092 Trimming Lists
08:09:28 – 093 Removing Elements
08:14:22 – 094 List Use Cases
08:24:35 – 095 Using Lists in Our App
08:28:37 – 096 Serializing and Deserializing Bids
08:35:03 – 097 Retrieving Bid Histories
15 Practice with E-Commerce App
08:48:22 – 098 More on Bids
08:52:23 – 099 Validating Bids
08:57:07 – 100 Updating Items with Bids
09:00:34 – 101 Issues with Bids
09:04:57 – 102 Understanding Concurrency Issues
09:15:09 – 103 Applying Atomic Updates
09:22:52 – 104 Transactions
09:27:44 – 105 Watching a Key with Transactions
09:30:53 – 106 Isolated Connections for Transactions
09:34:47 – 107 Solving Multiple Bids with a Transaction
09:40:52 – 108 Items by Price
09:50:16 – 109 More on Items by Price
16 Redis with Scripting
09:53:01 – 110 Lua Scripting
09:56:17 – 111 Basics of Lua
10:02:42 – 112 Handling Arrays
10:05:32 – 113 Handling Tables
10:09:44 – 114 Loading and Executing Scripts
10:14:15 – 115 Providing Arguments
10:20:36 – 116 Providing Key lists
10:27:11 – 117 When to Use Scripts
10:31:41 – 118 Custom Scripts with Node Redis
10:36:12 – 119 Lua Script Integration
10:48:14 – 120 Creating a View Incrementing Script
11:08:12 – 121 Code Cleanup
17 Understanding and Solving Concurrency Issues
11:08:30 – 122 Concurrency Revisited
11:16:12 – 123 Issues with WATCH
11:20:56 – 124 Overview of a Lock
11:26:57 – 125 Understanding the Goal
11:31:20 – 126 Implementing WithLock
11:41:51 – 127 Using WithLock
11:44:36 – 128 It Works!
11:47:30 – 129 Automatically Expiring Locks
11:55:36 – 130 Another Lock Issue
12:03:24 – 131 Solving Accidental Unlocks
12:06:28 – 132 Adding an Unlock Script
12:11:13 – 133 One Last Issue
12:15:00 – 134 Providing Expiration Signals
18 Querying Data with RediSearch
12:28:26 – 136 Redis Modules
12:31:00 – 137 Redis Core vs Redis Stack
12:33:19 – 138 Using Modules in Production
12:38:59 – 139 Overview on Search
12:42:38 – 140 Creating and Using an Index
12:49:14 – 141 Details on Indexes
12:56:47 – 142 Index Field Types
13:02:34 – 143 Numeric Queries
13:08:07 – 144 Tag Queries
13:11:15 – 145 Text Queries
13:16:28 – 146 Fuzzy Search
13:19:41 – 147 Prefix Search
13:21:49 – 148 Pre Processing Search Criteria
19 Search in Action
13:27:13 – 149 Search Implementation
13:32:08 – 150 The Create Index Function
13:36:28 – 151 When to Create the Index
13:41:55 – 152 Parsing the Search Term
13:48:06 – 153 Executing the Search
13:55:12 – 154 Seeding Some Fake Data
13:57:47 – 155 RediSearch and TF IDF
14:05:05 – 156 Applying Weights to Fields
14:11:03 – 157 Understanding Queries
14:15:57 – 158 Query Performance
14:18:28 – 159 Sorting and Searching
14:22:53 – 160 Updating an Existing Index
14:28:21 – 161 Executing the Search
14:35:47 – 162 Deserializing Search Results
20 Service Communication with Streams
14:38:52 – 163 Streams
14:40:24 – 164 Use Case of Streams
14:47:23 – 165 Adding Messages to a Stream
14:50:00 – 166 Consuming Streams with XREAD
14:53:59 – 167 Blocking Reads
15:00:33 – 168 An XREAD Shortcut
15:02:03 – 169 A Little Gotcha Around Streams
15:06:43 – 170 Reading Streams with XRANGE
15:11:06 – 171 Issues with Standard Streams
15:13:32 – 172 Consumer Groups
15:18:22 – 173 Creating and Inspecting Consumer Groups
15:25:12 – 174 Consumer Groups in Action
15:33:43 – 175 Claiming Expired Messages
