Program integration method, device, equipment and product

Abstract

The invention provides a program integration method, device, equipment and product, and relates to the technical field of artificial intelligence. The method comprises the steps of obtaining a plug-in definition file package of a first model capability program; according to the plug-in definition file package, generating a plug-in package operated by the first model capability program, calling a process operated by the plug-in package, and storing metadata of the plug-in package in a database; according to the plug-in package, distributing a corresponding original Kubernetes container arrangement engine cluster; and loading and operating the process instance of the plug-in package in the distributed native Kubernetes container arrangement engine cluster. A model capability program is packaged into a plug-in by adopting a plug-in thought, when the plug-in is repeatedly used in different application scenes, only a small amount of configuration needs to be carried out, a new service is re-operated, a large amount of repeated coding development does not need to be carried out, and the problems that a large model is high in integration cost and poor in reusability are solved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of artificial intelligence, in particular to a program integration method, device, equipment and product. BACKGROUND

[0002] In the existing technical scheme for integrating and calling large model capabilities of a server program, the server program receives and processes responses from a large model API. The responses usually contain the results of model prediction or other related information. Different large model APIs return different response information, which requires developers to develop separately. Developers need to parse API responses and extract the required information, such as model output results or other related data. At the same time, they also need to handle possible error situations, such as network connection problems, API request format errors, or model service unavailability. Large model capability integration is performed by the server system of the integrator according to different interfaces of different large models to write background business logic for adaptation. The developed server program is customized and has poor reusability and high integration cost. SUMMARY

[0003] The present application aims to provide a program integration method, device, equipment and product to solve the problem of high integration cost and poor reusability of the server program in the prior art, which needs to be customized and developed for different large model interfaces.

[0004] To achieve the above-mentioned purpose, an embodiment of the present application provides a program integration method, which comprises the following steps:

[0005] obtaining a plug-in definition file package of a first model capability program;

[0006] generating a plug-in package for running the first model capability program according to the plug-in definition file package, calling a process running the plug-in package, and saving metadata of the plug-in package in a database;

[0007] allocating a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package;

[0008] loading a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

[0009] Optionally, the method further comprises the following steps:

[0010] The plug-in package comprises a plug-in form file obtained through the plug-in form definition file, a plug-in callback function file obtained through the plug-in callback function definition file, and a running image of the plug-in callback function in the plug-in callback function file.

[0011] The metadata includes data extracted from the plugin form file and the plugin callback function, respectively.

[0012] Optionally, the method, wherein, after obtaining the plugin definition file package of the first model capability program, the method further comprises:

[0013] verifying the plugin form definition file in the plugin definition file package to obtain a first verification result;

[0014] In the case where the first verification result is passed, pre-compiling the plugin callback function according to the plugin callback function definition file in the plugin definition file package; wherein the pre-compiled plugin callback function is used to generate the plugin package.

[0015] Optionally, the method, wherein, before calling the process running the plugin package, the method further comprises:

[0016] loading a sandbox environment process according to the programming language type of the plugin callback function file; wherein the plugin callback function file is obtained through the plugin callback function definition file in the plugin definition file package;

[0017] placing the plugin callback function in the plugin callback function file in the sandbox environment process for simulation verification, and in the case where the verification is passed, generating a running image of the plugin callback function; wherein the running image of the plugin callback function is used to generate the plugin package.

[0018] Optionally, the method, wherein, after loading the process instance running the plugin package, the method further comprises:

[0019] obtaining monitoring index data reported by the process instance at runtime;

[0020] analyzing the monitoring index data;

[0021] In the case where the monitoring index data is higher than a preset threshold, expanding the process instance.

[0022] Optionally, the method, wherein, before loading the process instance running the plugin package in the allocated native Kubernetes container orchestration engine cluster, the method further comprises:

[0023] obtaining a configuration file of the allocated native Kubernetes container orchestration engine cluster;

[0024] According to the configuration file, initializing the access file of the allocated native Kubernetes container orchestration engine cluster.

[0025] Optionally, the method, wherein after loading the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster, the method further comprises:

[0026] obtaining the process instance of the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster;

[0027] According to the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster, the automatic deployment of the index collection exporter index exporter in the allocated native Kubernetes container orchestration engine cluster is carried out.

[0028] Optionally, the method further comprises:

[0029] displaying a programming page capable of calling a task flow of the process instance running the plug-in package;

[0030] obtaining the user's orchestration operation on the programming page;

[0031] According to the orchestration operation, the business process graph of the task flow is obtained, and the business process information corresponding to the business process graph is saved.

[0032] To achieve the above purpose, an embodiment of the present application provides an instance calling method, comprising:

[0033] obtaining an instance calling instruction initiated by a user, the instance calling instruction being used to call a process instance running a plug-in package corresponding to a first model capability program; wherein the process instance running the plug-in package corresponding to the first model capability program is loaded and run in an allocated native Kubernetes container orchestration engine cluster, and the metadata of the plug-in package is saved in a database;

[0034] According to the metadata in the database, a callback interface of the process instance running the plug-in package is called in the allocated native Kubernetes container orchestration engine cluster.

[0035] Optionally, the method, wherein the plug-in package comprises a plug-in form file, a plug-in callback function file, and a running image of a plug-in callback function in the plug-in callback function file.

[0036] Optionally, the method, wherein before obtaining the instance calling instruction initiated by the user, the method further comprises:

[0037] providing a file editing interface of the first model capability program;

[0038] Obtaining form editing information input by a user on the file editing interface;

[0039] According to the form editing information, modifying a plug-in form file in the plug-in package.

[0040] Optionally, the method, wherein providing a file editing interface of the first model capability program comprises:

[0041] Obtaining metadata in the database, and obtaining a plug-in form file in the plug-in package;

[0042] According to form information of the plug-in form file, obtaining the file editing interface of the first model capability program.

[0043] Optionally, the method, wherein before obtaining an instance invocation instruction initiated by a user, the method further comprises:

[0044] Obtaining a process instance initiated by a user in a business process graph; wherein the business process graph comprises a task flow capable of invoking a process instance running the plug-in package;

[0045] According to the process instance, generating a to-do task.

[0046] Optionally, the method, wherein invoking a callback interface of the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster comprises:

[0047] Obtaining context information of the to-do task processing;

[0048] By analyzing the context information, assembling incoming parameters;

[0049] According to the incoming parameters, invoking the callback interface of the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

[0050] To achieve the above purpose, an embodiment of the present application provides a program integration system, comprising:

[0051] A database is configured to obtain a plug-in definition file package of a first model capability program, generate a plug-in package for running the first model capability program according to the plug-in definition file package, invoke a process running the plug-in package, and save metadata of the plug-in package;

[0052] A cluster management module is configured to allocate a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package;

[0053] The plugin execution module is configured to load a process instance running the plugin package in the allocated native Kubernetes container orchestration engine cluster.

