Evangelos Haleplidis

A Web Service- and ForCES-Based Programmable Router Architecture

Programmable networks have accentuated the need for a clear separation of the control and forwarding planes. The IETF ForCES protocol allows control elements to be connected to logically separated forwarding elements. The FlexiNET IST project relies on dynamic service deployment, which requires router programmability in the control and/or forwarding planes. Moreover, to shorten the implementation and deployment time of control elements, there is a need for simple higher-level APIs that shield such elements from ForCES protocol and model details. This paper proposes a ForCES CE Gateway (ForCEG) architecture that fulfills these requirements and maps Web Service interfaces to ForCES messages while checking the validity of commands to ensure consistency of the router state.

Towards a Network Abstraction Model for SDN

Recent advances in networking, namely the reemergence of network programmability with a new name, that of Software-Defined Networking (SDN) have paved the way for a new approach to network datapath configuration. SDN provides an abstraction model of the forwarding plane and separates it from the control plane using open APIs. On the other hand, regarding network infrastructure, motivated by the advances of virtualization, major operators created the Network Function Virtualization (NFV) group, as an Industry Specification Group at the European Telecommunications Standards Institute. NFV’s goal is to define how network functions such as firewalls and load-balancers or any other data or control plane functionality in the mobile and fixed network, can be virtualized and run as software on high-volume servers instead of using specialized hardware. We argue that both SDN and NFV are part of a bigger networking picture, that of the complete lifecycle of the network devices and therefore could take advantage of the definition of a common abstraction model, both for the forwarding model and for the network functions. Such a model will allow interoperability and homogeneity, as well as one protocol, for control, management and orchestration of the network datapath and the network functions respectively. This paper proposes, defines and designs a reference Network Abstraction Model based on a building block approach and demonstrates an initial proof-of-concept implementation.

Software-Defined Networking: Experimenting with the Control to Forwarding Plane Interface

Software-Defined Networking (SDN) is an emerging network architecture where the network control plane is decoupled from the forwarding plane and is programmable via an open protocol. Forwarding and Control Element Separation (Forces) first and OpenFlow later are the prevailing protocols that enable this separation. The differences between the two stem from the underlying models they are defined upon. While OpenFlow is widely used, its capability for adding new functionality of the Forwarding plane is questionable, a fact that is attributed to a restricted model. In contrast, Forces has a very dynamic model that makes its protocol quite powerful but has known little spread due to lack of industry adoption and in the academic world due to lack of open source availability for experimentation. In this paper we first investigate ways of possible confluence or convergence of Forces and OpenFlow and later we explore a real-life service use case for applying a Enabled-enabled OpenFlow switch.

Applying a Web-Service-Based Model to Dynamic Service-Deployment

Owing to the increase in both heterogeneity and complexity in todays networking systems, the need arises for an architecture for network-based services that provides flexibility and efficiency in the definition, deployment and execution of the services and, at the same time, takes care of the adaptability and evolution of such services. In this paper we present an approach that applies a component model to GT4, a Web-service-based grid environment, that enables the provision of parallel applications as QoS-aware (grid) services, whose performance characteristics may be dynamically negotiated between a client application and service providers. Our component model allows context dependencies to be explicitly expressed and dynamically managed with respect to the hosting environment, computational resources, and dependencies on other components. Our work can be seen as a first step towards a component-based programming model for service-oriented infrastructures utilizing standard Web-service technologies

ForCES Applicability to SDN-Enhanced NFV

Networking has seen lately a surge in research and innovation with the re-emergence of network programmability in the form of Software-Defined Networking (SDN), a new approach for network data path configuration. SDN provides an abstraction model of the Forwarding Plane and separates it from the Control Plane using open APIs. In parallel, major telecom operators have embarked on an effort to bring the advantages of virtualization to carrier network infrastructures. Part of this effort was invested in establishing the Network Function Virtualization (NFV) Industry Specification Group (ISG) at the European Telecommunications Standards Institute (ETSI). The NFV goal is to define how Network Functions (ranging from firewalls and load-balancers to routers and access elements) can be virtualized and run as software on high-volume servers instead of specialized hardware. This paper treats SDN and NFV as complementary concepts that together form a bigger picture in the domain of future carrier networks and discusses the complete lifecycle of such a network. In this context we present how ForCES can be used as the foundation for SDN-enhanced NFV and describe the blueprint for the Proof of Concept (PoC) prototype which has been introduced to the NFV ISG. A key goal of this paper is to concisely position carrier NFV and SDN activities under a unified framework.

Network Programmability With ForCES

