An implementation method, system and device of a service-free computing platform and a storage medium

Abstract

The application discloses an implementation method, system and device of a serverless computing platform and a storage medium, belongs to the technical field of Internet, and solves the technical problem that the existing serverless computing solution cannot meet the needs. The method is: initializing various components of the serverless computing platform, including a front-end service, a back-end service, an online coding integrated development environment, a construction tool, a container scheduling component, a gateway service, a code repository and a container image repository that need to be called; creating a new serverless computing function on the interface of the front-end service and deploying the serverless computing function into a Kubernetes cluster to meet different development needs. The serverless computing platform built by the Kubernetes cluster can significantly improve resource utilization, optimize the scheduling and resource configuration of the serverless computing function, and conveniently apply the perfect monitoring function of the Kubernetes platform. When starting the serverless computing function, the user does not need to write Kubernetes YAML, thereby reducing the learning cost and difficulty.

Description

Technical Field

[0001] This invention relates to the field of Internet technology, and more specifically, to a method, system, device, and storage medium for implementing a serverless computing platform. Background Technology

[0002] With the rapid development of information technology, especially the widespread application of cloud computing and big data technologies, enterprises are facing new challenges and opportunities in software development and deployment. Traditional application development models often require developers to focus on the management and maintenance of underlying infrastructure, which not only increases the complexity of development but also limits development speed and flexibility. Therefore, more and more enterprises are beginning to explore serverless computing as an emerging computing model to achieve more efficient development and operation.

[0003] Serverless computing is a cloud computing model that allows developers to focus on writing business logic without managing servers or infrastructure. Users only need to focus on writing code, while cloud service providers handle automated resource allocation, load balancing, monitoring, and fault recovery. This model reduces operating costs by allocating resources on demand, while improving system scalability and flexibility. The rise of serverless computing is due to several factors:

[0004] Rapid development and deployment: Developers can quickly build and release applications to respond to changes in market demands.

[0005] Cost-effectiveness: Users pay only based on actual usage, avoiding waste of resources.

[0006] Automatic scaling: The system can automatically adjust resources based on traffic fluctuations to ensure high availability of applications.

[0007] Kubernetes, as an open-source container orchestration platform, has become a core component of modern cloud computing architectures. It provides powerful container management, scheduling, and automation capabilities, enabling developers to efficiently deploy and manage containerized applications. Key advantages of Kubernetes include: elasticity and scalability—Kubernetes can automatically scale application instances up and down based on load, ensuring efficient utilization of system resources; self-healing capabilities—Kubernetes can automatically restart or replace failed instances in the event of a failure, ensuring continuous service availability; and a rich ecosystem—Kubernetes has a large number of open-source tools and plugins supporting monitoring, log management, service mesh, and other functions, greatly improving operational efficiency.

[0008] The advantages of integrating Kubernetes with serverless computing are mainly reflected in the following aspects:

[0009] 1. Flexibility and Scalability: Kubernetes' container orchestration capabilities, combined with the on-demand resource management of serverless computing, provide developers with greater flexibility. Through Kubernetes, developers can dynamically allocate and manage resources in a serverless architecture, ensuring service stability and availability under high load conditions.

[0010] 2. Simplified Development and Operations: Serverless computing allows developers to focus on business logic, while Kubernetes handles the management of the underlying infrastructure. This integration further simplifies operations, reduces technical complexity, and improves development efficiency.

[0011] 3. Event-Driven Architecture: Kubernetes can seamlessly integrate with serverless computing platforms, supporting event-driven application development. Developers can run serverless functions on Kubernetes to respond to various events (such as HTTP requests, message queues, etc.), thereby achieving efficient workflow and business logic processing.

[0012] 4. Cost-effectiveness: By integrating the on-demand billing model of serverless computing with Kubernetes' resource optimization capabilities, enterprises can significantly reduce infrastructure costs while maintaining high availability. Kubernetes' automated resource management reduces idle resources and improves ROI.

