CN113282377B - Code loading method, equipment, system and storage medium under server-free architecture - Google Patents
Code loading method, equipment, system and storage medium under server-free architecture Download PDFInfo
- Publication number
- CN113282377B CN113282377B CN202110833871.1A CN202110833871A CN113282377B CN 113282377 B CN113282377 B CN 113282377B CN 202110833871 A CN202110833871 A CN 202110833871A CN 113282377 B CN113282377 B CN 113282377B
- Authority
- CN
- China
- Prior art keywords
- code
- data
- function instance
- data part
- metadata
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000011068 loading method Methods 0.000 title claims abstract description 38
- 238000000034 method Methods 0.000 claims abstract description 72
- 230000008569 process Effects 0.000 claims abstract description 49
- 239000012634 fragment Substances 0.000 claims abstract description 25
- 230000006870 function Effects 0.000 claims description 289
- 230000015654 memory Effects 0.000 claims description 84
- 238000004590 computer program Methods 0.000 claims description 36
- 230000004044 response Effects 0.000 claims description 9
- 230000000875 corresponding effect Effects 0.000 description 62
- 238000010586 diagram Methods 0.000 description 15
- 238000004891 communication Methods 0.000 description 11
- 238000005516 engineering process Methods 0.000 description 11
- 238000006243 chemical reaction Methods 0.000 description 7
- 238000012545 processing Methods 0.000 description 7
- 230000006835 compression Effects 0.000 description 6
- 238000007906 compression Methods 0.000 description 6
- 230000005291 magnetic effect Effects 0.000 description 6
- 230000003287 optical effect Effects 0.000 description 3
- 230000005540 biological transmission Effects 0.000 description 2
- 238000013075 data extraction Methods 0.000 description 2
- 238000011161 development Methods 0.000 description 2
- 230000000977 initiatory effect Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012544 monitoring process Methods 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 230000001276 controlling effect Effects 0.000 description 1
- 238000012937 correction Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000002452 interceptive effect Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Transfer Between Computers (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The embodiment of the application provides a code loading method, equipment, a system and a storage medium under a server-free architecture. In the embodiment of the application, in the Serverless architecture, the function code uploaded by the user is converted into the code format with the metadata separated from the data part for storage, so that under the condition that the trigger event corresponding to the function code occurs, the directory view required by the function instance supporting the function code operation can be generated based on the metadata in the storage system, further, in the operation process of the function instance, the data part can be downloaded on demand based on the directory view, the data fragment required by the operation is provided for the function instance, and the downloading on demand can be realized without downloading all the function codes at one time, so that the downloading time is saved, and the loading and starting efficiency of the function code is improved.
Description
Technical Field
The present application relates to the field of cloud computing technologies, and in particular, to a code loading method, device, system, and storage medium under a server-less architecture.
Background
With the maturity of technologies such as cloud, big data, container, etc., a Serverless architecture (Serverless) comes into force. In a mode of combining a Serverless architecture with cloud computing, a user only needs to be dedicated to code implementation of application logic, and deployment and maintenance of infrastructures such as a server and the like and flexible expansion capacity of computing resources and the like are all in charge of the Serverless platform.
Under a server architecture, after a user realizes a code, the code is compressed and uploaded to an Object Storage Service (OSS) system; the Serverless platform responds to a user request or a trigger event, and downloads a code compression packet from the OSS system to a host node; and the host machine node decompresses the code compression package to the specified file directory, calls a kernel-state mounting command to mount the specified file directory to a specified container on the host machine node, and runs the codes in the specified file directory by the specified container so as to start the user application.
In the implementation of the existing Serverless architecture, a code loading process is the last loop of application starting, and a downloading and decompressing process of a code compression packet is a time-consuming operation, so that the application starting efficiency is slow, and even the bottleneck of application cold starting is formed.
Disclosure of Invention
Various aspects of the present application provide a code loading method, device, system and storage medium under a server-less architecture, so as to download required data as needed and improve code loading efficiency.
An embodiment of the present application provides a Serverless network system, including: the system comprises a main control node, a plurality of computing nodes and a storage system; the main control node is used for converting the function codes uploaded by the user into a code packet of a preset type and uploading the code packet to the storage system, wherein the code packet comprises metadata and a data part; responding to a trigger event corresponding to the function code, and sending a code starting instruction to a host node in the plurality of computing nodes, wherein the host node is a computing node running an objective function instance supporting the function code to run; and the host node is used for generating a directory view corresponding to the data part based on the metadata in the storage system under the condition that the code starting instruction is received, and downloading the data part in the storage system on demand based on the directory view in the running process of the target function instance so as to provide the data fragment required by current running for the target function instance.
The embodiment of the present application further provides a code loading method under the Serverless architecture, including: converting function codes uploaded by a user into a code packet of a preset type, and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part; generating a directory view corresponding to the data part required by the running of an object function instance supporting the running of the function code based on the metadata in the storage system in response to a trigger event corresponding to the function code; and in the running process of the target function instance, downloading the data part in the storage system on demand based on the directory view so as to provide the data fragment required by the current running to the target function instance.
An embodiment of the present application further provides a node device, which can be implemented as a master control node in a server-less network system, where the node device includes: a memory and a processor; the memory is used for storing a computer program; the processor is coupled with the memory for executing the computer program for: converting function codes uploaded by a user into a code packet of a preset type, and uploading the code packet to the storage system, wherein the code packet comprises metadata and a data part; responding to a trigger event corresponding to the function code, sending a code starting instruction to a host node in a plurality of computing nodes in the serverless network system, so that the host node generates a directory view corresponding to the data part required by the operation of an objective function instance based on metadata in the storage system, and downloading the data part in the storage system as required based on the directory view in the operation process of the objective function instance; wherein the host node is a computing node running an object function instance supporting the function code to run.
An embodiment of the present application further provides a node device, which may be implemented as a host node in a serverless network system, where the node device includes: a memory and a processor; the memory is used for storing a computer program; the processor is coupled with the memory for executing the computer program for: receiving a code starting instruction sent by a main control node in response to a trigger event corresponding to a function code, converting the function code into a code packet of a preset type and uploading the code packet to the storage system, wherein the code packet comprises metadata and a data part; and generating a directory view corresponding to the data part required by the operation of the target function instance based on the metadata in the storage system, and downloading the data part in the storage system as required based on the directory view in the operation process of the target function instance to provide the data fragment required by the current operation for the target function instance, wherein the target function instance is a function instance which is operated on the node equipment and supports the operation of the function code.
Embodiments of the present application also provide a computer-readable storage medium storing a computer program, which, when executed by a processor, causes the processor to implement the steps in the method of the embodiments of the present application.
Embodiments of the present application also provide a computer program product, which includes a computer program/instruction, and when the computer program/instruction is executed by a processor, the processor is caused to implement the steps in the method of the embodiments of the present application.
In the embodiment of the application, in the Serverless architecture, the function code uploaded by the user is converted into the code format with the metadata separated from the data part for storage, so that under the condition that the trigger event corresponding to the function code occurs, the directory view required by the function instance supporting the function code operation can be generated based on the metadata in the storage system, further, in the operation process of the function instance, the data part can be downloaded on demand based on the directory view, the data fragment required by the operation is provided for the function instance, and the downloading on demand can be realized without downloading all the function codes at one time, so that the downloading time is saved, and the loading and starting efficiency of the function code is improved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
fig. 1a is a schematic structural diagram of a Serverless network system according to an embodiment of the present application;
fig. 1b is a schematic diagram of an internal structure of each node in a Serverless network system according to an embodiment of the present application;
fig. 1c is a schematic internal structure diagram of each node in another Serverless network system according to the embodiment of the present application;
fig. 1d is a schematic internal structure diagram of each node in another Serverless network system according to the embodiment of the present application;
fig. 2 is a schematic flowchart of a code loading method under a Serverless architecture according to an embodiment of the present application;
fig. 3 is a schematic structural diagram of a node device according to an embodiment of the present application.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be described in detail and completely with reference to the following specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
The embodiment of the present application provides a network system 100, and the network system 100 adopts a Serverless architecture, and therefore may be referred to as a Serverless network system. The network system 100 can provide user-mode services for users, and the users only need to write function codes for implementing application logic, package the function codes and upload the function codes to the network system 100, and the specific execution of each function code is taken charge of by the network system 100. Wherein, allowing a user to configure a corresponding trigger event for the function code, and under the condition that the trigger event occurs, the network system 100 allocates a computing resource for the function code, and loads and runs the function code; in case of not needing to run the function code, the computing resource is reclaimed again. The user does not need to care about the problem of a computing resource layer, so that the user development becomes more convenient, the development burden of the user is reduced, and better experience is brought to the user. In addition, the network system 100 of this embodiment has higher availability, and can elastically stretch the computing resources allocated to the function codes in real time, so that less computing resources can be used to support the application requirements during the application peak, and more computing resources can be allocated in time during the expected or unexpected application peak, thereby ensuring smooth operation of the application.
The network system 100 of the embodiment may be applied to various scenarios, such as Internet of Things (IoT), mobile applications, audio/video processing, voice recognition, online translation, and other scenarios. For example, in an IoT scenario, a user may write function code for real-time data classification processing and upload the function code into the network system 100, allocate computing resources for the function code and run the function code by the network system 100 in case of a trigger event, to provide efficient real-time data classification service for the outside, and may also flexibly adjust the computing resources allocated to the function code according to real-time data classification needs. For another example, in an audio/video processing scenario, a user may write function codes with multiple functions, such as audio/video transcoding, data extraction, and face recognition, and upload the function codes to the network system 100, and the network system 100 allocates computing resources to the function codes and runs the function codes when a trigger event occurs, so as to provide services, such as audio/video transcoding, data extraction, and face recognition, to the outside, and flexibly adjust the computing resources allocated to the function codes according to application requirements, thereby meeting high requirements of the user on real-time performance and concurrency capability.
In order to implement the above functions, as shown in fig. 1a, a network system 100 provided in an embodiment of the present application includes: a master node 10, a plurality of computing nodes 20, and a storage system 30. The main control node 10 is communicatively connected to a plurality of computing nodes 20 and a storage system 30, and the computing nodes 20 are also communicatively connected to the storage system 30.
The main control node 10 is a management and control node in the network system 100, and is mainly responsible for at least one of resource scheduling, security control, system monitoring and error correction in the network system 100. In addition, the main control node 10 may also be used as an interactive interface with the user, and is responsible for receiving the function codes uploaded by the user and the related information. The number of the master nodes 10 may be one or more. The master node 10 may be deployed in one or more cloud computing data centers, or alternatively, may be deployed in one or more conventional data centers; of course, the master control node 10 may also be deployed in the network system 100, for example, the master control node 10 may be deployed independently from the plurality of computing nodes 20, for example, on other physical devices in the network system 100, which is not limited in this embodiment.
The computing node 20 is a resource node in the network system 100, and is mainly responsible for providing various resources, such as computing resources of a physical machine, a CPU, a GPU, and the like, storage resources of a memory, a hard disk, and the like, and network resources of a bandwidth, and is also a scheduling object of the main control node 10. In this embodiment, the computing node 20 may be various physical devices with certain computing capabilities, such as a server, a cabinet, a CPU, a GPU, a core network device, a base station, an edge gateway, a home gateway, a computing device, and/or a storage device. Accordingly, the storage system 30 is primarily responsible for storing function codes uploaded by users, which may include, but are not limited to: object Storage Service (OSS), Network Attached Storage (NAS), data warehouse or various types of databases, and the like.
In this embodiment, the main control node 10 may receive a function code uploaded by a user, store the function code in the storage system 30, perform resource scheduling on the computing node 20 when the function code needs to be executed, allocate a host node to the function code from the computing node 20, and create or pre-create a function instance supporting the function code to be executed in real time on the host node. The function instance refers to an execution environment that runs on the computing node 20 relatively isolated and can support function code execution, and may be, for example, a container, a virtual machine, or other similar execution environments. When the function instance runs the function code, the function code needs to be downloaded from the storage system 30, and further, if the function code is compressed, the function code needs to be decompressed. On the basis of the function code, the function instance can load and run the function code.
In order to improve the loading efficiency of the function codes, in this embodiment, after receiving the function codes uploaded by the user, the main control node 10 does not directly upload the function codes uploaded by the user to the storage system 30, but converts the function codes uploaded by the user into a code packet of a preset type and uploads the code packet to the storage system 30. In the embodiment of the application, the preset type is a user mode file format supporting on-demand access, a code packet of the format comprises metadata and a data part, a directory view of the data part can be obtained through the metadata, the directory view embodies a storage structure of the data, and on-demand downloading of the data part can be supported based on the directory view. Optionally, the user-mode File format may be a File format supported by a rafs (registry access File system) File system, where the File format includes metadata (meta) and a blob File, the metadata (meta) is used to store a directory structure of the blob File, and the blob File is used to store a data portion, where the blob File refers to a binary File that can store picture data or large text data. For example, if the function code uploaded by the user is in a zip format, the main control node 10 may convert the function code in the zip format into a code package in a rafs format, where the code package includes metadata and a blob file, and when data in the blob file needs to be accessed, a directory structure of the blob file may be obtained from the metadata (meta), and then the data in the blob file may be downloaded according to the directory structure.
In addition, the main control node 10 is also responsible for storing and managing trigger events corresponding to function codes, and monitoring whether the trigger events occur. The trigger event may be a time trigger, an event trigger, or a user trigger. Time trigger means that when a set time or time range arrives, it means that a function code needs to be started; the event trigger means that when a set event occurs, the function code needs to be started; by user trigger is meant that upon receiving a specific user instruction (e.g. a start instruction) it means that the function code needs to be started. As shown in fig. 1a, the master node 10 may further send a code start instruction to the host node 21 in the plurality of computing nodes 20 in response to a trigger event corresponding to the function code, so that the host node 21 runs the function code. The host node 21 has an infrastructure with certain computing power, and a computing node running an objective function instance 22 supporting function code running, where the objective function instance 22 may be one or more, and these objective function instances 22 may provide various cloud computing services to the outside. Alternatively, the implementation form of the target function instance 22 may be a Virtual Machine (VM), a container (Docker), a function calculation service, a native application program, or the like, which is not limited herein.
In this embodiment, the master node 10 may select the host node 21 from the plurality of computing nodes 20, and for example, the host node 21 may be selected according to information such as a load condition, an available resource amount, a deployment location, and a resource type of each computing node 20. In addition, the target function instance 22 on the host node 21 can be created in the following two ways: one is that after selecting the host node 21, the master node 10 instructs the host node 21 to create the target function instance 22 in real time; the other method is to create corresponding function instances on a plurality of computing nodes 20 in advance, and after the host node 21 is selected, the function instance on the host node 21 is the target function instance 22.
In this embodiment, the host node 21 is configured to receive a code start instruction sent by the main control node 10, generate a directory view corresponding to a data portion in a code packet based on metadata in the code packet in the storage system 30 when the code start instruction is received, and download the data portion in the code packet in the storage system 30 as needed based on the directory view in the running process of the objective function instance 22, so as to provide a data fragment required for current running to the objective function instance 22. The data segment refers to a part of data required by the current operation of the target function instance 22. Optionally, as shown in fig. 1a, the host node 21 further includes a memory 24, and the host node 21 may download metadata from the storage system 30 into the local memory 24, so as to generate a directory view corresponding to the data portion based on the downloaded metadata; alternatively, in the case where the storage system 30 may be mounted on the host node 21 as its local storage, the host node 21 may also directly access the metadata in the storage system 30 to generate a directory view corresponding to the data portion based on the metadata in the storage system 30. Alternatively, where the storage system 30 comprises a NAS system, the hosting node 21 may mount the NAS system at startup or on demand and directly access the metadata in the NAS system without downloading the metadata into local memory.
Further, in the case of generating the directory view, as shown in fig. 1a, the host node 21 may also respond to the data access operation on the directory view, and download a data fragment corresponding to the data access operation in the data portion from the storage system 30 to the memory 24 according to the data access operation on the directory view, so that the target function instance 22 runs the data fragment, and provides a corresponding service for the user. In particular, the hosting node 21 may present the directory view to the user, e.g., the hosting node 21 with a display screen through which the directory view is displayed; alternatively, the host node 21 may present the directory view to the terminal device used by the user in a remote desktop manner; based on this, the user can issue various access operations to the directory view, such as clicking, double clicking, selecting, and the like, and the data access operation of the user can be perceived by the host node 21; the host node 21 determines the data segment to be accessed based on the data access operation, and downloads the data segment from the storage system 30 to the memory, so that the target function instance 22 runs the data segment, and provides the corresponding service for the user.
In the embodiment of the present application, the network system 100 may convert the function code uploaded by the user into a code format in which the metadata is separated from the data portion, and store the converted function code, so that in the event of a trigger event corresponding to the function code, a directory view required by a function instance supporting the function code to run may be generated based on the metadata in the storage system 30. Furthermore, in the operation process of the function instance, the data part can be downloaded on demand based on the directory view, the data segment required by operation is provided for the function instance, and the function code can be downloaded on demand instead of being downloaded all at once, so that the downloading time is saved, and the loading and starting efficiency of the function code is improved.
In this embodiment of the present application, the internal structures of the master node 10, the host node 21 and the storage system 30 are not limited, and the following embodiment provides the implementation structures of the master node 10, the host node 21 and the storage system 30, and describes the operation principle of the network system 100 with reference to the drawings.
In an alternative embodiment, in the network system 100 shown in fig. 1b, the main control node 10 includes an Application Programming Interface (API) service module, a conversion module, and a management and control module. The API service module may provide various API interfaces required for accessing the network system 100 to the user, and the conversion module is mainly responsible for converting the function code into a preset type of code packet. Specifically, the user may upload the function code to the main control node 10 through an API interface provided by the API service module, and the conversion module converts the function code into a preset type of code packet, and then stores the preset type of code packet in the storage system 30. Certainly, the user may update the function code, upload the updated function code to the main control node 10 through an API interface provided by the API service module, convert the updated function code into a new code packet of a preset type by the conversion module, and replace an existing old code packet in the storage system 30 with the new code packet to complete the update of the function code.
In an alternative embodiment, the function code may be compressed before being uploaded by the user to reduce the amount of data transmission. Based on this, when the conversion module in the master control node 10 converts the function codes uploaded by the user into the code packet of the preset type, the conversion module may specifically decompress the function codes uploaded by the user, and convert the decompressed function codes into metadata and a data part according to the preset type; further, in order to save the data downloading amount, the conversion module may further compress the data portion, and then generate a corresponding code packet according to the metadata and the compressed data portion, and upload the code packet to the storage system 30.
Under the condition that the function code is stored in the storage system 30, the management and control module is configured to, on one hand, sense a trigger event corresponding to the function code and issue a code start instruction to the host node 21. On the other hand, the management and control module needs to determine the host node 21 before issuing the code start instruction. Optionally, the management and control module may select a host node 21 from the plurality of computing nodes 20 according to information such as a load condition, an available resource amount, a deployment location, and a resource type of each computing node 20, and may issue a code start instruction to the host node 21 when determining the host node 21. For example, assuming that the function code needs 3-core CPUs and 52G memories for running, the management and control module may select a compute node that can provide the 3-core CPU and the 52G memories from the maintained available resource information of each compute node 20 as the host node 21. An objective function instance of executable function code is deployed on the host node 21, and the objective function instance may be pre-deployed on the host node 21 or may be deployed in real time after the host node 21 is selected.
In an alternative embodiment, as shown in FIG. 1a, the storage system 30 comprises a NAS system in which a code package is stored, the code package including metadata and data portions corresponding to function codes. The NAS system is a network storage system, and has the advantages of convenience in reading, high efficiency, and the like, and the host node 21 can mount the NAS system. In this embodiment, a manner of mounting the NAS system by the host node 21 is not limited, and optionally, the host node 21 may mount the NAS system by default at the time of starting, or the master node 10 includes first address information pointing to the NAS system in a code start instruction, in which case, the host node 21 mounts the NAS system according to the first address information. Under the condition that the host node 21 receives a starting instruction, whether a function code to be started exists in a local disk can be preferentially judged; and if the local disk does not exist, reading the metadata from the NAS system, generating a directory view according to the metadata, and further loading data fragments required by the operation of the target function instance 22 from the NAS system according to the directory view, so that the function starting efficiency is improved.
Further optionally, considering that the NAS system is a network storage system and faces a series of uncertain risks such as network, bandwidth, system status, etc. in the data downloading process, in order to ensure stability of data downloading and subsequent data loading, as shown in fig. 1b, the storage system 30 of this embodiment further includes an OSS system. The OSS is a large-capacity block storage system and has the advantages of stability, reliability, high concurrency and the like. Based on this, the host node 21 can download the whole code package in the OSS system to the local disk 26 of the host node 21 in the background in the process of downloading the required data segment from the NAS system as needed, so as to implement synchronous operation and downloading of the function code, save the loading time, and ensure the efficiency of function start. Further optionally, after the code package in the OSS system is downloaded to the local disk in full, the data loading address may be further modified from the first address information pointing to the NAS system to the second address information pointing to the local disk, so as to implement hot switch of the loading address, so that in a subsequent data loading process, according to a data access operation on the directory view, remaining data in the data portion that has not been loaded into the memory space corresponding to the target function instance 22 may be continuously loaded as needed from the local disk. Therefore, dependence on the NAS can be reduced, stability risks are reduced, the stability and safety of data loading are improved, and data loading efficiency can be improved by locally loading data from the host node 21.
In an alternative embodiment, as shown in fig. 1b, the host node 21 further includes a management and control system 23 and a user-mode file system 25, in addition to the target function instance 22, the memory 24 and the local disk 26. The management and control system 23 is configured to receive various instructions issued by the main control node 10, and control modules such as the user mode file system 25 and/or the target function instance on the host node 21 to execute corresponding actions according to the instructions issued by the main control node 10. For example, the management and control system 23 may receive a start instruction issued by the management and control module in the main control node 10, call the user-mode file system 25 according to the start instruction, and perform operations such as downloading metadata from the NAS system and downloading data portions as needed by the user-mode file system 25 in the process of starting the function code, and downloading a code package from the OSS system in full amount in the background, so as to provide a data basis for the target function instance to run the function code.
Specifically, the user-mode file system 25 may download metadata from the NAS system to the memory 24 corresponding to the target function instance under the call of the management and control system 23, so that the target function instance generates a directory view corresponding to the data portion based on the metadata in the memory. Further, in the process of running the target function instance, the user-mode file system 25 may also download a data fragment corresponding to the data access operation from the NAS system to the memory 24 in response to the data access operation on the directory view, so that the target function instance runs the data fragment, and provides a corresponding service for the user. Further optionally, if the data portion in the code packet is compressed, after downloading the data segment required by the current operation of the target function instance 22 on the basis of the directory view as needed, the data segment may be decompressed, and the decompressed data segment is stored in the memory 24, so that the target function instance 22 operates the decompressed data segment to provide a corresponding service to the user.
In an alternative embodiment, as shown in fig. 1b, the number of target function instances 22 may be multiple, and in a case where multiple target function instances 22 use the same function code, the host node 21 may allocate a shared memory for the multiple target function instances 22, that is, the memory 24 may be shared by the multiple target function instances 22, and the memory space corresponding to each target function instance 22 is specifically a shared memory. Wherein, the multiple target function instances 22 can respectively load and run the data segments in the shared memory 24.
In the above example, it is not limited to what technology is used to implement the objective function example in the serverless architecture, and what technology is used to implement the objective function example may be determined according to specific requirements, and is not limited herein. It should be noted that the implementation of the target function instance is different, and the implementation of the user-mode file system 25 is also different. As shown in fig. 1c, in an alternative embodiment, the objective function instance may be implemented as a common container running on the host node 21, and accordingly, the user-mode file system 25 also needs to run on the host node 21, specifically, a user-mode process may be started by an operating system of the host node 21, and the user-mode process runs the user-mode file system 25; based on this, the management and control system 23, upon receiving the code start instruction, may notify the operating system of the host node 21, start the user mode process corresponding to the user mode file system 25 by the operating system, and perform the above-mentioned related operations of generating the directory view and downloading the data portion as needed by the user mode process. In another alternative embodiment, as shown in FIG. 1d, a security container is run on the host node 21, wherein the security container is equivalent to a VM of the user, the security container comprises a Virtual Machine Monitor (VMM) and a common container running on top of the VMM, and the target function instance is the common container running on top of the VMM; in this case, the user-mode file system 25 may be run in a secure container, and specifically, the user-mode file system 25 may be run by a kernel-mode process in the secure container; based on this, the management and control system 23, upon receiving the code start instruction, may notify the VMM to start a kernel-mode process corresponding to the user-mode file system 25, and perform the above-mentioned operations related to generating the directory view and downloading the data portion as needed by the kernel-mode process.
Based on the above embodiments, in a Serverless network system, a function uploaded by a user may be transcoded into a predetermined type of code packet, which includes metadata and a data portion. During storage, the metadata and the data part are stored into the NAS system separately, and in the case of responding to a trigger event of a user to the function code, a directory view required by a function instance supporting the function code to run can be generated based on the metadata in the NAS system; and further loading the data fragments in the data part from the NAS system according to the access operation of the user as required so as to provide corresponding services for the user when the function instance runs the data part. As all function codes do not need to be downloaded at one time, downloading can be carried out as required, the downloading time is saved, and the loading and starting efficiency of the function codes is improved. And the network system can also store the converted code packet into the OSS system, synchronously download the code packet in the OSS into the host node disk in the process of running the data part by the function instance, and switch from NAS loading to host node disk loading after the code packet downloading is finished.
The embodiment of the present application further provides a code loading method under the Serverless architecture, as shown in fig. 2, the method includes:
s2a, converting the function codes uploaded by the user into a code package of a preset type, and uploading the code package to a storage system, wherein the code package comprises metadata and a data part;
s2b, responding to a trigger event corresponding to the function code, and generating a directory view corresponding to a data part required by the operation of a target function instance supporting the operation of the function code based on metadata in the storage system;
and S2c, downloading the data parts in the storage system on demand based on the directory view in the running process of the target function instance, so as to provide the data fragments required by the current running to the target function instance.
In this embodiment, the function code uploaded by the user may be converted into a preset type code packet, where the code packet includes metadata and a data portion corresponding to the function code, and the metadata may embody a directory structure of the data portion.
Optionally, the user may compress the function code before uploading it. In this embodiment, the compression method adopted by the user to compress the function code is not limited, and may be, for example and without limitation: RAR compression or ZIP compression. Based on the above, when the function codes uploaded by the user are converted into the code packets of the preset type, the function codes uploaded by the user can be decompressed, the decompressed function codes are converted into metadata and data parts according to the preset type, then the data parts are compressed, and finally the code packets are generated according to the metadata and the compressed data parts.
Correspondingly, when the data part in the storage system is downloaded on demand based on the directory view, the data segment required by the current operation of the target function instance can be downloaded on demand based on the directory view, the data segment is decompressed, and the decompressed data segment is stored in the memory space corresponding to the target function instance, so that the decompressed data segment can be operated by the target function instance, and the corresponding service can be provided for the user.
In an alternative embodiment, the storage system may comprise a NAS system in which the code packages are stored. Based on the above, in response to a trigger event corresponding to the function code, generating a directory view corresponding to a data portion supporting the function code to run based on metadata in the storage system, including: and responding to a trigger event corresponding to the function code, mounting the NAS system, and downloading metadata from the NAS system to a memory space corresponding to the target function instance so that the target function instance can generate a directory view based on the metadata. Correspondingly, during the running process of the target function instance, downloading data parts in the storage system on demand based on the directory view so as to provide data fragments required by the current running to the target function instance, wherein the downloading process comprises the following steps: in the running process of the target function instance, according to the data access operation on the directory view, downloading the data fragments corresponding to the data access operation in the data part from the NAS system to the memory space corresponding to the target function instance so as to allow the target function instance to run the data fragments, and finally providing corresponding services for users.
Further optionally, the storage system may further include an OSS system, and the OSS system stores a code packet corresponding to the function code. Based on this, the method further comprises: and in the process of downloading the data segments corresponding to the data access operation in the data part from the NAS system to the memory space as required, downloading the code packets from the OSS system to the local disk in a full amount. Further, after the code package is successfully downloaded to the local disk in full, the data loading address can be modified from the first address information pointing to the NAS system to the second address information pointing to the local disk, and in the subsequent data loading process, according to the data access operation on the directory view, the remaining data in the data portion that has not been loaded to the memory space corresponding to the target function instance is continuously loaded from the local disk as needed, so that the stability and efficiency of data loading are improved.
In this embodiment, the function code uploaded by the user may be converted into a code format in which the metadata is separated from the data portion, and stored, so that, when a trigger event corresponding to the function code occurs, a directory view required by a function instance supporting the function code to run may be generated based on the metadata in the storage system. Furthermore, in the operation process of the function instance, the data part can be downloaded on demand based on the directory view, the data segment required by operation is provided for the function instance, and the function code can be downloaded on demand instead of being downloaded all at once, so that the downloading time is saved, and the loading and starting efficiency of the function code is improved.
It should be noted that the execution subjects of the steps of the methods provided in the above embodiments may be the same device, or different devices may be used as the execution subjects of the methods. For example, the execution subjects of steps S2a-S2c may be device A; for another example, the execution subject of step S2a may be device a, and the execution subjects of steps S2B and S2c may be device B; and so on.
In addition, in some of the flows described in the above embodiments and the drawings, a plurality of operations occurring in a specific order are included, but it should be clearly understood that the operations may be executed out of the order they appear herein or in parallel, and the sequence numbers of the operations, such as S2a, S2b, etc., are merely used to distinguish between the various operations, and the sequence numbers themselves do not represent any execution order. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used to distinguish different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.
Based on the above, an optional embodiment of the present application further provides a node device, which may be implemented as a master control node in a server-less network system. Fig. 3 is a schematic structural diagram of a node device according to an embodiment of the present application, and as shown in fig. 3, the node device includes: a processor 31 and a memory 32 in which a computer program is stored; the processor 31 and the memory 32 may be one or more.
The memory 32 is mainly used for storing computer programs, and these computer programs can be executed by the processor 31, so that the processor 31 controls the node device to implement corresponding functions, and complete corresponding actions or tasks. In addition to storing computer programs, the memory 32 may also be configured to store other various data to support operations on the node devices. Examples of such data include instructions for any application or method operating on the node device.
The memory 32, may be implemented by any type or combination of volatile or non-volatile memory devices, such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.
In the embodiment of the present application, the implementation form of the processor 31 is not limited, and may be, for example, but not limited to, a CPU, a GPU, an MCU, or the like. The processor 31 may be regarded as a control system of the node device and may be configured to execute a computer program stored in the memory 32 to control the node device to implement the corresponding functions and perform the corresponding actions or tasks. It should be noted that, according to different implementation forms and scenes of the node device, the functions, actions or tasks to be implemented may be different; accordingly, the computer programs stored in the memory 32 may be different, and the execution of different computer programs by the processor 31 may control the node device to perform different functions, perform different actions or tasks.
In this embodiment, only some components are schematically shown in fig. 3, which does not mean that the node device includes only the components shown in fig. 3, and the node device may further include other components according to different application requirements, for example, as shown in fig. 3, the node device may further include a power component 33 and a communication component 34, etc. The components that the node device may include may depend on the product form of the node device, and are not limited herein.
In the embodiment of the present application, when the processor 31 executes the computer program in the memory 32, it is configured to: converting function codes uploaded by a user into a code packet of a preset type, and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part; responding to a trigger event corresponding to the function code, sending a code starting instruction to a host node in a plurality of computing nodes in the server-free network system, so that the host node generates a directory view corresponding to a data part required by the running of the target function instance based on metadata in the storage system, and downloading the data part in the storage system as required based on the directory view in the running process of the target function instance; the host node is a computing node running an object function instance supporting function code running.
In an alternative embodiment, when the processor 31 converts the function code uploaded by the user into a code package of a preset type and uploads the code package to the storage system, the processor is specifically configured to: decompressing function codes uploaded by a user, converting the decompressed function codes into metadata and a data part according to a preset type, compressing the data part, generating a code packet according to the metadata and the compressed data part, and uploading the code packet to a storage system.
Accordingly, the present application further provides a computer-readable storage medium storing a computer program, where the computer program is capable of implementing the steps that can be executed by the node device in the foregoing method embodiments when executed.
Another alternative embodiment of the present application further provides a node device, which may be implemented as a host node in a serverless network system. The structure of the node device is similar to that of the node device shown in fig. 3, and specifically, the structural diagram shown in fig. 3 can be referred to. In this embodiment, the node device includes: a processor and a memory storing a computer program; the processor and the memory may be one or more, among others.
In this embodiment, the node device may further include other components according to different application requirements, for example, the node device may further include a power component, a communication component, and the like. The components that the node device may include may depend on the product form of the node device, and are not limited herein.
In an embodiment of the application, the processor, when executing the computer program in the memory, is configured to: receiving a code starting instruction sent by a main control node in response to a trigger event corresponding to a function code, converting the function code into a code packet of a preset type and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part; and in the running process of the target function instance, downloading the data part in the storage system as required based on the directory view so as to provide a data fragment required by current running for the target function instance, wherein the target function instance is a function instance which runs on the node equipment provided by the embodiment and supports the running of the function code.
In an optional embodiment, the storage system further comprises an OSS system, and the processor is further configured to: and downloading the code packet from the OSS system to the local disk, modifying the data loading address from the first address information pointing to the NAS system to the second address information pointing to the local disk, and continuously loading the residual data which are not loaded into the memory space corresponding to the target function instance in the data part according to the data access operation on the directory view.
In an alternative embodiment, the plurality of instances of the objective function, the processor is further configured to: and distributing a shared memory for a plurality of target function examples, wherein the memory space corresponding to the target function examples is the shared memory.
In an alternative embodiment, the processor is further configured to: and after downloading the data segments required by the current operation of the target function instance based on the directory view as required, decompressing the data segments, and storing the decompressed data segments into a memory space corresponding to the target function instance so as to allow the target function instance to operate the decompressed data segments.
In an alternative embodiment, the object function instance is a generic container running on the node device, and the processor, upon receiving the code initiation instruction, is configured to: starting a user mode process corresponding to the user mode file system, and executing the operation of generating the directory view and downloading according to the requirement by the user mode process; or a security container is operated on the node equipment, the security container comprises a VMM and a common container operated on the VMM, and the target function instance is the common container; the processor, upon receiving the code initiation instruction, is configured to: and controlling the VMM to start a kernel mode process corresponding to the user mode file system, and executing the operation of generating the directory view and downloading according to the requirement by the kernel mode process.
Accordingly, the present application further provides a computer readable storage medium storing a computer program, which when executed by a processor, causes the processor to implement the steps in the above method embodiments.
Accordingly, the present application also provides a computer program product, which includes a computer program/instruction, when the computer program/instruction is executed by a processor, the processor is enabled to implement the steps in the above method embodiments.
The communication component in the above embodiments is configured to facilitate communication between the device in which the communication component is located and other devices in a wired or wireless manner. The device where the communication component is located can access a wireless network based on a communication standard, such as a WiFi, a 2G, 3G, 4G/LTE, 5G and other mobile communication networks, or a combination thereof. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast related information from an external broadcast management system via a broadcast channel. In one exemplary embodiment, the communication component further includes a Near Field Communication (NFC) module to facilitate short-range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, Ultra Wideband (UWB) technology, Bluetooth (BT) technology, and other technologies.
The power supply assembly of the above embodiments provides power to various components of the device in which the power supply assembly is located. The power components may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the device in which the power component is located.
As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.
Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.
The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.
Claims (13)
1. A Serverless network system, comprising: the system comprises a main control node, a plurality of computing nodes and a storage system;
the main control node is used for converting function codes uploaded by a user into a code packet of a preset type and uploading the code packet to the storage system, wherein the code packet comprises metadata and a data part, the metadata is used for storing a directory view of the data part, and the directory view reflects a storage structure of the data part; responding to a trigger event corresponding to the function code, and sending a code starting instruction to a host node in the plurality of computing nodes, wherein the host node is a computing node running an objective function instance supporting the function code to run;
and the host node is used for generating a directory view corresponding to the data part based on the metadata in the storage system under the condition that the code starting instruction is received, and downloading the data part in the storage system on demand based on the directory view in the running process of the target function instance so as to provide the data fragment required by current running for the target function instance.
2. The network system of claim 1, wherein the storage system comprises a NAS system;
the host node is specifically configured to: mounting the NAS system, and downloading the metadata from the NAS system to a memory space corresponding to the target function instance so as to enable the target function instance to generate the directory view; and downloading a data fragment corresponding to the data access operation in the data part from the NAS system to the memory space according to the data access operation on the directory view, so that the target function instance can run the data fragment.
3. The network system of claim 2, wherein the storage system further comprises an OSS system;
the host node is further configured to: and downloading the code packet from the OSS system to a local disk, changing a data loading address from first address information pointing to the NAS system to second address information pointing to the local disk, and continuously loading the residual data which are not loaded into the memory space corresponding to the target function instance in the data part according to the data access operation on the directory view.
4. The network system of claim 2, wherein the target function instance is plural, and wherein the host node is further configured to: and distributing a shared memory for the target function instances, wherein the memory space corresponding to the target function instances is the shared memory.
5. The network system according to any one of claims 1 to 4, wherein the master node is specifically configured to: decompressing function codes uploaded by a user, converting the decompressed function codes into metadata and a data part according to a preset type, compressing the data part, generating a code packet according to the metadata and the compressed data part, and uploading the code packet to the storage system;
the host node is further configured to: and after downloading the data segments required by the current operation of the target function instance based on the directory view as required, decompressing the data segments, and storing the decompressed data segments into a memory space corresponding to the target function instance so that the target function instance can operate the decompressed data segments.
6. The network system according to any of claims 1-4, wherein the object function instance is a generic container running on the hosting node, the hosting node being specifically configured to: under the condition of receiving the code starting instruction, starting a user mode process corresponding to a user mode file system, and executing the operation of generating the directory view and downloading according to the requirement by the user mode process;
or
A security container runs on the host node, the security container comprises a VMM and a common container running on the VMM, and the target function instance is the common container; the host node is specifically configured to: and under the condition of receiving the code starting instruction, controlling the VMM to start a kernel mode process corresponding to the user mode file system, and executing the operation of generating the directory view and downloading according to the requirement by the kernel mode process.
7. A code loading method under a Serverless architecture without a server is characterized by comprising the following steps:
converting function codes uploaded by a user into a code packet of a preset type, and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part, the metadata is used for storing a directory view of the data part, and the directory view reflects a storage structure of the data part;
generating a directory view corresponding to the data part required by the running of an object function instance supporting the running of the function code based on the metadata in the storage system in response to a trigger event corresponding to the function code; and
and in the running process of the target function instance, downloading the data part in the storage system on demand based on the directory view so as to provide the data fragment required by the current running to the target function instance.
8. The method of claim 7, wherein transcoding the function uploaded by the user into a preset type of code packet comprises: decompressing the function codes uploaded by the user, and converting the decompressed function codes into metadata and data parts according to a preset type; compressing the data part, and generating the code packet according to the metadata and the compressed data part;
correspondingly, downloading the data part in the storage system on demand based on the directory view to provide the data segment required by the current operation to the target function instance comprises: downloading the data segments required by the current operation of the target function instance according to the directory view, decompressing the data segments, and storing the decompressed data segments into the memory space corresponding to the target function instance so that the target function instance can operate the decompressed data segments.
9. The method of claim 7, wherein the storage system comprises: a NAS system;
in response to a trigger event corresponding to the function code, generating a directory view corresponding to a data part supporting the function code to run based on metadata in the storage system, including: mounting the NAS system, and downloading the metadata from the NAS system to a memory space corresponding to the target function instance so as to enable the target function instance to generate the directory view;
correspondingly, in the running process of the target function instance, downloading the data part in the storage system on demand based on the directory view so as to provide the data fragment required by the current running to the target function instance, including: and according to the data access operation on the directory view, downloading a data fragment corresponding to the data access operation in the data part from the NAS system to the memory space so that the target function instance can run the data fragment.
10. The method of claim 9, wherein the storage system further comprises an OSS system; the method further comprises the following steps:
downloading the code packet from the OSS system to a local disk, and modifying a data loading address from first address information pointing to the NAS system to second address information pointing to the local disk;
and continuously loading the residual data which are not loaded into the memory space corresponding to the target function instance in the data part from the local disk according to the data access operation on the directory view.
11. A node device, which can be implemented as a master node in a serverless network system, the node device comprising: a memory and a processor; the memory is used for storing a computer program; the processor is coupled with the memory for executing the computer program for:
converting function codes uploaded by a user into a code packet of a preset type, and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part, the metadata is used for storing a directory view of the data part, and the directory view reflects a storage structure of the data part; responding to a trigger event corresponding to the function code, sending a code starting instruction to a host node in a plurality of computing nodes in the serverless network system, so that the host node generates a directory view corresponding to the data part required by the operation of an objective function instance based on metadata in the storage system, and downloading the data part in the storage system on demand based on the directory view in the operation process of the objective function instance; wherein the host node is a computing node running an object function instance supporting the function code to run.
12. A node apparatus that can be implemented as a host node in a serverless network system, the node apparatus comprising: a memory and a processor; the memory is used for storing a computer program; the processor is coupled with the memory for executing the computer program for:
receiving a code starting instruction sent by a main control node in response to a trigger event corresponding to a function code, converting the function code into a code packet of a preset type and uploading the code packet to a storage system, wherein the code packet comprises metadata and a data part, the metadata is used for storing a directory view of the data part, and the directory view reflects a storage structure of the data part;
and generating a directory view corresponding to the data part required by the operation of the target function instance based on the metadata in the storage system, and downloading the data part in the storage system as required based on the directory view in the operation process of the target function instance to provide the data fragment required by the current operation for the target function instance, wherein the target function instance is a function instance which is operated on the node equipment and supports the operation of the function code.
13. A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, causes the processor to carry out the steps of the method according to any one of claims 7-10.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110833871.1A CN113282377B (en) | 2021-07-23 | 2021-07-23 | Code loading method, equipment, system and storage medium under server-free architecture |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110833871.1A CN113282377B (en) | 2021-07-23 | 2021-07-23 | Code loading method, equipment, system and storage medium under server-free architecture |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113282377A CN113282377A (en) | 2021-08-20 |
| CN113282377B true CN113282377B (en) | 2022-01-04 |
Family
ID=77287046
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110833871.1A Active CN113282377B (en) | 2021-07-23 | 2021-07-23 | Code loading method, equipment, system and storage medium under server-free architecture |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113282377B (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113791865A (en) * | 2021-09-08 | 2021-12-14 | 山石网科通信技术股份有限公司 | Container security processing method and device, storage medium and processor |
| CN114598706B (en) * | 2022-03-08 | 2023-05-16 | 中南大学 | Storage system elastic expansion method based on Serverless function |
| CN116932241A (en) * | 2022-04-08 | 2023-10-24 | 华为云计算技术有限公司 | Service starting method and related device |
| CN116048735B (en) * | 2023-03-23 | 2023-08-29 | 阿里云计算有限公司 | Information processing method and object sharing method |
| CN117112075B (en) * | 2023-06-19 | 2024-02-20 | 领悦数字信息技术有限公司 | Method and system for automatically converting timed task applications into serverless functions |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110058950A (en) * | 2019-04-17 | 2019-07-26 | 上海沄界信息科技有限公司 | Distributed cloud computing method and equipment based on serverless backup framework |
| US20200241999A1 (en) * | 2020-03-25 | 2020-07-30 | Intel Corporation | Performance monitoring for short-lived functions |
| CN112214293A (en) * | 2017-11-08 | 2021-01-12 | 华为技术有限公司 | Method for service deployment under server-free architecture and function management platform |
| CN112445550A (en) * | 2020-12-08 | 2021-03-05 | 中国科学院深圳先进技术研究院 | Server-free computing method and system for preprocessing function |
| CN112753019A (en) * | 2018-09-27 | 2021-05-04 | 亚马逊技术有限公司 | Efficient state maintenance of execution environments in on-demand code execution systems |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108491191A (en) * | 2018-03-29 | 2018-09-04 | 安徽航天信息有限公司 | A kind of serverless backup FaaS frameworks tax big data system |
| CN108845878A (en) * | 2018-05-08 | 2018-11-20 | 南京理工大学 | The big data processing method and processing device calculated based on serverless backup |
-
2021
- 2021-07-23 CN CN202110833871.1A patent/CN113282377B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112214293A (en) * | 2017-11-08 | 2021-01-12 | 华为技术有限公司 | Method for service deployment under server-free architecture and function management platform |
| CN112753019A (en) * | 2018-09-27 | 2021-05-04 | 亚马逊技术有限公司 | Efficient state maintenance of execution environments in on-demand code execution systems |
| CN110058950A (en) * | 2019-04-17 | 2019-07-26 | 上海沄界信息科技有限公司 | Distributed cloud computing method and equipment based on serverless backup framework |
| US20200241999A1 (en) * | 2020-03-25 | 2020-07-30 | Intel Corporation | Performance monitoring for short-lived functions |
| CN112445550A (en) * | 2020-12-08 | 2021-03-05 | 中国科学院深圳先进技术研究院 | Server-free computing method and system for preprocessing function |
Non-Patent Citations (1)
| Title |
|---|
| 云计算应用服务开发环境: 从代码逻辑到数据流图;刘云浩等;《中国科学: 信息科学》;20190903(第9 期);第1-19页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113282377A (en) | 2021-08-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN113282377B (en) | Code loading method, equipment, system and storage medium under server-free architecture | |
| US11556366B2 (en) | Container login method, apparatus, and storage medium | |
| CN110413346B (en) | Parameter updating method and device | |
| CN116170317A (en) | Network system, service providing and resource scheduling method, device and storage medium | |
| WO2022161430A1 (en) | Edge cloud system, edge management and control method, management and control node, and storage medium | |
| CN102571940B (en) | Application program remote installation system, method, intelligent terminal, application server | |
| KR101427561B1 (en) | Method for adaptively executing an android application on tizen platform by automatically transforming the android application into tizen-installable package, and computer-readable recording medium for the same | |
| CN117411765A (en) | Network system, management and control method, equipment and storage medium | |
| US20190286354A1 (en) | Selecting and compressing target files to obtain additional free data storage space to perform an operation in a virtual machine | |
| CN109558143A (en) | The method and device of application deployment in a kind of cluster | |
| CN111026406A (en) | Application running method, device and computer readable storage medium | |
| CN114489690A (en) | Distributed system deployment method and device, electronic equipment and storage medium | |
| WO2023193433A1 (en) | Service starting method and related device | |
| CN113300866A (en) | Node capacity control method, device, system and storage medium | |
| KR101427562B1 (en) | Method for automatically transforming an android application into tizen-installable application package, and computer-readable recording medium for the same | |
| CN113553194B (en) | Hardware resource management method, device and storage medium | |
| US11709749B1 (en) | Diagnostic data collection for kubernetes | |
| CN111651172B (en) | Automatic generation method and system based on containerized ISO | |
| CN111597021B (en) | Method, device, system and related equipment for realizing application program operation | |
| CN114675872A (en) | Data processing method, device and equipment for application program and storage medium | |
| CN114816789A (en) | File processing method based on cloud application, electronic device and storage medium | |
| CN113434244B (en) | Instance creating method, instance creating apparatus, data processing method, data processing system, and storage medium | |
| CN114721728A (en) | Processing method based on cloud application, electronic equipment and storage medium | |
| CN116016644A (en) | Service request processing method, network device and computer readable storage medium | |
| CN113268272A (en) | Application delivery method, device and system based on private cloud |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |