[This blog was written by Avishek Kumar, Product Manager for XtremIO]
Our customers have been using XtremIO extensively in their VMware environments since the initial days of the array’s availability. And the logic is easy to understand – virtual environments typically have a lot of random workloads and duplicate datasets; making XtremIO a perfect fit for those applications. Even if an application might be running a purely sequential workload (as rare as it is), multiple sequential workloads from multiple virtual machines will eventually translate into a highly random access pattern for the storage array. This is where an all-flash array (AFA) like XtremIO with its true scale-out architecture excels by delivering consistent and predictable performance at sub-millisecond response times. VMware has used XtremIO for hosting their Hands-on lab environment at VMworld – and you can find some interesting details in a blog that we wrote about it earlier.
Being a part of the EMC Federation, we have been able to leverage some of the unique relationships that we have with VMware. In a lot of cases, we go way beyond just providing a ‘checkbox’ indicating that a specific product or feature is supported with XtremIO. It is important for the customers to go a bit beyond the feature comparison matrix, and evaluate the real benefits that they are getting with XtremIO in VMware environments. Often times, there are hidden gems that you will be pleasantly surprised to know about! I will focus on some of these integration points with VMware in this blog.
VAAI is a set of APIs from VMware that enables some of the storage administrative tasks to be offloaded from the ESX server to the backend storage arrays. As long as any storage array can interpret/understand these VMware APIs, they can have a checkbox in their data sheets claiming that they support VAAI primitives. XtremIO also recognizes these APIs, but as I mentioned above – we go one step further and add another level of intelligence to provide even greater benefits to the customer.
I will give two examples to illustrate the unique benefits that we provide vis-à-vis VAAI integration (the basic VAAI functionality has been discussed extensively in multiple forums and I will not spend too much time describing the API itself):
- Full Copy or Extended Copy: This VMware API allows any copy operation to be offloaded to the storage array; the benefit being that there is less work to be done by the ESX server and there is less data traveling over the network fabric. The storage array is provided information about the source and destination addresses and the data that needs to be copied – and the server is free to do other ‘stuff’ while the copy operation is taken care of by the storage array.
Typically there is a performance benefit of using this API because the storage platform can copy the data much faster compared to what the ESX server would have been able to accomplish over the network. With XtremIO, the key benefit is that we understand that an ‘Extended Copy’ or an ‘XCOPY’ operation by its very definition is going to create duplicate data on the array.
In XtremIO, you cannot create duplicate copies of data even if you wanted to! Deduplication is a data reduction service in XtremIO that is inline, global and unstoppable. This means that the copy operation initiated by the XCOPY command turns into an operation where all we need to do is create copies of pointers in memory and point them to the existing data. This results in two very important benefits for you:
- Improved application performance: It is important to understand that flash technology is fast, but memory technology is still many times faster than that. Since the XCOPY command essentially translates into a deduplication operation in memory – customers see performance numbers exceeding what their physical infrastructure can support in theory! See this for yourself in the demo below.
XtremIO doesn’t just accelerate XCOPY operations. Any copy operation that you do on XtremIO – for example making a writeable volume clone – is handled with in-memory metadata updates at lightning speed. Think about it for a minute – all the copies of databases, virtual machines or any other application will be created that much faster because the copy operation is entirely metadata driven and happens in memory. In fact, XtremIO snapshots and clones happen even faster still than XCOPY, and you can read about XtremIO snapshots in this blog post.
- Longer SSD life: Since we are implementing the XCOPY (or any other copy operation) in memory – we don’t need to do any I/Os on the SSDs. For you, this means that the SSDs last much longer on XtremIO for the same workload, as compared to other storage technologies where this intelligence is not built in. Most flash arrays make copies through brute force speed while consuming copies amounts of IOPS and bandwidth that the array should be using to serve host I/O. XtremIO makes copies with metadata magic – faster and without the heavy impact on the array.
- Block zeroing or Write-same: VMware recognized that writing a zero block to storage is a very common operation in a real world scenario and that they can make it more efficient. So instead of the ESX server writing zeroes one at a time, this API allows VMware to tell the storage array that it wants to write zeroes over a particular address range – and the storage array will take care of it as long as they understand this VMware API. Like the previous example, this would typically result in performance benefits because the ESX server is no longer busy writing those zeroes to storage. This is especially relevant when you are provisioning ‘EagerZeroedThick’ datastores (recommended for best performance) – where you write a whole lot of zeroes when you provision storage.
As you would expect now, XtremIO takes this story one step further! Since we are a content-based storage array, we have the flexibility to decide how to store data in the array based on the content of the data that is coming in. If writing zeroes efficiently is so important, we can treat it differently. And treat it differently we do! When XtremIO gets a request to write a zero, we will not even create a pointer to it or do any operation on the SSD – we will send an immediate acknowledgement back to the application that the I/O is complete (more details on this in this blog). This is one reason why you should not test our array’s performance by writing zeroes – I can tell you that the performance will be very very fast!!
In the context of this discussion, we do support this specific VAAI primitive – but you get even better performance because of the way the zeroing operation is being handled internally on XtremIO.
XtremIO supports other VAAI primitives also like Atomic test and set (ATS), space reclamation and thin provision stun (TP Stun). I explained the specific ones above to show how we go the extra mile to provide additional (and non-trivial) benefits to our customers in terms of performance and SSD endurance.
Virtual Storage Integrator (VSI) plugin
VSI plugin is a free vSphere web client plugin that enables VMware administrators to view, manage, and optimize storage for their ESX/ESXi servers. It consists of a graphical user interface and the EMC Solutions Integration Service (SIS), which provides communication and access to XtremIO arrays.
At a high level, the VSI plugin allows you to interact with your storage array from a vCenter perspective. For example, can provision VMFS datastores and RDM volumes, create full clones using XtremIO snapshots, view properties of datastores and RDM volumes, extend datastore capacity and do bulk provisioning of datastores and RDM volumes. But this is what you would expect from any VSI plugin! With XtremIO, VSI plugin does much more than the regular stuff!
We have been putting in a lot of optimizations into the VSI plugin to leverage the full potential of XtremIO. Some of the efficiency and ease-of-use features that the VSI plugin includes are:
- Set host parameters to recommended values: We realized very early on that we needed to change the default settings of ESX servers (or any other application server) in order to be able to push the XtremIO array to its full potential. This included things like setting the right native multipathing policy, higher HBA queue depth, disk settings, etc. All of this and much more is documented very well in our product documentation. But lets face it, how many of us actually read the manuals? 🙂
We included an “Easy” button in the VSI plugin wherein we will recognize that the backend storage is XtremIO, and will present you a simple option in the GUI (see below) to enable all the recommended settings for our storage array. All you have to do is to select the options and apply it . This will ensure that all the best practice recommendations for XtremIO are being implemented – how much easier can it get?!
- Optimized settings for VAAI and other ESX operations: I mentioned earlier about the benefit that VAAI provides when you are working with XtremIO. We found out that you can get even better performance when you optimize the IO size that those operations use when working with XtremIO storage arrays. For example, the array performance improves significantly if the IO size used by unmap operation is changed from the default value of 4MB to 16MB. This nugget of information is incorporated into the VSI plugin to make your lives that much easier.
Similarly, we are in the process of changing the recommended IO size for XCOPY operations so that you get the best performance when you are doing any kind of copy operations on the array (see this blog for more details). You can expect to see a lot of these technical optimizations being pushed into the VSI plugin to provide the benefits automatically for you.
- Space reclamation at the datastore level: Space reclamation is a very important operation for any storage array that supports thin provisioning. The reason you need it is because if the application or the ESX Server deletes any data from their file system, the backend storage array knows nothing about that delete operation and continues to show that storage as “used capacity”. The consumed capacity at the array level can therefore balloon very quickly if there are lots of delete/move operations from a VMware perspective.
Space reclamation command is a way for the host to tell the backend arrays to free up the space that the applications are no longer using. VMware has a space reclamation command that can be run at the datastore level. VSI makes your life that much easier by enabling you to do that from the VSI plugin. We are working on a few things to make it even simpler and intuitive in one of the future VSI releases.
It is important to note that the space reclamation command mentioned above is run at the datastore level only. If there are delete operations inside the Virtual Machines, then it is highly recommended to run space reclamation commands inside the VM first and then reclaiming the storage at the datastore level. One way to do that is to use ‘sdelete’ utility for Windows VMs.
- Integration with VMware Horizon View and Citrix XenDesktop: VSI plugin is integrated with VMware Horizon View and Citrix XenDesktop to give you the best performance by leveraging highly efficient XtremIO Snapshots. In a VDI environment when you provision hundreds of VDI images, there is no reason why you should create one image at a time – that is time consuming and an inefficient process!
With XtremIO, VSI plugin has been tuned to create a certain number of VDI images on a single datastore, but additional VDI images are created by taking a snapshot of the original datastore. Since the snapshots are created instantaneously and have no performance impact on the array – this becomes a very efficient and fast operation for the VDI environment.
You can download the latest VSI plugin here (it’s free!) and if you want to see it in action, check out the demo below.
I gave some examples of the kind of features and efficiencies that we have bundled with the VSI plugin. We have a very rich roadmap of many more goodies to be made available for you. If there is anything specific that you think should be automated through the VSI plugin – by all means, let us know!
EMC Storage Analytics (ESA)/vR Ops Integration
EMC Storage Analytics further extends the integration capabilities across EMC and VMware solutions to provide out-of-the-box analytics and visualization across your physical and virtual infrastructure. Storage Analytics provides preconfigured, customizable dashboards so you can optimally manage your storage environment.
ESA interfaces with XtremIO using RestAPI calls and provides an overview of performance, space utilization and space efficiency metrics from the array in a single pane of glass. As an example, the health dashboard will allow you to drill down from a health alert on a VM all the way down to the array and the LUN where that VM is hosted. This enables very quick triaging of any health issues that might come up in your VMware environment. Or you can monitor the deduplication and compression ratios over a period of time and see how the usable capacity has been trending on XtremIO. You can see a glimpse of ESA 3.0 and its integration with XtremIO in the demo below.
Perhaps more relevant to a lot of our customers is the ability of ESA to provide increased insight into storage resource pools to help detect capacity and performance issues so they can be corrected before they cause a major impact. With the built-in machine learning based analytics in ESA, customers can identify anomalous behavior in individual applications, virtual machines and other storage components. The combination of machine learning, deep and granular storage visibility across the EMC product line, along with dashboards built by engineers with decades of experience in performance troubleshooting means that customers can use ESA to stay within their SLAs and reliably predict issues in their environment.
Lastly, we have included a very rich set of dashboards for XtremIO in ESA by default, but it is very easy for you to go in and create your own customized dashboard to monitor a specific aspect of your environment that we have not thought about. There are easy to use templates available to you to help with this process.
At a high level, EMC AppSync allows you to manage XtremIO snapshots from an application perspective. In the context of this blog, I will focus on the special integration that AppSync provides for VMware environments.
Let’s assume that you have multiple VMs on a single datastore and you take a snapshot through AppSync. Behind the covers, we actually take a VMware level snapshot first and use it to provide pretty interesting capabilities for your environment:
- You can restore the entire datastore – wherein all the virtual machines on that datastore will be restored to their previous state. Assuming that you have taken multiple snapshots, AppSync will allow you to choose the snapshot that you want to restore the datastore to, but this is not all that you might want to do in certain situations.
- You may not want to restore/penalize all users using the VMs on that datastore just because one specific VM needs to be restored. With AppSync, you can restore a particular virtual machine within the datastore to a previous state. That’s right – AppSync will identify all the VMs that exist on that datastore and allow you to restore a specific VM, if you wanted to.
- You may not want to restore the entire datastore or even the entire VM – you may want to restore a particular file within a specific VM on a specific datastore. Guess what – AppSync allows you to do that too!
AppSync is supported through the VSI plugin (version 6.4 onwards) also and allows you to configure protection, run AppSync service plans, mount datastores, restore files – all from within vCenter!
I have discussed AppSync’s integration with XtremIO in greater detail here. You can check out a cool demo on this integration in the video below.
We are actively working on a Log Insight management pack for XtremIO. Log Insight integration will enable XtremIO log files to be analyzed automatically and will provide you with performance, health and audit related information in the form of dashboards. Look for more value to be added to the already awesome VSI plugin, AppSync and ESA offerings. As always, we are open to ideas and comments from you – we would really appreciate if you can share your thoughts and feedback on how to make these solutions even better.
We are always looking for opportunities to leverage the XtremIO capabilities in the best possible way. It becomes more relevant in a virtualized environment where the workloads are typically more demanding. The aim is not to do the integrations in order to get an extra ‘checkbox’ in our product datasheets, but to go above and beyond your expectations to provide something truly unique to our solution.