[0013] 5. Unified Management Platform: After integration, enterprises can manage containerized applications and serverless functions on a unified platform, simplifying operations such as monitoring, logging, and security management. This unified management approach helps improve overall operational efficiency and reduces the complexity of managing multiple platforms.

[0014] 6. Enhanced Developer Experience: Integrating Kubernetes with serverless computing allows developers to more easily build, test, and deploy applications. Whether it's containerized applications or serverless functions, developers enjoy a consistent development environment and toolchain, thereby improving overall development efficiency.

[0015] By integrating Kubernetes with serverless computing, enterprises can fully leverage the advantages of both to achieve more efficient and flexible application development and deployment, meeting rapidly changing market demands. This integration not only enhances the flexibility and scalability of the technical architecture but also creates greater business value for enterprises, driving the further development of cloud computing technology.

[0016] While serverless computing and Kubernetes each have significant advantages, combining them in practical applications still faces challenges. Currently, many serverless computing platforms rely on specific cloud service providers, lacking flexibility and portability. Meanwhile, configuring and managing Kubernetes often requires developers to have a certain level of technical expertise, increasing the learning curve.

[0017] Specifically, existing serverless computing solutions have problems in the following aspects:

[0018] 1. YAML Configuration Complexity: Kubernetes configuration files are typically in YAML format, which has a complex structure and is prone to human error. This is particularly unfriendly to novice developers, increasing the learning and usage barrier.

[0019] 2. Lack of unified monitoring tools: Although Kubernetes supports a variety of monitoring tools, users need to configure and integrate these tools separately, resulting in scattered monitoring information and difficulty in obtaining a comprehensive view of the system.

[0020] 3. Limitations in resource scheduling and management: In serverless computing scenarios, how to efficiently automate resource scheduling and optimize configuration remains an unsolved problem. This may lead to resource waste or performance bottlenecks under high load.

[0021] 4. Insufficient end-to-end management: The process from code editing to function deployment often lacks complete management tools, causing inconvenience to users during development and deployment, and affecting development efficiency. Summary of the Invention

[0022] The technical problem to be solved by this invention is to address the above-mentioned shortcomings of the prior art. The purpose of this invention is to provide a method for implementing a serverless computing platform, which can better integrate Kubernetes with the serverless computing platform, make full use of the advantages of Kubernetes clusters, provide full-process management from code editing to function deployment, simplify configuration schemes, reduce the difficulty for users to use serverless computing, and at the same time, provide some monitoring functions to help users understand the system's operating status in real time, thereby improving the system's availability and reliability.

[0023] The second objective of this invention is to provide an implementation system for a serverless computing platform.

[0024] The third objective of this invention is to provide a computer device.

[0025] The fourth objective of this invention is to provide a computer storage medium.

[0026] To achieve the first objective mentioned above, the present invention provides a method for implementing a serverless computing platform, comprising the following steps:

[0027] Step S1. Initialize the various components of the serverless computing platform, including: front-end service, back-end service, online coding integrated development environment, build tools, container scheduling component, gateway service, and the code repository and container image repository that need to be called;

[0028] Step S2. Create a new serverless computing function on the interface of the front-end service, and provide two construction methods for users to choose from: online coding deployment or container image deployment, to meet different development needs;

[0029] Step S3. Obtain the function code edited online by the user through the interface of the front-end service. The function code is used to implement simple serverless computing functions.

[0030] Step S4. Obtain the service publishing request submitted by the user. In this step, the service publishing request initiated by the user through the interface of the front-end service is obtained so as to deploy the edited serviceless computing function to the Kubernetes cluster and complete the formal launch of the function.

[0031] Step S5. The backend service creates the KubernetesYAML configuration required by the build tool and creates it in the cluster as a custom resource object; and continuously listens for changes to the custom resource object to obtain the latest status of the custom resource object;

[0032] Step S6. The build tool listens for the creation of the custom resource object and creates a corresponding pipeline task to execute the image build; after the image build is completed, the image build result is written back to the custom resource object.

[0033] Step S7. The backend service obtains the image building result; if the image building fails, it records the error information, displays the error log on the interface of the frontend service, and returns; if the image building succeeds, it continues with subsequent operations.

