What is the monolithic approach?
Most software systems have traditionally been built as a single monolithic application. Components and functionality are tightly coupled, as opposed to the looser coupling of elements in microservices or service-oriented architecture. Disadvantages of sticking with that approach include:
- Difficulty in making improvements and changes to an ever-growing code base — refactoring the code base is challenging because each change can impact the entire application
- More complexity in testing and deploying changes, as the entire monolithic application is affected
- Increased risk — if one component fails, the whole application goes down
Microservices offer greater flexibility than a traditional monolithic system. There is no single path for developing microservices, but there are general guidelines for managing data within microservice architectures. The complexity of data management that drives a development team to consider microservices can come from many sources including:
- Working with large teams
- Supporting many user interaction models
- Allowing different business functions to evolve independently
- Offering many different web services
But the biggest difference is sheer size — people often find that they have a monolith that's too big to modify, deploy and scale.
SOA is better suited for large and complex business application environments that require integration with many heterogeneous applications. Microservices, on the other hand, are better suited for smaller and well-partitioned, web-based systems, giving much greater control to developers. Separating applications into smaller parts is not a new idea — service-oriented architecture (SOA) preceded microservices.
According to the SOA manifesto:
- Business value is prioritized over technical strategy.
- Strategic goals are more important than project-specific benefits.
- Intrinsic interoperability is more important than custom integration.
- Shared services are more important than specific-purpose implementations.
- Flexibility over optimization.
- Evolutionary refinement over pursuit of initial perfection.
Microservices are a part of a larger shift in IT departments toward a DevOps culture, in which development and operations teams work closely together to support an application over its lifecycle. A company should consider implementing microservices if an SOA culture already exists.
A service-oriented architecture is essentially a collection of services that communicate with each other. The communication can involve either simple data passing or it could involve two or more services coordinating some activity.
Service-oriented architecture represents an effective strategy for agile and fast-moving development cycles. A primary advantage of microservices is the ability for developers to deploy a continuous delivery cycle. Before adopting microservices, an organization must first evaluate the technology already in place. It’s not a question of which architecture performs better. Instead, it’s important to evaluate the purpose of the application you are building.
What is the difference between microservices and containers?
A container is a method of packaging, deploying and running a Linux program/process. You could have one giant monolithic application as a container and you could also have an app built with microservices that does not use containers at all.
A container is a useful resource allocation and is something DevOps people get excited about. A microservice is a software design pattern and is something developers get excited about. Containers and microservices are both useful but not dependent on each other.
What are some challenges when switching to microservices?
Two key challenges of a microservices approach are the individual work styles of independent teams, and never feeling that you’re “finished.” To the first point, while microservices offer the opportunity for better productivity and tool selection, teams will often prefer different coding languages, frameworks and libraries. This can stall the team if they’re not ready for such independence.
Secondly, the appeal of monolithic architectures is that changes become a big project that have clear starting and finishing points. With microservices, change is always in the works. Constant change is not a “bug,” but a feature of a viable, evolving system, and teams not used to this kind of flow may have to make an effort to adapt.
A third challenge is the complexity of microservices, which requires a strategic approach to monitoring.
Why switch to microservices?
A primary reason to switch to microservices is to better focus on business priorities due to the increased speed of innovation. The rise of DevOps, similarly focused on speed and outcomes, has also fueled interest in microservices.
Many companies have evolved from a monolith architecture to a microservices structure, including Amazon, Spotify, Uber, Groupon and Karma. Using microservices, developers at Netflix deploy thousands of code sections every day to support more than 139 million subscribers and 10 billion hours of movies and TV series.
What are the advantages of microservices?
Advantages of microservices include faster software development and deployment, which saves money and can give the organization a competitive edge. Microservice architecture is a perfect choice for developers unable to predict the kinds of devices on which the app is going to run. Developers can provide fast and controlled upgrades without slowing or stopping the app. Further advantages include:
- Stability. Functional decomposition means that each component of the application can scale up or down independently of others. Thus, faults can be isolated, and a single failing component shouldn’t bring down the entire application.
- No vendor or technology lock-in. You can potentially select a different technology stack for different microservices.
- Easier to build and maintain. Their single-purpose design means components can be built and maintained by smaller teams. Each team can be cross-functional. Each microservice can be deployed independently.
- Higher-quality code. Modularising an overall solution into discrete components helps application development teams focus on one small part at a time. This simplifies the overall coding and testing process.
- Easier cross-team coordination. Unlike traditional service-oriented architectures (SOAs), which typically involve heavyweight inter-process communications protocols, microservices use event-streaming technologies to enable easier integration.
- Real-time processing. At the core of a microservices architecture is a publish-subscribe framework, enabling data processing in real time to deliver immediate output and insights.
- Fast project development. Microservices work independently, so you don’t have to change the codebase to modify the features. You can change one component, test, then deploy it individually. In turn, you will deliver the app faster.
- They enable scale. Scalability is more than just about the ability to handle more volume. It’s also about the effort involved. Microservices make it easier to identify scaling bottlenecks and resolve them at a per-microservice level.
What is microservices monitoring/How do you monitor microservices?
Monitoring is a vital component of a microservices architecture. While breaking applications into component microservices offers many benefits, it also creates complexity. Microservices need to communicate with one another, and each individually created and updated component must work with other components, with a minimum of latency. So when managing an application composed of microservices, you're managing a network of interrelated components. Effective management of that network is essential to overall reliability.
Monitoring and observability are easier for developers who already have a DevOps/Agile mindset. As with those approaches, microservices rely on automation and collaboration across all facets of the software development lifecycle (SDLC). Config management, CI/CD servers, APM, network monitoring, dashboards, alert automation and incident management are basics for teams running microservices.
Two essential components of microservices monitoring are basic monitoring and rapid application deployment.
- Basic monitoring: It's essential to be able to quickly detect problems that were not caught in the testing phase. The baseline here is detecting technical issues (counting errors, service availability, etc.) but it's also worth monitoring business issues (such as detecting a drop in orders). If a sudden problem appears, you can quickly roll back independent services and operating systems.
- Rapid application deployment: With so many services that need managing, administrators need to be able to quickly deploy them — both in test environments and in production — and generally in no more than a couple of hours. Some manual intervention is all right in the early stages, but you'll be looking to fully automate it soon.
These capabilities imply an important organizational shift — close collaboration between developers and operations — seen in DevOps Culture. This collaboration is needed to ensure that provisioning and deployment can be done rapidly. It's also important to ensure you can react quickly when your monitoring indicates a problem.
With distributed systems, different teams can work toward a culture of observability — including better orchestration, load balancing and fault isolation.
Of course, monitoring is the forward-positioned response to maintaining a microservices architecture. When an anomaly is detected, you also need to respond. It's important to have an alerting process and incident response plan that lets you respond promptly and effectively.