5 key considerations for developing all-cloud streaming video workflows
Even for the largest and best resourced streaming video companies, realizing the vision of delivering streaming video from an all-cloud workflow using a microservices architecture is still a little way off. But it’s a hot topic that’s firmly on the radar of industry leaders like Jason Thibault, Executive Director of the Streaming Video Alliance.
Before we get into his thoughts on the evolution of streaming technology architectures towards microservices, let’s define a key concept: the edge. Right now, we think of the edge as a specific place, or places, on the network or in the cloud. But the cloud is evolving too. It’s becoming a fabric of resources: compute, memory, storage. And thinking of the cloud as a fabric helps when thinking about streaming workflow components as microservices because, in a serverless world, it’s no longer about instances and containers. It’s just about code deployed within the fabric.
Thibeault shared with us five key considerations for organizations that are starting to think about how to integrate their entire streaming video workflows better into this new cloud fabric. “We’re talking about this now, because this is ultimately the way the industry will go,” he says. “It’s still pretty theoretical, but the wave is forming for converting video stack components into microservices, and it will come soon enough.”
1. Assess the cost/benefit ratio of what you’re thinking of doing
No company can afford to base its strategy on simply pushing everything out closer to the user. “You have to bear in mind that there will always be more compute resources further upstream,” says Thibeault. “Basing every decision on network location doesn’t take into account the benefits of that location. Not every component belongs closer to the end user.”
When you start thinking about transitioning elements of your workflow technology into serverless functions or microservices that will be more deeply integrated into the cloud fabric, you have to weigh the anticipated benefit against the cost involved. There’s always going to be a cost associated with migrating an aspect of workflow technology to a microservice or serverless function implementation. So if, say, your goal is to reduce latency, you need to decide where that latency reduction can be achieved, and how much you’re prepared to spend on doing so. Think about it like this: if converting a technology to microservices only gets you 1 millisecond of latency reduction but costs $1m, it might not be worth it.
2. Make sure you can operationalize the technologies you migrate
Supporting instances and containers is far different than functions and microservices. DevOps and OpsEng are only just beginning to understand how to operationalize those. That’s because a critical part of supporting workflow components is being able to monitor the health of the service and check it’s performing as intended. How to do that with existing cloud technologies is very well known. But with microservices or serverless functions, it’s not yet totally understood.
“Having a way to monitor microservices that’s similar to how traditional streaming workflow components are monitored today is what’s going to allow organizations to move their video stack technologies deeper into the cloud fabric,” says Thibeault. “You also have to understand the role each element plays in the end-to-end workflow. Unless you can confidently operationalize these technologies, you risk doing a disservice to your business.”
3. Think about how you’ll implement in the cloud fabric
Developers are working hard to figure out the best way to implement microservices and serverless functions in the cloud fabric. They may be used to solving containerization challenges, but microservices and serverless functions are quite different development paradigms.
For example, a must-have for your serverless functions is self-healing capability. With containers, if something goes wrong, you just re-instantiate it—but that’s not possible with a serverless function that’s stopped operating correctly, as it’s just a bit of code out there in the cloud. “You need to find a way to incorporate error correction into the serverless function itself so that it can self-heal,” says Thibeault.
He points out, however, that the cloud itself isn’t yet self-healing either; if a part of the cloud goes down for any reason, everyone in that part will be affected. And that’s complicated by companies that use a multi-cloud strategy and see their infrastructure as one giant cloud. Until the cloud can self-heal, you can’t afford, for example, to have both your primary and your backup virtualized encoders in the same cloud.
“That’s why, to be on the safe side, streaming providers today still often retain physical equipment as yet another layer of backup,” says Thibeault. “So first we have to ask: how do we get the cloud to self-heal? Then we can start thinking about developing serverless functions that can self-heal.”
4. Choose carefully which functions to transform
When you start thinking about transforming video stack technologies into microservices and serverless functions to deploy into the cloud fabric, you have to get away from looking at it in terms of entire components. That’s the old way of thinking: virtualize an application within an instance or a container. An encoding component comprising 37 functions, for example, will be too large to convert into a single microservice.
Instead, you’ll need to take an inventory of the functions in an individual component to work out where to start. Thibeault describes the process as “chiseling apart” that encoding component into its 37 constituent functions, and deciding which of them could work as microservices or serverless functions.
“Microservices, though, are just one aspect of a more fundamental shift to an organic view of programming,” he says. “Think about infrastructure-as-code and network function virtualization (NFV). We’re moving to a much more fluid view of compute resources and fixed infrastructure.”
5. You can’t do anything without thinking about security
Once large numbers of microservices and serverless functions are out in the cloud, they’ll be floating around what amounts to a gigantic multi-tenant environment, so securing them will be a top priority. Although specific solutions aren’t available as yet, Thibeault conjures up the concept of transforming the web application firewall (WAF) itself into microservices, and loosely coupling each WAF microservice to your workflow component microservices.
“You’d then be able to protect those workflow microservices without encumbering them with the bloat of a single point of WAF software that everything has to go through,” he says. “Each microservice or serverless function you add effectively becomes an element in your workflow DNA within the organic programming model I mentioned earlier.”
Steps you can take now to start preparing for this future model
Whether you’re considering microservices or have already begun experimenting to prepare for the eventual transformation of your streaming video stack, you can take steps now to ensure you are prepared for the future state we’ve described:
- Deploy in multi-cloud. If you haven’t already, expand your cloud infrastructure to involve multiple providers. Being able to effectively and efficiently support resources deployed across multiple clouds is the precursor to treating your streaming infrastructure as a cloud fabric.
- Implement a monitoring harness. You’ll need a stable, flexible framework to handle plugging in microservices as individual components to an end-to-end monitoring solution. It’s not going to be operationally efficient to constantly retool your monitoring solution.
- Define security rules now. Don’t wait until you already have a legion of microservices out in the fabric. Create a security framework to define the rules by which microservices are accessed by, and can access, network resources.
- Test, test, and test some more. There’s no reason you shouldn’t be testing microservices now. Set up a sandbox in a cloud. Implement the monitoring harness. Test the security. All the work you do early on will lay the foundation for when it becomes more feasible to transform video stack technologies into serverless functions.
Thibeault sees a lot of potential for the future in the way we think about complex connected systems like streaming workflows and how they operate within cloud infrastructure. And although streaming providers aren’t yet ready to rely on microservices and serverless functions as part of their commercial platform workflows, he’s clear that the thinking has started, and that it will become a reality at some point. “There’s a lot still to be done, but I truly believe we’re on the cusp of starting to envisage a broadcast-like structure using microservices and serverless technologies.”
To learn more about Lumen’s edge application delivery offerings, check out our white paper or reach out to firstname.lastname@example.org.
This content is provided for informational purposes only and may require additional research and substantiation by the end user. In addition, the information is provided “as is” without any warranty or condition of any kind, either express or implied. Use of this information is at the end user’s own risk. Lumen does not warrant that the information will meet the end user’s requirements or that the implementation or usage of this information will result in the desired outcome of the end user. All third-party company and product or service names referenced in this article are for identification purposes only and do not imply endorsement or affiliation with Lumen. This document represents Lumen’s products and offerings as of the date of issue. Services not available everywhere. Business customers only. Lumen may change or cancel products and services or substitute similar products and services at its sole discretion without notice. ©2021 Lumen Technologies. All Rights Reserved.