Image optimization for pipe workload

Abstract

A computer-implemented method, apparatus, system, and computer program product manage updates to a plurality of images. A computer system determines a plurality of shared layers present between a plurality of images selected for update management. The plurality of images includes executable code that is executed to create a container. The computer system detects a change to a shared layer of the plurality of shared layers for an image of the plurality of images. The computer system updates a shared layer of the plurality of shared layers for a set of images having the shared layer in response to detecting a change to the shared layer for the image. According to other illustrative embodiments, a computer system and computer program product for managing updates to a plurality of images is provided.

Description

Technical Field

[0001] The present disclosure relates generally to improved computer systems, and more particularly to optimizing pipeline workloads. More particularly, the present disclosure relates to computer-implemented methods, apparatus, systems, and computer program products for managing image optimization for pipeline workloads. Background Art

[0002] Such as (a registered trademark of the Linux Foundation, San Francisco, California) provides a platform for automating the deployment, scaling, and operation of containers across a cluster of host nodes. A host node is a physical or virtual machine where a container is deployed. A pod is a group of one or more containers with shared storage and network resources, and a specification of how to run the container. A container can run a workload. An image represents the executable code that is run to create a container.

[0003] Pipeline workloads typically run in a container orchestration environment. Pipeline workloads can include any type of workload. For example, the workload can be artificial intelligence processing, training machine learning models, natural language processing, image processing, computer vision, scientific computing, forecasting, prediction, recommendation, data processing, transaction processing, etc.

[0004] Pipeline workloads divide the workload into many steps. These steps can be executed in sequence in order for the pipeline workload to obtain a result. In a container orchestration environment, containers are used to implement these steps. Each container is used for one of the multiple steps performed by the pipeline workload. For example, pipeline workloads are used with artificial intelligence processing, where the workload is divided into steps that are executed in sequence to perform the process.

[0005] In the case of a pipeline workload, there is an image for each step. When there are hundreds or thousands of steps, it may be difficult to maintain this number of images. For example, if operating system level patches are used on some images, these images are currently patched one by one. This process is complex and error-prone. For example, there are 1000 images, 800 of which use a first Linux version, and 200 of which use a second Linux version. Currently, if a patch is needed for the first Linux version, the user repeatedly builds the image with the patch and uploads the image to the Docker server 800 times. This process is tedious, time-consuming, and error-prone.

[0006] One solution involves using scripts to handle patch requests. The user writes a build with a script that has the build and upload logic. The script is run for each image. However, using a script can still lead to errors because some images with the first Linux version may have been changed, while some images with the first Linux version may not have been changed with the update. Even with the use of a script, a set of image information about which images need to be changed still needs to be manually collected by the user. For example, the user checks all images to identify which images need to be changed and which images have been updated. Maintaining this list is cumbersome, time consuming, and can be error prone.

[0007] As another example, a user may include a script in an image. Once the image is loaded to run a container, the script is executed before the image is run to create a container. The script looks for a patch and applies the patch to the file containing the code for the container before the container runs. This process of obtaining the patch and patching the files in the image before creating the container uses resources such as time and bandwidth. This approach has a performance impact that increases as the number of images with the script that applies the patch increases. When there are thousands of images for a pipeline workload, the performance impact can be severe.

[0008] Therefore, it would be desirable to have a method and apparatus that takes into account at least some of the above-mentioned problems as well as other possible problems.For example, it would be desirable to have a method and apparatus that overcomes the technical problems of maintaining images. Summary of the invention

[0009] According to an illustrative embodiment, a computer-implemented method manages updates to multiple images. A computer system determines multiple shared layers that exist between multiple images selected for update management. The multiple images include executable code that is run to create a container. The computer system detects changes to shared layers in the multiple shared layers for an image in the multiple images. In response to detecting changes to the shared layers for the images, the computer system updates the shared layers in the multiple shared layers for a group of images having the shared layers. According to other illustrative embodiments, a computer system and a computer program product for managing updates to multiple images are provided. As a result, the illustrative embodiments can provide technical effects of improving performance by reducing errors in updated images and improving the performance of updating images by eliminating the need to update the code in each image separately.

[0010] The illustrative embodiments can, in response to detecting a change to the shared layer for the image, permissively update the shared layer in the plurality of shared layers for a group of images having the shared layer by determining a new unique identifier for the shared layer for the image that has changed, identifying the group of images having the shared layer that has changed, and updating the shared layer for the group of images using the new unique identifier for the shared layer that has changed. As a result, the illustrative embodiments can provide a technical effect of improving performance by reducing errors in updated images and improving performance of updating images by eliminating the need to individually update code in each image. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] Figure 1 is a block diagram of a computing environment according to an illustrative embodiment;

[0012] Figure 2 is a block diagram of an imaging environment according to an illustrative embodiment;

[0013] Figure 3 is a diagram of an image that may be managed by an image manager according to an illustrative embodiment;

[0014] Figure 4 is a block diagram illustrating determining a plurality of shared layers existing between a plurality of images according to an illustrative embodiment;

[0015] Figure 5 is an illustration of a table identifying a plurality of shared layers in accordance with an illustrative embodiment;

[0016] Figure 6 is a block diagram illustrating detecting a change in a shared layer according to an illustrative embodiment;

[0017] Figure 7 is a block diagram illustrating updating multiple shared layers according to an illustrative embodiment;

[0018] Figure 8 is a diagram of an image manager for multiple images used in a pipeline workload in accordance with an illustrative embodiment;

[0019] Fig. 9 is a flowchart of a process for identifying a plurality of shared layers in a plurality of images selected for automatic updating in accordance with an illustrative embodiment;

[0020] Fig.10 is a flow chart of a process for detecting changes to a plurality of shared layers between a plurality of images in accordance with an illustrative embodiment;

[0021] Fig.11is a flow chart of a process for monitoring a service port to detect changes to a plurality of shared layers between a plurality of images in accordance with an illustrative embodiment;

[0022] Fig.12 is a flow chart of a process for updating a plurality of shared layers between a plurality of images according to an illustrative embodiment;

[0023] Fig.13 is a flow chart of a process for updating a shared layer for multiple images according to an illustrative embodiment;

[0024] Fig.14 is a flowchart of a process for removing a selected image according to an illustrative embodiment;

[0025] Fig.15 is a flow chart of a process for determining that a plurality of shared layers exist between a plurality of images according to an illustrative embodiment;

[0026] Fig.16 is a flow chart of a process for determining that a plurality of shared layers exist between a plurality of images according to an illustrative embodiment;

[0027] Fig.17 is a flow chart of a process for detecting changes to a shared layer in accordance with an illustrative embodiment;

[0028] Fig.18 is a flow chart of a process for detecting a command to update an image according to an illustrative embodiment;

[0029] Fig.19 is a flowchart of a process for updating a shared layer according to an illustrative embodiment; and

[0030] Fig. 20 is a block diagram of a data processing system in accordance with an illustrative embodiment. DETAILED DESCRIPTION

[0031] Various aspects of the present invention are described by explanatory text, flow charts, block diagrams of computer systems, and / or block diagrams of machine logic, included in computer program product (CPP) embodiments. For any flow chart, depending on the technology involved, the operations may be performed in an order different from the order shown in a given flow chart. For example, two operations shown in consecutive flow chart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that at least partially overlaps in time, also depending on the technology involved.

[0032] Computer program product embodiments ("CPP embodiments" or "CPP") are terms used in this disclosure to describe any collection of one or more storage media (also referred to as "media") that are collectively included in a collection of one or more storage devices that collectively include machine-readable code corresponding to instructions and / or data for performing the computer operations specified in a given CPP claim. A "storage device" is any tangible device that can retain and store instructions for use by a computer processor. A computer-readable storage medium may be an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination of the above. Some known types of storage devices that include these media include: floppy disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or Flash memory), static random access memory (SRAM), compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanical encoding device (such as a punch card or pits / islands formed in a major surface of a disk), or any suitable combination of the above. As the term is used in the present invention, computer readable storage media is not to be interpreted as storage in the form of transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, light pulses through optical cables, electrical signals transmitted through wires and / or other transmission media. As will be appreciated by those skilled in the art, data is typically moved at certain occasional points in time during normal operation of the storage device, such as during access, defragmentation or garbage collection, but this does not make the storage device temporary because the data is not temporary when stored.

