The MANO framework is at the core of SONATA's (powered by 5GTANGO) service platform. It consists of a set of loosely coupled components (micro-services) that use a message broker to communicate, thus providing a highly flexible orchestration system. These components are called MANO plugins and can easily be replaced to customize the orchestration functionalities of the platform.
The main orchestration functionalities are currently implemented in the service lifecycle management plugin (SLM). The SLM uses the function lifecycle management plugin (FLM) to perform the tasks on the level of the vnf and the specific manager registry (SMR) for customised life cycle events that are embedded in service specific managers (SSMs) and function specific managers (FSMs). These SSMs and FSMs are processes created by the developer of the service which customise life cycle events of the service or vnf they are attached to. The SLM and FLM create and maintain records for the deployed services and vnfs by using repositories and the SLM informs the Monitoring Manager when a new service or vnfs should be monitored. The SLM and the FLM use the infrastructure adaptor (IA) for all instructions and requests related to the VIMs and WIMs. The MANO Framework requires access to a catalogue for some of its workflows, to fetch descriptors.
The MANO framework exposes the following workflows to its north-bound:
- Instantiate a service
- Terminate a running service instance
- Scale a running service
The MANO framework exposes the following life cycle events to be customised/overwritten by SSMs and FSMs:
- The placement of a service (Placement SSM)
- The configuration of a service (Configure SSM)
- The schedule of a workflow (Task SSM)
- The scaling workfow for a service (Scale SSM)
- Reaction by the MANO Framework on received Monitoring information (Monitoring SSM)
- Start, stop and configureevents for a single VNF (Start/Stop/Configure FSM)
More details on these processes can be found in the wiki. The overall SONATA (powered by 5GTANGO) service platform architecture is available on the website:
SONATA's MANO framework is designed and implemented with micro-services. The following micro-services are currently implemented:
son-mano-base: not a standalone service but a collection of base classes that are used by the other MANO plugins, also contains a message abstraction layer that encapsulates the RabbitMQ related communication code;
son-mano-pluginmanager: every MANO plugin registers to this service, the PM provides a CLI to control and monitor active plugins;
plugins/son-mano-service-lifecycle-management: main orchestration component, manages the lifecycle of the serivces;
plugins/son-mano-function-lifecycle-management: manages the lifecycle of the individual vnfs, based on instructions from the SLM;
plugins/son-mano-placement-executive: manages the communication between placement SSMs and the core of the MANO framework;
son-mano-specificmanager: manages the lifecycle of the SSMs and FSMs;
plugins/son-mano-placement: provides the in-house placement algorithm, if the placement for a service needs to be calculated and there was no Placement SSM provided by the developer, this plugin is used;
Each of these components is entirely implemented in Python.
Each micro-service of the framework is executed in its own Docker container. So 'building' the framework becomes building all the containers. The build steps for this are described in a
Dockerfile that is placed in the folder of each micro service. Building the containers goes is done as follows:
docker build -t sonatanfv/pluginmanager -f son-mano-pluginmanager/Dockerfile .
docker build -t sonatanfv/servicelifecyclemanagement -f plugins/son-mano-service-lifecycle-management/Dockerfile .
docker build -t sonatanfv/functionlifecyclemanagement -f plugins/son-mano-function-lifecycle-management/Dockerfile .
docker build -t sonatanfv/specificmanagerregistry -f son-mano-specificmanager/son-mano-specific-manager-registry/Dockerfile .
docker build -t sonatanfv/placementexecutive -f plugins/son-mano-placement-executive/Dockerfile .
docker build -t sonatanfv/placementplugin -f plugins/son-mano-placement/Dockerfile .
Son-mano-framework expects the following environment:
- Python 3.4
- Docker >= 1.10 (Apache 2.0)
- RabbitMQ >= 3.5 (Mozilla Public License)
- MongoDB >= 3.2 (AGPLv3)
- A repository to store records that excepts our record schemas (https://github.com/sonata-nfv/tng-schema)
- A catalogue to where the descriptors can be requested from
Son-mano-framework has the following dependencies:
- amqpstorm >= 1.4 (MIT)
- argparse >= 1.4.0 (Python software foundation License)
- docker-py == 1.7.1(Apache 2.0)
- Flask >= 0.11 (BSD)
- flask_restful >= 0.3 (BSD)
- mongoengine >= 0.10.6 (MIT)
- pytest-runner >= 2.8 (MIT)
- pytest >= 2.9 (MIT)
- PyYAML >= 3.11 (MIT)
- requests >= 2.10 (Apache 2.0)
- pycrypto >= 2.6.1 (Public Domain)
Contributing to the son-mano-framework is really easy. You must:
- Fork this repository;
- Work on your proposed changes, preferably through submiting issues;
- Push changes on your fork;
- Submit a Pull Request;
- Follow/answer related issues (see Feedback-Chanel, below).
If you do not want to execute the components within a Docker container, you can also install them on a normal machine. Each micro-service contains a
setup.py file so that you can follow the standard Python installation procedure by doing:
python setup.py install
python setup.py develop
To run all components of the MANO framework you have to start their containers. Additionally, a container that runs RabbitMQ and a container that runs MongoDB has to be started. A docker network is facilitating the connections between the containers.
docker network create sonata
docker run -d -p 5672:5672 --name broker --net=sonata rabbitmq:3.6-management
docker run -d -p 27017:27017 --name mongo --net=sonata mongo
docker run -d --name pluginmanager --net=sonata --network-alias=pluginmanager -p 8001:8001 -e mongo_host=$HOSTIP sonatanfv/pluginmanager
docker run -d --name servicelifecyclemanagement --net=sonata --network-alias=servicelifecyclemanagement sonatanfv/servicelifecyclemanagement
docker run -d --name functionlifecyclemanagement --net=sonata --network-alias=functionlifecyclemanagement sonatanfv/functionlifecyclemanagement
docker run -d --name placementplugin --net=sonata --network-alias=placementplugin sonatanfv/placementplugin
docker run -d --name placementexecutive --net=sonata --network-alias=placementexecutive sonatanfv/placementexecutive10.
docker run -d --name specificmanagerregistry --net=sonata --network-alias=specificmanagerregistry -v '/var/run/docker.sock:/var/run/docker.sock' sonatanfv/specificmanagerregistry
Please check specific dockerfiles of each micro-service whether the default ENV variables are correct for your setup.
Unit testing is done through a Jenkinsfile, which can be found on the root of the repository. Specific scripts for unit tests per component can be found in
Son-mano-framework is published under Apache 2.0 license. Please see the LICENSE file for more details.
The following lead developers are responsible for this repository and have admin rights. They can, for example, merge pull requests.
- Thomas Soenen (https://github.com/tsoenen)
- Manuel Peuster (https://github.com/mpeuster)
- Felipe Vicens (https://github.com/felipevicens)