There is a lot of focus being put onto container technology at the moment. As Docker continues to move ahead in popularity, and features, we also have the CoreOS team jumping into the mix with their Rocket offering. It is important to note that Rocket is being built to enhance what’s been done by Docker, and also targets different use-cases. In other words, both are very viable, and exciting technologies.
Since everyone is talking containers, perhaps it’s best for us to go a little into the history of why containers were created and then we can get to the core of the importance if what containers do: creating agility to enable better operations and development practices.
LXC – Containers in the Early Stages
LXC is described from the site LinuxContainers.org as follows:
“LXC is a userspace interface for the Linux kernel containment features.
Through a powerful API and simple tools, it lets Linux users easily create
and manage system or application containers.”
The core of what LXC does is that it provides a way to deliver repeatable, contained application environments to run isolated from the host environment. It’s a safe method to run the application so that it does not interfere with the underlying infrastructure, and vice versa. It’s also consistent which is important.
LXC deployments may have more than one iteration because there have been different versions deployed on different Linux distributions. LXC as a project has been solidified and you can run the core code across platforms to ensure that you have a consistent build.
Using LXC, we can package services, applications, and even full Linux distributions. This is very cool because we may be running our LXC instances on different base platforms. By abstracting the infrastructure further up the stack to the container, we have now created some distinct advantages.
LXC is not all puppies and kittens of course. There are some challenges that come along with it including scalability, reliability, and being able to design your application to leverage the container as a platform. This highlights the importance of why DevOps is a practice, not a technology. Containers are effectively the same thing. Containers provide a way in which to do things, but it is up to us as Operations and Development teams to truly take advantage of what they can do.
Operations Advantages of Containers
We led with the statement that this is about creating agility to enable better operations and development practices. How that happens is by creating a simplified deployment method to package and build applications into. Using a container methodology allows us to bridge the gap between the Infrastructure-as-a-Service (IaaS) to the Platform-as-a-Service (PaaS) with an interesting middle ground that meets a different set of requirements.
Containers enable us to build multi-tier applications with separate components, isolated by container, but with the ability to create East-West networking without having to move networking down to the host. The abstraction of the networking into the container infrastructure means that the underlying network infrastructure is no longer a problem during design and deployment. You have the ability to use the same internal networks across platforms within your containers because it won’t matter what the surrounding network looks like. All that matters is that there is an ingress/egress point which is aware of the external network.
This multi-platform capability is where containers will really shine. Running a container-based application means that you can deploy to your IaaS running on-premises, or you may also run it in a public cloud that supports the container infrastructure.
The consistency of the API is also what provides agility for the operations teams. Being able to create orchestration around the container infrastructure will be an important part of getting the most out of containers. Simply using a container as a manual deployment framework as we did with legacy applications and virtual machines will not provide the advantages that containers really open up for us.
Using LXC will be interesting for us, and that’s what we will dive into in our next post. Building a simple LXC environment to illustrate what the steps are will give us a real view of how the Operations team can start dabbling in containers. From there we can see how the Development team will be able to make use of this platform to build applications.
If you’re a fan of Sesame Street, you may even remember this cute little segment. It’s a great depiction of how containers can hold some exciting surprises inside.