[0054] The plugin flow execution module is configured to obtain an instance invocation instruction initiated by a user, the instance invocation instruction being used to invoke a process instance running a plugin package corresponding to the first model capability program.

[0055] The plugin execution module is further configured to, according to the metadata in the database, invoke a callback interface of the process instance running the plugin package in the allocated native Kubernetes container orchestration engine cluster.

[0056] Optionally, the system, wherein the database is further configured to verify a plugin form definition file in the plugin definition file package to obtain a first verification result; and in a case where the first verification result is passed, precompile a plugin callback function according to a plugin callback function definition file in the plugin definition file package; wherein the precompiled plugin callback function is used to generate the plugin package.

[0057] Optionally, the system, wherein the database is further configured to load a sandbox environment process according to a programming language type of a plugin callback function file, wherein the plugin callback function file is obtained through the plugin callback function definition file in the plugin definition file package; place the plugin callback function in the plugin callback function file in the sandbox environment process for simulation verification; in a case where the verification is passed, generate a running image of the plugin callback function; wherein the running image of the plugin callback function is used to generate the plugin package.

[0058] Optionally, the system, wherein the system further comprises a plugin observability engine configured to obtain monitoring index data reported by the process instance during runtime; analyze the monitoring index data; and in a case where the monitoring index data is higher than a preset threshold, scale the process instance.

[0059] Optionally, the plugin observability engine is further configured to obtain an index collection task initialization instruction of the process instance and information of the allocated native Kubernetes container orchestration engine cluster; and according to the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster, automatically deploy an index collection exporter in the allocated native Kubernetes container orchestration engine cluster.

[0060] Optionally, the system, wherein the plug-in execution module is further configured to obtain a configuration file of the assigned native Kubernetes container orchestration engine cluster; and initialize an access file of the assigned native Kubernetes container orchestration engine cluster according to the configuration file.

[0061] Optionally, the system, wherein the plug-in process execution module is further configured to display a programming page of a task process capable of calling a process instance running the plug-in package; obtain an orchestration operation of a user on the programming page; obtain a business process graph of the task process according to the orchestration operation, and save business process information corresponding to the business process graph.

[0062] Optionally, the system, wherein the system further comprises a plug-in form module configured to provide a file editing interface of the first model capability program; obtain form editing information input by a user on the file editing interface; and modify a plug-in form file in the plug-in package according to the form editing information.

[0063] Optionally, the system, wherein the plug-in form module is further configured to obtain metadata in the database, and obtain a plug-in form file in the plug-in package; and obtain the file editing interface of the first model capability program according to form information of the plug-in form file.

[0064] Optionally, the system, wherein the plug-in process execution module is further configured to obtain a process instance initiated by a user in a business process graph; wherein the business process graph comprises a task process capable of calling a process instance running the plug-in package; and generate a to-do task according to the process instance.

[0065] Optionally, the system, wherein the plug-in execution module is further configured to obtain context information of the to-do task processing; assemble an incoming parameter by analyzing the context information; and call a callback interface of a process instance running the plug-in package according to the incoming parameter in the assigned native Kubernetes container orchestration engine cluster.

[0066] To achieve the above object, embodiments of the present application provide a program integration device, comprising:

[0067] A first obtaining module is configured to obtain a plug-in definition file package of a first model capability program;

[0068] A first processing module is configured to generate a plug-in package running the first model capability program according to the plug-in definition file package, call a process running the plug-in package, and save metadata of the plug-in package in a database;

[0069] The second processing module is configured to allocate a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package.

[0070] The third processing module is configured to load a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

[0071] To achieve the above object, an embodiment of the present application provides an instance calling device, which comprises:

[0072] The second obtaining module is configured to obtain an instance calling instruction initiated by a user, the instance calling instruction being used to call a process instance running a plug-in package corresponding to a first model capability program; wherein the process instance running the plug-in package corresponding to the first model capability program is loaded and run in an allocated native Kubernetes container orchestration engine cluster, and metadata of the plug-in package is saved in a database.

[0073] The fourth processing module is configured to call a callback interface of the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster according to the metadata in the database.

[0074] To achieve the above object, an embodiment of the present application provides an electronic device, which comprises a transceiver, a processor, a memory, and a program or instruction stored in the memory and executable on the processor; wherein the processor implements the program integration method or the instance calling method as described above when executing the program or instruction.

[0075] To achieve the above object, an embodiment of the present application provides a readable storage medium, which stores a program or instruction, wherein the program or instruction is executable on a processor to implement the steps of the program integration method or the steps of the instance calling method as described above.

[0076] To achieve the above object, an embodiment of the present application provides a computer program product, which comprises computer instructions, wherein the computer instructions are executable on a processor to implement the steps of the program integration method or the steps of the instance calling method as described above.

[0077] The above technical solution of the present application has the following advantages:

[0078] In an embodiment of the present invention, a plug-in package for running the first model capability program is generated based on a plug-in definition file package of the first model capability program. Based on the plug-in package, a process instance for running the plug-in package is loaded in the allocated native Kubernetes container orchestration engine cluster. This approach encapsulates the model capability program into a plug-in. When reused in different application scenarios, only a small amount of configuration is required to re-run a new service, eliminating the need for extensive repetitive coding development. This solves the problems of high integration costs and poor reusability of large models. BRIEF DESCRIPTION OF THE DRAWINGS

[0079] Figure 1 A schematic diagram of a program integration method according to an embodiment of the present invention;

[0080] Figure 2 A schematic diagram of a program integration system according to an embodiment of the present invention;

[0081] Figure 3 A deployment flow chart of the program integration system according to an embodiment of the present invention;

[0082] Figure 4 This is one of the flow charts of the program integration method according to an embodiment of the present invention;

[0083] Figure 5 This is a second flowchart of the program integration method according to an embodiment of the present invention;

[0084] Figure 6 A flowchart of an example calling method according to an embodiment of the present invention;

[0085] Figure 7 A schematic diagram of an example calling method according to an embodiment of the present invention;

[0086] Figure 8 A schematic diagram of a program integration device according to an embodiment of the present invention;

[0087] Figure 9 A schematic diagram of an example calling device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0088] In order to make the technical problems, technical solutions and advantages to be solved by the present invention clearer, a detailed description will be given below with reference to the accompanying drawings and specific embodiments.

[0089] It should be understood that every reference to “one embodiment” or “an embodiment” throughout the specification means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the application. Therefore, the appearance of the phrases “in one embodiment” or “in an embodiment” in various places throughout the specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics can be combined in any suitable manner in one or more embodiments.

[0090] In various embodiments of the application, it should be understood that the size of the serial number of the following processes does not mean the order of execution, and the execution order of the processes should be determined by its function and inherent logic, and should not constitute any limitation on the implementation process of the embodiments of the application.

[0091] In addition, the terms “system” and “network” are often used interchangeably herein.

