Patent Application
20220092192
Embodiments of the present invention generally relate to containerized applications, container security and container orchestration security. More particularly, at least some embodiments of the invention relate to systems, hardware, software, computer-readable media, and methods for a focused encryption and/or decryption of container images.
A container image, such as a Docker image, can be described in different ways. For example, an image may be described as a file that includes multiple layers or as a set of files. An image may also be described as an ordered collection of changes (e.g., layers) to a root filesystem. The image can be run in an engine, such as a Docker engine. Kubernetes, an example of a container orchestration platform, can be used to manage the deployment and scaling of containerized applications. Images can be deployed on any host with an appropriate engine and/or in an orchestration platform.
The image may be organized in logical layers that are defined in a file that may be referred to, in the case of the Docker container service, as a Dockerfile. The Dockerfile is typically a text document that contains the commands to be executed, in order, to build a docker image. The commands, when executed, build the image. The layers of an image may be readable to anyone who is able to access the image and this may constitute a threat to any sensitive data inside one of the layers within an image.
While the image could be encrypted to protect the sensitive data from being read when the container is at rest, such an approach may be problematic and inefficient. For example, the entire image may be encrypted and transported as a ‘blob’ to a deployment site. However, this approach introduces management and performance issues. For example, container startup time is impacted when an instance is instantiated, since the full encrypted image could be quite large. Another problem with the solution of encrypting the image, is that the deployment environment may have to be modified to support image decryption. Finally, performing the decryption may take a relatively long time, depending on the image size, and may also impact performance of other elements in environments that have heavy deployment scenarios.
In order to describe the manner in which at least some of the advantages and features of the invention may be obtained, a more particular description of embodiments of the invention will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, embodiments of the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings in which:
Embodiments of the present invention generally relate to containerized applications and container security. More particularly, at least some embodiments of the invention relate to systems, hardware, software, computer-readable media, and methods for a focused encryption of container image(s) or portions thereof. Embodiments of the invention further relate to encrypting and/or decrypting container images or layers thereof while removing operating system (OS) runtime dependency for decryption. More specifically, embodiments of the invention remove the dependency of the decryptor on the operating system of the container.
Generally, embodiments of the invention improve the security of containers/images or the data contained therein by building related, but separate, images (or by dividing an image into related images). The first image may include layers that are not sensitive and may not need encryption. The first image may also contain a main application. A second image may include a decryptor layer along with an encrypted layer, which may include encrypted data or encrypted layers. During deployment or execution, the second image may be instantiated as a container and run first in order to decrypt the sensitive data. Running the first image after completion of the container that includes the decryptor allows the now decrypted layers to be incorporated into the runtime container of the main application. In one example, the decryptor and the sensitive layers, which are encrypted, are separated from the base image and the decryptor is run separately.
If the decryptor is inside a container image, the decryptor is part of the container runtime. If the decryptor is above the OS layers, then the decryptor runs in the context of the OS in that runtime instance. In addition, when the decryptor is inside a container image, layers that are loaded or executed prior to the decryptor may have malicious code that could be used to compromise the system or the security of the container.
Embodiments of the invention remove this dependency on the OS by moving the decryptor to a separate image and a separate runtime instance. When the decryptor is separated from the main image, the decryptor becomes a layer in its own image and OS dependency on the OS of the other image is removed. This eliminates the need to create different decryptors for different OS versions when the decryptor is simply included in the main image.
Also, by placing the decryptor in a separate image, bugs and security issues in the main application container do not enable access to the decryption keys. In other words, when the decryptor is included in the main application image, the application runs in the same memory as the decryptor. This may compromise instances of the application in a variety of ways.
Embodiments of the invention may integrate into and leverage orchestration platforms such as Kubernetes. By separating the decryptor from the application container, OS dependency is removed from the perspective of the decryptor. Further, the layers of the image can be selectively encrypted. In addition, the decryption keys are not provided through the main application container. Embodiments of the invention can also ensure that nothing in the main application runs before the decryptor to ensure that malicious code does not run before the decryptor.
In general, example embodiments of the invention embrace an image encryption process that may encrypt only the sensitive data (or layers) inside the image. The sensitive layers may be combined into a single layer that is then encrypted, and stored encrypted while at rest (e.g., in an image repository). Embodiments of the invention may also provide for adding a decryptor to an image that is separate from the main application image. The decryptor image is run before the main application image runs or is instantiated, so that the decryption process may take place at run-time and before the original application runs.
The encryption and decryption processes may be significantly shorter than if an entire image were to be encrypted and decrypted. There may be no need to make any changes in the deployment process or deployment environment, with the possible exception of some relatively minor configuration changes, and secret sharing. As well, example embodiments may provide for processes and mechanisms by way of which the layers of an image file to be protected may be readily selected and encrypted. In this way, it may be relatively easy to define and test the tradeoff between protection and runtime of an image.
In particular, one advantageous aspect of at least some embodiments of the invention is that, when encrypting a portion of an image, it may be relatively easy to define and test the tradeoff between protection and runtime of an image. An embodiment of the invention may secure the image data at rest, and so the image may be put in public domain or backup sites in a secure way. An embodiment of the invention may provide for selective encryption of an image in such a way that there is little or no impact on an associated deployment environment for the image. An embodiment of the invention may implement selective encryption of an image in such a way that the impact to startup time of a full working container is not materially affected. The selective encryption may be intra image or by encrypting sensitive data in a separate image.
The discussion herein may include references to images and containers in the context of Docker and Kubernetes. However, embodiments of the invention are not limited to these platforms and may be implemented in various container or image platforms and container orchestration platforms. More generally, embodiments of the invention may be employed in connection with any container definition and deployment environment, orchestration platform, and associated images, files, and components. The following discussion is not intended to limit the scope of the invention in any way. For example, embodiments of the invention may be adapted to the packaging and run-time methods of an orchestration platform such as Kubernetes.
In one example, embodiments of the invention are configured to increase or improve the security of container related processes including container or image formation, container deployment, layer encryption/decryption, container orchestration, or the like. Users are able to control which layers or portions of an image are encrypted. Embodiments of the invention may separate the decryptor (which could be a layer of the container image) into a separate image and run the decryptor image separately from the main container itself. In addition to providing a modular and efficient solution, this also improves security.
In general, and with reference to the example of
Generally, a command file describes the base image, as well as the additional layers the image will be composed of. More specifically, a command file may be a text file that contains commands used to assemble an image. Each command may result in a layer of the image. A command that does not modify the image file system may be considered as an empty layer, and the metadata of the commands may be kept in build history within an image configuration file. Each image may have an image configuration file that describes various parameters of the image itself such as, for example, the layers the image is composed of, and the identification of the entry point, for example. Identification of the entry point refers to the command to run after instantiation of the container.
Example embodiments may operate in connection with an image registry, an example of which is a Docker registry. In general, an image registry may comprise a repository that stores the layers that collectively form an image or that stores images. Such a registry may store the image configuration and layers as blobs in zipped fashion with plain text data inside. A registry may provide an application program interface (API) to pull and push images.
A registry may keep manifests of all images in the registry. A manifest may hold data about what image configuration to use, and the layers/commands that may be used to construct the image. For example, the Docker hub is a public domain docker registry that stores Docker images for public use. Many use cases and products may rely on this registry to hold their production images which can be used for deployment in AWS or Azure or any other platform.
In general, deployment refers to a process that instantiates an image such as to obtain a running process on an image engine, and to run a containerized application. Deployments may be implemented on any host with an appropriate engine or any other platform that supports and/or orchestrates images. A deployment environment may make a copy of the image from a registry and keep the copy of the image locally.
While images provide useful functionality, they are vulnerable to threats. For example, any data that is stored in a database (DB), Artifactory or local files is exposed to a risk of data theft, especially in public domains that can be breached. Additionally, there is a risk in private environments as well. Data can be stolen when the data is in a production environment or in some backup environments. Following is a more detailed discussion of some of the shortcomings of some images.
One characteristic of images that may make them vulnerable, such as to unauthorized access, is that images may include plain text files stored on disk. Thus, an attacker that can obtain the disk, breach the file system, or intercept the movement of an image from one location to the other, may obtain the data stored in the image.
As well, encryption and decryption processes such as may be employed with images may generally be relatively slow. This may be due to the use of algorithms that rely on complex mathematical functions. Data modification, such as IO operations, and mechanisms to protect against brute force may can be relatively slow on encryption/decryption process. Thus, decryption of a full image can be slow, and will slow the performance of the deployment system.
Further, container deployment environments may be performance sensitive. For example, deployment environments that use microservices architectures are constantly scaling or instantiating new containerized services. Anything that slows down these processes, such as image encryption and decryption, may adversely impact the system recovery and/or the system functionality. This, in turn, may result in a poor user experience and/or a slow system.
Moreover, conventional approaches to image security require modification of the deployment environment where the image is deployed. For example, encrypting the entire image, or encrypting each layer individually, requires support from the deployment environment. Such support is not present in most of the existing deployment environments and, even if present, may complicate and slow the deployment and operation processes. The process may be complicated further if the deployment environment does not have decryption capabilities, since the image may then have to be sent to a third party for decryption, which can result in delays to deployment of the container.
Finally, conventional approaches to image decryption may require support by the deployment environment, particularly, by an orchestrator before the image is sent to a target host for execution. Thus, the host which runs the application receives the image in an unencrypted form, which may make sensitive data in the image vulnerable to host access attacks.
The following observations may be pertinent to one or more example embodiments. First, decrypting a full image at an orchestrator or the host involves storing an unencrypted, and therefore vulnerable, image. As well, decryption of the full image may require modifications to the runtime environment. Further, the base image, which may comprise or consist of the OS (operating system), may not comprise sensitive data and, as such, there may be little value in encrypting the base image as a whole or as a layer. An image may comprise other layers as well for which encryption may not be necessary or useful, where such layers may include, but are not limited to, Apache Tomcat, Java, routers/proxies, databases, and/or, other application level services. Finally, the OS and base application services may collectively comprise a relatively large percentage of the overall size of a container image. As such, avoiding the encryption of the OS and related services may allow the container to run without requiring modifications to the deployment environment, and may significantly reduce the size of the encrypted portions of the image.
Thus, embodiments of the invention may provide a user with control over which image layers to encrypt, and may enable a user to build a mechanism to decrypt only those layers without requiring the support of the deployment environment. Accordingly, example embodiments comprise a new secured image, such as a Docker image for example, that has only the sensitive data encrypted. Thus, the relatively large base image or layer of unsensitive data may remain in plain text or original format, but data that is considered as sensitive may be kept encrypted. The decryption process may be implemented at runtime by a decryptor that is added, as a layer, to the image and that may decrypt the encrypted image data before executing the original application of which the container is a part.
In general, some example embodiments may involve marking the data or layers to be encrypted. In the context of an image, such marking may involve modifying, for example, the command file (e.g., the Dockerfile) of the image in order to mark the particular layer, or layers, of the image to be encrypted. For example, within a command file, just above the layer(s) that are to be marked for encryption, a command may be inserted to signal where encryption should begin. One example of such a command is:
The inclusion of a command such as this may result in the creation of an empty layer that holds the command in the history of the layers within the image configuration file. A stop encryption signal may also be included in the command file.
Note that the invention is not limited to the particular example string noted above. Any sequence that signals where encryption should begin may be employed. It is also noted that while ‘RUN echo’ results in the creation of an empty layer, various other commands may be employed. Further, commands that create a layer that is not empty may alternatively be employed. In general then, any layer or may be implemented as one of a group of one or more signal layers. However, the use of a trivial empty layer, such as the one that may be created with the ‘RUN echo’ command, may be simple, and may function with no additional limitations.
During the image encryption process, the system may traverse the layers of the image or the commands in the command file until the signal layer, such as the command layer or command noted above, is located. The system may then know to encrypt at least one of the layers following the signal layer. This approach may thus enable the marking of any one or more image layers for encryption, and may help to optimize a tradeoff between data protection and runtime constraints.
With attention now to
Note that in some embodiments, a non-sensitive layer may comprise some sensitive information, but the designation of that layer as non-sensitive may reflect a judgment that the potential risk of exposure of that sensitive information is outweighed by the cost of additional processing that would be required to protect that non-sensitive layer, and/or by other considerations. As well, a sensitive layer, discussed below, may include some non-sensitive information, but the designation of that layer as sensitive may reflect a judgment that, on the whole, it is desirable to encrypt that non-sensitive information since the encryption of that non-sensitive information may not impose any material processing burden on the system and such burden, in any case, may be outweighed by the need to protect the sensitive information in that sensitive layer.
The image 200 may additionally include one or more layers, such as the sensitive layers 208, 210, and 212, that include sensitive information that may require encryption. No particular number, or type, of sensitive layers 208, 210, and 212, is required. Whether or not particular data or information is sensitive may be defined by a user, administrator, or any other entity. Such an entity may be a human, or a computing system. In general, sensitive information embraces any information that is desired to be kept confidential, or at least subject to limited dissemination and/or availability, for whatever reason(s). In some instances, sensitive information may comprise user-specific, and/or system-specific information, that is not publicly available. Sensitive information may comprise proprietary financial and technical information of a business enterprise.
As also indicated in
With continued reference to
The example method 300 may begin with inspection 302 of an image, which may have an image name, in a registry. The image may be located in the registry by searching for the image name. As a result of the inspection 302, one or more signal layers and/or one or more layers to be encrypted may be identified 304. The layer, or layers, to be encrypted may then be downloaded 306 or accessed. The layers may be encrypted prior to download.
The downloaded layers, if there are more than one, may then be combined together to create a single layer file, such as a .TAR file 308, for example. As used herein, a .TAR file refers to an archive that may be created by the Unix-based TAR utility. A TAR file is an archive created by TAR, a Unix-based utility that operates to package files together. The .TAR file may contain multiple files, which may be stored in an uncompressed format, and the .TAR file may also comprise metadata concerning the archive. The .TAR files may be compressed into .GZ files using GNU Zip compression. The scope of the invention is not limited to TAR files however, and any other suitable files and platforms for creating those files may alternatively be used. After the .TAR file has been created 308, it may then be encrypted 310 using any suitable encryption algorithm.
Next, a new image may be created 312 that includes the encrypted .TAR file. The new image may also include the non-sensitive data layer(s) of the original, unencrypted image, one or more signal layers, and a decryptor layer. The entry point of the original image may be modified 314 so that the decryptor layer of the new image runs first when the new image is instantiated. After the decryptor layer has run, the original entry point may then be called. After the entry point has been modified 314, the new image may then be stored in a production registry 316. At this point, the new image may be ready for use in a production environment.
Returning once more to
In the example of
Thus, the image 400 that is generated, such as by the method 300, based on the original image 200 may comprise a self-contained decryptable image or decryptable layers. As such, the image 400 may not rely on any outside processes, entities, or services, to decrypt the sensitive information in the image 400, or to perform the other functions of the image 400. Rather, the image 400 performs its own decryption of its encrypted layer 410. Moreover, because the sensitive information may remain encrypted until runtime, the image 400 may provide assurance as to the security of that sensitive information.
Upon deployment, the system may use the new encrypted image 400 and provide the decryption key through standard secret handling. In Docker Swarm, for example, the system may use the secrets mechanism, or in Kubernetes use the ETCD and secrets mechanism.
With continued attention to the example encrypted image 400 of
Because the decryptor may be part of image, no support is needed from the runtime environment. Rather, the decryptor may run as part of the standard container initialization and may therefore transparent to the runtime system and to the image layers themselves. It is noted that OSs other than Linux may be supported in a similar fashion in alternative embodiments.
As disclosed earlier, an image, such as the example image 400 for example, may comprise multiple separate encryption layers, such as the encryption layer 410. Such a configuration may be implemented by adding the following command:
to identify layers that may be plain text. The signal layer 408 and stop-signal layer may be repeated multiple times in a given image 400. In at least some embodiments, there may be only one decryptor executable layer in the final image, regardless of how many encrypted layers may exist. This decryptor layer may decrypt all the encrypted layers prior to calling the original entry point. Care should be used using multiple layers, as in-between plain text layers may be a source for leakage of sensitive information. That said, if there are encrypted layers that are common to multiple containers, these encrypted layers may be shared in this way in their encrypted form, thus maintaining bandwidth efficiency during download despite the fact that the layers are encrypted.
While an OS layer of an image, such as the example image 200 for example, may not be encrypted in some embodiments, there may be a need in other embodiments to encrypt the OS layer. If there is a need to encrypt the OS layer and/or other non-sensitive layers, such as the layers 202, 204, and 206, for example, a boot loader layer may be added to the OS layer solely to run the decryptor. The boot loader layer may only need to have enough functionality to run the decryptor, and no more. This approach will still make encryption and decryption transparent to the deployment environment, but the runtime decryption may take longer as the OS, which is typically large in size, will also be decrypted prior to instantiation of the image. As well, if the OS layer and/or other non-sensitive layers are encrypted, the container environment variables that are used to pass runtime parameters to the application, may need to be transferred from the loader environment to the spun-off, decrypted OS.
As disclosed herein then, example embodiments embrace, among other things, encryption and decryption of images or portions thereof, such as Docker images for example. Such embodiments may use a command file and embedded decryptor to simplify management, and make the image portable to various different runtime environments. Example embodiments of the invention may include various attributes such as that they are relatively simple to use, may be instantiated efficiently at runtime, may avoid the need for changes or accommodation in the runtime environment, and may be transparent to the container, the runtime environment, and/or, to the administrator. Some particular embodiments may employ a signal layer as a marker to identify which layer(s) is/are to be encrypted. Some embodiments may embed a decryptor in an encrypted image which may run prior to an original entry point that was specified for the unencrypted image. Some embodiments may support multiple encryption layers. Finally, some embodiments may provide for encryption of an OS and/or other non-sensitive information.
In addition to containers as described with respect to
In some example, initialization containers are used for various purposes of attached device data. However, embodiments of the invention relate to initialization containers that are configured to manipulate other containers, including containers that are part of a pod. A pod, by way of example only, may include one or more containers or images. Thus, the application container and the initialization or decryption container may be included in the same pod. Because the initialization or decryption container is separate from the main or application container, it is possible to map devices and parameter only to the initialization container.
When creating the images, it may not be necessary to have a signal layer at least because the location of the encrypted layers can be predetermined in the image that includes the encrypted layers/files and the decryptor.
For discussion,
The initialization image 480 contains a decryptor layer 482, the signal layer 458, and an encrypted layer 484. The encrypted layer 484 is generated by encrypting/combining or combining/encrypting the sensitive layers 460 and 462. The sensitive layers 460 can be encrypted separately however in one example. The signal layer 458 in the initialization image 480 allows the decryptor layer 482 to locate the encrypted layer 484 and perform decryption. However, the signal layer 458 could be removed and the encrypted layers 484 may be at a predefined location. In one example, the signal layer 458 is not required in the initialization image 480.
In this example, each image is constructed separately and a pod specification may be as follows:
In this example, the pod includes two containers and the initialization container or image 480 is defined in this pod specification. The pod specification ensures that the initialization container, which performs the decryption, can run and complete before the main container or image 470 is run.
Because the decryptor runs in a container that is separate from the main container, the decryptor is not dependent on the OS associated with the main application. This illustrates how the decryptor can be independent of the application OS.
In addition, because the initialization container can run with a different view of the filesystem or device than the main container or other containers in the same pod, decryption keys may be provided to the initialization container. The decryption keys are not accessible to the main application in the main container.
Next, the decryptor finds the signal layer and uses the signal layer to locate 504 the encrypted layer or data. Alternatively, the decryptor may use a predetermined location at which the encrypted layer or data is stored.
Next, the decryptor decrypts 506 the encrypted layer or data to a directory on a filesystem (e.g., /mainappdecrypted). This may be in a base directory and, in one example, each layer of the image may have its own directory under the base directory.
If the initialization container runs and completes successfully, the main application container is run 508. The application layers are run normally until the copier layer is reached. The copier layer is run 510. The copier layer may copy the unencrypted layers on the filesystem (e.g., from /mainappdecrypted) into their place in the layer root directory. The main application then runs 512.
By placing the decryptor in a separate image or container, the decryption is transparent to the main application or the main image. This makes the scheme both modular and more secure.
In some examples, there may be multiple signal and stop-signal layers in an image. In some example, a signal layer may not be required. A predetermined location may be used. In one example, a copier layer is provided for each set of signal and stop-signal layers. At runtime, each encrypted data layer is opened into a separate directory. The corresponding copier layer then copies from a designated layer or directory.
Embodiments of the invention also accommodate additional initialization layers. In one example, the decryptor image is configured to run first and may be the first initialization image in the pod specification. If any initialization layers are placed before the decryptor image, these initialization layers should not contain any encrypted layers in one example. Further, these layers may pose a security risk as they may attempt to manipulate inputs to the decryptor image.
When packaging the application, the images are configured 604 such that the decryptor image executes first.
Following are some further example embodiments of the invention. These are presented only by way of example and are not intended to limit the scope of the invention in any way.
Embodiment 1. A method, comprising: packaging an application that is associated with sensitive data into at least a first image and a second image by placing first layers in the first image, the first layers including a copier layer and by placing second layers in the second image, wherein the second layers include a decryptor layer and an encrypted layer that includes the sensitive data in an encrypted form; and configuring the second image to run before the first image.
Embodiment 2. The method of embodiment 1, further comprising running the second image as an initialization container, wherein execution of the initialization container includes decrypting, by the decryptor, the encrypted layer to obtain decrypted sensitive data.
Embodiment 3. The method of embodiment 1 and/or 2, further comprising storing the decrypted sensitive data in a directory of a filesystem.
Embodiment 4. The method of embodiment 1, 2, and/or 3, further comprising running the first image as a main container after the initialization container successfully completes.
Embodiment 5. The method of embodiment 1, 2, 3, and/or 4, further comprising running the copier layer, wherein the copier layer copies the decrypted sensitive data in the directory to a location in a layer root directory associated with the main application.
Embodiment 6. The method of embodiment 1, 2, 3, 4, and/or 5, further comprising generating a pod specification such that the second image runs and completes before the first image is run.
Embodiment 7. The method of embodiment 1, 2, 3, 4, 5, and/or 6, further comprising generating the encrypted layer by encrypting one or more sensitive layers of the sensitive data.
Embodiment 8. The method of embodiment 1, 2, 3, 4, 5, 6, and/or 7, wherein packaging the application includes dividing an image into the first image and the second image or constructing a command file for the first image and a command file for the second image.
Embodiment 9. The method of embodiment 1, 2, 3, 4, 5, 6, 7, and/or 8, further comprising placing the decryptor layer in the second image such that the decryptor layer in the second image is not dependent on an operating system included in the first image.
Embodiment 10. The method of embodiment 1, 2, 3, 4, 5, 6, 7, 8, and/or 9, the second image including a signal layer and a stop-signal layer that identify a location of the encrypted layer in the second image.
Embodiment 11. A method for performing any of the operations, methods, or processes, or any portion of any of these including any portions of any of embodiments 1-109, disclosed herein.
Embodiment 12. A non-transitory storage medium having stored therein instructions that are executable by one or more hardware processors to perform the operations of any one or more of embodiments 1 through 11.
The embodiments disclosed herein may include the use of a special purpose or general-purpose computer including various computer hardware or software modules, as discussed in greater detail below. A computer may include a processor and computer storage media carrying instructions that, when executed by the processor and/or caused to be executed by the processor, perform any one or more of the methods disclosed herein, or any part(s) of any method disclosed.
As indicated above, embodiments within the scope of the present invention also include computer storage media, which are physical media for carrying or having computer-executable instructions or data structures stored thereon. Such computer storage media may be any available physical media that may be accessed by a general purpose or special purpose computer.
By way of example, and not limitation, such computer storage media may comprise hardware storage such as solid state disk/device (SSD), RAM, ROM, EEPROM, CD-ROM, flash memory, phase-change memory (“PCM”), or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other hardware storage devices which may be used to store program code in the form of computer-executable instructions or data structures, which may be accessed and executed by a general-purpose or special-purpose computer system to implement the disclosed functionality of the invention. Combinations of the above should also be included within the scope of computer storage media. Such media are also examples of non-transitory storage media, and non-transitory storage media also embraces cloud-based storage systems and structures, although the scope of the invention is not limited to these examples of non-transitory storage media.
Computer-executable instructions comprise, for example, instructions and data which, when executed, cause a general purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. As such, some embodiments of the invention may be downloadable to one or more systems or devices, for example, from a website, mesh topology, or other source. As well, the scope of the invention embraces any hardware system or device that comprises an instance of an application that comprises the disclosed executable instructions.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts disclosed herein are disclosed as example forms of implementing the claims.
As used herein, the term ‘module’ or ‘component’ may refer to software objects or routines that execute on the computing system. The different components, modules, engines, and services described herein may be implemented as objects or processes that execute on the computing system, for example, as separate threads. While the system and methods described herein may be implemented in software, implementations in hardware or a combination of software and hardware are also possible and contemplated. In the present disclosure, a ‘computing entity’ may be any computing system as previously defined herein, or any module or combination of modules running on a computing system.
In at least some instances, a hardware processor is provided that is operable to carry out executable instructions for performing a method or process, such as the methods and processes disclosed herein. The hardware processor may or may not comprise an element of other hardware, such as the computing devices and systems disclosed herein.
In terms of computing environments, embodiments of the invention may be performed in client-server environments, whether network or local environments, or in any other suitable environment. Suitable operating environments for at least some embodiments of the invention include cloud computing environments where one or more of a client, server, or other machine may reside and operate in a cloud environment.
With reference briefly now to
In the example of
Such executable instructions may take various forms including, for example, instructions executable to perform any method or portion thereof disclosed herein, and/or executable by/at any of a storage site, whether on-premises at an enterprise, or a cloud storage site, client, datacenter, or backup server, to perform any of the functions disclosed herein. As well, such instructions may be executable to perform any of the other operations and methods, and any portions thereof, disclosed herein.
Embodiments of the invention, such as the examples disclosed herein, may be beneficial in a variety of respects. For example, and as will be apparent from the present disclosure, one or more embodiments of the invention may provide one or more advantageous and unexpected effects, in any combination, some examples of which are set forth below. It should be noted that such effects are neither intended, nor should be construed, to limit the scope of the claimed invention in any way. It should further be noted that nothing herein should be construed as constituting an essential or indispensable element of any invention or embodiment. Rather, various aspects of the disclosed embodiments may be combined in a variety of ways so as to define yet further embodiments. Such further embodiments are considered as being within the scope of this disclosure. As well, none of the embodiments embraced within the scope of this disclosure should be construed as resolving, or being limited to the resolution of, any particular problem(s). Nor should any such embodiments be construed to implement, or be limited to implementation of, any particular technical effect(s) or solution(s). Finally, it is not required that any embodiment implement any of the advantageous and unexpected effects disclosed herein.
The following is a discussion of aspects of example operating environments for various embodiments of the invention. This discussion is not intended to limit the scope of the invention, or the applicability of the embodiments, in any way.
In general, embodiments of the invention may be implemented in connection with systems, software, and components, that individually and/or collectively implement, and/or cause the implementation of, the creation, modification, encryption, and/or decryption, of one or more container images. More generally, the scope of the invention embraces any operating environment in which the disclosed concepts may be useful.
Embodiments of the invention may be employed in connection with container-based platforms such as Docker, although no particular platform is required to be employed in any embodiment. Container-based platforms may involve or include deployment environments such as cloud computing environments. Example cloud computing environments with which example embodiments of the invention may be employed include, but are not limited to, DellEMC Cloud, Microsoft Azure, Amazon AWS, and Google Cloud. More generally however, the scope of the invention is not limited to employment of any particular type or implementation of cloud computing environment.
The present invention may be embodied in other specific forms without departing from its spirit or essential characteristics. The described embodiments are to be considered in all respects only as illustrative and not restrictive. The scope of the invention is, therefore, indicated by the appended claims rather than by the foregoing description. All changes which come within the meaning and range of equivalency of the claims are to be embraced within their scope.
