Method and device for uploading container mirror image

Abstract

The invention provides a method and a device for uploading a container mirror image. The method comprises the steps that a JavaScript engine of a browser is used for executing the following operations that a container mirror image file is decompressed, a mirror image file list is obtained, and the mirror image file list comprises a mirror image list and a plurality of mirror image layered files; aiming at each mirror image layered file in the plurality of mirror image layered files, checking whether the mirror image layered file exists in the mirror image warehouse or not; if the mirror image hierarchical file does not exist in the mirror image warehouse, uploading the mirror image hierarchical file to the mirror image warehouse; and uploading the mirror image list to a mirror image warehouse.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method and device for uploading a container image. Background Art

[0002] Containerization is an approach to software development whereby an application or service, its dependencies, and its configuration (abstracted as a deployment manifest file) are packaged together as a container image. Containerized applications can be tested as a unit and deployed to a host operating system (OS) as an instance of a container image. Just as ships, trains, or trucks transport containers regardless of the cargo inside, software containers serve as a standard unit of software deployment, which can contain different code and dependencies. Containerizing software in this way allows developers and IT professionals to deploy it to different environments with little or no modification. Containers also isolate applications from each other on a shared OS. Containerized applications run on a container host, which runs an OS (Linux or Windows). As a result, containers have a much smaller footprint than virtual machine (VM) images.

[0003] When using container images, you need a place to save and access the created images, which is exactly what the container image repository does. The image repository is mainly used to store container images, which can be shared through upload (push) and download (pull) processes. If the image is on another system, the original application contained in it can also be run on that system.

[0004] The related technology is based on client-side container image uploading, which has at least the following problems: the image environment installation is complex and users need professional knowledge to install it. Summary of the invention

[0005] To overcome the problems existing in the related art, this specification provides a method and device for uploading a container image.

[0006] According to a first aspect of an embodiment of the present specification, a method for uploading a container image is provided, the method comprising: using a JavaScript engine of a browser to perform the following operations: decompressing a container image file to obtain an image file list, the image file list comprising an image manifest and multiple image layered files; for each image layered file in the multiple image layered files, checking whether the image layered file exists in an image repository; if the image layered file does not exist in the image repository, uploading the image layered file to the image repository; uploading the image manifest to the image repository.

[0007] According to a second aspect of an embodiment of the present specification, there is provided a device for uploading a container image, comprising: a decompression module, for decompressing a container image file by using a JavaScript engine of a browser to obtain an image file list, wherein the image file list comprises an image manifest and a plurality of image layered files; a checking module, for checking, for each image layered file in the plurality of image layered files by using a JavaScript engine of a browser, whether the image layered file exists in an image repository; an image layered file uploading module, for uploading the image layered file to the image repository by using a JavaScript engine of a browser if the image layered file does not exist in the image repository; and an image manifest uploading module, for uploading the image manifest to the image repository.

[0008] According to a third aspect of an embodiment of this specification, a device for uploading a container image is provided, including:

[0009] processor;

[0010] a memory for storing processor-executable instructions;

[0011] The processor is configured to: use the JavaScript engine of the browser to perform the following operations: decompress the container image file to obtain an image file list, wherein the image file list includes an image manifest and multiple image layered files; for each image layered file in the multiple image layered files, check whether the image layered file exists in the image warehouse; if the image layered file does not exist in the image warehouse, upload the image layered file to the image warehouse; upload the image manifest to the image warehouse.

[0012] The technical solutions provided by the embodiments of this specification may have the following beneficial effects:

[0013] In the embodiments of this specification, users do not need to install the client environment of the image repository, and can directly use the browser to upload the container image. The JavaScript framework is used locally in the browser to perform container image parsing and incremental upload, and the API of the image repository is directly connected, which omits the steps of repeated upload and server-side processing, improves ease of use, reduces upload traffic consumption, and reduces the complexity of server-side design. In addition, it can support upload on mobile devices such as mobile terminals.

[0014] It is to be understood that the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the present specification. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the specification and, together with the description, serve to explain the principles of the specification.

