CloudDevelopersDevOpsFeaturedLet's Talk

Can You Really Tame Cloud Complexity? Yes, Says Rob Hirschfeld

0

Guest: Rob Hirschfeld (LinkedIn, Twitter)
Company: RackN (Twitter)
Show: Let’s Talk

Can complexity, within the cloud-native and container spaces, be tamed? Rob Hirschfeld, co-founder and CEO of RackN, makes it very clear it has to be. On this subject, he starts by saying, “We keep adding more and more things. And when we do that, we’ve added to the complexity budget of our overall system.” Hirschfeld continues, “So when we think about how we build things in cloud-native spaces, we have to look at ways to manage the complexity in a comprehensive way.”

RackN takes the science of managing and taming complexity and builds it into their products and builds infrastructure pipelines that are designed to tame complexity. For Hirschfeld, the key is “managing through that complexity in a repeatable way.”

RackN even has a list of items that serve as a way to tame the complexity of infrastructure. Hirschfeld offers up that list with, “It’s focusing on intents, and using that as your abstraction boundary. It’s keeping tools inside their lane and using things where they excel, and then, finally, avoiding a single source of truth and the challenges that come from having multiple sources of truth.”

Hirschfeld also brings up the concept of coupling. “We always joke about DNS being the root cause of every problem. And that’s because every system is coupled to DNS in some way because it needs to look up names and find other machines.” Because of this, Hirschfeld believes we need to identify places where we have introduced coupling between systems. To that, Hirschfeld adds, “It doesn’t mean that we should eliminate coupling, but it means that we need to identify what’s coupled.” Hirschfeld clarifies by saying, “It means we have to do it very deliberately and be able to track how those systems are interconnected together. So by being deliberate in how we’ve coupled systems together means that we can manage the complexity.”

Another complexity involves intent, to which Hirschfeld says, “What we find is that intent is actually a really good abstraction boundary. You build an API that extracts the actual thing you’re building. But that ends up being incredibly fragile, and it exposes a lot of complexity in how your systems get built. And what we found is that if you can express the goal of what you’re trying to build, then when you build the abstractions, you can actually abstract away those different approaches.”

The summary of the show is written by Jack Wallen

Read Transcript
Don't miss out great stories, subscribe to our newsletter.

Login/Sign up