CN112948248A - Method and device for debugging software in cloud computing service - Google Patents

Abstract

The embodiment of the application provides a method and a device for debugging software in cloud computing service, wherein the method comprises the following steps: the cloud service node receives a first service creation request sent by a client, the first service creation request comprises information of a target service to be created and a simulation identifier, the simulation identifier is used for identifying that the target service is used for software debugging, the cloud service node sends a second service creation request to a simulation resource pool node according to the simulation identifier, the cloud service node receives a second service creation response returned by the simulation resource pool node, the second service creation response is used for informing that the target service is successfully created, wherein resources allocated to the target service by the simulation resource pool node are simulation resources, and the cloud service node sends the first service creation response to the client. By setting the simulation resource pool node, the simulation resource pool node allocates simulation resources for the service for software debugging, and the waste of physical resources is avoided.

Description

Method and device for debugging software in cloud computing service

Technical Field

The present application relates to cloud computing technologies, and in particular, to a method and an apparatus for debugging software in a cloud computing service.

Background

Cloud computing (cloud computing) is an emerging computing model, which distributes computing tasks over a resource pool consisting of a large number of computing nodes, enabling various application systems to obtain computing power, storage space, and information services as needed. Due to the appearance of cloud computing, a new development direction is provided for data mining technologies and platforms, and a trend is to construct a new generation of data mining platform by combining virtualization, high expansion and high availability of cloud computing.

Under the trend of cloud computing, more and more users need to operate cloud computing services through Software Development Kits (SDKs) provided by cloud computing service providers, and the cloud computing services are services which are obtained through a network in an on-demand and easily-extensible manner. For example, when the client detects that the service response delay exceeds a threshold, the client invokes the SDK of the cloud computing service provider to dynamically create a new virtual machine, and deletes the virtual machine after the service meets a certain condition. At present, a developer needs to debug software in a software development process, and a cloud computing service provider can provide real resources for the developer to debug in the software debugging process. The real resources used in the debugging process incur a lot of expenses and result in a waste of resources.

Disclosure of Invention

The application provides a method and a device for debugging software in cloud computing service, which can avoid resource waste in the software debugging process.

A first aspect of the present application provides a method for debugging software in a cloud computing service, including:

the method comprises the steps that a cloud service node receives a first service creation request sent by a client, wherein the first service creation request comprises information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging;

the cloud service node sends a second service creation request to a simulation resource pool node according to the simulation identification, wherein the second service creation request comprises the information of the target service;

the cloud service node receives a second service creation response returned by the simulation resource pool node, wherein the second service creation response is used for notifying that the target service is successfully created, and resources allocated to the target service by the simulation resource pool node are simulation resources;

and the cloud service node sends a first service creation response to the client, wherein the first service creation response is used for notifying that the target service is successfully created.

In the method, the client carries the simulation identification in the first service creation request, so that the cloud service node sends the creation request of the target service to the simulation resource pool node according to the simulation identification, and the simulation resource pool node allocates simulation resources for the target service, thereby avoiding the waste of physical resources.

In an exemplary manner, after the cloud service node receives the second service creation response returned by the simulation resource pool node, the method further includes:

and the cloud service node stores the creation parameters of the target service to a resource database, wherein the creation parameters comprise information of a node where the resource used by the target service is located and information of the target service.

In another exemplary manner, before the cloud service node sends a service creation request to the simulation resource pool node according to the simulation identifier, the method further includes: and the cloud service node judges whether the first service creation request contains the simulation identification.

In yet another exemplary manner, the method further includes:

when the first service creation request does not comprise the simulation identification, the cloud service node sends the second service creation request to a physical resource pool node;

and the cloud service node receives the second service creation response sent by the physical resource pool node, wherein the second service creation response is sent after the physical resource pool node allocates physical resources for the target service.

In yet another exemplary manner, the method further includes:

the cloud service node acquires node information of resources used by the target service from the resource database;

when the node of the resource used by the target service is the simulation resource pool node, the cloud service node sends a service management request to the simulation resource pool node, wherein the service management request comprises identification information of the target service;

and the cloud service node receives a service management response sent by the simulation resource pool node, wherein the service management response comprises management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node.

A second aspect of the present application provides a method for debugging software in a cloud computing service, including:

the method comprises the steps that a simulation resource pool node receives a second service creation request sent by a cloud service node, wherein the second service creation request comprises information of a target service to be created;

the simulation resource pool node creates the target service according to the second service creation request, wherein the resources distributed by the simulation resource pool node for the target service are simulation resources;

and the simulation resource pool node sends a second service creation response to the cloud service node, wherein the second service creation response is used for notifying that the target service is successfully created.

In an exemplary manner, the method further comprises:

the simulation resource pool node receives a service management request sent by the cloud service node, wherein the service management request comprises identification information of the target service;

the simulation resource pool node inquires the information of the target service from the information of the locally stored service according to the identification information of the target service;

the simulation resource pool node generates management data according to the information of the target service;

and the simulation resource pool node sends a service management response to the cloud service node, wherein the service management response comprises the management data.

A third aspect of the present application provides a method for debugging software in a cloud computing service, including:

the method comprises the steps that a client receives parameters input by a user, wherein the parameters input by the user comprise information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging;

the client sends a first service creation request to a cloud service node, wherein the first service request comprises the information of the target service and the simulation identifier;

the client receives a first service creation response sent by the cloud service node, wherein the first service creation response is used for notifying that the target service is successfully created, and the resources of the target service are simulation resources.

A fourth aspect of the present application provides a cloud service node, including:

