Getting started with Salt
A couple of days ago I had the chance to spend a full day working with Salt(stack). On my current project we are using a different configuration management tool and my colleagues there claimed that Salt was simpler and more productive. The challenge was easily set, they claimed that a couple of people with no Salt experience, albeit with a little configuration management knowledge, would be productive in a single day.
My preparation was easy, I had to know nothing about Salt….done!
During the day I was working side by side with another colleague who knew little to nothing about Salt. When the day started, the original plan was to do a quick one hour introduction into Salt. But as we like to dive in head first this intro was skipped in favor of just getting started. We used an existing Vagrant box that spun up a Salt master & minion we could work on. The target was to get Salt to provision a machine for XL Deploy, complete with the customizations we were doing at our client. Think of custom plugins, logging configuration and custom libraries.
So we got cracking, running down the steps we needed to get XL Deploy installed. The steps were relatively simple, create a user & group, get the installation files from somewhere, install the server, initialize the repository and run it as a service.
First thing I noticed is that we simply just could get started. For the tasks we needed to do (downloading, unzipping etc.) we didn’t need any additional states. Actually, during the whole exercise we never downloaded any additional states. Everything we needed was provided by Salt from the get go. Granted, we weren’t doing anything special but it’s not a given that everything is available.
During the day we approached the development of our Salt state like we would a shell script. We started from the top and added the steps needed. When we ran into issues with the order of the steps we’d simply move things around to get it to work. Things like creating a user before running a service as that user were easily resolved this way.
Salt uses yaml to define a state and that was fairly straight forward to use. Sometimes the naming used was strange. For example the salt.state.archive uses the parameter “source” for it’s source location but “name” for it’s destination. It’s clearly stated in the docs what the parameter is used for, but a strange convention nonetheless.
We also found that the feedback provided by Salt can be scarce. On more than one occasion we’d enter a command and nothing would happen for a good while. Sometimes there would eventually be a lot of output but sometimes there wasn’t. This would be my biggest gripe with Salt, that you don’t always get the feedback you’d like. Things like using templates and hierarchical data (the so-called pillars) proved easy to use. Salt uses jinja2 as it’s templating engine, since we only needed simple variable replacement it’s hard to comment on how useful jinja is. For our purposes it was fine. Using pillars proved equally straightforward. The only issue we encountered here was that we needed to add our pillar to our machine role in the top.sls. Once we did that we could use the pillar data where needed.
The biggest (and only real) problem we encountered was to get XL Deploy to run as a service. We tried two approaches, one using the default service mechanism on Linux and the second using upstart. Upstart made it very easy to get the service started but it wouldn’t stop properly. Using the default mechanism we couldn’t get the service to start during a Salt run. When we send it specific commands it would start (and stop) properly but not during a run. We eventually added a post-stop script to the upstart config to make sure all the (child) processes stopped properly.
At the end of the day we had a state running that provisioned a machine with XL Deploy including all the customizations we wanted. Salt basically did what we wanted. Apart from the service everything went smooth. Granted, we didn’t do anything exotic and stuck to rudimentary tasks like downloading, unzipping and copying, but implementing these simple tasks remained simple and straightforward. Overall Salt did what one might expect.
From my perspective the goal of being productive in a single day was easily achieved. Because of how straightforward it was to implement I feel confident about using Salt for more complex stuff. So, all in all Salt left a positive impression and I would like to do more with it.