CN113312168A

CN113312168A - Page access method and electronic equipment

Info

Publication number: CN113312168A
Application number: CN202010120074.4A
Authority: CN
Inventors: 金伟明; 沈金明
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2020-02-26
Filing date: 2020-02-26
Publication date: 2021-08-27

Abstract

The application provides a page access method and electronic equipment, and relates to the technical field of computers, wherein the method comprises the following steps: receiving an initialized page access request of a target user sent by a client; and allocating a target container to the target user, wherein the target container carries a background service process of the editor, and the target container is used for processing a code editing request of the target user sent by the client. According to the technical scheme, each user can be allocated to the independent background server, so that the problem of resource preemption can be relieved, the phenomenon of pause is reduced, and the use safety of the user is improved.

Description

Page access method and electronic equipment

Technical Field

The present application relates to the field of computer technologies, and in particular, to a page access method and an electronic device.

Background

An Integrated Development Environment (IDE) is an application program for providing a program Development Environment, and the function thereof is generally divided into two major parts: the method comprises the steps of project management and code editing, wherein the project management comprises the functions of creating, opening, closing, compiling, packaging and the like of a project, and the code editing comprises the functions of text editing, automatic code filling, code highlighting and the like. The IDE integrates various functions in the software development process, so that developers can develop software more quickly and conveniently.

A large amount of manpower and material resources are usually needed to be spent on the traditional IDE development tool in the building process. With the continuous development of cloud technology, more and more cloud platform companies start to migrate an IDE tool to the cloud, provide page (Web) version IDEs for users to use, and enable users to directly perform software development on Web pages without installing any application program. The Web IDE system mainly comprises a client and a background server, wherein a user accesses the server through a Web page on the client, and the server returns corresponding services and pages according to a request of the user.

However, the current request processing mode of the Web IDE is easy to cause resource preemption, so that the jam is easy to cause; and the isolation is not good, which easily causes safety problem.

Disclosure of Invention

In view of the above, the present application provides a page access method and an electronic device, which are used to reduce the pause phenomenon and improve the security of the user.

In order to achieve the above object, in a first aspect, an embodiment of the present application provides a page access method applied to an integrated development environment IDE server, where the method includes:

receiving an initialized page access request of a target user sent by a client;

and allocating a target container to the target user, wherein the target container carries a background service process of an editor, and the target container is used for processing a code editing request of the target user sent by the client.

According to the page access method provided by the embodiment of the application, after receiving the initial page access request of the target user sent by the client, the IDE server allocates the target container for the target user through the container platform to process the code editing request of the target user, so that each user can be allocated to an independent background server, the resource preemption problem can be relieved, the karton phenomenon is reduced, and the use safety of the user can be improved.

In a possible implementation manner of the first aspect, the allocating a target container to the target user includes:

sending a container allocation request to a container platform, wherein the container allocation request is used for requesting the container platform to allocate a target container to the target user;

receiving the container identification of the target container returned by the container platform.

In the above embodiment, the containers are allocated to the users through the independent container platform, so that the management of the containers is facilitated, and the processing of the access requests of the users is facilitated.

In a possible implementation manner of the first aspect, the container allocation request carries a resource application amount, and the resource occupied by the target container is determined according to the resource application amount. This may increase flexibility of the IDE service.

In one possible implementation of the first aspect, the target container is a previously created free container. This can improve scheduling efficiency.

In one possible implementation of the first aspect, the method further comprises: and returning the container identification of the target container to the client. This can reduce the throughput and system complexity of the forwarding device.

In one possible implementation of the first aspect, the method further comprises: receiving an access quitting request of the target user sent by the client; and releasing the resources occupied by the target container. Therefore, resources can be released in time, and the resource utilization rate is improved.

In a possible implementation manner of the first aspect, the releasing the resource occupied by the target container includes:

and sending a container release request to a container platform, wherein the container release request is used for requesting the container platform to release the resources occupied by the target container.

In a possible implementation manner of the first aspect, the target container further carries a client process of a code management service, and the target container is further configured to upload code edited by the target user to a code management platform. This may facilitate the user in managing the edited code.

In a possible implementation manner of the first aspect, the target container further carries a background service process of a previewer, and the target container is further configured to process a preview request of the target user sent by the client. Therefore, the display effect of the development result can be conveniently previewed by the user.

In one possible implementation of the first aspect, the method further comprises:

receiving an engineering management request of the target user sent by the client;

and sending response data corresponding to the engineering management request to the client.

In the above embodiment, different backend servers are used for engineering management and code editing, so that the problem of resource preemption between the engineering management and the code editing can be avoided, and the pause phenomenon can be further reduced.

In a second aspect, an embodiment of the present application provides a page access method, which is applied to a container platform, and the method includes:

receiving a container allocation request sent by an IDE server, wherein the container allocation request is used for requesting the container platform to allocate a target container for the target user;

scheduling the target container, wherein the target container carries a background service process of an editor, and the target container is used for processing a code editing request of the target user sent by a client;

returning the container identification of the target container to the IDE server.

In one possible implementation of the second aspect, the scheduling the target container comprises:

if the container allocation request carries the resource application amount, creating the target container according to the resource application amount;

and if the container allocation request does not carry the resource application amount, selecting one container from the pre-created idle containers as the target container.

