CN110083366B - Application running environment generation method and device, computing equipment and storage medium - Google Patents
Application running environment generation method and device, computing equipment and storage medium Download PDFInfo
- Publication number
- CN110083366B CN110083366B CN201810067537.8A CN201810067537A CN110083366B CN 110083366 B CN110083366 B CN 110083366B CN 201810067537 A CN201810067537 A CN 201810067537A CN 110083366 B CN110083366 B CN 110083366B
- Authority
- CN
- China
- Prior art keywords
- application
- container
- identification information
- mirror image
- loading
- 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
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/61—Installation
- G06F8/63—Image based installation; Cloning; Build to order
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a method and a device for generating an application running environment, a computing device and a storage medium. The method for generating the application running environment comprises the following steps: acquiring identification information of an application to be deployed; acquiring a mirror image corresponding to the identification information, wherein the mirror image does not contain the application to be deployed and is used for describing an environment on which the application depends during running; creating a container corresponding to the mirror image, wherein the container is used for running the application; and acquiring the application corresponding to the identification information, and loading the acquired application in the container.
Description
Technical Field
The present application relates to the field of virtualization technologies, and in particular, to a method and an apparatus for generating an application execution environment, a computing device, and a storage medium.
Background
With the development of internet technology, users need to develop and deploy application modules in terms of a large number of services on a server side. Here, an application module is generally a component capable of performing a certain business function. In order to test or deploy an application module, a server side typically applies a virtualization technology (such as Linux container technology, abbreviated as LXC) to construct a virtualization environment for executing the application module on the server side. For example, the application container engine Docker may build an image for each application module that contains the application and the middleware that the application depends on.
Disclosure of Invention
The application provides a generation scheme of an application running environment, so as to solve the problem of how to improve the flexibility of constructing the application running environment.
According to an aspect of the present application, there is provided a method for generating an application execution environment, including: acquiring identification information of an application to be deployed; acquiring a mirror image corresponding to the identification information, wherein the mirror image does not contain the application to be deployed and is used for describing an environment on which the application depends during running; creating a container corresponding to the image, wherein the container is used for running the application; and acquiring the application corresponding to the identification information, and loading the acquired application in the container.
According to an aspect of the present application, there is provided an apparatus for generating an application execution environment, including: the system comprises a mirror image acquisition unit, a mirror image processing unit and a control unit, wherein the mirror image acquisition unit is used for acquiring identification information of an application to be deployed and acquiring a mirror image corresponding to the identification information, and the mirror image does not contain the application to be deployed and is used for describing an environment on which the application depends during running; a container creating unit configured to create a container corresponding to the image, wherein the container is used to run the application; and an application management unit configured to acquire an application corresponding to the identification information, and load the acquired application in the container.
According to an aspect of the present application, there is provided a computing device comprising: one or more processors, memory, and one or more programs. One or more programs are stored in the memory and configured to be executed by the one or more processors, the one or more programs including instructions for performing the method of generating an application execution environment of the present application.
According to an aspect of the present application, there is provided a storage medium storing one or more programs, the one or more programs including instructions, which when executed by a computing device, cause the computing device to perform the application execution environment generation method of the present application.
In summary, according to the technical solution of the present application, when determining an application to be deployed, an image corresponding to a middleware required for running the application is automatically obtained, so that a container corresponding to the image can be generated and the application is automatically loaded in the container (for example, an application loading module is loaded in the container first, and then the application is obtained and loaded by the module). In other words, the technical solution of the present application can automatically generate an environment for running applications based on images and applications that are managed independently from each other. In addition, because the application running environment can be generated according to the respective independent mirror image and the application, the technical scheme of the application can avoid generating the mirror image in which the middleware and the application are bound together when the user updates the application every time, and avoid generating the environment for running the application through the mirror image containing the application and the middleware. Typically, in application scenarios such as agile development, a large number of applications (i.e., a large number of business modules) require frequent iterative updates. When the application and the middleware are bound to generate the image, the image of a large number of iterations needs to occupy larger storage space and generate larger network resource consumption. According to the technical scheme, the mirror image can be prevented from being frequently generated, and the mirror image corresponding to the middleware has higher reusability (namely one mirror image can be used for constructing the running environment of multiple versions of applications or multiple types of applications). Therefore, the technical scheme of the application can improve the flexibility of constructing the application running environment.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive labor.
FIG. 1 illustrates a schematic diagram of an application scenario 100, in accordance with some embodiments of the present application;
FIG. 2 illustrates a flow diagram of a method 200 of generating an application execution environment according to some embodiments of the present application;
FIG. 3 shows a schematic user interface diagram of a client according to an embodiment of the present application;
FIG. 4 illustrates a flow diagram of a method 400 of generating an application execution environment according to some embodiments of the present application;
FIG. 5 shows a schematic user interface diagram of a client according to an embodiment of the present application;
FIG. 6 illustrates a schematic diagram of an application scenario in accordance with some embodiments of the present application;
FIG. 7 illustrates a schematic diagram of an apparatus 700 for generating an application execution environment, in accordance with some embodiments of the present application;
FIG. 8 illustrates a schematic diagram of an apparatus 800 for generating an application execution environment, in accordance with some embodiments of the present application; and
FIG. 9 illustrates a block diagram of the components of a computing device.
Detailed Description
The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
FIG. 1 illustrates a schematic diagram of an application scenario in accordance with some embodiments of the present application. As shown in fig. 1, the application scenario 100 includes a client 110 and an application execution system 120. Here, the client 110 may be, for example, various computing devices such as a desktop computer, a mobile phone, a tablet computer, or a laptop computer. The application execution system 120 is used to deploy an environment for executing an application, i.e., for executing an application. The application execution system 120 may include, for example, one or more servers. Here, the application may be various business components (also referred to as business modules) adapted to run on the application running system 120. The application examples are a hypertext transfer Protocol (HTTP) service component or a service data processing component, and the application is not limited thereto. In some embodiments, an application needs to rely on middleware (which may also be referred to as a base service component) when running in the application running system 120. For example, a web application relies on web service components. The web service component is, for example, an Apache (Apache) service component or the like. As another example, a Java application relies on Java platform components. Here, the application execution system 120 may communicate with the client 110 through the network 130. Upon receiving a generation request from the client 110 regarding the application execution environment, the application execution system 120 may generate a corresponding container according to an image of the middleware on which the application depends. The application execution system 120 may load the application in the generated container. The method for generating the application operating environment is further described with reference to fig. 2.
FIG. 2 illustrates a flow diagram of a method 200 for generating an application execution environment according to some embodiments of the present application. The generation method 200 of the application execution environment may be executed in the application execution system 120, for example, but is not limited thereto.
As shown in fig. 2, the method 200 may include step S201 of acquiring identification information of an application to be deployed. In other words, step S201 may determine the application to be deployed at the application execution system 120.
According to an embodiment of the present application, in step S201, a runtime environment generation request containing identification information is received from the client 110, and the identification information is extracted from the generation request. For example, the identification information may include an identification of the application. Also for example, the identification information may include an identification of the application, a version number, and a downstream application identification. The downstream application identification is used for describing a downstream application to be triggered to run after the application to be deployed runs. In other words, the application to be deployed is associated with a downstream application. For example, after the application to be deployed performs data processing, the data processing result may be transmitted to the downstream application, so that the downstream application performs subsequent business processing operations using the data processing result (i.e., the deployed upstream application triggers the business processing operations of the downstream application). For another example, the application to be deployed may determine whether to launch a downstream application based on business logic.
Fig. 3 shows a schematic view of a user interface of the client 110. The user interface (i.e., command line window) shown in FIG. 3 may be used to enter application deployment commands. The client 110 may generate a corresponding runtime generation request according to the application deployment command. For example, the application deployment command shown in area 301 is: "./run.sh-s display-u xxxx-v 1.0.228-d mixer:10.133.1.104: 9526". Step S201, upon receiving a request for generating a runtime environment corresponding to the application deployment command in the area 301, may determine that the identifier of the application to be deployed is "display", the version number is "1.0.228", and the identifier of the downstream application is "mixer: 10.133.1.104: 9526". Wherein, "mixer" represents a downstream application name, "10.133.1.104" represents an access address of the downstream application, and "9526" represents an access port of the downstream application.
In yet another embodiment, the execution environment generation request received at step S201 may include identification information of a plurality of applications. Here, the identification information of each application may include an identification of one or more downstream applications to which the application corresponds. In this way, step S201 may determine a plurality of applications to be deployed and a downstream application corresponding to each application.
In step S202, a mirror image corresponding to the identification information is acquired. Wherein the image does not contain the application to be deployed and is used to describe the environment on which the application depends at runtime. In other words, step S202 may acquire an image corresponding to the application to be deployed. In this way, step S202 can avoid generating an image in which the middleware is bound to the application each time the user updates the application, and avoid generating an environment in which the application is run by the image including the application and the middleware. For example, when the application to be deployed is a web application, the image is, for example, a web service resource (e.g., an Apache image, etc.). As another example, where the application to be deployed is a Java application, the image is a Java middleware resource (e.g., including Java classes needed to execute the Java application). In some embodiments, step S202 may determine the mirror identifier corresponding to the application according to the identification information. For example, step S202 may query a mapping table describing a mapping relationship between the application set and the mirror set to obtain a mirror identifier corresponding to the application. According to the image identifier, step S202 may obtain a corresponding image. For example, step S202 may pull the image from an image storage server (which may also be referred to as a mirror database).
From the mirror image obtained in step S202, the method 200 may perform step S203 to create a container corresponding to the mirror image. Wherein the container is used to run an application.
In one embodiment, step S203 may be performed by a container management engine in the application execution system 120. The container management engine is an application component running on top of the operating system and may also be referred to herein as a module for starting the container. In step S203, the container management engine may generate a virtual environment for deploying the application according to the image, and treat the virtual environment as a container. Here, the application execution system 120 may share the kernel of the operating system with multiple containers. Each container (i.e., each virtual environment) may have a separate network access address, access port, and a separate user space.
In another embodiment, after the step S202 obtains the images corresponding to the plurality of applications, the step S203 may generate a corresponding container for each image. In other words, step S203 may generate a plurality of containers for running the application in parallel. In addition, step S203 may also transmit the identification information to the container in an environment variable manner.
In step S204, an application corresponding to the identification information is acquired, and the acquired application is loaded in the container. According to some embodiments of the present application, in step S204, the application loading module may be loaded in the container by the container management engine, so that the application loading module obtains the corresponding application (actually, the code resource corresponding to the application) from the application storage server according to the identification information in the container (i.e., the identification information transmitted to the container in the environment variable manner in step S203), and loads the obtained application in the container.
In one embodiment, step S204 may load one application independently in the container without loading multiple applications. In this way, step S204 may enable the application loaded in the container to be concatenated with the determined upstream and downstream applications. In this embodiment, since the containers correspond to the applications one to one, the applications in step S204 can be flexibly connected in series with the upstream and downstream applications, so that the combination of the applications can be flexibly deployed. Here, connecting a plurality of applications in series may form a combination of applications. A combination of applications may also be referred to as an application system.
In summary, the method 200 may automatically acquire an image corresponding to the middleware required for running the application when determining the application to be deployed, so that a container corresponding to the image may be generated and the application may be automatically loaded in the container (for example, first, an application loading module is loaded in the container, and then the application is acquired and loaded by the module). In other words, the method 200 may automatically generate an environment to run an application based on images and applications that are each managed independently.
It should be noted that, since the application execution environment can be generated according to the respective independent images and applications, the method 200 can avoid generating an image in which the middleware and the application are bound together each time the user updates the application, and avoid generating an environment for executing the application by using the image including the application and the middleware. Typically, in application scenarios such as agile development, a large number of applications (i.e., a large number of business modules) require frequent iterative updates. When the application and the middleware are bound to generate the image, the image of a large number of iterations needs to occupy larger storage space and generate larger network resource consumption. The method 200 can avoid frequent generation of images, and enable the images corresponding to the middleware to have higher reusability (i.e. one image can be used for the runtime environment construction of multiple versions of applications or multiple types of applications). In this way, the method 200 may increase the flexibility of building an application execution environment.
FIG. 4 illustrates a flow diagram of a method 400 of generating an application execution environment according to some embodiments of the present application. The generation method 400 of the application execution environment may be executed in the application execution system 120, for example, but is not limited thereto.
As shown in fig. 4, the method 400 may include steps S401 to S404. The implementation of steps S401 to S404 is identical to steps S201 to S204, and will not be described herein.
In addition, the method 400 may further include step S405, after loading the retrieved application, automatically testing the application in the container. In one embodiment, step S405 may load a testing module for testing applications in the container, so that the testing module performs usability tests on the applications loaded in the container, and the like. Here, step S405 may be, for example, a container management engine acquiring a test module for testing an application and loading the test module into a container. Here, the test module may execute a corresponding automated test script depending on the test requirement, which is not limited in this application.
In step S406, after the application is loaded in the container, corresponding loading result information is generated. The loading result information may include, for example: description information about whether the application was loaded successfully, an identification of the container, and an identification of the port of the loaded application. In step S407, the loading result information is transmitted to the client 110. In yet another embodiment, step S406 may also generate test result information, and step S407 may also send the test result information to the client 110.
In addition, the method 400 may further include step S408, when the application is updated, acquiring the updated application loading module corresponding to the updated application, so as to load the updated application in the container by using the updated application loading module. Here, the updated application refers to an application whose deployment manner is changed. An updated application load module refers to a load module that is consistent with the deployment of the updated application. In this way, in the application iteration process, the embodiment of the present application can avoid generating a large number of images containing updated applications, and load the updated applications by updating the application loading module.
FIG. 5 illustrates a user interface diagram of a client according to one embodiment of the present application. The command line window shown in fig. 5 displays a description 501 ("success to run service display") indicating that the runtime environment of the application "display" is successfully constructed, an identifier 502 of a container, and a port identifier 503 of a loaded application, so as to immediately feed back the construction of the runtime environment to the user.
In summary, the method 400 may load the test module in the container generated by the mirror image, and test the application by the test module, so that the test on the application may be automatically completed, and further, the high-availability application running environment may be obtained. Here, the method 400 may avoid the hassle of generating a test script by a user and then testing the in-container application. The method 400 may also send application loading result information and/or test result information to the client for the client 110 to present the result information instantly.
FIG. 6 illustrates a schematic diagram of an application scenario according to some embodiments of the present application. As shown in fig. 6, application scenario 600 may include computing device 610, image storage server 620, application storage server 630, and client 640. The computing device 610 may include a container management engine 611, an application load module resource store 612, and a test module resource store 613.
The client 640 may perform step S601, and send an application environment generation request to the container management engine 611. Upon receiving the request, the container management engine 611 may perform step S602, pulling the image from the image storage server 620. On this basis, the container management engine 611 may perform step S603 to generate the container 614 corresponding to the mirror. Here, the container management engine 611 may transmit identification information (including, for example, an application identification and a version number) corresponding to the application to the container 614 in the form of an environment variable when generating the container 614. The container management engine 611 may also perform steps S604 and S605. In step S604, the application load module resource in the application load module resource storage unit 612 is loaded into the container 614. As such, the container 614 may include an application loading module 6141. In step S605, the test module resources in the test module resource storage unit 613 are loaded into the container 614. As such, the container 614 may include a test module 6142. The application loading module 6141 may execute step S606, obtain the resource corresponding to the application from the application storage server 630 according to the identification information, and load the resource in the container 614. As such, the container 614 may include the application 6143. On the basis, the testing module 6142 may execute step S607 to perform an automated test (e.g., usability test, etc.) on the application 6143. In addition, the container management engine 611 may also perform steps S608 and S609. In step S608, result information (which may include, for example, application loading result information and/or test result information, etc.) is obtained from the container 614. In step S609, the result information is sent to the client 640 so that the client 640 presents the result information.
Fig. 7 shows a schematic diagram of an apparatus 700 for generating an application execution environment according to some embodiments of the present application. The generating apparatus 700 may reside in the application execution system 120, for example, but is not limited thereto.
As shown in fig. 7, the generation apparatus 700 may include an image acquisition unit 710, a container creation unit 720, and an application management unit 730.
The mirror image obtaining unit 710 is configured to obtain identification information of an application to be deployed, and obtain a mirror image corresponding to the identification information. Wherein the image does not contain the application to be deployed, but is used to describe the environment on which the application depends when running. In one embodiment, the image obtaining unit 710 may receive a runtime environment generation request containing identification information from the client 110 and extract the identification information from the generation request. Here, the identification information may include, for example, an identification of the application, a version number, and a downstream application identification. Wherein, the downstream application identification is used for describing the downstream application which is triggered to run after the application runs. To acquire the image, the image acquisition unit 710 may determine an image identifier corresponding to the application according to the identification information. For example, the image obtaining unit 710 may query a mapping table describing a mapping relationship between the application set and the image set to obtain an image identifier corresponding to the application. Based on the image identifier, the image obtaining unit 710 may obtain the corresponding image from the image storage server.
The container creating unit 720 is used to create a container corresponding to the mirror image. Wherein the container is used to run an application. In one embodiment, the container creation unit 720 may generate a virtual environment for deploying the application according to the image and treat the virtual environment as a container. In addition, the container creating unit 720 may also transmit the identification information to the container in an environment variable manner.
The application management unit 730 is configured to acquire an application corresponding to the identification information and load the acquired application in the container. In one embodiment, the application management unit 730 may load the application loading module in the container, so that the application loading module acquires the corresponding application from the application storage server according to the identification information and loads the acquired application in the container. In one embodiment, the application management unit 730 may load the applications independently in the container so as to concatenate the applications loaded in the container with the determined upstream and downstream applications. More specific embodiments of the generating device 700 are consistent with the method 200 and will not be described here.
Fig. 8 shows a schematic diagram of an apparatus 800 for generating an application execution environment according to some embodiments of the present application. The generating apparatus 800 may reside in the application execution system 120, for example, but is not limited thereto.
As shown in fig. 8, the generation apparatus 800 may include an image acquisition unit 810, a container creation unit 820, and an application management unit 830. Here, the respective embodiments of the image obtaining unit 810, the container creating unit 820, and the application management unit 830 are respectively consistent with the image obtaining unit 710, the container creating unit 720, and the application management unit 730, and are not described herein again. In addition, the generation apparatus 800 may further include a test management unit 840 and a notification unit 850.
In one embodiment, the container creating unit 820 may further obtain an updated application loading module corresponding to the updated application when the application is updated, so that the apparatus 800 loads the updated application in the container by using the updated application loading module.
The test management unit 840 automates testing applications in containers after the application management unit 830 loads the applications. In one embodiment, the test management unit 840 loads a test module for testing an application in a container so that the test module performs usability tests on the application loaded in the container.
After the application management unit 830 loads the application in the container, the notification unit 850 may generate corresponding loading result information. Wherein, the loading result information comprises: description information about whether the application was loaded successfully, an identification of the container, and an identification of a port on which the application has been loaded. The notification unit 850 may transmit the loading result information to the client 110. More specific embodiments of the generating apparatus 800 are consistent with the method 400 and will not be described herein.
FIG. 9 illustrates a block diagram of the components of a computing device. As shown in fig. 9, the computing device includes one or more processors (CPUs) 902, a communications module 904, a memory 906, a user interface 910, and a communications bus 908 for interconnecting these components.
The processor 902 can receive and transmit data via the communication module 904 to enable network communications and/or local communications.
User interface 910 includes one or more output devices 912 including one or more speakers and/or one or more visual displays. The user interface 910 also includes one or more input devices 914. The user interface 910 may receive, for example, an instruction of a remote controller, but is not limited thereto.
The memory 906 may be a high-speed random access memory such as DRAM, SRAM, DDR RAM, or other random access solid state memory devices; or non-volatile memory, such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid-state storage devices.
The memory 906 stores a set of instructions executable by the processor 902, including:
an operating system 916 including programs for handling various basic system services and for performing hardware related tasks;
the application 918 includes various programs for implementing the method for generating the application execution environment, and such programs can implement the processing flows in the embodiments described above, for example, the application execution environment generating apparatus 700 shown in fig. 7 or the application execution environment generating apparatus 800 shown in fig. 8 may be included. In this way, the generating device of the application execution environment may automatically acquire the image corresponding to the middleware required for executing the application when determining the application to be deployed, so that a container corresponding to the image may be generated and the application may be automatically loaded in the container (for example, an application loading module is first loaded in the container, and then the application is acquired and loaded by the module). In other words, the generation means of the application execution environment can automatically generate the environment in which the application is executed based on the image and the application that are each managed independently.
In addition, each of the embodiments of the present application can be realized by a data processing program executed by a data processing apparatus such as a computer. It is clear that a data processing program constitutes the present application.
Further, the data processing program, which is generally stored in one storage medium, is executed by directly reading the program out of the storage medium or by installing or copying the program into a storage device (such as a hard disk and/or a memory) of the data processing device. Such a storage medium therefore also constitutes the present application. The storage medium may use any type of recording means, such as a paper storage medium (e.g., paper tape, etc.), a magnetic storage medium (e.g., a flexible disk, a hard disk, a flash memory, etc.), an optical storage medium (e.g., a CD-ROM, etc.), a magneto-optical storage medium (e.g., an MO, etc.), and the like.
The present application therefore also discloses a non-volatile storage medium in which a data processing program is stored, the data processing program being configured to execute any one of the embodiments of the method for generating an application execution environment described above in the present application.
In addition, the method steps described in this application may be implemented by hardware, for example, logic gates, switches, Application Specific Integrated Circuits (ASICs), programmable logic controllers, embedded microcontrollers, and the like, in addition to data processing programs. Such hardware capable of implementing the methods described herein may also constitute the present application.
The above description is only exemplary of the present application and should not be taken as limiting the present application, as any modification, equivalent replacement, or improvement made within the spirit and principle of the present application should be included in the scope of protection of the present application.
Claims (14)
1. A method for generating an application running environment is characterized by comprising the following steps:
acquiring identification information of an application to be deployed, wherein the identification information comprises an identification of the application, or comprises the identification of the application and a downstream application identification, and the downstream application identification is used for describing a downstream application to be triggered to run after the application runs;
acquiring a mirror image corresponding to the identification information, wherein the mirror image does not contain the application to be deployed and is used for describing an environment on which the application depends when running;
creating a container corresponding to the image, wherein the container is used for running the application; and
and acquiring the application corresponding to the identification information, and loading the acquired application in the container.
2. The generation method of claim 1, further comprising: automatically testing the application in the container after loading the retrieved application.
3. The generation method of claim 2, wherein the automated testing of the application in the container comprises:
and loading a testing module for testing the application in the container so that the testing module can test the usability of the application loaded in the container.
4. The generation method of claim 1, wherein the obtaining identification information of the application to be deployed comprises:
and receiving a running environment generation request containing the identification information from a client, and extracting the identification information from the generation request.
5. The generation method of claim 1, wherein the obtaining a mirror image corresponding to the identification information comprises:
determining a mirror image identifier corresponding to the application according to the identifier information;
and acquiring a corresponding mirror image from a mirror image storage server according to the mirror image identifier.
6. The generation method of claim 5, wherein the determining the image identification corresponding to the application comprises:
and querying a mapping table for describing a mapping relation between the application set and the mirror image set to acquire a mirror image identifier corresponding to the application.
7. The generation method of claim 1, wherein the creating a container corresponding to the image comprises:
generating a virtual environment for deploying the application according to the mirror image by a container management engine, and taking the virtual environment as the container;
transmitting the identification information to the container in an environment variable manner.
8. The generation method of claim 1, wherein acquiring the application according to the identification information and loading the acquired application in the container comprises:
and loading an application loading module in the container so that the application loading module acquires the corresponding application from the application storage server according to the identification information and loads the acquired application in the container.
9. The generation method of claim 8, further comprising:
when the application is updated, acquiring the updated application loading module corresponding to the updated application so as to load the updated application in the container by using the updated application loading module.
10. The generation method of claim 1, wherein the loading the retrieved application in the container comprises:
independently loading the application in the container so as to concatenate the application loaded in the container with the determined upstream and downstream applications.
11. The generation method of claim 1, further comprising:
after the application is loaded in the container, generating corresponding loading result information, wherein the loading result information includes: description information about whether the application was loaded successfully, an identification of the container, and an identification of a port on which the application has been loaded;
and sending the loading result information to a client.
12. An apparatus for generating an application execution environment, comprising:
the system comprises a mirror image obtaining unit, a mirror image obtaining unit and a control unit, wherein the mirror image obtaining unit is used for obtaining identification information of an application to be deployed and obtaining a mirror image corresponding to the identification information, the mirror image does not contain the application to be deployed and is used for describing an environment on which the application depends when running, the identification information comprises an identification of the application or comprises an identification of the application and a downstream application identification, and the downstream application identification is used for describing a downstream application to be triggered to run after the application runs;
a container creating unit configured to create a container corresponding to the image, wherein the container is used to run the application; and
and the application management unit is used for acquiring the application corresponding to the identification information and loading the acquired application in the container.
13. A computing device, comprising:
one or more processors;
a memory; and
one or more programs stored in the memory and configured to be executed by the one or more processors, the one or more programs including instructions for performing the method of generating an application execution environment of any of claims 1-11.
14. A storage medium storing one or more programs, the one or more programs comprising instructions, which when executed by a computing device, cause the computing device to perform the method of generating an application execution environment of any one of claims 1-11.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810067537.8A CN110083366B (en) | 2018-01-24 | 2018-01-24 | Application running environment generation method and device, computing equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810067537.8A CN110083366B (en) | 2018-01-24 | 2018-01-24 | Application running environment generation method and device, computing equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110083366A CN110083366A (en) | 2019-08-02 |
| CN110083366B true CN110083366B (en) | 2021-06-18 |
Family
ID=67412143
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810067537.8A Active CN110083366B (en) | 2018-01-24 | 2018-01-24 | Application running environment generation method and device, computing equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110083366B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110908675B (en) * | 2019-11-15 | 2023-10-24 | 北京百度网讯科技有限公司 | Method and device for acquiring running environment and electronic equipment |
| CN113596958B (en) * | 2021-07-28 | 2023-04-28 | 中移（杭州）信息技术有限公司 | Terminal equipment data interaction method, system, equipment and storage medium |
| CN114327779B (en) * | 2021-12-30 | 2023-09-01 | 北京瑞莱智慧科技有限公司 | Application running environment building method, device and storage medium |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105490860A (en) * | 2015-12-24 | 2016-04-13 | 北京奇虎科技有限公司 | Method, device and system for deploying application program operation environment |
| CN106502905A (en) * | 2016-10-26 | 2017-03-15 | 腾讯科技（深圳）有限公司 | A kind of method of testing of application program, apparatus and system |
| CN107220100A (en) * | 2016-03-22 | 2017-09-29 | 中国移动（深圳）有限公司 | One kind exploitation O＆M method, device and cloud computing PaaS platform |
| CN107463432A (en) * | 2017-08-17 | 2017-12-12 | 福建中金在线信息科技有限公司 | Server production environment dispositions method, device, electronic equipment and storage medium |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7962620B2 (en) * | 2007-10-19 | 2011-06-14 | Kubisys Inc. | Processing requests in virtual computing environments |
| CN103544049A (en) * | 2012-07-10 | 2014-01-29 | 百度在线网络技术（北京）有限公司 | Testing environment automatic processing method, and method and device for realizing testing automation |
| CN105224466B (en) * | 2015-11-17 | 2018-08-28 | 广州亦云信息技术有限公司 | A kind of integration test method and system based on Docker |
-
2018
- 2018-01-24 CN CN201810067537.8A patent/CN110083366B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105490860A (en) * | 2015-12-24 | 2016-04-13 | 北京奇虎科技有限公司 | Method, device and system for deploying application program operation environment |
| CN107220100A (en) * | 2016-03-22 | 2017-09-29 | 中国移动（深圳）有限公司 | One kind exploitation O＆M method, device and cloud computing PaaS platform |
| CN106502905A (en) * | 2016-10-26 | 2017-03-15 | 腾讯科技（深圳）有限公司 | A kind of method of testing of application program, apparatus and system |
| CN107463432A (en) * | 2017-08-17 | 2017-12-12 | 福建中金在线信息科技有限公司 | Server production environment dispositions method, device, electronic equipment and storage medium |
Non-Patent Citations (1)
| Title |
|---|
| 基于Docker和持续交付的项目管理系统设计与实现;周振兴;《中国优秀硕士学位论文全文数据库 信息科技辑》;20170715;I138-335 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110083366A (en) | 2019-08-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10592402B2 (en) | Automated integration testing with mock microservices | |
| US10635406B2 (en) | Determining the identity of software in software containers | |
| CN109547570B (en) | Service registration method, device, registration center management equipment and storage medium | |
| US11625281B2 (en) | Serverless platform request routing | |
| CN108964968B (en) | Service access management method and system in container cloud environment | |
| US9274843B2 (en) | Multi-redundant switchable process pooling for cloud it services delivery | |
| US9311161B2 (en) | Automatically configured management service payloads for cloud IT services delivery | |
| CN111527474B (en) | Dynamic delivery of software functions | |
| CN105164644A (en) | Hook framework | |
| CN111984269A (en) | Method for providing application construction service and application construction platform | |
| CN110083366B (en) | Application running environment generation method and device, computing equipment and storage medium | |
| CN110647332A (en) | Software deployment method and device based on container cloud | |
| CN111897623B (en) | Cluster management method, device, equipment and storage medium | |
| CN108628626B (en) | Development environment building method, code updating method and device | |
| CN111984270A (en) | Application deployment method and system | |
| CN110968331A (en) | Method and device for running application program | |
| CN112068850A (en) | Method and device for creating service product instance and electronic equipment | |
| CN114880073A (en) | Cloud application engine deployment method, device, equipment and storage medium for shielding Web framework for user | |
| CN117337429A (en) | Deploying a machine learning model | |
| CN115016862A (en) | Kubernetes cluster-based software starting method, device, server and storage medium | |
| US11425203B2 (en) | Commissioning a virtualized network function | |
| CN111026502B (en) | Business debugging architecture creating method and device, electronic equipment and storage medium | |
| CN113821303A (en) | Method and device for deploying hardor cluster and readable storage medium | |
| CN114679491A (en) | Micro front-end service application method and device, storage medium and electronic equipment | |
| CN113032004A (en) | Method, apparatus and program product for managing development jobs in a development environment |
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 |