[0033] Referring now to the drawings, and in particular to Figure 1, a block diagram of a computing environment is depicted according to an illustrative embodiment. The computing environment 100 includes an example of an environment for executing at least some of the computer code involved in performing the method of the present invention, such as an improved image manager code 190. In the illustrative example, the improved image manager code 190 operates to manage multiple images. For example, an image or pipeline workload can be managed by the improved image manager code 190. In the illustrative example, the improved image manager code 190 is capable of detecting that a shared layer in an image is updated and automatically updating these shared layers in other images containing multiple shared layers corresponding to the shared layer. In addition to the improved image manager code 190, the computing environment 100 also includes, for example, a computer 101, a wide area network (WAN) 102, an end-user device (EUD) 103, a remote server 104, a public cloud 105, and a private cloud 106. In this embodiment, the computer 101 includes a processor group 110 (including a processing circuit 120 and a cache 121), a communication structure 111, a volatile memory 112, a persistent storage device 113 (including an operating system 122 and an improved image manager code 190, as described above), a peripheral device group 114 (including a user interface (UI) device group 123, a storage device 124 and an Internet of Things (IoT) sensor group 125), and a network module 115. The remote server 104 includes a remote database 130. The public cloud 105 includes a gateway 140, a cloud orchestration module 141, a host physical machine group 142, a virtual machine group 143 and a container group 144.

[0034] Computer 101 may take the form of a desktop computer, a laptop computer, a tablet computer, a smart phone, a smart watch or other wearable computer, a mainframe computer, a quantum computer, or any other form of computer or mobile device now known or developed in the future that is capable of running programs, accessing a network, or querying a database, such as remote database 130. As is understood in the art of computer technology, execution of computer-implemented methods may be distributed among multiple computers and / or among multiple locations. On the other hand, in the presentation of this computing environment 100, the detailed discussion focuses on a single computer, particularly computer 101, to keep the presentation as simple as possible. Computer 101 may be located in the cloud, although Figure 1 On the other hand, computer 101 need not be in the cloud unless it can be positively indicated to any extent.

[0035] Processor group 110 includes one or more computer processors of any type now known or to be developed in the future. Processing circuit 120 can be distributed over multiple packages, such as multiple coordinated integrated circuit chips. Processing circuit 120 can implement multiple processor threads and / or multiple processor cores. Cache 121 is a memory located in the processor chip package, typically used for data or code that threads or cores running on processor group 110 should have quick access to. Cache memories are typically organized into multiple levels based on relative proximity to the processing circuit. Alternatively, some or all of the caches of the processor group may be located "off-chip". In some computing environments, processor group 110 may be designed to use quantum bits and perform quantum computing.

[0036] Computer readable program instructions are typically loaded onto the computer 101 to cause the processor group 110 of the computer 101 to execute a series of operating steps to implement a computer-implemented method, such that the instructions so executed will instantiate the method specified in the flowchart and / or illustrative description of the computer-implemented method contained in this document (collectively referred to as the "method of the present invention"). These computer readable program instructions are stored in various types of computer readable storage media, such as cache 121 and other storage media discussed below. The program instructions and related data are accessed by the processor group 110 to control and directly execute the method of the present invention. In the computing environment 100, at least some of the instructions for executing the method of the present invention can be stored in the improved image manager code 190 in the persistent storage device 113.

[0037] The communication fabric 111 is the signaling pathways that allow the various components of the computer 101 to communicate with each other. Typically, the fabric is comprised of switches and conductive pathways, such as those that make up a bus, a bridge, physical input / output ports, etc. Other types of signal communication pathways may be used, such as fiber optic communication pathways and / or wireless communication pathways.

[0038] The volatile memory 112 is any type of volatile memory currently known or developed in the future. Examples include dynamic type random access memory (RAM) or static type RAM. Typically, the volatile memory 112 is characterized by random access, but this is not required unless explicitly indicated. In the computer 101, the volatile memory 112 is located in a single package and is internal to the computer 101, but, alternatively or additionally, the volatile memory can be distributed over multiple packages and / or located externally relative to the computer 101.

[0039] The persistent storage device 113 is any form of non-volatile storage device for a computer known now or to be developed in the future. The non-volatility of the storage device means that the stored data will be maintained regardless of whether power is supplied to the computer 101 and / or whether power is supplied directly to the persistent storage device 113. The persistent storage device 113 can be a read-only memory (ROM), but typically at least a portion of the persistent storage device allows the writing of data, the deletion of data, and the rewriting of data. Some common forms of persistent storage devices include magnetic disks and solid-state storage devices. The operating system 122 can take a variety of forms, such as various known proprietary operating systems or open source portable operating system interface type operating systems using a kernel. The code included in the improved image manager code 190 typically includes at least some computer code involved in executing the method of the present invention.

[0040] The peripheral device group 114 includes a peripheral device group of the computer 101. The data communication connection between the peripheral device and other components of the computer 101 can be implemented in various ways, such as a Bluetooth connection, a near field communication (NFC) connection, a cable connection (such as a universal serial bus (USB) type cable), a plug-in connection (such as a secure digital (SD) card), a connection through a local area communication network, or even a connection through a wide area network such as the Internet. In various embodiments, the UI device group 123 may include components such as a display screen, a speaker, a microphone, a wearable device (such as goggles and smart watches), a keyboard, a mouse, a printer, a touchpad, a game controller, and a tactile device. The storage device 124 is an external storage device (such as an external hard drive) or a pluggable memory (such as an SD card). The storage device 124 can be persistent and / or volatile. In some embodiments, the storage device 124 can take the form of a quantum computing storage device for storing data in the form of quantum bits. In embodiments where computer 101 is required to have a large amount of storage (e.g., computer 101 locally stores and manages a large database), the storage may be provided by a peripheral storage device designed to store very large amounts of data, such as a storage area network (SAN) shared by multiple geographically dispersed computers. IoT sensor group 125 includes sensors that can be used in IoT applications. For example, one sensor may be a thermometer and another sensor may be a motion detector.

[0041] The network module 115 is a collection of computer software, hardware, and firmware that allows the computer 101 to communicate with other computers via the WAN 102. The network module 115 may include hardware, such as a modem or a Wi-Fi signal transceiver, software for packetizing and / or depacketizing data for transmission over a communication network, and / or web browser software for transmitting data over the Internet. In some embodiments, the network control function and the network forwarding function of the network module 115 are executed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software defined networks (SDN)), the control function and forwarding function of the network module 115 are executed on physically separated devices, so that the control function manages multiple different network hardware devices. Computer-readable program instructions for executing the method of the present invention can typically be downloaded to the computer 101 from an external computer or an external storage device via a network adapter card or a network interface contained in the network module 115.

[0042] WAN 102 is any wide area network (e.g., the Internet) capable of transmitting computer data over non-local distances by any technology for transmitting computer data now known or developed in the future. In some embodiments, WAN 102 may be replaced and / or supplemented by a local area network (LAN) designed to transmit data between devices located in a local area such as a Wi-Fi network. WANs and / or LANs typically include computer hardware such as copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and edge servers.

[0043] End-user device (EUD) 103 is any computer system used and controlled by an end-user (e.g., a customer of an enterprise operating computer 101), and may take any of the forms discussed above in connection with computer 101. EUD 103 typically receives data that is helpful and useful from the operation of computer 101. For example, in the hypothetical case where computer 101 is designed to provide recommendations to an end-user, the recommendations would typically be transmitted from network module 115 of computer 101 to EUD 103 via WAN 102. In this way, EUD 103 may display or otherwise present the recommendations to the end-user. In some embodiments, EUD 103 may be a client device, such as a thin client, a heavy client, a mainframe, a desktop, etc.

[0044] Remote server 104 is any computer system that provides at least some data and / or functionality to computer 101. Remote server 104 may be controlled and used by the same entity that operates computer 101. Remote server 104 represents a machine that collects and stores useful data for use by other computers, such as computer 101. For example, in the hypothetical case where computer 101 is designed and programmed to provide recommendations based on historical data, the historical data may be provided to computer 101 from remote database 130 of remote server 104.

