CN-Infra
CN-Infra (cloud-native infrastructure) is a Golang framework for building
control plane agents for cloud-native Virtual Network Functions It is
basically a collection of components/libraries used in most control plane
agents tied together with a common life-cycle management mechanism.
Documentation
Extensive documentation with tutorials & how-to guides can be found at docs.ligato.io.
Quickstart
A very simple example of a control plane agent that uses Etcd as its configuration data store
is as follows:
func main() {
a := agent.NewAgent(agent.AllPlugins(
&etcd.DefaultPlugin,
&resync.DefaultPlugin,
))
if err := a.Run(); err != nil {
log.Fatal(err)
}
}
You can find the above example here, from where it can be
compiled and run in your favorite environment.
Architecture
Each management/control plane app built on top of the CN-Infra framework is
basically a set of modules called "plugins" in CN-Infra lingo, where each
plugin provides a very specific/focused functionality. Some plugins are
provided by the CN-Infra framework itself, some are written by the app's
implementors. In other words, the CN-Infra framework itself is implemented
as a set of plugins that together provide the framework's functionality,
such as logging, health checks, messaging (e.g. Kafka), a common front-end
API and back-end connectivity to various KV data stores (Etcd, Cassandra,
Redis, ...), and REST and gRPC APIs.
The architecture of the CN-Infra framework is shown in the following figure.
The CN-Infra framework consists of a Agent that provides plugin
lifecycle management (initialization and graceful shutdown of plugins)
and a set of framework plugins. Note that the figure shows not only
CN-Infra plugins that are a part of the CN-Infra framework, but also
app plugins that use the framework. CN-Infra framework plugins provide
APIs that are consumed by app plugins. App plugins themselves may
provide their own APIs consumed by external clients.
The framework is modular and extensible. Plugins supporting new functionality
(e.g. another KV store or another message bus) can be easily added to the
existing set of CN-Infra framework plugins. Moreover, CN-Infra based apps
can be built in layers: a set of app plugins together with CN-Infra plugins
can form a new framework providing APIs/services to higher layer apps.
This approach was used in the VPP Agent - a management/control agent
for VPP based software data planes.,
Extending the code base does not mean that all plugins end up in all
apps - app writers can pick and choose only those framework plugins that
are required by their app; for example, if an app does not need a KV
store, the CN-Infra framework KV data store plugins would not be included
in the app. All plugins used in an app are statically linked into the
app.
Available CN-Infra Plugins:
A CN-Infra plugin is typically implemented as a library providing the
plugin's functionality/APIs wrapped in a plugin wrapper. A CN-Infra
library can also be used standalone in 3rd party apps that do not use
the CN-Infra framework. The plugin wrapper provides lifecycle management
for the plugin component.
Plugins in the current CN-Infra release provide functionality in one of
the following functional areas:
- RPC - allows to expose application's API:
- GRPC - handles GRPC requests and allows app plugins to define
their own GRPC services
- REST - handles HTTP requests and allows app plugins to define
their own REST APIs
- Prometheus - serves Prometheus metrics via HTTP and allows
app plugins to register their own collectors
- Data Stores - provides a common data store API for app plugins (the
Data Broker) and back-end clients. The data store related plugins are:
- Consul - key-value data store adapter for Consul
- Etcd - key-value data store adapter for Etcd
- Redis - key-value data store adapter for Redis
- Casssandra - key-value data store adapter for Cassandra
- [FileDB][docs-filedb] - key-value data store using OS filesystem
- Messaging - provides a common API and connectivity to message buses:
- Kafka - adapter for the Kafka message bus (built on top of
Sarama)
- Logging:
- Logrus wrapper - implements logging skeleton
using the Logrus library. An app writer can create multiple loggers -
for example, each app plugin can have its own logger. Log level
for each logger can be controlled individually at run time through
the Log Manager REST API.
- Log Manager - allows the operator to set log
level for each logger using a REST API.
- Health Monitoring - Self health check mechanism between plugins
plus RPCs:
- StatusCheck - allows to monitor the status of plugins
and exposes it via HTTP
- Probe - callable remotely from K8s
- Miscellaneous - value-add plugins supporting the operation of a
CN-Infra based application:
- Config - helpers for loading plugin configuration.
- Datasync - provides data resynchronization after HA
events (restart or connectivity restoration after an outage) for data
stores, gRPC and REST.
- IDX Map - reusable thread-safe map with advanced features:
- multiple subscribers for watching changes in the map
- secondary indexes
- ServiceLabel - provides setting and retrieval of a
unique identifier for a CN-Infra based app. A cloud app typically needs
a unique identifier so that it can differentiated from other instances
of the same app or from other apps (e.g. to have its own space in a kv
data store).
Contributing
If you are interested in contributing, please see the contribution guidelines.