Snapshot volume proxy for object storage interfaces

A snapshot storage proxy receives a request from an object storage interface component to access a snapshot volume, wherein the request is formatted to interact with object storage data, and wherein the snapshot volume is stored as non-object storage data; translates the request from the object storage interface into a snapshot volume request, wherein the snapshot volume request is formatted to interact with non-object storage data; and accesses the snapshot volume in view of the translated snapshot volume request.

TECHNICAL FIELD

The present disclosure is generally related to computer systems, and more particularly, to enabling a snapshot volume proxy for object storage interfaces in cloud computing systems.

BACKGROUND

Platform-as-a-Service (PaaS) system offerings can include software and/or hardware facilities for facilitating the execution of applications (web applications, mobile applications, etc.) in a cloud computing environment (the “cloud”). Cloud computing is a computing paradigm in which a user engages a “cloud provider” to execute a program on computer hardware owned and/or controlled by the cloud provider. A cloud provider can make virtual machines (VMs) hosted on its computer hardware available to customers for this purpose. The cloud provider can provide an interface that a user can use to requisition virtual machines and associated resources such as security policies, processors, storage, and network services, etc., as well as an interface to install and execute the user's applications and files on the virtual machines.

PaaS offerings can facilitate deployment of application workloads without the cost and complexity of buying and managing the underlying hardware and software and provisioning hosting capabilities, providing the facilities to support the complete life cycle of building and delivering application workloads and services entirely available from the Internet.

DETAILED DESCRIPTION

Described herein are methods and systems for a snapshot storage proxy for facilitating communication translation between snapshot storage data and object storage interfaces in a cloud computing environment. Cloud computing environments provide many advantages over locally owned computing systems. For example, cloud computing environments can optimize resources by sharing them across multiple users and multiple clients, thereby reducing costs otherwise dedicated to procuring and maintaining local hardware. Additionally, cloud computing environments provide improved scalability for clients. Instead of purchasing additional local computing resources, supporting more data storage and buying more software licenses to support growth in the business, users can rent more storage space, acquire more bandwidth and increase access to software programs which are controlled by a cloud computing provider.

Cloud computing environments, however, can present challenges with the management of data storage. As with other types of enterprise systems, cloud computing environments can implement data protection capabilities that include storage snapshots and backups that provide point in time data copies that can be restored in the event of data corruption, data loss, or ransomware incursion. A storage snapshot is an image or reference point created at a particular point in time which preserves the state of a system, server, storage volume, etc., so that recovery can be performed to return the system to the preserved state. In conventional systems, the snapshot data is typically stored as an immutable volume (e.g., cannot be overwritten, deleted, or edited) to preserve the validity of the captured state information.

While the use of snapshots can provide significant flexibility for data recovery, various conventional cloud providers can provide storage solutions that vary from one another, which can increase complexity in the management of those snapshots. For example, some cloud computing environment clients can implement their applications using storage providers that store data as block data or file based data while others can utilize storage providers that store data as object data. File storage is network attached storage where the data is typically stored in a folder type structure. When a file needs to be accessed, the full path of file location should be known. Block storage can save data in blocks and should be accessed through a particular network structure (e.g., a storage area network (SAN)). Object storage is a type of architecture where each file is saved as an object that can be accessed using a hypertext transfer protocol (HTTP) request. Each type of storage solution involves different network configurations and storage protocols. Thus, an interface developed for one type of storage does not readily interact with data of other types.

Applications deployed in a large hybrid cloud computing environment that use different storage solution architectures can significantly increase environment complexity since data storage tools and interfaces may need to be developed for each type of storage architecture implemented. In some instances, the tools available for one type of storage solution may be significantly more robust than others, which can increase management and development costs associated for those solutions lacking robust toolsets. For example, many object storage solutions offer robust, standardized toolsets to interact with object based data, including snapshot data stored in object format. The toolsets available for many other types of data architectures may not be as robust, which can involve increases in development costs for a cloud provider to develop those tools.

Some conventional cloud providers attempt to mitigate these issues by restricting the storage architectures implemented to those with robust toolsets. This, however, can often result in a more narrowly limited storage architecture platform, which can significantly decrease the flexibility and efficiency of the cloud environment. Alternatively, cloud providers can implement solutions where snapshot data that is stored as non-object data (e.g., block data, file data, etc.) is copied to object data. While this can offer more advanced and readily available toolsets to manage the data, it can significantly increase the storage requirements as well as processing resources involved in conducting the copy operations.

Aspects of the present disclosure address the above noted and other deficiencies by implementing a snapshot storage proxy (e.g., as a computer program or a computer program component) to facilitate communication translation between snapshot storage data and object storage interfaces in a cloud computing environment. The snapshot storage proxy can expose non-object persistent snapshot image volume data as an object storage endpoint to enable an object storage interface to access the non-object data as if it were an object. Subsequently, the snapshot storage proxy can receive a request from an object storage interface (e.g., a toolset configured to access object data) to access a snapshot volume where the request formatted to interact with object storage data, and where the target data is stored as non-object storage data. The snapshot storage proxy can translate the request into a snapshot volume request that is formatted to interact with the non-object storage data, and subsequently, can access the snapshot using the translated request.

Aspects of the present disclosure present advantages over conventional solutions to the issues noted above. First, the snapshot storage proxy of the present disclosure can provide the ability to access non-object data storage solutions using the tools developed to interact with object-based storage solutions. This can significantly streamline cloud environments by providing the ability to utilize the conventionally implemented and accepted object storage tools across an environment with hybrid storage architecture without the need to replicate those tools for each storage solution. This, in turn, can significantly reduce development costs as well as processing costs associated with maintaining hybrid storage infrastructure access tools. Similarly, by translating requests formatted for object data into a format that can be recognized and processed by non-object data interfaces, the non-object data can remain in place without being copied into objects. This can significantly reduce overall storage costs since data need not be copied in order to access with more robust toolsets. Moreover, by reducing the resources needed for interacting with non-object data, the snapshot storage proxy can improve the performance of snapshot data management within the cloud environment, providing increased efficiency in management of cloud computing resources overall.

FIG.1is a block diagram of a network architecture100in which implementations of the disclosure may operate. In some implementations, the network architecture100may be used in a containerized computing services platform. A containerized computing services platform may include a Platform-as-a-Service (PaaS) system, such as OpenShift® or Kubernetes®. The PaaS system provides resources and services (e.g., micro-services) for the development and execution of applications owned or managed by multiple users. A PaaS system provides a platform and environment that allow users to build applications and services in a clustered compute environment (the “cloud”) Although implementations of the disclosure are described in accordance with a certain type of system, this should not be considered as limiting the scope or usefulness of the features of the disclosure. For example, the features and techniques described herein can be used with other types of multi-tenant system

s and/or containerized computing services platforms.

As shown inFIG.1, the network architecture100includes a cloud-computing environment130(also referred to herein as a cloud) that includes nodes111,112,121to execute applications and/or processes associated with the applications. A “node” providing computing functionality may provide the execution environment for an application of the PaaS system. In some implementations, the “node” may refer to a virtual machine (VM) that is hosted on a physical machine, such as host 1110through host N120, implemented as part of the cloud130. For example, nodes111and112are hosted on physical machine of host 1110in cloud130provided by cloud provider104. In some implementations, an environment other than a VM may be used to execute functionality of the PaaS applications. When nodes111,112,121are implemented as VMs, they may be executed by operating systems (OSs)115,125on each host machine110,120.

In some implementations, the host machines110,120are often located in a data center. Users can interact with applications executing on the cloud-based nodes111,112,121using client computer systems, such as clients160,170and180, via corresponding client software161,171and181. Client software161,171,181may include an application such as a web browser. In other implementations, the applications may be hosted directly on hosts 1 through N110,120without the use of VMs (e.g., a “bare metal” implementation), and in such an implementation, the hosts themselves are referred to as “nodes”.

Clients160,170, and180are connected to hosts110,120in cloud130and the cloud provider system104via a network102, which may be a private network (e.g., a local area network (LAN), a wide area network (WAN), intranet, or other similar private networks) or a public network (e.g., the Internet). Each client160,170,180may be a mobile device, a PDA, a laptop, a desktop computer, a tablet computing device, a server device, or any other computing device. Each host110,120may be a server computer system, a desktop computer or any other computing device. The cloud provider system104may include one or more machines such as server computers, desktop computers, etc.

In various implementations, developers, owners, and/or system administrators of the applications may maintain applications executing in cloud130by providing software development services, system administration services, or other related types of configuration services for associated nodes in cloud130. This can be accomplished by accessing cloud130using an application programmer interface (API) within the applicable cloud service provider system104. In some implementations, a developer, owner, or system administrator may access the cloud service provider system104from a client device (e.g., clients160,170, and180) that includes dedicated software to interact with various cloud components. Additionally, or alternatively, the cloud service provider system104may be accessed using a web-based or cloud-based application that executes on a separate computing device that communicates with a client device via network102.

In one implementation, the cloud provider system104is coupled to a cloud controller108via the network102. The cloud controller108may reside on one or more machines (e.g., server computers, desktop computers, etc.) and may manage the execution of applications in the cloud130. In some implementations, cloud controller108receives commands from containerized system controller140. In view of these commands, the cloud controller108provides data (e.g., such as pre-generated images) associated with different applications to the cloud provider system104. In some implementations, the data may be provided to the cloud provider104and stored in a snapshot image repository106, in an image repository (not shown) located on each host110,120, or in an image repository (not shown) located on each node111,112,121. This data may be used for the execution of applications for a containerized computing services platform managed by the containerized system controller140.

In various implementations, snapshot image repository106can store snapshot images of application data as well as delta images (e.g., information describing incremental changes made to the data stored in the most recent snapshot image). The snapshot image repository106can be stored as non-object data (e.g., block storage, file storage, etc.). In some implementations, data from snapshot image repository106can be copied to object storage. Alternatively, as discussed herein, the data from the snapshot image repository can be exposed to tools available via an object storage interface application (e.g., object storage interface162) such that the data in snapshot image repository106can remain in place without being copied to object storage. Object storage interface162can be a component of client software161, or a different component executed by client160.

In one implementation, the data is used for execution of containers191,192,193,194in one or more pods151,152,153. The pods151,152,153are a group of one or more containers that are deployed together on the same node111,112,121, and are the smallest compute unit that can be defined, deployed, and managed in the containerized computing service environment. Each pod151,152,153is allocated its own internal IP address, with containers191,192,193,194within pods151,152,153being able to share local storage and networking. Pods151,152,153have a lifecycle that is defined and can run on a node111,112,121until the pod's containers exit or they are removed for some other reason.

The containers191,192,193,194can include application images built from pre-existing application components and source code of users managing the application. An image may refer to data representing executables and files of the application used to deploy functionality for a runtime instance of the application. In some implementations, the application images can be built using various types of containerization technologies (e.g., Docker™). An image build system (not pictured) can generate an application image for an application by combining a preexisting ready-to-run application image corresponding to core functional components of the application (e.g., a web framework, database, etc.) with source code specific to the application provided by the user. The resulting application image may be pushed to image repository106for subsequent use in launching instances of the application images for execution in the PaaS system.

In various implementations, a container191,192,193,194can be a secure process space on the nodes111,112,121to execute functionality of an application. In some implementations, a container191,192,193,194is established at the nodes111,112,121and122with access to certain resources of the underlying node, including memory and storage. In one implementation, the containers191,192,193,194may be established using the Linux Containers (LXC) method. In further implementations, containers191,192,193,194may also be established using cgroups, SELinux™, and kernel namespaces, to name a few examples.

In various implementations, containers191,192,193,194can include one or more executable workloads195,196,197,198. Workloads195,196,197,198can be standalone applications to be executed in containers191,192,193,194or virtual machine (VM), a virtual machine that itself hosts one or more applications, or the like. In some implementations, the executable workloads can be the containers191,192,193,194themselves that host one or more applications or VMs, or the like.

In some implementations, cloud controller108may include a snapshot storage proxy142that facilitates communication translation with object storage interfaces for the cloud-based PaaS system described above. As noted above, the snapshot image repository106can store persistent snapshot volumes as non-object based data (e.g., block storage, file storage, etc.). Snapshot storage proxy142can expose the persistent snapshot volumes to the object storage interface162as if it actually were composed of object-based data. Thus, the snapshot storage proxy142can provide the ability to use the data access tools available via object storage interface162to access the non-object data in snapshot image repository106without copying that data to object data before doing so.