the system comprises a receiving module, a processing module and a debugging module, wherein the receiving module is used for receiving a first service creation request sent by a client, the first service creation request comprises information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging;

a resource scheduling module, configured to determine, according to the simulation identifier, that the second service creation request is sent to a simulation resource pool node, where the second service creation request includes information of the target service;

a sending module, configured to send the second service creation request to the simulation resource pool node;

the receiving module is further configured to receive a second service creation response returned by the simulation resource pool node, where the second service creation response is used to notify that the target service is successfully created, and a resource allocated to the target service by the simulation resource pool node is a simulation resource;

the sending module is further configured to send a first service creation response to the client, where the first service creation response is used to notify that the target service creation is successful.

In an exemplary manner, the node further includes:

and the resource database management module is used for storing the creation parameters of the target service to a resource database, wherein the creation parameters comprise the information of the node where the resource used by the target service is located and the information of the target service.

In another exemplary manner, the resource scheduling module is further configured to: and judging whether the first service creation request contains the simulation identification.

In another exemplary manner, the resource scheduling module is further configured to:

when the first service creation request does not include the simulation identification, determining to send the second service creation request to a physical resource pool node;

the sending module is further configured to send, by the service node, the second service creation request to the physical resource pool node;

the receiving module is further configured to receive the second service creation response sent by the physical resource pool node, where the second service creation response is sent by the physical resource pool node after allocating physical resources to the target service.

In another exemplary manner, the node further includes:

the resource database management module is also used for acquiring node information of resources used by the target service from the resource database;

the resource scheduling module is further configured to determine to send a service management request to the simulation resource pool node when the node of the resource used by the target service is the simulation resource pool node, where the service management request includes identification information of the target service;

the sending module is further configured to send the service management request to the simulation resource pool node;

the receiving module is further configured to receive a service management response sent by the simulation resource pool node, where the service management response includes management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node.

A fifth aspect of the present application provides a simulation resource pool node, including:

the receiving module is used for receiving a second service creation request sent by a cloud simulation resource pool node service node, wherein the second service creation request comprises information of a target service to be created;

a creating module, configured to create the target service according to the second service creation request, where the resource allocated to the target service by the simulation resource pool node is a simulation resource;

a sending module, configured to send a second service creation response to the cloud service node, where the second service creation response is used to notify that the target service creation is successful.

In an exemplary manner, the receiving module is further configured to: receiving a service management request sent by the cloud service node, wherein the service management request comprises identification information of the target service;

the node also comprises a query module, wherein the query module is used for querying the information of the target service from the information of the locally stored service according to the identification information of the target service;

the generating module is used for generating management data according to the information of the target service;

the sending module is further configured to send a service management response to the cloud service node, where the service management response includes the management data.

A sixth aspect of the present application provides a client, comprising:

the system comprises a receiving module, a debugging module and a display module, wherein the receiving module is used for receiving parameters input by a user, the parameters input by the user comprise information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging;

a generating module, configured to generate a first service creation request according to the parameter input by the user, where the first service request includes the information of the target service and the simulation identifier;

a sending module, configured to send the first service creation request to a cloud service node;

the receiving module is further configured to receive a first service creation response sent by the cloud service node, where the first service creation response is used to notify that the target service is successfully created, and a resource of the target service is a simulation resource.

A seventh aspect of the present application provides a computing device comprising: a storage unit to store instructions; and at least one processor coupled to the memory unit; wherein the instructions, when executed by the at least one processor, cause the processor to perform the method of the first or second or third aspect.

According to the method and the device for software debugging in the cloud computing service, the simulation resource pool nodes are arranged, the client carries the simulation identification in the first service creation request sent to the cloud service nodes, the cloud service nodes send the second service creation request to the simulation resource pool according to the simulation identification, the simulation resource pool nodes distribute simulation resources for the service for software debugging, and waste of physical resources is avoided.

Drawings

FIG. 1 is a schematic diagram of a conventional cloud computing service architecture;

FIG. 2 is a schematic diagram of a cloud computing service architecture suitable for use in the present application;

FIG. 3 is a physical hardware diagram of the cloud service node shown in FIG. 2;

fig. 4 is a flowchart of a method for debugging software in a cloud computing service according to an embodiment of the present application;

FIG. 5 is a schematic diagram of a software architecture of a cloud service node;

fig. 6 is a flowchart of a method for debugging software in a cloud computing service according to a second embodiment of the present application;

fig. 7 is a flowchart of a method for debugging software in a cloud computing service according to a third embodiment of the present application;

fig. 8 is a flowchart of a method for debugging software in a cloud computing service according to a fourth embodiment of the present application;

fig. 9 is a signaling flowchart of a method for debugging software in a cloud computing service according to a fifth embodiment of the present application;

fig. 10 is a signaling flowchart of a method for debugging software in a cloud computing service according to a sixth embodiment of the present application;

fig. 11 is a schematic structural diagram of a cloud service node according to a seventh embodiment of the present application;

fig. 12 is a schematic structural diagram of a simulation resource pool node according to an eighth embodiment of the present application;

fig. 13 is a schematic structural diagram of a client according to a ninth embodiment of the present application.

Detailed Description

