Open Stack

Hi.



I'm looking into reference architectures for OpenStack deployments for a
project taking place soonish. I'm looking to build an OpenStack environment
with an as yet undetermined (but might scale to thousands) compute core
count. It'll most likely be based on 10GbE networking constructs.



I've been tasked with looking at backend storage architecture for the
platform, as well as the bigger picture of how it'll all fit together ­ but
first and foremost, there are a lot of guidelines and requirements for
functionality and a minimum level of service I'd like to meet. One such
minimum requirement is true live migration that my company has told me is a
must from an availability perspective.



After looking over the majority of the documentation that I can find, it
would seem to me, the path of least resistance here is to use a shared
storage mechanism. I've read about two kinds of migration, one being block
based, the other being "true" live.



I've talked to a few experienced openstack users and three of them suggest
that the shared storage path is the sensible path for what we're
undertaking, but I'd like to dig deeper here, as I've been given a lot of
comments by others suggesting that such a platform or mechanism (shared
storage array/SAN style architecture) isn't scalable ­ opting for local
storage inter-node instead.



Personally, I'm not convinced of this entirely, and I perceive that with
modern storage arrays and with some of the controller technology we have
available to us now (think: extremely high performance controllers,
inter-array tiering mechanisms including "hot" or "warm" SSD cache
mechanisms) a shared storage methodology could work very well, be easier to
manage and ultimately be a success.



I've been told by several people that if I used shared storage in an effort
to get to a point where live migration is a possibility and is sane, I leave
myself open to flooding the shared storage backend if I boot up lots of VM's
at once and a lack of IO scalability because my storage is "bound" to what a
storage array is capable of [so, to that end, growing it, scaling it and
making it perform could be expensive], but, again, I'm not sure that's
entirely true due to the significant caching that might take place
internally.



I'm very interested in understanding what others have done here and how they
have tackled such scenarios.



Thank  you for your time, openstack list.



--z




-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.openstack.org/pipermail/openstack/attachments/20130119/bbd91ab6/attachment.html>