As will be discussed in further detail below, snapshot storage proxy142can expose configuration information from the snapshot image repository106to object storage interface162as an object storage endpoint to enable object storage interface162to access the non-object data. Subsequently, snapshot storage proxy142can receive a request from object storage interface162to access a snapshot volume in snapshot image repository106. As noted above, since this request is received from the object storage interface162, it can be formatted to interact with object storage data whereas the target data is stored as non-object storage data. Snapshot storage proxy142can translate the request from object storage interface162into a snapshot volume request, where that translated request is formatted to interact with the non-object storage data stored in snapshot image repository106. Subsequently, snapshot storage proxy142can access snapshot image repository106using the translated request.

Similarly, snapshot storage proxy142can translate any response data received from the snapshot image repository106into a format that can be received by the object storage interface162. In such instances, snapshot storage proxy142can receive a notification from snapshot image repository106that indicates that a request to access the applicable snapshot volume has been performed. In various implementations, the notification can include response data to be provided to the requesting client. Snapshot storage proxy142can translate the response received from the snapshot image repository106into a format that can be received by object storage interface162, and subsequently provide the translated response to the object storage interface.

While aspects of the present disclosure describe the snapshot storage proxy142as implemented in a PaaS environment, it should be noted that in other implementations, the snapshot storage proxy142can also be implemented in an Infrastructure-as-a-Service (Iaas) environment, such as such as Red Hat OpenStack®. Additionally, while for simplicity of illustration,FIG.1depicts a single cloud130, aspects of the present disclosure can be implemented to manage workloads across multiple clouds130. In such instances the snapshot storage proxy142can manage storage interface translation for hybrid cloud environments, multi-cluster cloud environments, or the like. Snapshot storage proxy142is described in further detail below with respect toFIGS.2-3.

FIG.2depicts a block diagram illustrating an example of a snapshot storage proxy210for facilitating communication translation with an object storage interface in a cloud computing environment. In some implementations, snapshot storage proxy210may correspond to snapshot storage proxy142ofFIG.1. As shown inFIG.2, snapshot storage proxy210may be a component of a computing apparatus200that includes a processing device205, operatively coupled to a memory201, to execute snapshot storage proxy210. In some implementations, processing device205and memory201may correspond to processing device502and main memory504respectively as described below with respect toFIG.5.

Snapshot storage proxy210may include request receiver211, protocol translator212, snapshot volume access module213, response receiver214, and object storage interface notification module215. Alternatively, the functionality of one or more of request receiver211, protocol translator212, snapshot volume access module213, response receiver214, and object storage interface notification module215may be combined into a single module or divided into multiple sub-modules.

Request receiver211is responsible for receiving a request from an object storage interface component to access a snapshot volume in a cloud computing environment. As noted above, the request can be received from a user interface (or other interface component) executing on a client device (e.g., object storage interface161of client160inFIG.1), where that interface component includes tools/functionality that is configured to interact with object storage data. Accordingly, in various implementations, the received request can be formatted to interact with object storage data (e.g., Amazon S3® object data). Also as noted above, the snapshot volume to which access is being requested (e.g., snapshot image repository106inFIG.1) can be stored as non-object storage data.

In some implementations, the request can be directed to performing various operations on the snapshot volumes using the tools that are configured for accessing object storage data. For example, the request can be a request to wherein the request comprises a request to perform a replication operation (e.g., where the target snapshot is to be replicated, etc.), a compression operation (e.g., where the target snapshot is to be compressed, etc.), an encryption operation (e.g., where the target snapshot is to be encrypted, etc.), an upload operation (e.g., where data is to be uploaded to the snapshot data store, etc.), a download operation (e.g., where the target snapshot is to be downloaded from the snapshot data store, etc.), a tiering operation (e.g., where the target snapshot is to be tiered, etc.), a versioning operation (e.g., interacting with a particular snapshot version, creating a new snapshot version, etc.), a listing operation (e.g., listing the snapshots in a volume, etc.), a creation operation (e.g., creating a new snapshot image, etc.), or a life cycling operation.