The application provides a method for debugging Software in cloud computing Service, wherein the mode of the cloud computing Service can be Software as a Service (SaaS), Platform as a Service (PaaS), or Infrastructure as a Service (IaaS). Services provided by SaaS to tenants are applications that operators run on cloud computing infrastructure, and users can access through client interfaces, such as browsers, on various devices. The tenant does not need to manage or control any cloud computing infrastructure, including networks, servers, operating systems, storage, and the like. The PaaS provides services to tenants by deploying applications developed or purchased by development languages and tools (e.g., Java, python,. Net, etc.) provided by customers to the provider's cloud computing infrastructure, and the tenants do not need to manage or control the underlying cloud infrastructure, including networks, servers, operating systems, storage, etc., but the tenants can control the deployed applications and possibly the hosting environment in which the applications are run. The services provided by IaaS to tenants are the utilization of all computing infrastructure, including processors, memory, hard disks, networks, and other basic computing resources, and users can deploy and run arbitrary software, including operating systems and applications. Consumers do not manage or control any cloud computing infrastructure, but can select operating systems, select storage space, and deploy applications, and may also have the potential to gain control over limited network components (e.g., routers, firewalls, load balancers, etc.).

SaaS is a mode for providing software through the Internet, and a user can obtain required services through the Internet according to the actual requirements of the user. Rest is used as an implementation of Saas, has the advantages of light weight, easy understanding, semantization and the like, and the servitization and restation of a software system are easy for integration and communication among multiple systems in an enterprise. The algorithm capability provided by the cloud-based data mining platform is exposed to the outside in a service mode, the design concept of SaaS is met, the complexity of cloud computing programming can be shielded for common users, and meanwhile, different service systems can be conveniently called.

Fig. 1 is a schematic diagram of a conventional cloud computing service architecture, as shown in fig. 1, the architecture includes a client side, an Application Programming Interface (API) gateway, a cloud service layer, and a resource layer. The client side is composed of different client applications installed on the terminal device, the user performs cloud computing service through the client applications, and when the service needs to be created, the client applications generate SDK or Rest requests and send the SDK or Rest requests to the API gateway. The API gateway is used for processing a plurality of API groups, the API groups are a set of the same service API, one API group can be regarded as one service, and the API gateway sends the SDK or REST request to the corresponding cloud service in the cloud service layer. The cloud service layer provides various cloud services, the cloud services comprise a request scheduling module and a resource database, the request scheduling module is used for scheduling resources for the services and sending service requests to corresponding physical resource pools, and the resource database is used for storing resource information of the services. After receiving the SDK or Rest request, the cloud service determines the resources used by the service through a scheduling algorithm, and sends the service request to the corresponding physical resource pool, and each cloud service can communicate with all the physical resource pools. The resource layer comprises a plurality of physical resource pools (or resource pools), each physical resource pool comprises a virtualization interface and physical resources, and the virtualization interfaces are used for creating services in a virtualization mode and distributing the physical resources for the services. After determining the resources used by the service, the cloud service sends the SDK or Rest request to a corresponding physical resource pool, and the physical resource pool allocates physical resources for the service and returns a request response.

In the architecture shown in fig. 1, each cloud service may be located on different physical devices, or multiple cloud services may be located on the same physical device, and similarly, each physical resource pool may be located on different physical devices, or multiple physical resource pools may be located on the same physical device, or a cloud service and a physical resource pool are integrated on one device. The API gateway may be implemented by an independent physical device, or may be integrated with a physical device where any cloud service is located. The embodiment does not limit the physical form of the API, the cloud service, and the physical resource pool.

Fig. 2 is a schematic diagram of a cloud computing service architecture suitable for the present application, and as shown in fig. 2, compared with an existing cloud computing service architecture, the cloud computing service architecture of the present application adds a simulation resource pool, which is different from an existing physical resource pool, and includes a simulation module and simulation resources, where the simulation module has a similar function as a virtualization interface of the physical resource pool, is used for simulating a service creation process, and allocates the simulation resources to the created service, the simulation resources are not real physical resources, the simulation resources are one virtual resource, the virtual resource cannot be used for data processing, and the created service does not use the simulation resources. Since the simulation resources allocated by the simulation module for the service are not real physical resources, the service creation process is also referred to as a simulation creation process. The simulation resource pool occupies a certain resource, but the resource occupied by the simulation resource pool is far smaller than that occupied by a physical resource pool. Certainly, the number of the simulation resource pools is not limited to one, a plurality of simulation resource pools can be added, and each cloud service can communicate with the simulation resource pools.

The interface provided by the simulation resource pool is the same as the interface provided by the physical resource pool, so that the simulation resource pool is not different from the real resource pool in the view of the cloud service, and the format of the message transmitted between the cloud service and the simulation resource pool is the same as the format of the message transmitted between the cloud service and the physical resource pool. Correspondingly, the function of the resource scheduling module of the cloud service is also changed, the resource scheduling module is further used for judging whether the currently created service is used for software debugging, when the created service is used for software debugging, the creation request is sent to the simulation resource pool, and the simulation resource pool allocates simulation resources for the created service.