In one possible implementation of the second aspect, the method further comprises:

receiving a code editing request of a target user sent by the client, wherein the code editing request carries a container identifier of the target container;

operating the target container according to the container identifier of the target container, and generating response data corresponding to the code editing request;

and returning response data corresponding to the code editing request to the client.

In a possible implementation manner of the second aspect, the target container further carries a client process of a code management service, and the method further includes:

and uploading the code edited by the target user to a code management platform.

In a possible implementation manner of the second aspect, the target container further carries a background service process of a previewer therein, and the method further includes:

receiving a preview request of a target user sent by the client, wherein the preview request carries a container identifier of the target container;

operating the target container according to the container identifier of the target container, and generating response data corresponding to the preview request;

and returning response data corresponding to the preview request to the client.

receiving a container release request sent by an IDE server, wherein the container release request is used for requesting the container platform to release resources occupied by the target container;

and releasing the resources occupied by the target container.

In a third aspect, an embodiment of the present application provides a page access method, which is applied to a client, and the method includes:

sending an initialization page access request of a target user to an IDE server;

receiving the container identification of the target container returned by the IDE server; the target container is used for processing a code editing request of the target user sent by the client;

sending a code editing request of the target user to a target container in a container platform, wherein the code editing request carries a container identifier of the target container;

and receiving response data corresponding to the code editing request returned by the container platform.

In one possible implementation of the third aspect, the method further comprises:

sending a preview request of the target user to the container platform, wherein the preview request carries a container identifier of the target container;

and receiving response data corresponding to the preview request returned by the container platform.

In a fourth aspect, an embodiment of the present application provides a page access apparatus, which is applied to an IDE server, and the apparatus includes:

the receiving module is used for receiving an initialized page access request of a target user sent by a client;

and the processing module is used for distributing a target container to the target user, wherein the target container carries a background service process of an editor, and the target container is used for processing the code editing request of the target user sent by the client.

In a possible implementation manner of the fourth aspect, the apparatus further includes a sending module, and the processing module is specifically configured to: and instructing the sending module to send a container allocation request to a container platform, and receiving a container identifier of the target container returned by the container platform through the receiving module, wherein the container allocation request is used for requesting the container platform to allocate the target container to the target user.

In a possible implementation manner of the fourth aspect, the container allocation request carries a resource application amount, and the resource occupied by the target container is determined according to the resource application amount.

In one possible implementation of the fourth aspect, the target container is a previously created empty container.

In a possible implementation manner of the fourth aspect, the sending module is further configured to: and returning the container identification of the target container to the client.

In a possible implementation manner of the fourth aspect, the receiving module is further configured to: receiving an access quitting request of the target user sent by the client;

the processing module is further configured to: and releasing the resources occupied by the target container.

In a possible implementation manner of the fourth aspect, the processing module is specifically configured to: and instructing the sending module to send a container release request to a container platform, wherein the container release request is used for requesting the container platform to release the resources occupied by the target container.

In a possible implementation manner of the fourth aspect, the target container further carries a client process of a code management service, and the target container is further configured to upload code edited by the target user to a code management platform.

In a possible implementation manner of the fourth aspect, the target container further carries a background service process of a previewer, and the target container is further configured to process a preview request of the target user sent by the client.

In a possible implementation manner of the fourth aspect, the receiving module is further configured to: receiving an engineering management request of the target user sent by the client;

the sending module is further configured to: and sending response data corresponding to the engineering management request to the client.

In a fifth aspect, an embodiment of the present application provides a page access apparatus, which is applied to a container platform, and the apparatus includes:

a receiving module, configured to receive a container allocation request sent by an IDE server, where the container allocation request is used to request the container platform to allocate a target container to the target user;

the scheduling module is used for scheduling the target container, wherein the target container carries a background service process of an editor, and the target container is used for processing a code editing request of the target user sent by a client;

and the sending module is used for returning the container identifier of the target container to the IDE server.

In a possible implementation manner of the fifth aspect, the scheduling module is specifically configured to:

In a possible implementation manner of the fifth aspect, the receiving module is further configured to: receiving a code editing request of a target user sent by the client, wherein the code editing request carries a container identifier of the target container;

the device further comprises: the operation module is used for operating the target container according to the container identifier of the target container and generating response data corresponding to the code editing request;

the sending module is further configured to: and returning response data corresponding to the code editing request to the client.

In a possible implementation manner of the fifth aspect, the target container further carries a client process of a code management service, and the execution module is further configured to: and uploading the code edited by the target user to a code management platform.

In a possible implementation manner of the fifth aspect, the target container further carries a background service process of a previewer, and the receiving module is further configured to: receiving a preview request of a target user sent by the client, wherein the preview request carries a container identifier of the target container;

the operation module is further configured to: operating the target container according to the container identifier of the target container, and generating response data corresponding to the preview request;

the sending module is further configured to: and returning response data corresponding to the preview request to the client.

In a possible implementation manner of the fifth aspect, the receiving module is further configured to: receiving a container release request sent by an IDE server, wherein the container release request is used for requesting the container platform to release resources occupied by the target container;

the device also comprises a releasing module used for releasing the resources occupied by the target container.

In a sixth aspect, this embodiment provides a page access apparatus, applied to a client, where the apparatus includes:

the sending module is used for sending an initialized page access request of a target user to the IDE server;

the receiving module is used for receiving the container identifier of the target container returned by the IDE server; the target container is used for processing a code editing request of the target user sent by the client;

the sending module is further configured to: sending a code editing request of the target user to a target container in a container platform, wherein the code editing request carries a container identifier of the target container;

the receiving module is further configured to: and receiving response data corresponding to the code editing request returned by the container platform.

In a possible implementation manner of the sixth aspect, the sending module is further configured to: sending a preview request of the target user to the container platform, wherein the preview request carries a container identifier of the target container;

the receiving module is further configured to: and receiving response data corresponding to the preview request returned by the container platform.

In a seventh aspect, an embodiment of the present application provides a Web IDE system, including: the system comprises an IDE server for performing the method according to any of the above first aspect or embodiments of the first aspect, a container platform for performing the method according to any of the above second aspect or embodiments of the second aspect, and a client for performing the method according to any of the above third aspect or embodiments of the third aspect.

In an eighth aspect, an embodiment of the present application provides an electronic device, including: a memory for storing a computer program and a processor; the processor is configured to perform the method of the first, second or third aspect when the computer program is invoked.

In a ninth aspect, embodiments of the present application provide a computer-readable storage medium, on which a computer program is stored, and the computer program, when executed by a processor, implements the method of the first, second or third aspect.

In a tenth aspect, embodiments of the present application provide a computer program product, which, when run on an electronic device, causes the electronic device to perform the method of the first, second or third aspect.

It is to be understood that the beneficial effects of the second to tenth aspects can be seen from the description of the first aspect, and are not repeated herein.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments or the prior art descriptions will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive exercise.

Fig. 1 is a schematic structural diagram of a Web IDE system according to an embodiment of the present application;

fig. 2 is a schematic flowchart of a page access method provided in an embodiment of the present application;

fig. 3 is a schematic structural diagram of a page access apparatus according to an embodiment of the present application;

fig. 4 is a schematic structural diagram of another page access apparatus provided in the embodiment of the present application;

fig. 5 is a schematic structural diagram of a page access apparatus according to an embodiment of the present application;

fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

In the existing Web IDE system, a plurality of users share the same background server, so that the problem of resource preemption is easy to occur, and the blockage is easy to cause; moreover, a large number of users share the same background server when editing codes, and the isolation of the codes is poor, so that the safety problem is easily caused.

In view of the above technical problems, embodiments of the present application provide a page access method, which allocates an independent background server to each user by using a container technology to solve the problem of resource preemption, reduce the pause phenomenon, and improve the security of user usage.

The embodiments of the present application will be described below with reference to the drawings. The following several specific embodiments may be combined with each other, and details of the same or similar concepts or processes may not be repeated in some embodiments.

First, a Web IDE system according to an embodiment of the present application will be described. Referring to fig. 1, fig. 1 is a schematic structural diagram of a Web IDE system according to an embodiment of the present disclosure.

As shown in fig. 1, the Web IDE system may include a client 10, an IDE Server 20, a container platform 30, a database Server 40, an Elastic Load Balancer Server (ELB) 50, a proxy Server 60, a service gateway 70, an authentication platform 80, a log Server 90, an Object Storage Server (OBS) 100, an application service distribution platform 110, and a code management platform 120. Various servers can be implemented in a cluster manner to improve service capability, and for convenience of drawing, an example is illustrated in the drawing.

It is to be understood that fig. 1 is merely an example of a Web IDE system and does not constitute a limitation of the Web IDE system. In other embodiments of the present application, the Web IDE system may include more or fewer devices than shown, or some devices may be combined, some devices may be split, or a different arrangement of devices. The following describes each component device of the Web IDE system in detail with reference to fig. 1:

the client 10 may be an electronic device with display, operation and network access functions, for example, a tablet computer, a notebook computer or a desktop computer. The user may open the relevant page through a browser on the client 10 to access the background server.

In particular implementations, the client 10 may implement a front-end page for engineering management using the Vue framework, a front-end page for code editing by embedding Theia in Vue. Vue is a set of progressive framework for constructing a user interface, and is different from other heavy-weight frameworks in that Vue adopts a design of bottom-up incremental development, and the Vue framework can effectively reduce the code amount and improve the performance of a front-end page. Of course, the client 10 may also be implemented by using other frameworks, which is not particularly limited in this embodiment.

The IDE server 20 is used to process page access requests of users. In order to reduce resource preemption and improve user security, the IDE server 20 may allocate a container to the user to process the user's page access request when receiving the user's initial page access request.

The problem that resources are easily seized is also considered when the same background server is shared by engineering management and code editing; moreover, the frequency of requests for engineering management and code editing is different from the requirements for resources, wherein the request frequency of the engineering management for a background server is very low, and the requirements for the resources are less; in the code editing, each time a letter is input, a completion scheme and the like are requested, so that the request frequency is very high, the requirements on resources are more, and in order to further improve the rationality of resource allocation, in the embodiment, a plurality of users can share one background server to process the program management request, and each user processes the code editing request through a container allocated to the user, namely the IDE server 20 can be used as a background server for the project management to process the project management request of the user; the container allocated for the user is specifically used for processing the code editing request of the user.

