SONATA's Service Platform MANO Framework
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
pipeline
plugins
son-mano-base
son-mano-pluginmanager
son-mano-specificmanager
test/misc
utils
.dockerignore
.gitignore
Jenkinsfile
LICENSE
README.md

README.md

Build Status Join the chat at https://gitter.im/sonata-nfv/5gtango-sp

son-mano-framework

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:

Development

SONATA's MANO framework is designed and implemented with micro-services. The following micro-services are currently implemented:

  1. 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;
  2. son-mano-pluginmanager: every MANO plugin registers to this service, the PM provides a CLI to control and monitor active plugins;
  3. plugins/son-mano-service-lifecycle-management: main orchestration component, manages the lifecycle of the serivces;
  4. plugins/son-mano-function-lifecycle-management: manages the lifecycle of the individual vnfs, based on instructions from the SLM;
  5. plugins/son-mano-placement-executive: manages the communication between placement SSMs and the core of the MANO framework;
  6. son-mano-specificmanager: manages the lifecycle of the SSMs and FSMs;
  7. 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.

Building

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:

  1. docker build -t sonatanfv/pluginmanager -f son-mano-pluginmanager/Dockerfile .
  2. docker build -t sonatanfv/servicelifecyclemanagement -f plugins/son-mano-service-lifecycle-management/Dockerfile .
  3. docker build -t sonatanfv/functionlifecyclemanagement -f plugins/son-mano-function-lifecycle-management/Dockerfile .
  4. docker build -t sonatanfv/specificmanagerregistry -f son-mano-specificmanager/son-mano-specific-manager-registry/Dockerfile .
  5. docker build -t sonatanfv/placementexecutive -f plugins/son-mano-placement-executive/Dockerfile .
  6. docker build -t sonatanfv/placementplugin -f plugins/son-mano-placement/Dockerfile .

Dependencies

Son-mano-framework expects the following environment:

Son-mano-framework has the following dependencies:

Contributing

Contributing to the son-mano-framework is really easy. You must:

  1. Fork this repository;
  2. Work on your proposed changes, preferably through submiting issues;
  3. Push changes on your fork;
  4. Submit a Pull Request;
  5. Follow/answer related issues (see Feedback-Chanel, below).

Installation

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

or

python setup.py develop

Usage

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.

  1. docker network create sonata
  2. docker run -d -p 5672:5672 --name broker --net=sonata rabbitmq:3.6-management
  3. docker run -d -p 27017:27017 --name mongo --net=sonata mongo
  4. HOSTIP=<hosting_ip>
  5. docker run -d --name pluginmanager --net=sonata --network-alias=pluginmanager -p 8001:8001 -e mongo_host=$HOSTIP sonatanfv/pluginmanager
  6. docker run -d --name servicelifecyclemanagement --net=sonata --network-alias=servicelifecyclemanagement sonatanfv/servicelifecyclemanagement
  7. docker run -d --name functionlifecyclemanagement --net=sonata --network-alias=functionlifecyclemanagement sonatanfv/functionlifecyclemanagement
  8. docker run -d --name placementplugin --net=sonata --network-alias=placementplugin sonatanfv/placementplugin
  9. docker run -d --name placementexecutive --net=sonata --network-alias=placementexecutive sonatanfv/placementexecutive 10.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 tests

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 pipeline/unittest.

License

Son-mano-framework is published under Apache 2.0 license. Please see the LICENSE file for more details.

Useful Links


Lead Developers

The following lead developers are responsible for this repository and have admin rights. They can, for example, merge pull requests.

Feedback-Channel