Cooperative Caching for SDN Policy Distribution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In software-defined networking (SDN) environments, as policies become larger and more complex, managing policy implementation and distribution becomes inefficient due to excessive communication between controllers and nodes, especially when SDN environments are extended outside of centralized on-premises settings, leading to resource consumption and complexity challenges.
Innovation Solution
The method involves chunking policies into variable-sized chunks with corresponding identifications and hashes, distributing these chunks from a controller to an intermediate policy node, and then to edge nodes, using chunk identifications and hashes for efficient policy implementation and management, reducing the need for extensive communication and resource usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If policies are distributed from controller to all nodes in SDN environment, then policy implementation is ensured, but communication overhead and resource consumption increase significantly
Solution Approach 1:
The patent segments policies into reusable policy chunks that are distributed once to an intermediate policy node, which then caches and serves them to multiple edge nodes. This segmentation eliminates the need for the controller to communicate with every node for every policy, significantly reducing communication overhead while ensuring policy implementation through cached chunks.
Solution Approach 2:
The intermediate policy node performs preliminary action by caching policy chunks before they are needed by edge nodes. When edge nodes require policies, they retrieve pre-cached chunks from the intermediate node rather than requesting from the controller, reducing real-time communication overhead while maintaining policy reliability.
2Reliability
If policies are distributed to all nodes in SDN environment, then policy implementation is ensured, but system complexity increases with larger SDN environments
Solution Approach 1:
The patent introduces an intermediate policy node as a mediator between the controller and edge nodes. This intermediary caches policy chunks and handles distribution requests, simplifying the system architecture by reducing the controller's direct communication burden and providing a centralized caching layer that manages complexity in large SDN environments.
Solution Approach 2:
By segmenting policies into reusable chunks and introducing an intermediate layer, the system complexity is managed through modular organization. Policy chunks can be independently cached, retrieved, and managed, making the overall system more scalable and less complex than direct controller-to-node distribution in large environments.
3Reliability
If complete policies are distributed to each node, then policy implementation is complete, but resource consumption and communication time increase
Solution Approach 1:
The patent extracts only the necessary policy chunks from complete policies and stores them in the intermediate policy node's cache. Edge nodes retrieve only the specific chunks they need rather than receiving complete policies, reducing communication time while maintaining policy completeness through selective extraction and caching of relevant chunks.
Solution Approach 2:
Policy chunks are preliminarily extracted and cached at the intermediate node before being requested by edge nodes. This preliminary preparation reduces the time required for policy distribution, as chunks are ready for immediate retrieval rather than being transmitted from the controller at the moment of need, while ensuring complete policy implementation through comprehensive chunk caching.
Data Source
AI summary
Systems, methods, and computer-readable media for distributing policies in a SDN environment through chunking. A policy can be chunked into a plurality of policy chunks having corresponding chunk identifications at a controller of a SDN environment. Each of the plurality of policy chunks can be hashed to create corresponding chunk hashes for each of the plurality of policy chunks. Further, the plurality of policy chunks, the chunk identifications of the plurality of policy chunks, and the chunk hashes of the plurality of policy chunks can be distributed from the controller of the SDN environment to an intermediate policy node in a fabric of the SDN environment. The chunk hashes and the chunk identifications of the plurality of policy chunks can be used to control distribution of the plurality of policy chunks to one or more edge nodes in the SDN environment.