[paraphrased from notes]
We should all be optimistic about open source and serverless technologies. Kubernetes, an example of how to evolve your service, a means to an end, housing processes internally, making management easier for developers to deploy and scale horizontally, to update gracefully without causing downtime. One of the themes in the future of cloud-based computing is that is increasingly open source which makes it easier for developers to influence and contribute the software stack as it's evolving. Our focus is switching to managing applications and not machines.
"...the future of cloud-based computing...is increasingly open source which makes it easier for developers to influence and contribute the software stack as it's evolving."
(photo credit: @rockchick322004)
Serverless means caring about the code, embedded in all cloud platforms. In App Engine, you run code snippets and only get charged for your app or service as it scales up or down. With container engine, you run containers but don't specify the machine it runs on. In the future, we're not going to be thinking or talking about VMs. What does it mean for us developers? It will enable us to compose and create our software dynamically. As one of the most creative and competitive markets, software puts us in the same room and presents us with the same challenge: how to make things better, faster.
Melody tells a story about a project she was working on where they were using a new piece of hardware. They were having trouble scaling during peak load, holiday traffic being really important to their particular customer. They were constantly scrambling and for the first 6-9 months, she spent her time on primarily DevOps related work. This was frustrating because she wanted to work on features, seeing the potential of what she could do, and she could never quite get to that.
As developers, we are constantly raising the bar on the tools we use to release, and correspondingly our users' expectations increase. Also as developers, we have the ability to create magic for users, predicting what they want, putting things in context, and launching the next great engaging thing. In a serverless future, developers will be focused on code, which means that PaaS (platform as a service) will have to evolve to integrate the components it's not doing today. To do that, developers will need to shift Ops work from themselves more to cloud providers, being able to pick and choose different providers. Developers come to a platform with a specific language that they're productive in, so this is a place where PaaS providers will have to support a variety of runtimes and interpreters. App Engine is the hint and glimmer of creating an entirely new developer experience.
"In a serverless future, developers will be focused on code...will need to shift Ops work from themselves more to cloud providers."
What does a serverless future mean for the developer experience?
We will spend more of our time coding and have more and more choice. Right now, we're in a world where we still have to deal with hardware, but as that changes, we'll spend more of our time building value in our products and services and leave the infrastructure costs to providers and the business. If we want to do that, developers need to make it very easy to integrate with machine learning frameworks and provide analytics. Again, to do this, we need to free up our time: hence NoOps. If we're spending all out time on ops, we're not going to get to a world where we can customize and tailor our applications for users in the ways they want and expect. This is why NoOps is going to continue to go mainstream.
If we're spending all out time on ops, we're not going to get to a world where we can customize and tailor our applications for users in the ways they want and expect.
Think about if you're a startup. If you're writing code snippets, you may not need to think about storage. You don't need to worry about security because the cloud providers will take care of that for you. Some wifi and laptops, and that's your infrastructure. You'll have machine-oriented frameworks to allow that app to be really amazing. This idea that you can go from prototype to production-ready to then scale it to the whole planet. Examples of really disruptive technology because they were enabled to do so by cloud resources.
To get there, we're going to have to automate away the configuration and management and the overhead. We still have to do this automation. We have work to do there.
Multi-cloud in NoOps is a reality.
People are using mixed and multiple levels of on-prem IT and hybrid cloud; the problem is that the operational tools are siloed in this model though. This makes it very hard to operate these services. As developers, we should expect unifying management...and we should get it. Kubernetes is an example, just another way for teams to deploy faster. Interestingly, we're seeing enterprises use Docker and Kubernetes on-prem; the effect of this is that it will make their apps and services cloud-ready. When they are faced with having to migrate to the cloud, it will be easy to do it.
"...we're seeing enterprises use Docker and Kubernetes on-prem...it will make their apps and services cloud-ready"
Once you're deployed like this though across multiple clouds and service providers, you'll need to have an easy way to collect logs and perform analysis; StackDriver is an example of this. It's this single-pane-of-glass view that enables developers to find and fix issues fast, to see what's happening with workloads, and to monitor more effectively. Debugging and diagnosing isn't going to go away, but with better services like Spinnaker and App Engine, we'll be able to manage it more effectively.
Spinnaker providers continuous delivery functionality, tractability throughout our deployment process, it's open source. As a collaboration with Netflix, Melody's team worked hard on this. It was a case of being more open about the software stack we're using and multiple companies coming together. We don't all need to go build our own thing, especially when we share so many common problems.
Debugging and diagnosis
The problem is that there's all this information across all these sources and it's hard to make sense of it. It's usually in a time-critical situation and we have to push out a quick fix as soon as we can. Part of streamlining that developer and debugging experience in the future cloud is having the tools at our disposal. These are things like being able to trace through a complex application for a performance issue, going back through the last 3 releases and see where the slow-down started, or production debuggers where you can inspect your service that's running in the cloud and go to any point in the code to look through variable and see what's happening. Error reporting as well needs to be easier, as errors can be spread across multiple logs, it's hard to see the impact of the errors you're seeing. Errors aren't going away, so we need to be able to handle them effectively. We want to reduce the effort it takes to resolve these errors, we want to speed up the iteration cycles for finding and fixing the errors, and provide better system transparency.
"The faster we can bring the insight from these motions back in to our source code and hence optimize, those are all benefits that we are passing through to users, making us all happier."
In the NoOps, serverless future, not everything will be open source, but we will expect that 3rd party providers should work well with all the cloud platforms. Meledy's team is currently working on an open source version of their build system called Basil. Right after their work on Spinnaker in collaboration with Netflix, they're looking for other opportunities to work with others on open source tools.
What does the world look like 5-10 years from now?
We're not talking about VMs anymore. We're benefiting from accelerated hardware development. We're seeing integration of data into apps and compute so that we can have better insight into how to make applications better. It's easier for machine learning to be embedded in apps so that developers can create that magical software that users expect. We don't have to talk about DevOps anymore. We will have more time to innovate. In an open cloud, you have more opportunity to influence and contribute to how things evolve. Like thinking back on how there used to be pay phones and there aren't anymore, the future of development is wide open, no one knows what it will look like. But contributions towards the future cloud are a big part of that future and everyone's invited.