Notably, as discussed above, the requested operations can be configured by the object storage interface to interact with data configured as object data, rather than non-object data. In some implementations, the request received by request receiver211can be formatted using a particular application programming interface (API) protocol (or a particular communication protocol) associated with interacting with object data. As discussed below, the protocol associated with interacting with the object data can include multiple communication elements, attributes, or features that define how the object storage interface interacts with object data as well as any applicable elements, attributes, features, or content of the data stored in object data.

In some implementations, the snapshot storage proxy210can facilitate receipt of the request by initially exposing configuration information associated with the snapshot volume data as if it were object storage by exposing an “endpoint” for the snapshot volume data to the object storage interface. A storage endpoint can represent settings and access credentials needed to connect to the object storage API. In various implementations, the snapshot storage proxy210can expose the endpoint to the snapshot data such that it is in the format expected by the object storage interface, but representing the settings and access credentials needed to access the snapshot volume data that is stored as non-object data.

Protocol translator212is responsible for translating the request from the object storage interface into a snapshot volume request, where the snapshot volume request is formatted to interact with non-object storage data. Protocol translator212can perform the translation operation by examining the object-based request and determining non-object storage data operations that can be performed on the snapshot data to satisfy the request. In some implementations, protocol translator212can analyze the request from the object storage interface in view of an object storage interface protocol used by the interface. As noted above, the object storage interface protocol can include the elements, attributes, features, or data that define how the object storage interface interacts with object data. In some implementations, the snapshot storage proxy210can be specifically configured to receive requests for a specific protocol. Alternatively, the snapshot storage proxy210can be configured to receive requests for multiple protocols, and the request can specify the protocol used.

In various implementations, after identifying the protocol being used, protocol translator212can identify the applicable protocol features associated with the request from the object storage interface. In some instances, protocol translator212can retrieve protocol information from a data store (e.g., object interface protocol information202) that includes the layout, format, content, etc. of the applicable object interface protocol. Alternatively, protocol translator212can identify this information in view of the format of the request itself. For example, in instances where the protocol being used is defined with key/value pairs, protocol translator212can identify the protocol features of the request by parsing the key value pairs.

In various implementations, the protocol features associated with the request can specify the particular operation to be performed on the target snapshot data, the data to be retrieved and/or modified, the location of the snapshot data, or the like. In such instances, protocol translator212can identify object data instructions and/or operations using the information included in the request. Alternatively, protocol translator212can use information from the request and access information that maps object interface protocol information to applicable object data access instructions (e.g., instruction mapping information204).

Subsequently, protocol translator212can determine one or more snapshot volume instructions to perform operations on the snapshot data that are associated with the identified object storage protocol features. In other words, once protocol translator212identifies the object-based operations to be performed, it can then identify one or more analogous instructions that can be performed on the snapshot data to satisfy the request. In some implementations, protocol translator212can identify the snapshot instructions to be performed by accessing mapping information that maps an object-based instruction (or instructions) to a snapshot-based instruction (or instructions). For example, this instruction mapping can be stored in instruction mapping information204.

Snapshot volume access module213is responsible for accessing the snapshot volume in view of the translated snapshot volume request. In various implementations, snapshot volume access module213can access the snapshot volume using the applicable instruction (or instructions) identified by protocol translator212. In such instances, snapshot volume access module213can execute the one or more snapshot volume instructions to perform the snapshot operations on the snapshot volume that satisfy the received request.

Response receiver214is responsible for receiving a notification from the snapshot volume that the request to access the snapshot volume has been performed. The notification can include response information associated with the snapshot volume request that is formatted for a non-object storage interface. In other words, the response information may be in a format that is not readily accepted by the object storage interface component that provided the original request to request receiver211. In various implementations, the notification can be received as a return code, a response message, an API response from the snapshot data volume, or the like.

In some implementations, response receiver214can invoke protocol translator212to translate the response received from the snapshot data volume into a format understood and/or accepted by the object storage interface component. In such instances, protocol translator212can translate the response information from the received notification into an object storage response, where the object storage response is formatted for the object storage interface component. In various implementations, protocol translator212can follow the reverse of the process mentioned above for translating the request.

