Sensu - Intermediate
4.7 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
359 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Sensu - Intermediate to your Wishlist.

Add to Wishlist

Sensu - Intermediate

Start taking Sensu to Production!
4.7 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
359 students enrolled
Created by Kyle Anderson
Last updated 10/2015
Current price: $10 Original price: $100 Discount: 90% off
3 days left at this price!
30-Day Money-Back Guarantee
  • 3.5 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • How to deploy Sensu with Configuration Management!
  • How to write your own Sensu Checks and Handlers!
  • Understanding of Senus Pub/Sub model, and how to take advantage of it
  • A solid (reinforced) understanding of Sensu's Architecture.
View Curriculum
  • Standard Linux administration knowledge (installing packages, starting things, looking at logs).
  • A VM or Server with a modern OS (Ubuntu is used in this Video) for configuring Sensu.
  • The server must have access to the internet to download packages and send email.
  • A sense of Curiosity for learning new things!

Sensu is a powerful Next-Generation monitoring framework that is quickly replacing traditional monitoring systems like Zabbix, Icinga, and Nagios.

More than just a beginner Sensu user? Ready to learn more?

This intermediate course will teach you the things you need to setup Sensu in Production.


  • Realtime whiteboard interaction - learn like you would if I was right in front of you
  • In-depth architecture overview and recap
  • Deploy and configure Sensu with Configuration Management - I fully cover Chef / Puppet / Ansible / Salt
  • Tune and Filter noisy alerts, keep your pager under control
  • Write your own Sensu Check and Handlers - Live code demonstration
  • Security walkthrough - deploying SSL, hardening API endpoints
  • Advanced Sensu-cli usage and examples
  • Bonus: Dynamically monitoring infrastructure by pushing your own custom events
  • Extensive show-notes, vagrant images, and source code is open-source and on Github

When you are finished with the course, you will be ready to deploy a performant, secure, and tuned Sensu installation for your organization.

Let Me Make The Mistakes For You

It's one thing to read docs and get perfect copy-paste command line examples that work. It is another thing to be in real life watching a real engineer fight a live system and try to get it working! I purposely make mistakes just to demonstrate what happens when things go wrong. That gives me an excuse to troubleshoot the problem and then solve it. Then, when you encounter that same mistake in your infrastructure, you will know exactly what to do!

For Dev and Ops Alike

Sysadmins, Devops Practitioners, Infrastructure engineers, SREs, and simply curious software engineers should take this course to better their craft and learn more about what makes Sensu special. It is not your grandfather's monitoring system. It is a modern, scalable, flexible monitoring system with a great API to integrate with your infrastructure.

This course is a must for engineers who are currently, or considering deploying Sensu intro production. Increasing the scope of your DevOps toolbox, enroll today and check it out!

Who is the target audience?
  • If you have got your feet wet with the Introduction class and you are ready for more
  • Professionals who want to learn more than just the 'surface' level Sensu concepts
  • *Sysadmins* who are sick of inflexible monitoring systems!
  • Curious *Devopsy* types who have heard of Sensu and would like to try it for themselves!
  • System *engineers* who want to further their craft by adding a super cool tool to their toolbox!
Students Who Viewed This Course Also Viewed
Curriculum For This Course
23 Lectures
Welcome to Sensu - Intermediate
2 Lectures 05:21

Welcome to Sensu - Intermediate! This course is all about how to run Sensu in a Production environment.

Preview 02:37

Sensu is designed differently that most monolithic centralized monitoring systems. Let's review the architecture again before we deep-dive into more intermediate Sensu topics.

We'll review exactly how the information flows from Sensu Client to Sensu Server. If this quick recap is too quick, check out my Free Introductory Lecture on Sensu:

Preview 02:44
Using Configuration Management to Deploy Sensu Sustainably
9 Lectures 01:42:15

This lecture will involve using the official Sensu Puppet module to install components, configure checks, etc.

We'll start with a base Ubuntu Trusty vagrant image, install Puppet, Sensu, RabbitMQ, and Redis. The installation of each component will be 100% reproducible, and the Puppet code I use will be on Github.

Preview 10:45

In this lecture we will continue using Puppet to install Uchiwa, the Dashboard. We'll also fine-tune RabbitMQ vhost/user/passwords.

We'll also configure Sensu to use those same credentials, so they can both talk to each other.

Using Puppet to Deploy Sensu - Part 2

We conclude with a discussion on how to integrate Sensu Puppet modules with the rest of your Puppet infrastructure.

What would it look like if you could install an application and deploy the monitoring for that application in a single Puppet class? We'll use the example with an Apache webserver and check_http.

Using Puppet to Deploy Sensu - Part 3

This lecture will involve using the official Sensu Chef cookbook to install server and client components and get them up and running from scratch. We'll use chef-solo to run things, and knife to install the cookbooks we need.

While we are at it we'll install Uchiwa too, and make sure everything is pretty in the Dashboard. All the chef code we write will be on Github of course.

Preview 09:54

In this second half of using Chef with Sensu, we cover adding checks and handlers. We'll install a plugin to check disk space, and an email handler so you can get email when you run out of disk space!

Using Chef to Deploy Sensu - Part 2

This lecture will involve using the Unofficial ansible playbook from Matthieu Maury (Mayeu on Github) to deploy Sensu using Ansible.

