The Logical Progression of DevOps and IaaS

Datetime:2016-08-23 04:03:09          Topic: IaaS  DevOps           Share

It all started with the mainframe. This big box that probably costs more than your house is hardware, OS, database, development environment and execution environment all in one. The distinction between dev and ops here is clear: keeping that box powered up, connected and monitored is ops, while the code inside is dev. Not only is the distinction clear, but the scope of what a mainframe is and what is does is largely static. Ops will be monitoring the same core set of mainframe services today that they were looking at 5 years ago, while devs will still be coding in the same language against the same set of libraries.

From the mainframe we moved into LAMP (Linux, Apache, MySQL and PHP) stacks, or some derivation thereof. The tiers remain much the same: OS, database, application code and some kind of execution environment. But now we are starting to see different tiers spread out across multiple servers.

Even with a LAMP stack, there are some pretty clear boundaries between dev and ops. The OS, the database and the web server are going to be configured and monitored by ops, while devs still focus largely on application code and data.

The rise of the web and mobile starts to muddy the water here though. On top of the neat topology of OS, database, webserver, and application code, we start adding things like: NoSQL, single sign on, message queues, machine learning, multiple programming languages to target browsers, mobile devices and backend services, analytics, CDNs, etc. Even here though there is still a clear delineation between dev and ops. Ops are still responsible for provisioning services, and devs glue them all together into an end product. There are a lot more services now, and a lot more interaction is required between devs and ops to make everything work. But once the stack has been designed and implemented, dev and ops still mostly work in their own silos.

Today we have IaaS and PaaS. This is where the traditional roles of devs and ops start to break down. The solutions being created are consuming as many services as ever, and the kinds of services haven’t changed. What has changed is that services like SQL, NoSQL, message queues, and SSO can now be provisioned and incorporated into an application as if they were just uber-libraries.

Take Amazon SQS as an example. Before the rise of IaaS, deploying a message queue was quite a lot of work. Servers has to be provisioned, networks had to be configured, operating systems had to be installed, messaging middleware had to be configured, and the whole lot needed custom monitoring. This is probably months worth of work.

These days a production ready queue can be created programmatically with any number of infrastructure orchestration tools. Just as a developer would pull in a library to interact with a message queue, they can now define the queue itself in code.

We are fast reaching a point where complex pieces of infrastructure are exposed behind the same kind of interfaces that are used to abstract complex pieces of code. The process is not that seamless yet, but it is only a small step from running a Chef script to create a SQS queue to creating that infrastructure directly inside an application.

Today devs do this:

if (!file.exists(“error.log”)) {
        file.create(“error.log”);
}
file.append(“error.log”, “something went wrong”);

Tomorrow they’ll do this:

if (!queue.exists(“error.log”)) {
        queue.create(“error.log”);
}
queue.send(“error.log”, “something went wrong”);

As infrastructure increasingly becomes something that is as easily instantiated as a class, it becomes a little harder to draw a line between dev and ops.

I predict that ops will become increasingly less about the provisioning, configuration, and maintenance of infrastructure, and more about the monitoring, tuning, and securing of IaaS resources. On the other hand, devs will be able to incorporate sophisticated services with the ease of creating a file or building a GUI.

In maybe 5 years and I believe that, to developers at least, IaaS functionality from providers like AWS, Azure, Google Cloud, and Rackspace will be created and consumed as transparently as a file on a local disk. Code and infrastructure will merge into one solution. These services will be so reliable, and prices will have dropped so far, that there will no longer be a distinction between local resources and network services.





About List