How to use microservices and containers for enterprise continuous delivery
Connected group concept image via Shutterstock
Microservices and containers such as Docker are among the most discussed topics in the world of enterprise software today. Many DevOps practitioners are looking at these technologies as a key part of delivering large software projects faster. While successful implementations are most common among smaller, “born in the cloud” organizations, larger enterprises can benefit from microservices and containers too — as long as they address some challenges head-on.
Let’s start with a review of some of the attributes and benefits of microservices and containers in a DevOps context, then explore some of the enterprise-specific challenges.
Benefits of microservices
Microservices enable enterprises to deliver software as a loose collection of single purpose services, each running in its own process, and communicating via lightweight mechanisms like REST. A microservices architecture brings many benefits to a software development organization.
- Heterogeneous development. Since microservices interact via standard protocols (like HTTP, RPC, etc.), individual microservices can be written in completely different technology stacks. Microservices written in Java, Ruby, or Python can all combine in one application This flexibility enables developers to use the language with which they’re most productive and can help teams across the enterprise solve problems faster.
- Easier maintenance. The code base for each microservice is small, so it makes it easier for developers to read and update.
- Easy-to-upgrade. Each service can be independently deployed, upgraded, or replaced, which enhances the agility of the service, simplifies the work of developers, and speeds time-to-market.
- Independent scaling. Each microservice stands on its own, so each microservice can scale on its own as demand increases. If a particular microservice becomes a bottleneck, horizontal or vertical scaling can be applied to that service alone.
- Faster, effective debugging and fault isolation. Microservices enable developers to hone in on a particular service to find and fix issues very quickly. The independent nature of each service makes it easy for developers to do so without affecting services downstream or upstream.
Benefits of Docker
Docker is an open-source project that allows you to package an application with all of its dependencies — code, runtime, system tools, system libraries – into a container. It gives you the ability to develop, package, distribute, and then run applications in isolation. With consistent environment setups, you should stop hearing the excuse “well, it worked on my machine”.
- Fast and lightweight. Docker containers run as lightweight processes within a host OS, unlike virtual machines that depend on a hypervisor to emulate the x86 architecture. You can often pack many more containers on a host machine than you can a virtual machine.
- Portable and easily duplicated. With containers, you know that the application will always run the same, regardless of the environment it’s running in. And they can be easily duplicated and expanded as demand increases.
- Easy to share. Docker containers can be between developers and operations and provide consistent base images. The Docker Hub is a centralized resource for container image discovery, distribution and change management.
- Consistent. Docker containers provide a standardized environment giving you consistency across release cycles to help avoid configuration drift.
Microservices is an architecture that emphasizes process isolation and Docker containers are a technology for deploying isolated runtimes. So it’s natural that they often go hand in hand. Used together, you get better levels of abstraction. This presents opportunities for “specialization of labor” in your teams, which yields improved quality and agility with lower cost.
The benefits of using Docker containers to deliver software built with a microservices architecture are compelling. But it’s not always a simple option to start using them particularly in an enterprise setting. Among the key considerations are:
- Legacy applications. Changing an existing monolithic application into a microservices based application is essentially a re-write. Instead, consider starting with an existing monolith and add new features as microservices isolated in Docker containers.
- Security. Unlike in a virtual machine, the kernel is shared among all containers and the host in Docker. There is one thin layer of access control that could lead to security problems such as denial of service attacks, kernel exploits, or privilege escalation attacks. Docker continues to improve security capabilities, but it’s something to consider.
- Complexity. Release orchestration can be more challenging with microservices in general. But particularly in an enterprise with large, disparate, geographically dispersed teams in multi-tiered application infrastructure.
- Versioning. Versioning of services is very important in microservices architectures to manage both forward and backward compatibility. Both API versioning and service versioning are more complex to manage.
- Skills shortage. Like most hot technologies, there is a shortage of professionals with strong microservices and Docker skills. Be prepared for challenging recruiting if looking for new hires. Better yet, cultivate skills internally. Docker is very easy for developers to learn and microservices come from a long line of architectural approaches, notably SOA, so you may already have the skills on your team today.
Microservices and containers are leading-edge technologies that can deliver amazing results in greenfield installations and pilot projects. However, they present some challenges in the real-world of large-scale enterprise software, which is dominated by legacy apps and infrastructure. Microservices and containers can prove their mettle if enterprises mesh these technologies with specialized tools for release, deployment and testing.
To hear more, tune into this webinar “Continuous Delivery in the Age of Containers and Microservices” on YouTube.