[0092] In the embodiments provided by the application, it should be understood that “B corresponding to A” means that B is associated with A, and B can be determined according to A. However, it should also be understood that determining B according to A does not mean that B is determined only according to A, but B can also be determined according to A and / or other information.

[0093] For the convenience of understanding, some of the contents related to the embodiments of the application are described as follows:

[0094] As shown in FIG. 1, a program integration method according to an embodiment of the application, comprising: Figure 1

[0095] S10, obtaining a plug-in definition file package of a first model capability program;

[0096] It should be noted that, as shown in FIG. 2, the developer submits the plug-in definition file package to the database of the program integration system after the task starts, wherein the plug-in definition file package includes a plug-in form definition file and a plug-in callback function definition file. The developer only needs to write the plug-in form definition yaml file according to the large model capability plug-in form definition specification, and write the plug-in callback function definition file using python language or nodejs language according to the large model capability plug-in callback function definition specification. The plug-in form definition file and the plug-in callback function definition file written are submitted to the large model capability plug-in platform (i.e. the program integration system) for preprocessing. Figure 4 A schematic diagram of a program integration system for running the program integration method according to the embodiments of the application, the program integration system comprising a database. Figure 2

[0097] ​​S20, generating the plugin package for the first model capability program according to the plugin definition file package, calling the process of running the plugin package, and saving the metadata of the plugin package in the database;

[0098] It should be noted that, as Figure 4 shown, the large model capability plugin platform (i.e., the program integration system) parses the plugin package definition file package, extracts the metadata of the plugin form file and the plugin callback function file in the plugin package, and persists the metadata to the database of the large model capability plugin platform (i.e., the program integration system).

[0099] S30, according to the plugin package, allocate the corresponding native Kubernetes container orchestration engine cluster;

[0100] It should be noted that, as Figure 4 shown, the native K8s cluster in the cluster management module of the program integration system is allocated, that is, the corresponding native Kubernetes container orchestration engine cluster is allocated. As Figure 2 shown, the program integration system further includes a cluster management module.

[0101] S40, load the process instance of running the plugin package in the allocated native Kubernetes container orchestration engine cluster;

[0102] It should be noted that, as Figure 4 shown, the plugin callback function running process instance is pulled up in the plugin execution module of the program integration system, that is, the process instance of running the plugin package is loaded in the allocated native Kubernetes container orchestration engine cluster. As Figure 2 shown, the program integration system further includes a plugin execution module.

[0103] In this embodiment, according to the plugin definition file package of the first model capability program, the plugin package for the first model capability program is generated, and according to the plugin package, the process instance of running the plugin package is loaded in the allocated native Kubernetes container orchestration engine cluster. The model capability program is encapsulated into a plugin by taking the idea of plugin, and when it is reused in different application scenarios, only a new service needs to be run with a small amount of configuration, without a large amount of repeated coding and development, to solve the problems of high integration cost and poor reusability of large models.

[0104] Optionally, the method, wherein the plugin definition file package includes a plugin form definition file and a plugin callback function definition file;

[0105] The plug-in package includes a plug-in form file obtained through the plug-in form definition file, a plug-in callback function file obtained through the plug-in callback function definition file, and a running image of a plug-in callback function in the plug-in callback function file.

[0106] The metadata includes data extracted from the plug-in form file and the plug-in callback function, respectively.

[0107] In this embodiment, after the running image of the plug-in callback function in the plug-in callback function file is generated, the large model capability plug-in platform (i.e., the program integration system) packs the plug-in form file obtained through the plug-in form definition file, the plug-in callback function file obtained through the plug-in callback function definition file, and the running image of the plug-in callback function in the plug-in callback function file to generate a standard large model capability plug-in package (i.e., the plug-in package).

[0108] Optionally, the method further includes, after the step S10:

[0109] checking the plug-in form definition file in the plug-in definition file package to obtain a first checking result;

[0110] In a case where the first checking result is passed, pre-compiling a plug-in callback function according to a plug-in callback function definition file in the plug-in definition file package; wherein the plug-in callback function after pre-compiling is used to generate the plug-in package.

[0111] In this embodiment, the checking rule of the plug-in form definition file is as follows:

[0112] The writing and generation format of the plug-in form definition file is written in the format of JSON (JavaScript Object Notation, JavaScript object notation). The content of the plug-in form definition file is a JSON object, and the attributes of the JSON object include the three attributes of key, name, and fields. The key attribute is the unique identifier of the form definition file, which is a globally unique string in each plug-in form definition file in the large model capability plug-in platform (i.e., the program integration system), composed of uppercase letters (A-Z), lowercase letters (a-z), numbers (0-9), and special characters, and has a length of 32 bits. The name attribute is the name of the plug-in form definition file, composed of uppercase letters (A-Z), lowercase letters (a-z), and numbers (0-9), and has a length of 1-50 bits. The fields attribute is a collection of form definition attributes of the plug-in form definition file, which is an array of form field JSON objects. The form field JSON object includes five attributes: id, name, type, required, and placeholder. The id attribute of the form field represents the unique identifier of the form field, composed of uppercase letters (A-Z) and lowercase letters (a-z), and has a length of 1-50 bits. The name attribute of the form field represents the name of the form field, composed of uppercase letters (A-Z) and lowercase letters (a-z), and has a length of 1-50 bits. The type attribute of the form field represents the type of the form field, including input box (input), date (date), radio box (radio), check box (checkbox), attachment (file), drop-down box (select), and text area (textarea). The required attribute of the form field represents whether the form field is required, including two types of true and false. True represents required, and false represents non-required. The placeholder attribute of the form field represents the placeholder set for the form field, which defaults to empty and supports setting a custom placeholder variable. If it is set, the plug-in form module in the program integration system injects the placeholder variable extracted from the context information when rendering the form. Figure 2 The program integration system also includes a plug-in form module.

[0113] Optionally, the method further comprises, before step S20:

[0114] According to the programming language type of the plug-in callback function file, a sandbox environment process is loaded. The plug-in callback function file is obtained through the plug-in callback function definition file in the plug-in definition file package.

[0115] The plugin callback function in the plugin callback function file is placed in the sandbox environment process for simulation verification, and a running image of the plugin callback function is generated if the verification is passed.

[0116] In this embodiment, after the large model capability plugin platform (i.e., program integration system) verifies the legality of the plugin form definition file and the plugin callback function definition file, a sandbox environment process is pulled based on the programming language type (python / nodeJs) of the plugin callback function file obtained through the plugin callback function definition file to simulate interface calling to simulate and verify the plugin callback function, and a callback function running image is generated by pulling the corresponding base image. The sandbox environment is a safe and isolated virtual execution space, so that programs or codes are limited to run in it without affecting the real system or external environment, thereby performing simulation verification.

[0117] Optionally, the method, wherein after the step S40, the method further comprises:

[0118] Obtaining monitoring index data reported by the process instance at runtime;

[0119] Analyzing the monitoring index data;