[0045] The public cloud 105 is any computer system that is available to multiple entities and provides on-demand availability of computer system resources and / or other computer capabilities, particularly data storage (cloud storage) and computing capabilities, without requiring direct active management by users. Cloud computing typically utilizes resource sharing to achieve consistency and economies of scale. Direct active management of the computing resources of the public cloud 105 is performed by computer hardware and / or software of the cloud orchestration module 141. The computing resources provided by the public cloud 105 are typically implemented by virtual computing environments running on various computers that constitute the host physical machine group 142, which are various physical computers in and / or available for the public cloud 105. The virtual computing environment (VCE) is typically in the form of a virtual machine from the virtual machine group 143 and / or a container from the container group 144. It will be appreciated that these VCEs can be stored as images and can be transferred between various physical machine hosts as images or after the VCE is instantiated. The cloud orchestration module 141 manages the transmission and storage of images, deploys new instances of the VCE, and manages active instances of VCE deployment. Gateway 140 is a collection of computer software, hardware, and firmware that allows public cloud 105 to communicate over WAN 102 .

[0046] Some further explanation of virtualized computing environments (VCEs) will now be provided. A VCE can be stored as an "image." A new active instance of a VCE can be instantiated from an image. Two familiar types of VCEs are virtual machines and containers. Containers are VCEs that use operating system level virtualization. This refers to an operating system feature where the kernel allows multiple isolated user space instances (called containers) to exist. From the perspective of the programs running in them, these isolated user space instances typically behave like real computers. Computer programs running on a normal operating system can utilize all of the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, a program running within a container can only use the contents of that container and the devices assigned to that container, a feature known as containerization.

[0047] Private cloud 106 is similar to public cloud 105, except that the computing resources are only available to a single enterprise. Although private cloud 106 is depicted as communicating with WAN 102, in other embodiments, the private cloud can be completely disconnected from the Internet and can only be accessed through a local / private network. A hybrid cloud is a combination of multiple clouds of different types (e.g., private, community, or public cloud types), typically implemented separately by different vendors. Each of the multiple clouds remains an independent discrete entity, but the larger hybrid cloud architecture is tied together through standardized or proprietary technologies that support orchestration, management, and / or data / application portability between multiple constituent clouds. In this embodiment, both public cloud 105 and private cloud 106 are part of a larger hybrid cloud.

[0048] The illustrative embodiments provide a method, apparatus, system, and computer program product for managing updates to multiple images. A computer system determines multiple shared layers that exist between multiple images selected for update management. The multiple images include executable code that is run to create a container. The computer system detects changes to a shared layer in multiple shared layers for an image in the multiple images. In response to detecting a change to the shared layer for the image, the computer system updates the shared layer in multiple shared layers for a group of images having the shared layer. One or more illustrative examples described herein can provide technical effects of improving performance by reducing errors in updated images and improving the performance of updating images by eliminating the need to update the code in each image separately.

[0049] As used herein, a "set" when used to refer to an item means one or more items. For example, a set of images is one or more images.

[0050] Reference now Figure 2 , depicts a block diagram of an imaging environment according to an illustrative embodiment. In this illustrative example, imaging environment 200 includes a plurality of image processing units that can be used in a plurality of environments such as Figure 1 Components implemented in hardware such as the hardware shown in computing environment 100 in FIG.

[0051] In this illustrative example, image management system 202 in image environment 200 manages plurality of images 204. As depicted, plurality of images 204 include executable code that is executed to create container 206 from plurality of images 204. In this example, the code in plurality of images 204 is contained in binaries, libraries, and other types of files that can be executed.

[0052] In this illustrative example, multiple images 204 may form a pipeline workload 205. In one illustrative example, the pipeline workload 205 formed using multiple images 204 may be an artificial intelligence pipeline 207. In this example, multiple images 204 are for a container 206 that performs steps in the artificial intelligence pipeline 207. When the artificial intelligence pipeline 207 includes a machine learning model, steps such as retrieving data, building a data set, cleaning data, transforming data, model training, model evaluation, etc. may be performed in the artificial intelligence pipeline 207. In addition, when the artificial intelligence pipeline 207 involves training a machine learning model, the training may include steps such as data set splitting, algorithm selection, analyzing training data, and hyperparameter tuning.

[0053] Container 206 is a container running in container orchestration platform 208, which may be, for example, architecture, environment, etc. However, it should be understood that the use of The description of the illustrative example is only meant to be an example architecture, not a limitation of the illustrative embodiments. In this example, container 206 is used as a workload for an application running in container orchestration platform 208.

[0054] As shown, the image management system 202 includes a computer system 210 and an image manager 212. The image manager 212 is located in the computer system 210.

[0055] Image manager 212 may be implemented in software, hardware, firmware, or a combination thereof. When software is used, the operations performed by image manager 212 may be implemented in program instructions configured to run on hardware such as a processor unit. When firmware is used, the operations performed by image manager 212 may be implemented in program instructions and data and stored in persistent memory to run on a processor unit. When hardware is employed, the hardware may include circuits that operate to perform the operations in image manager 212.

[0056] In an illustrative example, the hardware can take the form of at least one selected from a circuit system, an integrated circuit, an application specific integrated circuit (ASIC), a programmable logic device, or some other suitable types of hardware configured to perform multiple operations. For a programmable logic device, the device can be configured to perform these operations. The device can be reconfigured at a later time, or can be permanently configured to perform these operations. Programmable logic devices include, for example, programmable logic arrays, programmable array logic, field programmable logic arrays, field programmable gate arrays, and other suitable hardware devices. In addition, these processes can be implemented in organic components integrated with inorganic components, and can be composed entirely of organic components other than humans. For example, these processes can be implemented as circuits in organic semiconductors.

[0057] The computer system 210 is a physical hardware system and includes one or more data processing systems. When there are more than one data processing systems in the computer system 210, these data processing systems communicate with each other using a communication medium. The communication medium may be a network. The data processing system may be selected from at least one of a computer, a server computer, a tablet computer, or some other suitable data processing system.

[0058] As used herein, the phrase "at least one of" when used with a list of items means that different combinations of one or more of the listed items can be used, and only one of each item in the list may be required. In other words, "at least one of" means that any combination of the items in the list and any number of items may be used, but not all of the items in the list are required. An item may be a specific object, thing, or category.

[0059] For example, but not limited to, "at least one of item A, item B, or item C" may include item A, item A and item B, or item B. This example may also include item A, item B, and item C, or item B and item C. Of course, there may be any combination of these items. In some illustrative examples, "at least one" may be, for example, but not limited to, two items A; one item B and ten items C; four items B and seven items C; or other suitable combinations.

[0060] As depicted, computer system 210 includes multiple processor units 214 capable of executing program instructions 216 that implement the process in the illustrative example. As used herein, a processor unit in multiple processor units 214 is a hardware device and includes hardware circuits such as hardware circuits on an integrated circuit that respond to and process instructions and program instructions for operating a computer. When multiple processor units 214 execute program instructions 216 for a process, multiple processor units 214 are one or more processor units that can be on the same computer or on different computers. In other words, the process can be distributed between processor units on the same or different computers in the computer system.

[0061] In addition, the plurality of processor units 214 may be processor units of the same type or of different types. For example, the plurality of processor units 214 may be selected from at least one of a single-core processor, a dual-core processor, a multi-processor core, a general-purpose central processing unit (CPU), a graphics processing unit (GPU), a digital signal processor (DSP), or some other type of processor unit.

[0062] Image manager 212 may manage changes to plurality of images 204. In this illustrative example, plurality of images 204 have been selected for management regarding plurality of shared layers 218 existing between plurality of images 204. Multiple shared layers 218 in plurality of images 204 means that the layers exist between all of plurality of images 204 or a subset of plurality of images 204. Image manager 212 determines multiple shared layers 218 existing between plurality of images 204 that are selected for update management.

[0063] In this example, image manager 212 detects change 219 of shared layer 220 in plurality of shared layers 218 in image 222 in plurality of images 204. Change 219 may be caused, for example, by a patch in the form of an operating system, an update library, or other change to shared layer 218. Shared layer 220 having change 219 becomes updated shared layer 224.

[0064] In this example, image manager 212 updates shared layer 220 in plurality of shared layers 218 in set of images 204 having shared layer 220 in response to detecting a change to shared layer 220 in image 222 .