For example, protocol translator212can analyze the response information in view of the snapshot volume interface protocol (e.g., snapshot volume interface protocol203), where the snapshot volume interface protocol includes protocol features associated with accessing the snapshot data volume. Protocol translator212can then identify one or more snapshot volume features of the first set of protocol features associated with the response information from the first notification. As noted above, protocol translator212can identify these features by accessing the stored snapshot volume interface protocol203, or in the alternative, identify these features using the context of the response (e.g., the key/value pair notations included in the response). Once the applicable features have been identified, protocol translator212can map the identified snapshot volume features to corresponding object storage interface protocol features for the object storage interface protocol associated with the original request. As noted above, protocol translator212can perform this mapping by accessing information stored in instruction mapping information204. Subsequently, protocol translator212can generate the object storage response using this mapping.

Object storage interface notification module215is responsible for providing a notification to the object storage interface using the object storage response generated by response receiver214and protocol translator212.

FIGS.3A-3Billustrate examples of a snapshot storage proxy for facilitating communication translation with object storage interfaces in a cloud computing environment.FIG.3Aillustrates an example of translating a request from an object storage interface into a snapshot data volume request. As shown inFIG.3A, snapshot storage proxy142receives a request (e.g., access request350) from object storage interface162to access a persistent snapshot volume in snapshot image repository106. As described above with respect toFIG.2, the request can be received from a component of a client device that provides storage management interface functionality to object storage data, and the access request350can be formatted to interact with object storage data. Also as described above, access request350can be formatted to interact with object storage data, while the target snapshot data stored in snapshot image repository106is stored as non-object storage data.

As shown inFIG.3A, snapshot storage proxy142can receive access request350using a communication protocol or API that specifies particular communication and/or data features associated with interacting with object storage (communication361). Snapshot storage proxy142can then translate access request350into a format that can be processed by the snapshot image repository106(operation(s)362). As described above with respect toFIG.2, snapshot storage proxy142can analyze the information included the request, and identify the applicable features associated with that request. In various implementations, snapshot storage proxy142can conduct the analysis using stored information that describes the protocol rules associated with the object storage interface162(e.g., object interface protocol information302).

Subsequently, snapshot storage proxy142can translate the received access request350by determining one or more instructions to perform operations362on the snapshot volume in snapshot image repository106. In various implementations, snapshot storage proxy142can use the communication protocol rules associated with communication with the snapshot image repository106(e.g., snapshot volume interface protocol303) as well as mapping rules that map object storage instructions to their associated snapshot volume instructions (e.g., instruction mapping information304). Once the request has been translated to an analogous request or set of instructions that can be performed on the snapshot volume, snapshot storage proxy142can perform the access operation on snapshot image repository106to satisfy access request350.

FIG.3Billustrates an example of translating a response from a snapshot data volume to response for an object storage interface in a cloud computing environment As shown inFIG.3B, snapshot storage proxy142receives a notification (e.g., notification363) from snapshot image repository106that indicates that an access request (e.g., access request350ofFIG.3A) has been performed. As described above with respect toFIG.2, the notification can include response information associated with the processed access request, where the response data is formatted for a snapshot data that is stored as persistent volumes in a non-object format (e.g., file data, block data, etc.).

As shown inFIG.3B, snapshot storage proxy142can receive notification363using a communication protocol or API that specifies particular communication and/or data features associated with interacting with non-object data. Snapshot storage proxy142can then translate the notification into a format that can be processed by the object storage interface162(access response351). As described above with respect toFIG.2, snapshot storage proxy142can analyze the information included the response notification, and identify the applicable features associated with that response. In various implementations, snapshot storage proxy142can conduct the analysis using stored information that describes the protocol rules associated with the snapshot image repository106(e.g., snapshot volume interface protocol303).

Subsequently, snapshot storage proxy142can translate the received notification by converting the features of response363into a response that can be received understood by the object storage interface162. In various implementations, snapshot storage proxy142can use the communication protocol rules associated with communication with the object storage interface162(e.g., object interface protocol information302) as well as mapping rules that map snapshot volume protocol features to corresponding object interface protocol features (e.g., instruction mapping information304). Once the response information has been translated to an analogous response that can be received by the object storage interface162API, snapshot storage proxy142can generate the access response351and provide it to object storage interface162via communication364.