[0120] In the case where the monitoring index data is higher than a preset threshold, the process instance is scaled out.

[0121] In this embodiment, the plugin observability module in the program integration system is responsible for analyzing the monitoring index data (CPU, memory, IO, Socket, and resource usage) reported by the process instance at runtime, and determining whether to scale out or scale in the process instance based on the analysis result. This module is a non-optional component, and can be selectively enabled in scenarios where an open source log service system (ELK, etc.) or a commercial log system is already available in the actual user environment. The judgment rule of the plugin observability module for scaling out or scaling in the process instance according to the monitoring index data reported by the process instance at runtime is as follows:

[0122] 1) CPU. When the CPU usage of the process instance at runtime exceeds 90%, the plugin observability module detects that the CPU of the process instance is too high, and notifies the plugin observability module to scale out the process instance. The plugin observability module calls the HPA controller interface of the k8s cluster where the process instance is located to automatically scale out or scale in the Pod.

[0123] 2) Memory. When the memory usage of the process instance in running exceeds 90%, the large model capability plug-in observability engine detects the process instance with high memory and notifies the plug-in observability module to scale the process instance.

[0124] The plug-in observability module calls the HPA controller interface of the k8s cluster where the process instance is located to automatically scale the pod.

[0125] 3) IO (input / output). When the IO usage of the process instance in running reaches 70% of the upper limit of the node host IO, the plug-in observability module detects the process instance with high IO usage and notifies the plug-in observability module to scale the process instance, and the plug-in observability module elastic scaling scheduling controller adjusts the instance distribution of the process instance and schedules to a host with higher IO performance.

[0126] 4) Socket. When the Socket handle occupancy continues to grow to more than 90% of the maximum handle limit of the server host, after the plug-in observability module detects the process instance with high Socket handle occupancy and usage, it notifies the plug-in observability module to scale the process instance, and the plug-in observability module elastic scaling scheduling controller adjusts the deployment host server configuration of the process instance or adjusts the instance distribution of the process instance.

[0127] As shown in Figure 2 The program integration system also includes a plug-in observability module.

[0128] Optionally, the method, wherein before loading the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster, the method further comprises:

[0129] Obtaining the configuration file of the allocated native Kubernetes container orchestration engine cluster;

[0130] According to the configuration file, initializing the access file of the allocated native Kubernetes container orchestration engine cluster.

[0131] In this embodiment, as shown in Figure 4As shown, the plugin execution module sends an application native Kubernetes container orchestration engine cluster instruction to the cluster management module after receiving the sandbox environment simulation verification instruction. The cluster management module responds to the plugin execution module with a success message and returns the allocated Kubernetes container orchestration engine cluster kubeconfig (configuration) file if the allocation of the native Kubernetes container orchestration engine cluster is successful. If the allocation of the native Kubernetes container orchestration engine cluster fails, the cluster management module responds to the plugin execution module with a failure message. After the plugin execution module sends the application native Kubernetes container orchestration engine cluster instruction to the cluster management module and the instruction is processed successfully, the plugin execution module performs a local initialization operation on the native Kubernetes container orchestration engine cluster access file. After the local initialization of the native Kubernetes container orchestration engine cluster access file is completed, the plugin execution module loads and runs the process instance of the plugin package in the allocated native Kubernetes container orchestration engine cluster.

[0132] Optionally, the method further comprises the following steps after the process instance of the plugin package is loaded and run in the allocated native Kubernetes container orchestration engine cluster:

[0133] obtaining an index collection task initialization instruction of the process instance and information of the allocated native Kubernetes container orchestration engine cluster;

[0134] automatically deploying an index collection exporter in the allocated native Kubernetes container orchestration engine cluster according to the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster.

[0135] In this embodiment, as shown in Figure 4 After the plugin execution module successfully loads and runs the process instance of the plugin package in the allocated native Kubernetes container orchestration engine cluster, the plugin execution module sends an index collection task initialization instruction of the process instance to the plugin observability module and transmits information of the Kubernetes container orchestration engine cluster where the process instance is located. After receiving the index collection task initialization instruction, the plugin observability module automatically deploys an exporter in the Kubernetes container orchestration engine cluster where the plugin callback function running process is located.

[0136] Optionally, the method further comprises the following steps:

[0137] displaying a programming page that can call a task flow of the process instance running the plugin package.

[0138] obtaining a user's arrangement operation on the programming page;

[0139] According to the arrangement operation, a business process graph of the task flow is obtained, and business process information corresponding to the business process graph is saved.

[0140] In this embodiment, as shown in Figure 5 , a developer (i.e., a user of a program integration method) uses a web-side flow canvas page function (i.e., a programming page capable of calling a task flow of a process instance running the plug-in package) of a plug-in flow execution module to arrange task nodes and gateway connections for drawing a business process graph, and sets a task node capable of selecting a large model capability type (i.e., capable of calling a process instance running the plug-in package) when drawing the business process graph. After the developer completes drawing the business process graph in the plug-in flow execution module, business process information corresponding to the business process graph is saved to the plug-in flow execution module. As shown in Figure 2 , the program integration system further includes a plug-in flow execution module.

[0141] As shown in Figure 7 , to achieve the above purpose, an embodiment of the present application provides an instance calling method, which includes the following steps.

[0142] A10, an instance calling instruction initiated by a user is obtained, the instance calling instruction being used to call a process instance running a plug-in package corresponding to a first model capability program; wherein the process instance running the plug-in package corresponding to the first model capability program is loaded and run in an assigned native Kubernetes container orchestration engine cluster, and metadata of the plug-in package is saved in a database;

[0143] It should be noted that, as shown in Figure 6 , triggering a large model capability plug-in task node action in the plug-in flow execution module in the program integration system, i.e., obtaining the instance calling instruction initiated by the user.

[0144] A20, according to the metadata in the database, a callback interface of the process instance running the plug-in package is called in the assigned native Kubernetes container orchestration engine cluster;

[0145] It should be noted that, as shown in Figure 6 , calling a callback interface of a large model capability plug-in callback function container process in the plug-in execution module in the program integration system, i.e., calling the callback interface of the process instance running the plug-in package in the assigned native Kubernetes container orchestration engine cluster.

[0146] Optionally, the method, wherein the plug-in package includes a plug-in form file, a plug-in callback function file, and a running image of a plug-in callback function in the plug-in callback function file.

[0147] In this embodiment, after the running image of the plug-in callback function in the plug-in callback function file is generated, the large model capability plug-in platform (i.e., the program integration system) packs the plug-in form file obtained through the plug-in form definition file, the plug-in callback function file obtained through the plug-in callback function definition file, and the running image of the plug-in callback function in the plug-in callback function file to generate a standard large model capability plug-in package (i.e., the plug-in package).

[0148] Optionally, the method, wherein, before the step A10, the method further includes:

[0149] providing a file editing interface of the first model capability program;

