Open Stack

On Wed, 6 Feb 2019, Lars Kellogg-Stedman wrote:

> I'm still not clear on whether there's any way to make this work with
> existing tools, or if it makes sense to figure out to make Nova do
> this or if we need something else sitting in front of Ironic.

If I recall the early conversations correctly, one of the
thoughts/frustrations that brought placement into existence was the
way in which there needed to be a pile of flavors, constantly
managed to reflect the variety of resources in the "cloud"; wouldn't
it be nice to simply reflect those resources, ask for the things you
wanted, not need to translate that into a flavor, and not need to
create a new flavor every time some new thing came along?

It wouldn't be super complicated for Ironic to interact directly
with placement to report hardware inventory at regular intervals
and to get a list of machines that meet the "at least X
GB RAM and Y GB disk space" requirements when somebody wants to boot
(or otherwise select, perhaps for later use) a machine, circumventing
nova and concepts like flavors. As noted elsewhere in the thread you
lose concepts of tenancy, affinity and other orchestration concepts
that nova provides. But if those don't matter, or if the shape of
those things doesn't fit, it might (might!) be a simple matter of
programming... I seem to recall there have been several efforts in
this direction over the years, but not any that take advantage of
placement.

One thing to keep in mind is the reasons behind the creation of
custom resource classes like CUSTOM_BAREMETAL_GOLD for reporting
ironic inventory (instead of the actual available hardware): A job
on baremetal consumes all of it. If Ironic is reporting granular
inventory, when it claims a big machine if the initial request was
for a smaller machine, the claim would either need to be for all the
stuff (to not leave inventory something else might like to claim) or
some other kind of inventory manipulation (such as adjusting
reserved) might be required.

One option might be to have all inventoried machines to have classes
of resource for hardware and then something like a PHYSICAL_MACHINE
class with a value of 1. When a request is made (including the
PHSYICAL_MACHINE=1), the returned resources are sorted by "best fit"
and an allocation is made. PHYSICAL_MACHINE goes to 0, taking that
resource provider out of service, but leaving the usage an accurate
representation of reality.

I think it might be worth exploring, and so it's clear I'm not
talking from my armchair here, I've been doing some
experiments/hacks with launching VMs with just placement, etcd and a
bit of python that have proven quite elegant and may help to
demonstrate how simple an initial POC that talked with ironic
instead could be:

     https://github.com/cdent/etcd-compute

-- 
Chris Dent                       ٩◔̯◔۶           https://anticdent.org/
freenode: cdent                                         tw: @anticdent