Do-nothing scripting
source link: https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-the-key-to-gradual-automation/
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
Do-nothing scripting: the key to gradual automation
Every ops team has some manual procedures that they haven’t gotten around to automating yet. Toil can never be totally eliminated.
Very often, the biggest toil center for a team at a growing company will be its procedure for modifying infrastructure or its procedure for provisioning user accounts. Partial instructions for the latter might look like this:
- Create an SSH key pair for the user.
- Commit the public key to Git and push to master.
- Wait for the build job to finish.
- Find the user’s email address in the employee directory.
- Send the user their private key via 1Password.
This is a relatively short example. Sometimes there are 20 steps in the process. Sometimes there are branches and special cases to keep track of as you go. Over time, these procedures can become unmanageably large and complex.
Procedures like this are frustrating because they’re focus-intensive yet require very little thought. They demand our full attention, but our attention isn’t rewarded with interesting problems or satisfying solutions – just another checkbox checked. I have a word for a procedure like this: a slog.
We know that this procedure is ripe for automation. We can easily see how to automate any given step. And we know that a computer could carry out the instructions with far greater speed and accuracy than we can, and with less tendency toward practical drift.
However, automating slogs sometimes feels like an all-or-nothing proposition. Sure, we could write a script to handle step 2, or step 5. But that wouldn’t really make the procedure any less cumbersome. It would lead to a proliferation of single-purpose scripts with different conventions and expectations, and you’d still have to follow a documented multi-step procedure for using those scripts.
This perception of futility is the problem we really need to solve in order to escape from these manual slogs. I’ve found an approach that works pretty reliably: do-nothing scripting.
Do-nothing scripting
Almost any slog can be turned into a do-nothing script. A do-nothing script is a script that encodes the instructions of a slog, encapsulating each step in a function. For the example procedure above, we could write the following do-nothing script:
import
sys
def
wait_for_enter():
raw_input
(
"Press Enter to continue: "
)
class
CreateSSHKeypairStep(
object
):
def
run(
self
, context):
print
(
"Run:"
)
print
(
" ssh-keygen -t rsa -f ~/{0}"
.
format
(context[
"username"
]))
wait_for_enter()
class
GitCommitStep(
object
):
def
run(
self
, context):
print
(
"Copy ~/new_key.pub into the `user_keys` Git repository, then run:"
)
print
(
" git commit {0}"
.
format
(context[
"username"
]))
print
(
" git push"
)
wait_for_enter()
class
WaitForBuildStep(
object
):
def
run(
self
, context):
print
(
"Wait for the build job at {0} to finish"
.
format
(
self
.build_url))
wait_for_enter()
class
RetrieveUserEmailStep(
object
):
def
run(
self
, context):
print
(
"Go to {0}"
.
format
(
self
.dir_url))
print
(
"Find the email address for user `{0}`"
.
format
(context[
"username"
]))
context[
"email"
]
=
raw_input
(
"Paste the email address and press enter: "
)
class
SendPrivateKeyStep(
object
):
def
run(
self
, context):
print
(
"Go to 1Password"
)
print
(
"Paste the contents of ~/new_key into a new document"
)
print
(
"Share the document with {0}"
.
format
(context[
"email"
]))
wait_for_enter()
if
__name__
=
=
"__main__"
:
context
=
{
"username"
: sys.argv[
1
]}
procedure
=
[
CreateSSHKeypairStep(),
GitCommitStep(),
WaitForBuildStep(),
RetrieveUserEmailStep(),
SendPrivateKeyStep(),
]
for
step
in
procedure:
step.run(context)
print
(
"Done."
)
This script doesn’t actually do any of the steps of the procedure. That’s why it’s called a do-nothing script. It feeds the user a step at a time and waits for them to complete each step manually.
At first glance, it might not be obvious that this script provides value. Maybe it looks like all we’ve done is make the instructions harder to read. But the value of a do-nothing script is immense:
- It’s now much less likely that you’ll lose your place and skip a step. This makes it easier to maintain focus and power through the slog.
- Each step of the procedure is now encapsulated in a function, which makes it possible to replace the text in any given step with code that performs the action automatically.
- Over time, you’ll develop a library of useful steps, which will make future automation tasks more efficient.
A do-nothing script doesn’t save your team any manual effort. It lowers the activation energy for automating tasks, which allows the team to eliminate toil over time.
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK