Explore responsible microservices development in this conference talk. Learn about forming effective teams, managing complexity, and evolving systems at different speeds. Discover techniques like software archaeology, the Strangler Application pattern, and data-driven approaches to gradually replace legacy systems. Examine the benefits of microservices, including faster onboarding, improved testing strategies, and more efficient resource allocation. Delve into deployment strategies, monitoring best practices, and the importance of chaos engineering. Understand the advantages of specialized teams and the need for standardization to balance flexibility with maintainability. Gain insights on avoiding pitfalls and making informed decisions when implementing microservices architecture.
Overview
Syllabus
Intro
Forming two pizza teams.
We have to consider the cost of the added complexity.
If parts of your system evolve at different speeds...
Maybe the Inventory system is really stable.
But our product owners constantly tweak the Recommendation Engine.
Start with your source code management tool...
Software archeology time!
Look for (apologies Isaac Newton) smoother pebbles and prettier shells.
Chad Fowler created Turbulence based on churn vs. complexity.
Who is working on what?
Last commit around the Super Blue Blood Moon Eclipse?
Strangler Application.
Gradually replace the heritage bits.
Reduces the risk of a big bang cutover.
We can go a step further and apply a data driven approach.
Put a proxy layer between the client and the legacy system.
Drives test cases for the new functionality.
You can run the new in parallel with the old.
Route requests to both modules - compare the results.
Don't be surprised if the old system is wrong!
Run experiments. A/B testing.
Speed matters.
Monoliths often have dictionary sized getting started guides.
It can take months for a new developer to get up to speed.
What was your longest stretch to get to productive team member?
Goodbye 80 hour manual regression suites.
Forget the one-off performance test.
Use the right tools for the job!
Shared life cycles put us at the mercy of the longest tent pole.
Each microservice can use the mix of tests that make sense.
Use the appropriate linting rules and code quality scans.
Simplifies the search for fitness functions.
We can practice hypothesis drive development
How do you know?
Focus on "paved roads."
Deploy early, deploy often.
Need to develop trust in the process.
Spring Cloud Pipelines.
Opinionated build/ test/stage/prod flow.
For example - how much capacity will you need?
It was in our best interest to over allocate resources.
Gave us single digit resource utilization.
Annual budgets make it difficult to add capacity smoothly.
Cloud environments and microservices flip the script.
Odds are the order processing system has a unique scaling needs.
Monitoring to the rescue!
Site Reliability Engineering
Four Golden Signals.
Spring Boot Actuator!
Often use bailing twine and duct tape...
Look for failure points.
When month end falls on the Super Blue Blood Moon.
It is hard. We are really good at thinking through the happy path.
What systems does our service talk to? How do they integrate?
The circuit breaker pattern.
Redirects to the fallback mechanism.
Chaos engineering.
Teams develop deep expertise.
People can shift teams to cross pollinate and balance workloads.
Simplifies the hiring and training processes.
Ops can focus on the primary environment.
We aren't forced down the square peg round hole path.
It's great right? Each team can use just the right tool for the job!
Teams will have their pipeline preferences, meaningful metrics...
Pick from these 3 flavors. Won't work for you? Let's talk.
With great power comes great responsibility.
Avoid the temptation of resume driven design.
Taught by
Devoxx
