Low-code platform application deployment method and device and medium

Abstract

The invention discloses a low-code platform application deployment method and device and a medium, and the method comprises the steps: converting a low-code platform application into a digital model, then constructing an HTTP interface through a MultipartForm protocol to receive a binary file of a component when the digital model runs, and storing metadata of the binary file into a system database, and generating an RPM spec file of the digital model according to a preset text template and the metadata of the binary file, and calling an rpm-build instruction for the RPM spec file of the digital model to construct an RPM package of the digital model. By constructing the application package capable of being installed repeatedly, deployment among different tenants is not influenced mutually, and unified management and personalized configuration are facilitated; the number of application examples is dynamically managed according to service pressure, automatic scheduling and load balancing of service resources are achieved, and the requirement that all application versions adapt to rapid iteration is achieved through a standardized model version management mechanism.

Description

Technical Field

[0001] This application relates to the field of computer software, and in particular to a low-code platform application deployment method, device and medium. Background Art

[0002] In scenarios where low-code platforms provide independent application services to multiple customers in a SaaS model, existing technologies lack an integrated approach for generating reusable application packages based on models and runtime microservices. This results in deployments between different tenants interfering with each other, making independent isolation difficult. Unified management requires frequent manual configuration coordination, and personalized configuration is complicated due to the lack of standardized packaging. This leads to low deployment efficiency. Furthermore, the deployment process relied on manual intervention, lacking standardized models and automated processes. This resulted in a low level of automation from design to launch and a long delivery cycle. The inability to quickly generate reusable application packages necessitated rebuilding for each deployment, making it difficult to accommodate rapid iterations. This further exacerbated deployment inefficiencies and severely impacted service responsiveness and management effectiveness in multi-tenant scenarios. Summary of the Invention

[0003] The embodiments of the present application provide a low-code platform application deployment method, device and medium for solving the problem of low deployment efficiency in the prior art.

[0004] The embodiments of this application adopt the following technical solutions: On the one hand, an embodiment of the present application provides a low-code platform application deployment method, which includes: converting the low-code platform application into a digital model; the digital model includes a component structure, form relationship and process description expressed in JSON format; constructing an HTTP interface through the MultipartForm protocol to receive the binary file of the digital model runtime component, and storing the metadata of the binary file to the system database; the components include a server, a workflow service, a front-end service, and an application launcher; generating an RPM spec file of the digital model based on a preset text template and the metadata of the binary file; calling the rpm-build command on the RPM spec file to build the RPM package of the digital model.

[0005] In one example, after converting the low-code platform application into a digital model, the method also includes: establishing a connection between the digital model and the object storage service Minio through the Minio Client; uploading the model version of the digital model to the remote end of the object storage service Minio for storage, and generating a version record including a version number and timestamp in the system database.

[0006] In one example, an RPMspec file of a digital model is generated based on a preset text template and binary file metadata, specifically including: generating structure data for template rendering based on a pre-defined text template file and binary file metadata obtained from a system database; the text template file includes basic spec information, build dependencies, and custom macro commands; filling the structure data into the text template file through a text template engine to obtain an initial spec file; determining whether the initial spec file includes a workflow service through a conditional statement to generate corresponding directory creation and file installation instructions; and installing the initial spec file into the created corresponding directory according to the file installation instructions to obtain an RPM spec file.

[0007] In one example, after uploading the model version of the digital model to the remote end of the object storage service Minio for storage, the method further includes: comparing different versions of the digital model through a Diff algorithm, identifying change points in component structure, form relationship and process description, and generating a visual change report; performing version conflict detection on the visual change report through an optimistic locking mechanism, and generating measures to resolve version conflicts; sending the visual change report and measures to resolve version conflicts to the client for display.

[0008] In one example, after calling the rpm-build instruction on the RPM spec file to build the RPM package of the digital model, the method further includes: returning the built RPM package to the client through the HTTP response of the Gin framework FileAttachment interface.

[0009] In one example, after returning the constructed RPM package to the client through the HTTP response of the Gin framework FileAttachment interface, the method further includes: defining the database, Redis, Minio and user center addresses in the configuration file of the RPM package; reading the configuration file through the application launcher to obtain the configuration required for deploying the RPM package to deploy the rpm package.

