CN109150978B - Method and device for debugging micro service - Google Patents
Method and device for debugging micro service Download PDFInfo
- Publication number
- CN109150978B CN109150978B CN201810819331.6A CN201810819331A CN109150978B CN 109150978 B CN109150978 B CN 109150978B CN 201810819331 A CN201810819331 A CN 201810819331A CN 109150978 B CN109150978 B CN 109150978B
- Authority
- CN
- China
- Prior art keywords
- user
- request
- micro
- debugging
- identification
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/50—Network services
- H04L67/51—Discovery or management thereof, e.g. service location protocol [SLP] or web services
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L63/00—Network architectures or network communication protocols for network security
- H04L63/08—Network architectures or network communication protocols for network security for authentication of entities
- H04L63/0807—Network architectures or network communication protocols for network security for authentication of entities using tickets, e.g. Kerberos
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/2866—Architectures; Arrangements
- H04L67/30—Profiles
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/50—Network services
- H04L67/60—Scheduling or organising the servicing of application requests, e.g. requests for application data transmissions using the analysis and optimisation of the required network resources
Abstract
The embodiment of the application discloses a method and a device for debugging micro-services. One embodiment of the method comprises: determining the identification of a user sending a request and the identification of a micro service module requested to be debugged, which are indicated by the obtained debugging request; reading a configuration file of a user according to the identification of the user, wherein the configuration file comprises the user identification and a routing relation between the micro-service module identification and the network address of the micro-service instance; and forwarding the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and executing debugging operation based on the target micro-service instance. The embodiment realizes the micro-service debugging based on the network address of the micro-service instance, can quickly locate the problem during debugging and improves the debugging efficiency.
Description
Technical Field
The embodiment of the application relates to the technical field of computers, in particular to the field of cloud services, and particularly relates to a method and a device for debugging micro services.
Background
Micro-services are a service technology that can be deployed independently for each service by dividing service types according to business modules, and are one of the popular software architectures at present. Numerous micro services can be deployed in the cloud service, complex dependency relationships exist among the micro services, particularly, micro service modules inside a cloud computing system depend on infrastructure of numerous bottom layers, the numerous micro service modules in the cloud service use a shared development and debugging system, and the micro service modules to be debugged need to be positioned by relying on support of resources of numerous bottom layer data during development and debugging.
Disclosure of Invention
The embodiment of the application provides a method and a device for debugging micro-service.
In a first aspect, an embodiment of the present application provides a method for debugging a microservice, including: determining the identification of a user sending a request and the identification of a micro service module requested to be debugged, which are indicated by the obtained debugging request; reading a configuration file of a user according to the identification of the user, wherein the configuration file comprises the user identification and a routing relation between the identification of the micro service module and the network address of the micro service instance; and forwarding the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and executing debugging operation based on the target micro-service instance.
In some embodiments, the above method further comprises: when the micro service module is deployed, a domain name generated by the identification of the user and the identification of the micro service module is created for the micro service instance deployed by the user, the created domain name is mapped to the network address of the micro service instance deployed by the user, and the domain name is stored in the configuration file of the user.
In some embodiments, the forwarding the debug request to the target micro service instance corresponding to the debug request determined based on the configuration file of the user, and executing the debug operation based on the target micro service instance includes: according to the configuration file of the user, the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged is found out; and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request.
In some embodiments, the above method further comprises: initiating a microservice instance within a container, comprising: acquiring a program package of the compiled micro service module and operating the program package in a container; or performing the following operations in the container: the method comprises the steps of obtaining a patch file of a micro-service module uploaded by a client sending a debugging request, obtaining a stored program file of the micro-service module, applying the patch file of the micro-service module in the program file of the micro-service module, compiling the program file after applying the patch file to generate a program package, and operating the generated program package.
In some embodiments, the determining the identity of the requesting user indicated by the obtained debugging request includes: acquiring a request identifier distributed for a debugging request; and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier, wherein the user identifier is used as the identifier of the user sending the request.
In some embodiments, before determining the identity of the requesting user indicated by the obtained debug request, the method further comprises: acquiring a debugging request for debugging the micro service through an agent, wherein the debugging request comprises a user token; authenticating a user who sends a debugging request based on a user token; the determining the identifier of the requesting user indicated by the acquired debugging request and the identifier of the micro-service module requested to be debugged includes: and if the authentication is passed, determining the identification of the user sending the request and the identification of the micro service module requested to be debugged, which are indicated by the obtained debugging request.
In a second aspect, an embodiment of the present application provides an apparatus for debugging a microservice, including: a determining unit configured to determine an identification of a requesting user indicated by the acquired debugging request, and an identification of the micro service module requested to be debugged; the reading unit is configured to read a configuration file of the user according to the identification of the user, wherein the configuration file comprises the user identification and a routing relation between the micro service module identification and the network address of the micro service instance; and the forwarding unit is configured to forward the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and execute debugging operation based on the target micro-service instance.
In some embodiments, the above apparatus further comprises: the deployment unit is configured to create a domain name generated by the user identifier and the micro service module identifier for the micro service instance deployed by the user when the micro service module is deployed, map the created domain name to the network address of the micro service instance deployed by the user, and store the domain name in the configuration file of the user.
In some embodiments, the forwarding unit is further configured to: searching out the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged according to the configuration file of the user; and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request.
In some embodiments, the above apparatus further comprises: a start unit configured to start a microservice instance within a container as follows: acquiring a program package of the compiled micro service module and operating the program package in a container; or performing the following operations in the container: the method comprises the steps of obtaining patch files of micro service modules uploaded by a client sending out a debugging request, obtaining program files of the stored micro service modules, applying the patch files of the micro service modules in the program files of the micro service modules, compiling the program files after the patch files are applied to generate a program package, and operating the generated program package.
In some embodiments, the determining unit is further configured to determine the identity of the requesting user indicated by the obtained debugging request as follows: acquiring a request identifier distributed for a debugging request; and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier, wherein the user identifier is used as the identifier of the user sending the request.
In some embodiments, the above apparatus further comprises: a connection unit configured to acquire, by proxy, a debug request for debugging the microservice, the debug request including a user token, before determining an identification of a requesting user indicated by the acquired debug request; an authentication unit configured to authenticate a user who issued a debugging request based on a user token; and the determining unit is further configured to determine the identification of the requesting user and the identification of the micro service module requested to be debugged, which are indicated by the obtained debugging request, in response to the authentication passing.
In a third aspect, an embodiment of the present application provides an electronic device, including: one or more processors; a storage device for storing one or more programs which, when executed by one or more processors, cause the one or more processors to implement the method of debugging a microservice as provided by the first aspect.
In a fourth aspect, an embodiment of the present application provides a computer readable medium, on which a computer program is stored, where the program, when executed by a processor, implements the method for debugging a microservice provided by the first aspect.
According to the method and the device for debugging the micro service, the identification of the user sending the request and the identification of the micro service module requested to be debugged, which are indicated by the obtained debugging request, are determined, the configuration file of the user is read according to the identification of the user, the configuration file comprises the user identification and the routing relation between the micro service module identification and the network address of the micro service instance, the debugging request is transmitted to the target micro service instance corresponding to the debugging request determined based on the configuration file of the user, the debugging operation is executed based on the target micro service instance, the micro service debugging based on the network address of the micro service instance is realized, the problem can be quickly positioned due to the fact that the debugging request can be directly connected to the network address of the micro service instance according to the identification of the user and the identification of the micro service module during debugging, and the debugging efficiency can be improved.
Drawings
Other features, objects and advantages of the present application will become more apparent upon reading of the following detailed description of non-limiting embodiments thereof, made with reference to the accompanying drawings in which:
FIG. 1 is an exemplary system architecture diagram to which embodiments of the present application may be applied;
FIG. 2 is a flow diagram for one embodiment of a method of debugging a microservice in accordance with the present application;
FIG. 3 is a flow diagram of another embodiment of a method of debugging a microservice in accordance with the present application;
FIG. 4 is a schematic diagram of the structure of the apparatus for debugging microservices of the present application;
FIG. 5 is a schematic block diagram of a computer system suitable for use in implementing an electronic device according to embodiments of the present application.
Detailed Description
The present application will be described in further detail with reference to the following drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the relevant invention and not restrictive of the invention. It should be noted that, for convenience of description, only the portions related to the related invention are shown in the drawings.
It should be noted that the embodiments and features of the embodiments in the present application may be combined with each other without conflict. The present application will be described in detail below with reference to the embodiments with reference to the attached drawings.
Fig. 1 illustrates an exemplary system architecture 100 to which the method of debugging a microservice or the apparatus for debugging a microservice of the present application may be applied.
As shown in fig. 1, system architecture 100 may include commissioning devices 101, 102, 103, network 104, and server 105. Network 104 is used to provide a medium for communication links between commissioning devices 101, 102, 103 and server 105. Network 104 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.
The server 105 may be a server that provides micro-service deployment and debugging services for the debugging devices 101, 102, and 103, and the server 105 may parse micro-service deployment/debugging requests sent by the debugging devices 101, 102, and 103, locate corresponding micro-service instances according to a parsing result, transmit debugging data to the corresponding micro-service instances to perform debugging operations, and then return the debugging results to the debugging devices 101, 102, and 103.
The server 105 may be a cloud server based on cloud computing, which may provide a runtime environment for the microservice, providing underlying data support. A plurality of micro-services can be deployed in the cloud server, and the micro-services in the cloud server can share the bottom data provided by the operating environment.
It should be noted that the method for debugging the micro service provided in the embodiment of the present application may be executed by the server 105, and accordingly, an apparatus for debugging the micro service may be disposed in the server 105.
The server may be hardware or software. When the server is hardware, it may be implemented as a distributed server cluster formed by multiple servers, or may be implemented as a single server. When the server is software, it may be implemented as multiple pieces of software or software modules (e.g., multiple software modules for providing distributed services), or as a single piece of software or software module. And is not particularly limited herein.
It should be understood that the number of terminal devices, networks, servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, servers, as desired for implementation.
With continued reference to FIG. 2, a flow 200 of one embodiment of a method of debugging a microservice in accordance with the present application is illustrated. The method for debugging the microservice comprises the following steps:
In this embodiment, an executing agent of a method of debugging a microservice (e.g., server 105 shown in FIG. 1) may obtain a debug request. Here, the micro-service is a tiny service module, and may be a function set of a minimum amount perceivable by a user in a systematized service, for example, a shopping cart module in an online shopping system, a harvest address module of the user, a logistics state module of an order, and so on.
The debugging request can be a request for debugging the functions of the micro-service, which is sent by a developer through a debugging client on the terminal device or a debugging device for debugging the micro-service. The terminal device and the debugging device can be provided with a client connected to a deployment/debugging platform provided by the cloud server, developers can start a debugging program of the micro-service through the client, specifically can select an identifier of a debugged micro-service module after logging in, and the client can generate a debugging request according to the operation of starting the micro-service debugging program by a user.
In a specific scenario, a developer may access the cloud service platform through a browser, for example, through a website of the cloud service platformwww.xxx.comA cloud server is accessed. A micro-service requiring debugging may be selected in the cloud service platform, for example, a micro-service module identified as service1, a debugging request including the identification of the micro-service module may be generated and issued to the cloud server, for example, access to the micro-service module through debug. That is, a request can be made through httpA debug request is issued.
The execution subject (i.e. the accessed cloud server) may receive a debugging request sent by the terminal device or the debugging device, and parse the identifier of the micro service module requested to be debugged from the debugging request. In this embodiment, the debugging request may further include an identifier of the user who sends the request, where the identifier of the user who sends the request is used to identify an identity of a developer who executes debugging, and may be determined by login information submitted by the developer when logging in the cloud service platform. Thus, when accessing the micro service module service1, a link address containing a user identification, such as user1.debug. www. xxx. com/api. service1, can be directly entered in the address bar of the browser, where user1 is the user identification of the developer. From this link address, the identity service1 of the microservice requested to debug, and the identity use1 of the requesting user, can be identified.
In some optional implementations of this embodiment, the identifier of the requesting user supported by the obtained debugging request may be determined as follows: acquiring a request identifier distributed for the debugging request, and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier to be used as the identifier of the user sending the request.
Specifically, after the request is issued, each request may be assigned a unique request identification, which corresponds one-to-one to the identification of the user issuing the request. After the request identity is assigned, the correspondence between the request identity and the identity of the user may be saved to a database. After the debugging request is obtained, the request identifier of the request can be obtained, and the user identifier corresponding to the request identifier is found out based on the corresponding relationship between the preset request identifier and the user identifier stored in the database and is used as the identifier of the user sending the debugging request.
In an actual scenario, the user may be identified from the user's debugging request. The network access layer at the front end (i.e. the layer closest to the debugging device or the terminal device where the browser is located) may assign a request identification to each request, which may run through the call chain of the entire request. When the network access layer requests a backend service through an API (Application Programming Interface) gateway, for example, when the microservice module service1 is forwarded to the microservice module service2 through the API gateway, a user identifier when accessing a cloud service through the network access layer may be queried through the request identifier.
The user's profile may be stored in the database in advance in association with the user's identification. After determining the identity of the requesting user, the user's profile may be queried in a database based on the user's identity. The user's profile may include a routing relationship between the user identification and the microservice module identification and the network address of the microservice instance.
In this embodiment, the network address of the instance of the micro service module corresponding to the user, that is, the network address of the micro service instance, may be configured in advance. The user may configure a domain name for the microservice embodiment and associate the domain name with the user's identity. Alternatively, the user's identity may be set in a field of the domain name, for example in a field used to characterize a "path" or "query". The execution main body can construct a corresponding relation between the domain name of the micro service instance, the identification of the user and the identification of the micro service module according to the configuration of the user, and the corresponding relation between the domain name of the micro service instance, the identification of the user and the identification of the micro service module is used as a routing relation between the user identification, the identification of the micro service module and the network address of the micro service instance, and the routing relation is stored in a database. The executing agent may analyze the Domain Name of the micro service instance configured by the user through a DNS (Domain Name System), that is, associate the Domain Name of the micro service instance configured by the user with a corresponding IP (Internet Protocol) address. Thus, the network address of the micro-service instance can be accessed through the domain name corresponding to the micro-service instance.
After the configuration file of the user sending the request is queried, the debug request may be forwarded to the network address of the micro service instance (i.e., the target micro service) corresponding to the identifier of the user and the identifier of the micro service module determined in step 201 according to the routing relationship among the user identifier in the configuration file, the identifier of the micro service module, and the network address of the micro service instance, so that a connection between the client sending the request and the network address of the target micro service may be established. And then, according to the debugging operation of the user at the client, sending the corresponding debugging data to the network address of the target micro-service instance, thereby executing the debugging operation on the micro-service module.
The user can debug based on JDWP (Java Platform debug Architecture). And a debugging program can be established through an application program interface provided by JDWP, and related data of the debugging program is sent to a network address of a target micro-service instance, so that the micro-service module is debugged.
The method for debugging the micro service according to the embodiment of the application determines the identifier of a user sending a request and the identifier of a micro service module requested to be debugged, which are indicated by an acquired debugging request, reads a configuration file of the user according to the identifier of the user, wherein the configuration file comprises the user identifier and a routing relation between the identifier of the micro service module and a network address of the micro service instance, and then forwards the debugging request to a target micro service instance corresponding to the debugging request determined based on the configuration file of the user, so that the micro service debugging based on the network address of the micro service instance is realized.
In some optional implementations of this embodiment, the method for debugging a microservice may further include a step of deploying a microservice module. The step of deploying the micro service module may specifically include: when the micro service module is deployed, a domain name generated by the identification of the user and the identification of the micro service module is created for the micro service instance deployed by the user, the created domain name is mapped to the network address of the micro service instance deployed by the user, and the created domain name is stored in the configuration file of the user.
Specifically, when the micro service module is deployed in the cloud service platform, the micro service instance of the micro service module may be started, that is, a thread is started to run an executable file (e.g., a source code file) that implements a function of the micro service module, and a domain name may be configured for the micro service instance, where the domain name may be generated by an identifier of a user deploying the micro service and an identifier of the micro service module, for example, the identifier of the micro service module and the identifier of the user may be combined, and a standard domain name field may be added to generate the domain name of the micro service instance. The domain name for an exemplary microservice instance is:http://user1.service1wherein, the user1 and the service1 are the identifier of the user and the identifier of the micro service module, respectively, and the configuration file of the user may further include domain names of other micro services deployed by the user, for example, the domain names of other micro services deployed by the userhttp://user1.service2The domain name of the microservice instance configured for microservice module service2 for user1. Then, a DNS server of a physical machine on which the cloud service is deployed may be set as a DNS service discovery component, and the domain name of the micro service instance is mapped to the network address of the micro service instance deployed by the user through the DNS service discovery component. Thus, in step 202, the user's profile may be queried according to the user's identification, and then the network address corresponding to the micro-service instance of the debugged micro-service may be extracted from the user's profile. The debug request may be forwarded to a network address corresponding to the micro-service instance at step 203.
The domain name containing the user identification and the micro-service module identification is created for the user, and the domain name is mapped to the network address of the micro-service instance indicated by the micro-service module identification, so that the configuration file of the user is generated, different micro-service instances can be accessed through different domain names on an http layer, a fussy positioning process of the micro-service instance is shielded, and problem positioning in a debugging process is accelerated.
In some optional implementations of this embodiment, step 203 may be performed as follows: searching out the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged according to the configuration file of the user; and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request. Specifically, a domain name including the identifier of the user and the identifier of the requested micro service module may be found in the configuration file of the user, the domain name is mapped to the network address of the corresponding micro service instance through the DNS service discovery component, or the network address to which the domain name including the identifier of the user and the identifier of the requested micro service module is mapped is directly found in the configuration file of the user, and the debugging request is linked to the network address of the micro service instance, so that the user can access the network address of the micro service instance, and can further perform the debugging operation, and transmit the relevant data of the debugging operation to the network address of the started micro service instance to obtain the debugging result.
Further, the method for debugging the microservice may further include: a microservice instance is initiated within the container. An optional method for starting up a micro-service instance in a container is as follows: and acquiring a program package of the compiled micro service module and running the program package in the started container. The user can start the container at the client, when the container is started, the version of the program package of the micro service module can be specified, then the program package of the compiled micro service module is continuously downloaded from the server, the downloaded program package is uploaded to the started container, and the acquired program package is operated in the container to start the micro service instance.
Another alternative method for initiating a microservice instance in a container includes performing the following operations in the container: the method comprises the steps of obtaining a patch file of a micro-service module uploaded by a client sending a debugging request, obtaining a stored program file of the micro-service module, applying the patch file of the micro-service module in the program file of the micro-service module, compiling the program file after applying the patch file to generate a program package, and operating the generated program package. Here, the patch file is generated from the difference between the program files of the client local and the server, that is, the difference between the code of the client local implementing the micro service module function and the code of the server implementing the micro service module. The patch file can be uploaded to the inside of the container through the client, the inside of the container can synchronize the program files of the micro-service modules stored in the server, and then the patch file can be applied to the synchronized program files of the micro-service modules, so that the program files of the micro-service modules in the container are consistent with the local program files of the client. Then, the compiling instruction can be started in the container, a program package of the micro service module is generated, and the micro service instance can be started in the container by running the program package.
By starting the micro-service instance in the container, an isolated operating environment can be allocated to the micro-service, so that micro-service instances with different port numbers and different network addresses do not conflict with each other, and external access can be isolated in a physical machine where the container is located. The safety and the usability of the cloud service are improved. Moreover, each micro-service instance is deployed and operated in the container environment, so that debugging of different micro-services in the debugging process is independent of deployment/debugging of other micro-services, codes do not need to be issued and developers of other micro-service modules do not need to check during development, and the codes are directly issued after development, deployment and debugging, and development efficiency can be greatly improved.
Further, when generating the configuration file of the user, the user may deploy the micro service instance of the user, and may link the micro service of the user to the micro service instances of other users. The example micro service instance service1 is an example of a micro service module service deployed by a user1, and the user2 may also configure that the micro service module service is turned to a micro service instance service1 deployed by a user1, so that the configuration file of the user2 stores the identification of the user2 and the identification of the micro service module service and the routing relationship of the micro service instance service 1. Thus, after user2 issues a debug request, the debug request may be forwarded to microservice instance service1 deployed by user1, i.e., linking the microservice to microservice instances of other users.
The user may also use public instances in the cloud service environment when generating the user's profile. The cloud service environment is also provided with a public instance based on operation on bottom data, for example, the public instance based on operation on a CPU and a memory resource, the public instance in the cloud service environment can be used as a micro service instance of a public micro service module, a routing relationship between an identifier of a user and an identifier of the public micro service module and a network address of the public instance is stored in a configuration file of the user, and for example, a domain name of each micro service instance can be generated. In this way, based on the user's configuration file, the user's debugging request can be diverted to the user's own deployed microservice instance, other user deployed microservice instances, or public instances. In this way, the access of the user to the micro service instance inside the container and the access of the common instance outside the container can be supported, and the mixing of different operation environments is realized.
Usually, the debugging environment is different from the actual operation environment, and the method can avoid the influence caused by the difference between the debugging environment and the actual operation environment. For example, when the method is applied to a function test in a product pre-online link, a micro-service module corresponding to the function can be deployed in a container mode by using the method, a micro-service instance of the micro-service module is operated in the container, the container environment is fused with the original physical environment, namely, the existing bottom data and resources of cloud computing are utilized to support the micro-service deployed in the container environment, a specific operation environment for deploying the micro-service module is not required to be created, and the micro-service deployment/debugging cost can be effectively reduced,
with continued reference to FIG. 3, a flowchart diagram of another embodiment of a method of debugging a microservice in accordance with the present application is shown. As shown in fig. 3, a flow 300 of the method for debugging a microservice according to the embodiment may include the following steps:
In this embodiment, for a remote debugging scenario, a proxy (proxy) may be started locally at a client, and a connection is established between the proxy and an execution subject of the method for debugging the microservice (i.e., a physical machine of the remote debugging environment). The execution main body may be disposed with a module for executing the debugging agent service function, and the module for executing the debugging agent function may obtain a debugging request for debugging the microservice. The debug request may include a user token (token). After logging in the cloud service platform, the user can obtain a user token returned by the cloud server, and the token can contain the user identification, the token valid time and the like.
In this embodiment, whether the user sending the debugging request is a valid user may be determined based on the obtained user token, and specifically, whether the user token is valid may be determined. For example, it may be determined whether the user token exists in the data table, and it may also be determined whether the user token has expired, thereby determining whether the user has the right to debug the microservice.
If the authentication is passed, that is, it is determined that the user has the right to debug the micro service, the execution main body may parse the identifier of the micro service module requested to be debugged from the debug request obtained in step 301. In this embodiment, the debugging request may further include an identifier of the user who sends the request, where the identifier of the user who sends the request is used to identify an identity of a developer who performs debugging, and may be determined by login information submitted by the developer when logging in the cloud service platform. Thus, when accessing the micro service module service1, a link address containing a user identification, such as user1.debug. www. xxx. com/api. service1, can be directly entered in the address bar of the browser, where user1 is the user identification of the developer. From this link address, the identity service1 of the microservice requested to debug, and the identity use1 of the requesting user, can be identified.
In some optional implementations of this embodiment, the identifier of the requesting user supported by the obtained debugging request may be determined as follows: acquiring a request identifier distributed for the debugging request, and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier to be used as the identifier of the user sending the request.
The user's profile may be stored in the database in advance in association with the user's identification. After determining the identity of the requesting user, the user's profile may be queried in a database based on the user's identity. The user's profile may include a routing relationship between the user identification and the microservice module identification and the network address of the microservice instance.
After the configuration file of the user sending the request is queried, the debug request may be forwarded to the network address of the micro service instance (i.e., the target micro service) corresponding to the identifier of the user and the identifier of the micro service module determined in step 303 according to the routing relationship among the user identifier in the configuration file, the identifier of the micro service module, and the network address of the micro service instance, so that a connection between the client sending the request and the network address of the target micro service may be established. And then, according to the debugging operation of the user at the client, sending the corresponding debugging data to the network address of the target micro-service instance, thereby executing the debugging operation on the micro-service module.
The above steps 304 and 305 are respectively consistent with the steps 202 and 203 of the foregoing embodiment, and the optional implementation manner described above for the micro service debugging method flow 200 is also applicable to the micro service debugging method flow 300 of the present embodiment, which is not described herein again.
As can be seen from fig. 3, the method for debugging microservice according to the embodiment adds a step of obtaining a debugging request including a user token by a proxy and authenticating based on the user token, thereby implementing remote debugging. When the containerized micro-service deployment scene of the application is used, because the container does not provide an access port and a debugging port for an external environment, the micro-service instance in the container can be accessed by establishing connection with a physical machine of the debugging environment through an agent.
With further reference to fig. 4, as an implementation of the methods shown in the above-mentioned figures, the present application provides an embodiment of an apparatus for debugging microservices, where the embodiment of the apparatus corresponds to the embodiment of the method shown in fig. 2 and fig. 3, and the apparatus may be applied to various electronic devices in particular.
As shown in fig. 4, the apparatus 400 for debugging microservice of the present embodiment includes: a determination unit 401, a reading unit 402 and a forwarding unit 403. Wherein the determining unit 401 is configured to determine an identification of the requesting user indicated by the acquired debugging request, an identification of the micro service module requested to be debugged; the reading unit 402 is configured to read a configuration file of the user according to the user identifier, where the configuration file includes a user identifier and a routing relationship between the micro service module identifier and the network address of the micro service instance; the forwarding unit 403 is configured to forward the debug request to a target micro-service instance corresponding to the debug request determined based on the user's configuration file, and perform a debug operation based on the target micro-service instance.
In some embodiments, the apparatus 400 may further include: the deployment unit is configured to create a domain name generated by the user identifier and the micro service module identifier for the micro service instance deployed by the user when the micro service module is deployed, map the created domain name to the network address of the micro service instance deployed by the user, and store the domain name in the configuration file of the user.
In some embodiments, the forwarding unit 403 may be further configured to: searching out the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged according to the configuration file of the user; and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request.
In some embodiments, the apparatus 400 may further include: an initiating unit configured to initiate a microservice instance within a container as follows: acquiring a program package of the compiled micro service module and operating the program package in a container; or performing the following operations in the container: the method comprises the steps of obtaining a patch file of a micro-service module uploaded by a client sending a debugging request, obtaining a stored program file of the micro-service module, applying the patch file of the micro-service module in the program file of the micro-service module, compiling the program file after applying the patch file to generate a program package, and operating the generated program package.
In some embodiments, the determining unit 401 may be further configured to determine the identity of the requesting user indicated by the obtained debugging request as follows: acquiring a request identifier distributed for a debugging request; and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier, wherein the user identifier is used as the identifier of the user sending the request.
In some embodiments, the apparatus 400 may further include: a connection unit configured to acquire, by proxy, a debug request for debugging the microservice, the debug request including a user token, before determining an identification of a requesting user indicated by the acquired debug request; an authentication unit configured to authenticate a user who issued a debugging request based on a user token; and the determining unit 401 may be further configured to determine, in response to the authentication passing, an identification of the requesting user indicated by the acquired debugging request, and an identification of the micro service module requested to be debugged.
It should be understood that the elements recited in apparatus 400 correspond to various steps in the methods described with reference to fig. 2 and 3. Thus, the operations and features described above for the method are equally applicable to the apparatus 400 and the units included therein, and are not described in detail here.
The apparatus 400 for debugging micro-services according to the above embodiment of the present application determines, by the determining unit, the identifier of the user who has issued the request and the identifier of the micro-service module that is requested to be debugged, the reading unit reads the configuration file of the user according to the identifier of the user, the configuration file includes the user identifier and the routing relationship between the identifier of the micro-service module and the network address of the micro-service instance, the forwarding unit forwards the debug request to the target micro-service instance corresponding to the debug request determined based on the configuration file of the user, executes the debug operation based on the target micro-service instance, and implements the micro-service debug based on the network address of the micro-service instance, during debugging, the micro service module can be directly connected to the network address of the micro service instance according to the identification of the user and the identification of the micro service module, so that the problem can be quickly positioned, and the debugging efficiency can be improved.
Referring now to FIG. 5, shown is a block diagram of a computer system 500 suitable for use in implementing an electronic device of an embodiment of the present application. The electronic device shown in fig. 5 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present application.
As shown in fig. 5, the computer system 500 includes a Central Processing Unit (CPU)501 that can perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM)502 or a program loaded from a storage section 508 into a Random Access Memory (RAM) 503. In the RAM 503, various programs and data necessary for the operation of the computer system 500 are also stored. The CPU 501, ROM 502, and RAM 503 are connected to each other via a bus 504. An input/output (I/O) interface 505 is also connected to bus 504.
The following components are connected to the I/O interface 505: an input portion 506 including a keyboard, a mouse, and the like; an output portion 507 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage portion 508 including a hard disk and the like; and a communication section 509 including a network interface card such as a LAN card, a modem, or the like. The communication section 509 performs communication processing via a network such as the internet. The driver 510 is also connected to the I/O interface 505 as necessary. A removable medium 511 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 510 as necessary, so that a computer program read out therefrom is mounted into the storage section 508 as necessary.
In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method illustrated in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network through the communication section 509, and/or installed from the removable medium 511. The computer program performs the above-described functions defined in the method of the present application when executed by the Central Processing Unit (CPU) 501. Note that the computer readable medium of the present application can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present application, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In this application, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.
Computer program code for carrying out operations for aspects of the present application may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C + +, or the like, as well as conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).
The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The units described in the embodiments of the present application may be implemented by software or hardware. The described units may also be provided in a processor, and may be described as: a processor includes a determination unit, a reading unit, and a forwarding unit. Where the names of these elements do not in some cases constitute a limitation on the elements themselves, for example, the retrieval element may also be described as an "element that determines the identity of the requesting user indicated by the retrieved debug request, the identity of the microservice module requested to debug".
As another aspect, the present application also provides a computer-readable medium, which may be contained in the apparatus described in the above embodiments; or may be present separately and not assembled into the device. The computer readable medium carries one or more programs which, when executed by the apparatus, cause the apparatus to: determining the identification of a user sending a request and the identification of a micro service module requested to be debugged, which are indicated by the obtained debugging request; reading a configuration file of a user according to the identification of the user, wherein the configuration file comprises the user identification and a routing relation between the micro-service module identification and the network address of the micro-service instance; and forwarding the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and executing debugging operation based on the target micro-service instance.
The above description is only a preferred embodiment of the application and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the invention herein disclosed is not limited to the particular combination of features described above, but also encompasses other arrangements formed by any combination of the above features or their equivalents without departing from the spirit of the invention. For example, the above features may be replaced with (but not limited to) features having similar functions disclosed in the present application.
Claims (14)
1. A method of debugging a microservice, comprising:
determining an identifier of a user sending a request and an identifier of a micro service module requested to be debugged, wherein the identifier of the user is used for identifying the identity of a developer executing debugging and can be determined by login information submitted by the developer when logging in a cloud service platform;
reading a configuration file of the user according to the identification of the user, wherein the configuration file comprises a user identification and a routing relation between the micro service module identification and the network address of the micro service instance;
and forwarding the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and executing debugging operation based on the target micro-service instance.
2. The method of claim 1, wherein the method further comprises:
when the micro service module is deployed, a domain name generated by the identification of the user and the identification of the micro service module is created for the micro service instance deployed by the user, the created domain name is mapped to the network address of the micro service instance deployed by the user, and the domain name is stored in the configuration file of the user.
3. The method of claim 1, wherein forwarding the debug request to a target microservice instance corresponding to the debug request determined based on the user's profile, and performing a debug operation based on the target microservice instance comprises:
finding out the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged according to the configuration file of the user;
and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request.
4. The method of claim 3, wherein the method further comprises:
initiating a microservice instance within a container, comprising:
acquiring a program package of a compiled micro service module and operating the program package in a container; or
Performing the following operations within the container: the method comprises the steps of obtaining a patch file of a micro service module uploaded by a client sending a debugging request, obtaining a stored program file of the micro service module, applying the patch file of the micro service module in the program file of the micro service module, compiling the program file after applying the patch file to generate a program package, and operating the generated program package.
5. The method of claim 1, wherein the determining an identity of the requesting user indicated by the obtained debug request comprises:
acquiring a request identifier distributed for the debugging request;
and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier, wherein the user identifier is used as the identifier of the user sending the request.
6. The method of any of claims 1-5, wherein prior to determining the identity of the requesting user indicated by the retrieved debug request, the method further comprises:
acquiring a debugging request for debugging the microservice through an agent, wherein the debugging request comprises a user token;
authenticating a user who sends a debugging request based on the user token; and
the determining the identification of the requesting user and the identification of the micro service module requested to be debugged, which are indicated by the obtained debugging request, includes:
and if the authentication is passed, determining the identification of the user sending the request and the identification of the micro service module requested to be debugged, which are indicated by the obtained debugging request.
7. An apparatus to debug a microservice, comprising:
the determining unit is configured to determine an identification of a user sending a request and an identification of a micro service module requested to be debugged, wherein the identification of the user is used for identifying the identity of a developer executing debugging and can be determined through login information submitted by the developer when the developer logs in the cloud service platform;
the reading unit is configured to read a configuration file of the user according to the identification of the user, wherein the configuration file comprises a user identification and a routing relation between a micro service module identification and a network address of a micro service instance;
and the forwarding unit is configured to forward the debugging request to a target micro-service instance corresponding to the debugging request determined based on the configuration file of the user, and execute debugging operation based on the target micro-service instance.
8. The apparatus of claim 7, wherein the apparatus further comprises:
the deployment unit is configured to create a domain name generated by the user identifier and the micro service module identifier for the micro service instance deployed by the user when the micro service module is deployed, map the created domain name to the network address of the micro service instance deployed by the user, and store the domain name in the configuration file of the user.
9. The apparatus of claim 7, wherein the forwarding unit is further configured to:
finding out the network address of the target micro-service instance corresponding to the identification of the user and the identification of the micro-service module required to be debugged according to the configuration file of the user;
and linking the debugging request to the network address of the started target micro-service instance, and executing the debugging operation corresponding to the debugging request.
10. The apparatus of claim 9, wherein the apparatus further comprises:
a start unit configured to start a microservice instance within a container as follows:
acquiring a program package of a compiled micro service module and operating the program package in a container; or
Performing the following operations within the container: the method comprises the steps of obtaining a patch file of a micro service module uploaded by a client sending a debugging request, obtaining a stored program file of the micro service module, applying the patch file of the micro service module in the program file of the micro service module, compiling the program file after applying the patch file to generate a program package, and operating the generated program package.
11. The apparatus of claim 7, wherein the determining unit is further configured to determine the identity of the requesting user indicated by the obtained debug request as follows:
acquiring a request identifier distributed for the debugging request;
and determining a user identifier corresponding to the request identifier of the debugging request based on the corresponding relation between the preset request identifier and the user identifier, wherein the user identifier is used as the identifier of the user sending the request.
12. The apparatus of any of claims 7-11, wherein the apparatus further comprises:
a connection unit configured to acquire, by a proxy, a debug request for debugging the microservice, the debug request including a user token, before determining an identification of a requesting user indicated by the acquired debug request;
an authentication unit configured to authenticate a user issuing a debugging request based on the user token; and
the determining unit is further configured to determine, in response to the authentication passing, an identification of the requesting user indicated by the acquired commissioning request, an identification of the micro service module requested to be commissioned.
13. An electronic device, comprising:
one or more processors;
a storage device for storing one or more programs,
when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-6.
14. A computer-readable medium, on which a computer program is stored, wherein the program, when executed by a processor, implements the method of any one of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810819331.6A CN109150978B (en) | 2018-07-24 | 2018-07-24 | Method and device for debugging micro service |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810819331.6A CN109150978B (en) | 2018-07-24 | 2018-07-24 | Method and device for debugging micro service |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109150978A CN109150978A (en) | 2019-01-04 |
| CN109150978B true CN109150978B (en) | 2022-05-10 |
Family
ID=64797831
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810819331.6A Active CN109150978B (en) | 2018-07-24 | 2018-07-24 | Method and device for debugging micro service |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109150978B (en) |
Families Citing this family (17)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109831361B (en) * | 2019-02-28 | 2020-10-16 | 东软集团股份有限公司 | Distributed debugging method, system and device |
| CN110032392B (en) * | 2019-04-15 | 2023-05-09 | 杭州朗和科技有限公司 | Service management method and device, storage medium and electronic equipment |
| CN110489139A (en) * | 2019-07-03 | 2019-11-22 | 平安科技（深圳）有限公司 | A kind of real-time data processing method and its relevant device based on micro services |
| CN112416737B (en) * | 2019-08-21 | 2024-03-01 | 广州虎牙科技有限公司 | Container testing method, device, equipment and storage medium |
| CN110647469B (en) * | 2019-09-24 | 2023-09-08 | 广州荔支网络技术有限公司 | Micro-service testing method and device, computer equipment and storage medium |
| CN111274150B (en) * | 2020-02-07 | 2023-08-22 | 北京字节跳动网络技术有限公司 | Service instance access method and device and electronic equipment |
| CN111984309A (en) * | 2020-08-31 | 2020-11-24 | 北京达佳互联信息技术有限公司 | Service calling method, device, server and storage medium |
| CN112181439A (en) * | 2020-09-24 | 2021-01-05 | 中国建设银行股份有限公司 | Micro-service deployment method and device, electronic equipment and readable storage medium |
| CN112199288A (en) * | 2020-10-16 | 2021-01-08 | 深圳无域科技技术有限公司 | Distributed test environment deployment method and system |
| CN112929230B (en) * | 2021-01-22 | 2022-09-06 | 中信银行股份有限公司 | Test processing method and device, electronic equipment and computer readable storage medium |
| CN113806104A (en) * | 2021-08-02 | 2021-12-17 | 北京房江湖科技有限公司 | Interface access request processing method, API gateway, server and system |
| CN114064475A (en) * | 2021-11-11 | 2022-02-18 | 中国联合网络通信集团有限公司 | Cloud native application testing method, device, equipment and storage medium |
| CN114615521B (en) * | 2022-03-10 | 2024-02-23 | 网易（杭州）网络有限公司 | Video processing method and device, computer readable storage medium and electronic equipment |
| CN114416224B (en) * | 2022-03-25 | 2022-07-12 | 共道网络科技有限公司 | Method and device for calling micro service under multi-micro service environment |
| CN114827674B (en) * | 2022-03-30 | 2023-09-05 | 北京奇艺世纪科技有限公司 | Network resource display method, device and system |
| US11943115B2 (en) * | 2022-04-05 | 2024-03-26 | International Business Machines Corporation | Locally debugging remote deployment of microservices |
| CN116112569B (en) * | 2023-02-23 | 2023-07-21 | 安超云软件有限公司 | Micro-service scheduling method and management system |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105959138A (en) * | 2016-04-29 | 2016-09-21 | 深圳前海大数点科技有限公司 | Micro-service dynamic disposition system and method based on cloud calculation |
| CN106844213A (en) * | 2017-01-21 | 2017-06-13 | 江苏千米网络科技股份有限公司 | A kind of front end method of testing and device |
| CN108073504A (en) * | 2016-11-17 | 2018-05-25 | 北京京东尚科信息技术有限公司 | For debugging the method, apparatus of distributed system and debugging system |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9979799B2 (en) * | 2015-04-27 | 2018-05-22 | Lenovo Enterprise Solutions (Singapore) Pte. Ltd. | Impersonating a specific physical hardware configuration on a standard server |
| CN106131233B (en) * | 2016-06-20 | 2019-03-15 | 腾讯科技（深圳）有限公司 | Realize the method, apparatus and system of the access of database multipath |
| US10389602B2 (en) * | 2016-12-05 | 2019-08-20 | General Electric Company | Automated feature deployment for active analytics microservices |
-
2018
- 2018-07-24 CN CN201810819331.6A patent/CN109150978B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105959138A (en) * | 2016-04-29 | 2016-09-21 | 深圳前海大数点科技有限公司 | Micro-service dynamic disposition system and method based on cloud calculation |
| CN108073504A (en) * | 2016-11-17 | 2018-05-25 | 北京京东尚科信息技术有限公司 | For debugging the method, apparatus of distributed system and debugging system |
| CN106844213A (en) * | 2017-01-21 | 2017-06-13 | 江苏千米网络科技股份有限公司 | A kind of front end method of testing and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109150978A (en) | 2019-01-04 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109150978B (en) | Method and device for debugging micro service | |
| JP6935496B2 (en) | Management of messaging protocol communication | |
| CN111062024B (en) | Application login method and device | |
| CN110505162B (en) | Message transmission method and device and electronic equipment | |
| CN109388626B (en) | Method and apparatus for assigning numbers to services | |
| US9590859B2 (en) | Discovering resources of a distributed computing environment | |
| CN110830374B (en) | Method and device for gray level release based on SDK | |
| CN109815107B (en) | Method and device for automatic testing | |
| CN110377440B (en) | Information processing method and device | |
| CN109542862B (en) | Method, device and system for controlling mounting of file system | |
| CN113495921A (en) | Routing method and device of database cluster | |
| CN111045833A (en) | Interface calling method and device | |
| CN110580305A (en) | Method, apparatus, system, and medium for generating identifier | |
| CN112202744B (en) | Multi-system data communication method and device | |
| CN113360377B (en) | Test method and device | |
| CN113778499B (en) | Method, apparatus, device and computer readable medium for publishing services | |
| CN107181802B (en) | Intelligent hardware control method and device, server and storage medium | |
| CN110928594A (en) | Service development method and platform | |
| CN112929453A (en) | Method and device for sharing session data | |
| CN114125067A (en) | Front-end and back-end separated gray scale publishing method, front-end server and configuration server | |
| CN112422429B (en) | Data request processing method and device, storage medium and electronic equipment | |
| CN112860447A (en) | Interaction method and system between different applications | |
| US8880702B2 (en) | Provision of other than 1:1 resource mapping | |
| CN113765868B (en) | Service processing method and device | |
| CN111258560B (en) | Data storage device, system and method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |