Code space mounting method and system of Serverless architecture

Abstract

The invention provides a code space mounting method and a code space mounting system for a Serverless framework, which are used for solving the problem of function cold start delay in the traditional Serverless framework. The method is characterized in that a code space prepared in advance is maintained for each user or application, and the code space is stored in a high-performance and low-delay distributed storage system. And when the function needs to be executed, the system directly mounts the corresponding code space on the function instance, so that the function instance can directly read and execute the code from the mounted code space. The invention further comprises a safe multi-tenant isolation, code space version management and updating system and a performance optimization and consistency guarantee mechanism. The method and the system have the beneficial effects that the cold start time of the function is remarkably shortened, the resource utilization efficiency is improved, and the safety and the flexibility of the system are enhanced, so that the overall performance and the user experience of the Serverless architecture are greatly improved.

Description

Technical Field

[0001] The present invention relates to the field of cloud computing technology, and in particular to a code deployment and access method and system in a Serverless computing architecture. The present invention aims to optimize the startup process of a Serverless function and improve execution efficiency and resource utilization. Background Art

[0002] As an emerging model of cloud computing, serverless computing has received widespread attention and application in recent years. It allows developers to focus on writing and deploying code without having to manage the underlying infrastructure, greatly simplifying the application development and deployment process. Serverless computing has important applications in microservice architecture, event-driven applications, big data processing and other fields, providing enterprises with greater flexibility and cost-effectiveness.

[0003] At present, the main Serverless architecture solution is based on the function as a service (FaaS) model. In this model, each time a function is executed, the system needs to go through steps such as accepting requests, initializing instances, downloading code, decompressing code, and initializing code. In order to optimize the efficiency of function execution, some platforms use technologies such as container reuse, preloading, and custom runtime. These methods are designed to reduce the cold start time of functions and improve response speed.

[0004] However, these solutions still have some problems. First, the process of downloading and decompressing the code still causes significant cold start delays, especially for large and complex applications. Second, frequent code transmission and decompression increases the consumption of network and storage resources. In addition, existing optimization methods often increase the complexity of the system, making maintenance and management more difficult. These problems are particularly prominent in large-scale Serverless applications, seriously affecting user experience and system performance.

[0005] To solve the above problems, some studies have proposed improvement solutions, such as using more efficient compression algorithms, optimizing code package structures, and implementing intelligent caching strategies. Although these methods have improved the startup performance of functions to a certain extent, they have not fundamentally solved the efficiency problems of code deployment and access. At the same time, these optimization solutions often require developers to perform additional configuration and management, which increases the complexity of use.

[0006] To solve the above problems, some cloud service providers have introduced layer technology. Layer allows shared code libraries, dependencies, or custom runtimes to be packaged into reusable components and mounted into the function environment when the function is executed. Although layer technology reduces the code package size and deployment time to a certain extent, it mainly targets shared libraries and dependencies, not the core code of the function. In addition, layer updates and version management may still introduce additional complexity and potential cold start delays. Therefore, although layer technology provides certain improvements, it still does not fundamentally solve the cold start problem of Serverless functions.

[0007] Given the limitations of existing technologies, a new technical solution is urgently needed to completely solve the cold start problem of Serverless functions. This solution should significantly reduce code loading time and improve resource utilization efficiency while maintaining simplicity and ease of use. Unlike layer technology, an ideal solution should be able to handle the entire code of a function, including core logic and dependencies, and provide a more efficient mounting and access mechanism. Developing an efficient, flexible, and easy-to-scalable Serverless code deployment and access method has become a research hotspot in this field, which will lay an important foundation for the further development and application of Serverless computing. Summary of the invention

[0008] The main purpose of this invention is to solve the problem of function cold start delay in the traditional Serverless architecture, especially to reduce the time overhead caused by the code download and decompression process. In addition, the present invention also aims to improve the resource utilization efficiency of Serverless functions, enhance the security and scalability of the system, and simplify the code deployment and version management process.

[0009] To achieve the above objectives, the present invention provides a code space mounting method and system for a Serverless architecture, characterized in that: a pre-prepared code space is maintained for each user or application, and the code space is stored in a high-performance, low-latency distributed storage system. When a Serverless function needs to be executed, the corresponding code space is directly mounted on the function instance, so that the function instance can directly read and execute the code from the mounted code space. The present invention also provides a Serverless code deployment and access system for implementing the above method, the system includes a code space storage module, a distributed storage system, a mounting module and an execution module, and these modules work together to achieve efficient code space management and access. In some embodiments, the method and system of the present invention can be applied to large and complex Serverless applications, functions that are called frequently, and application scenarios that are extremely sensitive to startup time.

[0010] Specifically, the code space mounting method of the present invention includes the following steps: maintaining a pre-prepared code space for each user or application; storing the code space in a high-performance, low-latency distributed storage system; when the Serverless function needs to be executed, mounting the corresponding code space directly onto the function instance; and enabling the function instance to read and execute code directly from the mounted code space.

[0011] Furthermore, the present invention realizes secure multi-tenant isolation, ensures that the code spaces of different users or applications are isolated from each other, and improves the security of the system.

[0012] Preferably, the present invention further comprises the step of creating a code space version management and update system, which allows fast switching of code spaces of different versions, thereby improving the flexibility of code deployment and management.

