Patent Publication Number: US-8533701-B2

Title: Virtual machine image update service

Description:
BACKGROUND 
     A distributed computing system is employed in a variety of settings for running applications and maintaining data. For example, an application traditionally stored and maintained on a personal computer for performing one or more desired functions, may, when executed in a distributed computing system, provide similar functionality without the need for local resources, maintenance, and other burdens associated with individual copies of an application residing at a personal computer. 
     An application that is accessible through a distributed computing system (environment) may include features particular to a specific group of users. These features that are particular to a specific group of users inhibit traditional automation of an update to components utilized by the application. Traditionally, when a distributed computing system application is updated, the process is laborious and results in manual intervention to re-instate many of the features unique to the application prior to the update. Consequently, a user, such as a developer of the application, initiates the update process to re-deploy the features and customization that was present prior to updating of a component within the application. 
     Further, a user initiating the update of a component used by an application is traditionally required to have knowledge that the component is used by a particular application and that an update for the component is present. As a result, updating of a component across a distributed computing environment is hindered by the lack of centralization and automation for updating components system wide. 
     As such, current processes for updating components of applications, which rely on users manually identifying an update is available and rebuilding an application, are ad hoc solutions, are labor intensive, and are error prone. Further, these solutions are not scalable for applying across a distributed computing environment providing a plurality of applications with multiple components utilized therein and identifying an update is available. 
     SUMMARY 
     Embodiments of the present invention relate to systems, methods and computer storage media for updating a component utilized by an application within a distributed computing environment. An inventory of components relied on by applications within a distributed computing environment is created and maintained to facilitate identifying applications utilizing a particular component. A determination is made of applications that utilize a particular component. An indication is received that an update is available for the particular component used by an application. An application image for the application utilizing the particular component is booted in an isolated computing environment to allow the component to be updated with respect to the application. The component used by the application is updated within the isolated computing environment. A new application image of the application is created to reflect the updated component. In an exemplary embodiment, a user, such as a developer, of the application is notified that the new application image reflecting the updated component is available for future instantiations of the application within the distributed computing environment. 
     This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. 
    
    
     
       BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS 
       Illustrative embodiments of the present invention are described in detail below with reference to the attached drawing figures, which are incorporated by reference herein and wherein: 
         FIG. 1  depicts an exemplary computing device suitable for implementing embodiments of the present invention; 
         FIG. 2  depicts a block diagram illustrating an exemplary application distribution system in which embodiments of the present invention may be employed; 
         FIG. 3  depicts a block diagram illustrating an exemplary distributed computing environment in which embodiments of the present invention may be employed; 
         FIG. 4  depicts an exemplary distributed computing environment in accordance with embodiments of the present invention; 
         FIG. 5  depicts a flow diagram illustrating a method for updating an application image with a component in a distributed computing environment that is in accordance with an embodiment of the present invention; and 
         FIG. 6  depicts another flow diagram illustrating a method for updating an application image with a component in a distributed computing environment that is in accordance with an embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     The subject matter of embodiments of the present invention is described with specificity herein to meet statutory requirements. However, the description itself is not intended to limit the scope of this patent. Rather, the inventors have contemplated that the claimed subject matter might also be embodied in other ways, to include different steps or combinations of steps similar to the ones described in this document, in conjunction with other present or future technologies. 
     Embodiments of the present invention relate to systems, methods and computer storage media for updating a component utilized by an application within a distributed computing environment. An inventory of components relied on by applications within a distributed computing environment is created and maintained to facilitate identifying applications utilizing a particular component. A determination is made of applications that utilize a particular component. An indication is received that an update is available for the particular component. An application image for an application utilizing the particular component is booted in an isolated computing environment to allow the component to be updated. A new image of the application is created to reflect the updated component. In an exemplary embodiment, a user, such as a developer, of the application is notified that the new image is available for future instantiations of the application. 
     Accordingly, in one aspect, the present invention provides computer storage media having computer-executable instructions embodied thereon, that when executed by a computing system having a processor and memory, cause the computing system to perform a method for updating an application image with a component. The method includes automatically determining the component is utilized by a service that is accessible through a distributed computing environment, wherein the service is an instantiation of an application represented by the application image. The method also includes receiving an indication that an update for the component is available. Further, the method includes identifying the application image is utilizing the component. Additionally, the method includes automatically executing the application image in an isolated computing environment of the distributed computing environment to update the component. The method also includes storing, within the distributed computing environment, a new application image reflecting the application having the component updated. 
     In another aspect, the present invention provides a computer system for performing a method for updating a component of an application image, the computer system comprising a processor coupled to a computer storage medium, the computer storage medium having stored there on a plurality of computer software executable by the processor. The computer software includes a receiving service for receiving an update to a component utilized by one or more applications in a distributed computing environment. The computer software also including a component update service for automatically identifying an application image, for an application of the one or more applications, utilizing the component. The component update service executing the application image in a virtual machine that is an isolated computing environment within the distributed computing environment. Additionally, the component update service is functional for facilitating an update agent with applying the update to the component in the isolated computing environment. The component update service facilitates storing a new image of the application. 
     A third aspect of the present invention provides computer storage media having computer-executable instructions embodied thereon, that when executed by a computing system having a processor and memory, cause the computing system to perform a method for updating an application image with a component. The method includes determining a plurality of components utilized by an application that is represented by an application image. The method also includes recording the plurality of components as an inventory. Further, the method includes receiving an indication of an update for a component of the plurality of components. Additionally, the method includes automatically identifying from the inventory; the application image utilizes the component. The method also includes executing the application image in an isolated computing environment of the distributed computing system. The method further includes receiving the update for the component at the isolated computing environment. The method also includes facilitating update of the component within the isolated computing environment. The method additionally includes verifying the component is updated within the isolated computing environment. The method also includes creating a new application image of the application utilizing the updated component. The method also includes storing the new application image within the distributed computing environment. Additionally, the method includes notifying a user of the application that the new application image is available within the distributed computing environment. 
     Having briefly described an overview of embodiments of the present invention, an exemplary operating environment suitable for implementing embodiments hereof is described below. 
     Referring to the drawings in general, and initially to  FIG. 1  in particular, an exemplary operating environment suitable for implementing embodiments of the present invention is shown and designated generally as computing device  100  (computing environment). Computing device  100  is but one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing device  100  be interpreted as having any dependency or requirement relating to any one or combination of modules/components illustrated. 
     Embodiments may be described in the general context of computer code or machine-useable instructions, including computer-executable instructions such as program modules, being executed by a computer or other machine, such as a personal data assistant or other handheld device. Generally, program modules including routines, programs, objects, modules, data structures, and the like, refer to code that performs particular tasks or implements particular abstract data types. Embodiments may be practiced in a variety of system configurations, including hand-held devices, consumer electronics, general-purpose computers, specialty computing devices, cloud computing environment, servers, nodes etc. Embodiments may also be practiced in distributed computing environments where tasks are performed by remote-processing devices that are linked through a communications network. 
     With continued reference to  FIG. 1 , computing device  100  includes a bus  110  that directly or indirectly couples the following devices: memory  112 , one or more processors  114 , one or more presentation modules  116 , input/output (I/O) ports  118 , I/O modules  120 , and an illustrative power supply  122 . Bus  110  represents what may be one or more busses (such as an address bus, data bus, or combination thereof). Although the various blocks of  FIG. 1  are shown with lines for the sake of clarity, in reality, delineating various modules is not so clear, and metaphorically, the lines would more accurately be grey and fuzzy. For example, one may consider a presentation module such as a display device to be an I/O module. Also, processors have memory. The inventors hereof recognize that such is the nature of the art, and reiterate that the diagram of  FIG. 1  is merely illustrative of an exemplary computing device that can be used in connection with one or more embodiments. Distinction is not made between such categories as “workstation,” “server,” “laptop,” “hand-held device,” etc., as all are contemplated within the scope of  FIG. 1  and reference to “computer” or “computing device.” 
     Computing device  100  typically includes a variety of computer-readable media. By way of example, and not limitation, computer-readable media may comprise computer storage media such as Random Access Memory (RAM); Read Only Memory (ROM); Electronically Erasable Programmable Read Only Memory (EEPROM); flash memory or other memory technologies; CDROM, digital versatile disks (DVD) or other optical or holographic media; magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to encode desired information and be accessed by computing device  100 . 
     Memory  112  includes computer storage media in the form of volatile and/or nonvolatile memory. The memory may be removable, non-removable, or a combination thereof. Exemplary hardware devices include solid-state memory, hard drives, optical-disc drives, etc. Computing device  100  includes one or more processors that read data from various entities such as memory  112  or I/O modules  120 . Presentation module(s)  116  present data indications to a user or other device. Exemplary presentation modules include a display device, speaker, printing module, vibrating module, and the like. I/O ports  118  allow computing device  100  to be logically coupled to other devices including I/O modules  120 , some of which may be built in. Illustrative modules include a microphone, joystick, game pad, satellite dish, scanner, printer, wireless device, and the like. 
     With reference to  FIG. 2 , a block diagram is provided illustrating an exemplary application distribution system  200  in which embodiments of the present invention may be employed. It should be understood that this and other arrangements described herein are set forth only as examples. Other arrangements and elements (e.g., machines, interfaces, images, components, and applications, etc.) can be used in addition to or instead of those shown, and some elements may be omitted altogether. 
     The application distribution system  200  may be employed as part of a distributed computing system. Examples of a distributed computing system include a cloud computing system or the like. For example, a cloud computing system is an Internet based computing system that shifts infrastructure (e.g., processing power, memory, resources) away from an end user to providers within the “cloud.” The term cloud may be used as a metaphor for the Internet. Consequently, cloud computing represent, in an embodiment, a computing capability that provides an abstraction between the computing resource and underlying technical architecture (e.g., servers, storage, network), enabling convenient, on-demand network access to a shared pool of configurable computing resources that are capable of rapid provisioning and release with minimal management effort or service provider interaction. 
     The application distribution system  220  is comprised of an application  202 . Application  202  is an exemplary application, such as a cloud application. An application utilizes cloud computing in the software architecture to reduce or potentially eliminate the need to install and/or run the application on an end user&#39;s computer. Consequently, an application delivered through the application distribution system  200  may alleviate the end user of software maintenance, the burden of ongoing operation and support. Examples of an application  202  include services used by an end user to perform computing tasks while maintaining at least a portion of the application code and infrastructure separate from a computing device used by the end user. 
     The application  202  is comprised of a number of components. For example, component  1   204 , component  2 ,  206 , and component N  208 . A component, in an exemplary embodiment, is a discreet portion of code of an application that provides functionality to an application. A component may be viewed, at least in some embodiments, as a building block, that when combined with other components, creates the ultimate functionality provided by an application. Consequently, the application  202  is built from a number of components (i.e., component  1   204 , component  2 ,  206 , and component N  208 ), where each of the components, either alone or in combination, are responsible for various functions offered by a service of the application  202 . 
     In an exemplary embodiment, when an application is updated in response to errors, flaws, new functionality, additional resources, additional options, changes in resources, etc., one or more components of the application are updated to facilitate the desired changes to be implemented within the application. As a result, an application may be updated by updating one or more components utilized by the application. Therefore, instead of updating all of the code that represents an application, portions or components of the application may instead be updated to reduce the resources required for an update. It is understood that a “component” as used herein is a portion or a whole of an application that provides functionality within a distributed computing system, such as a cloud computing system. 
     An application, such as the application  202 , is developed by a developer. The developer, sometimes referred to as an owner of the application, identifies the functionality that the application is intended to provide, creates, coordinate, and/or identifies components that when used alone or in combination, provides the functionality of the application to a user. The developer may also desire to update the functionality provided by the application. In order to facilitate updating the functionality, the developer of the application may provide updates to one or more components. 
     Similarly, components utilized by an application may be developed by a third-party developer. A third-party developer may update a component and then offer the updated component for use by application. In an exemplary embodiment, a developer develops an application that is comprised of a number of components. The components comprising the application may be partially developed by the developer and also partially developed by a third-party developer. For those components of an application developed by a third-party developer, the third-party developer may notify the developer of updates to a particular component. In another embodiment, the third-party developer may not notify the developer of the updated component, but instead rely on the developer to discover the update on their own. Consequently, the developer, in this example, is responsible for identifying that a component update is available for a particular application utilizing the component. Reduced management and resource costs may be realized when a developer is not responsible for manually identifying component updates. 
     With continued reference to  FIG. 2 , an image  210 , such as an application image, is a snapshot of the state of an application within a machine. For example, an image includes a snapshot of an application within a virtual machine. The snapshot may include variables, program counters, memory state, and the like. An image, such as the image  210 , may be instantiated to provide a service, such as service  212 , service  214 , or service  216  for a requesting user. In an exemplary embodiment, the image  210  is a snapshot of the application  202  as operating within a virtual machine of a distributed computing environment. 
     Machine  1   218 , machine  2   220 , and machine N  222  are machines operating in a distributed computing environment. In an exemplary embodiment, the machine  1   218 , machine  2   220 , and machine N  222  are virtual machines functional for providing resource for a respective service. As discussed supra, a service is an instantiation of an image. Consequently, the machine  1   218 , in this example, provides resources requested and required by the service  212 . A virtual machine is an implementation of a machine (e.g., computing device) that executes computing code as if it was a physical machine. Therefore, in a cloud computing environment, virtual machines provide a framework that is conducive to expansion and contraction with minimal manual resources consumed. 
     In an exemplary embodiment, a developer of the application  202  provides the application  202  including a number of components, such as component  1   204 . A distributed computing environment may include an operating environment, such as an operating environment provided under the trademark WINDOWS AZURE available from the Microsoft Corporation of Redmond, Wash., that is functional to generate the image  210  from the application  202 . The image  210  is a snapshot of the application  202  within a machine, such as a virtual machine. When a service provided by the image  210  is requested, the image  210  is instantiated by an operating environment as a service, such as the service  212  that utilizes resource of a machine, such as the machine  1   218 . 
     The various embodiments and examples provided in connection with  FIG. 2  are exemplary in nature and not all inclusive. It is understood that additional processes, services, machines, networks applications, and the like may be implemented to achieve distribution of an application in a distributed computing environment. 
     Further many of the elements described herein are functional entities that may be implemented as discrete or distributed components or in conjunction with other components, and in any suitable combination and location. Various functions described herein as being performed by one or more entities may be carried out by hardware, firmware, and/or software. For instance, various functions may be carried out by a processor executing instructions stored in memory. 
     With reference to  FIG. 3 , a block diagram is provided illustrating an exemplary distributed computing environment  300  in which embodiments of the present invention may be employed. It should be understood that this and other arrangements described herein are set forth only as examples. Other arrangements and elements (e.g., machines, interfaces, images, components, and applications, etc.) can be used in addition to or instead of those shown, and some elements may be omitted altogether. 
     Among other components not shown, the environment  300  may include an update service machine  302 , an image store  304 , a component information machine  310 , an isolated environment machine  312 , an inventory  314 , a user machine  316 , a machine  1   318 , a machine  2 ,  320 , and a machine N  322 . Each of the units shown in  FIG. 3  may be any type of computing device, such as computing device  100  described with reference to  FIG. 1 , for example. The components may communicate with each other via a network (not shown), which may include, without limitation, one or more local area networks (LANs) and/or wide area networks (WANs). Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets, and the Internet. It should be understood that any number of machines and stores may be employed within the environment  300  within the scope of the present invention. Additionally other units not shown may also be included within the environment  300   
     The update service machine  302  is a machine, either virtually or actually, that among other responsibilities manages and facilitates update of an image. In an exemplary embodiment, the update service machine is a virtual machine operating within a cloud computing environment. The image store  304  is a computer readable medium functional for maintaining one or more images, such as the image  306  and the new image  308 . The update service machine  302  and the image store  304  communicate by way of one or more networks, such as the Internet. Similarly, other machines and stores of the exemplary distributed computing environment  300  communicate by way of one or more networks. 
     The user machine  316  is a machine, such as a computing device, utilized by a user, developer, and/or a third-party developer. For example, a developer may access an application developed by the developer for use within the distributed computing environment  300  by way of the user machine  316 . In an additional embodiment, the user machine  316 , like all machines of the distributed computing environment  300 , may be a virtual machine. 
     The component information machine  310  is a machine, such as a computing device, a virtual machine, a process, an application, an agent, or the like, that is functional to identify and determine components utilized by applications operating within the distributed computing environment  300 . For example, an application provided by a developer using the user machine  316  is analyzed by the component information machine  310  to identify and determine a plurality of components utilized by the application. Consequently, the component information machine  310 , in this example, maintains a listing of the identified components as an inventory within the inventory  314 . 
     The inventory  314 , in an exemplary embodiment, is a data store for maintaining a listing or inventory of components utilized by one or more applications operating within the distributed computing environment  300 . For example, the inventory  314  may be a computer readable medium that, in connection with a computing device, maintains and monitors the inventory of components relied upon by applications. 
     The isolated environment machine  312  is an isolated computing environment within the distributed computing environment  300 . For example, an isolated computing environment, in an exemplary embodiment, is a virtual machine with limited resources and connections. In this example, the isolated computing environment is designed to prevent conflicts within a cloud computing environment, which prevents a disruption of service within the distributed computing environment. Conflicts may be prevented by restricting resources, connections, parameters, access, and other controls to limit a footprint of the isolated computing environment within a distributed computing environment. Conflicts within the distributed computing environment may be avoided in the update process by inhibiting or preventing the isolated computing environment from broadcasting (e.g., communicating) various resources associate with the component. The machine  1   318 , machine  2   320 , and machine N  322  are machines, virtual or physical, functional to provide resource for use by a service, such as an instantiation of an image (i.e., image  306 , new image  308 ). 
     In an exemplary embodiment, the component information machine  310  creates and maintains an inventory of at the inventory  314  of all components utilized within the image  306 . Consequently, when a developer, third-party developer, or the like provides an indication of an update for a particular component, the update service machine  302  receives this indication and accesses the inventory  314  to identify an application image that utilizes the component. In this exemplary embodiment, the update service machine  302  identifies the image  306  as including or utilizing the updated component. 
     Continuing with this example, the update service machine boots or executes the image  306  within the isolated environment machine  312 . As previously discussed, the isolated environment machine  312  has limited resources and connections within the distributed computing environment  300  to prevent possible conflicts within the distributed computing environment  300 . For example, instantiations of the image  306  may be running on the machine  1   320  (for example) concurrently with the update service machine  302  attempting to update the image  306 . Therefore, to prevent the service operating on machine  1   318  from “seeing” or relying on parallel resources of the image  306  as it is booted in the isolated environment machine  312 , the resources and connection of the isolated environment machine are controlled and limited to prevent potential conflicts. 
     Returning to the example, once the update service machine  302 , which may be associated with or part of a fabric layer of a distributed computing environment, causes the image  306  to be executed within the isolated environment machine  312 , the update for the component is applied. In a particular embodiment, an indication of the update is received by the update service machine  302 ; therefore, the update service machine  302  retrieves the update to be applied to the image  306 . In an additional embodiment, the update is received by the update service machine (or other units of the distrusted computing environment) as part of the received indication. 
     In an embodiment, the update includes an update agent. The update agent is provided by a developer, a third-party developer, or the like to control and/or manage the update of a component. In an additional embodiment, the update agent may be provided by a fabric controller or other operating platform utilized by the distributed computing environment  300 . The update agent, in an embodiment, marshals the update of the component within the isolated environment machine to allow the functionality of a resulting image to be maintained but yet allowing a particular component to be updated. 
     Continuing yet again with the example, the image  306  is updated with an updated component on the isolated environment machine. A snapshot of the updated image may be captured to generate the new image  308  that is stored within the image store  304 . The new image  308 , like the image  306 , is a snap shot of the state of an underlying application. However, the new image  308  reflects utilization of an updated component unlike the image  306 . In an exemplary embodiment, both the image  306  and the new image  308  are maintained within the image store  304 . Further, in an exemplary embodiment, the image  306  is continued to be instantiated to provide a service at the various machines (e.g., machine  1   318 ) until the new image  308  is authorized by a user, developer or the like. In an additional exemplary embodiment, the new image  308  is automatically utilized to instantiate a service, while the image  306  is maintained for roll-back purposes. 
     In an exemplary embodiment verification is performed once a component is updated. The verification may be conducted by the isolated environment machine  312  or another machine of the distributed computing environment  300 . The verification may include enumerating the update to ensure that it has been applied to the component. Additional verification may include identifying file names, extensions, logs or other indications of a properly applied update. 
     Once a new image  308  is stored in the image store  304 , in an exemplary embodiment, a notification is provided to a developer, owner, controller or the like of the affected application. The notification may provide details indicating what update was applied, when it was applied, what was included with the update, what is affected by the update, and that a new image reflecting the updated component is available. In this example, a receiving entity of this notification may perform additional verification or provide a command to begin utilizing the new image  308  in place of the image  306 . Or, as previously indicated, an exemplary embodiment automatically reboots services of the image  306  utilizing the new image  308 . 
     Accordingly, any number of units, machines, and stores may be employed to achieve the desired functionality within the scope of embodiments of the present invention. Although the various units of  FIG. 3  are shown with lines for the sake of clarity, in reality, delineating various components is not so clear, and metaphorically, the lines would more accurately be grey or fuzzy. Further, although some units of  FIG. 3  are depicted as single blocks, the depictions are exemplary in nature and in number and are not to be construed as limiting. 
     Turning to  FIG. 4  illustrating an exemplary distributed computing environment  400  in accordance with embodiments of the present invention. The distributed computing environment  400  is comprised of, at least in part, a processor  402 , computer readable medium  404 , a virtual machine  412 , and a store  414 . The computer readable medium  404  is comprised of, at least in part, code for performing functions associated with a receiving service  406 , a component update service  408 , and an update agent  410 . The elements illustrated and discussed herein with respect to  FIG. 4  are exemplary in nature and are not limiting as to scope of the present invention. It is understood that additional element, machines, media, code, services, etc. may be implemented in the distributed computing environment  400 . For example, while only a single virtual machine  412  is visually illustrated, in practice a plurality of virtual machine may be utilized at any time within the distributed computing environment  400   
     The processor  402  is a computing processor. In an exemplary embodiment the processor  402  is similar in nature to the processor(s)  114  previously discussed with respect to  FIG. 1 . 
     The computer readable medium  404  is a computer readable medium for use within the distributed computing environment  400 . The computer readable medium  404 , in an exemplary embodiment, is functional for maintaining one or more components, applications, services, and other functionality, that when executed by the processor  402 , results in transformations of data, information, and other inputs within the distributed computing environment  400 . 
     The receiving service  406  is, in an exemplary embodiment, functional for receiving an update to a component utilized by one or more applications in a distributed computing environment. For example, a component of an application may be updated by a developer of the component to patch a known conflict or error within the component. An indication of availability of the update is communicated from the developer to the distributed computing environment  400 . The indication, which may be an electronic message, is received, in this example, by the receiving service  406 . In response to receiving the indication, the update may be automatically requested by the receiving service  406  or other elements of the distributed computing environment  400 . In an additional example, upon receiving the indication, the receiving service  406  may pass along the indication or a derivative of the indication to one or more other services/machines of the distributed computing environment  400  to determine if the update is relevant to an application residing or operating within the distributed computing environment  400 . 
     Additionally, the receiving service  406  is functional to receive a component update, as opposed to receiving an indication of an update. For example, a developer of a component may “push” an update out to known users, subscribers, and/or services of the component. In this example, the receiving service  406  is functional to receive the update and allow one or more services/machines of the distributed computing environment  400  to utilize the update, such as to update a related component. Therefore, in an exemplary embodiment, the receiving service  406  is a service, when executed by a processor, that allows for the receiving of an update or an indication of an update. 
     The component update service  408  is functional to, among other responsibilities, identify a component within an application, inventory the component, identify from the inventory an application with the component, and facilitate the updating of the component with an update. In an exemplary embodiment, the component update service  408  is computer code, that when executed by the processor  402 , facilitates the updating of a component utilized by an application within the distributed computing environment  400 . In an exemplary embodiment, the component update service  408  is functionally equivalent to the update service machine  302  previously discussed with respect to  FIG. 3 . Therefore, as previously discussed, the update service machine  302  may be a virtual machine acting a service operating within a distributed computing environment. 
     In an exemplary embodiment, the component update service  408  is functional to automatically identify an application image (or an application) that utilizes or relies on a component that is available for update. As used herein, an application image and an application may be used interchangeably depending on a level of abstraction at which each is to be conceived. In an exemplary embodiment, an application may be conceptually thought of as a recipe or blueprint for building a series of code to cause one or more functions to be realized within a distributed computing system. An application image, in an exemplary embodiment, may be conceptually thought of as a snapshot of the application as executed/structured within a machine (e.g., virtual machine). Therefore, in an exemplary embodiment, the updating of a component of an application is merely the re-booting of an application within a machine so as to include an updated component as opposed to a previous (i.e., out dated) component that may have been called for in the application “recipe.” 
     Further, in an exemplary embodiment, the component update service  408  is functional to execute an application image in a virtual machine within a distributed computing environment. As discussed previously, the execution of an application image for purposes of updating a component may be done in an isolated computing environment having limited network connection, resources, and/or access. In an exemplary embodiment, the execution of an application image in a virtual machine for purposes of updating a component is significantly different from a developer of the application from configuring the application for the updated component from a computing device under the direct control of the developer. For example, the executing of the application image in an isolated computing environment of the distributed computing environment does not require intervention by a third-party (e.g., developer) to cause the application image to be executed for update purposes. Additionally, automatically executing the application image within an isolated computing environment allows for optimization of resources by the distributed computing environment that may not otherwise be realized by a third-party. Further, in order for the application image to be booted in an isolated environment of the distributed computing environment, the component update service  408 , not a third-party, identifies the application image as relying on or utilizing a component to be updated. 
     The update agent  410  is functional to update an application. For example, an image may be executed or booted in a virtual machine. The update agent  410  includes information that allows an update to a particular component being utilized within the application to be updated. As previously discussed, an update agent may be provided by a developer of the application, a developer (e.g., third-party developer) of the component, the operating system/controlling software of the distributed computing environment, and/or the like. Additionally, it is contemplated that an update agent is a combination of instructions, application program interfaces, services, computer applications, etc., that may be used in combination to facilitate updating an application. 
     In an exemplary embodiment, the component update service  408  facilitates updating of the component by employing (i.e., calling) the update agent  410  to marshal the update process for a particular application and/or component within an isolated computing environment. For example, the component update service  408  may call or cause the update agent  410  to begin an update of a component. In an additional embodiment, the update service  408  may reserve or call resources necessary for the update agent  410  to proceed with updating the component. Further yet, it is contemplated that the update agent  410  is provided by a third-party that is independent of the component update service  408 . In this example, the component update service  408  facilitates the updating of a component by calling or notifying an update agent  410  that an update to a component may be initiated. 
     The virtual machine  412  is a virtual machine operating, at least in part, within the distributed computing environment  400 . In an exemplary embodiment, the virtual machine  412  is an isolated computing environment for booting an application image, updating a component, and composing a new application image to reflect the updated component. In an additional exemplary embodiment, the virtual machine  412  is a computing device in which one or more instantiations of an application image are operating as services for a user of the distributed computing environment  400 . As previously discussed, it is contemplated that a plurality of virtual machines, such as the virtual machine  412 , are used when updating a component of an application in a distributed computing environment. 
     The store  414  is a data store for maintaining application images. For example, the store  414  may be incorporated within a distributed storage platform and functional for storing both an application image and a new application image that reflects an application following the update of a component. In an exemplary embodiment, the component update service  408  facilitates the storing, within the store  414 , of a “new” application image following the update of a component. 
     In an exemplary embodiment, an application is available within the distributed computing environment  400 . The component update service  408  determines the components that are utilized by the application and generates an inventory of those components. The receiving service  406  receives an indication from a third-party developer that an update is available for a component that is being utilized within the distributed computing environment  400 . The component update service queries the inventory to identify that the component is called for within the application. Consequently, the receiving service  406  requests and receives the update from the third-party developer. Upon receipt of the update, the component update service  408  causes the application image to be executed within an isolated computing environment provided by the virtual machine  412 . The booting within the isolated computing environment allows the update agent  410  to cause the component to be updated without causing potential conflicts throughout the distributed computing environment  400 . Following the update of the component, the component update service  408  verifies the component has been updated. The component update service  408  causes a snapshot of the updated application to be generated, which results in a “new” application image from which a service can be instantiated. This new application image is then stored within the store  414  for access by a developer/controller of the application to implement for future instantiations of the service. 
     In an exemplary embodiment booting of an application within an isolated computing environment occurs without human intervention. For example, a user is not required to initiate or approve the booting of an application image for purposes of updating a component or capturing a new application image. Similarly, human intervention is not required, in an exemplary embodiment, for causing any of the functionality discussed herein with respect to the component update service to occur or be realized. As a result, updating of a component utilized by an application may be automated while maintaining features particular to the application prior to update of the component. 
     As similarly stated for  FIG. 3 , any number of units, machines, services, and stores may be employed to achieve the desired functionality within the scope of embodiments of the present invention. Although the various units of  FIG. 4  are shown with lines for the sake of clarity, in reality, delineating various components is not so clear, and metaphorically, the lines would more accurately be grey or fuzzy. Further, although some units of  FIG. 4  are depicted as single blocks, the depictions are exemplary in nature and in number and are not to be construed as limiting. 
       FIG. 5  depicts a flow diagram illustrating a method  500  for updating an application image with a component in a distributed computing environment that is in accordance with an embodiment of the present invention. 
     At a block  502  a component is automatically determined to be utilized by a service that is accessible through a distributed computing environment. A component is utilized by a service when an underlying application calls for the component to be used in order for one or more functionalities to be achieved by an instantiation of a related application. As previously discussed, an instantiation of an application image may result in a service being performed within the distributed computing environment to perform one or more desired functions. Automatic determination of components allows for the distributed computing system to remain autonomous from manual intervention for purposes of updating an application. Consequently, efficiencies within the update process are realized and available. 
     At a block  504 , an indication that an update for the component is available is received. In an exemplary embodiment, the indication is the receipt of the update or at least a portion of the update (e.g., code, code segments). In an additional exemplary embodiment, the indication is a notification that automatically calls for an inventory of components utilized within the system to be evaluated. Further yet, the indication is a notification, which is entered into a queue, for causing an update process to begin once a predetermined threshold is achieved (e.g., a number of components are available for update, time duration passing, level of resources available). 
     Further, receiving an indication that an update is available for the component may, in an exemplary embodiment, include facilitating the addition or removal of the component at a developer&#39;s request. For example, a developer that would like to update an image containing or that will contain the component provides the indication that an “update” is available. In this example, an “update” to the component includes adding and/or removing the component, in whole or in part, to/from the application image. Therefore, a developer may request that a particular component is added or removed to/from the application image by way of sending an indication that an update to the component is available. Consequently, it is understood that in an exemplary embodiment receiving an indication of an update includes receiving an indication that a component is to be added and or removed from an application image. 
     At a block  506  an application image that is utilizing a component to be updated is identified. In an exemplary embodiment a previously generated inventory of component utilized by a plurality of application is referenced to identify which of those pluralities of applications rely on the component for which an update has been received. The identification of an application image may be accomplished by identifying which application utilizes the component and as a result a related application image to the application is identified. In an exemplary embodiment, the application image is booted in an isolated environment for a component to be updated, but in an additional embodiment, the application is reconstructed in the isolated environment to result in a new application image that reflects the updated component. 
     At a block  508  the application image identified in the block  506  is automatically executed in an isolated computing environment. Automatically executing the application or application image avoids requiring resources of a developer or owner of the underlying application from manually intervening to cause the components to be updated. Consequently, efficiencies may be achieved such as reducing the time between reception of an indication for an update and the actual booting of the application image within an isolated environment. Additionally, the component may be updated within an application without requiring previously applied customizations to be re-applied manually by a developer as a result of the component update. For example, instead of updating a generic base image for an application and the requiring the developer to apply customization features (e.g., features particular to the application image) and elements to the application, by automatically booting the existing application image, the previously applied customization for the application may be maintained or preserved while still updating the component within. 
     At a block  510  a new application image is stored to reflect the application having the component updated. In an exemplary embodiment, an application image is booted/executed within an isolated computing environment as indicated at the block  508 . An update for the component is applied to the component within the isolated computing environment; after which, the update may be verified as having been applied. 
     In an exemplary embodiment, the new application image is stored within the distributed computing environment with a unique name that follows a defined naming convention. In this example, both the application image prior to the component upgrade and the application post component upgrade are maintained within the system. A notification is sent to a user, such as the developer of the application, indicating that the new application image is available and that, with authorization, future instantiations of the application will be based from the new image. A defined naming convention allows the user to easily identify the newer application image when determining if it should be used for future instantiations of the application. 
       FIG. 6  depicts a block diagram illustrating a method  600  for updating an application image with a component in accordance with embodiments of the present invention. 
     At a block  602  a plurality of components utilized by an application represented by an application image are determined. For example, based on a review of an application that calls out various components, the components are recorded as an inventory, as indicated at a block  604 . The inventory of components may include additional information, such as resources, permissions, restrictions, and the like. In an exemplary embodiment, the inventory is maintained as an electronically searchable format that facilitates identification of application and application images that utilize various components. 
     At a block  606  an indication of an update for a component is received. As previously discussed, the indication may be a notification that an update is available. Or, in an additional exemplary embodiment, the indication of an upgrade includes the code necessary to cause the update of the component. The indication includes identification as to which component it is associated. For example, the indication may identify the component by a file name, a code, or another commonly used naming convention. 
     At a block  608 , an application that utilizes the component is automatically identified from the inventory. For example, based on recording to the inventory discussed at the block  604 , an application and an application image is identifiable based on a correlation between the known components of applications and the component associated with the received indication. 
     At a block  610  the identified application image is executed in an isolated computing environment. The isolated computing environment, in an exemplary embodiment, is a virtual machine within a cloud computing environment in which the virtual machine has limited connections and resources. 
     At a block  612  an update associated with the indication received at the block  606  is received. In this exemplary embodiment, the reception of the update may be a result of a “push” by an entity (e.g., developer) or a “pull” by one or more services and machines of the distributed computing environment. 
     At a block  614  the update of the component is facilitated. In an exemplary embodiment, facilitating update of the component is achieved by allowing an update agent provided by a developer to cause a patch to be applied to the application or component. In an exemplary embodiment, the facilitating the update include acquiring or reserving resources that allow the update to occur. Additionally, facilitating the update includes actually causing the update to occur. 
     At a block  616  verification that the component has been updated occurs. As discussed previously, the verification may include identifying a particular new file name extension (e.g., *.dll) or the like that is being utilized by a resulting instantiation of the application. 
     At a block  618  a new application image of the application utilizing the updated component is created. Creation of a new application image, in an exemplary embodiment, includes generating a snapshot of the state of the isolated computing environment while executing the application. 
     At a block  620  the new application image is stored within the distributed computing environment. As discussed previously, the application image and the new application image may both be maintained within the distributed computing environment to facilitate rollbacks and other trouble shooting processes. When a service defined by the application is requested, the new application image may be instantiated to provide the requested new instances of the service. 
     At a block  622  a user of the application is notified that a new application image is available. For example, a developer of the application, in an exemplary embodiment, is a user of the application. Similarly, an owner, controller, and other interested parties, in exemplary embodiment, are users of the application. 
     Further, in an embodiment, the notification provided to a user includes in indication that the new application is available and where the new application is maintained. Similarly, the notification may also include details related to the component and/or the update as applied to the new application image. Further, the notification, in an embodiment where the new application image is being used for instantiations of the service, includes information useable for rolling back to the previous application image prior to updating of the component. 
     In response to this notification, the user may provide a response that a particular application image is to be sued for the instantiation of a service. Consequently, a user selection as to which image is to be sued for instantiating a related service is received by the distributed computing environment, which facilitates offering the related service to one or more entities. 
     Many different arrangements of the various components depicted, as well as components not shown, are possible without departing from the spirit and scope of the present invention. Embodiments of the present invention have been described with the intent to be illustrative rather than restrictive. Alternative embodiments will become apparent to those skilled in the art that do not depart from its scope. A skilled artisan may develop alternative means of implementing the aforementioned improvements without departing from the scope of the present invention. 
     It will be understood that certain features and subcombinations are of utility and may be employed without reference to other features and subcombinations and are contemplated within the scope of the claims. Not all steps listed in the various figures need be carried out in the specific order described.