Fig. 3 is a physical hardware schematic diagram of the cloud service node shown in fig. 2, and as shown in fig. 3, the cloud service node may include a processing unit 11 and a communication interface 12, where the processing unit 11 is configured to execute functions defined by an operating system and various software programs running on the cloud service node, for example, various functions of the scheduling request module shown in fig. 2. The communication interface 12 is used for communication interaction with other devices, which may be clients, physical resource pool nodes, and emulated resource pool nodes. Optionally, the cloud service node may further include an input/output interface 13, where the input/output interface 13 is connected to an input/output device, and is configured to receive input information and output an operation result. The input/output interface 13 may be a mouse, a keyboard, a display, or an optical drive, etc. Optionally, the cloud service node may further include an auxiliary memory 14, which is also commonly referred to as an external memory, and a storage medium of the auxiliary memory 14 may be a magnetic medium (e.g., a floppy disk, a hard disk, a magnetic tape), an optical medium (e.g., an optical disk), or a semiconductor medium (e.g., a solid state disk), and the like. The processing unit 11 may have various specific implementation forms, for example, the processing unit 11 may include a processor 111 and a memory 112, the processor 111 performs related operations according to program units stored in the memory 112, the processor 111 may be a Central Processing Unit (CPU) or a Graphics Processing Unit (GPU), and the processor 111 may be a single-core processor or a multi-core processor. The processing unit 111 may also be implemented by using a logic device with built-in processing logic, such as a Field Programmable Gate Array (FPGA), a Digital Signal Processor (DSP), or the like. Moreover, FIG. 3 is merely an example of a physical server that may include more or fewer components than shown in FIG. 3, or have a different arrangement of components. The physical resource pool node, the simulation resource pool node, and the client shown in fig. 2 may also adopt the structure shown in fig. 3, which is not described herein again.

Based on the service architecture shown in fig. 2, a method for debugging software in a cloud computing service is provided in an embodiment of the present application, and fig. 4 is a flowchart of the method for debugging software in a cloud computing service provided in the embodiment of the present application, and as shown in fig. 4, the method provided in the embodiment includes the following steps:

step S101, a cloud service node receives a first service creation request sent by a client, wherein the first service creation request comprises information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging.

The cloud service node is a physical device running a certain cloud service, the first service creation request is sent to the cloud service node by a client through an API gateway, and the first service creation request may be an SDK request or a Rest request. When the target service to be created is used for software debugging, the first service creation request comprises the simulation identification, and when the target service is not used for software debugging, the first service creation request does not comprise the simulation identification. The emulation identification can be a resource type (resource type), for example, indicating that the service is used for software debugging when the resource type of the target service is fake. Of course, the simulation identifier may also be other identifiers, which is not limited in this embodiment.

The target service may be a virtual machine creation service, a storage resource creation service, a network resource creation service, a virtual machine monitoring service, and the like. The information of the target service comprises an identification of the target service and information of resources required by the target service, and the information of the resources required by the target service can be any one or more of the following information: the model or rate of a Central Processing Unit (CPU), the size of a memory, the size of a disk, the identification of a node where a resource is located, a bandwidth, a frequency, and the like.

Step S102, the cloud service node sends a second service creation request to the simulation resource pool node according to the simulation identification, wherein the second service creation request comprises information of the target service.

Optionally, after receiving the first service creation request, the cloud service node determines whether the first service creation request includes the simulation identifier, and when the first service creation request includes the simulation identifier, step S103 is executed.

Optionally, when the cloud service node determines that the first service creation request does not include the simulation identifier, the cloud service node sends a second service creation request to the physical resource pool node, the physical resource pool node creates the target service according to the second service creation request, the cloud service node receives a second service creation response sent by the physical resource pool node, and the second service creation response is sent after the physical resource pool node allocates physical resources to the target service. Different from the simulation resource pool, the resource allocated by the physical resource pool for the service is a real physical resource, and the process of creating the service by the physical resource pool is the same as that in the prior art, and is not described herein again.

Fig. 5 is a schematic diagram of a software structure of a cloud service node, as shown in fig. 5, the cloud service node includes a scheduling request interface, a resource pool filtering module, a resource capacity filter, a request identifier filter, a message forwarding module, and a resource database, the scheduling request interface is configured to receive a first service creation request, the resource capacity filter is configured to filter out a physical resource pool that does not satisfy resources required by a target service, the resource pool filter is configured to select one physical resource pool from a plurality of physical resource pools that satisfy resources required by the target service, the request identifier filter is a filter added in the present application, and is configured to filter out the physical resource pool when a simulation identifier exists in the first service creation request, and filter out the simulation resource pool when the simulation identifier does not exist in the first service creation request, and the message forwarding module is configured to send a message to the simulation resource pool or the physical resource pool, or receiving a message sent by the simulation resource pool or the physical resource pool.

Step S103, the cloud service node receives a second service creation response returned by the simulation resource pool node, and the resource allocated to the target service by the simulation resource pool node is a simulation resource.

And the simulation resource pool node creates the target service, returns a second service creation response after distributing the simulation resources for the target service, and the second service creation response is used for notifying that the target service is successfully created. Optionally, after receiving the second service creation response, the cloud service node stores a creation parameter of the target service to the resource database, where the creation parameter includes information of a node where a resource used by the target service is located and information of the target service. The resource database is used for storing the use condition of the resources in the resource pool, the number of the residual resources and the information of the resources used by the created service.

Step S104, the cloud service node sends a first service creation response to the client, and the first service creation response is used for notifying that the target service is successfully created.

In this embodiment, the cloud service node and the client view that the service created by the simulation resource pool is not different from the service created by the physical resource pool, and since the target service created by the simulation resource pool is used for software debugging and the resource of the service is not needed to be used in the software debugging process, the simulation resource is allocated to the service for debugging, and the debugging process and the debugging result are not affected. In the prior art, physical resources are allocated to the service for debugging, and the physical resources are not used, thereby causing resource waste. And physical resources are limited, and even a situation may occur where the resources are empty, so that the service cannot be debugged due to a shortage of resources.

