Redis: The Complete Developer's Guide

Name: Redis: The Complete Developer's Guide
Price: 9 USD
Availability: InStock

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.

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