When you take a step back from the buzz of activities we generalize as work, you'll notice event patterns—repetitive processes. We can document most of these events and processes into easy-to-run steps in runbooks. Runbooks help make sure tasks are performed at the same level of accuracy and yield predictable and desired results. While runbooks tend to live in Google Docs or wiki pages, runbook automation is the process of using software to execute these more reliably, quickly, and autonomously.
This article walks through what runbook automation is, benefits and best practices, and how to get started.
Why use runbooks?
One common way of resolving issues in system usage is to create a manual. Think of a knowledge base or wiki with clearly documented cases and solutions.
However, this is generally an incomplete solution. In reality, when a system glitches or you begin a repetitive task, you don't want to browse through volumes of text and videos for an answer. A more effective approach is a clearly defined (step-by-step) process flow that accomplishes tasks. As an example, let’s take the simple but repetitive task of onboarding new enterprise customers onto your company’s SaaS offering.
Without a runbook, a new member of your company’s implementation team might need to watch videos, consult with more experienced team members, and try multiple times to get it right.
With a runbook, you can lay out the necessary steps as precisely as possible. Here's what one of these runbooks might look like:
Log in to [application name]
Open [application name] customers tab
Click the "Add new" button
Enter customer information into matching fields
Click save and continue
Select client type
Assign client managerSave and close
Additionally, you can add scripts to runbooks like the above to help cover the capabilities that you'd get from using the cron daemon and task scheduler services for Linux and Windows OS.
Typically, runbooks start as quick solution gateways for ad hoc tasks and fault instances. At the early stages, you may need little to no documentation besides the steps and directions themselves.
One primary benefit of runbooks is that they can be simple but can also support additional complexity. Another major benefit is that runbooks respond to events. Unlike task schedulers and many cron job crunchers, runbooks are repeatable and will fire in response to events that happen outside a preset schedule. This means you can have runbooks trigger processes and, in turn, trigger other runbooks based on their return states. When you get to this level of efficiency, you’ll likely want to infuse controls into runbooks. We’ll discuss controls further in the best practices section.
What is runbook automation?
Runbook automation means automatically running a set of processes when a trigger event takes place to execute them more reliably, quickly, and autonomously.
Let’s consider the following use case:
Say your department carries out a set of repetitive but highly sensitive tasks. Even with a clear runbook to outline the team's sensitive workflows, slight errors can have damaging effects on data integrity. Taking the user out of the equation and letting scripts run autonomously will help uphold data integrity.
Once you've achieved automation, you can layer access controls, input validation, and audit logs to protect sensitive information.
What are the benefits of runbook automation?
To recap, runbook automation lets you take sensitive, technical operations that are executed manually like “run this script to sync data” and turn them into automated processes that don’t require intervention. Some notable benefits include:
- Performance. Executing tasks via scripts is much faster than having employees manually execute the same functions.
- Fewer incidents. You reduce the number of error incidents and guarantee more consistent results when you remove human error.
- Minimize interruptions. Bottlenecks are removed by triggering processes as soon as an event is observed in a system's environment rather than causing interruptions or waiting for users to respond to alerts.
- Accessibility. The operations that these runbooks perform are now available to anyone with access to them rather than a limited set of individuals with prior knowledge.
Overall, automating your runbooks will increase performance and consistency, and minimize interruptions. So, how do we get to a state of automation with runbooks?
Runbook automation best practices
Following some best practices when managing runbooks can help you attain automation more quickly. Here are a couple suggestions:
- Use groups and permission gates to create checks.
- Collect an audit trail for runbooks to track history and edits.
- Test runbooks on staging before pushing them to prod. You want to ensure your workflow only affects the intended elements of your system.
- Keep the individual steps of the runbook simple and focused to enable customization and maximize performance.
- Check for runbook idempotence during the building phase.
Getting started with runbook automation
You can leverage platforms like Airplane runbooks to automate runbooks quickly. Made for developers, Airplane simplifies runbook automation by letting you transform Python, JS, REST, and more into lightweight apps and providing a UI, permissions, audit logs, approval flows, schedules, and more to layer on top.
Other rundeck automation platforms, like Rundeck, require a significant amount of effort put into implementation and maintenance over time. If you're looking for an easy-to-use and simple solution, you can watch a quick demo and sign up for a free Airplane account here.