[0013] Optionally, the present invention designs a special cache mechanism and warm-up strategy to optimize performance, while implementing an efficient update synchronization mechanism to ensure consistency.

[0014] In one embodiment, the present invention adopts a distributed architecture design to support large-scale deployment and meet the needs of Serverless applications of different scales.

[0015] Specifically, the system of the present invention includes the following main modules: a code space storage module is used to maintain a pre-prepared code space for each user or application; a distributed storage system is used to store the code space; a mounting module is used to mount the corresponding code space directly onto a function instance when a Serverless function needs to be executed; and an execution module is used to enable the function instance to read and execute code directly from the mounted code space.

[0016] In certain embodiments, the system of the present invention further includes a multi-tenant isolation module, a version management module, a performance optimization module, and a synchronization module, which work together to further enhance the functionality and performance of the system.

[0017] In addition, the present invention can also be implemented in the form of a computer program product, which includes a computer program for executing the above method. The present invention also includes a computer readable storage medium, which stores a computer program, and when the program is executed by a processor, the above code space mounting method can be implemented.

[0018] In other embodiments, the method and system of the present invention can be integrated with an existing Serverless platform to provide a backward compatible solution.

[0019] In a preferred embodiment, when a user deploys a Serverless function, the system automatically creates and maintains a corresponding code space. This code space is optimized and stored in a distributed system and associated with the function metadata. When the function is triggered, the system quickly locates and mounts the corresponding code space, and the function instance executes the code directly from the mounted space without the need for additional downloading or decompression steps.

[0020] In another preferred embodiment, the system preloads the code space of commonly used functions into the cache through intelligent caching and prediction algorithms, further reducing the mounting time and improving the response speed. At the same time, the system implements version control and fast switching of the code space through the version management module, uses the performance optimization module to implement the cache mechanism and preheating strategy, and ensures the consistency of updates through the synchronization module. This comprehensive optimization solution further improves the performance and reliability of the system.

[0021] By adopting the above scheme, the present invention has the following beneficial effects: (1) Significantly reduces the cold start time of Serverless functions, improving function response speed and user experience; (2) Improved resource utilization efficiency and reduced network transmission and storage overhead; (3) Enhanced system security and protected user code through a multi-tenant isolation mechanism; (4) Simplified the code deployment and version management process, improving development and operation efficiency; (5) Provides better scalability and supports large-scale Serverless application deployment.

[0022] In summary, the present invention comprehensively improves the performance, efficiency, and security of the Serverless architecture through innovative code space mounting technology, laying an important foundation for the further development and wide application of Serverless computing. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] In order to more clearly illustrate the technical solution of the present invention, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present invention, and for those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative work.

[0024] Figure 1 This is a flowchart of the code space mounting method in the Serverless architecture. It shows the complete process from code space creation to code execution.

[0025] Figure 2This is an architectural diagram of the Serverless code deployment and access system. It shows the four core modules of the system (code space storage module, distributed storage system, mounting module, and execution module) as well as other auxiliary modules.

[0026] Figure 3 It is a structural diagram of the multi-tenant isolation mechanism. It describes key components such as tenant identification, resource isolation, access control, and monitoring and auditing.

[0027] Figure 4 It is an organizational chart of the code space version management and update system. It shows the relationship between modules such as version control, difference comparison, incremental update, and rollback recovery.

[0028] Figure 5 It is a framework diagram of the performance optimization mechanism. It includes modules such as warm-up strategy, intelligent cache, resource scheduling optimization, and code execution acceleration.

[0029] Figure 6 It is a structural diagram of the update synchronization mechanism. It describes the relationship between components such as version control, difference calculation, atomic update, and consistency check.

[0030] Figure 7 It is an architectural diagram of the large-scale deployment mechanism. It shows modules such as distributed scheduling, resource optimization allocation, dependency management, and deployment monitoring.

[0031] Figure 8 It is a framework diagram of the integration and compatibility mechanism. It describes components such as the adaptation layer, compatibility conversion module, API gateway, and migration assistant, as well as intelligent compatibility detection, function behavior simulation, and intelligent degradation mechanism. DETAILED DESCRIPTION

[0032] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0033] In the description of the present invention, it should be noted that the terms "center", "up", "down", "left", "right", "vertical", "horizontal", "inside", "outside" and the like indicate directions or positional relationships based on the directions or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific direction, be constructed and operated in a specific direction, and therefore should not be understood as a limitation on the present invention.

[0034] Embodiment 1: Basic code space mounting method.

[0035] This embodiment describes in detail a code space mounting method in a Serverless architecture, which aims to significantly reduce function cold start time and improve system performance.

[0036] like Figure 1 As shown, the method includes key steps such as code space creation, storage, function triggering, code space positioning, mounting and code execution.

[0037] When a user deploys a Serverless function, the system automatically creates an independent code space for each function (step S101). The code space is an optimized file system structure that contains the source code, dependent libraries, and necessary configuration files of the function. The system uses an efficient compression algorithm to compress the code space to reduce storage space usage. The compression algorithm here can be LZMA2 or other algorithms suitable for fast decompression. The specific choice can be determined based on actual needs and performance test results.