In this embodiment, a cloud service node receives a first service creation request sent by a client, where the first service creation request includes information of a target service to be created and a simulation identifier, the simulation identifier is used to identify the target service for software debugging, the cloud service node sends a second service creation request to a simulation resource pool node according to the simulation identifier, the cloud service node receives a second service creation response returned by the simulation resource pool node, and the second service creation response is used to notify that the target service is successfully created, where a resource allocated by the simulation resource pool node for the target service is a simulation resource, and the cloud service node sends the first service creation response to the client. The simulation resource pool node avoids the waste of physical resources by distributing simulation resources for the service for software debugging.

On the basis of the first embodiment, fig. 6 is a flowchart of a method for debugging software in a cloud computing service provided by the second embodiment of the present application, and as shown in fig. 6, the method provided by the present embodiment includes the following steps:

step S201, the cloud service node acquires node information of resources used by the target service from a resource database.

The cloud service node in the first embodiment is used for creating a service, the cloud service node in the first embodiment is used for monitoring a service, the two services are different services, and the two services can be integrated on one cloud service node. When the target service needs to be monitored, the cloud service node requests the resource database to acquire node information of resources used by the target service.

Step S202, when the node of the resource used by the target service is a simulation resource pool node, the cloud service node sends a service management request to the simulation resource pool node, wherein the service management request comprises identification information of the target service.

The node of the resource used by the target service may be a simulation resource pool node or a physical resource pool node, when the node of the resource used by the target service is the simulation resource pool node, the cloud service node sends a service management request to the simulation resource pool node, and when the node of the resource used by the target service is the physical resource pool node, the cloud service node sends a service management request to the physical resource pool node. The cloud service node sends the same service management request to the simulation resource pool node and the physical resource pool node, and the service management request comprises identification information of a target service so as to monitor which service is monitored through the simulation resource pool node or the physical resource pool node.

Step S203, the cloud service node receives a service management response sent by the simulation resource pool node, where the service management response includes management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node.

After the simulation resource pool node receives the service management request, because the simulation resource pool does not allocate physical resources to the target service, management data such as the use condition of the physical resources cannot be acquired, and the simulation resource pool node can only generate some random data as the management data of the target service for the target service. And the physical resource pool node can acquire management data such as the use condition of the physical resource through the virtualization interface according to the service management request and return the management data to the cloud service node. After receiving the management data of the target service, the cloud service node may store the management data of the target service in the resource database.

In this embodiment, a cloud service node obtains node information of a resource used by a target service from a resource database, and when a node of the resource used by the target service is a simulation resource pool node, the cloud service node sends a service management request to the simulation resource pool node, where the service management request includes identification information of the target service, the cloud service node receives a service management response sent by the simulation resource pool node, the service management response includes management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node. The method makes it possible for the emulated resource pool node to also simulate the monitoring of the target service.

Fig. 7 is a flowchart of a method for debugging software in a cloud computing service according to a third embodiment of the present application, where the method is described in the present embodiment from the perspective of a simulation resource pool, and as shown in fig. 7, the method provided in the present embodiment includes the following steps:

step S301, the simulation resource pool node receives a second service creation request sent by the cloud service node, where the second service creation request includes information of a target service to be created.

The interface provided by the simulation resource pool node is the same as the interface provided by the physical resource pool node, the information of the target service includes the identifier of the target service and the information of the resource required by the target service, and the information of the resource required by the target service may be any one or more of the following information: the type or speed of the CPU, the size of the memory, the size of the disk, the identification of the node where the resource is located, the bandwidth, the frequency and the like.

Step S302, the simulation resource pool node creates a target service, wherein the resource distributed by the simulation resource pool node for the target service is a simulation resource.

After receiving the second service creation request, the simulation resource pool node allocates resources for the target service, which is different from the operation of the physical resource pool node, and the resources allocated for the target service by the simulation resource pool node are simulation resources which are virtual resources, and the simulation resources cannot be used for data processing. And after the simulation resource pool node allocates resources for the target service, saving the information of the simulation resources allocated for the target service.

Step S303, the simulation resource pool node sends a second service creation response to the cloud service node, and the second service creation response is used for notifying that the target service is successfully created.

And after receiving the second service creation response, the cloud service node determines that the target service is successfully created, and for the cloud service node, the simulation resource pool node and the physical resource pool node are the same type of node and the processing operation of the simulation resource pool node and the physical resource pool node is the same.

Optionally, the simulation resource pool node further receives a service management request sent by the cloud service node, where the service management request includes identification information of the target service, the simulation resource pool node queries information of the target service from information of the locally stored service according to the identification information of the target service, generates management data according to the information of the target service, and sends a service management response to the cloud service node, where the service management response includes management data. The management data generated by the simulation resource pool node is not the real management data of the target service but random data to simulate the management of the target service.

In this embodiment, the simulation resource pool node receives a second service creation request sent by the cloud service node, where the second service creation request includes information of a target service to be created, and the simulation resource pool node creates the target service, where a resource allocated to the target service by the simulation resource pool node is a simulation resource, and the simulation resource pool node sends a second service creation response to the cloud service node, where the second service creation response is used to notify that the target service is successfully created. The simulation resource pool node avoids the waste of physical resources by distributing the simulation resource pool for the target service.

Fig. 8 is a flowchart of a method for debugging software in a cloud computing service according to a fourth embodiment of the present application, where the method is described from the perspective of a client, and as shown in fig. 8, the method provided by the present embodiment includes the following steps:

step S401, the client receives parameters input by a user, wherein the parameters input by the user comprise information of a target service to be created and a simulation identifier, and the simulation identifier is used for identifying the target service for software debugging.

