Code debugging method, system and equipment for low-code platform and medium

Abstract

The invention provides a code debugging method, system and device for a low-code platform and a medium, and the debugging method comprises the steps: obtaining a plurality of application DSLs generated by the low-code platform, and respectively analyzing each application DSL to obtain a corresponding function code; performing resource pre-allocation on each debugging container according to the code language type of each function code and a pre-configured resource scheduling strategy to obtain a runtime debugging container; and scheduling and acquiring the corresponding run-time debugging containers for the function codes of different code language types based on a resource scheduling service integrated on the low-code platform, running the function codes through the run-time debugging containers to generate corresponding running results, and displaying the running results by the low-code platform. The operation debugging effect preview of the online design is realized, the user experience is better improved, and the low-code design and verification efficiency is improved.

Description

Technical Field

[0001] The present invention relates to the field of computer software application technology, and in particular to a code debugging method, system, device and medium for a low-code platform. Background Art

[0002] At present, when developers are running codes, they often encounter problems such as complex development environment configuration, lengthy code writing, old computers, and low software and hardware configuration. In order to achieve a more simplified development process, a low-code platform system has been proposed.

[0003] The research and development design of existing low-code platform systems usually focuses on implementing code programming through visual drag, drop and drop operations; however, the existing low-code platform systems lack a debugging method for the designed pages, processes, back-end interfaces, etc., and lack the ability to preview the overall effects and perform local debugging for scenarios such as complex page linkage, front-end and back-end logic debugging, and complex process debugging. It is impossible to improve development speed and save time costs. Summary of the invention

[0004] The embodiment of the present invention provides a code debugging method, system, device and medium of a low-code platform to solve the problems existing in the related technologies. The technical solution is as follows:

[0005] In a first aspect, an embodiment of the present invention provides a code debugging method for a low-code platform, including:

[0006] Get several application DSLs generated by the low-code platform, parse each application DSL separately, and get the corresponding function code;

[0007] Pre-allocate resources for each debugging container according to the code language type of the function code and the pre-configured resource scheduling policy to obtain a runtime debugging container;

[0008] Based on the resource scheduling service integrated in the low-code platform, the function code scheduling of different code language types obtains the corresponding runtime debugging container, runs the function code according to the runtime debugging container, generates the corresponding running results, and the running results are displayed by the low-code platform.

[0009] In some implementations, the application DSL includes a page DSL, a model DSL, and a microflow DSL; the function code includes a page function code, a model function code, and a microflow function code.

[0010] In some implementations, the resource scheduling strategy is one of the following: same-application distributed scheduling, same-application centralized scheduling, hybrid balanced scheduling, or custom scheduling.

[0011] In some embodiments, it further comprises:

[0012] Function codes of different code language types are synchronously submitted to the code warehouse of the corresponding code language type for storage; the code warehouse includes the front-end code warehouse and the back-end code warehouse.

[0013] In some embodiments, it further comprises:

[0014] The resources of the runtime debugging container that has finished running are recycled according to the pre-configured resource recycling strategy, and the debugging container is returned to the container resource pool after the resources are emptied.

[0015] In some implementations, the resource recovery strategy is one of timed recovery, least-used recovery, least-flow recovery, or a custom recovery strategy.

[0016] In some embodiments, it further comprises:

[0017] Receive query instructions, and retrieve the log information of the runtime debugging container according to the query instructions for display. The log information includes running logs, operation logs, and error logs.

[0018] In a second aspect, an embodiment of the present invention provides a code debugging system that executes the code debugging method of the low-code platform as described above.

[0019] In a third aspect, an embodiment of the present invention provides an electronic device, the device comprising: a memory and a processor. The memory and the processor communicate with each other through an internal connection path, the memory is used to store instructions, the processor is used to execute the instructions stored in the memory, and when the processor executes the instructions stored in the memory, the processor executes the method in any one of the above-mentioned embodiments.

[0020] In a fourth aspect, an embodiment of the present invention provides a computer-readable storage medium, which stores a computer program. When the computer program runs on a computer, the method in any one of the above-mentioned embodiments is executed.

[0021] The advantages or beneficial effects of the above technical solution include at least:

[0022] The low-code platform of the present invention builds a debugging container resource scheduling service, flexibly configures the resource scheduling strategy required by the debugging environment to allocate the corresponding debugging container's running code resources, and connects to the low-code platform debugging display panel according to the observability capability indicators and log function endpoints exposed by the debugging container scheduling service, to achieve online design running debugging effect preview, better improve user experience, and improve the efficiency of low-code design and verification.

[0023] The above summary is for illustrative purposes only and is not intended to be limiting in any way. In addition to the illustrative aspects, embodiments and features described above, further aspects, embodiments and features of the present invention will be readily apparent by reference to the accompanying drawings and the following detailed description. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] In the accompanying drawings, unless otherwise specified, the same reference numerals throughout the multiple drawings represent the same or similar parts or elements. These drawings are not necessarily drawn to scale. It should be understood that these drawings only depict some embodiments disclosed in the present invention and should not be regarded as limiting the scope of the present invention.

[0025] Figure 1 It is a flowchart of the code debugging method of the low-code platform of the present invention;

[0026] Figure 2 A schematic diagram of the present invention for debugging container running resources and interacting with users;

[0027] Figure 3 The structure block diagram of an electronic device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0028] In the following, only some exemplary embodiments are briefly described. As those skilled in the art will appreciate, the described embodiments may be modified in various ways without departing from the spirit or scope of the present invention. Therefore, the drawings and descriptions are considered to be exemplary and non-restrictive in nature.

[0029] Embodiment 1

[0030] A code debugging method for a low-code platform can achieve the purpose of previewing the running debugging effect of online design, better improve the user experience, and improve the efficiency of low-code design and verification.

[0031] This embodiment integrates a resource scheduling service for debugging containers on the basis of the low-code platform, which is equivalent to building a debugging container resource scheduling service based on the existing cloud platform. It takes the resource scheduling service as the core function and is mainly responsible for overall cloud platform resource monitoring, cloud platform resource scheduling, multi-language runtime container resource management, multi-language runtime preheating resource management, and container scheduling capability API.

[0032] The resource scheduling service of the debugging container is executed according to the resource scheduling strategy. It is necessary to configure the resource scheduling strategy required by the debugging environment in advance according to actual needs, and pre-allocate resources for the debugging container according to the resource scheduling strategy. Resource pre-allocation means that the resource scheduling service of the debugging container obtains and allocates the messages pushed by the application created by the low-code platform from the scheduling container resource pool to the corresponding debugging container before the user uses the debugging container function, and schedules the debugging container to the corresponding application.

[0033] The supported scheduling strategies include decentralized scheduling of the same application, centralized scheduling of the same application, mixed balanced scheduling, and other custom scheduling rules. The specific meanings of each scheduling strategy are as follows:

[0034] (1) Distributed scheduling of the same application: Based on the application identifier identified on the low-code platform, different debugging containers belonging to the same application are scheduled to different cluster nodes as much as possible. When cluster resources are insufficient, scheduling failure information is returned to the low-code platform.

[0035] (2) Centralized scheduling of the same application: Based on the application identifier identified on the low-code platform, different debugging containers belonging to the same application are scheduled to the same cluster node as much as possible. When cluster resources are insufficient, scheduling failure information is returned to the low-code platform.

[0036] (3) Hybrid balanced scheduling: Based on the cluster resource distribution, the debugging container is allocated to the node with lower cluster load by combining the distributed scheduling of the same application and the centralized scheduling of the same application.

[0037] (4) Other custom scheduling rules: Supports custom scheduling conditions, including label selection / filtering rule matching, resource load, node selection and other condition combination scheduling.

[0038] In addition, the debugging container resource recycling strategy required by the debugging environment can be configured according to actual needs. The supported recycling strategies include timed recycling, least recently used recycling, low-traffic recycling, and other custom recycling strategies. Among them, timed recycling is to recycle the preloaded resources in the debugging container according to the preset timing rules or survival time; least recently used recycling is to recycle the resources in the debugging container with the least frequency of use within the preset recent period; low-traffic recycling is to recycle the resources in the debugging capacity with the least access traffic within the preset recent period; custom policy management is also provided, and judgment rules and conditions can be added according to specific indicators to generate corresponding custom recycling strategies for corresponding configuration. According to the debugging container resource recycling strategy, the preloaded resources in the debugging container are recycled. After the preloaded resources are cleared, the original debugging container is returned to the debugging container resource pool.