[0034] Step S8. The backend service uses the container image to create a custom resource object of the container scheduling component, thereby using the container scheduling component to publish serverless computing functions;

[0035] Step S9. The container scheduling component creates Kubernetes container groups and corresponding Kubernetes services based on the provided configuration information;

[0036] Step S10. The backend service generates a random domain name prefix and combines the domain name prefix with other domain name parts to generate a complete domain name; then it creates a Kubernetes route and hands it over to the gateway service for processing.

[0037] Step S11. By resolving the domain name using wildcard domain name resolution, the generated domain name is pointed to the gateway service entry point; this allows users to access the serverless computing function through the domain name, thereby triggering the corresponding function.

[0038] As a further improvement, in step S2, when the user selects the online coding deployment method to deploy the function, the specific steps executed by the backend service are as follows:

[0039] Step S21. The backend service automatically creates a new repository in the code repository;

[0040] Step S22. Execute the gitclone command to clone the new repository to the shared persistent storage mounted on the container group of the backend service;

[0041] Step S23. Copy the code template to the corresponding location on the mounted shared persistent storage to complete the initialization of the code repository and the local working directory.

[0042] Furthermore, in step S2, when the user selects the container image deployment method to deploy the function, the user only needs to provide the image address and the exposed port number.

[0043] Furthermore, in step S3, the front-end service calls the online coding integrated development environment to provide online coding functionality in an embedded IDE manner. The online coding functionality supports code marking and error prompting. The online coding integrated development environment needs to be mounted with the same shared persistent storage as the back-end service to ensure code file sharing.

[0044] Furthermore, in step S3, when a user saves online code, the backend service executes the gitcommit command to commit the code changes to the corresponding code repository, thereby ensuring the effectiveness of version management.

[0045] Furthermore, in step S4, when the user selects the online coding deployment method to deploy the function, the build process is started to generate a deployable container image;

[0046] When a user chooses to deploy a function using a container image, no build process is required; the release operation can be performed directly.

[0047] Furthermore, in step S9, after the Kubernetes container group and the corresponding Kubernetes service are created, the container scheduling component uses the internal activator component to monitor and analyze the call status of the Kubernetes service; at the same time, the container scheduling component uses the autoscaler component to dynamically control the size of the Kubernetes container group; if the Kubernetes service is not called for a long time, the size of the Kubernetes container group will be reduced to 0; once a request is triggered, the size of the Kubernetes container group will be automatically adjusted to 1.

[0048] To achieve the second objective mentioned above, the present invention provides a system for implementing a serverless computing platform, comprising:

[0049] The initialization module is used to initialize the various components of the serverless computing platform. These components include: front-end services, back-end services, online coding integrated development environment, build tools, container scheduling components, gateway services, and the code repository and container image repository that need to be called.

[0050] A new serverless computing function module is provided to create new serverless computing functions on the interface of the front-end service. Two construction methods are provided for users to choose from: online coding deployment or container image deployment, to meet different development needs.

[0051] The function code acquisition module is used to acquire function code that the user edits online through the interface of the front-end service. The function code is used to implement simple serverless computing functions.

[0052] The service publishing request acquisition module is used to acquire service publishing requests submitted by users. In this step, the service publishing request initiated by the user through the interface of the front-end service is acquired so as to deploy the edited serviceless computing function to the Kubernetes cluster and complete the formal launch of the function.

[0053] The monitoring module is used to create the KubernetesYAML configuration required by the backend service to create the build tool and create it in the cluster in the form of a custom resource object; and continuously monitor the change operation of the custom resource object to obtain the latest status of the custom resource object.

[0054] The image building module is used by the building tool to monitor the creation of custom resource objects, create corresponding pipeline tasks, and execute image building. After the image building is completed, the image building result is written back to the custom resource object. The backend service obtains the image building result. If the image building fails, the error information is recorded, the error log is displayed on the interface of the frontend service, and then returned. If the image building is successful, subsequent operations continue.

[0055] The publishing module is used by the backend service to create a custom resource object of the container scheduling component using the container image, thereby using the container scheduling component to publish serverless computing functions.

