Build An Uptime Monitor with Inertia

Sign in Get started

This episode is for members only

Sign up to access "Build An Uptime Monitor with Inertia" right now.

Already a member? Sign in to continue

Playing

31. Setting up queues

Episodes

0%

Your progress

Total: 4h 59m
Played: 0m
Remaining: 4h 59m

Join or sign in to track your progress

01. Introduction

01. Introduction and demo

02. A fresh Inertia project

02. Sites

03. Site and dashboard setup

04. Building the site selector dropdown

05. Making use of API resources

06. Setting the default site

07. Setting up Vue modals

08. Creating a site

03. Endpoints

09. Setting up endpoints

10. Enum endpoint frequencies

11. Creating the endpoint form

12. Storing an endpoint

13. Validating and authorizing endpoint stores

14. Normalizing the endpoint location

15. Displaying endpoints

16. Deleting endpoints

17. Toggling inline editing for endpoints

18. Applying a watcher to the endpoint form

19. Storing endpoint edits

04. Checking endpoints

20. Determining endpoints to check

21. Creating a job to perform a check

22. Making an HTTP request

23. Scheduling checks every second

24. Setting up the check relationship

25. Updating the job

26. Showing the last status

27. Expanded list of checks

28. The response body modal

29. Authorizing the endpoint details

30. Calculating uptime for endpoints

05. Queuing

31. Setting up queues

32. Queuing the endpoint check

06. Email notifications

33. Setting up email in Laravel

34. Site model email notification storage

35. Adding email addresses via the UI

36. Listing and deleting email addresses

07. Downtime notifications

37. Observing when to notify

38. Creating an endpoint down notification

39. Creating an endpoint recovery notification

40. Making the emails a bit friendlier

08. Extras

41. Deleting sites

42. Eager loading

43. Recovery notification bug

44. No sites fix and placeholder

Transcript

00:00

We're now on to queuing, and if you're new to queues, we're going to go through in the Laravel docs setting up

00:05

database queues just to keep things really simple. We'll run our queue worker, and then in the next episode, we'll queue the endpoint check so this can be done in the background, rather than

00:15

having to rely on this taking up too many resources within the app itself. OK, so Laravel queues, the way that they work is we have jobs, which we've already created.

00:26

They are sent into a queue. We run a queue worker, and then they are run in sequence. Now, queues are incredibly powerful,

00:33

but for 80% of the time, we really just need to set up a basic queue worker and let all of the jobs that are created run through. Now, what we're queuing here are the checks themselves.

00:44

Remember, our scheduler is going to run every second. What that scheduler is going to do is determine which endpoints need to have an HTTP request made to them.

00:53

Once that happens, we're then going to queue the actual HTTP request within that job. And if we recall, the job that we created, if we head over to our job section,

01:03

is perform endpoint check. Within the app itself, doing all of this is not advisable. We want this to happen in the background. It's pretty much what queues are doing here.

01:13

So we're going to set up queues on the database just to keep things really simple. You can always switch this over to another driver if you need to.

01:21

So let's head down to the driver notes and prerequisites section and go ahead and set this up for the database. So what we need to do is run the queue table command within Laravel.

01:30

That's going to go ahead and generate a migration for us, which will create our queue table. So if we just have a look at this really quickly over in migrations, create jobs table.

01:39

Let's have a look at this. Contains everything Laravel needs to insert jobs onto this queue, which will be in the database. And then we'll be able to run them.

01:48

So now, of course, we just need to migrate our changes. So let's go ahead and say phpr to migrate. And that will have created out a jobs table. And every time a job gets put into here, it will be inserted.

01:59

Our queue worker will pick up on the job that needs to be run. It will be run. And of course, all of this is happening in the background, not at runtime while we are working through our app.

02:09

Now, the last thing that we need to do here, really importantly, is make sure that we have configured the queue driver or queue connection inside of our EMV file to actually use the database.

02:20

Sync is just like a normal app. It's just going to do it at runtime as this job is run. So we're going to switch this over to not date time, database. Great.

02:31

OK, so how do we run our queue? Well, we're going to need another tab open for this. So let's keep this one for any commands we run. And we're going to run phpr to queue work.

02:41

Now, once again, there are loads of options you can pass through to here. Queues are incredibly powerful in Laravel. But at least for now, we just want to run queue work.

02:50

That's it. And that's going to hang there and wait. So now what's going to happen is when a job goes into that database table,

02:56

this queue is going to work through each of them jobs that we have inside of here. Now, in the next episode, we are going to actually queue our endpoint checks.

03:05

So we'll see these roll in. And we will see them processed in here. What we're also going to need to do is set up our scheduler, our short schedule,

03:13

just so the jobs actually get put into the queue in the first place. Let's handle all that in the next episode. Now we have all of our queue stuff set up.

Episode summary

In this episode, we dive into setting up queues in Laravel, which is super useful for handling background tasks (like checking endpoints) without slowing down your main application. We start by keeping things simple—using Laravel's database queue driver—so new concepts don't get overwhelming.

You'll see how to create the required database tables for queues using Laravel's built-in artisan commands. After running the migration, we've got a shiny new jobs table where jobs (like our endpoint checks) will get queued up and run in the background.

We also update our .env file to use the database queue driver instead of the default sync driver. This ensures things actually run in the background, not just in real time. Finally, we kick off the queue worker, so it's ready to start processing jobs as they get added.

Don't worry, we don't queue any real jobs just yet—that's coming in the next episode! For now, the stage is set with everything ready to handle background tasks, making our app more efficient and scalable.

Episode discussion

No comments, yet. Be the first!