When Applications Drive the Network

#SDDC #SDN #context When applications can dictate service invocation dynamically, then we'll have a truly dynamic network

There's a lot of lip service given to the notion of applications defining the way the network behaves. That's primarily because it's recognized that today, at least, it's an application world. Applications are large and in-charge in the eyes of the business who, after all, pays all the bills

So it's really not surprising to hear a renewed focus on applications as the driving force behind behavior of networks. The network has for too long been seen as little more than a big fat pipe, a mere transportation system for bits and bytes traversing client to application and back again.

But that view undervalues the benefits of the network. The network can, after all, provide a variety of services from the mundane to the spectacular that aid in the delivery of applications. Applications, after all, aren't always aware (for a variety of technical reasons we won't dive into today because, well, you'd need a fresh pot of coffee, trust me) of conditions in the data path - including those on the Internet - that might be adversely affecting performance.

Worse, there's not a whole lot an application can do about even if it knows.

Many of the performance-enhancing options available to an application are configured on a "server" wide (and I use the term "server" here very loosely to refer to an application or web server instance) basis. Even though it might benefit Alice to turn off compression or turn on caching, it's not feasible to do so because it impacts Bob and Mary, as well. And they might need compression but not caching. Or some other combination thereof.

That's where the "network" comes in, or more precisely where the application service network comes in. It does have the visibility into the network, and into the device layer (the client), as well as the application layer to determine what the best combination of services is that will result in the best possible performance for this user on this device at this time given conditions across all networks.

Yeah, it's pretty powerful when you think about.

But what isn't always easy is managing to actually provide a dynamic means of adjusting those services in real-time. Generally speaking, you configure a set of services based on something akin to an 80/20 rule and shrug. Greater good and all that, benefits of the many outweigh the negatives to a smaller population.

But what if it didn't have to be like that? What if you could, actually, automatically make those adjustments based on context and serve 100% of the users with optimal performance?

What if the network really were driven by applications and understood that for Bob, on his iPhone at the local Sbux, compression will help so the network invokes that service - even while at the same time Mary is on her PC at headquarters and it won't, so the network doesn't invoke that service. Same application, different context. Same application, entirely different services applied on-demand. Not only is that optimal for the user, but it's also great for the business stakeholder that's paying the bills. Because not only are they now only paying for what they use, they're only paying for what they need, as well.

That's where we have to get. To a place where the network isn't just application-centric, or application-aware, but application-driven. Where applications drive service invocation in real-time, automatically and based on the unique context that surrounds each and every request that traverses the network.

I'm not talking about pre-defined application-specific policies full of if-then-else statements. I'm talking about an intermediary that's able to grab the context and evaluate it for any application and make intelligent decisions regarding the invocation of services based on whether or not they'll actually provide value in terms of enhanced security, improved performance or higher reliability.

That's where the evolution of application delivery is going: to a world where applications are not just sitting in the passenger seat on the network, they're driving.