[0010] In one example, after reading the configuration file through the application launcher to obtain the configuration required for deploying the RPM package and deploying the rpm package, the method also includes: monitoring the service pressure of the deployment platform through a heartbeat mechanism; when the service pressure is greater than a preset pressure threshold, adjusting the AppReplicas parameter value to increase the number of running application copies; and adjusting the WorkflowReplicas parameter value to increase the number of workflow copies.

[0011] In one example, after calling the rpm-build instruction on the RPM spec file to build the RPM package of the digital model, the method further includes: obtaining the rpm-build command execution log, searching for "ERROR" and "FATAL" keywords, and if so, determining that an error occurred in building the RPM package; checking the command return status code, and if the return status code is a non-zero value, determining that an error occurred in building the RPM package; and viewing the installation script through the script view command, and if a syntax error or path abnormality occurs, determining that an error occurred in building the RPM package.

[0012] On the other hand, an embodiment of the present application provides a low-code platform application deployment device, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute any one of the above-mentioned low-code platform application deployment methods.

[0013] On the other hand, an embodiment of the present application provides a low-code platform application deployment method comprising a non-volatile computer storage medium storing computer-executable instructions capable of executing any of the above-mentioned items.

[0014] At least one of the above technical solutions adopted in the embodiments of the present application can achieve the following beneficial effects: This application builds a re-installable application package to achieve independent deployment between different tenants, facilitate unified management and personalized configuration, and improve the efficiency of low-code platform application deployment; dynamically manage the number of application instances according to service pressure, and can elastically expand or reduce the number of application copies at any time to cope with different levels of user services, and realize automatic scheduling and load balancing of service resources; it also provides a standardized model version management mechanism to make changes to each application version during the development and deployment process traceable and rollbackable, to meet the needs of rapid iteration. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] In order to more clearly illustrate the technical solution of the present application, some embodiments of the present application will be described in detail below with reference to the accompanying drawings, in which: Figure 1 A flowchart of a low-code platform application deployment method provided in an embodiment of the present application; Figure 2 A digital model construction diagram of a low-code platform application deployment method provided in an embodiment of the present application; Figure 3 A flowchart of version storage and management of a low-code platform application deployment method provided in an embodiment of the present application; Figure 4A flowchart of the RPM package construction and deployment of a low-code platform application deployment method provided in an embodiment of the present application; Figure 5 A structural diagram of a low-code platform application deployment device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0016] To make the objectives, technical solutions, and advantages of this application more clear, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the embodiments described are only part of the embodiments of this application, not all of them. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0017] Some embodiments of the present application are described in detail below with reference to the accompanying drawings.

[0018] Figure 1 This is a flowchart of a low-code platform application deployment method provided in an embodiment of the present application. This method can be applied to different business areas. Certain input parameters or intermediate results in this process allow for manual intervention and adjustment to help improve accuracy.

[0019] The analysis method involved in the embodiments of the present application can be implemented by a terminal device or a server, and the present application does not impose any special restrictions on this. For ease of understanding and description, the following embodiments are described in detail using a controller as an example.

[0020] Based on this, Figure 1 The process in may include the following steps: S101: Convert the low-code platform application into a digital model; the digital model includes component structure, form relationship and process description expressed in JSON format.

[0021] It should be noted that in some embodiments of the present application, it is first necessary to abstract the model of the existing low-code platform application and digitally express various types of forms, web pages, processes, etc. under the application.

[0022] Specifically, it records the basic properties of the components in the application, such as type, location, icon, style, function, script, events and event handling functions, in the form of abstract JSON. It also includes the relationship between components, such as table layout or grid layout, to perform component nesting association, and record the nesting relationship and position formed by layout components and ordinary components.

[0023] Regarding form relationships, when dealing with complex real-world business problems, form nesting is often required. A form may contain multiple subforms. For example, a return form often requires filling in information such as shipping status, logistics information, receipt information, damage status, and compensation plan. Form relationships refer to the nesting of forms and the names, locations, and attributes of subforms. The process is a feedback on the actual processing process of time. The process design of the low-code platform is based on the BPMN2.0 model, and its process definition itself has multiple data XML and JSON expressions.

[0024] Furthermore, after the digital model is generated, a connection is established between the digital model and the object storage service Minio through the Minio Client, and then the model version of the digital model is uploaded to the remote end of the object storage service Minio for storage, and a version record including the version number and timestamp is generated in the system database; so that the designer can track the application design change process, and can also repeatedly download the application version products through the Minio Client.

