Local Customized Code Execution for Cloud Service Security
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Cloud computing and service-based architectures face challenges in security and performance due to the need for remote access and storage of customized code, leading to potential congestion and communication bottlenecks.
Innovation Solution
Implementing a system that allows customized code to be created and stored locally using a visual code editor like Blockly, which is then executed locally in response to service calls from a remote system, utilizing a localization engine to manage and execute the code securely and efficiently.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If customized code is stored remotely with the remote system, then access to the code is centralized and manageable, but security is compromised and network congestion increases
Solution Approach 1:
The system segments code storage and execution across multiple locations. Customized code is stored locally at edge devices or client systems rather than being centralized in the remote cloud system. This segmentation allows code to be executed locally while still being part of a distributed service architecture, improving security by keeping code close to where it is needed and reducing network dependency.
Solution Approach 2:
The patent implements local quality by enabling each client or edge device to store and execute its own customized code locally. This localizes the code storage and execution quality, allowing each system to operate independently with its own customized logic while still participating in the broader service-based architecture. This reduces network congestion and improves security by eliminating the need to transmit code over the network.
2Productivity
If customized code is executed remotely, then service calls can be processed centrally, but network congestion and communication bottlenecks increase
Solution Approach 1:
The system extracts the code execution function from the remote cloud system and places it at the local edge devices or client systems. By taking out the execution capability from the central remote system, customized code can be executed locally without requiring network communication for each service call. This extraction eliminates network congestion and communication bottlenecks while maintaining service processing efficiency.
Solution Approach 2:
The patent implements self-service by enabling local systems to execute their own customized code independently without requiring remote system intervention for each service call. Each client or edge device serves itself by locally processing service calls using its stored customized code, eliminating the need for continuous network communication and reducing overall system latency.
3Adaptability or versatility
If a service-based architecture is implemented, then code can be reused across applications reducing cost, but security and performance are compromised due to remote access requirements
Solution Approach 1:
The patent maintains universality by implementing a service-based architecture where customized code can be shared and reused across multiple applications and systems. The service registry allows different applications to discover and utilize the same customized code services, achieving code reuse and cost reduction. Simultaneously, the local storage and execution capability ensures that each system can securely run the code locally without compromising security.
Data Source
AI summary
Embodiments facilitate deployment of customized code at a local site, for reference by a service that is being called by a remote system. At a design time, a visual code editor (e.g., Blockly) is utilized to create and store customized code at the local site. During a subsequent runtime, in response to dispatched service call initiated by the remote system, the customized code is retrieved and executed at the local site. By maintaining the customized code locally, embodiments confer security and avoid congestion associated with having the customized code stored remotely (with the remote system). This selective dispatch of a service call for handling by the local customized code, can be implemented based upon an extension scheme.