[0150] obtaining form editing information input by a user on the file editing interface;

[0151] modifying the plug-in form file in the plug-in package according to the form editing information.

[0152] In this embodiment, as shown in Figure 6 the plug-in form module, the user fills in the large model capability plug-in form page information, i.e., obtains the form editing information input by the user on the file editing interface, and modifies the plug-in form file in the plug-in package according to the form editing information. After the first model capability program is encapsulated into a plug-in, the plug-in can be reused in different application scenarios by only running a new service after a small amount of configuration, without the need for a large amount of repeated coding and development, thereby solving the problems of high cost and poor reusability of large model integration.

[0153] Optionally, the method, wherein the providing of the file editing interface of the first model capability program includes:

[0154] obtaining metadata in the database and obtaining the plug-in form file in the plug-in package;

[0155] obtaining the file editing interface of the first model capability program according to form information of the plug-in form file.

[0156] In this embodiment, as shown in Figure 6As shown, the large model capability plug-in metadata is pulled in the database, that is, the metadata is obtained in the database, so as to obtain the plug-in form file in the plug-in package. The large model capability plug-in initiation form page is rendered on the plug-in form module, that is, the file editing interface of the first model capability program is obtained according to the form information of the plug-in form file. And the browser page is updated, and after the user fills in the information on the file editing interface and submits, the plug-in process execution module is instructed to send a form filling completion receipt. The form information includes form field layout and form field type and the like.

[0157] Optionally, the method, wherein, before the step A10, the method further comprises:

[0158] Obtaining a process instance initiated by a user in a business process diagram; wherein the business process diagram comprises a task flow capable of calling a process instance running the plug-in package;

[0159] Generating a to-do task according to the process instance.

[0160] In this embodiment, as shown in Figure 6 As shown, after the plug-in process execution module receives the process instance initiation instruction issued by the user, it internally generates a process node task and a process flow. When the user issues a to-do task processing instruction to the plug-in process execution module, the plug-in process execution module issues a metadata pulling instruction to the database to obtain the plug-in form definition file associated with the to-do task.

[0161] Optionally, the method, wherein the step A20 comprises:

[0162] Obtaining context information of the to-do task processing;

[0163] Assembling the incoming parameters by analyzing the context information;

[0164] In the allocated native Kubernetes container orchestration engine cluster, according to the incoming parameters, a callback interface of a process instance running the plug-in package is called.

[0165] In this embodiment, as shown in Figure 6As shown, the plug-in flow execution module sends a trigger large model capability plug-in node action instruction to the plug-in execution module, and passes the user's to-do task processing context information to the plug-in execution module. After receiving the trigger large model capability plug-in node action instruction, the plug-in execution module parses the user's to-do task processing context information, assembles the incoming parameters to call the callback interface of the process instance running the plug-in package, and returns the response result of the callback interface to the plug-in flow execution module. After receiving the large model capability plug-in node action processing completion instruction of the plug-in execution module, the plug-in flow execution module updates the process node task state for subsequent process flow transfer.

[0166] To achieve the above purpose, an embodiment of the present application provides a program integration system, which comprises:

[0167] A database is configured to obtain a plug-in definition file package of a first model capability program, generate a plug-in package for running the first model capability program according to the plug-in definition file package, call a process running the plug-in package, and save metadata of the plug-in package.

[0168] A cluster management module is configured to allocate a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package.

[0169] A plug-in execution module is configured to load a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

[0170] A plug-in flow execution module is configured to obtain an instance calling instruction initiated by a user, the instance calling instruction being used to call a process instance running a plug-in package corresponding to the first model capability program.

[0171] The plug-in execution module is further configured to call a callback interface of the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster according to the metadata in the database.

[0172] In this embodiment, as shown, Figure 2 The program integration system comprises a database, a cluster management module, a plug-in execution module, a plug-in flow execution module, a plug-in form module, and a plug-in observability module. The database is based on a harbor warehouse for secondary development, and is deployed in a k8s cluster in a containerized manner through a docker image. The cluster management module is a GO language backend application, and is deployed in a k8s cluster in a containerized manner through a docker image. The plug-in execution module is a backend application, and is deployed in a k8s cluster in a containerized manner through a docker image. The plug-in flow execution module is a backend application, and is deployed in a k8s cluster in a containerized manner through a docker image. As shown,Figure 3 As shown in the figure, the plug-in form module, the cluster management module, the plug-in execution module, and the database are sequentially deployed in the program integration system; in a case where it is determined that the deployment environment needs to be arranged for business scenarios, the plug-in process execution module is deployed; and in a case where it is determined that the deployment environment needs to be connected to a monitoring platform product, the plug-in observability module is deployed.

[0173] Optionally, the system, wherein the database is further configured to verify the plug-in form definition file in the plug-in definition file package to obtain a first verification result; and in a case where the first verification result is passed, pre-compile a plug-in callback function according to a plug-in callback function definition file in the plug-in definition file package; wherein the plug-in callback function after pre-compilation is used to generate the plug-in package.

[0174] Optionally, the system, wherein the database is further configured to load a sandbox environment process according to a programming language type of a plug-in callback function file; wherein the plug-in callback function file is obtained through a plug-in callback function definition file in the plug-in definition file package; place the plug-in callback function in the plug-in callback function file in the sandbox environment process for simulation verification; in a case where the verification is passed, generate a running image of the plug-in callback function; wherein the running image of the plug-in callback function is used to generate the plug-in package.

[0175] Optionally, the system, wherein the system further comprises a plug-in observability module configured to obtain monitoring index data reported by the process instance during runtime; analyze the monitoring index data; and in a case where the monitoring index data is higher than a preset threshold, expand the process instance.

[0176] In this embodiment, as shown in the figure, Figure 2 The program integration system further comprises a plug-in observability module, which is a backend application and is deployed in a containerized manner in a k8s cluster through a docker image. Figure 3 As shown in the figure, in a case where it is determined that the deployment environment needs to be connected to a monitoring platform product, the plug-in observability module is deployed.

[0177] Optionally, the system, wherein the plug-in observability engine is further configured to obtain an index collection task initialization instruction of the process instance and information of the allocated native Kubernetes container orchestration engine cluster; and according to the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster, automatically deploy an index collection exporter in the allocated native Kubernetes container orchestration engine cluster.

[0178] Optionally, the system, wherein the plug-in execution module is further configured to obtain a configuration file of the allocated native Kubernetes container orchestration engine cluster; and initialize an access file of the allocated native Kubernetes container orchestration engine cluster according to the configuration file.

[0179] Optionally, the system, wherein the plug-in process execution module is further configured to display a programming page of a task process capable of calling a process instance running the plug-in package; obtain an orchestration operation of a user on the programming page; obtain a business process graph of the task process according to the orchestration operation, and save business process information corresponding to the business process graph.