[0065] An update to the set of images 204 having the shared layer 220 may occur by including the shared layer 220 having the change 219 in the set of images 204 of the shared layer 220 without the change 219. In other words, the executable code for the corresponding layer in the set of images 204 does not need to be patched. Instead, the shared layer 220 having the change 219 may be used to replace the shared layer 220 without the change 219 that existed in the set of images 204 prior to the update performed by the image manager 212.

[0066] For example, the plurality of images 204 includes 600 images 204, and 350 of the plurality of images 204 may have a shared layer 220. As a result, when a change 219 is made to the shared layer 220 in one of the 350 images, the other 349 images may be updated to use the shared layer 220 with the change 219. This change to the other 349 images in the plurality of images 204 is made without applying a patch to the actual code in the files for the shared layer 220. Instead, the layers may be updated to reference or point to the updated shared layer 224, which is the shared layer 220 with the change 219. Thus, the image manager 212 automatically updates the plurality of shared layers 218 for the plurality of images 204 in response to detecting a change in the plurality of shared layers 218.

[0067] Additionally, the selected image 226 in the plurality of images 204 can be removed from the plurality of images 204. This removal of the selected image 226 can be performed in response to user input to maintain automatic updates to the selected image 226. In response to removing the selected image 226 from the plurality of images 204, the image manager 212 no longer considers the selected image 226 for updating.

[0068] For example, when shared layer 220 is an operating system, an updated version of the operating system may not work with other layers in plurality of images 204. Images in which the update to the shared layer causes problems may be removed from plurality of images 204 so that image manager 212 does not perform automatic updates on selected images 226. These problems may be, for example, execution errors, performance degradation, or other problems.

[0069] In one illustrative example, there are one or more technical solutions that overcome the technical problem of managing updates to images when there are a large number of images. As a result, one or more technical solutions can provide a technical effect of managing images by identifying a plurality of shared layers common between a plurality of images, detecting changes in the shared layers, and updating a plurality of shared layers in the plurality of images corresponding to the updated shared layers. In one illustrative example, there can be a technical effect of reducing errors in updated images and improving performance by eliminating the need to update code in each image individually.

[0070] Steering Figure 3 , depicts diagrams of images that may be managed by an image manager according to an illustrative embodiment. In illustrative examples, the same reference numeral may be used in more than one figure. Reference numerals are repeated in different figures to denote the same element in the different figures.

[0071] An example of information that may be present in an image 222 is shown in this figure. As shown, the image 222 includes a file 301, image information 302, and layer context information 303.

[0072] In this example, file 301 includes executable code for layer 304, which can be executed to create a container for image 222. The executable code can be in the form of machine-readable code that can be executed by a processor unit in a computer, such as binary code and libraries.

[0073] Image information 302 is metadata containing information about image 222. In this example, image information 302 may include image name, owner, creation file, size, creation time, and other information.

[0074] In this illustrative example, layer context information 303 is metadata that contains information about layers 304 in file 301. For example, layer context information 303 may be a list of unique identifiers (UIDs) 306 for layers 304 of image 222. Thus, unique identifiers 306 are pointers to layers 304 for image 222 and may be used to obtain files 301 for layers 304 when files 301 for layers 304 are not stored with image 222. By using unique identifiers 306 for layers 304, storage space for images can be reduced.

[0075] As depicted in the illustrative example, file 301 for layer 304 of image 222 may be stored in a location different from image information 302 and layer context information 303, and referenced by layer context information 303 at that location. In this illustrative example, when used to implement multiple images 204 managed by image manager 212, image 222 may include image information 302 and layer context information 303 without file 301. In other words, image manager 212 stores image information 302 and layer context information 303, but does not store file 301 for layer 304. As a result, when file 301 is needed to run Figure 2 When multiple images 204 are included, the images may be retrieved for Figure 2 A file 301 of layer 304 of multiple shared layers 218.

[0076] When image 222 is sent to a requester for use, the requester receives image 222 with image information 302 and layer context information 303. The requester can use unique identifier 306 and layer context information 303 to obtain file 301 for layer 304. In this illustrative example, unique identifier 306 references a location where file 301 can be found. For example, unique identifier 306 points to a container repository containing files for layer 304. In the case of retrieving file 301, image 222 is in a form that can be executed to create a container.

[0077] Next reference Figure 4 , a block diagram illustrating determining the presence of multiple shared layers between multiple images is depicted in accordance with an illustrative embodiment. Information for multiple images 204 may be used to determine the presence of multiple shared layers 218 between multiple images 204.

[0078] Image manager 212 may use context information 400 for multiple images 204 to determine multiple shared layers 218 that exist between multiple images 204 selected for update management. In this illustrative example, the determination of multiple shared layers 218 that exist between multiple images 204 selected for update management may be performed by image manager 212 using layer context information for multiple images 204.

[0079] For example, image manager 212 can compare unique identifiers (UIDs) 402 for layers 404 of multiple images 204 to each other. Layers 404 between multiple images 204 that have matching unique identifiers form multiple shared layers 218 between the images. For example, a selected image in multiple images 204 can have a selected layer that has a unique identifier UID1 that identifies the selected layer as a Linux operating system. Each layer in other images in multiple images 204 that has UID1 as a unique identifier is a shared layer to the selected layer.

[0080] Therefore, the plurality of layers 404 for the images having the unique identifier UID1 is a set of shared layers 218 in the plurality of layers 404. In other words, the plurality of layers 404 for the images 204 having UID1 as the unique identifier is a set of shared layers 218.

[0081] Multiple sets of shared layers may exist between the multiple images 204. For example, another unique identifier UID2 in the layer in the selected image may be for the C library. Comparison of the unique identifier UID2 with the unique identifiers (UIDs) 402 for other images in the multiple images 204 may be used to identify that the same layer is used for some or all of the multiple images 204 to form another set of shared layers 218. As a result, the multiple layers 404 with the unique identifier UID2 are a set of shared layers 218.

[0082] In this illustrative example, image manager 212 collects information 405 about a relationship of multiple images 204 to multiple shared layers 218 by determining the presence of multiple shared layers 218 between multiple images 204. Information 405 may be stored in data structure 406. Data structure 406 may include at least one of a database, a table, a linked list, a flat file, or some other suitable type of data structure that may be used to store information 405 about multiple shared layers 218 and multiple images 204 that contain multiple shared layers 218.

[0083] Next turn Figure 5 , depicts a diagram of a table identifying shared layers according to an illustrative embodiment. In this illustrative example, shared layer table 500 is a table that can be used to implement Figure 4An example of a table in a database in data structure 406 .

[0084] As depicted in shared layer table 500, layer column 501 identifies the layer name, UID column 502 identifies the unique identifier of the layer, and layer creation date 504 identifies the date the shared layer was created. This creation date in shared layer table 500 can be compared to the creation date of the layer in the image being checked for changes. The comparison can be made to determine whether a change occurred between the time the shared layer was added to shared layer table 500 and the time the image with the shared layer is being checked. Additionally, in shared layer table 500, image name 505 identifies the image in which the layer with the unique identifier exists.

[0085] As depicted in this simplified example, in row 510, the shared layer is Linux with a unique identifier UIDA. The shared layer was created at 5:18 on 16.02.2022. In this example, UIDA uniquely identifies the shared layer Linux in the repository. UIDA can take various forms, such as a hash number, an alphanumeric value, a uniform resource locator, or some other value that uniquely distinguishes Linux from other layers. For this example, image X, image Y, and image Z are images with Linux as a layer with a unique identifier UIDA. The unique identifier can be used as an index to find an image with a shared layer.

[0086] As another example, row 512 in shared layer table 500 is named centos:7 and has a unique identifier UIDB. The shared layer has a creation date of 7.04.2022 10:18. The images with this shared layer are image A, image C, and image F. In other words, all three images have the same shared layer.

[0087] In yet another example, row 514 is for a shared layer named Data Collection with a unique identifier UIDC. The shared layer has a creation date of 11.06.2022 17:21. In this example, the images with the shared layer are Image A and Image X.

[0088] In addition to identifying images with shared layers, shared layer table 500 can also be used to identify shared layers in an image. For example, an image name can be used to search shared layer table 500 for shared layers for an image with the image name. As shown, image A has two shared layers with unique identifiers UIDB and UIDC. Additionally, image X has two shared layers identified using unique identifiers UIDA and UIDC. Image Y and image Z have a single shared layer with unique identifier UIDA. Image C and image F have a single shared layer with unique identifier UIDB.