The emulation identifier may be a resource type, where the resource type includes an emulation resource type and a physical resource type, and the emulation resource type is used to identify the target service for software debugging. The emulated resource type and the physical resource type may be indicated by a bit, for example, the bit may have a value of 1 when the resource type is the emulated resource type and 0 when the resource type is the physical resource type. Or, the simulation resource type is represented by fake, and the physical resource type is represented by true, or when the resource type is the physical resource type, the simulation identifier is not carried. Of course, the emulation identification is not limited to the asset type. The parameters input by the user also comprise information of the target service to be created.

Step S402, the client sends a first service creation request to the cloud service node, wherein the first service creation request comprises information of a target service to be created and a simulation identifier.

When the client detects the parameters input by the user, a first service creation request containing a simulation identifier is generated, the simulation identifier is used for identifying a target service for software debugging, the difference between the service creation service request and a normal service creation request is distinguished through the simulation identifier, and the service created by the normal service creation request is not used for software testing. The simulation identifier is carried in the first service creation request, so that the cloud service node sends the first service creation request to the simulation resource pool node according to the simulation identifier.

The client side can send the first service creation request to the API gateway in an SDK or Rest mode, and the API gateway sends the target service to the corresponding cloud service node according to the information of the target service.

Step S403, the client receives a first service creation response sent by the cloud service node, where the first service creation response is used to notify that the target service is successfully created, and a resource of the target service is a simulation resource.

Although the resources allocated to the target service by the simulation resource pool nodes are simulation resources, for the client, the client does not pay attention to whether the resources of the target service are simulation resources or physical resources, and after receiving the first service creation response, the client considers that the target service creation is successful.

In this embodiment, a client receives a parameter input by a user, where the parameter input by the user includes information of a target service to be created and a simulation identifier, the simulation identifier is used to identify the target service for software debugging, the client sends a first service creation request to a cloud service node, the first service creation request includes information of the target service and the simulation identifier, and the client receives a first service creation response sent by the cloud service node, where a resource of the target service is a simulation resource. The client enables the cloud service node to send the service creation request to the simulation resource pool node according to the simulation identifier by carrying the simulation identifier in the first service creation request, and the simulation resource pool node allocates a simulation resource pool for the target service, so that waste of physical resources is avoided.

Fig. 9 is a signaling flowchart of a method for debugging software in cloud computing service according to a fifth embodiment of the present application, where the present embodiment is described by taking a target service as a virtual machine creation service as an example, and as shown in fig. 9, the method provided by the present embodiment includes the following steps:

step S501, the client generates a first virtual machine creation request.

The first virtual machine creation request is used for creating a virtual machine, the first virtual machine creation request includes information of a virtual machine to be created, and the first virtual machine creation request may include or may not include a simulation identifier.

Step S502, the client sends a first virtual machine creation request to the virtual machine service.

Step S503, the virtual machine service sends a first virtual machine creation request to the virtual machine scheduling service.

Step S504, the virtual machine service returns a first virtual machine creating response to the client.

In the asynchronous creation process, after the virtual machine service sends the first virtual machine creation request to the scheduling service, the first virtual machine creation response is immediately returned to the client to notify the client that the virtual machine is being created, so as to avoid the client from having a response to the virtual machine service for a long time. Certainly, the present application also supports a synchronization creation process of the virtual machine, in the synchronization creation process, after the virtual machine service sends the first virtual machine creation request to the virtual machine scheduling service, the step S505 to the step S507 is executed instead of returning the first virtual machine creation response to the client, so as to create the virtual machine, and after the virtual machine is successfully created, the virtual machine service returns the first virtual machine creation response to the client, so as to notify the client that the virtual machine is successfully created.

Step S505, the virtual machine scheduling service determines a node where the resource of the virtual machine to be created is located.

The virtual machine scheduling service judges whether the first virtual machine creating request contains a simulation identifier, if the first virtual machine creating request contains the simulation identifier, the node where the resources of the virtual machine to be created are located is determined to be a simulation resource pool node, and if the first virtual machine creating request does not contain the simulation identifier, the node where the resources of the virtual machine to be created are located is determined to be a physical resource pool node. Optionally, the first virtual machine creation request further includes information of a physical resource pool node where a resource of the virtual machine to be created is located.

When the node where the resource of the virtual machine to be created is located is the simulation resource pool node, step S506 is executed, and when the node where the resource of the virtual machine to be created is located is the physical resource pool node, step S512 is executed.

Step S506, the virtual machine scheduling service sends a second virtual machine creation request to the simulation resource service.

The second virtual machine creation request includes information of a virtual machine to be created.

Step S507, the simulation resource service sends a second virtual machine creation request to the simulation module.

Step S508, the simulation module records the creation parameters of the virtual machine.

The creating parameters of the virtual machine comprise the information of the volume of the virtual machine, a network interface, the name of the virtual machine, the ID of the virtual machine, the memory size, the information of disk resources, the information of network card resources and the information of the CPU. The information of the volume of the virtual machine includes a volume hanging path, a volume size, and a volume ID. The information of the network card resource includes a Media Access Control (MAC) address of the network card, a port ID corresponding to the network card, and an identifier of a tap port of the virtual network card. The information of the CPU includes the number of cores (cores) of the CPU.

The simulation module may record the creation parameters of the virtual machine in a file, and the path of the file may be "/opt/image/instances/UUID".

Step S509, the simulation module sends a second virtual machine creation response to the simulation resource service.

The second virtual machine creation response is used to notify that the target service creation was successful.

Step S510, the simulation resource service sends the creation parameter of the virtual machine to the resource database.

Step S511, the resource database sends a save success message to the simulation resource service.

And the resource database stores the creation parameters of the virtual machine and returns a storage success message to the simulation resource service.