[0016] Figure 1 It is a schematic diagram of a system architecture shown in this specification according to an exemplary embodiment.

[0017] Figure 2 The flowchart of a method for uploading a container image is shown in this specification according to an exemplary embodiment.

[0018] Figure 3 It is a schematic diagram of an image file list according to an exemplary embodiment of this specification.

[0019] Figure 4 The flowchart of another method for uploading a container image is shown in this specification according to an exemplary embodiment.

[0020] Figure 5 It is a hardware structure diagram of the computer device where the device for uploading the container image in the embodiment of this specification is located.

[0021] Figure 6 It is a block diagram of a device for uploading a container image according to an exemplary embodiment of the present specification. DETAILED DESCRIPTION

[0022] Exemplary embodiments will be described in detail herein, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The implementations described in the following exemplary embodiments do not represent all implementations consistent with this specification. Instead, they are merely examples of devices and methods consistent with some aspects of this specification as detailed in the appended claims.

[0023] The terms used in this specification are for the purpose of describing specific embodiments only and are not intended to limit this specification. The singular forms "a", "the" and "the" used in this specification and the appended claims are also intended to include plural forms unless the context clearly indicates otherwise. It should also be understood that the term "and / or" used herein refers to and includes any or all possible combinations of one or more associated listed items.

[0024] It should be understood that although the terms first, second, third, etc. may be used in this specification to describe various information, this information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of this specification, the first information may also be referred to as the second information, and similarly, the second information may also be referred to as the first information. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".

[0025] Next, the embodiments of this specification are described in detail.

[0026] The following combination Figure 1 The system architecture of the method and device for uploading container images in the embodiments of this specification is described. It should be noted that: Figure 1 What is shown is merely an example of a system architecture to which the embodiments of this specification can be applied, to help those skilled in the art understand the technical content of this specification, but it does not mean that the embodiments of this specification cannot be used in other devices, systems, environments or scenarios.

[0027] Figure 1 It is a schematic diagram of a system architecture shown in this specification according to an exemplary embodiment.

[0028] like Figure 1 As shown, the system architecture may include, for example, a terminal device, a network and a server. The network is used to provide a medium for a communication link between the terminal device and the server. The network may include various connection types, such as wired and / or wireless communication links, etc.

[0029] Users can use terminal devices to interact with servers through the network to receive or send messages, etc. Various communication client applications can be installed on the terminal devices, such as service access clients, web browser applications, search applications, instant messaging tools, email clients and / or social platform software.

[0030] The terminal device may be any electronic device having a display screen and supporting web browsing, including but not limited to a smart phone, a tablet computer, a laptop computer, a desktop computer, and the like.

[0031] The server may be a server that provides container image repository services (also referred to as an image repository), which may be used to store and manage container images. Exemplarily, the container image may include a Docker image, and the image repository may include a Docker Registry.

[0032] The following is a detailed description of the method for uploading a container image provided by the embodiment of this specification. Figure 2 As shown, Figure 2This is a flowchart of a method for uploading a container image according to an exemplary embodiment of this specification. The method can be applied to a terminal device. The method for uploading a container image provided by the embodiment of this specification may include the following operations.

[0033] In operation 210, the container image file is decompressed to obtain an image file list, which includes an image manifest and multiple image layered files.

[0034] According to an embodiment of the present specification, a user can use a browser to open an upload page, select a container image file to be uploaded on the upload page, and then the browser can decompress the container image file to be uploaded.

[0035] According to an embodiment of the present specification, the image manifest may include information such as the relationship between the layers and configurations of the image. The image manifest may be expressed in JSON format. The image layered file may include the actual file content of each layer of the image.

[0036] In operation 220, for each image layer file in the plurality of image layer files, it is checked whether the image layer file exists in the image repository.

[0037] In operation 230 , if the image layered file does not exist in the image warehouse, the image layered file is uploaded to the image warehouse.

[0038] According to an embodiment of the present disclosure, for each image layered file, if the image layered file does not exist in the image warehouse, the image layered file is uploaded to the image warehouse. If the image layered file already exists in the image warehouse, the image layered file is skipped, the next image layered file is selected, and the operation of checking whether the image layered file exists in the image warehouse is returned.