[0089] The shared layer table 500 is an illustration of how information is determined from identifying shared layers between images and how the information can be used by Figure 2 1 and 2. In other illustrative examples, shared layer table 500 may have hundreds or thousands of rows.

[0090] In this illustrative example, the image name in the image name 505 column uniquely distinguishes the image from other images. In other illustrative examples, an image identifier may be used in addition to or instead of an image name. In other illustrative examples, a separate table may be used where each image is represented by a row with a layer name and a unique identifier for the layer that is a shared layer in the image.

[0091] As another example, the shared layer table 500 may also include additional information. For example, the creation date of the image may be stored for the image name. The creation date may be used to determine whether the image has changed since the image was checked to identify the shared layers of the shared layer table 500.

[0092] Next reference Figure 6 , a block diagram illustrating detecting changes in shared layers is depicted in accordance with an illustrative embodiment. In this illustrative example, image manager 212 may detect changes 219 to shared layers 220 in multiple shared layers 218 in a number of different ways. For example, image manager 212 may detect local file changes 606 to multiple shared layers 218 for multiple images 204 by inspecting multiple images 204 stored on image server 602, monitoring a service port 604 for uploading multiple images 204 to image server 602, or monitoring local file changes 606. In this example, image server 602 may be a Docker server.

[0093] For example, image manager 212 checks multiple images 204 stored on image server 602 to find changed images. For example, image manager 212 can detect changes to image 222 using image information 302 for image 222 indicating that image 222 has changed. In this illustrative example, any updates or patches to image 222 are reflected in image information 302. For example, changes to layers in image 222 cause the created time to be updated to the latest build. This information obtained for image 222 can be compared with the image information stored in data structure 406 for image 222.

[0094] In response to identifying a change to image 222 using image information 302, image manager 212 may, in response to detecting the change to image 222, determine that shared layer 220 in image 222 has changed using layer context information 303 for image 222 indicating that shared layer 220 for image 222 has changed. For example, the UID in layer context information 303 for image 222 may be compared with layer context information stored for image 222. Layer context information 303 may be used for comparison and may be used in a manner such as Figure 5 The shared layer table 500 in the data structure 406 is stored in the form of one or more tables.

[0095] In another illustrative example, changes to image 204 may be monitored via service port 604. For example, if image 222 is uploaded to service port 604, detecting the upload of image 222 may enable image manager 212 to determine whether a change to image 222 has occurred and whether the change includes a shared layer. For this example, multiple images 204 are checked as they are uploaded to image server 602 using service port 604.

[0096] In another example, local file changes 606 can be used to determine whether an update to a shared layer has occurred for an image 222. For example, the image manager 212 can detect a command 608 used as part of the local file changes 606 to update the image 222. For example, the image manager 212 can detect the command 608 to update the image 222. The image manager 212 can determine that a shared layer 220 for the image 222 has changed based on the command 608 for the plurality of layers for the image 222. In the example depicted here, in response to detecting the command 608 to update the image 222, the command can indicate that a shared layer 220 in the plurality of layers 218 has changed.

[0097] For example, when the image is used in When in a container orchestration platform of Docker, commands 608 may be located in a Dockerfile 609. These commands are executed to build image 222. A user may create a Dockerfile 609 containing commands 608, which includes a unique identifier for a layer for image 222. The user may then use the Dockerfile 609 containing commands 608 to execute the Docker build commands.

[0098] In the depicted example, image manager 212 detects the execution of command 608 in Dockerfile 609 and can identify the layer referenced by the command. The command can use unique identifiers that can then be used to determine whether changes have occurred in multiple shared layers 218 for image 222.

[0099] Steering Figure 7 , a block diagram illustrating updating multiple shared layers is depicted according to an illustrative embodiment. In this illustrative example, image manager 212 may update shared layer 220 in multiple shared layers 218 in set of images 204 having shared layer 220. The update may be performed by image manager 212 in response to detecting a change to shared layer 220.

[0100] In this illustrative example, image manager 212 determines that shared layer 220 for image 222 has changed and has a new unique identifier 700 replacing previous unique identifier 702. In this example, shared layer 220 is for image 222 that has changed.

[0101] The determination of the previous unique identifier 702 may be performed using the creation date of the shared layer 220 and information in the data structure 406, which may be Figure 5 406. For example, the creation dates of the plurality of shared layers 218 for the image 222 can be compared with the creation dates of those shared layers stored in the data structure 406. The unchanged shared layers in the plurality of shared layers 218 have the same creation date. When compared to the entry for the shared layer 220 in the data structure 406, the newer creation date of the shared layer 220 indicates that the shared layer 220 has changed.

[0102] In this example, the unique identifier for the shared layer 220 in the data structure 406 is different from the new unique identifier 700 for the shared layer 220. The unique identifier for the shared layer 220 in the data structure 406 is the previous unique identifier 702.

[0103] Additionally, the data structure 406 can be used to identify the shared layers 220 for other images in the plurality of images 204. Thus, the image manager 212 identifies the set of images 204 having the shared layers 220 that have changed. The plurality of shared layers 218 for the images 204 can be determined using the data structure 406 in which the previous unique identifier 702 of the shared layer 220 has been changed to the new unique identifier 700.

[0104] The image manager 212 updates the shared layer 220 for the group of images using the changed new unique identifier 700 for the shared layer. The update may be performed to change the previous unique identifier 702 to the new unique identifier 700 for the shared layer 220 for the plurality of images 204 identified using the data structure 406. The update may be performed in a number of different ways.

[0105] As a result, the set of shared layers 218 in the set of images 204 is updated. The update can be performed without applying a patch to change the code in the files in the set of images 204.

[0106] Figure 2 The computer system 210 in the embodiment may be configured to perform at least one of the steps, operations, or actions described in the different illustrative examples using software, hardware, firmware, or a combination thereof. As a result, the computer system 210 operates as a special-purpose computer system, wherein the image manager 212 in the computer system 210 enables automatic management of images. In particular, the image manager 212 transforms the computer system 210 into a special-purpose computer system compared to currently available general-purpose computer systems without the image manager 212.

[0107] In the illustrative example, the use of the image manager 212 in the computer system 210 integrates the process into the actual application by managing updates to the images for the containers, which improves the performance of the computer system 210. In other words, the image manager 212 in the computer system 210 involves the actual application of the processes integrated into the image manager 212 in the computer system, which processes identify shared layers in the image, detect changes to the shared layers in the image, and update the shared layers with the changes in the image.

[0108] Figure 2-7 The diagram of the imaging environment 200 and different components in the illustrative embodiment is not meant to imply physical or architectural limitations on the manner in which the illustrative embodiments can be implemented. Other components other than the components shown or other components that replace the components shown can be used. Some components may be unnecessary. In addition, these frames are presented to illustrate some functional components. When implemented in the illustrative embodiments, one or more of these frames can be combined, divided, or combined and divided into different frames.

[0109] For example, in addition to or as an alternative to container orchestration platform 208, image 204 can be used to create container 206 on one or more container orchestration platforms. As another example, another table other than shared layer table 500 can be used for data structure 406. For example, the image table can be used to identify images and shared layers for the images. In other words, the image name can be indexed to identify the shared layers used by the image.

[0110] Reference now Figure 8 , depicts an illustration of an image manager for multiple images used in a pipeline workload according to an illustrative embodiment. In this illustrative example, the image manager 800 is Figure 2800. In this example, image manager 800 manages image X 802, image Y 804, and image Z 806. In this example, each of these images can be run to create a container for an artificial intelligence pipeline. Only three images are shown to illustrate how image manager 800 can manage different aspects of images. When implemented, image manager 800 can manage many more images, such as hundreds or thousands of images.

[0111] In this example, image X 802, image Y 804, and image Z 806 have been selected for management by image manager 800. In this example, image X 802 includes a data collection layer 810 and a Linux layer 812. Image Y 804 includes a data cleansing layer 814 and a Linux layer 816, and image Z 806 includes a module training layer 818 and a Linux layer 820.

[0112] In this depicted example, image manager 800 examines the images and identifies shared layers 822, which include Linux layer 812, Linux layer 816, and Linux layer 820. In this example, the shared layers have the same unique identifier. Image manager 800 establishes a shared list 824 and shared layers 822 for these images.