We'll use the Ansible-Galexy tool to get the playbooks we need, including Redis, RabbitMQ, and Uchiwa.

Finally we'll look at the dashboard and make sure everything is up and running. Of course all the Ansible code we write will be available on Github.

Preview 10:40

Next we take the Ansible playbooks and integrate email handler, so you can get emails when things go wrong.

Then we'll install a disk check to watch how much disk space your servers have.

Finally I'll show how to combine Sensu and Apache together, so your monitoring gets deployed with your app.

Using Ansible to Deploy Sensu - Part 2

This lecture will involve using the official Sensu Salt forumulas to install Sensu, RabbitMQ, Redis, and Uchiwa.

We'll connect all the pieces, put our config data in Pillar, and verify everything works on Uchiwa. Of course all the Salt formulas we right will be available on Github.

Preview 12:19

Next we'll use Salt to install a disk check, and an email handler so you can get emails when your disks fill up.

Finally, we conclude by demonstrating it what it would look like if we deployed Sensu checks with apache, to get good cohesion between your deployments and your monitoring.

Using Salt to Deploy Sensu - Part 2
Working for the Long Haul: Running Sensu In Production
4 Lectures 40:19

How do you know what commands to run, on what hosts, how frequently, and with what settings?

This will cover things like:

  • Interval
  • Occurences
  • Refresh
  • Command
  • Subscribers

Some of these paramaters may not be as obvious as you might think.

How to Tune Check Parameters

We covered one example of how to take advantage of the third-party Sensu Community Plugins, but let's do more.

Specifically we'll look at exactly what it takes to install any of the plethora of Sensu Plugins:

Deploying Third-Party Checks and Handlers

Luckily, writing your own Sensu checks is Super Easy!

This lecture will cover how to do that.

Also, if you decide to write a check in Ruby, you can take advantage of the included 'sensu-plugin/check/cli' class to get a lot of free boilerplate.

We'll start with a simple bash script, and grow it into a fancy ruby script, all in a test-driven-development way. Fancy!

Writing Your Own Sensu Checks

Writing Sensu handlers is a bit more complicated than writing checks. This lecture will cover how to write basic handlers and how to test them.

I'll bring out my Android phone and write a notify-my-android handler together.

Writing Your Own Sensu Handlers
Intermediate Sensu Topics
7 Lectures 01:07:24

Sensu comes packaged in "omnibus" form, which means every platform Sensu is deployed to will get a consistent, modern ruby that you can use to run checks.

Learn how to take advantage of this ruby, install custom gems, etc.

Taking Advantage of the Embedded Omnibus Ruby

Standalone checks, Safemode, and check Subscriptions are intermediate Sensu topics that are often confused.

Let's get this all figured out together on the whiteboard.

Preview 09:46

We've talked about handlers a bit, but this lecture will go deeper into the nut-and-bolts on how they work, and how they interact with filters.

Filters are essential for tuning noisy alerts that don't deserve to wake people up in the middle of the night, and every production Sensu installation should use them.

Handlers, Filters, and Subdued Checks

Any production Sensu installation needs to be secured with SSL. This prevents the possibility of attackers ease-dropping and listening on the plain-text communication.

It also allows RabbitMQ to validate the client connections, to ensure no rouge actors can connect.

This does require a bit more work and understanding, but you have an expert to help show you the way...

Securing RabbitMQ With SSL

Running any production system requires extra security considerations. In this lecture I demonstrate possible attack surfaces of Sensu, and how to harden them against attack.

This includes where you should be using encryption, authentication, and network separation.

I'll cover specifics about what to do with RabbitMQ, Redis, Uchiwa, and Sensu in a secure, production environment.

Hardening the Rest of Sensu

The sensu-cli is a great tool for interacting with Sensu. In this lecture I'll demonstrate how to install, configure, and use the sensu-cli.

Then I'll start getting all crazy mixing in 'jq' and 'xargs'. If you love stringing unixy tools together with pipes to construct powerful command line invocations, you will love this lecture.

Preview 17:10

Sending events directly to the Sensu socket on localhost is probably the most under-rated feature of Sensu.

This will be a small introduction to this feature, but the possibilities are endless.

This is the idea that you can iterate over some dynamic endpoint, and emit your own check results based on that status of the endpoint.

I'll start with a simple bash example: a nightly cron job. Then I'll grow it into a complicated custom report, iterating through customers and sending Sensu notification on a per-customer basis.

(Advanced) Pushing Your Own External Check Results
Conclusion + Further Reading + Bonus
1 Lecture 01:21

This course should leave you with enough knowledge and inspiration to run Sensu in a Production environment.

It should be secure, and sustainably deployed, and as an engineer you should feel comfortable and empowered by Sensu.

Preview 01:21
Frequently Bought Together
About the Instructor
Kyle Anderson
4.4 Average rating
513 Reviews
6,299 Students
2 Courses
System Engineer

I love building systems I can be proud of.

I also love teaching and empowering others to do the same.

All of my lessons come from this passion, and hopefully it shows.I teach from a background of real experience on tools and technologies that I use in production. (I don't want to teach something that I haven't been on call for.)

I specialize in Advanced deep-dives in distributed systems that are difficult to learn about from a manual. (Which is why I love teaching them!)