To facilitate handling user access requests and managing containers, in this embodiment, containers may be located on a separate container platform 30, and the IDE server 20 may notify the container platform 30 to allocate a container for a user when allocating a container for a user.

The container platform 30 may be a kubernets container cluster platform, which is hereinafter abbreviated as kubernets. On the basis of the Docker technology, Kubernets can provide a series of functions such as deployment operation, resource scheduling, service discovery, dynamic scaling and the like for containerized application, so that the convenience of large-scale container cluster management can be improved.

Kubernets may specifically include: the system comprises a Master Node (Master) and a slave Node (Node), wherein the Master is a central control Node and is used for controlling resource scheduling of the whole container cluster, executing tasks in the container cluster and managing containers in the whole container cluster; a Node is a computing unit that specifically carries containers, and each Node includes one or more container groups (pod) therein, and each pod includes one or more containers (containers). Both Master and Node may be deployed by physical or virtual machines.

The database server 40 is used for providing data services, and the database managed by the database server may be specifically a MySQL database, or may be another database, such as an Oracle database. The IDE server 20 may store the generated project information (e.g., project name and application type, etc.) in the database server 40 for management, and may read the project information from the database server 40.

The ELB50 is used to distribute the page access request of the client 10 to the background server according to the forwarding policy, so as to extend the service capability of the system and improve the fault tolerance capability of the system.

The proxy server 60 is used to implement reverse proxy, forward the page access request sent by the user through the client 10 to the background server, and return the result obtained from the background server to the client 10, so as to improve the access speed and the access security, and can be used for load balancing. The proxy Server 60 may be an Nginx Server, or may be another Server having a reverse proxy function, such as a Server Load Balancer (SLB) Server.

The service gateway 70 is responsible for request forwarding, user authentication, and other content, such as addressing cross-site access and setting up a HyperText Transfer Protocol (HTTP) security message header. The internal services can be protected from unauthorized access by providing a firewall to allow requests to the IDE server 20 to pass through the gateway, thereby isolating the internal services from external users.

The authentication platform 80 is used for access authentication. The Web IDE system developer may provide a plurality of service platforms for users to use, and a user may register an account in each service platform and then access the service platform through a login account, that is, the Web IDE system may provide account registration and login services, and a user may register an account in the Web IDE system and then access the Web IDE service through the login account. For the convenience of the user and the management of the account, the Web IDE system developer may perform login authentication of each service platform through the authentication platform 80, so that the user may access multiple service platforms through the account registered in the authentication platform 80.

In specific implementation, a user can register an account number on the authentication platform 80, and when the user accesses the Web IDE service through the client 10, the client 10 can redirect a page access request of the user to a login page of the authentication platform 80 for the user to log in; after receiving the login request carrying the login information (which may include information such as an account number and a password) of the user, the authentication platform 80 may return an access credential (token) to the client 10 if the login information is verified. After receiving the token, the client 10 may carry the token in the initialized page access request and send the token to the IDE server 20; after receiving the initialization page access request, the IDE server 20 may send the token carried therein to the authentication platform 80 for authentication, and in case that the authentication platform 80 passes the authentication, allocate a container for the user.

The log server 90 is used for recording system logs, operation and maintenance logs and the like generated in the operation process of service devices such as the IDE server 20, the container, the service gateway 70 and the like, and analyzing the logs to generate reports, so that managers can accurately find key data, locate network faults and identify security threats in advance, service performance is improved, and network security is guaranteed.

The OBS100 is used to provide stable, safe and highly reliable data storage service, and a developer (i.e., a user) can store a developed Application (APP) on the OBS100 through the IDE server 20, so that the user can download and use the APP through a terminal such as a mobile phone.

The application service distribution platform 110 aggregates the terminal multimedia platform, which can provide efficient distribution service for developers, and the developers can also upload developed APPs to the application service distribution platform 110 through the IDE server 20 for downloading and use by terminal users, so as to improve the popularization efficiency and provide more convenient and optimized experience for the terminal users.

The code management platform 120 is used for version management of the code, and may specifically be a Git code repository or other code repository. The container in the container platform 30 may upload the code edited by the user to the code management platform 120 for code management, so that the user can maintain and manage the developed code conveniently, and the development efficiency is improved. The IDE server 20 may also obtain engineering-related code from the code management platform 120 and compile the code.

The following describes a process of processing a page access request by a background server, and for ease of understanding, the process only involves a message processing process between a client, an IDE server and a container platform, and a message processing flow of other devices possibly involved in the process is omitted, for example: the page access request sent by the client to the IDE server can reach the IDE server through the ELB, the proxy server and the service gateway, and the message processing flow of the ELB, the proxy server and the service gateway is omitted in order to reduce repeated description.

Fig. 2 is a schematic flowchart of a page access method provided in an embodiment of the present application, and as shown in fig. 2, the method may include the following steps:

s101, the client sends an initialization page access request of a target user to the IDE server.

Specifically, a user may access a Web page corresponding to the Web IDE service through a browser on the client, and the browser responds to an access operation of the user and sends an initialization page access request of a target user to the IDE server, so as to provide an initialization page of the Web IDE service to the user, for example: IDE home page.

The initialization page access request may carry a user identifier, where the user identifier may specifically include an Identity (ID) of a target user, and may also include a client ID.

And S102, after receiving the initialized page access request, the IDE server sends a container allocation request to the container platform.

Specifically, after receiving the initialization page access request, the IDE server may allocate a container (referred to as a target container herein) to the target user to process the page access request of the target user, so as to improve the reasonableness of resource allocation and improve the security of the user.

As described above, in order to further improve the reasonableness of resource allocation, in this embodiment, multiple users may share one background server to process the engineering management request, and each user processes the code editing request through the container allocated to the user, that is, the IDE server may serve as a background server for engineering management to process the engineering management request of the user; the containers allocated for a user are specifically used to process the user's code editing request. To facilitate handling of user access requests, the container may be located on a separate container platform, and the IDE server may notify the container platform to allocate a container for the user when allocating the container for the user.

The container allocation request may correspond to the user identifier, or the user identifier may be carried in the container allocation request, and the container platform also carries the user identifier when returning the container allocation result, so that the IDE server determines the correspondence between the initialization access request and the container.

In order to improve the flexibility of the IDE service, in this embodiment, the user may also specify the resource application amount, and the IDE server may carry the resource application amount when sending the container allocation request. When the container platform allocates the target container, the resources occupied by the target container are determined according to the resource application amount.

The resource application amount may be preset by a user, for example: the system can provide a resource application amount setting function, a user can set the resource application amount through the function after logging in an account, the IDE server can store the corresponding relation between the resource application amount and the user account, and the resource application amount of the user can be obtained based on the corresponding relation after receiving an initialization page access request.

The resource application amount may also be set by the user when logging in the system, for example: the login page can provide a resource application amount setting option, and a user can set the resource application amount through the option; correspondingly, the initialized page access request can carry the resource application amount, and the IDE server can obtain the resource application amount from the initialized page access request.

S103, after the container platform receives the container allocation request, the target container is scheduled.

Specifically, after receiving the container allocation request, the container platform may generate a task for scheduling the target container in the Master, and then schedule the target container to be deployed to the target Node based on a preset scheduling rule, where the target container scheduled to the target Node carries a background service process of the editor.

The containers deployed in the container platform may be containers of the same type, i.e., containers each have the same mirror image loaded therein, providing the same service. In order to expand the application range of the container platform, the containers deployed in the container platform may also include multiple types of containers, so that when the IDE server sends a container allocation request, the IDE server may carry a mirror identifier in the container allocation request, and the container platform schedules a corresponding target container according to the mirror identifier.

In order to improve scheduling efficiency, idle containers can be created in the container platform in advance, after a container allocation request is received, one idle container is directly selected from the container resource pool to serve as a target container, and the target container is allocated to a target user without temporarily creating the container.

In specific implementation, if the container allocation request does not carry the resource application amount, the container platform can directly select an idle container as a target container; if the container allocation request carries the resource application amount, the container platform may temporarily create a container as a target container according to the resource application amount.

S104, the container platform returns the container identification of the target container to the IDE server.

After the container platform schedules the target container, it may return a container identifier of the target container to the container allocation server, where the container identifier may include an Internet Protocol (IP) address, and may also include information such as a port number, a container ID, and/or a node ID.

S105, the IDE server returns the container identification of the target container to the client.

Specifically, after receiving the container identifier of the target container returned by the container platform, the IDE server may transmit the corresponding relationship between the container identifier and the target user to a forwarding device (e.g., an ELB or a proxy server), so that the forwarding device forwards the code editing request of the target user to the target container by querying the container allocation result. In order to reduce the processing amount and the system complexity of the forwarding device, the IDE server may also return the container identifier of the target container to the client, and the client may carry the container identifier of the target container when sending the code editing request of the target user, so that the forwarding device directly forwards the code editing request to the target container according to the container identifier.

And S106, the client sends the engineering management request of the target user to the IDE server.

The user can perform engineering management operations such as engineering creation, opening, closing, compiling, packaging and the like after opening the IDE initialization page, and the client can send an engineering management request of the target user to the IDE server after receiving the engineering management operation of the target user).

And S107, the IDE server returns response data corresponding to the engineering management request to the client.

Specifically, the IDE server is used as a background server of the project management function, and after receiving a project management request from a target user, the IDE server may process the request, generate response data corresponding to the project management request, and send the response data to the client.

S108, the client sends a code editing request of the target user to the target container in the container platform.

Specifically, a user may perform operations related to code editing during development, and after receiving a code editing operation of a target user, a client may send a code editing request to a backend server (i.e., a target container) to request the backend server to process the request. The code editing request may carry a container identifier of the target container.

And S109, the container platform operates the target container according to the container identifier of the target container to generate response data corresponding to the code editing request.

Specifically, after receiving a code editing request of a target user, the container platform may find a corresponding target container according to a container identifier in the request, and then may forward the code editing request to the target container, and operate the target container to process the request, thereby generating response data corresponding to the code editing request.

In this embodiment, the target container may further bear a client process of the code management service, so as to upload a code edited by the target user to the code management platform for code management. In specific implementation, the target container may upload the edited code once every preset time, or upload the edited code according to a code upload instruction sent by the user through the client.

In addition, the system can also provide a preview function for a user to preview a development result in the software development process, and the target container can also bear a background service process of the previewer, so that after a preview request of the target user sent by the client is received, the target container is operated according to the container identifier of the target container in the preview request, response data corresponding to the preview request is generated and then returned to the client, and the client is enabled to present the preview result to the user according to the response data. The preview result may include a display effect of the development result on different terminals (including a mobile phone, a computer, a vehicle-mounted terminal, and the like).

And S110, the container platform returns response data corresponding to the code editing request to the client.

Specifically, after the target container generates response data corresponding to the code editing request, the container platform may return the response data to the client, so that the client displays a corresponding page to the user according to the response data.

And S111, the client sends an access quitting request of the target user to the IDE server.

Specifically, the user may quit the IDE system after the editing is finished, and the client may send an access quit request to the background server (IDE server) after receiving the system quit operation of the user, where the access quit request may carry a user identifier of the target user or a container identifier of the target container.

And S112, after receiving the access quitting request, the IDE server sends a container releasing request to the container platform.

Specifically, after receiving the access quitting request of the target user, the IDE server may notify the container platform to release the resource occupied by the target container corresponding to the target user, and timely release the resource, thereby improving the resource utilization rate. The container release request may carry a container identifier of the target container, and specifically, the IDE server may obtain the container identifier from the access exit request; or after the container is allocated, the corresponding relation between the container identifier and the user identifier may be established, and after the access quit request is received, the container identifier of the target container is obtained based on the corresponding relation.

And S113, after the container platform receives the container release request, releasing the resources occupied by the target container.

Specifically, after receiving the container release request, the container platform may destroy the target container according to the container identifier of the target container carried in the container release request, so as to release the resource occupied by the target.

It will be appreciated by those skilled in the art that the above embodiments are exemplary and not intended to limit the present application. Where possible, the order of execution of one or more of the above steps may be adjusted, or selectively combined, to arrive at one or more other embodiments. For example, the above steps S106 and S108 may be performed alternately. The skilled person can select any combination of the above steps according to the needs, and all that does not depart from the essence of the scheme of the present application falls into the protection scope of the present application.

In the page access method provided by this embodiment, after receiving an initial page access request of a target user sent by a client, the IDE server allocates a target container to the target user through the container platform to process a code editing request of the target user, so that each user can be allocated to an independent background server, thereby alleviating the problem of resource preemption, reducing the katon phenomenon, and improving the safety of user use.

Based on the same inventive concept, as an implementation of the foregoing method, an embodiment of the present application provides a page access apparatus, where the apparatus embodiment corresponds to the foregoing method embodiment, and for convenience of reading, details in the foregoing method embodiment are not repeated in this apparatus embodiment one by one, but it should be clear that the apparatus in this embodiment can correspondingly implement all the contents in the foregoing method embodiment.

Fig. 3 is a schematic structural diagram of a page access apparatus provided in this embodiment, which is applied to an IDE server, as shown in fig. 3, the page access apparatus 210 provided in this embodiment may include:

a receiving module 211, configured to receive an initialization page access request of a target user sent by a client;

a processing module 212, configured to allocate a target container to the target user, where the target container carries a background service process of an editor, and the target container is used to process a code editing request of the target user sent by the client.

As an optional implementation manner of this embodiment of the present application, the apparatus further includes a sending module 213, and the processing module 212 is specifically configured to: and instructing the sending module 213 to send a container allocation request to a container platform, and receiving, by the receiving module 211, the container identifier of the target container returned by the container platform, where the container allocation request is used to request the container platform to allocate the target container to the target user.

As an optional implementation manner of the embodiment of the present application, the container allocation request carries a resource application amount, and the resource occupied by the target container is determined according to the resource application amount.

As an optional implementation manner of this embodiment of the present application, the target container is a free container created in advance.

As an optional implementation manner of this embodiment of the present application, the sending module 213 is further configured to: and returning the container identification of the target container to the client.

As an optional implementation manner of this embodiment of this application, the receiving module 211 is further configured to: receiving an access quitting request of the target user sent by the client;

the processing module 212 is further configured to: and releasing the resources occupied by the target container.

As an optional implementation manner of the embodiment of the present application, the processing module 212 is specifically configured to: instructing the sending module 213 to send a container release request to a container platform, where the container release request is used to request the container platform to release the resources occupied by the target container.

As an optional implementation manner of the embodiment of the present application, the target container further carries a client process of a code management service, and the target container is further configured to upload a code edited by the target user to a code management platform.

As an optional implementation manner of the embodiment of the present application, the target container further carries a background service process of a previewer, and the target container is further configured to process a preview request of the target user sent by the client.

As an optional implementation manner of this embodiment of this application, the receiving module 211 is further configured to: receiving an engineering management request of the target user sent by the client;

the sending module 213 is further configured to: and sending response data corresponding to the engineering management request to the client.

The apparatus provided in this embodiment may perform the above method embodiments, and the implementation principle and the technical effect are similar, which are not described herein again.

Fig. 4 is another schematic structural diagram of a page access apparatus provided in this embodiment of the present application, where the apparatus is applied to a container platform, and as shown in fig. 4, the page access apparatus 220 provided in this embodiment may include:

a receiving module 221, configured to receive a container allocation request sent by an IDE server, where the container allocation request is used to request the container platform to allocate a target container to the target user;

a scheduling module 222, configured to schedule the target container, where the target container carries a background service process of an editor, and the target container is used to process a code editing request of the target user sent by a client;

a sending module 223, configured to return the container identifier of the target container to the IDE server.

As an optional implementation manner of this embodiment of the present application, the scheduling module 222 is specifically configured to:

As an optional implementation manner of this embodiment of the present application, the receiving module 221 is further configured to: receiving a code editing request of a target user sent by the client, wherein the code editing request carries a container identifier of the target container;

the device further comprises: an operation module 224, configured to operate the target container according to the container identifier of the target container, and generate response data corresponding to the code editing request;

the sending module 223 is further configured to: and returning response data corresponding to the code editing request to the client.

As an optional implementation manner of this embodiment of the present application, the target container further carries a client process of a code management service, and the running module 224 is further configured to: and uploading the code edited by the target user to a code management platform.

As an optional implementation manner of this embodiment of the present application, the target container further carries a background service process of a previewer, and the receiving module 221 is further configured to: receiving a preview request of a target user sent by the client, wherein the preview request carries a container identifier of the target container;

the execution module 224 is further configured to: operating the target container according to the container identifier of the target container, and generating response data corresponding to the preview request;

the sending module 223 is further configured to: and returning response data corresponding to the preview request to the client.

As an optional implementation manner of this embodiment of the present application, the receiving module 221 is further configured to: receiving a container release request sent by an IDE server, wherein the container release request is used for requesting the container platform to release resources occupied by the target container;

the apparatus further includes a releasing module 225 configured to release the resources occupied by the target container.

Fig. 5 is a schematic structural diagram of another structure of a page access apparatus provided in this embodiment, where the apparatus is applied to a client, and as shown in fig. 5, the page access apparatus 230 provided in this embodiment may include:

a sending module 231, configured to send an initialization page access request of a target user to the IDE server;

a receiving module 232, configured to receive a container identifier of the target container returned by the IDE server; the target container is used for processing a code editing request of the target user sent by the client;

the sending module 231 is further configured to: sending a code editing request of the target user to a target container in a container platform, wherein the code editing request carries a container identifier of the target container;

the receiving module 232 is further configured to: and receiving response data corresponding to the code editing request returned by the container platform.

As an optional implementation manner of this embodiment, the sending module 231 is further configured to: sending a preview request of the target user to the container platform, wherein the preview request carries a container identifier of the target container;

the receiving module 232 is further configured to: and receiving response data corresponding to the preview request returned by the container platform.

It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-mentioned division of the functional units and modules is illustrated, and in practical applications, the above-mentioned function distribution may be performed by different functional units and modules according to needs, that is, the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-mentioned functions. Each functional unit and module in the embodiments may be integrated in one processing unit, or each unit may exist alone physically, or two or more units are integrated in one unit, and the integrated unit may be implemented in a form of hardware, or in a form of software functional unit. In addition, specific names of the functional units and modules are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present application. The specific working processes of the units and modules in the system may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

Based on the same inventive concept, the embodiment of the application also provides the electronic equipment. Fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present application, and as shown in fig. 6, the electronic device according to the embodiment includes: memory 310, processor 320, and communication module 330.

Wherein the memory 310 may be used for storing computer programs and modules, and the processor 320 may execute the methods performed by the devices in the client, the IDE server, the container allocation server or the container platform in the above method embodiments by running the computer programs and modules stored in the memory 310. The memory 310 may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required by at least one function (such as a sound playing function, an image playing function, etc.), and the like; the storage data area may store data (such as audio data, a phonebook, etc.) created according to the use of the electronic device, and the like. Further, the memory 310 may include high speed random access memory, and may also include non-volatile memory, such as at least one magnetic disk storage device, flash memory device, or other volatile solid state storage device.

The processor 320 is a control center of the electronic device, connects various parts of the entire electronic device using various interfaces and lines, performs various functions of the electronic device and processes data by operating or executing software programs and/or modules stored in the memory 310 and calling data stored in the memory 310, thereby integrally monitoring the electronic device. Alternatively, processor 320 may include one or more processing units.

The communication module 330 may provide a solution for communication applied to an electronic device, including Wireless Local Area Networks (WLANs), such as Wi-Fi Networks, bluetooth, Zigbee, mobile communication Networks, Global Navigation Satellite Systems (GNSS), Frequency Modulation (FM), NFC, and Infrared (IR). The communication module may be one or more devices integrating at least one communication processing module. The communication module 330 may include an antenna, and may receive electromagnetic waves through the antenna, frequency modulate and filter electromagnetic wave signals, and transmit the processed signals to the processor. The communication module 330 may also receive a signal to be transmitted from the processor 320, perform frequency modulation and amplification on the signal, and convert the signal into electromagnetic waves through the antenna to radiate the electromagnetic waves. The electronic device can communicate with the terminal device through the communication module 330.

Those skilled in the art will appreciate that fig. 6 is merely exemplary of an electronic device and is not intended to limit the electronic device and may include more or fewer components than those shown, or some components may be combined, or a different arrangement of components.

The electronic device side provided in this embodiment may execute the above method embodiments, and the implementation principle and the technical effect are similar, which are not described herein again.

Embodiments of the present application further provide a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the computer program implements the method described in the above method embodiments.

The embodiment of the present application further provides a computer program product, which when running on an electronic device, enables the electronic device to implement the method described in the above method embodiment when executed.

In the above embodiments, the implementation may be wholly or partially realized by software, hardware, firmware, or any combination thereof. When implemented in software, may 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 loaded and executed on a computer, cause the processes or functions described in accordance with the embodiments of the application to occur, in whole or in part. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. The computer instructions may be stored in or transmitted over a computer-readable storage medium. The computer instructions may be transmitted from one website site, computer, server, or data center to another website site, computer, server, or data center via wired (e.g., coaxial cable, fiber optics, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.). The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device, such as a server, a data center, etc., that incorporates one or more of the available media. The usable medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., Solid State Disk (SSD)), among others.

One of ordinary skill in the art will appreciate that all or part of the processes in the methods of the above embodiments may be implemented by hardware related to instructions of a computer program, which may be stored in a computer-readable storage medium, and when executed, may include the processes of the above method embodiments. And the aforementioned storage medium may include: various media capable of storing program codes, such as ROM or RAM, magnetic or optical disks, etc.

In the above embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to the related descriptions of other embodiments for parts that are not described or illustrated in a certain embodiment.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus/device and method may be implemented in other ways. For example, the above-described apparatus/device embodiments are merely illustrative, and for example, the division of the modules or units is only one logical division, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

It will be understood that the terms "comprises" and/or "comprising," when used in this specification and the appended claims, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

It should also be understood that the term "and/or" as used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.

As used in this specification and the appended claims, the term "if" may be interpreted contextually as "when", "upon" or "in response to" determining "or" in response to detecting ". Similarly, the phrase "if it is determined" or "if a [ described condition or event ] is detected" may be interpreted contextually to mean "upon determining" or "in response to determining" or "upon detecting [ described condition or event ]" or "in response to detecting [ described condition or event ]".

Furthermore, in the description of the present application and the appended claims, the terms "first," "second," "third," and the like are used for distinguishing between descriptions and not necessarily for describing or implying relative importance.

Reference throughout this specification to "one embodiment" or "some embodiments," or the like, means that a particular feature, structure, or characteristic described in connection with the embodiment is included in one or more embodiments of the present application. Thus, appearances of the phrases "in one embodiment," "in some embodiments," "in other embodiments," or the like, in various places throughout this specification are not necessarily all referring to the same embodiment, but rather "one or more but not all embodiments" unless specifically stated otherwise. The terms "comprising," "including," "having," and variations thereof mean "including, but not limited to," unless expressly specified otherwise.

Finally, it should be noted that: the above embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some or all of the technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the scope of the technical solutions of the embodiments of the present application.

Claims

1. A page access method is applied to an Integrated Development Environment (IDE) server, and is characterized by comprising the following steps:

receiving an initialized page access request of a target user sent by a client;

2. The method of claim 1, wherein said assigning a target container to the target user comprises:

3. The method according to claim 2, wherein the container allocation request carries a resource application amount, and the resource occupied by the target container is determined according to the resource application amount.

4. The method of claim 1, wherein the target container is a previously created free container.

5. The method of claim 1, further comprising:

and returning the container identification of the target container to the client.

6. The method of claim 1, further comprising:

receiving an access quitting request of the target user sent by the client;

and releasing the resources occupied by the target container.

7. The method of claim 6, wherein the releasing the resources occupied by the target container comprises:

8. The method of claim 1, wherein the target container further carries a client process of a code management service, and wherein the target container is further used for uploading the code edited by the target user to a code management platform.

9. The method of claim 1, wherein the target container further carries a background service process of a previewer, and wherein the target container is further used for processing a preview request of the target user sent by the client.

10. The method according to any one of claims 1-9, further comprising:

11. A page access method applied to a container platform is characterized by comprising the following steps:

receiving a container allocation request sent by an Integrated Development Environment (IDE) server, wherein the container allocation request is used for requesting the container platform to allocate a target container for the target user;

12. The method of claim 11, wherein the scheduling the target container comprises:

13. The method of claim 11, further comprising:

14. The method of claim 11, wherein the target container further carries a client process of a code management service, and wherein the method further comprises:

and uploading the code edited by the target user to a code management platform.

15. The method of claim 11, wherein the target container further carries a background service process of a previewer, and wherein the method further comprises:

and returning response data corresponding to the preview request to the client.

16. The method according to any one of claims 11-15, further comprising:

and releasing the resources occupied by the target container.

17. A page access method is applied to a client, and is characterized in that the method comprises the following steps:

sending an initialization page access request of a target user to an Integrated Development Environment (IDE) server;

18. The method of claim 17, further comprising:

19. An electronic device, comprising: a memory for storing a computer program and a processor; the processor is adapted to perform the method of any of claims 1-18 when the computer program is invoked.

20. A Web IDE system for a page integrated development environment, comprising: an IDE server for performing the method of any of claims 1-10, a container platform for performing the method of any of claims 11-16, and a client for performing the method of claim 17 or 18.

21. A computer-readable storage medium, on which a computer program is stored, which, when being executed by a processor, carries out the method according to any one of claims 1-18.