[0113] The identity of shared layer 822 may be determined using a unique identifier of shared layer 822 found in the layer context information for the image. In this illustrative example, the layer context information may be obtained by inspecting the image or from detecting a command that created the image.

[0114] In this illustrative example, image manager 800 can monitor images to detect updates performed on one or more of the images. For example, image manager 800 can detect changes to shared layer 822 by checking images stored in image server 830, monitoring a service port for uploading images, or monitoring local file changes.

[0115] For example, a user may perform a local file change that patches image X 802. The patch changes Linux layer 812, resulting in a change in the unique identifier of Linux layer 812. In response to detecting the change, image manager 800 may update the unique identifier for Linux layer 816 in image Y 804 and Linux layer 820 for image Z 806. With this update, all shared layers 822 now have the same unique identifier. This update is also made by image manager 800 to shared list 824 for future comparisons.

[0116] In this illustrative example, when images are updated, those updated images can be uploaded to other locations, such as image servers 830 in cloud 832. Image servers 830 can be Docker servers. Thus, image manager 800 can manage complex image updates for a large number of images for pipeline workloads. These images for pipeline workloads can be hundreds of thousands of images. Image manager 800 can identify shared layers between images, monitor images for changes to shared layers, and update corresponding shared layers for other images in response to detecting changes to shared layers.

[0117] When automatic updates to shared layers are not needed, images can be removed from the shared list 824. For example, if an update to a shared layer in an image in the shared list 824 causes other layers to execute incorrectly or erroneously, the image can be removed from the shared list 824. In this way, errors caused by current techniques for updating can be avoided and the quality of pipeline workloads can be improved.

[0118] Next turn Fig. 9 , a flowchart of a process for identifying multiple shared layers in multiple images selected for automatic updating is depicted in accordance with an illustrative embodiment. Fig. 9 The processes in may be implemented in hardware, software, or both. When implemented in software, the processes may take the form of program instructions executed by one or more processor units in one or more hardware devices in one or more computer systems. For example, the processes may be implemented in Figure 2 The image manager 212 in the computer system 210 and Figure 8 The image manager 800 is implemented in .

[0119] The process begins by identifying images for automatic updating (step 900). The process identifies shared layers in all images selected for automatic updating (step 902). In step 902, identification of shared layers can be performed by identifying unique identifiers of shared layers. These unique identifiers can be used to retrieve files of shared layers from a container repository.

[0120] The process compares the layers between the images to identify the same layers between the images (step 904). The comparison can be performed by comparing the unique identifiers between the layers in the images. Layers with the same unique identifiers between the images are shared layers.

[0121] The process builds a list of images and shared layers (step 906). Thereafter, the process terminates. In step 906, the list may take the form of Figure 4 The data structure 406 may be in the form of a data structure, and may take the form of Figure 5The shared layer table 500 is in the form of.

[0122] When new images are to be added, the process can be repeated. In addition, images can be removed from the list so that those removed images are not automatically updated.

[0123] Reference now Fig.10 , a flowchart of a process for detecting changes to multiple shared layers between multiple images is depicted in accordance with an illustrative embodiment. Fig.10 The processes in may be implemented in hardware, software, or both. When implemented in software, the processes may take the form of program instructions executed by one or more processor units in one or more hardware devices in one or more computer systems. For example, the processes may be implemented in Figure 2 The image manager 212 in the computer system 210 and Figure 8 The image manager 800 is implemented in .

[0124] The process begins by detecting a change in an image among a plurality of images managed for automatic updating (step 1000). The process identifies shared layers in the image (step 1002). The process compares the shared layers with corresponding shared layers in other images to determine whether the shared layers between the image having the change and the other images are the same (step 1004).

[0125] The process determines, based on the comparison, whether any changes to the plurality of layers are to a set of shared layers in the image having the changes (step 1006). Thereafter, the process terminates.

[0126] Reference now Fig.11 , a flowchart of a process for monitoring a service port to detect changes to multiple shared layers between multiple images is depicted in accordance with an illustrative embodiment. Fig.11 The processes in may be implemented in hardware, software, or both. When implemented in software, the processes may take the form of program instructions executed by one or more processor units in one or more hardware devices in one or more computer systems. For example, the processes may be implemented in Figure 2 The image manager 212 in the computer system 210 and Figure 8 The image manager 800 is implemented in .

[0127] The process begins by detecting an upload of an image to an image server through a service port (step 1100). The process determines whether the image is a subscription image for management (step 1102). If the updated image is not a subscription image for management, the process terminates.

[0128] Otherwise, the process obtains information about multiple layers for the uploaded image (step 1104). In step 1104, the layer information is layer context information that can be obtained from a folder in the multiple folders storing the multiple images. For example, the folders can be in a container repository. Figure 5 A data structure of the shared layer table 500 in FIG. 5 can be used to determine which images have multiple shared layers that should be compared to each other.

[0129] The process compares each shared layer in the uploaded image with the corresponding shared layers in the other images to determine if there are changes to the shared layers in the uploaded image (step 1106). This determination can be made by comparing the unique identifiers in the shared layers in the uploaded image with the corresponding shared layers in the other images. Thereafter, the process terminates.

[0130] Reference now Fig.12 , a flowchart of a process for updating multiple shared layers between multiple images is depicted in accordance with an illustrative embodiment. Fig.12 The processes in may be implemented in hardware, software, or both. When implemented in software, the processes may take the form of program instructions executed by one or more processor units in one or more hardware devices in one or more computer systems. For example, the processes may be implemented in Figure 2 The image manager 212 in the computer system 210 and Figure 8 The image manager 800 is implemented in .

[0131] The process begins by identifying a plurality of images having a plurality of shared layers for updating (step 1200). The process removes unique identifiers of shared layers in the plurality of images to be updated (step 1202). The process replaces the removed unique identifiers with new unique identifiers of the detected updated shared layers (step 1204). Thereafter, the process terminates.

[0132] In this illustrative example, when a shared layer is updated, the updated shared layer can be stored in a repository such as a container repository. A new unique identifier is created for the updated shared layer. The new unique identifier can be used to replace the previous unique identifier so that the image now points to the updated shared layer instead of the old shared layer that was not updated.

[0133] For a shared layer used in multiple images, only a single file is needed. When the image is ready to run to create a container, the unique identifier is used to retrieve the shared layer. As a result, the file containing the code for the updated shared layer can be retrieved for use in the image, rather than patching the file after retrieval and before running the image.

[0134] Now turn to Fig.13 , a flowchart of a process for updating a shared layer for multiple images is depicted in accordance with an illustrative embodiment. Fig.13 The processes in may be implemented in hardware, software, or both. When implemented in software, the processes may take the form of program instructions executed by one or more processor units in one or more hardware devices in one or more computer systems. For example, the processes may be implemented in Figure 2 The image manager 212 in the computer system 210 and Figure 8 The image manager 800 is implemented in .

[0135] The process begins by determining a plurality of shared layers existing between a plurality of images selected for update management, wherein the images include executable code that is executed to create a container (step 1300). The process detects a change to a shared layer in a plurality of shared layers for an image in the plurality of images (step 1302). The process updates a shared layer in a plurality of shared layers for a set of images having shared layers in response to detecting the change to the shared layer for the image (step 1304). Thereafter, the process terminates.

[0136] Steering Fig.14 , a flowchart of a process for removing a selected image is depicted in accordance with an illustrative embodiment. Fig.14 The process shown is comparable to Fig.13 The process removes the selected image from the plurality of images identified for management (step 1400) in response to user input to terminate automatic updates to the selected image. Thereafter, the process terminates.

[0137] refer to Fig.15 , a flowchart of a process for determining that multiple shared layers exist between multiple images is depicted in accordance with an illustrative embodiment. Fig.15 The process shown is Fig.13 The process uses the layer context information for the multiple images to determine multiple shared layers that exist between the multiple images selected for update management (step 1500). Thereafter, the process terminates.

[0138] Next turn Fig.16 , a flowchart of a process for determining that multiple shared layers exist between multiple images is depicted in accordance with an illustrative embodiment. Fig.16 The process shown in Fig.13 An example of one implementation of step 1300 in FIG.

[0139] The process determines, using a command for building multiple images, multiple shared layers that exist between multiple images selected for update management (step 1600). Thereafter, the process terminates.

