Improved Caching with Redis
In this lesson, we'll install and configure the AdonisJS Redis package. We'll then swap out our singleton in-memory cache service with a Redis cache implementation.
- Author
- Tom Gobich
- Published
- Feb 04
- Duration
- 10m 44s
Developer, dog lover, and burrito eater. Currently teaching AdonisJS, a fully featured NodeJS framework, and running Adocasts where I post new lessons weekly. Professionally, I work with JavaScript, .Net C#, and SQL Server.
Adocasts
Burlington, KY
Transcript
Improved Caching with Redis
-
(upbeat music)
-
Okay, so let's go ahead and install
-
and configure Redis within our project.
-
So first let's install it.
-
So we'll run npm i @adonisjs/redis.
-
This will install it within our project.
-
Okay, cool, it's installed.
-
So we can clear this out.
-
Now, this package also requires us
-
to configure it within our project.
-
The configuration process is essentially going
-
to inform our project about the particular package
-
and it will allow the package itself
-
to run the necessary hooks that it needs
-
to instantiate various things that it needs
-
in order for us to successfully use the package itself.
-
So to configure a package, we'll wanna use the ACLI.
-
So that'll be node ace and there's a configure command.
-
And to this configure command,
-
we just need to provide the package names.
-
That's adamusjs/redis.
-
Once we have that run,
-
we'll see that it's done four things for us.
-
First, it's created a configuration
-
within our config directory called redis.ts.
-
Within this configuration is where we'll set up
-
our connection to Redis itself.
-
Then it's also updated our ENV file.
-
Since that connection information is environment specific,
-
this is where we're storing the connection information
-
that our config is reading from.
-
Then it's updated our start_env.ts file,
-
requiring those new ENV variables
-
that have been added into our .env file.
-
And then lastly, it's updated our adonisrc.ts file,
-
which we've yet to talk about.
-
So now the adonisrc.ts file is essentially in charge
-
of configuration for our project.
-
It is where the package has added its provider
-
into our providers array.
-
Providers essentially allow for the package
-
to hook into our application's lifecycle
-
to instantiate instances that it needs to
-
in order for us to properly work with the package.
-
It's also within that package's provider
-
that it's going to read from our configuration
-
to actually grab our connection details.
-
Before we leave here,
-
we can go ahead and boot our server back up,
-
so empty and run dev,
-
and let's dive back into our project.
-
So we left off within our .env file,
-
and within this file, we see three new variables.
-
We have our redis_host, our redis_port,
-
and our redis_password.
-
Now by default, this package has set us up
-
with a redis_host and redis_port value.
-
These two values are actually the default values
-
for Redis itself.
-
So if you haven't changed anything
-
within your Redis configuration,
-
you're most likely okay to leave these values as is.
-
The same goes for the password.
-
By default, it's not going to utilize a password.
-
So unless you've explicitly set up a password
-
for your Redis configuration,
-
you won't need to provide one in here either.
-
Since we're on our local machine,
-
we're not really worried about passwords
-
at this point in time.
-
Now within the env.ts file,
-
that's where we're specifying that our host
-
and our port are required.
-
So if we dive into here,
-
we'll see two new additions for our redis_host
-
and our redis_port.
-
The redis_host is specifying that it should be a string,
-
and that string should be a host format.
-
A host format's basically going to look like an IP address.
-
It's going to be that 127.0.0.1 value
-
that we have within our .env file.
-
And then the port should be a number.
-
Remember that the port kind of serves
-
as like the street address for the server
-
that we want to reach to on the specific host.
-
So we're A-okay here.
-
I'll go ahead and give that file a save
-
so that it fixes our missing comma.
-
All right, the next thing that the configuration step changed
-
was our adonisrc.ts file.
-
So let's go ahead and dive into there.
-
And we'll see that we're calling define_config
-
and providing that some form of an object.
-
This object contains commands, service providers.
-
There's that providers array that we had mentioned.
-
And specifically, here's our redis_provider right here.
-
So it's within this redis_provider
-
that the redis_package is reading from our configuration,
-
setting up the connection,
-
and then providing us back a redis_package
-
to actually be able to work with.
-
There's some other things going on
-
within this adonisrc.ts file,
-
but we don't need to care about them at this point in time.
-
We'll come across them as they become important
-
to the series topic.
-
So we'll go ahead and close this out for now.
-
And the last thing that was added to our project
-
was a new configuration file specifically for Redis
-
with connection details.
-
By default, our redis_config
-
is going to have a default connection called main,
-
and then we'll have a connections object
-
that will allow us to define multiple connections
-
if we need to.
-
Out of the box though,
-
we'll just have that single main default connection.
-
And this main default connection
-
is going to use the host and the port,
-
and if needed, the password
-
that we have set within our environment variables.
-
It's also got some additional configuration
-
going on down here as well.
-
You might notice that we're reading from env.get
-
to actually read from our environment variables.
-
If we scroll up to see where that's coming from,
-
we'll see it's being imported from our start directory
-
and specifically that env.ts file.
-
So one nice thing about that file
-
is not only is it providing type safety
-
whenever we boot our server up,
-
but it's also providing type safety
-
whenever we actually try to read from it as well.
-
So if we scroll back down to where we call those gets
-
and we remove, let's say our redis_host altogether,
-
let's remove the strings as well,
-
and we type strings back in,
-
we're going to get an auto-complete
-
of the variables that we have defined within our env.ts
-
so that we know what we have within our environment variables
-
and we can say, okay, I want the redis_host,
-
click on it, and there we go.
-
Now, for me particularly,
-
I need to change one more thing in here.
-
You most likely don't need to worry about this whatsoever.
-
Redis allows you to have multiple different databases
-
specified by this db0, which is the default database.
-
I'm already using db0 for the Atacast project,
-
so I need to switch to a different index.
-
For this one, I'll switch it to one.
-
Again, you most likely don't need to change this whatsoever.
-
So I'm going to give that a save,
-
collapse our config back down, scroll up,
-
and now we're ready to replace
-
our cache service implementation with redis.
-
So let's dive into here.
-
First things first, let's go ahead and import redis.
-
So at the top of the file,
-
let's call import redis from at adonisjs/redis/services/main.
-
This is going to give us a redis service
-
to be able to work with.
-
All right, so let's go ahead and just roll through
-
the different methods that we have here.
-
So first, we have a has method,
-
checking whether or not the key exists within our store.
-
For this, for redis, what we'll want to do is return.
-
We can read from redis.
-
And there's an exists method
-
that we can utilize to check this.
-
Now, this method here is overloaded,
-
meaning that there's a couple of different argument sets
-
that we could provide into it.
-
The various options for this essentially mean
-
that we can either spread in an array of redis keys,
-
or we could provide a redis key array.
-
There's an additional callback option
-
for a couple of these here that we could provide in as well,
-
but we don't really care about that at this point.
-
We just want to check whether or not the key exists.
-
So within here, we can provide our key.
-
Now, if we wanted to,
-
we could mimic their spread behavior by spreading our key,
-
turning this into keys,
-
and now the string will be a string array.
-
We can still provide a singular key
-
because our arguments here are spread,
-
but if we needed to,
-
we could provide multiple arguments as an array.
-
And now we can just provide our keys directly into here,
-
and we're good to go.
-
So now we can get rid of our prior implementation reading
-
directly from our store.
-
And before we move on,
-
let's check the exists method.
-
So this is returning back a promise of number.
-
So since it's returning back a promise,
-
that means that this call is asynchronous.
-
We currently have our methods asynchronous,
-
so we do want to switch them to async.
-
Before I forget,
-
I'm just going to do that for all of them.
-
So we'll paste it in here,
-
paste it in there,
-
and paste it in for our delete as well.
-
So now we're ready to take care of our get method,
-
where we're reading a value from the store.
-
So for this one,
-
we're actually going to want to hold the value here
-
momentarily before we return it.
-
So let's do const value equals await
-
or read from Redis dot,
-
and there's a get method
-
and provide in the key that we want to get.
-
Now, before we return our value,
-
we need to understand how Redis
-
is actually going to store our information.
-
So Redis is going to store it as a string,
-
meaning that if we pass it in an object or an array,
-
we're going to need to stringify it
-
before we actually put it into the Redis database.
-
So since we'll need to set it as a string,
-
whenever we get it,
-
we'll be getting it back as a string,
-
meaning we'll want to parse it before we return it back.
-
So for our return,
-
what we'll want to do is JSON dot parse
-
and provide the value in.
-
Now you'll notice a red squiggly here.
-
That's because the value could be null
-
and parse does not like that.
-
It requires a value.
-
So what we'll do is check whether or not the value exists
-
by doing value and, and.
-
This is a shorthand kind of ternary check
-
using the fact that JavaScript will return back
-
the result of the if check.
-
So essentially, if we have a value,
-
it will move on to the and, and check,
-
parsing our value.
-
And since this is the last thing that is running,
-
it will return that value back for our method.
-
If our value does not exist,
-
it will stop there and it will return back
-
most likely undefined since our value does not exist.
-
Okay, so now we have our get method.
-
We're ready to move on to our set method
-
where we're setting the value onto the store.
-
So let's go ahead and get rid of this
-
and we can return and we'll call redis.set.
-
We'll set for our key and we'll set the value.
-
Now we do need to stringify it.
-
So we'll do json.stringify value.
-
And there we go.
-
Lastly, we have our delete.
-
So we'll go ahead and get rid of our store deletion
-
and we'll return redis.
-
And they have a method called del
-
that will serve as the deletion.
-
So similar to our has check,
-
this one also accepts a spread in array of arguments
-
or a redis key array.
-
So we can do the exact same thing here.
-
We can spread in our keys, change that to keys,
-
and this will now be a string array.
-
And then we can provide the keys into the delete call.
-
So now we're no longer using our store at all.
-
So we can go ahead and get rid
-
of the private store key that we had.
-
And there's actually one additional method
-
that we can add into the service
-
to make clearing out our database a little bit easier.
-
Previously, all that we had to do was stop
-
and start our server back up.
-
And that would clear out the in-memory cache
-
that we had going on.
-
But since Redis is running on a completely different server,
-
that complicates things a little bit.
-
So let's dive back into the service,
-
scroll down to the end where we have a delete,
-
and let's add an additional method.
-
This will be async, and we'll call this flushDB.
-
We don't need to take anything in for this one.
-
And we'll just return back Redis.
-
And they have a method themselves called flushDB.
-
So we'll call that.
-
And what this will do is it will flush out all of the data
-
that we have stored within the particular database
-
that we're using inside of Redis.
-
We'll see exactly what that's doing here in a little bit
-
whenever we actually clear our store.
-
So we'll give this a save,
-
and now we need to utilize this cache.
-
So let's dive into our movie model.
-
You'll see immediately our cache call is not happy
-
since promise number will always return true.
-
So what we wanna do is await that,
-
and now we're getting back a number as our has check.
-
If it doesn't find anything matching the slug,
-
it will return back zero, which will be falsy,
-
which will allow us to move on
-
to actually reading our information.
-
If it finds any results for our slug,
-
it will return back one or higher,
-
allowing us to dive into the if check
-
where we can return our cache.get.
-
Since this method itself is asynchronous,
-
we're a-okay to just leave that as is.
-
Let's scroll up to make sure the rest of the file's happy,
-
and it looks like it.
-
So that's really the only change
-
that we needed to make there.
-
So one thing that I missed here
-
is that set is actually asynchronous as well.
-
So if we hover over this,
-
we're gonna see promise okay
-
is the expected return for set.
-
So we'll also want to await here as well.
-
During my initial recording, I did miss this await,
-
so you might see it disappear here in a second,
-
but do note that you do actually want it to be there.
-
Let's go ahead and give this a save,
-
dive back into our browser,
-
and we saw it do a refresh there,
-
so if we check our terminal,
-
we should see we didn't get any cache hits
-
because nothing's logged into our terminal here.
-
If we give the page a refresh,
-
open our terminal back up,
-
there's our cache hits.
-
So our page is successfully utilizing our cache
-
since everything worked A-okay.
-
We can dive into our individual movies,
-
go back home, and everything's still working.
-
Introduction
-
Fundamentals
-
2.0Routes and How To Create Them5m 23s
-
2.1Rendering a View for a Route6m 29s
-
2.2Linking Between Routes7m 51s
-
2.3Loading A Movie Using Route Parameters9m 17s
-
2.4Validating Route Parameters6m 6s
-
2.5Vite and Our Assets6m 38s
-
2.6Setting Up Tailwind CSS9m 5s
-
2.7Reading and Supporting Markdown Content4m 32s
-
2.8Listing Movies from their Markdown Files8m 51s
-
2.9Extracting Reusable Code with Services7m 4s
-
2.10Cleaning Up Routes with Controllers4m 52s
-
2.11Defining A Structure for our Movie using Models9m 38s
-
2.12Singleton Services and the Idea of Caching6m 11s
-
2.13Environment Variables and their Validation4m 16s
-
2.14Improved Caching with Redis10m 44s
-
2.15Deleting Items and Flushing our Redis Cache6m 46s
-
2.16Quick Start Apps with Custom Starter Kits6m 28s
-
2.17Easy Imports with NodeJS Subpath Imports8m 40s
-
-
Building Views with EdgeJS
-
3.0EdgeJS Templating Basics8m 49s
-
3.1HTML Attribute and Class Utilities6m 9s
-
3.2Making A Reusable Movie Card Component10m 24s
-
3.3Component Tags, State, and Props4m 53s
-
3.4Use Slots To Make A Button Component6m 56s
-
3.5Extracting A Layout Component5m 13s
-
3.6State vs Share Data Flow2m 59s
-
3.7Share vs Global Data Flow6m 7s
-
3.8Form Basics and CSRF Protection6m 13s
-
3.9HTTP Method Spoofing HTML Forms3m 3s
-
3.10Easy SVG Icons with Edge Iconify7m 57s
-
-
Database and Lucid ORM Basics
-
4.0Configuring Lucid and our Database Connection4m 3s
-
4.1Understanding our Database Schema9m 35s
-
4.2Introducing and Defining Database Migrations18m 35s
-
4.3The Flow of Migrations8m 28s
-
4.4Introducing Lucid Models5m 43s
-
4.5Defining Our Models6m 49s
-
4.6The Basics of CRUD11m 56s
-
4.7Defining Required Data with Seeders11m 11s
-
4.8Stubbing Fake Data with Model Factories13m 48s
-
4.9Querying Our Movies with the Query Builder15m 30s
-
4.10Unmapped and Computed Model Properties3m 24s
-
4.11Altering Tables with Migrations7m 6s
-
4.12Adding A Profile Model, Migration, Factory, and Controller2m 57s
-
4.13SQL Parameters and Injection Protection9m 19s
-
4.14Reusable Query Statements with Model Query Scopes8m 11s
-
4.15Tapping into Model Factory States9m 15s
-
4.16Querying Recently Released and Coming Soon Movies4m 59s
-
4.17Generating A Unique Movie Slug With Model Hooks7m 59s
-
-
Lucid ORM Relationships
-
5.0Defining One to One Relationships Within Lucid Models5m 49s
-
5.1Model Factory Relationships2m 54s
-
5.2Querying Relationships and Eager Vs Lazy Loading5m 17s
-
5.3Cascading and Deleting Model Relationships5m 16s
-
5.4Defining One to Many Relationships with Lucid Models6m 56s
-
5.5Seeding Movies with One to Many Model Factory Relationships5m 24s
-
5.6Listing A Director's Movies with Relationship Existence Queries8m 41s
-
5.7Listing and Counting a Writer's Movies8m 41s
-
5.8Using Eager and Lazy Loading to Load A Movie's Writer and Director5m 18s
-
5.9Defining Many-To-Many Relationships and Pivot Columns9m 48s
-
5.10Many-To-Many Model Factory Relationships4m 50s
-
5.11A Deep Dive Into Relationship CRUD with Models18m 5s
-
5.12How To Create Factory Relationships from a Pool of Data13m 55s
-
5.13How To Query, Sort, and Filter by Pivot Table Data9m 47s
-
-
Working With Forms
-
6.0Accepting Form Data12m 15s
-
6.1Validating Form Data with VineJS9m 29s
-
6.2Displaying Validation Errors and Validating from our Request7m 16s
-
6.3Reusing Old Form Values After A Validation Error2m 3s
-
6.4Creating An EdgeJS Form Input Component5m 28s
-
6.5Creating A Login Form and Validator5m 1s
-
6.6How To Create A Custom VineJS Validation Rule9m 7s
-
-
Authentication & Middleware
-
The Flow of Middleware7m 49s
-
Authenticating A Newly Registered User4m 14s
-
Checking For and Populating an Authenticated User2m 10s
-
Logging Out An Authenticated User2m 24s
-
Logging In An Existing User6m 54s
-
Remembering A User's Authenticated Session6m 55s
-
Protecting Routes with Auth, Guest, and Admin Middleware5m 36s
-
-
Filtering and Paginating Queries
Join The Discussion! (2 Comments)
Please sign in or sign up for free to join in on the dicussion.
PhillipMwaniki
Incase you have issues with writing to redis, head over to redis-cli on the terminal and run this
`config set stop-writes-on-bgsave-error no`
Restart your redis server and all will be good.
Please sign in or sign up for free to reply
tomgobich
Thanks for sharing, Phillip!!
Please sign in or sign up for free to reply