[0039] Among them, the debugging container is a container that is adapted to multiple languages, including Java, NodeJS, Python, Go and other language environments, and can also be equipped with corresponding compatible configurations and basic tools; the build dependencies required for each runtime environment of the debugging container are hosted on the debugging container resource scheduling service for classified management and pre-loading.

[0040] The debugging container can be triggered through an event-driven mechanism or an open capability API to cold start the debugging container, obtain available runtime container resources of the corresponding language environment from the debugging container resource pool, load code resources, code dependencies, and runtime basic environment, and run code resources.

[0041] The resource scheduling service constructed in this embodiment accesses the existing CICD capabilities to configure and synchronize the application CI resource information required for the low-code platform debugging environment and the CICD resources required for the general environment resources.

[0042] In addition, the resource scheduling service of this embodiment is also connected to the debugging display panel of the low-code platform. Specifically, it is connected to the debugging display panel of the low-code platform based on the observability capability indicators and log function endpoints exposed by the debugging container scheduling service; at the same time, it is connected to the debugging operation panel of the low-code platform based on the operable open capability API exposed by the debugging container resource scheduling service.

[0043] like Figure 1 As shown in the figure, the scheduling process of the low-code platform integrated with the resource scheduling service mainly includes the following steps:

[0044] Step S1: Obtain several application DSLs generated by the low-code platform, parse each application DSL separately, and obtain the corresponding function code;

[0045] Step S2: pre-allocate resources for each debugging container according to the code language type of each function code and the pre-configured resource scheduling strategy to obtain a runtime debugging container;

[0046] Step S3: Based on the resource scheduling service integrated in the low-code platform, the corresponding runtime debugging container is obtained for the function code scheduling of different code language types, and the function code is run through the runtime debugging container to generate the corresponding running results, which are displayed by the low-code platform.

[0047] Users can use different applications to perform different design operations on the visual interface and generate corresponding application DSLs simultaneously. Specifically, users can design pages on the page designer application and generate page DSLs simultaneously; users can design data models on the model designer application and generate model DSLs simultaneously; users can also design logic arrangement on the microflow designer application and generate microflow DSLs simultaneously.

[0048] The low-code platform parses the page DSL through the page design service to generate page function code; it parses the model DSL through the model design service to generate model function code; it can also parse the microflow DSL through the microflow design service to generate microflow function code.

[0049] The low-code platform submits the page function code, model function code, and microflow function code to the code warehouse through the code integration service. The code warehouse includes the front-end code warehouse and the back-end code warehouse. Different types of function codes are submitted to the corresponding code warehouse according to the code type of the function code. Specifically, if the page function code belongs to the front-end code, it will be submitted to the front-end code warehouse; if the model function code and microflow function code belong to the back-end code, they will be submitted to the back-end code warehouse.

[0050] Asynchronously trigger the scheduling of debugging container resources at the preset trigger point on the low-code platform, obtain the debugging container through the resource scheduling service integrated in the low-code platform, and trigger the cold start of the debugging container through an event-driven mechanism or an open capability API. Afterwards, obtain the available runtime container resources of the corresponding language environment from the debugging container resource pool based on the code language type of the function code and the preset resource scheduling strategy. This resource is mainly the messages pushed by the application created by the low-code platform; at the same time, load code resources, code dependencies, runtime basic environment, etc. for the debugging container, and schedule the debugging container to the corresponding cluster node according to the scheduling strategy, so as to pre-allocate resources for each debugging container. After pre-allocation, the runtime debugging container corresponding to the function code is obtained. Combined with Figure 2 As shown:

[0051] If the code language type of the page function code is NodeJS, the NodeJS language environment and the corresponding code resources are obtained from the debugging container resource pool and pre-allocated to the debugging container according to the resource scheduling strategy. After the debugging container is scheduled to the corresponding cluster node according to the scheduling strategy, the runtime debugging container corresponding to the page function code is obtained.

