Why Docker is Not Enough for Enterprise IT
Discover why Docker alone isn't enough for the enterprise, despite the growing reliance on its usage.
Join the DZone community and get the full member experience.Join For Free
I want to start by saying that, at ActiveState, we absolutely love Docker. We think it's phenomenal technology that is really becoming the global currency of the cloud. We've written about Docker a lot on the ActiveState blog--we've celebrated its birthday, discussed evolving technologies surrounding it, and shown how we've integrated Docker into Stackato. But, I wanted to share with you why we feel Docker alone is not enough for the enterprise.
Two Major Issues Faced by Enterprise IT
First, I'm going to discuss two underlying problems that plague most enterprises today:
1) Shipping Code is Hard
Shipping code can be really hard. The reason? There's no simple way to package your application code, complete with your system dependencies. You are dealing with code across different operating systems, different hypervisors or different infrastructures-as-a-service. That is a real challenge in shipping software.
2) Devs and Ops Don't Always Play Well Together
Another common issue that enterprises must deal with is the challenge of handing off code from developers to operations teams. There isn't necessarily a harmonious relationship that exists between these two constituents. And often there's a lot of tension.
It Starts With Docker
Docker has been very appealing to people because it seems to solve these problems. The first problem appears to be fixed because you're able to package up everything related to your app into a single application process.
The second problem seems to be solved because there is a clean separation between IT ops and developers. Developers worry about what goes inside the Docker container and IT ops worries about what goes on outside the container. This makes it more convenient--the developer can provide the container (and whatever is inside) to IT ops and then they can run with it. Now, it's a very portable solution.
However, Docker only partially solves these problems.
What is Docker Missing?
We're all familiar with Lego bricks. They're a very powerful creative toy for children and even some adults. Think of a Docker container as Lego, with each individual brick representing a Docker container. Now the beauty of Lego is that you can assemble the bricks and build all sorts of amazing things. Same thing applies to Docker containers. However, with Docker, issues such as orchestration, monitoring, logging, and scaling become a concern for enterprises. A Docker container is fine for a start-up or a small company if it's only running a handful of containers, but what if you're running hundreds or thousands of Docker containers? These are just some of the issues that need to be considered which are above and beyond what the Docker container itself can provide, and why Docker wouldn't be enough.
So let's go through some specific areas in which containers, by themselves, fall short:
Loading the Container
The first problem is loading the container. How does a developer get its application into the container? And there's also the burden of building Docker images for the developer. The developer needs to be focused on the code, not on the various system dependencies. The solution for this is something we call Buildpacks. Buildpacks were revolutionized by a company named Heroku, which is one of the first companies in the Platform-as-a-Service (PaaS) space. We at ActiveState adopted Cloud Foundry v1 and then incorporated buildpacks. Cloud Foundry then also adopted Buildpacks in version 2 of the project. Buildpacks are the best and most portable option for PaaS, and the majority of the PaaS ecosystem is standardizing on them. They allow you to build up your stack, including all the system dependencies inside the container, as well as configure your application’s environment. Developers just need to supply and think about their application code. They don't have to worry about anything else. Buildpacks configure your application.
Shipping the Container
What happens when all of a sudden developers throw a whole bunch of Docker containers at IT ops and say, "Ship these. Deploy these to production." How does IT ops ship these containers in a systematic way to manage performance, manage security, and manage compliance? They have all these Lego bricks. How do they manage these Lego bricks? So how do you ship the container? The answer to that is something called Docker Schedulers. There are a number of schedulers in the marketplace today: Google Kubernetes, Apache Mesos; Cloud Foundry Diego; CoreOS and then there's Stackato, our enterprise private Cloud Foundry solution that allows you to schedule your Docker containers. The scheduler orchestrates and runs the containers for you, and distributes them across your cluster, whatever your Cloud cluster is. It's resilient, so if a container or machine or application goes down it redistributes those containers elsewhere. From the end user’s perspective there's no downtime. While these schedulers are helpful in solving part of the shipping problem, there are still another important issue that enterprises face that a scheduler can't solve.
Bridging the Divide with Developer Self-Service
There's another key aspect, and this is more cultural, that exists within enterprises. That is this divide that exists between developers and IT ops. Right now there is some classic tension that exists between these two organizations. In some respects you can say there is a wall between them. Often what happens is a developer will build an application and then throw it over the wall to IT ops. Most of the time they end up with an application that doesn't work. As a result, deploying an application to production in an enterprise takes literally weeks or months to do. It's not uncommon to hear how frustrating and how long it takes for developers to deploy applications in production.
Some of this cultural divide exists with infrastructure. Because the enterprise is still using an outdated ticketing system to get access to virtual machines, access to compute cycles can take weeks when it should be literally minutes.
In order to break down this wall, there needs to be a way in which developers can do it themselves. We need tools that empower developers. They need to be able to self-serve in a way that works for the enterprise. Give the developer freedom to deploy on his own, but also address security and compliance needs of the enterprise as well as managing multi-tenancy. The developer only thinks about his or her single app, but the enterprise needs to think about all of the apps that are being submitted by various developers. How do you deal with this? How do you break down this wall that exists between developers and IT ops? The answer is PaaS. With PaaS you have a platform that sits between your applications and your infrastructure. This platform is the same one that goes from development to QA to staging and to production, giving a seamless application delivery experience. The developer who is building an application is doing it in such a way when it's ready, they pass it to QA and it works. They're no longer throwing it over the wall--they know it's going to work because everybody is using the same platform.
There are a lot of people collaborating around Docker and we, at ActiveState, fundamentally believe that Docker is the future. When we were building Stackato v3.0 we said we needed to have Docker in it, and we have recently expanded the functionality so users can deploy their Docker apps to Stackato. But there are limitations for the enterprise because it needs a solution above and beyond containers. With more than 70% of people saying they are actively evaluating or using Docker, it's important to weigh all the issues and understand how Docker will meet the needs of the enterprise as a whole.
Published at DZone with permission of Bart Copeland, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.