Redis in Action

by Josiah L. Carlson

Summary

Redis in Action introduces Redis and walks you through examples that demonstrate how to use it effectively. You'll begin by getting Redis set up properly and then exploring the key-value model. Then, you'll dive into real use cases including simple caching, distributed ad targeting, and more. You'll learn how to scale Redis from small jobs to massive datasets. Experienced developers will appreciate chapters on clustering and internal scripting to make Redis easier to use.

About the Technology

When you need near-real-time access to a fast-moving data stream, key-value stores like Redis are the way to go. Redis expands on the key-value pattern by accepting a wide variety of data types, including hashes, strings, lists, and other structures. It provides lightning-fast operations on in-memory datasets, and also makes it easy to persist to disk on the fly. Plus, it's free and open source.

About this book

Redis in Action introduces Redis and the key-value model. You'll quickly dive into real use cases including simple caching, distributed ad targeting, and more. You'll learn how to scale Redis from small jobs to massive datasets and discover how to integrate with traditional RDBMS or other NoSQL stores. Experienced developers will appreciate the in-depth chapters on clustering and internal scripting.

Written for developers familiar with database concepts. No prior exposure to NoSQL database concepts nor to Redis itself is required. Appropriate for systems administrators comfortable with programming.

Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

What's Inside

About the Author

Dr. Josiah L. Carlson is a seasoned database professional and an active contributor to the Redis community.

Table of Contents

Genres: Programming, Computer Science, Software, Technology, Technical, Nonfiction

320 pages, Paperback

First published January 28, 2013

Reviews

[Sebastian Gebski · Rating 4 out of 5]

3.5-3.7 stars would be perfect :)

This book is nearly perfect if you're interested in purely developer's perspective. The problem is that Redis is quite frequently used in distributed scenarios, so Adm/Ops perspective is just as crucial - and it is lacking (just some stuff about backing up) ;/

What I liked:
* book is very practical, there are plenty of viable RL scenarios covered & it's a *great* start
* examples are awesome & perfectly commented
* performance aspect is very well covered
* the description of distributed scenariod (dev perspective, like I've mentioned before) is a good start as well

What I didn't like:
* nothing about trouble-shooting, monitoring, operations
* minor problems with formatting on Kindle PPW (fixed font size in code samples)
* pretty much nothing about particular client libraries - maturity, model

Anyway - if you want to learn about Redis and you're an absolute beginner: this book is a very reasonable option. Especially if you're a dev.

[Eduardo · Rating 3 out of 5]

I've finished the MEAP version of the book.

It's a good read with lots of "recipes" for solving different problems using Redis structures and abilities.
It's a book you should know the solutions it delivers, to search for them when needed and not for reading (deeply) beyond chapter 4 in an ordered way.

It uses some advanced aspects from Python so knowing Python will greatly help you to better understand the examples.

All in all is a good read and if you are planning to use Redis it's a good book to have in mind.

[Le Dat · Rating 3 out of 5]

I read the web version on redislabs site on my way to solve a problem of fixing the autocomplete feature in which a guy was setting all cached data on Redis hashes instead of sorted sets.
The problem is that redis hashes has no thing like lexicographical sort and no limit/offset scanning, the hscan count is for a very index optimization and it will yield all the data. So it was a wrong thing for the feature.

In the software development world, it will be good to know more approaches as always, as redis did become a favourite database/cache/message broker system for its functionality. The book is on the surface for understanding redis and what it can solve, trust me there is no overengineering stuff written here.

[Frank Palardy · Rating 4 out of 5]

Python seemed like an odd language at the time.

[Oleksandr · Rating 3 out of 5]

This book could be restructured into 2 major parts:

1) "Redis data types with use-cases, performance, and scaling".
2) "How to spend a lifetime building a scalable database on top of primitives and hope it will persist and debugging will be fun".

And my guess everyone would like to see at least part #1 with examples of Redis commands instead of Python API calls. I already know Python and there's no need to spend extra time explaining to me what a decorator is and so on. It would be better to have an overview of concepts + examples of commands + overview of patterns & algorithms + tracing of data changes during application of them. Then performance, persisting, scaling, and fault-tolerance. And only after that should come overview of specific use-cases or solutions like building a sharded storage for Twitter with Redis (possibly as a separate part or as a series of appendixes). Instead, the whole book is a continuous "unexpected journey".

I really like the holistic and systematic approach across the book. I appreciate the efforts, smartness, and dedication of the author. Using Redis data structures can give a not-ordinary way to tackle certain problems and the book is full of practical examples on how to use them in non-obvious ways (or at least not so common ways) and how to consider and exploit certain technical nuances while designing a solution. The guy is really an expert in the domain, definitely knows what he's writing about and I really believe he applied all that in production successfully.

