1 answer

There is no term like limits in the entire openstack installation about the limit to the compute nodes as When it comes to availability in openstack every compute node runs a major service known as nova-compute and neutron-openvswitch-agent.

Now these two services connect to controller via RabbitMQ which is an AMQP broker ( Again it has no limits to the number of connections)

So practically its like the more resources you have the more load your controller can handle. In my experience I was able to add 15 physical compute nodes and for testing I created a fake kind of mechanism and was able to add around 180 compute nodes to controller.

OK... if you are intrested in making fake compute nodes then do the following. There are actually 2 ways of doing it :

Method 1-

Take a physical machine and install docker on it.

Create a lxc container and install nova-compute service on it.

Configure the compute node service running inside the container.

Make sure you do the networking in such a way that you are able to ping the controller from the container.

Start the container.

The service should come up and there should be a compute node added to the controller.

Create as many clones of the container as you want .

So if you have 9 clones then you have 9 fake compute nodes running for testing purpose.

Method 2- This method requires prior knowledge of AMQP server and Messaging application which you are using in openstack environment. In 90% of cases is RabbitMQ. Also you need to have basic knowledge of python as you have to write a small script.

Bring down the nova-compute service running on a compute node.

Once its down, see which exchanges are present on the RabbitMQ server running on the controller.

Bring up the compute node and try to capture the messages that go from compute node to the controller via AMQP server.

To capture messages you need to create a consumer script on the exchange which is getting used for the compute to send messages to the controller.

The messages will be in oslo messaging format and they would be actually in the form of nested python dictionaries.

Once you have all the messages create another python script, and using that script send the messages captured earlier.

When these messages come the controller thinks that a compute node is added to the system.

Create threads of this python script.

Each thread corresponds to a Fake compute node.

Method 2 is somewhat complicated but it would consume the least number of resources as there are no services involved. Just a piece of code along with threading.

You can use any of the methods listed to create a Fake compute node. The agenda of this experiment is just to test how much compute nodes controller in your environment can handle. you wont be able to launch instances or do the networking.