Nova The core components of Nova include the following: The nova-api accepts and responds to end- user compute API calls. It also initiates most of the orchestration activities (such as running an instance) as well as enforcing some policies. The nova-compute process is primarily a worker daemon that creates and terminates virtual machine instances via hypervisor APIs (XenAPI for XenServer/XCP, libvirt for KVM or QEMU, VMwareAPI for vSphere, etc.). The nova-scheduler process is conceptually the simplest piece of code in OpenStack Nova: it take a virtual machine instance request from the queue and determines where it should run (specifically, which compute node it should run on).

Neutron plugin agent (quantum-*-agent):Runs on each hypervisor to perform local vswitch configuration. Agent to be run depends on which plugin you are using, as some plugins do not require an agent. dhcp agent (quantum-dhcp- agent):Provides DHCP services to tenant networks. This agent is the same across all plugins. l3 agent (quantum-l3-agent):Provides L3/NAT forwarding to provide external network access for VMs on tenant networks. This agent is the same across all plugins.

Neutron Use Case: Per-tenant Routers with Private Networks A more advanced router scenario in which each tenant gets at least one router, and potentially has access to the OpenStack Networking API to create additional routers. The tenant can create their own networks, potentially uplinking those networks to a router. This model enables tenant-defined multi-tier applications, with each tier being a separate network behind the router. Since there are multiple routers, tenant subnets can be overlapping without conflicting, since access to external networks all happens via SNAT or Floating IPs. Each router uplink and floating IP is allocated from the external network subnet.

Process Flows

AMQP AMQP is the messaging technology chosen by the OpenStack cloud. The AMQP broker, either RabbitMQ or Qpid, sits between any two Nova components and allows them to communicate in a loosely coupled fashion. More precisely, Nova components (the compute fabric of OpenStack) use Remote Procedure Calls (RPC hereinafter) to communicate to one another; however such a paradigm is built atop the publish/subscribe paradigm so that the following benefits can be achieved: Decoupling between client and servant (such as the client does not need to know where the servant reference is). Full a-synchronism between client and servant (such as the client does not need the servant to run at the same time of the remote call). Random balancing of remote calls (such as if more servants are up and running, one-way calls are transparently dispatched to the first available servant).