Network programmability has re-emerged as a top item of the networking research agenda since Software Defined Networking (SDN) gained wide acceptance simultaneously in vendor product line plans and operator expectations for future deployments. Key ingredients for the successful deployment of SDN technologies are standardized models, mechanisms, and protocols for the separation of the control and forwarding planes. The Internet Engineering Task Force (IETF) standardization effort on Forwarding and Control Element Separation (ForCES) has published a set of standards track documents which specify in detail a comprehensive architectural framework and the respective standard protocols which can be employed to implement the separation of these two planes in a flexible, scalable, and vendor-agnostic yet fully interoperable manner. The IETF standards on ForCES define how to achieve said separation through a complete and modular system model of the forwarding plane elements. In the ForCES model every network element is composed of numerous logically separate and well-defined functional entities that cooperate to provide the desired overall functionality, such as a routing or IP switching. The elegance of the model lies in the fact that a ForCES-based implementation of a network element is indistinguishable from a traditional (“closed-box”) network element and therefore can be deployed in the field without any need for migration to a new architecture. Conversely, ForCES allows for rapid prototyping and agile deployment of new architectures as emphasis is placed on software-defined functionality and full programmability. The difference of ForCES from other SDN approaches that depend on logically centralized controllers and the deployment of solely simple or “dumb” switches is that ForCES standards provide a complete toolbox to design, implement, and interoperate ForCES-based network elements with both previously deployed infrastructures as well as in experimental or early-deployment phase endeavors. An example of the former is the implementation of 3GPP-standardized network elements such as a packet gateway (PGW). Examples of the latter include the use of ForCES for network function virtualization (NFV) proofs-of-concepts. This paper surveys the programmable networks and SDN area and provides a comprehensive tutorial on ForCES by summarizing numerous standards documents and thus making the technology easily understood by the wider research community. We present the design goals, choices, and tradeoffs for this standardized approach for network programmability and provide a thorough primer on the ForCES model and protocol. This paper also surveys recent independent interoperable implementations that showcase the full spectrum of ForCES applications in the era of NFV and SDN.

SDN and ForCES based optimal network topology discovery

Software-defined Networking proposes an alternative paradigm on network programmability based on the separation of control and forwarding planes. Discovering network elements in a dynamic and optimized fashion, able to cope with the ever-growing network traffic, is a key requirement for SDN networks, in order to ensure a data centers robustness and manageability. OpenFlows approach for creating the topology map is by exchanging LLDP frames between the controller and the forwarding elements. This paper proposes a better usage of LLDP by taking advantage of existing hardware capabilities to extract information directly from the data plane to the control plane in order to construct a dynamic and automatic topology discovery algorithm. Following this procedure to obtain the topology map and using the IETFs ForCES framework, we managed to model a generic method for extracting the required LLDP information from the datapath to the controller.

A Web-Services Based Architecture for Dynamic-Service Deployment

Due to the increase in both heterogeneity and complexity in todays networking systems, there arises a demand for an architecture for network-based services, that gives flexibility and efficiency in the definition, deployment and execution of the services and at the same time, takes care of the adaptability and evolution of such services. In this paper we present an approach that applies a component model to GT4, a Web-service based Grid environment, which enables the provision of parallel applications as QoS-aware (Grid) services, whose performance characteristics may be dynamically negotiated between a client application and service providers. Our component model allows context dependencies to be explicitly expressed and dynamically managed with respect to the hosting environment, computational resources, as well as dependencies on other components. Our work can be seen as a first step towards a component-based programming-model for service---oriented infrastructures utilizing standard Web services technologies.

Building softwarized mobile infrastructures with ForCES

This paper explores how can one virtualize a mobile packet core infrastructure using the IETF Forwarding and Control Element Separation (ForCES) standard and capitalizing on recent advances in networking, namely Software Defined Networking (SDN) and Network Functions Visualization (NFV). As a case in point we build a proof-of-concept (PoC) implementation of the currently standardized 3GPP Evolved Packet Core (EPC). In doing so, we separate the control from the forwarding plane in SDN terms and enable dynamic deployment and integration of new functionality as softwarized network functions running on off-the-shelf hardware as advocated by NFV. We discuss our implementation experience with the PoC and provide insights for building open 5G mobile infrastructures.

Towards a resource management and service employment framework

Owing to the increase in both heterogeneity and complexity in todays networking systems, the need arises for new network-based services architectures. They must provide flexibility and efficiency in the definition, deployment and execution of the services and, at the same time, handle the adaptability and evolution of such services. In this paper we present an approach that applies a Web-service-based resource management framework. It enables the provision of parallel applications as QoS-aware applications, whose performance characteristics may be dynamically negotiated between a client application and service providers. Our component model allows context dependencies to be explicitly expressed and dynamically managed with respect to the hosting environment, computational resources and dependencies on other components. In such a model the resource management, in terms of representation, allocation and management of the resources, plays a vital role regarding the efficiency of the entire dynamic service deployment architecture.