[0025] Furthermore, after uploading the model version of the digital model to the remote object storage service Minio for storage, the different versions of the digital model are compared through the Diff algorithm to identify the change points of component structure, form relationship and process description, and generate a visual change report; then, the visual change report is detected for version conflicts through the optimistic locking mechanism, and measures to resolve version conflicts are generated; finally, the visual change report and measures to resolve version conflicts are sent to the client for display.

[0026] S102: Constructing an HTTP interface through the MultipartForm protocol to receive the binary file of the digital model runtime component and storing the metadata of the binary file in the system database; the component includes a server, a workflow service, a front-end service, and an application launcher.

[0027] It should be noted that in some embodiments of this application, before building a reinstallable application, it is necessary to provide HTTP services based on the Golang language and the web service Gin framework. This application uses the MultipartForm protocol to build an HTTP interface, through which users upload runtime servers, workflows, front-end services, and application launchers, and persist basic file information such as file name, version, MD5 code, etc. to the database layer (system database).

[0028] It should also be noted that the server involved here mainly has the following functions: first, it connects to different user centers through the HTTP interface; second, it parses the application model version and generates a database table to prepare for form data storage; third, it acts as a registration center by integrating the microservice registration and discovery middleware Eureka. As a service registration center, the application runs as a Eureka Server to receive registrations from other microservices, check the status of related microservices through the heartbeat mechanism, and dynamically adjust the microservice load balancing through the spring cloud load balance component.

[0029] The front-end service is the visual presentation of the form. It converts JSON data into front-end components through the renderer and presents it to the user through the canvas.

[0030] The application launcher is a binary program that can be executed on CentOS. Its main functions are to detect available ports, generate application startup scripts, create system startup items, create HTTP Web service configuration files, proxy application runtime ports, and act as a front-end for reverse proxy runtime.

[0031] S103: Generate an RPMspec file of the digital model according to a preset text template and metadata of the binary file.

[0032] Before building the RPM spec file, it should be noted that the RPM spec file is the core of building the RPM package. Its main contents include the target RPM package Version, Release, Summary, License, URL, Source, BuildRequires, and BuildArach basic information of the target RPM package.

[0033] It should be noted that in some embodiments of the present application, structure data for template rendering is generated based on a predefined text template file (golang text template text / template) and binary file metadata obtained from a system database; the text template file includes spec basic information, build dependencies and custom macro commands; the structure data is then filled into the text template file through a text template engine to obtain an initial spec file; a conditional statement (a combination of {{ if}} and {{ end}}) is used to determine whether the initial spec file includes a workflow service to generate corresponding directory creation and file installation instructions; finally, according to the file installation instructions, the initial spec file is installed into the created corresponding directory to obtain an RPM spec file.

[0034] S104: calling the rpm-build instruction on the RPM spec file to build the RPM package of the digital model.

[0035] It should be noted that in order to prevent the Linux packaging tool rpm-build from compressing the JAR package during the build process, this article defines the macro command %define jar_repack 0 and the multi-core parallel build macro command %define smp mflags -j$(nproc).

[0036] In some embodiments of the present application, after the RPM spec file is determined, the rpm-build instruction is called on the RPM spec file to build the RPM package of the digital model.

[0037] It should be noted that the rpm-build command must be pre-installed on the deployment host. If not, you can install rpm-build and its dependencies using the system package manager yum install. Pass the "rpmbuild" parameter to the exec command. The system command is executed through the CombinedOutput interface, and the output is written to the log.

[0038] Furthermore, after the RPM package of the digital model is built, the rpm-build command execution log is obtained to check whether the "ERROR" and "FATAL" keywords exist. If so, it is determined that the RPM package building error occurred; or the command return status code is checked. If the return status code is non-zero, it is determined that the RPM package building error occurred; or the installation script is viewed through the script view command. If there is a syntax error or path abnormality, it is determined that the RPM package building error occurred.

[0039] Furthermore, when it is determined that the constructed RPM package is correct, the constructed RPM package is returned to the client through the HTTP response of the Gin framework FileAttachment interface, and then the database, Redis, Minio and user center addresses are defined in the configuration file of the RPM package; and the configuration file is read through the application launcher to obtain the configuration required for deploying the RPM package to deploy the rpm package.