[0180] Optionally, the system, wherein the system further comprises a plug-in form module configured to provide a file editing interface of the first model capability program; obtain form editing information input by a user on the file editing interface; and modify a plug-in form file in the plug-in package according to the form editing information.

[0181] In this embodiment, as shown in Figure 2 The program integration system further comprises a plug-in form module, which is a front-end and back-end integrated monomer project, and is deployed in a containerized manner in a k8s cluster through a docker image.

[0182] Optionally, the system, wherein the plug-in form module is further configured to obtain metadata in the database, and obtain a plug-in form file in the plug-in package; and obtain the file editing interface of the first model capability program according to form information of the plug-in form file.

[0183] Optionally, the system, wherein the plug-in process execution module is further configured to obtain a process instance initiated by a user in a business process graph; wherein the business process graph comprises a task process capable of calling a process instance running the plug-in package; and generate a to-do task according to the process instance.

[0184] Optionally, the system, wherein the plug-in execution module is further configured to obtain context information of the to-do task processing; assemble incoming parameters by analyzing the context information; and call a callback interface of a process instance running the plug-in package according to the incoming parameters in the allocated native Kubernetes container orchestration engine cluster.

[0185] As shown in Figure 8 To achieve the above purpose, an embodiment of the present application provides a program integration device, which comprises:

[0186] A first obtaining module 801 is configured to obtain a plug-in definition file package of a first model capability program.

[0187] The first processing module 802 is configured to generate a plug-in package for running the first model capability program according to the plug-in definition file package, call a process running the plug-in package, and save metadata of the plug-in package in a database.

[0188] The second processing module 803 is configured to allocate a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package.

[0189] The third processing module 804 is configured to load a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

[0190] Optionally, the apparatus, wherein the plug-in definition file package comprises a plug-in form definition file and a plug-in callback function definition file.

[0191] The plug-in package comprises a plug-in form file obtained through the plug-in form definition file, a plug-in callback function file obtained through the plug-in callback function definition file, and a running image of a plug-in callback function in the plug-in callback function file.

[0192] The metadata comprises data extracted from the plug-in form file and the plug-in callback function, respectively.

[0193] Optionally, the apparatus further comprises:

[0194] The third obtaining module is configured to check a plug-in form definition file in the plug-in definition file package and obtain a first checking result.

[0195] The fifth processing module is configured to, if the first checking result is passed, precompile a plug-in callback function according to a plug-in callback function definition file in the plug-in definition file package; wherein the plug-in callback function after precompilation is used to generate the plug-in package.

[0196] Optionally, the apparatus further comprises:

[0197] The sixth processing module is configured to load a sandbox environment process according to a programming language type of a plug-in callback function file; wherein the plug-in callback function file is obtained through a plug-in callback function definition file in the plug-in definition file package.

[0198] The first generating module is configured to place a plug-in callback function in the plug-in callback function file in the sandbox environment process for simulation verification, and generate a running image of the plug-in callback function if the verification is passed; wherein the running image of the plug-in callback function is used to generate the plug-in package.

[0199] Optionally, the apparatus further comprises:

[0200] a fourth obtaining module, configured to obtain monitoring index data reported by the process instance at runtime;

[0201] a seventh processing module, configured to analyze the monitoring index data;

[0202] an eighth processing module, configured to, in a case where the monitoring index data is higher than a preset threshold, expand the process instance.

[0203] Optionally, the apparatus further comprises:

[0204] a fifth obtaining module, configured to obtain a configuration file of the allocated native Kubernetes container orchestration engine cluster;

[0205] a ninth processing module, configured to initialize an access file of the allocated native Kubernetes container orchestration engine cluster according to the configuration file.

[0206] Optionally, the apparatus further comprises:

[0207] a sixth obtaining module, configured to obtain an index collection task initialization instruction of the process instance and information of the allocated native Kubernetes container orchestration engine cluster;

[0208] a tenth processing module, configured to, according to the index collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster, perform automatic deployment of an index collection exporter in the allocated native Kubernetes container orchestration engine cluster.

[0209] Optionally, the apparatus further comprises:

[0210] an eleventh processing module, configured to display a programming page of a task flow capable of calling a process instance running the plug-in package;

[0211] a seventh obtaining module, configured to obtain an orchestration operation of a user on the programming page;

[0212] a twelfth processing module, configured to, according to the orchestration operation, obtain a business flowchart of the task flow, and save business flow information corresponding to the business flowchart.

[0213] As shown in Figure 9 the embodiment of the present application provides an instance calling apparatus, which comprises:

[0214] The second obtaining module 901 is configured to obtain an instance invocation instruction initiated by a user, the instance invocation instruction being used to invoke a process instance of a plug-in package corresponding to a first model capability program; wherein the process instance of the plug-in package corresponding to the first model capability program is loaded and run in an assigned native Kubernetes container orchestration engine cluster, and metadata of the plug-in package is saved in a database.

[0215] The fourth processing module 902 is configured to invoke a callback interface of the process instance of the plug-in package in the assigned native Kubernetes container orchestration engine cluster according to the metadata in the database.

[0216] Optionally, the apparatus, wherein the plug-in package comprises a plug-in form file, a plug-in callback function file, and a running image of a plug-in callback function in the plug-in callback function file.

[0217] Optionally, the apparatus further comprises:

[0218] The thirteenth processing module is configured to provide a file editing interface of the first model capability program.

[0219] The eighth obtaining module is configured to obtain form editing information input by a user on the file editing interface.

[0220] The fourteenth processing module is configured to modify a plug-in form file in the plug-in package according to the form editing information.

[0221] Optionally, the apparatus, wherein the thirteenth processing module comprises:

[0222] The first obtaining unit is configured to obtain metadata in the database, and obtain a plug-in form file in the plug-in package.

[0223] The second obtaining unit is configured to obtain the file editing interface of the first model capability program according to form information of the plug-in form file.

[0224] Optionally, the apparatus further comprises:

[0225] The ninth obtaining module is configured to obtain a process instance initiated by a user in a business process diagram; wherein the business process diagram comprises a task flow capable of invoking the process instance of the plug-in package.

[0226] The second generating module is configured to generate a to-do task according to the process instance.

[0227] Optionally, the apparatus, wherein the fourth processing module 902 comprises:

[0228] A third obtaining unit is configured to obtain context information of the to-do task processing;

[0229] A first processing unit is configured to assemble an incoming parameter by analyzing the context information.

[0230] A second processing unit is configured to invoke a callback interface of a process instance running the plug-in package according to the incoming parameter in the assigned native Kubernetes container orchestration engine cluster.

[0231] It should be noted that the above device provided by the embodiments of the present application can realize all the method steps achieved by the above method embodiments and achieve the same technical effects, and thus the same parts and beneficial effects of the method embodiments will not be described in detail herein.

[0232] To achieve the above object, the embodiments of the present application provide an electronic device, comprising a transceiver, a processor, a memory, and a program or instructions stored on the memory and executable on the processor; wherein the processor executes the program or instructions to implement the program integration method or the instance calling method as described above.