[0039] According to an embodiment of the present specification, for example, the image layered file may be sent to a corresponding API (application programming interface) in an image repository through a browser to upload the image layered file.

[0040] In operation 240 , the image manifest is uploaded to the image repository.

[0041] According to an embodiment of the present specification, after all image layered files are uploaded, the browser may send the image manifest to a corresponding API in the image repository, thereby completing the image upload.

[0042] According to an embodiment of the present disclosure, a JavaScript script may be pre-configured to perform the above operations. Based on this, the JavaScript script may be executed using the JavaScript engine of the browser to perform the above operations and achieve the upload of the container image.

[0043] According to the embodiments of this specification, users do not need to install the client environment of the image repository, and can directly upload container images using a browser. The JavaScript framework is used locally in the browser to perform container image parsing and incremental uploads, and the API of the image repository is directly connected, which omits the steps of repeated uploads and server-side processing, improves ease of use, reduces upload traffic consumption, and reduces the complexity of server-side design. In addition, it can support uploads from mobile devices such as mobile terminals.

[0044] Figure 3 It is a schematic diagram of an image file list according to an exemplary embodiment of this specification.

[0045] like Figure 3 As shown in the figure, the image file list can include repositories files, manifest.json files, and multiple image hierarchical files. Among them, the repositories file can contain information such as the image's warehouse and tags. Manifest.json is the image manifest, which can include information such as the image's hierarchy, configuration, and history.

[0046] Optionally, operation 220 may include, for example: reading the image manifest to obtain summary information corresponding to multiple image layered files. Then, for each summary information, a HEAD request corresponding to the summary information is sent to the image repository, so that after the image repository receives the HEAD request, it checks whether the summary information exists in the image repository, and then returns a response to the browser of the terminal device, which response may indicate whether the summary information is found in the image repository. The browser receives the response to the HEAD request sent by the image repository. If the response indicates that the summary information is not found, it is determined that the image layered file corresponding to the summary information does not exist in the image repository. If the response indicates that the summary information has been found, it is determined that the image layered file corresponding to the summary information exists in the image repository.

[0047] For example, a HEAD request could include HEAD / v2 / <name> / blobs / <digest>Among them, / v2 / : represents the version of the image repository API (v2). <name>: Indicates the specific name of the image. / blobs / : Indicates the resource path, which means that you are interacting with a specific blob (that is, the image layer) of the image. <digest>: Indicates the specific digest of the blob. The digest can be, for example, a SHA256 hash value, which is used to uniquely identify the image layer.

[0048] The response to the HEAD request may include a status code to indicate whether summary information of the image layered file exists in the image repository. The status code may include, for example, 200 and 404. If the status code is 200, it indicates that summary information exists in the image repository, that is, the corresponding image layered file exists. If the status code is 404, it indicates that summary information does not exist in the image repository, that is, the corresponding image layered file does not exist.

[0049] Optionally, operation 230 may include, for example: generating a first PUT request according to the image layer file and the corresponding summary information, and sending the first PUT request to the image repository.

[0050] For example, the first PUT request may include PUT / v2 / <name> / blobs / uploads / <uuid>?digest= <digest>Among them, / v2 / : represents the version of the image repository API (v2). <name>: Indicates the specific name of the image. / blobs / uploads / : Indicates the path related to image layer uploads. <uuid>:A unique identifier for the current upload session. ? digest= <digest>: indicates a query parameter, which is used to specify the digest of the blob to be uploaded. In addition, the body of the first PUT request contains the blob data to be uploaded, that is, the image layered file.

[0051] Optionally, operation 240 may include, for example: generating a second PUT request according to the image list; and sending the second PUT request to the image repository.

[0052] For example, the second PUT request may include PUT / v2 / <name> / manifests / <reference>Among them, / v2 / : indicates the version of the image repository API (v2). <name>: Indicates the specific name of the image. / blobs / uploads / : Indicates the path related to image layer uploads. / manifests / : Indicates the path related to the image manifest. <reference>: Represents a reference to an image, which can be a tag or digest of an image. The request body of the second PUT request can contain the actual image list.