[0052] Similarly, if the code language type corresponding to the model function code and the microflow function code is Java, the Java language environment and the corresponding code resources are pre-allocated to the corresponding debugging container. After each debugging container is scheduled to the corresponding cluster node according to the scheduling strategy, the runtime debugging container of the model function code and the runtime debugging container corresponding to the microflow function code are obtained respectively; preloading resources in the debugging container can speed up code execution and reduce waiting time.

[0053] Afterwards, each debugging container pulls the corresponding function code from the front-end code repository and the back-end code repository, and loads each function code into the runtime debugging container adapted to the corresponding language environment. The function code is run through the runtime debugging container, so that each runtime debugging container will produce corresponding running results.

[0054] Each operation result can be displayed through the low-code platform. This embodiment connects to the low-code platform debugging display panel based on the observability capability indicators and log function endpoints of the resource scheduling service, so that users can view the operation results corresponding to each design operation through the low-code platform.

[0055] like Figure 2 As shown, the page function code is loaded into the runtime debugging container adapted to the Nodejs language environment for code execution. Users can visit the preview debugging environment to preview the corresponding running results of the page design. The model function code is installed in the runtime debugging container adapted to the Java language environment for code execution. After the model function code is executed, the microflow function code is loaded into the same runtime debugging container for execution. The running results of the model function code are presented together with the logical arrangement design results of the microflow in the low-code platform.

[0056] To query the running results, users can click to access the preview address through the debugging panel of the low-code platform, access the application running in the debugging container in a new window, query the running status of the debugging container in real time, and automatically generate log instructions. According to the log instructions, the running / operation / error logs of the debugging container during operation can be retrieved and the log information can be displayed.

[0057] The code debugging method of the low-code platform of this embodiment also includes step S4:

[0058] When the runtime debugging container is finished running, the preloaded resources of the debugging container that has finished running are recycled according to the preconfigured resource recycling strategy, and the debugging container is returned to the container resource pool after the preloaded resources are cleared.

[0059] The resource recycling strategy is one of the following: timed recycling, least-used recycling, least-flow recycling, or custom recycling strategy. The debugging container is triggered to recycle resources according to the resource recycling strategy used or defined by the low-code platform, the original debugging code and related configuration content are released, and the debugging container with recycled resources is put back into the scheduling container resource pool for subsequent scheduling container resource scheduling.

[0060] This embodiment can support the configuration of customized resource scheduling / recycling strategies based on indicators provided by the cloud platform, and support dynamic switching and debugging of container resource scheduling / recycling strategies, providing users with convenience when using business systems and application scenarios.

[0061] This embodiment can flexibly configure scheduling / recycling strategies, support multiple programming language operating environments, support Java, NodeJs, Python, Go environments, etc., and can also customize and extend the runtime environment containers of other programming language environments to quickly start running code; although the method of this embodiment takes the low-code platform as an example, the overall design of the platform is not coupled with various existing business systems, and has an independent open capability API for other platform systems to connect; for example, the operational capability API, observability indicator API, and log capability API of the open debugging container resource scheduling service are used for other business systems or platforms to connect to the corresponding capabilities of this solution.

[0062] Embodiment 2

[0063] This embodiment provides a code debugging system, which executes the code debugging method of the low-code platform in the first embodiment. Specifically, the system includes:

[0064] The front-end code generation module is used to obtain several application DSLs generated by the low-code platform, parse each application DSL separately, and obtain the corresponding function code;

[0065] The scheduling container scheduling module is used to pre-allocate resources for each debugging container according to the code language type of each function code and the pre-configured resource scheduling strategy to obtain a runtime debugging container; and based on the resource scheduling service integrated in the low-code platform, the corresponding runtime debugging container is obtained for the function code scheduling of different code language types, and the function code is run through the runtime debugging container to generate the corresponding running results;

[0066] The preview debugging module is used to query the debugging container's running status, running / operation / error logs, and access address in near real time through the low-code platform debugging panel. You can access the application running in the debugging container in a new window by clicking the access address.

[0067] In addition, the system also includes a debugging container recycling module, which triggers debugging container resource scheduling to recycle debugging container resources according to the recycling strategy used or defined by the low-code platform, releases the original debugging code and related artifact content, and re-invests them into the scheduling container resource pool for use in scheduling container resources.