Step S512, the virtual machine scheduling service sends a second virtual machine creation request to the physical resource service.

Step S513, the physical resource service sends a second virtual machine creation request to the virtualization interface.

Step S514, the virtualization interface creates a real virtual machine.

Step S515, the virtualized interface sends the creation result to the physical resource service.

The creation result may be a creation success or a creation failure for the virtual machine.

Step S516, the physical resource service sends the creation result of the virtual machine to the resource database.

When the virtual machine is successfully created, the creation result includes the creation parameters of the virtual machine.

And step S517, the resource database returns a storage success message to the physical resource service.

It should be noted that the virtual machine service, the virtual machine scheduling service, the physical resource service, the simulation resource service, the virtualization interface, the simulation module, and the resource database in fig. 9 may be implemented by different physical devices, or multiple services may be integrated on one physical device, for example, the virtual machine service and the virtual machine scheduling service are located on one cloud service node, the physical resource service and the virtualization interface are located on one physical resource pool node, the simulation resource service and the simulation module are located on one simulation resource pool node, and the resource database is located on a separate node.

Fig. 10 is a signaling flowchart of a method for debugging software in cloud computing service according to a sixth embodiment of the present application, where the present embodiment is described by taking a monitoring service of statistical information of a CPU with a target service as a virtual machine as an example, and as shown in fig. 10, the method provided by the present embodiment includes the following steps:

step S601, the virtual machine monitoring service sends a first query message to the resource database.

The first query message is used to query node information of a CPU used by the virtual machine to be monitored, where the node information of the CPU used by the virtual machine is information of a host in which the CPU is located, and for example, the node information of the CPU used by the virtual machine includes an address of a node.

Step S602, the resource database returns a first query response to the virtual machine monitoring service.

The first query response includes node information of the CPU used by the virtual machine to be monitored, and if the node of the CPU used by the virtual machine to be monitored is a physical resource pool node, step S603 is executed after step S602, and if the node of the CPU used by the virtual machine to be monitored is an emulated resource pool node, step S608 is executed after step S602.

Step S603, the virtual machine monitoring service sends a request for acquiring statistical information of the CPU of the virtual machine to the physical resource service.

Step S604, the physical resource service sends a request for acquiring statistical information of the CPU of the virtual machine to the virtualization interface.

Step S605, the virtualization interface acquires the statistical information of the CPU of the virtual machine through internal system call.

Step S606, the virtualized interface sends the statistical information of the CPU of the virtual machine to the physical resource service.

Step S607, the physical resource service sends the statistical information of the CPU of the virtual machine to the virtual machine monitoring service.

Step S608, the virtual machine monitoring service sends a request for acquiring statistical information of the CPU of the virtual machine to the emulation resource service.

Step S609, the simulation resource service sends an acquisition request of the statistical information of the CPU of the virtual machine to the simulation module.

Step S610, the simulation module generates the statistical information of the CPUs of the virtual machines according to the number of the CPUs of the virtual machines recorded when the virtual machines are created.

Different from the fact that the virtualized interface acquires the real statistical information of the CPU of the virtual machine, the simulation module generates a random value as the statistical information of the CPU of the virtual machine according to the number of the CPU recorded when the virtual machine is created.

Step S611, the emulation module sends the statistical information of the CPU of the virtual machine to the emulation resource service.

Step S612, the simulation resource service sends the statistical information of the CPU of the virtual machine to the virtual machine monitoring service.

Step S613, the virtual machine monitoring service sends the statistical information of the CPU of the virtual machine to the resource statistical database.

After step S607 or S612, step S613 is executed, and the virtual machine monitoring service sends the acquired statistical information of the CPU of the virtual machine to the resource statistical database, where the resource statistical database stores the statistical information of the CPU of the virtual machine.

And step S614, the resource statistical database sends a storage success message to the virtual machine monitoring service.

It should be noted that the virtual machine monitoring service, the physical resource service, the simulation resource service, the virtualization interface, the simulation module, the resource database, and the resource statistics database in fig. 10 may be implemented by different physical devices, or multiple services may be integrated on one physical device.

Fig. 11 is a schematic structural diagram of a cloud service node provided in a seventh embodiment of the present application, and as shown in fig. 11, the node provided in this embodiment includes:

a receiving module 21, configured to receive a first service creation request sent by a client, where the first service creation request includes information of a target service to be created and a simulation identifier, and the simulation identifier is used to identify the target service for software debugging;

a resource scheduling module 22, configured to determine, according to the simulation identifier, that the second service creation request is sent to a simulation resource pool node, where the second service creation request includes information of the target service;

a sending module 23, configured to send the second service creation request to the simulation resource pool node;

the receiving module 21 is further configured to receive a second service creation response returned by the simulation resource pool node, where the second service creation response is used to notify that the target service is successfully created, and a resource allocated to the target service by the simulation resource pool node is a simulation resource;

the sending module 23 is further configured to send a first service creation response to the client, where the first service creation response is used to notify that the target service creation is successful.

In an exemplary manner, the node further includes:

the resource database management module 24 is configured to store creation parameters of the target service in a resource database, where the creation parameters include information of a node where a resource used by the target service is located and information of the target service.

In another exemplary manner, the resource scheduling module 22 is further configured to: and judging whether the first service creation request contains the simulation identification.

In another exemplary manner, the resource scheduling module 22 is further configured to:

when the first service creation request does not include the simulation identification, determining to send the second service creation request to a physical resource pool node;

the sending module 23 is further configured to send, by the service node, the second service creation request to the physical resource pool node;

