API Container Separation for Safety-Critical Software Isolation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Interference between application programming interfaces (APIs) of varying safety assurance levels within a software package can cause unpredictable behavior and malfunctions, particularly in critical systems like automotive systems, leading to potential hazards.
Innovation Solution
Deploy APIs into separate containers based on their safety assurance levels, using feature flags to enable or disable APIs as needed, and route requests to appropriate containers to ensure compliance with safety thresholds, thereby isolating and customizing instances of the software package.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If multiple APIs with different safety assurance levels are deployed in the same container, then device complexity is reduced, but interference between APIs causes unpredictable behavior and safety risks
Solution Approach 1:
The patent segments APIs into separate containers based on their safety assurance levels (e.g., ASIL-A through ASIL-D). Each container hosts APIs with the same safety level, preventing interference between APIs of different safety levels. This segmentation maintains organizational simplicity while ensuring predictable system behavior by isolating safety-critical APIs from non-critical ones.
2Reliability
If APIs are separated into multiple containers based on safety levels, then safety assurance and reliability are improved, but device complexity and deployment complexity increase
Solution Approach 1:
The patent implements a unified container management system that handles multiple safety levels through standardized processes. The same containerization mechanism and deployment procedures are used across all safety levels, making the system universally applicable. This multi-functionality approach ensures that while APIs are separated for safety, the management overhead is minimized through consistent, reusable management patterns.
Solution Approach 2:
The patent introduces a container management intermediary layer that mediates between the diverse API safety requirements and the underlying infrastructure. This intermediary handles the complexity of separating and managing APIs across multiple containers, providing a standardized interface for deployment, monitoring, and resource allocation. The intermediary absorbs the complexity, presenting a simplified view to users while maintaining strict safety separations.
3Adaptability or versatility
If feature flags are used to enable or disable APIs without redeployment, then adaptability and operational flexibility are improved, but the risk of interference between enabled/disabled APIs increases
Solution Approach 1:
The patent combines feature flags with container segmentation to maintain flexibility while preventing interference. APIs are separated into containers based on safety levels, and feature flags within each container control which specific APIs are enabled. This ensures that enabling or disabling an API through feature flags only affects that container's APIs, preventing interference with APIs in other containers. The segmentation isolates the potential harmful effects of feature flag changes.
Data Source
AI summary
Application programming interfaces (APIs) of a software package can be separated into containers to facilitate safety assurance through isolation. For example, a computing system can receive an application request associated with the software package. The software package can include a first set of APIs that is compliant with a safety threshold and a second set of APIs that is noncompliant with the safety threshold. The computing system can determine that the application request corresponds to the first set of APIs. In response, the computing system can identify a first container that includes a first instance of the software package in which the first set of APIs is enabled and the second set of APIs is disabled. Subsequent to identifying the first container, the computing system can forward the application request to the first container that can handle the application request using the first instance of the software package.