[0040] Furthermore, after the deployment is completed, the service pressure of the deployment platform is monitored through the heartbeat mechanism; when the service pressure is greater than the preset pressure threshold, the AppReplicas parameter value is adjusted to increase the number of application running copies; and the WorkflowReplicas parameter value is adjusted to increase the number of workflow copies.

[0041] Specifically, AppReplicas=n specifies the number of replicas, where n represents the number of running application replicas. If you want to enable the workflow service at the same time, you need to specify the judgment condition as true when building the RPM package and specify the number of replicas in the form of WorkflowReplicas=n, where n represents the number of workflow replicas.

[0042] It should be noted that although the embodiments of this application are based on Figure 1 Steps S101 to S104 are described in sequence, but this does not mean that steps S101 to S104 must be performed in a strict order. Figure 1 The order shown in FIG1 is to introduce and explain step S101 to step S104 in order to facilitate those skilled in the art to understand the technical solution of the embodiment of the present application. In other words, in the embodiment of the present application, the order between step S101 to step S104 can be appropriately adjusted according to actual needs.

[0043] pass Figure 1 This application builds a re-installable application package to achieve deployment between different tenants without affecting each other, facilitates unified management and personalized configuration, and improves the efficiency of low-code platform application deployment; dynamically manages the number of application instances according to service pressure, and can elastically expand or reduce the number of application copies at any time to cope with different levels of user services, and realize automatic scheduling and load balancing of service resources; it also provides a standardized model version management mechanism to make changes of each application version in the development and deployment process traceable and rollbackable, to meet the needs of rapid iteration.

[0044] Figure 2 A digital model construction diagram of a low-code platform application deployment method provided in an embodiment of the present application; exist Figure 2 In the figure, the construction of digital model is demonstrated, which includes component abstract modeling, component layout modeling, form modeling, form relationship modeling, and process section modeling.

[0045] Figure 3 A flowchart of version storage and management of a low-code platform application deployment method provided in an embodiment of the present application; exist Figure 3 In the figure, the version storage and management method is demonstrated. When the requirements change, the application is edited, and then the application model is released based on the edited application. Finally, the model version is stored (the model version of the digital model is uploaded to the remote object storage service Minio for storage, and a version record including the version number and timestamp is generated in the system database).

[0046] Figure 4A flowchart of the RPM package construction and deployment of a low-code platform application deployment method provided in an embodiment of the present application; exist Figure 4 The figure shows the RPM package building and deployment process. Specifically, the SPEC file is first built, then the RPM package is built based on the SPEC file, and then the RPM package is returned to the user through the HTTP interface. Finally, the RPM package is deployed.

[0047] Figure 5 A schematic diagram of the structure of a low-code platform application deployment device provided in an embodiment of the present application includes: at least one processor; and, a memory communicatively connected to at least one processor; wherein, The memory stores instructions that can be executed by at least one processor, and the instructions are executed by at least one processor to enable at least one processor to execute any one of the above-mentioned low-code platform application deployment methods.

[0048] Some embodiments of the present application provide a low-code platform application deployment non-volatile computer storage medium, which stores computer-executable instructions, and the computer-executable instructions can execute any of the above-mentioned low-code platform application deployment methods.

[0049] The various embodiments in this application are described in a progressive manner. Similar portions between the various embodiments can be referred to in conjunction with each other. Each embodiment focuses on the differences between the other embodiments. In particular, the device and medium embodiments are generally similar to the method embodiments, so their descriptions are relatively simple. For relevant portions, refer to the descriptions of the method embodiments.

[0050] The devices and media provided in the embodiments of the present application correspond one-to-one to the methods. Therefore, the devices and media also have similar beneficial technical effects to their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0051] Those skilled in the art will appreciate that embodiments of the present invention may be provided as methods, systems, or computer program products. Thus, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0052] The present invention is described with reference to flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowcharts and / or block diagrams, as well as combinations of processes and / or blocks in the flowcharts and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowcharts and / or block diagrams. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0053] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0054] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operational steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing the instructions executed on the computer or other programmable device for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0055] In a typical configuration, a computing device includes one or more processors (CPUs), input / output interfaces, network interfaces, and memory.