[0233] To achieve the above object, the embodiments of the present application provide a readable storage medium having a program or instructions stored thereon, wherein the program or instructions are executed by a processor to implement the steps of the program integration method or the steps of the instance calling method as described above.

[0234] To achieve the above object, the embodiments of the present application provide a computer program product, comprising computer instructions, wherein the computer instructions are executed by a processor to implement the steps of the program integration method or the steps of the instance calling method as described above.

[0235] It should be further noted that the terminals described in the specification include but are not limited to smart phones, tablet computers, etc., and many functional components described are referred to as modules to more specifically emphasize the independence of their implementation.

[0236] In the embodiments of the present application, the modules can be implemented by software to be executed by various types of processors. For example, an identified executable code module can include one or more physical or logical blocks of computer instructions, which can be constructed as objects, processes or functions, for example. However, the executable code of the identified module does not need to be physically located together, but can include different instructions stored in different bits, which logically combine together to form a module and achieve the specified purpose of the module.

[0237] Indeed, a module of executable code can be a single instruction, or many instructions, and can even be distributed over several different code segments, among different programs, and across several memory devices. Similarly, operational data can be identified within the module and can be

[0238] When the modules are implemented in software, as discussed above, a person of ordinary skill in the art will recognize that the modules can be implemented in software and / or in hardware. The software can be stored on a computer-readable medium, such as a floppy disk, a hard disk, a CD ROM, a RAM, a ROM, a magnetic medium, an optical medium, or any other medium from which a computer can read. The hardware can include any or a combination of the following: a conventional central processing unit (CPU), microprocessor, microcomputer, microcontrol, programmable logic device, field programmable gate array (FPGA), application specific integrated circuit (ASIC), or any other conventional programmable silicon device. The modules can also be implemented in programmable hardware devices, such as PLDs and PALs, programmable logic arrays, and field programmable logic devices (FPLDs), or in any other conventional programmable hardware.

[0239] The foregoing exemplary embodiments are described in detail by reference to the drawings in which: many modifications and variations of the exemplary embodiments are possible and are within the scope of the disclosure, as those skilled in the art will readily understand. The exemplary embodiments were chosen and described in order to best explain the principles of the disclosure and its best mode of operation, thereby enabling others skilled in the art to best utilize the disclosure. The examples set forth herein are intended to be illustrative rather than exhaustive and were chosen to further the understanding of the disclosure. In the drawings, like reference numerals refer to like elements throughout the several views. The words "a" or "an," as used in the context of this document, generally are taken to mean "one or more." Additionally, the words "couple" or "couples" or "coupled" and "connect" or "connects" or "connected" are used broadly and encompass both direct and indirect coupling or connection, and are intended to encompass various forms of coupling or connection, including through air, through ground, and direct physical or electrical contact, including through wired or wireless media. The specific configurations illustrated and discussed are intended to exemplify embodiments of the application and that other alternative configurations are possible. Those of ordinary skill in the art will recognize many modifications and variations of the examples described herein that are within the scope of the present disclosure. It is also possible that a person of ordinary skill in the art will desire to import elements of the exemplary embodiments into other contexts or applications. All such modifications and variations are intended to be within the scope of the disclosure. Other aims, objectives or advantages of the disclosure will not necessarily be discussed below, and will become apparent to the skilled person upon reading the description.

[0240] The above description is the preferred embodiment of the present application. It is to be understood that the above description is intended to be illustrative and not restrictive. Many apparent modifications and changes can come to mind to one skilled in the art having the benefit of the teachings presented herein, and it is intended that the application embrace all such modifications and changes and, accordingly, the application is not to be limited based on the detailed description set forth herein.

Claims

1. A program integration method, characterized in that: include: Obtaining a plug-in definition file package of a first model capability program; generating a plug-in package for running the first model capability program according to the plug-in definition file package, calling a process for running the plug-in package, and saving metadata of the plug-in package in a database; Allocate the corresponding native Kubernetes container orchestration engine cluster according to the plug-in package; Load and run the process instance of the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

2. The method according to claim 1, characterized in that The plug-in definition file package includes a plug-in form definition file and a plug-in callback function definition file; The plug-in package includes a plug-in form file obtained through the plug-in form definition file, a plug-in callback function file obtained through the plug-in callback function definition file, and a running image of the plug-in callback function in the plug-in callback function file; The metadata includes data extracted from the plug-in form file and the plug-in callback function respectively.

3. The method according to claim 1 or 2, characterized in that After obtaining the plug-in definition file package of the first model capability program, the method further includes: Verifying the plug-in form definition file in the plug-in definition file package to obtain a first verification result; If the first verification result is passed, the plug-in callback function is precompiled according to the plug-in callback function definition file in the plug-in definition file package; wherein the precompiled plug-in callback function is used to generate the plug-in package.

4. The method according to claim 1 or 2, characterized in that Before calling the process to be run by the plug-in package, the method further includes: Loading a sandbox environment process according to the programming language type of the plug-in callback function file; wherein the plug-in callback function file is obtained through the plug-in callback function definition file in the plug-in definition file package; The plug-in callback function in the plug-in callback function file is placed in the sandbox environment process for simulation verification. If the verification passes, a running image of the plug-in callback function is generated; wherein the running image of the plug-in callback function is used to generate the plug-in package.

5. The method according to claim 1, wherein After loading and running the process instance of the plug-in package, the method further includes: Obtain monitoring indicator data reported by the process instance during runtime; Analyzing the monitoring indicator data; When the monitoring indicator data is higher than a preset threshold, the process instance is expanded.

6. The method according to claim 1, characterized in that Before loading and running the process instance of the plug-in package in the allocated native Kubernetes container orchestration engine cluster, the method further includes: Get the configuration file of the allocated native Kubernetes container orchestration engine cluster; Initialize access files for the allocated native Kubernetes container orchestration engine cluster according to the configuration file.

7. The method according to claim 1, characterized in that After loading and running the process instance of the plug-in package in the allocated native Kubernetes container orchestration engine cluster, the method further includes: Obtaining the metrics collection task initialization instructions for the process instance and information about the assigned native Kubernetes container orchestration engine cluster; According to the indicator collection task initialization instruction and the information of the allocated native Kubernetes container orchestration engine cluster, the indicator collection exporter indicator exporter is automatically deployed in the allocated native Kubernetes container orchestration engine cluster.

8. The method according to claim 1, characterized in that The method further comprises: Displaying a programming page for a task flow capable of invoking a process instance that runs the plug-in package; Obtaining the user's programming operation on the programming page; According to the arrangement operation, a business process diagram of the task process is obtained, and business process information corresponding to the business process diagram is saved.