the receiving module 21 is further configured to receive the second service creation response sent by the physical resource pool node, where the second service creation response is sent by the physical resource pool node after allocating physical resources to the target service.

In another exemplary manner, the resource database management module 24 is further configured to obtain node information of the resource used by the target service from the resource database;

the resource scheduling module 22 is further configured to determine to send a service management request to the simulation resource pool node when the node of the resource used by the target service is the simulation resource pool node, where the service management request includes identification information of the target service;

the sending module 23 is further configured to send the service management request to the simulation resource pool node;

the receiving module 21 is further configured to receive a service management response sent by the simulation resource pool node, where the service management response includes management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node.

The cloud service node of this embodiment may be configured to execute the method executed by the cloud service node in the foregoing method embodiment, and a specific implementation manner and a technical effect are similar and will not be described herein again.

Fig. 12 is a schematic structural diagram of a simulation resource pool node according to an eighth embodiment of the present application, and as shown in fig. 12, the node according to the present embodiment includes:

a receiving module 31, configured to receive a second service creation request sent by a cloud simulation resource pool node service node, where the second service creation request includes information of a target service to be created;

a creating module 32, configured to create the target service according to the second service creation request, where the resource allocated by the simulation resource pool node for the target service is a simulation resource;

a sending module 33, configured to send a second service creation response to the cloud service node, where the second service creation response is used to notify that the target service creation is successful.

In an exemplary manner, the receiving module 31 is further configured to: receiving a service management request sent by the cloud service node, wherein the service management request comprises identification information of the target service;

the node also comprises a query module and a generation module;

the query module is used for querying the information of the target service from the information of the locally stored service according to the identification information of the target service;

the generating module is used for generating management data according to the information of the target service;

the sending module 33 is further configured to send a service management response to the cloud service node, where the service management response includes the management data.

The simulation resource pool node of this embodiment may be configured to execute the method executed by the simulation resource pool node in the foregoing method embodiment, and a specific implementation manner and a technical effect are similar and will not be described here again.

Fig. 13 is a schematic structural diagram of a client according to a ninth embodiment of the present application, and as shown in fig. 13, the client according to the present embodiment includes:

a receiving module 41, configured to receive parameters input by a user, where the parameters input by the user include information of a target service to be created and a simulation identifier, and the simulation identifier is used to identify the target service for software debugging;

a generating module 42, configured to generate a first service creation request according to the parameter input by the user, where the first service request includes the information of the target service and the simulation identifier;

a sending module 42, configured to send the first service creation request to a cloud service node;

the receiving module 41 is further configured to receive a first service creation response sent by the cloud service node, where the first service creation response is used to notify that the target service is successfully created, and a resource of the target service is a simulation resource.

The client of this embodiment may be configured to execute the method executed by the client in the foregoing method embodiment, and a specific implementation manner and a technical effect are similar and will not be described here again.

It is clear to those skilled in the art that, for convenience and brevity of description, the specific working processes of the above-described systems, apparatuses and units may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus and method may be implemented in other ways. For example, the above-described apparatus embodiments are merely illustrative, and for example, the division of the units is only one logical division, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or 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 also be an electric, mechanical or other form of connection.

While the invention has been described with reference to specific embodiments, the scope of the invention is not limited thereto, and those skilled in the art can easily conceive various equivalent modifications or substitutions within the technical scope of the invention. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims (6)

1. A method for debugging software in cloud computing service is characterized by comprising the following steps:

the method comprises the steps that a cloud service node receives a first service creation request sent by a client, wherein the first service creation request comprises information of a target service to be created and a simulation identifier;

and the cloud service node sends a first service creation response to the client according to the simulation identification without calling physical resources in a physical resource pool, wherein the first service creation response is used for notifying that the target service is successfully created.

2. The method of claim 1, further comprising:

the cloud service node sends a second service creation request to a simulation resource pool node according to the simulation identification, wherein the second service creation request comprises the information of the target service;

the cloud service node receives a second service creation response returned by the simulation resource pool node, wherein the second service creation response is used for notifying that the target service is successfully created, and resources allocated to the target service by the simulation resource pool node are simulation resources;

after the cloud service node receives the second service creation response returned by the simulation resource pool node, the method further includes:

and the cloud service node stores the creation parameters of the target service to a resource database, wherein the creation parameters comprise information of a node where the resource used by the target service is located and information of the target service.

3. The method according to claim 1 or 2, wherein before the cloud service node sends the second service creation request to the simulation resource pool node according to the simulation identifier, the method further comprises:

and the cloud service node judges whether the first service creation request contains the simulation identification.

4. The method of claim 3, further comprising:

when the first service creation request does not comprise the simulation identification, the cloud service node sends the second service creation request to a physical resource pool node;

and the cloud service node receives the second service creation response sent by the physical resource pool node, wherein the second service creation response is sent after the physical resource pool node allocates physical resources for the target service.

5. The method of claim 2, further comprising:

the cloud service node acquires node information of resources used by the target service from the resource database;

when the node of the resource used by the target service is the simulation resource pool node, the cloud service node sends a service management request to the simulation resource pool node, wherein the service management request comprises identification information of the target service;

and the cloud service node receives a service management response sent by the simulation resource pool node, wherein the service management response comprises management data of the target service, and the management data of the target service is random data generated by the simulation resource pool node.

6. A cloud service node, comprising:

a storage unit to store instructions; and

at least one processor coupled to the memory unit;

wherein the instructions, when executed by the at least one processor, cause the processor to perform the method of any of claims 1-5.

Images