[0056] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM), and non-volatile memory such as read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0057] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can be implemented using any method or technology to store information. Information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase-change RAM (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include transitory computer-readable media such as modulated data signals and carrier waves.

[0058] It should also be noted that the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, commodity, or apparatus that includes a series of elements includes not only those elements but also other elements not explicitly listed, or includes elements inherent to such process, method, commodity, or apparatus. In the absence of further limitations, an element defined by the phrase "comprises a ..." does not exclude the presence of other identical elements in the process, method, commodity, or apparatus that includes the element.

[0059] The above are merely embodiments of the present application and are not intended to limit the present application. For those skilled in the art, the present application may have various modifications and variations. Any modifications, equivalent replacements, improvements, etc. made within the technical principles of the present application should fall within the scope of protection of the present application.

Claims

1. A low-code platform application deployment method, characterized in that: The method comprises: Converting a low-code platform application into a digital model; the digital model includes component structure, form relationships, and process descriptions expressed in JSON format; Constructing an HTTP interface using the MultipartForm protocol to receive the binary file of the digital model runtime component and storing the metadata of the binary file in a system database; the component includes a server, a workflow service, a front-end service, and an application launcher; Generate an RPM spec file of the digital model according to a preset text template and metadata of the binary file; The rpm-build instruction is called on the RPM spec file to build the RPM package of the digital model.

2. The method according to claim 1, characterized in that After converting the low-code platform application into a digital model, the method further includes: Establish a connection between the digital model and the object storage service Minio through Minio Client; The model version of the digital model is uploaded to the remote end of the object storage service Minio for storage, and a version record including a version number and a timestamp is generated in the system database.

3. The method according to claim 1, characterized in that Generating the RPM spec file of the digital model based on the preset text template and the metadata of the binary file specifically includes: Generate template rendering structure data based on a predefined text template file and binary file metadata obtained from the system database; the text template file includes spec basic information, build dependencies and custom macro commands; Filling the structure data into the text template file through a text template engine to obtain an initial spec file; Determine whether the initial spec file includes workflow services through conditional statements to generate corresponding directory creation and file installation instructions; According to the file installation instruction, the initial spec file is installed into the created corresponding directory to obtain the RPMspec file.

4. The method according to claim 2, characterized in that After uploading the model version of the digital model to the remote end of the object storage service Minio for storage, the method further includes: Compare different versions of digital models using the Diff algorithm to identify changes in component structure, form relationships, and process descriptions, and generate visual change reports. Performing version conflict detection on the visual change report through an optimistic locking mechanism and generating measures to resolve the version conflict; The visual change report and the measures for resolving the version conflict are sent to the client for display.

5. The method according to claim 1, wherein After calling the rpm-build instruction on the RPM spec file to build the RPM package of the digital model, the method further includes: The built RPM package is returned to the client through the HTTP response of the Gin framework FileAttachment interface.

6. The method according to claim 5, characterized in that After returning the constructed RPM package to the client through the HTTP response of the Gin framework FileAttachment interface, the method further includes: Define the database, Redis, Minio, and user center addresses in the RPM package configuration file; The application launcher reads the configuration file to obtain the configuration required for deploying the RPM package to deploy the RPM package.

7. The method according to claim 6, characterized in that After the configuration file is read by the application launcher to obtain the configuration required for deploying the RPM package to deploy the rpm package, the method further includes: Monitor the service pressure of the deployment platform through the heartbeat mechanism; When the service pressure is greater than the preset pressure threshold, the number of application running replicas can be increased by adjusting the AppReplicas parameter value; the number of workflow replicas can be increased by adjusting the WorkflowReplicas parameter value.

8. The method according to claim 1, characterized in that After calling the rpm-build instruction on the RPM spec file to build the RPM package of the digital model, the method further includes: Get the rpm-build command execution log and check whether the "ERROR" and "FATAL" keywords exist. If they exist, it is determined that the RPM package building error; Check the command return status code. If the return status code is non-zero, it is determined that the RPM package building failed. Use the script view command to view the installation script. If there are syntax errors or abnormal paths, it is determined that the RPM package building is wrong.

9. A low-code platform application deployment device, characterized in that: include: at least one processor; as well as, a memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute a low-code platform application deployment method as described in any one of claims 1-8 above.

10. A low-code platform application deployment storage medium storing computer-executable instructions, characterized in that: The computer-executable instructions are capable of executing a low-code platform application deployment method as described in any one of claims 1-8 above.

Images