[0068] The system of this embodiment builds a debugging container resource scheduling service on a low-code platform, dynamically configures debugging container resource scheduling strategies and recycling strategies, performs container runtime loading in multiple programming language environments, accesses CICD capabilities required for business systems, schedules debugging container resources according to scheduling strategies, cold-starts debugging containers, connects to observability / logging capabilities / open operation capabilities required by business systems, and recycles debugging container resources according to recycling strategies.

[0069] The functions of each module in the system of the embodiment of the present invention can be found in the corresponding description of the above method, which will not be repeated here.

[0070] Embodiment 3

[0071] Figure 3 FIG. 2 shows a structural block diagram of an electronic device according to an embodiment of the present invention. Figure 3 As shown, the electronic device includes: a memory 100 and a processor 200, and the memory 100 stores a computer program that can be run on the processor 200. When the processor 200 executes the computer program, the code debugging method of the low-code platform in the above embodiment is implemented. The number of the memory 100 and the processor 200 can be one or more.

[0072] The electronic device also includes:

[0073] The communication interface 300 is used to communicate with external devices and perform data exchange transmission.

[0074] If the memory 100, the processor 200 and the communication interface 300 are implemented independently, the memory 100, the processor 200 and the communication interface 300 can be connected to each other through a bus and communicate with each other. The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus. The bus can be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 3 Only one thick line is used in the diagram, but this does not mean that there is only one bus or only one type of bus.

[0075] Optionally, in a specific implementation, if the memory 100, the processor 200 and the communication interface 300 are integrated on a chip, the memory 100, the processor 200 and the communication interface 300 can communicate with each other through an internal interface.

[0076] An embodiment of the present invention provides a computer-readable storage medium storing a computer program, which implements the method provided in the embodiment of the present invention when executed by a processor.

[0077] An embodiment of the present invention further provides a chip, which includes a processor for calling and executing instructions stored in the memory from the memory, so that a communication device equipped with the chip executes the method provided by the embodiment of the present invention.

[0078] An embodiment of the present invention also provides a chip, including: an input interface, an output interface, a processor and a memory, wherein the input interface, the output interface, the processor and the memory are connected via an internal connection path, and the processor is used to execute the code in the memory. When the code is executed, the processor is used to execute the method provided by the embodiment of the invention.