[0056] A service creation module is used by the container scheduling component to create Kubernetes container groups and corresponding Kubernetes services based on the provided configuration information. The backend service generates a random domain name prefix and combines the domain name prefix with other domain name parts to generate a complete domain name. Then, a Kubernetes route is created and handed over to the gateway service for processing. Through wildcard domain name resolution, the generated domain name is pointed to the entry point of the gateway service, so that users can access the serviceless computing function through the domain name, thereby triggering the corresponding function.

[0057] To achieve the third objective mentioned above, the present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the above-described method for implementing a serverless computing platform.

[0058] To achieve the fourth objective mentioned above, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the above-described method for implementing a serverless computing platform.

[0059] Beneficial effects

[0060] Compared with the prior art, the advantages of this invention are as follows:

[0061] 1. This invention better integrates Kubernetes with serverless computing platforms, fully leveraging the advantages of both. Through this innovation, users can enjoy end-to-end management from code editing to function deployment, greatly simplifying configuration and lowering the technical barrier for users when using serverless computing.

[0062] 2. This invention provides an intuitive user interface and automated tools, enabling users to easily create and manage serverless computing functions without requiring extensive Kubernetes knowledge. Through a solution that eliminates the need for writing YAML configurations and an automated deployment process, novice users can quickly get started, reducing learning costs and accelerating the development cycle. This user-friendly experience will attract more developers to participate in serverless computing applications, promoting its widespread adoption across various industries. Attached Figure Description

[0063] Figure 1 This is a flowchart of the present invention. Detailed Implementation

[0064] The present invention will be further described below with reference to specific embodiments shown in the accompanying drawings.

[0065] See Figure 1 This paper presents an implementation method for a serverless computing platform, aiming to build a one-stop serverless computing platform. The serverless computing platform built using a Kubernetes cluster can significantly improve resource utilization, optimize the scheduling and resource configuration of serverless computing functions, and conveniently utilize the comprehensive monitoring functions of the Kubernetes platform. Furthermore, users do not need to write KubernetesYAML when starting serverless computing functions, thus reducing the learning cost and ease of use.

[0066] This method specifically includes the following steps S1 to S11:

[0067] Step S1. Initialize the various components of the serverless computing platform, including: front-end service serverless-ui, back-end service serverless, online coding integrated development environment web-ide, build tool build-controller, container scheduling component knative, gateway service istio, and the code repository and container image repository that need to be called.

[0068] The front-end service, serverless-ui, provides a user-friendly interface that allows users to create, manage, and monitor serverless computing functions. It supports online editing, function posting requests, and other operations, simplifying user interaction with the system.

[0069] Serverless backend services are responsible for handling backend logic, including receiving user requests, managing function lifecycles, coordinating the work of various components, and interacting with the Kubernetes cluster.

[0070] Web-based integrated development environment (IDE): Provides an embedded online development environment that allows users to write, edit, and debug function code within a browser. It features code tagging, error reporting, and supports real-time code saving and version control, improving user development efficiency.

[0071] The build controller manages the build process, including creating pipeline tasks and executing image builds. It monitors changes to custom resource objects and writes the build results back to the corresponding resource objects, ensuring automation and transparency in the build process.

[0072] The container scheduling component Knative provides core scheduling and management functions for serverless computing. Knative is responsible for automatically creating Kubernetes container groups and services based on user configurations, and monitoring service calls through internal activator and autoscaler components to dynamically adjust the size of container groups to optimize resource utilization.

[0073] Gateway service Istio: As the traffic management layer in a microservice architecture, Istio is responsible for handling requests entering the Kubernetes cluster. It provides load balancing, traffic control, monitoring, and security functions to ensure the stability and availability of serverless computing functions.

[0074] Step S2. Create a new serverless computing function on the front-end service serverless-ui interface, providing users with two build methods to choose from: online coding deployment or container image deployment, to meet different development needs.

[0075] In step S2, when the user selects the online coding deployment method to deploy the function, the specific steps executed by the backend serverless service are as follows:

[0076] Step S21. The serverless backend service automatically creates a new repository in the code repository;

[0077] Step S22. Execute the gitclone command to clone the new repository to the shared persistent storage mounted on the serverless container group of the backend service;

[0078] Step S23. Copy the code template to the corresponding location on the mounted shared persistent storage to complete the initialization of the code repository and the local working directory.

[0079] Furthermore, in step S2, when the user selects the container image deployment method to deploy the function, the user only needs to provide the image address and the exposed port number, without having to perform online coding and container image building steps.

[0080] Step S3. Obtain the function code that the user edits online through the interface of the front-end service serverless-ui. The function code is used to implement simple serverless computing functions.

[0081] In step S3, the front-end service serverless-ui calls the online coding integrated development environment web-ide to provide online coding functionality in an embedded IDE manner. The online coding functionality supports code marking and error prompting features. The online coding integrated development environment web-ide needs to be mounted with the same shared persistent storage as the back-end service serverless to ensure code file sharing.

[0082] In step S3, when a user saves online code, the backend service serverless executes the gitcommit command to commit the code changes to the corresponding code repository, thereby ensuring the effectiveness of version control.

[0083] Step S4. Obtain the service publishing request submitted by the user. In this step, obtain the service publishing request initiated by the user through the interface of the front-end service serverless-ui, so as to deploy the edited serverless computing function to the Kubernetes cluster and complete the formal launch of the function.

[0084] In step S4, when the user selects the online coding deployment method to deploy the function, the build process is started to generate a deployable container image.

[0085] When a user chooses to deploy a function using a container image, no build process is required; the release operation can be performed directly.

[0086] Step S5. The backend serverless service creates the KubernetesYAML configuration required by the build-controller tool and creates it in the cluster as a custom resource object; and continuously listens for changes to the custom resource object to obtain its latest status.

[0087] Step S6. The build tool build-controller listens for the creation of the custom resource object and creates the corresponding pipeline task to execute the image build; after the image build is completed, the image build result is written back to the custom resource object.

[0088] Step S7. The backend service serverless obtains the image build result; if the image build fails, it records the error information, displays the error log on the frontend service serverless-ui interface, and returns; if the image build succeeds, it continues with subsequent operations.

[0089] Step S8. The backend serverless service uses the container image to create a custom resource object of the container scheduling component Knative, thereby using the container scheduling component Knative to publish serverless computing functions.

[0090] Step S9. The container scheduling component Knative creates Kubernetes container groups and corresponding Kubernetes services based on the provided configuration information.

[0091] In step S9, after the Kubernetes container group and corresponding Kubernetes service are created, the container scheduling component Knative uses its internal activator component to monitor and analyze the Kubernetes service's call status. Simultaneously, Knative utilizes the autoscaler component to dynamically control the size of the Kubernetes container group. If the Kubernetes service remains inactive for an extended period, the size of the Kubernetes container group will be reduced to 0. Once a request is triggered, the size of the Kubernetes container group will automatically adjust to 1. This container group startup process can be completed within seconds, ensuring service efficiency and optimized resource utilization.

[0092] Step S10. The backend serverless service generates a random domain name prefix and combines the prefix with other domain name parts to generate a complete domain name. Then, a Kubernetes ingress is created and handed over to the gateway service Istio for processing.

[0093] Step S11. Through wildcard domain name resolution, point the generated domain name to the entry point of the gateway service Istio. This allows users to access serverless computing functions through this domain name, thereby triggering the corresponding functions.

[0094] A system for implementing a serverless computing platform includes:

[0095] The initialization module is used to initialize the various components of the serverless computing platform. These components include: the front-end service serverless-ui, the back-end service serverless, the online coding integrated development environment web-ide, the build tool build-controller, the container scheduling component knative, the gateway service istio, and the code repository and container image repository that need to be called.

[0096] The Create New Serverless Compute Function module is used to create new serverless compute functions on the front-end service serverless-ui interface. It provides two build methods for users to choose from: online coding deployment or container image deployment, to meet different development needs.