[0053] Optionally, the browser may store the image file list in the browser's cache, for example. Based on this, reading the image list may include: reading the image list from the browser's cache. By storing the image file list in the browser's cache, the browser can read the data in the image file list faster, thereby improving the processing speed.

[0054] like Figure 4 FIG. 1 is a flowchart of another method for uploading a container image according to an exemplary embodiment. The method may include the following steps:

[0055] 1. The user uses a browser to open the upload page and selects the container image file to be uploaded.

[0056] 2. The browser's JavaScript engine executes the JavaScript script. Based on the JavaScript script, the container image file is parsed. This process may include calling a decompression function to decompress the container image file, extracting the image file list therein, and storing it in the browser cache. Among them, the image file list may include, for example: a repositories file, a manifest.json file, and multiple image layer files. Then, read the contents of the manifest.json file and extract the digest information of all layered data (Layers).

[0057] Exemplarily, in this embodiment, manifest.json may include the following content:

[0058] [{

[0059] "Config":

[0060] "1d9a7003271b623bc5634cabf7e1e2b362faeb8507810e15f24c42b52cad1516.json",

[0061] "RepoTags":["registry.uiscloudnative.com / library / helm-api:v1.3"],

[0062] "Layers":

[0063] ["ce0f0799be37a8bf2dbcb5a900f53e284c92c0839f153679b3fdaf1da847b82d / layer.ta r",

[0064] "9e1cde9454d2bba928e0ee44bc7070add1a662eaac46b762b57683ef7cddd029 / layer.tar",

[0065] "d80cbb6932a499713ea268005bc0827655739657b4ac538f78f3d46afc68808c / layer.tar",

[0066] "f03780bae8c483c3e7feb0032f1c95770cbcef0457474be375e1177cabc3c98d / layer.tar",

[0067] "99a68c580f661bfafd08b40411174a2f1a9783851a73b83c7280f01b26811e5c / layer.tar",

[0068] "28da15ea377bad63bbe7045bbc063ae0470e20dc58b8934e435ecef8bfd37345 / layer.tar",

[0069] "3fce060cf5c0df56e498a3fccda1182fa35b24ddc809446a1e6513f632072d73 / layer.tar"]

[0070] } ]

[0072] The Config field is used to indicate the configuration file of the container image. The RepoTags field is the repository identifier. The Layers field is used to indicate the layer of each directory.

[0073] 3. Based on the JavaScript script, call the API (application programming interface) of the image repository to perform the upload operation. The API may be, for example, a RESTful API. More specifically, the process may include, for example, the following loop steps:

[0074] 1) Traverse all image layer data.

[0075] 2) Execute HEAD / v2 / for each layer <name> / blobs / <digest>Operation to query the image repository for layered data. If the image repository returns a response of 200OK, it means that the layer digest exists. It can be assumed that the image layer data of this layer already exists in the image repository. Skip uploading this layer and continue to execute HEAD / v2 / for the next layer. <name> / blobs / <digest>operate.

[0076] 3) If the image repository returns a result other than 200OK, it means that the layer digest does not exist and the image layer data needs to be uploaded. Based on this, you can call PUT / v2 / <name> / blobs / uploads / <uuid>?digest= <digest>, upload the image layer file of the image layer.

[0077] 4) After uploading all image layer data, call PUT / v2 / <name> / manifests / <reference>Send manifest.json to the image repository to complete the container image upload.

[0078] According to the embodiments of this specification, users do not need to install the client of the image repository, and can directly use the browser to upload the container image. The JavaScript framework is used locally in the browser to perform container image parsing and incremental upload, and the API of the image repository is directly connected, which omits the steps of repeated upload and server-side processing, improves ease of use, reduces upload traffic consumption, and reduces the complexity of server-side design. In addition, it can support uploads from mobile devices such as mobile terminals.

[0079] Corresponding to the embodiments of the aforementioned method, this specification also provides embodiments of an apparatus for uploading a container image and a terminal used therein.

