English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 185 lectures (15h 39m) | 5.42 GB
Master Redis v7.0 with hands-on exercises. Includes Modules, Scripting, Concurrency, and Streams!
Welcome to the best course online for understanding Redis.
Redis is an in-memory database known for being fast and flexible. Redis derives its incredible speed from its simplicity.
Data structures form the heart of Redis. Rather than hiding functionality behind complex abstractions, Redis exposes several powerful data structures that developer’s 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.
What you’ll learn
- Use Redis as an incredibly fast database for a backend application
- Extend the functionality of Redis by using custom scripts and modules
- Add, update, and query your data using simple and flexible commands
- Get hands-on experience by adding Redis to a complex E-Commerce project
- Handle concurrency issues by using powerful synchronization primitives
- Utilize data streams to add durable communication between servers
- Host your Redis database in AWS, GCP, or Azure using Redis Cloud
- Analyze and balance the tradeoffs of Redis’s different data structures
Table of Contents
Get Started Here!
1 Hello and Welcome!
2 Join Our Community!
3 Why Use Redis
4 Initial Setup
5 A Touch More Setup
Commands for Adding and Querying Data
6 Basic Commands
7 Documentation on Commands
8 Essentials of Commands
9 Variations of SET
10 Use Case of Expiration Options
11 Setting Multiple Keys
12 GET and MGET
13 String Ranges
14 Are These Commands Even Useful
15 Dealing with Numbers
16 Again… Why do These Commands Exist
17 Completed Notes
18 Using a Completed Notebook
19 Exercises
20 A Few Exercises
21 Exercise Solutions
E-Commerce App Setup
22 E-Commerce App Source Code Download
23 Don’t Skip This Video
24 Redis Client Libraries
25 First Implementation Task
26 Redis Design Methodology
27 Key Naming Methodology
28 Adding Page Caching
29 Better Key Generation
Hash Data Structures
30 Hashes in Redis
31 Storing and Retrieving Hashes
32 Creating, Updating, and Retrieving Hashes
33 Deleting Hash Data
34 Numbers in Hashes
35 Completed Notes
Redis Has Gotcha’s!
36 Slightly Unpredictable HSET and HGETALL
37 Issues with HSET
38 Issues with HGETALL
Powerful Design Patterns
39 App Overview
40 Reducing the Design to Queries
41 What Data Type for Each Resource
42 Create User Implementation
43 Serialization and Deserialization
44 Adding Serialize
45 Fetching a User
46 Implementing Sessions
47 Fetching a Saved Session
48 Creating Sessions
49 Serializing Date Times
50 Storing Items
51 Fetching a Single Item
Pipelining Commands
52 Batching Commands with Pipelines
53 Running Multiple Commands at the Same Time
54 Executing a Pipeline
Enforcing Uniqueness with Sets
55 Basics of Sets
56 Union of Sets
57 Intersection of Sets
58 Difference of Sets
59 Store Variations
60 Checking for an Element in a Set
61 Scanning a Set
62 Completed Notes
63 Most Common Use Cases of Sets
A Little Set Implementation
64 Requiring Unique User Names
65 Adding a Like System
66 How to Count the Number of Likes
67 Updating Like Quantities
68 Showing Liked Items
69 Showing Common Liked Items
Organizing Data with Sorted Sets
70 Sorted Sets
71 Adding and Removing Members
72 Finding a Range of Scores
73 Removing the Highest and Lowest Members
74 Updating Scores
75 Querying a Sorted Set
76 Completed Notes
Practice Time with Sorted Sets!
77 Sorted Set Use Cases
78 Reminder on the Auth Flow
79 Storing Usernames
80 Kind of Storing Strings in Sorted Sets
81 Converting User IDs
82 Plan for Showing Most Viewed Items
83 Initializing Views on Item Creation
84 Incrementing View Counters
85 Items by Ending Soonest
86 Querying for Ending Soonest
From Relational Data to Redis
87 Loading Relational Data
88 Relational Data with SORT
89 The Sort Command
90 Terminology Around Sort
91 Specifying the BY Argument
92 Joining Data with Sort
93 A Few More Arguments
94 Parsing SORT Output
95 Completed Notes
HyperLogLog Structures
96 HyperLogsLogs
97 When to use HyperLogsLogs
98 HyperLogsLogs in Action
Storing Collections with Lists
99 Lists
100 Reading and Writing Data to a List
101 Ranges and Searches
102 Trimming Lists
103 Removing Elements
104 List Use Cases
105 Using Lists in Our App
106 Serializing and Deserializing Bids
107 Retrieving Bid Histories
More Practice with the E-Commerce App
108 More on Bids
109 Validating Bids
110 Updating Items with Bids
111 Issues with Bids
112 Understanding Concurrency Issues
113 Applying Atomic Updates
114 Transactions
115 Watching a Key with Transactions
116 Isolated Connections for Transactions
117 Solving Multiple Bids with a Transaction
118 Items by Price
119 More on Items by Price
Extending Redis with Scripting
120 Lua Scripting
121 Basics of Lua
122 Handling Arrays
123 Handling Tables
124 Loading and Executing Scripts
125 Providing Arguments
126 Providing Key lists
127 When to Use Scripts
128 Custom Scripts with Node-Redis
129 Lua Script Integration
130 Creating a View-Incrementing Script
131 Code Cleanup
Understanding and Solving Concurrency Issues
132 Concurrency Revisited
133 Issues with WATCH
134 Overview of a Lock
135 Understanding the Goal
136 Implementing WithLock
137 Using WithLock
138 It Works!
139 Automatically Expiring Locks
140 Another Lock Issue
141 Solving Accidental Unlocks
142 Adding an Unlock Script
143 One Last Issue
144 Providing Expiration Signals
145 Alternate Expiration Solution
Querying Data with RediSearch
146 Redis Modules
147 Redis Core vs Redis Stack
148 Using Modules in Production
149 Overview on Search
150 Creating and Using an Index
151 Details on Indexes
152 Index Field Types
153 Numeric Queries
154 Tag Queries
155 Text Queries
156 Fuzzy Search
157 Prefix Search
158 Pre-Processing Search Criteria
Search in Action
159 Search Implementation
160 The Create Index Function
161 When to Create the Index
162 Parsing the Search Term
163 Executing the Search
164 Seeding Some Fake Data
165 RediSearch and TF-IDF
166 Applying Weights to Fields
167 Understanding Queries with EXPLAIN
168 Query Performance with PROFILE
169 Sorting and Searching
170 Updating an Existing Index
171 Executing the Search
172 Deserializing Search Results
Service Communication with Streams
173 Streams
174 Use Case of Streams
175 Adding Messages to a Stream
176 Consuming Streams with XREAD
177 Blocking Reads
178 An XREAD Shortcut
179 A Little Gotcha Around Streams
180 Reading Streams with XRANGE
181 Issues with Standard Streams
182 Consumer Groups
183 Creating and Inspecting Consumer Groups
184 Consumer Groups in Action
185 Claiming Expired Messages
Resolve the captcha to access the links!