Devops for Growth

La première partie de cette série d'articles évoque l'évolution de l'architecture et les patterns stratégiques d'architecture pour les tendances technologiques comme les microservices, le serverless et la conteneurisation. Les architectures s'appuyant sur des principes comme le couplage faible, l'extensibilité, et la programmation par interfaces seront plus résilients lors de changements majeurs de plateforme technologique. Les solutions bien conçues résistent au temps en isolant la logique métier des composants technologiques, ceux-ci devenant obsolètes tôt ou tard.

La seconde partie décrit le temps nécessaire à la stabilisation de l'architecture et certains anti-patterns comme le monolithe distribué et l'architecture "Etoile de la Mort". Il démontre le besoin d'équilibrer l'architecture et la stabilité technologique.

Cette troisième partie étudie l'importance des interactions entre les services dans une architecture microservices, les difficultés récurrentes des systèmes distribués, et comment des patterns d'architecture modernes comme l’orchestration de services et le Service Mesh peuvent y répondre.

This article describes a vendor/technology-neutral reference architecture for a cloud native digital enterprise that can be mapped into different cloud-native platforms (Kubernetes and service mesh), cloud providers (Microsoft Azure, Amazon AWS, and Google GCP), and infrastructure services.

Key Takeaways

When managing dependencies for distributed microservices, you must consider different types of growth when evolving the product, such as the number of users, user behavior, and the interactions between services and subsystems.
Stateless services are often easier to manage than stateful ones.
Colocate service components for greater performance, easier failure isolation, and SLO alignment.
Having isolated serving stacks may prevent a global outage of your service. This includes the dependencies of your service run by 3rd parties or in the Cloud.
Some architectural strategies may allow your service to have a graceful degradation during an outage instead of immediately returning errors to the user, e.g., having a cache between the API and the database.
When building an SLO, take into account the current SLO of all backends and the different user journeys, including edge cases for bad responses and degraded experiences.
Work with backend owners and allow extra time for resource allocation and architectural changes.

Last year, during QCon Plus, I shared some of the Pitfalls and Patterns in Microservice Dependency Management that I encountered while working at Google for over 10 years. Rather than being focused on any particular product or team, this talk was about sharing my own experiences and personal learnings as a software engineer at Google.

With that in mind, I presented. Each of these scenarios had key moments of epiphany, where I realized the importance of various aspects within the microservices environment.

Katharina Probst discusses some of the best practices to build, evolve, and operate microservices, learnings from containers, service meshes, DevOps, Chaos & load testing, and planning for growth.

What will make microservices the winning paradigm, where its predecessors clearly were not? What makes it tick? As a developer, there’s no doubt that I am rather enthusiastic about microservices, but I was enthusiastic as well (more or less) when people came up with CBD and SOA.

I do suppose there are differences. For the first time we seem to have the technology in place to build these type of architectures. All the fancy and complex middleware is gone, and we rely solely on very basic and long-time existing web protocols and technologies. Just compare REST to CORBA. Also we seem to understand deployment much better, due to the fact that we’ve learned how to do continuous integration, unit testing, and even continuous delivery. These differences suggest that we can get it to work this time around.

Still, from my historical viewpoint some skepticism is unavoidable. Ten years ago, we also really believed that service oriented architecture would be technologically possible, it would solve all our issues, and we would be able to build stuff faster, reusable and more reliable. So, to be honest, the fact that we believe that the technology is ready, is not much of an argument. Meanwhile the world also got more complex.

Over the last year I’ve been involved with a company that is moving away from their mainframe (too expensive) and a number of older Java monoliths (too big, and hard to maintain). Also time-to-market plays an important role. IT need to support introducing a new product in months, if not in weeks. So we decided to be hip and go microservices. Here’s my recap of the good, the bad and the ugly of microservice architectures, looking back on our first year on the road.

For innovative software organizations, managing the overall cognitive load on their teams is a guiding development and operational principle.

I had my fair share in designing and building large systems. I've taken part in rewriting Uber's distributed payment systems, designing and shipping Skype on Xbox One and open-sourcing RIBs, Uber's mobile architecture framework. All of these systems had thorough designs, going through multiple iterations and had lots of whiteboarding and discussion. The designs then boiled down to a design document that was circulated for more feedback before we started building.