[0080] The embodiments of the device for uploading container images in this specification can be applied to computer devices, such as servers or terminal devices. The device embodiments can be implemented through software, hardware, or a combination of software and hardware. Taking software implementation as an example, as a device in a logical sense, it is formed by the processor in which it is located reading the corresponding computer program instructions in the non-volatile memory into the memory and running them. From the hardware level, if Figure 5 As shown, it is a hardware structure diagram of the computer device where the device for uploading the container image in the embodiment of this specification is located, except Figure 5 In addition to the processor 510, memory 530, network interface 520, and non-volatile memory 540 shown, the server or electronic device where the device 531 is located in the embodiment may also include other hardware according to the actual function of the computer device, which will not be described in detail.

[0081] like Figure 6 As shown, Figure 6 This is a block diagram of a device for uploading a container image according to an exemplary embodiment of the present specification, and the device includes:

[0082] A decompression module 610 is used to decompress the container image file using the JavaScript engine of the browser to obtain an image file list, which includes an image manifest and multiple image layered files;

[0083] A checking module 620 is used to use a JavaScript engine of a browser to check whether an image layered file exists in an image repository for each image layered file among a plurality of image layered files;

[0084] The image layered file uploading module 630 is used to upload the image layered file to the image repository by using the JavaScript engine of the browser when the image layered file does not exist in the image repository;

[0085] The image list uploading module 640 is used to upload the image list to the image repository.

[0086] Optionally, the inspection module may include:

[0087] The reading submodule is used to read the image list and obtain summary information corresponding to multiple image layer files;

[0088] The sending submodule is used to send a HEAD request corresponding to each summary information to the image repository;

[0089] The receiving submodule is used to receive the response to the HEAD request sent by the image repository;

[0090] The determination submodule is used to determine that there is no image layered file corresponding to the summary information in the image repository if the response indicates that the summary information is not found.

[0091] Optionally, the image layered file upload module may include:

[0092] A first generating submodule, used to generate a first PUT request according to the image layered file and the corresponding summary information;

[0093] The first sending submodule is used to send a first PUT request to the image repository.

[0094] Optionally, the image list upload module may include:

[0095] The second generation submodule is used to generate a second PUT request according to the image list;

[0096] The second sending submodule is used to send a second PUT request to the image repository.

[0097] Optionally, the device may further include:

[0098] A storage module, used to store the image file list in the browser's cache;

[0099] Based on this, the reading submodule may include:

[0100] The reading unit is used to read the image list from the browser's cache.

[0101] According to the embodiments of this specification, users do not need to install the client environment of the image repository, and can directly upload container images using a browser. The JavaScript framework is used locally in the browser to perform container image parsing and incremental uploads, and the API of the image repository is directly connected, which omits the steps of repeated uploads and server-side processing, improves ease of use, reduces upload traffic consumption, and reduces the complexity of server-side design. In addition, it can support uploads from mobile devices such as mobile terminals.

[0102] Accordingly, the present specification also provides a device for uploading a container image, the device comprising a processor; a memory for storing instructions executable by the processor; wherein the processor is configured to: use the JavaScript engine of the browser to perform the following operations: decompress the container image file to obtain an image file list, the image file list comprising an image manifest and multiple image layered files; for each image layered file in the multiple image layered files, check whether the image layered file exists in the image repository; if the image layered file does not exist in the image repository, upload the image layered file to the image repository; upload the image manifest to the image repository.

[0103] The implementation process of the functions and effects of each module in the above-mentioned device is specifically described in the implementation process of the corresponding steps in the above-mentioned method, which will not be repeated here.

[0104] For the device embodiment, since it basically corresponds to the method embodiment, the relevant parts can refer to the partial description of the method embodiment. The device embodiment described above is only schematic, wherein the modules described as separate components may or may not be physically separated, and the components displayed as modules may or may not be physical modules, that is, they may be located in one place, or they may be distributed on multiple network modules. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this specification. A person of ordinary skill in the art can understand and implement it without paying creative labor.