[0140] Steering Fig.17 , a flowchart of a process for detecting changes to a shared layer is depicted in accordance with an illustrative embodiment. Fig.17 The process shown in Fig.13 An example of one implementation of step 1302 in FIG.

[0141] The process begins by detecting a change to an image using image information for the image indicating that the image has changed (step 1700). The process, in response to detecting the change to the image, determines that a shared layer for the image has changed using layer context information for the image indicating that the shared layer has changed (step 1702). Thereafter, the process terminates.

[0142] refer to Fig.18 , a flowchart of a process for detecting a command to update an image is depicted in accordance with an illustrative embodiment. Fig.18 The process shown in Fig.13 An example of one implementation of step 1302 in FIG.

[0143] The process begins by detecting a command to update an image (step 1800). The process, in response to detecting the command to update the image, determines that a shared layer for the image has changed based on a command for multiple layers for the image indicating that a shared layer in the multiple layers has changed (step 1802). Thereafter, the process terminates.

[0144] Steering Fig.19 , a flowchart of a process for updating a shared layer is depicted in accordance with an illustrative embodiment. Fig.19 The process shown in Fig.13 An example of one implementation of step 1304 in FIG.

[0145] The process begins by determining a new unique identifier for a shared layer for an image that has changed (step 1900). The process identifies a group of images with a shared layer that has changed (step 1902). The process updates the shared layer for the group of images using the new unique identifier for the shared layer that has changed (step 1904). Thereafter, the process terminates.

[0146] The flow chart and block diagram in the different embodiments of description illustrate the framework, function and operation of some possible implementations of the device and method in the illustrative embodiment.In this regard, each frame in the flow chart or block diagram can represent at least one of a part of a module, segment, function or operation or step.For example, one or more frames can be implemented as a combination of program instructions, hardware or program instructions and hardware.When implemented in hardware, the hardware can, for example, take the form of an integrated circuit that is manufactured or configured to perform one or more operations in the flow chart or block diagram.When implemented as a combination of program instructions and hardware, the embodiment can take the form of firmware.Each frame in the flow chart or block diagram can be implemented using a combination of a dedicated hardware system or dedicated hardware that performs different operations and the program instructions run by the dedicated hardware.

[0147] In some alternative implementations of the illustrative embodiments, one or more functions marked in the blocks may not occur in the order marked in the figure. For example, in some cases, two blocks shown in succession may be executed substantially simultaneously, or the blocks may sometimes be executed in reverse order, depending on the functions involved. In addition, other blocks may be added in addition to the blocks shown in the flowchart or block diagram.

[0148] Now turn to Fig. 20 , depicts a block diagram of a data processing system according to an illustrative embodiment. The data processing system 2000 may be used to implement Figure 1 The data processing system 2000 can also be used to implement the computer and computing devices in the computing environment 100. Figure 2 2000. In this illustrative example, data processing system 2000 includes communications framework 2002, which provides communications between processor unit 2004, memory 2006, persistent storage 2008, communications unit 2010, input / output (I / O) unit 2012, and display 2014. In this example, communications framework 2002 takes the form of a bus system.

[0149] The processor unit 2004 is used to execute instructions of software that can be loaded into the memory 2006. The processor unit 2004 includes one or more processors. For example, the processor unit 2004 can be selected from at least one of a multi-core processor, a central processing unit (CPU), a graphics processing unit (GPU), a physical processing unit (PPU), a digital signal processor (DSP), a network processor, or some other suitable type of processor. In addition, the processor unit 2004 can be implemented using one or more heterogeneous processor systems, in which a main processor exists on a single chip with an auxiliary processor. As another illustrative example, the processor unit 2004 can be a symmetric multi-processor system that includes multiple processors of the same type on a single chip.

[0150] Memory 2006 and persistent storage 2008 are examples of storage devices 2016. A storage device is any hardware capable of storing information, such as but not limited to at least one of data, program instructions in functional form, or other suitable information, which can be temporary, permanent, or both temporary and permanent. In these illustrative examples, storage devices 2016 may also be referred to as computer-readable storage devices. In these examples, memory 2006 may be, for example, a random access memory or any other suitable volatile or non-volatile storage device. Persistent storage 2008 may take various forms depending on the specific implementation.

[0151] For example, persistent storage 2008 may include one or more components or devices. For example, persistent storage 2008 may be a hard drive, a solid state drive (SSD), flash memory, a rewritable optical disk, a rewritable magnetic tape, or some combination thereof. The media used by persistent storage 2008 may also be removable. For example, a removable hard drive may be used for persistent storage 2008.

[0152] In these illustrative examples, communications unit 2010 provides for communications with other data processing systems or devices. In these illustrative examples, communications unit 2010 is a network interface card.

[0153] Input / output unit 2012 allows input and output of data with other devices that may be connected to data processing system 2000. For example, input / output unit 2012 may provide a connection for user input through at least one of a keyboard, a mouse, or some other suitable input device. In addition, input / output unit 2012 may send output to a printer. Display 2014 provides a mechanism for displaying information to a user.

[0154] Instructions for at least one of an operating system, applications, or programs may be located in storage devices 2016, which are in communication with processor unit 2004 through communications framework 2002. The processes of the different embodiments may be performed by processor unit 2004 using computer-implemented instructions, which may be located in a memory such as memory 2006.

[0155] These instructions are referred to as program instructions, computer usable program instructions, or computer readable program instructions, which may be read and executed by a processor in processor unit 2004. The program instructions in different embodiments may be contained on different physical or computer readable storage media (such as memory 2006 or persistent storage device 2008).

[0156] Program instructions 2018 are located in functional form on computer readable media 2020, which is selectively removable and can be loaded or transferred to data processing system 2000 for execution by processor unit 2004. In these illustrative examples, program instructions 2018 and computer readable media 2020 form computer program product 2022. In the illustrative examples, computer readable media 2020 is computer readable storage media 2024.

[0157] Computer-readable storage media 2024 is a physical or tangible storage device for storing program instructions 2018, rather than a medium that propagates or transmits program instructions 2018. Computer-readable storage media 2024 as used herein should not be interpreted as being a transitory signal per se, such as a radio wave or other freely propagating electromagnetic wave, an electromagnetic wave propagating through a waveguide or other transmission medium (e.g., light pulses through an optical cable), or an electrical signal transmitted through a wire.

[0158] Alternatively, program instructions 2018 may be transmitted to data processing system 2000 using a computer readable signal medium. A computer readable signal medium is a signal, and may be, for example, a propagated data signal containing program instructions 2018. For example, a computer readable signal medium may be at least one of an electromagnetic signal, an optical signal, or any other suitable type of signal. These signals may be transmitted over a connection such as a wireless connection, an optical cable, a coaxial cable, an electrical wire, or any other suitable type of connection.

[0159] In addition, as used herein, "computer-readable medium 2020" may be singular or plural. For example, program instructions 2018 may be located in a computer-readable medium 2020 in the form of a single storage device or system. In another example, program instructions 2018 may be located in a computer-readable medium 2020 distributed in multiple data processing systems. In other words, some instructions in program instructions 2018 may be located in one data processing system, while other instructions in program instructions 2018 may be located in one data processing system. For example, a portion of program instructions 2018 may be located in a computer-readable medium 2020 in a server computer, while another portion of program instructions 2018 may be located in a computer-readable medium 2020 in a group of client computers.

[0160] The different components illustrated for data processing system 2000 are not meant to provide architectural limitations to the manner in which the different embodiments may be implemented. In some illustrative examples, one or more components may be incorporated into or otherwise form a part of another component. For example, in some illustrative examples, memory 2006 or portions thereof may be incorporated into processor unit 2004. The different illustrative embodiments may be implemented in a data processing system including components in addition to or in place of those illustrated for data processing system 2000. Fig. 20 Other components shown in the can be different from the illustrative examples shown. Different embodiments can be implemented using any hardware device or system capable of running program instructions 2018.

[0161] Therefore, illustrative embodiments of the present invention provide a computer-implemented method, apparatus, system, and computer program product for managing updates to multiple images. According to an illustrative embodiment, a computer-implemented method manages updates to multiple images. A computer system determines multiple shared layers that exist between multiple images selected for update management. Multiple images include executable code that is run to create a container. The computer system detects changes to shared layers in multiple shared layers for images in multiple images. In response to detecting changes to shared layers for images, the computer system updates shared layers in multiple shared layers for a group of images with shared layers. According to other illustrative embodiments, a computer system and a computer program product for managing updates to multiple images are provided. As a result, the illustrative embodiments can provide technical effects of improving performance by reducing errors in updated images and improving the performance of updated images by eliminating the need to update the code in each image separately.

