Control plane functionalities for SDN.
- Getting Started
- Project Overview
- Database utilities
- Control plane functionalities
- Docker
- Requirements
- Links
- Issues
- Contributing
- Versioning
- License
This project provides a collection of modules implementing different control plane functionalities of a Software Defined Network (SDN), including SRv6 tunnel management aspects, exporting and uploading the network topology to a database and monitoring the performance of a network.
The project is part of a larger ecosystem called Research on Open SRv6 Ecosystem (ROSE).
| ROSE Homepage: | https://netgroup.github.io/rose |
| Documentation: | https://netgroup.github.io/rose-srv6-control-plane |
| Report a bug: | https://github.com/netgroup/rose-srv6-control-plane/issues |
| Contact page: | https://netgroup.github.io/rose/rose-contacts.html |
To start using the project, you need to clone this repository:
$ git clone https://github.com/netgroup/rose-srv6-control-planeThis repository is structured as follows:
.
├── db_update # Database utilities
├── control_plane # Control plane modules
├── Dockerfile # Dockerfile
├── LICENSE # Apache 2.0 license text
└── README.md
db_update is a Python library used to connect the Controller to a database. Using this library, the Controller can interact with a database in order to store information like the topology graph of a network.
The control_plane folder contains the two main components of this project:
- Controller, a SDN Controller
- Node Manager, an agent that must be installed on the node that you want to control through the SDN Controller.
The Controller uses a gRPC API to contact the Linux nodes. A gRPC server (Node Manager) must be run on the Linux nodes that you want to control through the Controller. The Controller (i.e. the gRPC client from the point of view of the gRPC protocol) interacts with the gRPC server executed on the nodes to enforce rules or configurations, such as the setup of SRv6 paths and behaviors.
The control-plane modules are organized as follows:
.
├── ...
├── control_plane # Control plane modules
| ├── controller # Controller (gRPC client)
| ├── examples # Usage examples
| ├── node-manager # Node Manager (gRPC server)
| └── protos # Protocol buffer files
└── ...
The control_plane/node-manager package implements the functionalities of an agent which connects a Linux node to the Controller. A Node Manager must be executed on each node that you want to control through the Controller.
Refer the Docker section for details on how to use the Node Manager in a pre-built docker container. For more information about the installation and usage of the Node Manager follow the instructions contained in the README.md file under the node-manager folder.
The control_plane/controller package implements different functionalities of a Controller.
Refer the Docker section for details on how to use the Controller in a pre-built docker container. For more information about the installation and usage of the Node Manager follow the instructions contained in the README.md file under the controller folder.
This project depends on the grpcio library that provides an implementation of the gRPC protocol. gRPC services use Protocol Buffers as Interface Description Language (IDL). Consequently, both the Controller and the Node Manager require some Python classes generated from the .proto files stored in the control_plane/protos folder. The compilation and generation of the Python classes required by the gRPC protocol has been automated in the setup scripts of the Controller and Node Manager.
There are two ways to use the functionalities offered by the Controller. You can execute the Python Command-Line Interface (CLI) provided by the Controller or you can import the Controller modules in your Python application and use the API exposed by the Controller.
For a description of the CLI and the supported commands, see the documentation contained in the control_plane/controller folder.
For a description of the API exposed by the Controller, see the API reference contained in the control_plane/controller folder. Moreover, the usage examples contained in the control_plane/examples folder can be an excellent starting point for understanding how to use the API and the features of the Controller.
From the root directory of the repository execute the following command inorder to build the controller image:
docker build --target controller -t rose-srv6-controller:latest . --no-cache
inorder to build the node-manager image:
docker build --target node-manager -t rose-srv6-node-manager:latest . --no-cache
docker run --name rose-srv6-controller -it rose-srv6-controller:latest bash
Currently the exposed port is 12345
docker run --name rose-srv6-node-manager -p 12345:12345 rose-srv6-node-manager:latest
docker exec -it <container_name> bash
for instance access to rose-srv6-controller with:
docker exec -it rose-srv6-node-manager bash
- Linux kernel >= 4.14
- Python >= 3.6
- Research on Open SRv6 Ecosystem (ROSE): https://netgroup.github.io/rose/
- Source code: https://github.com/netgroup/rose-srv6-control-plane
- Documentation: https://netgroup.github.io/rose-srv6-control-plane
- Report a bug: https://github.com/netgroup/rose-srv6-control-plane/issues
You are welcome to open github issues for bug reports and feature requests, in this repository or in the ROSE repository.
If you want to contribute to the ecosystem, provide feedback or get in touch with us, see our contact page: https://netgroup.github.io/rose/rose-contacts.html.
We use SemVer for versioning.
This project is licensed under the Apache License, Version 2.0.