Software Defined Storage with Puppet and ScaleIO
It’s a software-defined world in datacenters these days; everything from compute to networking and storage is becoming yet another application to deploy and manage. Scalability and ease of use and management is becoming the norm for any successful component in a truly software-defined data center.
As part of this push to software-defined scalable storage, EMC recently acquired ScaleIO, a massively scalable converged virtual storage area network (SAN) that is built on top of x86 servers’ internal hard disk drives. As part of my work at the CTO office here in EMC, I was asked to look into how ScaleIO could be easily deployed at scale, in an automated fashion.
Typical ScaleIO installations consist of using ScaleIO’s Python-based install scripts to install and configure the cluster, and a ScaleIO command line interface (CLI) to manage the cluster. Having worked with the ScaleIO manual installation process, I wanted to see if we could provide a more intuitive and consistent interface to installing and managing ScaleIO; one that would remove the error-prone nature of command lines and simplify installations on different platforms.
Shortly after starting this work, we were approached by a large customer who was considering ScaleIO as their Block storage component in a very sizeable deployment. The customer was very clear about their requirements; it had to be scalable and repeatable, it had to be quick and ideally provide management from a single interface.
Puppet Enterprise was the obvious choice for us. It offers customers a single intuitive interface for installing and configuring ScaleIO clusters across multiple platforms. Installation on baremetal would look the same to the storage admin as installing on VMware. ScaleIO management and storage configuration would look exactly the same across all supported platforms, everything could be managed from a single host and, most importantly, there would no longer be a need for custom automation scripts for each platform and component.
As I mentioned earlier in this post, ScaleIO clusters are spread across multiple hosts in a datacenter. Manual installation involves installing the requisite ScaleIO components across multiple hosts, and configuring the cluster when all nodes have been successfully installed. To automate this portion of the process, we created Puppet manifests that allow users to both install and configure the cluster using a single Puppet class. This same Puppet class can then be extended to support multiple platforms with no changes to how users specify the class configuration.
One of the obvious advantages of Puppet’s parameterized classes was the ability to also parameterize the ScaleIO version. This allowed us to support installation of multiple ScaleIO versions using the exact same class definitions and code base. And for customers moving to different versions of ScaleIO, there would be no perceptible difference in how they installed ScaleIO on Linux or VMware.
The management of ScaleIO components and storage configuration was automated using Puppet types and providers. The obvious benefit to us and users is the simplicity of management and deployment from Puppet, combined with the ability for users who have little experience with the ScaleIO CLI to manage ScaleIO using standard Puppet module syntax.
After the first revision of these modules, we were able to deliver a full set of Puppet manifests that installed and configured ScaleIO clusters, together with puppet types and providers that supported all ScaleIO functionality on Linux systems. The major benefit that quickly became apparent when using the modules was the ease of use and deployment that Puppet gave us. We had removed the error-prone nature of command lines, and we had consolidated Python scripts and CLIs into a single set of easily reusable Puppet modules. Deploying new clusters and configuring additional ScaleIO nodes had been reduced to a single Puppet manifest file. Nodes could be added in minutes from a single management server, and provisioning of user storage could be achieved in seconds across huge layers of compute servers.
When presenting this first version of the ScaleIO Puppet modules both internally at EMC and to our customers, the feedback was consistent. Everyone was amazed by the ease of defining configurations in Puppet. More impressive was the ability to configure a functional and working ScaleIO cluster across multiple nodes to provide storage provisioning to users within minutes. Eliminating interaction with CLIs was a huge benefit, as was the native cross-platform support. Puppet Enterprise made it possible for us to give our customers a fully automated ScaleIO deployment to manage clusters at scale across their entire infrastructure, and a truly automated software-defined storage cluster.