9. An instance calling method, characterized in that: include: Obtaining an instance call instruction initiated by a user, wherein the instance call instruction is used to call a process instance running a plug-in package corresponding to the first model capability program; wherein the process instance running the plug-in package corresponding to the first model capability program is loaded and run in the allocated native Kubernetes container orchestration engine cluster, and metadata of the plug-in package is stored in a database; According to the metadata in the database, a callback interface of the process instance running the plug-in package is called in the allocated native Kubernetes container orchestration engine cluster.

10. The method according to claim 9, characterized in that The plug-in package includes a plug-in form file, a plug-in callback function file, and a running image of the plug-in callback function in the plug-in callback function file.

11. The method according to claim 9 or 10, characterized in that Before obtaining the instance call instruction initiated by the user, the method further includes: Providing a file editing interface for the first model capability program; Obtaining form editing information entered by the user on the file editing interface; Modify the plug-in form file in the plug-in package according to the form editing information.

12. The method according to claim 11, characterized in that Providing a file editing interface for the first model capability program, including: Obtain metadata from the database and obtain a plug-in form file from the plug-in package; The file editing interface of the first model capability program is obtained according to the form information of the plug-in form file.

13. The method according to claim 9, characterized in that Before obtaining the instance call instruction initiated by the user, the method further includes: Obtaining a process instance initiated by a user in a business process diagram; wherein the business process diagram includes a task flow capable of invoking a process instance that runs the plug-in package; Generate to-do tasks based on the process instance.

14. The method according to claim 13, characterized in that Calling a callback interface of a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster includes: Obtaining context information for processing the to-do task; Assembling incoming parameters by parsing the context information; In the allocated native Kubernetes container orchestration engine cluster, the callback interface of the process instance running the plug-in package is called according to the input parameters.

15. A program integration system, characterized in that: include: A database, configured to obtain a plug-in definition file package of a first model capability program; generate a plug-in package for running the first model capability program based on the plug-in definition file package, and call a process for running the plug-in package; Saving metadata of the plug-in package; A cluster management module is used to allocate the corresponding native Kubernetes container orchestration engine cluster according to the plug-in package; A plug-in execution module, configured to load and run a process instance of the plug-in package in the allocated native Kubernetes container orchestration engine cluster; A plug-in process execution module is used to obtain an instance call instruction initiated by a user, wherein the instance call instruction is used to call a process instance of the plug-in package corresponding to the first model capability program; The plug-in execution module is further configured to call a callback interface of a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster according to the metadata in the database.

16. The system according to claim 15, wherein: The database is also used Verify the plug-in form definition file in the plug-in definition file package to obtain a first verification result; if the first verification result is passed, precompile the plug-in callback function according to the plug-in callback function definition file in the plug-in definition file package; wherein the precompiled plug-in callback function is used to generate the plug-in package.

17. The system according to claim 15, wherein: The database is also used Loading a sandbox environment process according to the programming language type of the plug-in callback function file; wherein the plug-in callback function file is obtained through the plug-in callback function definition file in the plug-in definition file package; placing the plug-in callback function in the plug-in callback function file in the sandbox environment process for simulation verification, and generating a running image of the plug-in callback function if the verification passes; wherein the running image of the plug-in callback function is used to generate the plug-in package.

18. The system according to claim 15, wherein: The system also includes a plug-in observability engine for obtaining monitoring indicator data reported by the process instance during runtime; analyzing the monitoring indicator data; and expanding the capacity of the process instance when the monitoring indicator data is higher than a preset threshold.

19. The system according to claim 18, wherein: The plug-in observability engine is also used to obtain the indicator collection task initialization instructions of the process instance and the information of the assigned native Kubernetes container orchestration engine cluster; according to the indicator collection task initialization instructions and the information of the assigned native Kubernetes container orchestration engine cluster, the indicator collection exporter indicator exporter is automatically deployed in the assigned native Kubernetes container orchestration engine cluster.

20. The system according to claim 15, wherein: The plug-in execution module is further used to obtain a configuration file of the allocated native Kubernetes container orchestration engine cluster; and initialize an access file of the allocated native Kubernetes container orchestration engine cluster according to the configuration file.

21. The system according to claim 15, wherein: The plug-in process execution module is also used to display a programming page of the task process that can call the process instance that runs the plug-in package; obtain the user's orchestration operations on the programming page; obtain the business process diagram of the task process based on the orchestration operations, and save the business process information corresponding to the business process diagram.

22. The system according to claim 15, wherein: The system further includes a plug-in form module for providing a file editing interface of the first model capability program; obtaining form editing information input by a user on the file editing interface; Modify the plug-in form file in the plug-in package according to the form editing information.

23. The system according to claim 22, wherein: The plug-in form module is further configured to obtain metadata from the database and a plug-in form file from the plug-in package; and obtain the file editing interface of the first model capability program according to form information of the plug-in form file.

24. The system according to claim 15, wherein: The plug-in process execution module is also used to obtain a process instance initiated by a user in a business process diagram; wherein the business process diagram includes a task process that can call a process instance that runs the plug-in package; and generate to-do tasks based on the process instance.

25. The system according to claim 24, wherein: The plug-in execution module is also used to obtain context information for processing the pending tasks; assemble incoming parameters by parsing the context information; and call the callback interface of the process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster according to the incoming parameters.

26. A program integration device, characterized in that: include: A first acquisition module, configured to acquire a plug-in definition file package of a first model capability program; a first processing module, configured to generate a plug-in package for running the first model capability program according to the plug-in definition file package, call a process running the plug-in package, and save metadata of the plug-in package in a database; The second processing module is used to allocate a corresponding native Kubernetes container orchestration engine cluster according to the plug-in package; The third processing module is used to load and run the process instance of the plug-in package in the allocated native Kubernetes container orchestration engine cluster.

27. An instance retrieval device, characterized in that: include: A second acquisition module is configured to acquire an instance call instruction initiated by a user, wherein the instance call instruction is used to call a process instance of a plug-in package corresponding to the first model capability program; wherein the process instance of the plug-in package corresponding to the first model capability program is loaded and run in the allocated native Kubernetes container orchestration engine cluster, and metadata of the plug-in package is stored in a database; The fourth processing module is configured to call a callback interface of a process instance running the plug-in package in the allocated native Kubernetes container orchestration engine cluster according to the metadata in the database.

28. An electronic device comprising: A transceiver, a processor, a memory, and a program or instruction stored in the memory and executable on the processor; wherein when the processor executes the program or instruction, the program integration method according to any one of claims 1 to 8 is implemented, or the instance retrieval method according to any one of claims 9 to 14 is implemented.

29. A readable storage medium having a program or instruction stored thereon, characterized in that: When the program or instruction is executed by a processor, the steps of the program integration method according to any one of claims 1 to 8 are implemented, or the steps of the instance calling method according to any one of claims 9 to 14 are implemented.

30. A computer program product, characterized in that The method comprises computer instructions, which, when executed by a processor, implement the steps of the program integration method according to any one of claims 1 to 8, or the steps of the instance calling method according to any one of claims 9 to 14.

Images