[0105] The above is a description of a specific embodiment of the specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0106] Those skilled in the art will readily appreciate other embodiments of the specification after considering the specification and practicing the invention claimed herein. The specification is intended to cover any variations, uses or adaptations of the specification that follow the general principles of the specification and include common knowledge or customary techniques in the art that are not claimed in the specification. The specification and examples are to be considered exemplary only, and the true scope and spirit of the specification are indicated by the following claims.

[0107] It should be understood that the present description is not limited to the precise structures that have been described above and shown in the drawings, and that various modifications and changes may be made without departing from the scope thereof. The scope of the present description is limited only by the appended claims.

[0108] The above description is only a preferred embodiment of this specification and is not intended to limit this specification. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of this specification should be included in the scope of protection of this specification.< / reference> < / name> < / digest> < / uuid> < / name> < / digest> < / name> < / digest> < / name> < / reference> < / name> < / reference> < / name> < / digest> < / uuid> < / name> < / digest> < / uuid> < / name> < / digest> < / name> < / digest> < / name>

Claims

1. A method for uploading a container image, characterized in that: The method comprises: Use the browser's JavaScript engine to do the following: Decompress the container image file to obtain an image file list, wherein the image file list includes an image manifest and multiple image layered files; For each image layered file among the multiple image layered files, checking whether the image layered file exists in the image repository; If the image layered file does not exist in the image warehouse, uploading the image layered file to the image warehouse; Upload the image list to the image warehouse.

2. The method according to claim 1, characterized in that: The step of checking, for each image layered file among the plurality of image layered files, whether the image layered file does not exist in the image repository comprises: Reading the image list to obtain summary information corresponding to the plurality of image layered files; For each summary information, Sending a HEAD request corresponding to the summary information to the image repository; Receive a response to the HEAD request sent by the image repository; If the response indicates that the summary information is not found, it is determined that no image layered file corresponding to the summary information exists in the image repository.

3. The method according to claim 2, characterized in that The uploading of the image layered file to the image warehouse comprises: Generate a first PUT request according to the image layered file and the corresponding summary information; Send the first PUT request to the image repository.

4. The method according to claim 1, characterized in that: The uploading of the image list to the image warehouse comprises: Generate a second PUT request according to the image list; Send the second PUT request to the image repository.

5. The method according to claim 2, characterized in that: The method further comprises: Using the browser's JavaScript engine, the image file list is stored in the browser's cache; The reading of the image list comprises: The mirror list is read from the cache of the browser.

6. A device for uploading a container image, characterized in that: The device comprises: A decompression module, used to decompress the container image file using the JavaScript engine of the browser to obtain an image file list, wherein the image file list includes an image manifest and multiple image layered files; A checking module, configured to use a JavaScript engine of a browser to check whether each image layered file in the plurality of image layered files exists in an image repository; An image layered file uploading module, used for uploading the image layered file to the image warehouse by using the JavaScript engine of the browser when the image layered file does not exist in the image warehouse; The image list uploading module is used to upload the image list to the image warehouse.

7. The device according to claim 6, characterized in that The inspection module comprises: A reading submodule, configured to read the image list and obtain summary information corresponding to the plurality of image layered files; A sending submodule, configured to send, for each summary information, a HEAD request corresponding to the summary information to the image repository; A receiving submodule, configured to receive a response to the HEAD request sent by the image repository; The determination submodule is configured to determine that no image layered file corresponding to the summary information exists in the image repository if the response indicates that the summary information is not found.

8. The device according to claim 7, characterized in that The image layered file upload module includes: A first generating submodule, used for generating a first PUT request according to the image layered file and the corresponding summary information; The first sending submodule is used to send the first PUT request to the image repository.

9. The device according to claim 6, characterized in that The image list upload module includes: A second generating submodule, used for generating a second PUT request according to the image list; The second sending submodule is used to send the second PUT request to the image repository.

10. The device according to claim 7, characterized in that The device also includes: A storage module, used for storing the image file list in the cache of the browser; The reading submodule comprises: A reading unit is used to read the image list from the cache of the browser.

Images