Presentation: Microservice AntiPatterns

Location:

Duration

Duration: 
4:10pm - 5:00pm

Day of week:

Key Takeaways

  • Hear some common pitfalls and issues when developing microservice architectures.
  • Learn patterns like the Correlation ID to help trace requests through your microservices.
  • Hear concrete, actionable advice on getting started or refining your existing architectures.

Abstract

Everyone's talking about microservices, but few have used them in anger. They haven't given any real thought to best practices around building and deploying them. In this talk, we'll highlight many of the mistakes we've seen people make when building a microservices architecture. We'll discuss:

  • When microservices are appropriate, and where to draw the lines between services.
  • Dealing with performance issues (data affinity, parallelism, monitoring).
  • Testing and debugging techniques.
  • Managing a polyglot landscape and the explosion of platforms.
  • Managing failure and graceful degradation.

Interview

Question: 
What is your role today?
Answer: 
I’ve spent my career moving from operations, to software development, to managing teams, to building product, and basically everything in between. Right now, I’m helping Pivotal build the Cloud Foundry platform.
Question: 
Can you explain your title a bit to me? What is an anti-pattern in a Microservice architecture?
Answer: 
As software engineers, we’re used to identifying AntiPatterns -- common design pitfalls that everyone is tempted to make at some point in their career. However, many engineers are suddenly finding themselves having to develop cloud-based microservice systems, and haven’t had time to gain the experience to recognise what are to them a whole new set of snags and hazards. This presentation walks the audience through the most common ones that we’ve seen in the wild.
Question: 
What are your key takeaways for this talk?
Answer: 
While the presentation goes into some bits of very tactical and actionable advice, the overarching theme is that microservices aren’t a magical solution to your monolithic woes. Microservice architectures are often the best path with a large and complex system, but they bring their own set of taxes and burdens that shouldn’t be taken lightly.
Question: 
Can you describe some of the debugging techniques you’ll go into? ...are these specific to a certain implementation toolkit?
Answer: 
One of my favorite debugging techniques that I describe in the presentation is the use of Correlation IDs. It’s a great example of a toolkit and framework agnostic practice that’s simple to implement and pays off huge dividends. The pattern is straightforward: Every incoming external request is assigned a unique ID, and all internal services copy and forward that ID, and use it in their log output. Following this pattern allows operators and developers to trace a single user-facing request throughout a complex microservice system.
Question: 
What are some of the actionable recommendations/advice that attendees will leave your session with?
Answer: 
One good piece of advice is not to underestimate the operational explosion that happens when shipping and maintaining microservice architectures in production. It’s absolutely essential that a team invest in a platform to abstract away the complexity of deployment, OS updates, HA, scaling, log management and all of the myriad other mechanisms required to keep a system healthy and stable. This is where open source platforms like Cloud Foundry really shine.

Tracks

Covering innovative topics

Monday, 7 March

Tuesday, 8 March

Wednesday, 9 March

Conference for Professional Software Developers