Large entities such as corporations, companies, educational institutions, and other organizations have hundreds of interconnected nodes as part of the large entity's information technology (IT) infrastructure. Each node may be a server, desktop computer, laptop computer, or other computer device. The interconnection between nodes is typically achieved using a network with connection devices, such as routers and hubs, and one or more connection mediums, such as standard network cables and wireless devices. By using the interconnection between nodes, large entities are able to provide greater functionality to the entity's employees and customers. Typically, the nodes are heterogeneous in terms of the architecture, applications, and operating system. For example, nodes are often configured and designed for a specific task, such as web server servicing web applications.
Managing the IT infrastructure of a large entity, when hundreds of heterogeneous nodes exist, is a non-trivial task. Specifically, the nodes, network, and all applications must be kept current, operable, and follow performance requirements.
One method for managing the IT infrastructure is for a large entity to have several system administrators, each of whom is responsible for a subset of nodes. Using this solution, management between subsets is often difficult to provide consistency. Accordingly, many large entities contract out portions or all of the IT computing space. Specifically, certain portions of the network may be managed by a business, such as a managed service provider, that specializes in managed computing service. For example, one managed service provider may manage the network, while another managed service provider may manage the personal computers of the employees.
In order to provide the managed computing service, the managed service provider must have access to the portion the managed service provider is managing. Specifically, the managed service provider must be able to determine when the portion is not functioning properly or needs updating. One manner for the managed service provider to access the portion is for the managed service provider to go physically to the large entity or access the network of the large entity remotely.
Once the managed service provider has access to the portion, then the managed service provider may use any number of monitoring tools to track the large entity's IT environment and maintain state of enterprise, configurations, log files, performance metrics. The managed service provider may adjust configuration settings, and update, replace, and add any necessary components.
In general, in one aspect, the invention relates to a method for providing managed computing service for a plurality of clients using a remote file system that includes obtaining a plurality of service unit files associated with each of the plurality of clients, updating a service unit file in the plurality of service unit files when a service unit is found not current based on the plurality of service unit files, and accessing the service unit file in the plurality of service unit files to update the plurality of clients, wherein the plurality of service unit files are stored and accessed on the remote file system by using a local file system.
In general, in one aspect, the invention relates to a computer system for providing managed computing services for a plurality of clients using a remote file system that includes a remote file system for storing a plurality of service unit files associated with each of the plurality of clients, and a processor within the computer system for executing software instructions to perform obtaining a plurality of service unit files associated with each of the plurality of clients, updating a service unit file in the plurality of service unit files when a service unit is found not current based on the plurality of service unit files, and accessing the service unit file in the plurality of service unit files to update the plurality of clients, wherein the plurality of service unit files are stored and accessed on the remote file system by using a local file system.
In general, in one aspect, the invention relates to a system for providing managed computing services for a plurality of clients using a remote file system that includes a remote file system for storing a plurality of service unit files associated with each of the plurality of clients, and a service unit manager connected to the remote file system for obtaining a plurality of service unit files associated with each of the plurality of clients, updating a service unit file in the plurality of service unit files when a service unit is found not current based on the plurality of service unit files, and accessing the service unit file in the plurality of service unit files to update the plurality of clients, wherein the plurality of service unit files are stored and accessed on the remote file system by using a local file system.
Other aspects and advantages of the invention will be apparent from the following description and the appended claims.
Specific embodiments of the invention will now be described in detail with reference to the accompanying figures. Like elements in the various figures are denoted by like reference numerals for consistency.
In the following detailed description of embodiments of the invention, numerous specific details are set forth in order to provide a more thorough understanding of the invention. However, it will be apparent to one of ordinary skill in the art that the invention may be practiced without these specific details. In other instances, well-known features have not been described in detail to avoid unnecessarily complicating the description.
In general, embodiments of the invention provide a method and apparatus for providing access to the IT infrastructure of a large entity. Specifically, embodiments of the invention use a file system which may be shared between the large entity and one or more managed service providers managing the large entity. Portions of the large entity that are being managed may store files on the shared file system. Thus, the managed service provider may access the shared files in order to manage the IT infrastructure of the large entity.
As shown in
The file system (110) may correspond to a file system for the entire client (102) or for a node (e.g., node A (108), node B (107), node n (109)). In one or more embodiments of the present invention, the file system (110) includes an interface to a remote file system (112). The interface to the remote file system (112) provides access to the remote file system for the client (126) (described below). Specifically, in one or more embodiments of the invention, as part of a directory structure for the file system (110) appears the remote file system. For example, a node may have a file system (110) with a “c:” drive which corresponds to a local hard drive, an “a:” drive which corresponds to a local floppy drive, and an “e:” drive which corresponds to the interface to remote file system (112). Accordingly, in one or more embodiments of the invention, a service unit (114), administrator or any application may access files on the remote file system for the client (126) using a similar interface (e.g., user interface (UI) or application programming interface (API)) provided for accessing files on a local disk. Thus, in accordance with one or more embodiments of the invention, the remote file system for the client (126) is simultaneously visible to both the client (102) and the backend (106).
Continuing with
Rather than accessing files on the remote file system, the service unit (114) may be based on the remote file system for the client (126) in accordance with one or more embodiments of the invention. Specifically, all of the files of the service unit may be store on the remote file system for the client (126). Accordingly, the service unit (114) may only be executed by a processor (not shown) on the node (e.g., node A (108)) which accesses the remote file system (126) using the interface to the remote file system (112). Accordingly, new service units (not shown) based on the remote file system for the client (126) may be added remotely by loading the service units on the remote file system for the client (126).
Those skilled in the art will appreciate that rather than the service unit (114) located on the node (e.g., node A (108)), the service unit (114) may optionally be connected to the node (e.g., node A (108), node B (107), node n (109)). Specifically, the service unit (114) may be associated with and provide functionality to multiple nodes (e.g., node A (108), node B (107), node n (109)). For example the service unit may be a router which maintains configuration files using the interface to the remote file system (112) on one of the nodes (e.g., node A (108), node B (107), node n (109)).
Further, those skilled in the art will appreciate that the node (e.g., node A (108), node B (107), node n (109)) may not be located within the parameters of client (102). Specifically, the node (e.g., node A (108), node B (107), node n (109)) may correspond to a laptop computer of a user in transit. Accordingly, in one or more embodiments of the invention, the node (e.g., node A (108), node B (107), node n (109)) may be directly connected to the wide area network (104).
However, when the node (e.g., node A (108), node B (107), node n (109)) is within parameters of the client, a network (116) may be used to connect the nodes (e.g., node A (108), node B (107), node n (109)). The network (116) may correspond to any type of mechanism for connecting nodes (e.g., node A (108), node B (107), node n (109)). Specifically, the network (116) may correspond to direct connections between the nodes (e.g., node A (108), node B (107), node n (109)), one or more local area network (LANs), wide area networks (WANs), etc.
Continuing with
In one or more embodiments of the invention, the backend (106) is connected to the client (102) via the wide area network (104). The backend (106) corresponds to a group of connected servers (not shown) and includes functionality to manage all or a portion of the client (102). Specifically, associated with the backend (106) may be one or more managed service providers, which are contracted by the client (102) to manage the IT infrastructure of the client (102). Accordingly, the backend (106) includes functionality to track changes in the client (102) and maintain state of enterprise, configurations, log files, performance metrics. Further, the backend (106) may include functionality to adjust configuration settings, and update, replace, and add any necessary components or service units (114).
The backend includes a storage farm (124), a knowledge repository (134), a service unit manager (130), and a service logic engine (142). Each of these components is described below.
Continuing with
In one or more embodiments of the invention, the remote file system (126) stores the service unit files (128) for the client (124). The service unit files (128) may include configuration files, log files, performance measurement files, a copy of the boot image, and other such files. Specifically, the service unit files (128) may correspond to files for the service unit (114). More specifically, rather than having the service unit boot using local files from the file system (110), the service unit may use the service unit files (128) stored on the remote file system for the client (126) in accordance with one or more embodiments of the invention. Further, the service unit files may also include the output from the service unit (110) such as log files and other such files.
Continuing with
The service unit manager (130) includes functionality to review the service unit files (128) and determine whether modifications, additions, or deletions to the service unit or service unit files are required. Specifically, the service unit manager (130) includes functionality to manage the service unit through the service unit files (128) and submit notifications if any hardware modifications need to be performed. Those skilled in the art will appreciate that the service unit manager may manage the entire service unit or only a portion of the service unit. Accordingly the service unit manager (130) may review all service unit files (128) associated with a service unit, or the service unit files (128) associated with the portion of the service unit the service unit manager manages (130). Further, the service unit manager (130) may correspond to a software program, a group of employees for the managed service provider, a combination thereof, or virtually any other entity which may manage a service unit (not shown) using the service unit files (128). In order to manage the service unit (not shown), the service unit manager (130) may be connected to a knowledge repository (134) in accordance with one or more embodiments of the invention.
The knowledge repository (134) maintains the current knowledge of all or a subset of the service units (not shown) on the client (102). For example, the knowledge repository (134) may maintain information regarding modifications that should be made to the service unit, a listing of rules for updating the service unit, and other such information that may be required for maintaining the service unit. For example, when a software vendor publishes an update, information regarding the update may be added to the knowledge repository (134). Accordingly, in one or more embodiments of the invention, the knowledge repository (134) may be continuously kept updated by the vendors of the different service units (not shown). Alternatively, the knowledge repository (134) may be updated by a web engine accessing the component vendors' websites. Typically, the knowledge repository (134) is kept continuously updated.
Further, one skilled in the art will appreciate that because communication between client and the backend data center is typically performed using the wide area network, various security measures may be used that are not shown or discussed in
Accordingly, each subtree (e.g., service unit 1 file system subtree (168), service unit 2 file system subtree (170), service unit n file system subtree (172)) includes the files particular to the service unit (e.g., service unit 1 file 1 (174), service unit 1 file x (176), service unit 2 file 1 (178), service unit 2 file y (180), service unit n file 1 (182), service unit n file z (184)). Thus, when the service unit (e.g., service unit 1 (162), service unit 2 (164), service unit n (166)) or the service unit manager wants to access the files for the service unit (e.g., service unit 1 file 1 (174), service unit 1 file x (176), service unit 2 file 1 (178), service unit 2 file y (180), service unit n file 1 (182), service unit n file z (184)), the service unit (e.g., service unit 1 (162), service unit 2 (164), service unit n (166)) or the service unit manager only need to access the folder for the service unit (e.g., service unit 1 (162), service unit 2 (164), service unit n (166)). Therefore, the exchange of information associated with the service unit (e.g., service unit 1 (162), service unit 2 (164), service unit n (166)) may be performed by simply accessing a file as if the file was local.
Those skilled in the art will be able to appreciate that while
Next, the service unit stores the files to the remote file system (Step 203). As stated above, storing the files to the remote file system may be performed as easily as storing the files to a local directory.
Alternatively, rather than configuring the service unit to store the service unit files on the remote file system, the service unit may be installed on the remote file system. Accordingly, the client may be configured to access the remote file system in order to execute the service unit. By using the interface to the remote file system, executing the service unit may be performed as if the service unit were stored on local file system of the client.
Returning to
After transferring the files to the service unit manager, in one or more embodiments of the invention, the service unit manager reviews the files (Step 207). For example, the service unit manager may check the log files to determine how the client or a portion of the client is operating, review the configuration files to determine whether changes are made by the client to the configuration files, or review any other of the possible service unit files to determine the state of the service unit.
Once the files are reviewed by the service unit manager, a determination is made whether changes are required to the service unit based on the files (Step 209). Specifically, in one or more embodiments of the invention, the service unit manager may compare the configuration files with an ideal configuration in the knowledge repository, review the log files to determine whether configuration changes are required, update the boot image using new knowledge in the knowledge repository, update a schema when the service unit is a database to provide better performance, or perform virtually any other updating or comparison. The knowledge repository may be continuously populated, for example, by the vendor's of the service unit sending notifications of possible updates to the service unit, an update engine which visits vendor's websites, or using virtually any other method which allows for the knowledge repository to obtain information about the service units. Accordingly, by using a knowledge repository, multiple clients may be managed by only maintaining the data in the knowledge repository.
Continuing with
Those skilled in the art will appreciate that certain changes, such as adding or removing nodes must be performed on site. Accordingly, in this stage rather than performing the changes by accessing the file, the changes may be performed by physically accessing the client or any other method necessary. Further, the service unit manager may send a signal to the service unit that changes are required. The signal may include information about the changes to be performed or may simply specify that the service unit should check the service unit files.
Those skilled in the art will appreciate that in a system in which a cache is used and files may be updated by at least two components (i.e., service unit and service unit manager), cache coherency problems may exist. Specifically, the service unit manager may modify the service unit files at the same time that the service unit is modifying the cache of the service unit files. To solve the cache coherency problems, when any component modifies a file, the satellite server or the storage farm may send a message to inform the file not being modified that a modification is occurring. Further, embodiments of the invention may use the knowledge that certain files may be (i) modified only by the client and read by the backend; or (ii) modified only by the backend and read by the client. Accordingly, for the aforementioned certain files, cache coherency problems may be alleviated. Those skilled in the art will appreciate that there are several mechanism not stated above for solving cache coherency in a distributed system which may be used in the current system.
Continuing with
Continuing with
Alternatively, those skilled in the art will appreciate that, while not shown, the service unit manager may not wait for the changes to files to be made by the service unit. Rather, at any stage in the method, the service unit manager may adjust the files for the service unit. Specifically, the service unit may check the files on a certain interval or when new data is added to the knowledge repository. Further, the service unit manager may add additional resources, such as more nodes to the service unit.
In one or more embodiments of the invention, the service unit manager does not need to know which service unit is being serviced. Specifically, embodiments of the invention provide a uniform method for accessing service unit files. Specifically, the service unit may be based on the location of the service unit files within the remote file system. Further, in one or more embodiments of the invention, the service unit manager is able to manage the service unit without knowledge of the platform of the node on which the service unit executes or the type of device of the node. Accordingly, the service unit manager is able to manage service units executing on heterogeneous nodes and using heterogeneous operating systems.
Specifically, suppose there is a service unit manager which manages the database service unit (303) and, in particular, an Oracle database. The database servers may use the Oracle database files (309) such as the schema files (311) to service queries and add entries. Because the files are shared on the remote file system, the service unit manager, which may be physically located across the world, may access the schema files to update the schema for the database. Moreover, both the access by the database and the access by the service unit manager may be performed as if the files were local.
As another example, consider the case in which a service unit manager is responsible for managing only the web server (313). While monitoring a log file (315) for the web server (313), the service unit manager discovers that midday, the number of queries to the web server increases to the extent that response time is low. Accordingly, the service unit manager may access the web server configuration file (317) and make appropriate corrections. Alternatively, the service unit manager may add resources to service queries during the midday.
As shown above, by using the model of a file system to transfer data, both the service unit and the service unit manager may access the required files easily as if the files were stored locally.
The invention may be implemented on virtually any type of computer regardless of the platform being used. For example, as shown in
Further, those skilled in the art will appreciate that one or more elements of the aforementioned computer system (500) may be located at a remote location and connected to the other elements over a network. Further, the invention may be implemented on a distributed system having a plurality of nodes, where each portion of the invention (e.g., service logic engine, service unit manager, service unit files, service unit, file system, and the like.) may be located on a different node within the distributed system. In one embodiment of the invention, the node corresponds to a computer system. Alternatively, the node may correspond to a processor with associated physical memory. The node may alternatively correspond to a processor with shared memory and/or resources. Further, software instructions to perform embodiments of the invention may be stored on a computer readable medium such as a compact disc (CD), a diskette, a tape, a file, or any other computer readable storage device.
Embodiments of the invention may include one or more of the following advantages. First by storing files to a remote file system, the complex set of user interfaces, protocols and system management tools that a managed service provider previously must use is hidden and in some cases eliminated. Specifically, because both the service unit and the service unit manager at the managed service provider may access the same set of files and the actual transfer of the data in the files are hidden. More specifically, both the service unit and the service unit manager may modify the files as if the files were local even though the service unit and the service unit manager are physically separated across and internet in accordance with one or more embodiments of the invention.
While the invention has been described with respect to a limited number of embodiments, those skilled in the art, having benefit of this disclosure, will appreciate that other embodiments can be devised which do not depart from the scope of the invention as disclosed herein. Accordingly, the scope of the invention should be limited only by the attached claims.