FaaS Framework Cross-Cloud Function Invocation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing distributed computing systems face challenges such as communication issues, including lost or delayed messages, and service crashes during function calls, which can lead to unreliable execution of microservices and functions.
Innovation Solution
The proposed solution involves a FaaS (Functions as a Service) framework that enables the execution of self-contained, reusable code blocks across multiple clouds, using REST and JSON for interaction. This framework receives an API call, generates a second API call to direct machines in a second cloud to invoke a corresponding function, and discards the function after execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If distributed computing systems use RPC/RMI for service communication, then service interaction capability is improved, but communication reliability deteriorates due to message loss, delays, and service crashes
Solution Approach 1:
The patent introduces an event-driven architecture with message queues and event subscribers as intermediaries between services. Instead of direct RPC/RMI calls, services publish events to a message queue and subscribers process these events asynchronously. This intermediary layer decouples services, preventing direct communication failures from propagating and improving reliability while maintaining interaction capability.
Solution Approach 2:
The patent implements transient function execution where functions are instantiated, executed, and discarded for each event processing task. These short-lived function instances handle specific events and are then destroyed, preventing persistent service crashes from affecting the entire system. The disposable nature of these function objects isolates failures to individual task executions rather than permanent service failures.
2Device complexity
If monolithic architecture is used, then system simplicity is improved, but modularity and code reusability deteriorate
Solution Approach 1:
The patent segments monolithic applications into independent, reusable functions that can be executed individually. Each function represents a discrete unit of business logic that can be independently developed, tested, and deployed. The event-driven architecture further segments the system into event producers, message queues, and event subscribers, allowing modular components to be developed and maintained separately while maintaining overall system simplicity through standardized event processing.
3Adaptability or versatility
If microservice oriented architecture is adopted, then code modularity is improved, but infrastructure complexity deteriorates
Solution Approach 1:
The patent creates a universal FaaS framework that provides standardized infrastructure for executing microservices. The framework handles common infrastructure concerns such as function instantiation, event routing, and resource management through a unified architecture. This universal layer simplifies infrastructure complexity by providing consistent mechanisms for deploying and managing diverse microservices across different cloud platforms, reducing the need for platform-specific infrastructure management.
Data Source
AI summary
Some embodiments of the invention provide a method for providing functions as a service (FaaS). At a FaaS framework executing in a first cloud, the method receives a first API (Application Programming Interface) call invoking a first function that is defined by the framework. At the FaaS framework, the method generates, from the first API call, a second API call that directs a set of machines in a second cloud to invoke a second function that performs a desired operation of the first function in the second cloud. At the FaaS framework, the method forwards the second API call to the second cloud for the set of machines to instantiate the second function after receiving the second API call, to use the second function to perform the desired operation, and to discard the second function after performing the desired operation.