All of these systems were large at scale: hundreds of developers build them - or on top of them - and they power systems used by millions of people per day. They were also not just greenfield projects. The payments system rewrite had to replace two, existing payments systems, used by tens of systems and dozens of teams, all without having any business impact. Rewriting the Uber app was a project that a few hundred engineers worked simultaneously on, porting existing functionality to a new architecture.

Let me start with a few things that might sound surprising. First, none of these designs used any of the standard software architecture planning tools. We did not use UML, nor the 4+1 model, nor ADR, nor C4, nor dependency diagrams. We created plenty of diagrams, but none of them followed any strict rules. Just plain old boxes and arrows, similar this one describing information flow or this one outlining class structure and relationships between components. Two diagrams within the same design document often had a different layout and were often added and modified by different engineers.

Second, there were no architects on the teams that owned the design. No IT architects or enterprise architects. True, neither Uber nor Skype/Microsoft have hands-off software architect positions. Engineers at higher levels, like staff engineers, are expected to still regularly code. For all the projects, we did have experienced engineers involved. However, no one person owned the architecture or design. While these experienced developers drove the design process, even the most junior team members were involved, often challenging decisions and offering other alternatives to discuss.

Third, we had practically no references to the common architecture patterns and other jargon referenced in common software architecture literature, such as Martin Fowler's architecture guide. No mentions of microservices, serverless architecture, application boundaries, event-driven architecture, and the lot. Some of these did come up during brainstormings. However, there was no need to reference them in the design documents themselves.

This blog provides various aspects that need to be considered while developing scalable and robust enterprise applications. I will discuss the following areas of enterprise applications development and considerations:

An application should have capabilities to accommodate growth and scale, should be modular to enhance or add new functionalities, and support gradual or abrupt surge. At the same time, it should be seamless for users and efficient for the organizations.
Factors or Characteristics that influence the application scalability and robustness
The different architecture patterns, pros, cons, and considerations: The standard architecture brings many advantages for development and better flexibility of the system for scaling.
How to build scalable enterprise applications: What are the different design methods to consider across various components of the applications?
Different technology, tools, framework, software that can be used while designing enterprise applications: Mostly we will highlight open source technologies as much as possible.
Basic Architectural Design principles to consider for designing large scale applications

In the end, I will provide very high-level architecture considering most of the aspects discussed in this blog. I will provide information in the form of mind maps which I captured for the above areas.

Key Takeaways

Microservices pattern doesn’t refer to the size of the services, decomposing your solution into ‘micro’ pieces is not the goal of the pattern, think of your solution as one whole then look at the requirements to guide you through what pieces to partition out. The article gives you an example of doing that.

These definitions might seem a bit obtuse, so here's how I would define them:

API stands for Application Programming Interface. APIs define how two pieces of software can connect and talk to each other. If your application were a big company, your API's job would be to keep in touch with external parties (customers or company partners, for example). Most APIs are organized around some standard, like REST or GraphQL, so that everybody knows how to use them.

Microservices are pieces of software (often just isolated functions) that do a single, tiny, independent part of a bigger application. If your application were a big company, each employee would be a microservice, each playing their own specific and small role, working alongside but independently from their coworkers. This lets you make changes to individual microservices without affecting the rest of the application. In a big company replacing or retasking one employee in a large team would probably not affect the rest of the company all that much.

It's the evolution of the monolith architecture. Instead of having one block composing the whole application, every component is divided into smaller building blocks.

Put like that, does it make a bit more sense how they're different and how they can work together?

Jessica Tai discusses lessons learned by Airbnb from its migration to microservices, covering cross-team collaboration strategies, designing observability access control, and planning for unified APIs.

A photo-sharing app built by NGINX and implemented using the Fabric Model from the Microservices Reference Architecture. - GitHub - nginxinc/mra-ingenious: A photo-sharing app built by NGINX and implemented using the Fabric Model from the Microservices Reference Architecture.

Chris Richardson, James Lewis, and Katie Gamanji discuss what the industry has learned over the last decade building and delivering Microservices architectures.

Cole Turner shares his experience in implementing new experiences across dozens of Netflix microservices, how they navigate assumptions, from ideation to delivery, and how those assumptions impact decision-making.

Going directly to a microservices architecture is risky, so consider building a monolithic system first. Split to microservices when, and if, you need it.