FIG.4Adepicts a flow diagram of an example method400for translating a request from an object storage interface into a snapshot data volume request in a cloud computing environment. The method may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), computer readable instructions (run on a general purpose computer system or a dedicated machine), or a combination of both. In an illustrative example, method400may be performed by snapshot storage proxy142inFIG.1and/or snapshot storage proxy210inFIG.2. Alternatively, some or all of method400might be performed by another module or machine. It should be noted that blocks depicted inFIG.4Acould be performed simultaneously or in a different order than that depicted.

At block405, processing logic receives a request from an object storage interface component to access a snapshot volume, where the request is formatted to interact with object storage data, and where the snapshot volume is stored as non-object storage data. At block410, processing logic translates the request from the object storage interface into a snapshot volume request, where the snapshot volume request is formatted to interact with non-object storage data. At block415, processing logic accesses the snapshot volume in view of the translated snapshot volume request.

FIG.4Bdepicts a flow diagram of an example method450for translating a response from a snapshot data volume to response for an object storage interface in a cloud computing environment. The method may be performed by processing logic that may comprise hardware (circuitry, dedicated logic, etc.), computer readable instructions (run on a general purpose computer system or a dedicated machine), or a combination of both. In an illustrative example, method450may be performed by snapshot storage proxy142inFIG.1and/or snapshot storage proxy210inFIG.2. Alternatively, some or all of method450might be performed by another module or machine. It should be noted that blocks depicted inFIG.4Bcould be performed simultaneously or in a different order than that depicted.

At block455, processing logic receives a first notification from the snapshot volume that the request to access the snapshot volume has been performed, where the first notification comprises response information associated with the snapshot volume request that is formatted for a non-object storage interface. At block460, processing logic translates the response information from the received first notification into an object storage response, where the object storage response is formatted for the object storage interface component. At block465, processing logic provides a second notification to the object storage interface in view of the translated object storage response.

FIG.5depicts an example computer system500which can perform any one or more of the methods described herein. In one example, computer system500may correspond to computer system100ofFIG.1. The computer system may be connected (e.g., networked) to other computer systems in a LAN, an intranet, an extranet, or the Internet. The computer system may operate in the capacity of a server in a client-server network environment. The computer system may be a personal computer (PC), a set-top box (STB), a server, a network router, switch or bridge, or any device capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that device. Further, while a single computer system is illustrated, the term “computer” shall also be taken to include any collection of computers that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methods discussed herein.

The exemplary computer system500includes a processing device502, a main memory504(e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM)), a static memory506(e.g., flash memory, static random access memory (SRAM)), and a data storage device516, which communicate with each other via a bus508.

The computer system500may further include a network interface device522. The computer system500also may include a video display unit510(e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device512(e.g., a keyboard), a cursor control device514(e.g., a mouse), and a signal generation device520(e.g., a speaker). In one illustrative example, the video display unit510, the alphanumeric input device512, and the cursor control device514may be combined into a single component or device (e.g., an LCD touch screen).

The data storage device516may include a non-transitory computer-readable medium524on which may store instructions526that include snapshot storage proxy142(e.g., corresponding to the method ofFIGS.4A-4B, etc.) embodying any one or more of the methodologies or functions described herein. Snapshot storage proxy142may also reside, completely or at least partially, within the main memory504and/or within the processing device502during execution thereof by the computer system500, the main memory504and the processing device502also constituting computer-readable media. Snapshot storage proxy142may further be transmitted or received over a network via the network interface device522.

Unless specifically stated otherwise, as apparent from the following discussion, it is appreciated that throughout the description, discussions utilizing terms such as “receiving,” “translating,” “accessing,” “identifying,” “analyzing,” or the like, refer to the action and processes of a computer system, or similar electronic computing device, that manipulates and transforms data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system memories or registers or other such information storage, transmission or display devices.

Aspects of the disclosure presented herein are not inherently related to any particular computer or other apparatus. Various general purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatus to perform the specified method steps. The structure for a variety of these systems will appear as set forth in the description below. In addition, aspects of the present disclosure are not described with reference to any particular programming language. It will be appreciated that a variety of programming languages may be used to implement the teachings of the disclosure as described herein.