[0097] The function code acquisition module is used to acquire function code that users can edit online through the interface of the front-end service serverless-ui. The function code is used to implement simple serverless computing functions.

[0098] The service publishing request acquisition module is used to acquire service publishing requests submitted by users. In this step, the service publishing request initiated by the user through the front-end service serverless-ui interface is acquired so that the edited serverless computing function can be deployed to the Kubernetes cluster and the function can be officially launched.

[0099] The monitoring module is used to create the KubernetesYAML configuration required by the backend serverless service to create the build-controller and create it in the cluster as a custom resource object; and continuously monitors the change operations of the custom resource object to obtain the latest status of the custom resource object.

[0100] The image building module is used by the build-controller to listen for the creation of custom resource objects and create corresponding pipeline tasks to execute image building. After the image building is completed, the image building result is written back to the custom resource object. The backend service serverless obtains the image building result. If the image building fails, the error information is recorded, the error log is displayed on the interface of the frontend service serverless-ui, and then returned. If the image building is successful, subsequent operations continue.

[0101] The deployment module is used by backend serverless services to create custom resource objects of the container scheduling component Knative using container images, thereby enabling the deployment of serverless computing functions using the container scheduling component Knative.

[0102] A service module is created, which is used by the container scheduling component Knative to create Kubernetes container groups and corresponding Kubernetes services based on the provided configuration information. The backend service serverless generates a random domain name prefix and combines the domain name prefix with other domain name parts to generate a complete domain name. Then, a Kubernetes routing ingress is created and handed over to the gateway service Istio for processing. Through wildcard domain name resolution, the generated domain name is pointed to the entry point of the gateway service Istio. This allows users to access serverless computing functions through the domain name, thereby triggering the corresponding functions.

[0103] A computer device includes a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the above-described method for implementing a serverless computing platform.

[0104] A computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the above-described method for implementing a serverless computing platform.

[0105] The above are merely preferred embodiments of the present invention. It should be noted that those skilled in the art can make several modifications and improvements without departing from the structure of the present invention, and these will not affect the effectiveness of the implementation of the present invention or the practicality of the patent.

Claims

1. A method for implementing a serviceless computing platform, the method comprising: The method comprises the following steps: Step S1. Initialize various components of the serverless computing platform, including: front-end service, back-end service, online coding integrated development environment, build tool, container scheduling component, gateway service, and code repository and container image repository that need to be called; Step S2. Create a new serverless computing function on the interface of the front-end service, and provide two construction methods for user selection, including: online coding deployment or container image deployment, to meet different development needs; Step S3. Obtain the function code edited by the user online through the interface of the front-end service, which is used to implement the function of simple serverless computing; Step S4. Obtain the service publishing request submitted by the user, in which the service publishing request initiated by the user through the interface of the front-end service is obtained, so as to deploy the edited serverless computing function to the Kubernetes cluster and complete the formal online of the function; Step S5. The back-end service creates the Kubernetes YAML configuration required by the build tool, and creates it in the form of a custom resource object to the cluster; and continuously listens to the change operation of the custom resource object to obtain the latest state of the custom resource object; Step S6. The build tool listens to the creation of the custom resource object, and creates a corresponding pipeline task to perform image building; after the image building is completed, the image building result is written back to the custom resource object; Step S7. The back-end service obtains the image building result; if the image building fails, record the error information, display the error log on the interface of the front-end service, and return; if the image building is successful, continue the subsequent operation; Step S8. The back-end service creates a custom resource object of the container scheduling component using the container image, so as to realize the publishing of the serverless computing function by using the container scheduling component; Step S9. The container scheduling component creates a Kubernetes container group and a corresponding Kubernetes service according to the provided configuration information; Step S10. The back-end service generates a random domain name prefix, combines the domain name prefix with other domain name parts, and generates a complete domain name; and then creates a Kubernetes route for the gateway service to process; Step S11. Point the generated domain name to the gateway service through domain name generic domain name resolution; so that the user can access the serverless computing function through the domain name, thereby triggering the corresponding function.