[0079] It should be understood that the processor may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application specific integrated circuits (ASIC), field programmable gate arrays (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor may be a microprocessor or any conventional processor, etc. It is worth noting that the processor may be a processor supporting the advanced RISC machines (ARM) architecture.

[0080] Further, optionally, the above-mentioned memory may include a read-only memory and a random access memory, and may also include a non-volatile random access memory. The memory may be a volatile memory or a non-volatile memory, or may include both volatile and non-volatile memories. Among them, the non-volatile memory may include a read-only memory (ROM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), or a flash memory. The volatile memory may include a random access memory (RAM), which is used as an external cache. By way of example but not limitation, many forms of RAM are available. For example, static RAM (SRAM), dynamic random access memory (DRAM), synchronous DRAM (SDRAM), double data rate synchronous dynamic random access memory (DDR SDRAM), enhanced synchronous dynamic random access memory (ESDRAM), synchronous link dynamic random access memory (SLDRAM) and direct rambus RAM (DR RAM).

[0081] In the above embodiments, it can be implemented in whole or in part by software, hardware, firmware or any combination thereof. When implemented using software, it can be implemented in whole or in part in the form of a computer program product. The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, the process or function according to the present invention is generated in whole or in part. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium, or transmitted from one computer-readable storage medium to another computer-readable storage medium.

[0082] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present invention. Moreover, the specific features, structures, materials or characteristics described may be combined in any one or more embodiments or examples in a suitable manner. In addition, those skilled in the art may combine and combine different embodiments or examples described in this specification and the features of different embodiments or examples, unless they are contradictory.

[0083] In addition, the terms "first" and "second" are used for descriptive purposes only and should not be understood as indicating or implying relative importance or implicitly indicating the number of the indicated technical features. Therefore, the features defined as "first" and "second" may explicitly or implicitly include at least one of the features. In the description of the present invention, the meaning of "plurality" is two or more, unless otherwise clearly and specifically defined.

[0084] Any process or method description in the flow chart or otherwise described herein can be understood to represent a module, segment or portion of a code including one or more executable instructions for implementing the steps of a specific logical function or process. And the scope of the preferred embodiment of the present invention includes other implementations, in which the functions may not be performed in the order shown or discussed, including in a substantially simultaneous manner or in a reverse order according to the functions involved.

[0085] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as an ordered list of executable instructions for implementing logical functions, which can be embodied in any computer-readable medium for use by an instruction execution system, apparatus or device (such as a computer-based system, a system including a processor or other system that can fetch instructions from an instruction execution system, apparatus or device and execute instructions), or used in combination with these instruction execution systems, apparatuses or devices.

[0086] It should be understood that the various parts of the present invention can be implemented by hardware, software, firmware or a combination thereof. In the above embodiments, multiple steps or methods can be implemented by software or firmware stored in a memory and executed by a suitable instruction execution system. All or part of the steps of the above embodiment method can be completed by instructing the relevant hardware through a program, which can be stored in a computer-readable storage medium, and when the program is executed, it includes one of the steps of the method embodiment or a combination thereof.

[0087] In addition, each functional unit in each embodiment of the present invention may be integrated into a processing module, or each unit may exist physically separately, or two or more units may be integrated into one module. The above-mentioned integrated module may be implemented in the form of hardware or in the form of a software functional module. If the above-mentioned integrated module is implemented in the form of a software functional module and sold or used as an independent product, it may also be stored in a computer-readable storage medium. The storage medium may be a read-only memory, a disk or an optical disk, etc.

[0088] The above is only a specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art can easily think of various changes or substitutions within the technical scope disclosed by the present invention, which should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.

Claims

1. A code debugging method for a low-code platform. It is characterized in that include: Obtain several application DSLs generated by the low-code platform, parse each of the application DSLs respectively, and obtain the corresponding function code; Pre-allocating resources for each debugging container according to the code language type of each function code and a pre-configured resource scheduling strategy to obtain a runtime debugging container; Based on the resource scheduling service integrated in the low-code platform, the function code scheduling for different code language types obtains the corresponding runtime debugging container, runs the function code through the runtime debugging container, generates the corresponding running results, and the running results are displayed by the low-code platform.

2. The code debugging method of the low-code platform according to claim 1, It is characterized in that The application DSL includes page DSL, model DSL and microflow DSL; the function code includes page function code, model function code and microflow function code.

3. The code debugging method of the low-code platform according to claim 1, It is characterized in that The resource scheduling strategy is one of the following: same-application decentralized scheduling, same-application centralized scheduling, hybrid balanced scheduling or custom scheduling.

4. The code debugging method of the low-code platform according to claim 1, It is characterized in that Also includes: Synchronously submitting the function codes of different code language types to the code warehouse of the corresponding code language type for storage; The code repository includes a front-end code repository and a back-end code repository.

5. The code debugging method of the low-code platform according to claim 1, It is characterized in that Also includes: The resources of the runtime debugging container that has finished running are recycled according to a pre-configured resource recycling strategy, and the debugging container is returned to the container resource pool after clearing the resources.

6. The code debugging method of the low-code platform according to claim 5, It is characterized in that The resource recycling strategy is one of scheduled recycling, least-used recycling, least-flow recycling or a custom recycling strategy.

7. The code debugging method of the low-code platform according to claim 1, It is characterized in that Also includes: A query instruction is received, and log information of the runtime debugging container is retrieved and displayed according to the query instruction, wherein the log information includes a running log, an operation log, and an error log.

8. A code debugging system, It is characterized in that Execute the code debugging method of the low-code platform as described in any one of claims 1 to 7.

9. An electronic device, It is characterized in that include: A processor and a memory, wherein the memory stores instructions, and the instructions are loaded and executed by the processor to implement the code debugging method of the low-code platform as described in any one of claims 1 to 7.

10. A computer-readable storage medium, It is characterized in that The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the code debugging method of the low-code platform as described in any one of claims 1 to 7 is implemented.

Images