In this thesis, we presented a comprehensive design for a future content deliv- ery platform. We then realised this through a prototype implementation, which explored a number of the proposed features. Further development continues on OpenCache, which serves as a platform to identify, implement and evaluate new techniques for content delivery.
An important goal for OpenCache is the fostering of a community of devel- opers and users. Progress in this respect is ongoing due to the recency of the work. In the future, this community will be vital in ensuring transparency and oversight in OpenCache. It will also serve as a platform to share additions and modifications that feedback directly into future iterations of the platform.
Future work also includes the proposition of the OpenCache API as a candi- date for standardising the method through which applications can communicate with (and subsequently control) CDNs. This can be achieved without the need to understand the specific details of the underlying resources or how to address its components.
There is also the opportunity to expand this API, including the provision of access control and tailored views. This allows different users and applications to not only have different representations of an OpenCache deployment, but also ac- cess to a different set of functions consummate to their role in the organisation or purpose as an application. This is a key step towards achieving the collaborative approach to content distribution outlined in the OpenCache design.
An important facet of using software defined networking technology is the
ability to go beyond its use as a redirection technique. We explored this in
the evaluation by implementing load-balancing and traffic steering behaviour. However, this can be taken even further. For example, replication could also be introduced, with little or no requirement to change the underlying code-base to support this. Instead, this functionality can be realised using a combination of flow modifications, and replicating the requests amongst a collection of cache nodes.
In order to give users and applications even more control over the caches in their deployment, it would be interesting to facilitate finer granularity over what content is stored on the cache. Although out of scope for this initial im- plementation, possibilities include determining the cache replacement policy on a per-object level. As this requires almost instantaneous decisions, it may be ap- propriate to have a compilable decision list or set of logic, which is then pushed to the cache node. As this is performance sensitive, this would avoid the need for a node to request information from the controller before making a decision on whether or not a content object should remain in the cache or be evicted.
There is also a clear need to investigate how resources of all types are de- scribed, provisioned and shared. Although OpenFlow makes progress towards achieving this in the field of networking, it is clearly not designed, nor intended to, consider all of these aspects in detail. However, there are wider concerns in other areas of softwarisation. For example, the OpenCache prototype is built around a proprietary interface necessary to provision resources in a compute en- vironment. Although there is a clear trend towards the format and style of these interfaces, harmonising these and ascertaining consensus amongst interested par- ties would clearly be beneficial to all interested parties.
Further research directions include the identification and realisation of addi- tional services and platforms that can be brought into software. This has been attempted in some areas, but many aspects have gone unexplored as of yet. This
process involves not only replicating basic functionality in software, but also ex- ploring how programmable infrastructure can by exploited to go beyond existing service provision and delivery.
Other directions include an investigation into how the commoditisation of compute and network resources impacts business models and user communities. This is particularly interesting in light of current trends towards the use of ho- mogenised hardware and networking platforms, which remove some of the market leverage that many of the current organisations and business hold. This is likely to be furthered by the widespread availability of flexible and configurable hardware platforms. These will be capable of operating as either compute or networking elements, without performance limitations, and seamlessly transitioning between each function.
With the flexibility offered by programmable platforms, there is a necessity to consider how the applications can best use the dynamic environment. In this case, resources are fluid, and functions can be migrated and moved without user intervention. In such an environment, it is important to define the requirements of a function (or set of such). For example, in the case of content delivery networks, it is vital to specify the performance and latency requirements, which are key to the success of the platform. Currently, there is no standard way of achieving such.
These requirements may also need to be matched and resolved against grander goals, such as reduced operating cost or more sustainable provisioning. Consider- ing that all of these metrics can change over time, there are unsolved challenges around the design and implementation of such an orchestration platform. This includes designing a common the method for gathering information from all the different potential inputs, and furthers the desire for greater coordination in such environments.