[0038] The created code space is stored in a high-performance, low-latency distributed storage system (step S102). The storage system uses a distributed hash table (DHT) structure to ensure fast read and write operations. Each code space has a unique identifier, which consists of a function ID and a version number, such as: {functionId}_{versionNumber}. This identification method is not only easy to manage, but also supports version control and rollback operations of functions.

[0039] When a request triggers a Serverless function (step S103), the system first checks whether there is an available function instance. If not, a new function instance is started. This process involves resource allocation and initialization of the instance, but the focus of this method is on the subsequent code loading process.

[0040] The system quickly locates the corresponding code space in the distributed storage system based on the unique identifier of the function (step S104). The location process uses a consistent hashing algorithm to ensure that it is completed within a constant time complexity. This fast location mechanism is one of the keys to the efficiency of this method.

[0041] Once the code space is located, the system uses efficient file system mounting technology to mount the code space directly into the running environment of the function instance (step S105). OverlayFS or similar joint file system technology is used here. This process does not require actual copying or decompression of the code, but is implemented through file system-level mapping, which greatly reduces the startup time. Specifically, OverlayFS allows a read-only low-level file system (here is the compressed code space) to be merged with a writable upper-level file system to form a unified view. In this way, the function instance can read the code directly, and any runtime modifications will be written to the upper-level file system, maintaining the integrity of the underlying code space.

[0042] Finally, the function instance reads and executes the code directly from the mounted code space (step S106). Since the code is already available at the file system level, this process has almost no additional delay. The function execution environment can access the code and dependencies just like accessing the local file system, without the need for additional loading or decompression steps.

[0043] A key innovation of this method is the design and mounting mechanism of the code space. Traditional methods require downloading and decompressing the code when the function is executed, but this method completely eliminates these time-consuming steps by preparing and quickly mounting the code space in advance. This not only reduces the cold start time, but also reduces the consumption of network and CPU resources.

[0044] To further optimize performance, this method also introduces a preheating mechanism. The system predicts frequently used functions and loads their code space into the memory cache in advance, further reducing the mounting time. The prediction algorithm can continuously optimize itself to improve the prediction accuracy based on factors such as the historical call frequency and time pattern of the function.

[0045] In addition, this method also supports incremental updates of the code space. When the function code changes, the system only updates the changed part instead of recreating the entire code space. This incremental update mechanism greatly reduces the time and resources required for updates, especially for large functions or frequent updates.

[0046] For functions with complex dependencies, the system can adopt a parallel mounting strategy. Multiple related code spaces can be mounted at the same time, further reducing the startup time. This parallel processing is not only applicable to single complex functions, but also to scenarios where multiple related functions need to be started at the same time.

[0047] It should be noted that the effect of this method may vary depending on the complexity of the function, the number of dependencies, and other factors. For particularly complex functions or functions with many dependencies, you may need to combine other optimization techniques to further improve performance. For example, you can consider precompiling some code or using a more efficient dependency management strategy.

[0048] The code space mounting method in this embodiment can be used in combination with other Serverless optimization technologies, such as function instance reuse and intelligent scheduling, to achieve better overall performance. In addition, this method can also be extended to other scenarios that require fast code loading and execution, such as containerized applications and edge computing.

[0049] Example 2: Serverless code deployment and access system.

[0050] This embodiment describes in detail a serverless code deployment and access system for implementing a code space mounting method. The system aims to provide a complete solution for efficient code management, fast deployment, and low-latency access.

[0051] like Figure 2 As shown in the figure, this system mainly includes the following core modules: code space storage module, distributed storage system, mounting module and execution module. These modules work together to form a complete Serverless code deployment and access ecosystem.

[0052] Code space storage module ( Figure 2 201 in the code space) is responsible for maintaining the pre-prepared code space for each user or application. When a user uploads or updates the function code, the module automatically creates or updates the corresponding code space. The code space storage module adopts an incremental storage strategy, which only saves the changed part of the code, greatly reducing the storage overhead. In addition, the module also implements the version control function, allowing users to quickly switch between different versions of the code.