But the book would greatly benefit from a strong editorial review. The code samples in Python are far from being examples to follow. Moreover, they contain typos or seldom gaps. Following code from one chapter could require rereading and recomprehending code samples from several chapters back. The code is commented, but trying to follow comments can give a real headache. Just a bit of explanation: code does not have syntax highlights, there are no line numbers or just different even/odd background of lines. And comments look almost like code, but in a bolder font. This itself is not a big issue, but comments for line 1 can be on the left side, comments for line 2 — on the right, and for line 3 — on the left again and co on. Moreover, comments are not aligned and can be arbitrarily displaced vertically or horizontally. And finally, lines and arrows between comments and target lines/tokens can be directed anywhere: top, bottom, left, right, etc. It can get very tricky and pretty quick to understand in what direction you should look even for a 10-lines sample. And oftentimes there are no examples of how data changes during the execution of code, which is really awful at places where temporary structures are created, like in the case of temporary ZSETs for multi-criteria sorting. And examples of functions' invocations are not always included, though.

I would recommend reading chapters 3, 4, 9, and 10 from this book, then study best practices (https://redislabs.com/redis-best-prac...) and take a look at modules (https://redislabs.com/modules/). After that one can get back to the rest of the chapters of this book and feel free to drop it as soon as one starts feeling sick.

[Edwin Dalorzo · Rating 3 out of 5]

As others have pointed out, the main problem with this book is that the examples are in Python, not in Redis. So, even when the concepts and examples are interesting and well explained, the reader is constantly doing the translation effort: reading the Python code and trying to map the code to the corresponding Redis commands. I would have liked the book much better if examples were defined in pure Redis commands.

Other than that, I think the book is well written, contains many interesting examples and practical ideas on how to implement solutions to common problems in which Redis shines.

Since this is my first time using Redis, I am sure I was no able to grasp or even appreciate the depth of all the knowledge in the book. But I am sure that as I work with Redis more and more I will be constantly coming back to this book for more ideas, guidance and to make sure a fully comprehend other interesting topics I couldn’t assimilate during my first, fast reading of this book.

[Wojtek Gawroński · Rating 3 out of 5]

It is a regular technical book about building applications with Redis that has nice and non-trivial examples. Nothing more, nothing less.

Author covers very well topics necessary for application developers. It ranges from basics, through data structures, data modelling, Redis specifics, scaling, and even more advanced concepts (publish-subscribe, replication, etc.). From the perspective of a Redis user, consumer, and application developer it is a well-rounded position.

However, I definitely missed deeper dive into details - especially about database internals, operational and deployment side of things.

[Daniel · Rating 3 out of 5]

Overall it's informative and teaches you the essentials, but there were still several flaws:
- bad code samples. Many of the code samples were broken, and all of them were poorly written with terrible formatting
- the examples were mostly pretty good, but several were fairly unclear and could be explained more clearly
- several typos / formatting issues in the copy

I did read this book on redislabs.com's online viewer, so I'm not sure if these issues are only present in that version of the book.

I'd still recommend this book, though, as it provides a decent overview on using Redis.

[Khang Nguyen · Rating 4 out of 5]

Good redis essential. Some examples are kinda forced, as in Redis is quite possibly not the best choice. For the sake of practices, that's alright, just bear in mind, Redis is a cache engine and more, but not a database.

[Rober · Rating 4 out of 5]

It's a pity it's so outdated by now. It covers all the basics for a developer and a bit for ops admins, but newer types in V6 and 7 are not covered, same as cluster deployments. The examples, although a bit artificial at first glance, are able to explain the actual value of redis types.

[Povilas Balzaravičius · Rating 4 out of 5]

Good intro into Redis and even more. If you need just basic knowledge to work with this database - first four chapters are covering most used commands, locks, transactions and replication. That is all you need! Now you can start work with Redis! Later chapters describe how to build and run complex applications on Redis. Most code examples are in phyton so you must be familiar with this language to get most from the source. Ending chapters includes good info on performance optimization and architecture of Redis based applications. In overal this book is great source to get familiar with the database.

[Alessandro Pellizzari · Rating 3 out of 5]

Apparentemente è impossibile scrivere un libro su Redis che sia chiaro e comprensibile.

Forse l'autore dà troppe cose per scontate, forse nemmeno lui sa descrivere bene i concetti che dovrebbe spiegare, forse fa troppa teoria per poi passare a esempi troppo complessi per poter essere capiti, ma più andavo avanti a leggere e meno capivo come realmente funziona Redis.

Abbandonato a circa metà perché mi sono reso conto che avrei dovuto ricominciare dall'inizio e forse nemmeno quello sarebbe servito. Si trovano tutorial più chiari su Internet.

[Arindam Chakraborty]

Begun reading it on the passing. Caught my attention in the first chapter with a good thorough example of a practical use-case.

Seems pretty standard Redis stuff, but good to see an official text-book instead of hitting the REPL and/or live console everytime. Useful for people beginning to use Redis, and/or identify the use cases.

Will update as I progress.

[Niklas Nihlén · Rating 2 out of 5]

I think this book is good if you want a solid intro to building redis backed python applications. Me, not being a python dev, had a hard time getting any value out of the examples in the book. I really think that every example should first be shown in Redis commands befor the author starts throwing python at it.

The first chapters introducing data types and commands where rally good.

[Mattias Lundell · Rating 4 out of 5]

Great book, a lot of content and good examples.