[0162] In an illustrative example, errors are reduced by automatically updating multiple shared layers rather than patching multiple images individually. In addition, performance is improved by replacing pointers, such as unique identifiers, to shared layers in multiple images rather than patching or copying patched files to the images. Using new unique identifiers for updated shared layers in multiple images having shared layers causes the images to share multiple updated layers without having to patch files individually for each image. In the illustrative example, the image manager does not store files for multiple shared layers. Instead, updates to the multiple shared layers are performed by updating unique identifiers that point to the locations of the multiple shared layers. As a result, the updated shared layers can be pulled from the repository using new unique identifiers for the updated shared layers, as compared to patching the individual files in the image after they have been retrieved for use in creating a container.

[0163] Additionally, errors are reduced and performance is improved in pipeline workloads that may have hundreds or thousands of steps, where each step is executed by a container formed from files in the running image.

[0164] For the purpose of illustration and description, descriptions of different illustrative embodiments have been given, and are not intended to be exhaustive or limited to embodiments of the disclosed form. Different illustrative examples describe components that perform actions or operations. In illustrative embodiments, components may be configured to perform the described actions or operations. For example, components may have a configuration or design for a structure that provides the components with the ability to perform the actions or operations described as being performed by the components in the illustrative examples. In addition, with respect to the terms "comprises," "comprising," "having," "containing," and variations thereof used herein, these terms are intended to be inclusive in a manner similar to the term "comprises" as an open transition word, without excluding any additional or other elements.

[0165] The description of various embodiments of the present invention has been given for the purpose of illustration, but it is not intended to be exhaustive or limited to the disclosed embodiments. Not all embodiments include all the features described in the illustrative examples. In addition, different illustrative embodiments may provide different features compared to other illustrative embodiments. Many modifications and variations are apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terms used herein are selected to best explain the principles of the embodiments, practical applications, or technical improvements to the technology available on the market, or to enable other persons of ordinary skill in the art to understand the embodiments disclosed herein.

Claims

1. A computer-implemented method for managing updates to a plurality of images, the computer-implemented method comprising: determining, by a computer system, a plurality of shared layers existing between a plurality of images selected for update management, wherein the plurality of images include executable code executed to create a container; detecting, by the computer system, a change to a shared layer in the plurality of shared layers of an image in the plurality of images; and The shared layer in the plurality of shared layers for a set of images having the shared layer is updated, by the computer system, in response to detecting a change to the shared layer for the image.

2. The computer-implemented method of claim 1 , further comprising: The selected image is removed from the plurality of images identified for management by the computer system in response to user input to discontinue automatic updating of the selected image.

3. The computer-implemented method of claim 1 , wherein: Determining, by the computer system, the plurality of shared layers existing between the plurality of images selected for the update management comprises: The plurality of shared layers existing between a plurality of images selected for the update management are determined by the computer system using layer context information for the plurality of images.

4. The computer-implemented method of claim 1 , wherein: Determining, by the computer system, the plurality of shared layers existing between the plurality of images selected for the update management comprises: The plurality of shared layers existing between a plurality of images selected for the update management are determined by the computer system using commands for building the plurality of images.

5. The computer-implemented method of claim 1 , wherein: Detecting, by the computer system, a change to the shared layer in the plurality of shared layers of the image in the plurality of images includes: detecting, by the computer system, a change to the image using image information for the image indicating that the image has changed; and In response to detecting a change to the image, determining, by the computer system, that the shared layer for the image has changed using layer context information for the image indicating that the shared layer has changed.

6. The computer-implemented method of claim 1 , wherein: Detecting, by the computer system, a change to the shared layer in the plurality of shared layers of the image in the plurality of images includes: detecting, by the computer system, a command to update the image; and In response to detecting the command to update the image, the computer system determines, based on a command for multiple layers for the image indicating that the shared layer in the multiple layers has changed, that the shared layer for the image has changed.

7. The computer-implemented method of claim 1 , wherein: In response to detecting a change to the shared layer for the image, updating, by the computer system, the shared layer in the plurality of shared layers for a set of images having the shared layer comprises: determining, by the computer system, a new unique identifier for the shared layer for the image that has changed; identifying, by the computer system, the set of images having the shared layer that has changed; and The shared layer for the set of images is updated, by the computer system, using the new unique identifier for the shared layer that has changed.

8. The computer-implemented method of claim 1 , wherein: The plurality of images form an artificial intelligence pipeline, and the plurality of images are for the container that executes steps in the artificial intelligence pipeline.

9. A computer system comprising: a plurality of processor units, wherein the plurality of processor units execute program instructions to: determining a plurality of shared layers existing between a plurality of images selected for update management, wherein the plurality of images include executable code executed to create a container; detecting a change to a shared layer in the plurality of shared layers of an image in the plurality of images; and In response to detecting a change to the shared layer for the image, updating the shared layer in the plurality of shared layers for a set of images having the shared layer.

10. The computer system according to claim 9, wherein: The plurality of processor units execute program instructions to: In response to user input to discontinue automatic updating of a selected image, the selected image is removed from the plurality of images identified for management.

11. The computer system according to claim 9, wherein: In determining the plurality of shared layers existing between a plurality of images selected for the update management, the plurality of processor units execute program instructions to: The plurality of shared layers existing between the plurality of images selected for the update management are determined using layer context information for the plurality of images.

12. The computer system according to claim 9, wherein: In determining the plurality of shared layers existing between a plurality of images selected for the update management, the plurality of processor units execute program instructions to: The plurality of shared layers existing between the plurality of images selected for the update management are determined using a command for building the plurality of images.

13. The computer system according to claim 9, wherein: In detecting a change to the shared layer in the plurality of shared layers of the image in the plurality of images, the plurality of processor units execute program instructions to: detecting a change to the image using image information for the image indicating that the image has changed; as well as In response to detecting a change to the image, determining that the shared layer for the image has changed using layer context information for the image indicating that the shared layer has changed.

14. The computer system according to claim 9, wherein: In detecting a change to the shared layer in the plurality of shared layers of the image in the plurality of images, the plurality of processor units execute program instructions to: detecting a command to update the image; as well as In response to detecting the command to update the image, based on a command for multiple layers for the image indicating that the shared layer of the multiple layers has changed, it is determined that the shared layer for the image has changed.

15. The computer system according to claim 9, wherein: In updating the shared layer of the plurality of shared layers for a set of images having the shared layer in response to detecting a change to the shared layer for the image, the plurality of processor units execute program instructions to: determining a new unique identifier for the shared layer for the image that has changed; identifying the set of images having the shared layers that have changed; as well as The shared layer for the set of images is updated using the new unique identifier for the shared layer that has changed.

16. The computer system according to claim 9, wherein: The plurality of images form an artificial intelligence pipeline, and the plurality of images are for the container that executes steps in the artificial intelligence pipeline.

17. A computer program product for managing updates to a plurality of images, the computer program product comprising a computer readable storage medium having program instructions embodied therewith, the program instructions being executable by a computer system to cause the computer system to perform the following method: The computer system determines a plurality of shared layers existing between a plurality of images selected for update management, wherein: The plurality of images include executable code that is executed to create containers; detecting, by the computer system, a change to a shared layer in the plurality of shared layers of an image in the plurality of images; as well as The shared layer in the plurality of shared layers for a set of images having the shared layer is updated, by the computer system, in response to detecting a change to the shared layer for the image.

18. The computer program product of claim 17, further comprising: The selected image is removed from the plurality of images identified for management by the computer system in response to user input to discontinue automatic updating of the selected image.

19. The computer program product of claim 17, wherein: Determining, by the computer system, the plurality of shared layers existing between the plurality of images selected for the update management comprises: The plurality of shared layers existing between a plurality of images selected for the update management are determined by the computer system using layer context information for the plurality of images.

20. The computer program product of claim 17, wherein: Determining, by the computer system, the plurality of shared layers existing between the plurality of images selected for the update management comprises: The plurality of shared layers existing between a plurality of images selected for the update management are determined by the computer system using commands for building the plurality of images.

Images