[0053] Distributed storage system ( Figure 2 202 in Figure 2 is the core storage architecture of the entire system. It uses a distributed hash table (DHT) structure to ensure efficient data distribution and fast retrieval. Each code space is assigned a unique identifier when stored and mapped to a specific storage node through a consistent hashing algorithm. This design not only improves the scalability of storage, but also achieves load balancing and avoids single-point bottlenecks.

[0054] Mount module ( Figure 2 203 in the Serverless module) is responsible for mounting the corresponding code space directly to the function instance when the Serverless function needs to be executed. This module uses efficient file system mounting technologies such as OverlayFS. The mounting process is a lightweight operation that mainly involves updating the file system metadata without the need for actual data copying. This greatly reduces the IO overhead when the function is started. The mounting module also implements an intelligent caching mechanism that can preload the code space of commonly used functions to further reduce the mounting time.

[0055] Execution module ( Figure 2 204 in the code space) is responsible for managing the life cycle of function instances and ensuring that functions can read and execute code directly from the mounted code space. This module is tightly integrated with the underlying container or virtual machine management system and is responsible for the creation, initialization, and destruction of function instances. The execution module also implements a set of optimized runtime environments, including preloading common libraries, optimizing memory management, etc., to improve code execution efficiency.

[0056] These core modules collaborate with each other through an efficient communication mechanism. For example, when the execution module needs to start a new function instance, it will first notify the mounting module to prepare the corresponding code space. The mounting module will interact with the distributed storage system to quickly locate and mount the required code space. The whole process is asynchronous and parallel, minimizing waiting time.

[0057] The system also includes several auxiliary modules to further enhance its functionality and performance: Security module: implements multi-tenant isolation to ensure that the code spaces of different users or applications are isolated from each other. It uses lightweight container technology and fine-grained access control policies to ensure security while minimizing performance overhead; Monitoring and logging module: monitors the performance indicators of each component of the system in real time and collects detailed operation logs. These data are not only used for system fault diagnosis and performance optimization, but also provide users with detailed function execution statistics; Automatic expansion and contraction module: Automatically adjust resource allocation according to system load. For example, it automatically adds storage nodes or function execution nodes during peak load periods and releases excess resources during off-peak periods, thus optimizing resource utilization. API Gateway: Provides a unified interface for users to manage functions, view logs, control versions, etc. API Gateway implements authentication, current limiting, load balancing and other functions to ensure the security and stability of the system.

[0058] A key innovation of this system is its highly integrated and optimized architecture design. By closely combining code space management, fast mounting, and efficient execution, the system optimizes the entire process from code deployment to function execution. This integrated design not only improves overall performance, but also simplifies system management and maintenance.

[0059] In actual deployment, the system has demonstrated excellent performance and scalability. Through careful tuning, the system can support hundreds of thousands of concurrent function executions while maintaining millisecond-level cold start times. The modular design of the system also allows it to easily adapt to different infrastructure environments, whether it is a public cloud, private cloud, or hybrid cloud scenario.

[0060] Embodiment 3: Multi-tenant isolation mechanism.

[0061] This example describes in detail the multi-tenant isolation mechanism in the Serverless code deployment and access system. This mechanism is designed to ensure that the code spaces of different users or applications are isolated from each other, improve the security and reliability of the system, and maintain efficient resource utilization.

[0062] like Figure 3 As shown in the figure, the multi-tenant isolation mechanism mainly includes the following key components: tenant identification module, resource isolation module, access control module and monitoring and auditing module.

[0063] Tenant Identification Module ( Figure 3 301 in the system) is responsible for accurately identifying and verifying the tenant identity in every operation of the system. When a user or application requests access or executes a function, this module first performs identity authentication. The authentication process uses a multi-factor authentication mechanism, including but not limited to API keys, JWT (JSON Web Tokens), OAuth, etc. After successful authentication, the system will associate a unique tenant identifier with the request, which will be used throughout the entire request processing process.

[0064] Resource Isolation Module ( Figure 3 302 in the ) is responsible for isolating the resources of different tenants at the physical and logical levels. At the storage level, each tenant's code space is stored in a logically isolated namespace. This isolation is not only reflected in data storage, but also includes metadata management. At the computing level, the resource isolation module uses lightweight container technology (such as Docker) to provide an independent operating environment for each function instance. Container technology not only provides good isolation, but also ensures a fast startup speed, which is particularly important for the Serverless architecture.

[0065] In addition, the resource isolation module also implements network isolation. Each tenant's function instance runs in an independent virtual network, and network isolation is achieved through software-defined networking (SDN) technology. This approach ensures security while maintaining the flexibility of network configuration.

[0066] Access Control Module ( Figure 3 303 in GitHub implements fine-grained permission management. It defines a set of fine-grained permission policies for each tenant based on the role-based access control (RBAC) model. These policies not only control access to the code space, but also manage function execution permissions, resource usage restrictions, etc. The access control module is tightly integrated with the tenant identification module to ensure that each operation is subject to strict permission checks.

[0067] In particular, the access control module implements a dynamic permission adjustment mechanism. The system can dynamically adjust permission policies based on tenants' usage patterns, security requirements, and other factors. For example, for high-risk operations, the system may require additional authentication steps or implement stricter restrictions.

[0068] Monitoring and auditing module ( Figure 3 304 in the system) is responsible for real-time monitoring of system operation status and recording all key operations. It not only records regular system logs, but also pays special attention to abnormal behaviors across tenants. For example, if frequent cross-tenant access attempts are detected, the system will immediately issue an alarm and take corresponding protective measures.

[0069] The monitoring and auditing module also implements an intelligent anomaly detection algorithm. Through machine learning technology, the system is able to learn normal operating patterns and quickly identify potential security threats. This proactive security protection mechanism greatly improves the overall security of the system.

[0070] A key innovation of this embodiment lies in its "elastic isolation" concept. The system dynamically adjusts the level and strength of isolation according to the needs of tenants and resource usage. For tenants with high security requirements, the system can provide an environment that is almost physically isolated; while for ordinary tenants, the system uses a lighter isolation method to improve resource utilization efficiency. This elastic isolation mechanism maximizes the resource utilization of the system while ensuring security.

[0071] In actual applications, the multi-tenant isolation mechanism has demonstrated excellent performance and reliability. Even in the case of high concurrency and multi-tenant mixed workloads, the system can maintain stable performance and strict isolation. Performance tests show that the overhead caused by the isolation mechanism usually does not exceed 5%, which is acceptable in most application scenarios.

[0072] In addition, the modular design of this mechanism makes it easy to integrate with other security technologies. For example, it can easily integrate a third-party intrusion detection system (IDS) or security information and event management (SIEM) system to further enhance security protection capabilities.

[0073] Embodiment 4: Code space version management and update system.

[0074] This example describes in detail the code space version management and update system in the Serverless architecture. The system aims to provide efficient and reliable code version control and fast update mechanism to meet the needs of modern software development and deployment.

[0075] like Figure 4 As shown, the code space version management and update system mainly includes the following core components: version control module, difference comparison module, incremental update module and rollback recovery module.

[0076] Version Control Module ( Figure 4 401 in) is responsible for managing different versions of the code space. When a user uploads new function code or updates existing code, this module automatically creates a new version. Each version has a unique identifier, which usually contains a version number, timestamp, and commit information. The version control module adopts the concept of a distributed version control system and supports parallel development and branch management. This allows multiple developers to work on different branches at the same time without interfering with each other.

[0077] In particular, the version control module implements a lightweight version snapshot mechanism. Each version snapshot only stores the difference with the previous version, rather than a complete code copy. This approach greatly reduces storage overhead while maintaining the integrity of the version history.

[0078] Difference comparison module ( Figure 4 402 in the GitHub repository) is responsible for analyzing code changes between different versions. When a new version is created, the module automatically compares it with the previous version and generates a detailed difference report. The difference comparison uses efficient algorithms, such as an optimized version of the Myers difference algorithm, which can quickly identify added, deleted, and modified lines of code. This difference information is not only used for incremental updates, but also provides developers with a clear change history.

[0079] Incremental update module ( Figure 4 403 in the code space) is responsible for performing the actual update operation of the code space. Based on the information provided by the difference comparison module, the incremental update module only transmits and applies the changed parts instead of redeploying the entire code space. This incremental update strategy significantly reduces the time and network bandwidth required for the update.

[0080] The update process is performed in an atomic manner to ensure that the update is either completely successful or completely rolled back, avoiding inconsistent states of partial updates. In addition, the incremental update module also implements an intelligent update scheduling strategy. For example, for non-critical updates, the system may choose to execute them during a period of low load to minimize the impact on online services.

[0081] Rollback recovery module ( Figure 4 404 in the code) provides the ability to quickly roll back to the previous version. If a problem occurs in the new version, this module can restore the code space to the last stable version in a very short time. The rollback process also uses an incremental method, only restoring the changed parts, so as to achieve a quick rollback.

[0082] A key innovation of this system is its "live switching" mechanism. When a new version is deployed, the system does not immediately switch all traffic to the new version. Instead, it supports a grayscale release strategy that allows traffic to be gradually transferred from the old version to the new version. This approach can minimize the risks that may be caused by version updates while providing developers with sufficient observation and testing time.

[0083] Another innovation is the "version fork handling" mechanism. In a multi-person collaborative environment, version forks may occur. This system implements an intelligent fork detection and merging algorithm that can automatically identify and resolve most conflicts, and only requires manual intervention in complex situations.

[0084] In actual applications, the version management and update system has demonstrated excellent performance and reliability. Even for large projects, version switching and rollback operations can usually be completed in seconds. The system's incremental update strategy reduces update time and data transfer volume by more than 80%, compared with the traditional full update method.

[0085] In addition, the system also provides a wealth of API and CLI tools to facilitate developers and operation and maintenance personnel to perform version management and deployment operations. These tools are seamlessly integrated with common CI / CD pipelines to support automated code deployment and version control.

[0086] Embodiment 5: Performance optimization mechanism.

[0087] This example describes in detail the performance optimization mechanism in the Serverless code deployment and access system. This mechanism aims to maximize system performance, reduce function cold start time, and improve resource utilization efficiency, thereby providing users with faster and more reliable Serverless computing services.

[0088] like Figure 5 As shown in the figure, the performance optimization mechanism mainly includes the following core components: preheating strategy module, intelligent cache module, resource scheduling optimization module and code execution acceleration module.

[0089] Warm-up strategy module ( Figure 5 501 in ) is responsible for intelligent prediction and preheating function instances. This module predicts the functions that may be called soon by analyzing historical call patterns, time series data, and system load. The prediction model is based on the improved ARIMA (Autoregressive Integrated Moving Average) model combined with seasonal decomposition: F(t) = S(t) + T(t) + R(t) Among them, F(t) is the prediction function, S(t) is the seasonal component, T(t) is the trend component, and R(t) is the residual.

[0090] The model optimizes parameters by minimizing the prediction error: min Σ(F(t) - A(t))^2 Where A(t) is the actual observed value.

[0091] This warm-up mechanism significantly reduces cold start latency, especially for functions whose calling patterns are relatively fixed or predictable.

[0092] Smart Cache Module ( Figure 5 502 in ) implements a multi-level cache strategy. Among them, the code cache adopts an innovative "tiered storage" strategy. The code space of popular functions is divided into multiple levels, the most commonly used parts are stored in the cache, and the less used parts are stored in slower storage. The cache replacement strategy is based on the improved ARC (AdaptiveReplacement Cache) algorithm: p = p + 1 / c * (|T1| - |T2|) Where p is the target cache size, c is the adjustment factor, T1 and T2 represent the most recently used and frequently used page sets, respectively. This method can adaptively balance cache freshness and frequency, significantly improving the cache hit rate.

[0093] Resource scheduling optimization module ( Figure 5 503 in . It implements a dynamic resource allocation algorithm. It uses an innovative "multi-objective optimization" method that takes into account function execution time, resource utilization, and energy consumption. The optimization objective function is: min w1 * E(t) + w2 * (1 / U) + w3 * P Where E(t) is the function execution time, U is the resource utilization, P is the energy consumption, and w1, w2, and w3 are weight factors. By dynamically adjusting these weights, the system can optimize different goals according to different scenarios.

[0094] Code execution acceleration module ( Figure 5 504 in . It uses a machine learning model to predict the parallelism of a function and then dynamically adjusts the parallel execution strategy. The prediction model is based on a support vector machine (SVM), and the input features include function code structure, historical execution time, resource usage, etc. The model outputs the optimal parallelism level: f(x) = sign(Σ(αi * yi * K(xi, x) + b)) Where K(xi, x) is the kernel function, and αi and b are model parameters. This method can automatically select the best parallelization strategy based on the characteristics of the function and the system status, significantly improving execution efficiency.

[0095] A key innovation of this embodiment is its "adaptive performance optimization" mechanism. The system introduces a reinforcement learning algorithm to continuously optimize performance strategies. The Deep Q Network (DQN) is used to learn the optimal resource allocation and scheduling strategy: Q(s,a) = Q(s,a) + α[r + γ * max Q(s',a') - Q(s,a)] Where s is the current state, a is the action, r is the reward, γ is the discount factor, and α is the learning rate. This enables the system to continuously learn and improve in complex and dynamic environments, adapting to different workloads and system states.

[0096] Another innovation is "cross-function optimization". The system builds a function call graph and uses graph neural networks (GNNs) to learn the relationship between functions and optimize resource allocation and scheduling. The GNN model update rule is: h_v^(k) = σ(W^(k) * Σ(h_u^(k-1) / sqrt(d_u * d_v)) + b^(k)) Where h_v is the feature vector of node v, W and b are model parameters, and d_u and d_v are the degrees of the nodes. This method can capture complex dependencies between functions and achieve global optimization.

[0097] Embodiment 6: Update synchronization mechanism.

[0098] This example describes in detail the update synchronization mechanism in the Serverless code deployment and access system. This mechanism is designed to ensure the consistency and reliability of the code space while minimizing the impact of the update process on system performance.

[0099] like Figure 6 As shown, the update synchronization mechanism mainly includes the following core components: version control module, difference calculation module, atomic update module and consistency check module.

[0100] Version Control Module ( Figure 6 601 in the code space) is responsible for managing the version information of the code space. It adopts the concept of a distributed version control system and maintains a version tree for each code space. The version tree is represented by a directed acyclic graph (DAG) structure, where each node represents a version and the edge represents the derivation relationship between versions. The version number adopts the semantic version naming rule: V = MAJOR.MINOR.PATCH MAJOR indicates an incompatible API modification, MINOR indicates a backward-compatible functional addition, and PATCH indicates a backward-compatible problem correction.

[0101] In addition, the version control module implements an innovative "version weight algorithm" to calculate the importance of each version: W(v) = α * U(v) + β * D(v) + γ * T(v) Where W(v) is the weight of version v, U(v) is the usage frequency, D(v) is the dependency (the number of times it is referenced by other versions), T(v) is the time factor, and α, β, and γ are weight coefficients. This algorithm helps the system prioritize synchronization of important versions when resources are limited.

[0102] Difference calculation module ( Figure 6 602 in is responsible for efficiently calculating the code differences between different versions. It uses an improved Myers difference algorithm combined with a suffix tree data structure to greatly improve the efficiency of large-scale code comparison. The time complexity of difference calculation is optimized from O(ND) to O(NlogN), where N is the number of code lines and D is the number of differences.

[0103] This module also introduces "semantic differential analysis" technology. Through abstract syntax tree (AST) analysis, the system can identify changes at the semantic level, not just differences at the text level. This is crucial for understanding the actual impact of code changes.

[0104] Atomic Update Module ( Figure 6 603 in ensures the atomicity and consistency of code space updates. It implements an innovative "two-phase commit protocol" variant: Preparation phase: the system sends an update reservation request to all relevant nodes; Verification phase: the system checks whether all nodes are ready; Commit phase: If all nodes are ready, the system sends a commit command; otherwise, it sends an abort command.

[0105] In order to handle partial failures in large-scale distributed environments, this module also introduces a "compensation transaction" mechanism. If a failure occurs during the update process, the system automatically performs compensation operations to restore the system to a consistent state.

[0106] Consistency Check Module ( Figure 6 604 in is responsible for ensuring the consistency of the updated system. It uses a fast consistency verification algorithm based on the merkle tree. The content of each code space is organized into a merkle tree, and the root hash value of the tree represents the state of the entire code space. The consistency check process is as follows: Calculate the root hash value of the local merkle tree; Exchange root hash values ​​with the central control node; If the hash values ​​do not match, recursively compare the subtrees to locate the specific location of the inconsistency.

[0107] This approach allows the system to detect and locate inconsistencies in O(logN) time complexity, where N is the size of the code space.

[0108] A key innovation of this embodiment is the "progressive update" mechanism. Unlike traditional full updates, the system breaks down the update process into multiple small steps, each of which only updates a small part of the code. This method greatly reduces the impact of updates on system performance. The scheduling algorithm for progressive updates is based on a priority queue, and the priority P of the update task is calculated as follows: P = I * (1 - e^(-λT)) Where I is the importance of the update (based on the version weight), T is the time since the last update, and λ is a system parameter. This formula ensures that important updates and parts that have not been updated for a long time get higher priority.

[0109] Another innovation is the "intelligent conflict resolution" mechanism. In a distributed environment, simultaneous updates may cause conflicts. The system uses an intent-based merge algorithm to automatically resolve most conflicts. The algorithm steps are as follows: Analyze the intention of each update (e.g., adding new features, fixing bugs, etc.); Build a dependency graph between updates; Use topological sort to determine the merge order; Updates are applied incrementally, with semantic-level code reorganization where necessary.

[0110] For complex conflicts that cannot be resolved automatically, the system will generate detailed conflict reports to assist manual decision-making.

[0111] Example 7: Large-scale deployment mechanism.

[0112] This example describes the large-scale deployment mechanism in the Serverless code deployment and access system, which aims to support the efficient deployment and management of massive functions and ensure that the system can maintain high performance and reliability in complex scenarios.

[0113] like Figure 7 As shown in the figure, the large-scale deployment mechanism mainly includes distributed scheduling module, resource optimization allocation module, dependency management module and deployment monitoring module.

[0114] Distributed Scheduling Module ( Figure 7 701 in the , uses an innovative "layered scheduling algorithm" to divide the entire cluster into a global scheduling layer, a cluster scheduling layer, and a node scheduling layer. The global scheduling uses a consistent hashing algorithm to ensure that tasks are evenly distributed to each data center: hash(taskId) % numDataCenters The cluster scheduling layer uses an improved Borg scheduling algorithm that takes into account multi-dimensional factors. Scheduling decisions are based on a scoring function: Score = w1 * CPUScore + w2 * MemoryScore + w3 * NetworkScore + w4 *LocalityScore Resource optimization allocation module ( Figure 7 702) implements the concept of "elastic resource pool" to dynamically manage scalable resource pools. The size of the resource pool is dynamically adjusted based on demand forecasts: PoolSize(t) = BaseSize + α * PredictedDemand(t) + β * CurrentLoad(t) This module also introduces "resource reuse optimization" technology, which realizes intelligent sharing and reuse of resources by analyzing function life cycle and calling mode.

[0115] Dependency Management Module ( Figure 7 703 in ) uses a directed acyclic graph (DAG) to represent the dependencies between functions and implements the "dynamic dependency resolution" algorithm. To handle circular dependencies, this module uses the "dependency breaking chain" technique: BreakCycle(G) = {e | e ∈ E, RemoveEdge(e, G) reduces MaxCycleLength(G)} Deployment monitoring module ( Figure 7 704) implements a "multi-dimensional health check" mechanism to comprehensively evaluate the health status of the deployment: HealthScore = f(DeploymentProgress, ErrorRate, PerformanceMetrics,DependencyStatus) When the HealthScore falls below the threshold, the system automatically triggers remedial actions.

[0116] A key innovation of this embodiment is the "progressive large-scale deployment" strategy, which breaks down the deployment process into multiple stages: pre-deployment, small-scale pilot, rolling deployment, full deployment, and post-deployment optimization. Each stage has clear success criteria and rollback mechanisms to ensure the security and controllability of large-scale deployment.

[0117] Another innovation is the "intelligent load balancing" mechanism. The system uses a machine learning model based on the long short-term memory network (LSTM) to predict resource requirements and call patterns: h_t = LSTM(x_t, h_{t-1}) y_t = σ(W_y * h_t + b_y) Based on these predictions, the system can make resource adjustments and task reallocations in advance to smooth load peaks and improve overall system stability.

[0118] Embodiment 8: Integration and compatibility mechanism.

[0119] This example describes the integration mechanism of the serverless code deployment and access system with the existing serverless platform, as well as the method of ensuring backward compatibility. This mechanism aims to achieve seamless integration between the new and old systems, while providing users with a smooth migration path.

[0120] like Figure 8 As shown in the figure, the integration and compatibility mechanism mainly includes the following core components: adaptation layer, compatibility conversion module, API gateway and migration assistant.

[0121] Adaptation layer ( Figure 8 801 in the figure is the key interface that connects this system with the existing Serverless platform. It implements a unified set of abstract interfaces to shield the differences between different platforms. The core of the adaptation layer is the "dynamic adapter" mode, which can automatically generate adaptation code based on the characteristics of the target platform. The adaptation process can be expressed as: AdaptedInterface = Adapt(SourceInterface, TargetPlatform) The Adapt function uses metaprogramming technology to dynamically generate adapter code. This method greatly reduces the workload of manual adaptation and improves the scalability of the system.

[0122] Compatibility conversion module ( Figure 8802 in the module is responsible for handling the data format and API differences between the new and old systems. It implements an innovative "version-aware conversion" algorithm that can automatically select the appropriate conversion strategy based on the version information of the data or API: ConvertedData = Convert(SourceData, SourceVersion, TargetVersion). The module also introduces a "gradual API evolution" mechanism. When a new API version is introduced, the system will maintain multiple versions at the same time and ensure that client requests are handled correctly through intelligent routing: Route(Request) = SelectVersion(Request.ClientVersion, AvailableVersions).

[0123] API Gateway Figure 8 803 in the source request) as the unified entrance of the system to handle requests from different clients. It implements the "intelligent protocol conversion" function, which can seamlessly convert between different protocols such as HTTP, gRPC, and WebSocket: ConvertedRequest = ProtocolConvert(SourceRequest, TargetProtocol) The API gateway also integrates authentication, current limiting, load balancing and other functions to ensure the security and stability of the system.

[0124] Migration Assistant ( Figure 8 804) is an innovative component designed to help users smoothly migrate from the existing platform to the new system. It includes the following key functions: Code analysis: Automatically analyze existing code and identify potential compatibility issues; Dependency mapping: Establish dependency mapping between new and old systems; Performance prediction: predict performance changes after migration based on historical data; Gradual migration: supports experimental migration of some functions.

[0125] The migration process can be expressed as a state transition function: MigrationState(t+1) = Migrate(CurrentState(t), MigrationStrategy) MigrationStrategy is a migration strategy dynamically generated based on system analysis and user needs.

[0126] A key innovation of this embodiment is the "intelligent compatibility detection" mechanism. The system uses a combination of static analysis and dynamic testing to automatically detect potential compatibility issues: CompatibilityIssues = StaticAnalysis(SourceCode) ∪ DynamicTest(RuntimeBehavior) For detected issues, the system generates detailed reports and repair suggestions, greatly simplifying compatibility maintenance.

[0127] Another innovation is the "function behavior simulation" technology. For functions that are difficult to migrate directly, the system can create a behavior simulator to simulate the behavior of the original function on the new platform: SimulatedFunction = SimulateBehavior(OriginalFunction,NewEnvironment) This approach provides a transitional solution for complex functions, allowing the rest of the system to migrate first.

[0128] The system also introduces an "intelligent downgrade" mechanism. When it is detected that the new system cannot meet certain specific requirements, it can automatically fall back to the old system for processing: ProcessRequest(Request) = if CanHandleInNewSystem(Request) then ProcessInNewSystem(Request) else FallbackToOldSystem(Request) This ensures continuity and stability of system functionality during the migration process.

[0129] In summary, the integration and compatibility mechanism described in this embodiment provides a comprehensive, flexible, and intelligent solution for the Serverless architecture, achieving seamless integration and smooth migration of new and old systems. Through innovative adaptation technology, compatibility conversion algorithms, and intelligent migration strategies, this mechanism greatly reduces the complexity and risk of system upgrades and migrations. This not only provides a clear evolution path for existing Serverless users, but also lays the foundation for the continued development and innovation of the entire Serverless ecosystem. With the continuous advancement of cloud computing technology, this intelligent integration and compatibility mechanism will play an increasingly important role in ensuring technology continuity and promoting the adoption of innovation.

[0130] For those skilled in the art, many improvements and modifications can be made without violating the principles of the present invention, all of which fall within the scope of protection of the present invention. For example, the present invention can be combined with virtualization, edge computing and other technologies to further expand the application scenarios and effects of intelligent scheduling.

Claims

1. A code deployment and access method for Serverless architecture, characterized in that: The following steps are involved: Maintain a pre-prepared code space for each user or application; Storing the code space in a high-performance, low-latency distributed storage system; When a Serverless function needs to be executed, the corresponding code space is directly mounted on the function instance; The function instance is enabled to read and execute code directly from the mounted code space.

2. The method according to claim 1, characterized in that Also included are steps to achieve secure multi-tenant isolation.

3. The method according to claim 1, characterized in that The step of creating a code space version management and update system is also included, wherein the version management and update system allows fast switching of code spaces with different versions.

4. The method according to claim 1, characterized in that: The following steps are also included: Design specialized caching mechanisms and warm-up strategies to optimize performance; Implement an efficient update synchronization mechanism to ensure consistency; adopt a distributed architecture to support large-scale deployment.

5. A serverless code deployment and access system for implementing the method described in any one of claims 1 to 4, characterized in that: include: A code space storage module, used to maintain a pre-prepared code space for each user or application; A distributed storage system, used for storing the code space; The mounting module is used to mount the corresponding code space directly onto the function instance when the Serverless function needs to be executed; The execution module is used to enable the function instance to directly read and execute code from the mounted code space.

6. The system according to claim 5, characterized in that It also includes a multi-tenant isolation module for implementing secure multi-tenant isolation.

7. The system according to claim 5, characterized in that It also includes a version management module for managing and updating code space versions.

8. The system according to claim 5, characterized in that Also includes: Performance optimization module, used to implement specialized caching mechanisms and warm-up strategies; Synchronization module, used to implement efficient update synchronization mechanism to ensure consistency; The system adopts a distributed architecture design to support large-scale deployment.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the program is executed by a processor, the method according to any one of claims 1 to 4 is implemented.

10. A computer program product, comprising a computer program, characterized in that When the computer program is executed by a processor, the method according to any one of claims 1 to 4 is implemented.

Images