Click to learn more about author Ariff Kassam.

Many companies are considering migrating their legacy applications to cloud-computing models and implementing microservices as part of that migration. These organizations are looking to take advantage of many of the benefits microservices offer, such as lower IT infrastructure costs, and the ability to deliver application changes faster using continuous integration and continuous delivery (CI/CD) pipelines. For those unfamiliar with microservices, they may be wondering how microservices offer all of these benefits.

What Are Microservices?

Microservices, or microservices architecture, is an architectural style of building applications that structures the application as a collection of smaller, independent services. Microservices have the following characteristics:

• Can be maintained and tested independently
• Are loosely coupled via well-defined APIs
• Can be developed on independent technology stacks from other services
• Can be deployed independently
• Organized based on business capabilities
• Owned by smaller teams
  

These characteristics increase developer agility, because they allow applications to be broken into smaller, more manageable components with clear interfaces. The smaller components mean that changes to a microservice need less coordination between components, and therefore require less testing before they can be pushed live. The reduced coordination and testing enables developers to be more agile as they deliver more scalable, available applications.

Are Microservices for You?

Sounds perfect, right? Still, microservices aren’t the right choice for every organization or application. For one thing, microservices require significant investment into new development and delivery skills, a mature DevOps environment, and a high degree of standardization and automation using technology such as containers and Kubernetes for container orchestration. Many organizations don’t yet have an environment well suited to microservices adoption. If you’re not sure what you need, there are a few important agile and DevOps competencies your application delivery teams should have in place if you’re looking to make the transition to microservices:

• Make sure that security is embedded in your DevOps processes
• Use continuous integration and continuous delivery tools in your software development and delivery process
• Automate your core infrastructure and release processes

Data Requirements

It’s also important to understand your application data requirements as you consider moving to a distributed deployment. For example, in scale out architectures there are multiple instances of the container. For stateful containers, clients must be able to connect to any instance of the container and receive a consistent view of the data. Different scale out databases have different consistency models. When you move to microservices and distributed deployment models, your application developers need to understand the consistency model supported by the database they are using and how that will work with the application you want to deploy.

Get Started with Microservices

First and foremost is to build competencies for DevOps and CI/CD pipelines. Start with a new stateless microservice to build the fundamental building blocks for microservice architectures. Ensure your organization can make development changes, build, and deploy a stateless microservices application into production in an automated fashion.

Once your organization has the fundamentals taken care of, you can look at existing stateful applications and evaluate which are candidates for microservices. One option is to start by taking one of your existing monolithic applications and add new functionality quickly by building your new features as microservices. That gets you started without having to undertake a significant long-term project. Your next step might be to build an entirely new stateful application using microservice architecture, or you may want to break down an older application into logical components. When you do that, make sure each component piece fits well as a single microservice, and then rebuild the application using those components. That approach will help you minimize code changes going forward while taking advantage of running those smaller autonomous application components. The individual components will be far easier to deploy and manage separately than deploying and managing large, complex applications.

Benefits for Your Organization

Microservices deployed in containers allow you to re-provision any container individually, or replace, deprecate, or easily add new microservices as needed for a new feature release, a vulnerability patch, a bug fix, or to roll out any other change. They’re also simple to scale independently and responsively, so you can scale out based on demand for a particular service — without scaling the entire application. This makes your development process more productive, agile, and cost effective. Equally important, you’ll be able to respond more quickly to customer demands and deploy continuously available applications in the cloud. Regardless of how or why you get started, it’s time to think about how and where microservices architectures fit into your application development plans.