2. The method of claim 1, wherein, In step S2, when the user selects the online coding deployment method to deploy the function, the back-end service performs the following specific steps: Step S21. The back-end service automatically creates a new repository in the code repository; Step S22. Execute the git clone command to clone the new repository to the shared persistent storage mounted by the container group of the back-end service; Step S23. Copy the code template to the corresponding position of the mounted shared persistent storage, thereby completing the initialization of the code repository and the local working directory.

3. The method of claim 1, wherein, In step S2, when the user selects the container image deployment mode to deploy the function, the user only needs to provide the image address and the exposure port number.

4. The method of claim 1, wherein, In step S3, the front-end service calls the online coding integrated development environment to provide online coding functions in the form of embedded IDE, which supports code tagging and error prompt features; the online coding integrated development environment needs to be mounted with the same shared persistent storage as the back-end service, thereby ensuring code file sharing.

5. The method of claim 1, wherein, In step S3, when the user saves the online coding, the back-end service executes the git commit command to commit the code changes to the corresponding code repository, thereby ensuring the effectiveness of version management.

6. The method of claim 1, wherein, In step S4, when the user selects the online coding deployment mode to deploy the function, the build process is started to generate a deployable container image; When the user selects the container image deployment mode to deploy the function, the build process is not required, and the publishing operation is directly executed.

7. The method of claim 1, wherein, In step S9, after the Kubernetes container group and the corresponding Kubernetes service are created, the container scheduling component uses the internal activator component to monitor and analyze the invocation of the Kubernetes service; at the same time, the container scheduling component uses the autoscaler component to dynamically control the size of the Kubernetes container group; in the case of long-time non-invocation of the Kubernetes service, the size of the Kubernetes container group will be reduced to 0; once a request is triggered, the size of the Kubernetes container group will be automatically adjusted to 1.

8. A system for implementing a serviceless computing platform, the system comprising: Comprise: An initialization module for initializing various components of the serverless computing platform, including: front-end service, back-end service, online coding integrated development environment, build tool, container scheduling component, gateway service, and code repository and container image repository that need to be called; A new serverless computing function module for creating a new serverless computing function on the interface of the front-end service, providing two construction methods for user selection, including online coding deployment or container image deployment to meet different development needs; A function code acquisition module for acquiring the function code edited by the user online through the interface of the front-end service, the function code being used to implement a simple serverless computing function; A service publishing request acquisition module for acquiring the service publishing request submitted by the user, in this step, the service publishing request initiated by the user through the interface of the front-end service is acquired, so as to deploy the edited serverless computing function to the Kubernetes cluster and complete the formal online of the function; A listening module for the back-end service to create the Kubernetes YAML configuration required by the build tool and create it in the form of a custom resource object in the cluster; and continuously listen to the change operation of the custom resource object to obtain the latest state of the custom resource object; The mirror building module is configured to listen to the creation of a custom resource object by the building tool, create a corresponding pipeline task, and perform mirror building; after the mirror building is completed, the mirror building result is written back to the custom resource object; the backend service obtains the mirror building result; if the mirror building fails, error information is recorded, error logs are displayed on the interface of the front-end service, and the process is returned; if the mirror building succeeds, subsequent operations are continued; The publishing module is configured to create a custom resource object of a container scheduling component by the backend service using a container image, so that the container scheduling component is used to publish a serverless computing function; The creating service module is configured to create a Kubernetes container group and a corresponding Kubernetes service according to provided configuration information by the container scheduling component; the backend service generates a random domain name prefix, combines the domain name prefix with other domain name parts, and thus generates a complete domain name; a Kubernetes route is created and handed over to a gateway service for processing; the generated domain name is pointed to the gateway service by domain name generic domain name resolution; and the user can access the serverless computing function through the domain name, so as to trigger the corresponding function. 9.A computer device, comprising a memory and a processor, wherein the memory stores a computer program, and the computer device is configured to perform the method according to any one of claims 1-8 when the computer program is executed by the processor. The computer program is executed by the processor to implement the implementation method of the serverless computing platform according to any one of claims 1-7.

10. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor to implement the implementation method of the serverless computing platform according to any one of claims 1-7.

Images