O'Reilly logo
live online training icon Live Online training

Comparing service-based architectures

Neal Ford

Microservice architectures are popular, described as "service-oriented architecture (SOA) done correctly." But what does that mean? Many aren't quite sure what the differences are between enterprise service bus (ESB)-flavored service-oriented, service-based, and microservice architectural styles, to say nothing about the middle ground between the "shared everything" approach of SOA and the "shared nothing" approach of microservices. If you've been wondering the same thing, or if you just want a refresher on what makes these approaches distinct, this is the course for you.

Join Neal Ford to explore the similarities and differences between various distributed architectural styles. You'll explore the origins of distributed computing via event-driven architectures and dive into the characteristics of ESB-driven SOA, microservices, and hybrid service-based architectures. Along the way, Neal discusses specific engineering practices, orchestration styles, reuse strategies, and how to migrate between architectural styles (e.g., from monolithic applications to service-based or microservice architectures).

No one architecture can solve every problem, and many projects take on more complexity than necessary by choosing the wrong architectural pattern. This course will equip you with the knowledge and context to choose the architecture that best fits your problems.

What you'll learn-and how you can apply it

By the end of this live, example-led online course, you understand:

  • The difference between service-oriented, service-based, and microservice architectures
  • How to choose the proper architecture for your problem domain
  • How to best achieve code reuse without inadvertent coupling
  • How service meshes achieve operational code reuse in microservices
  • Restructuring and migrating architectures

And you’ll be able to:

  • Migrate from one architectural style to another
  • Identify architecture quanta
  • Choose the correct architecture for your problem domain
  • Identify bounded contexts in microservices architectures

This training course is for you because...

  • You're an architect tasked with choosing an appropriate architecture, but you aren't sure what architectural style is most suitable for your problem.
  • You're an architect who needs to understand the real differences between distributed architecture styles to allow better analysis.
  • You're an architect who needs to migrate from one architecture style to another.
  • You're a developer who needs to understand how to restructure architecture.

Prerequisites

  • A basic understanding of architectural patterns
  • Software development experience, especially in a distributed system

Recommended preparation:

Recommended follow-up:

About your instructor

  • Neal Ford is Director, Software Architect, and Meme Wrangler at ThoughtWorks, a software company and a community of passionate, purpose-led individuals, who thinks disruptively to deliver technology to address the toughest challenges, all while seeking to revolutionize the IT industry and create positive social change. Before joining ThoughtWorks, Neal was the Chief Technology Officer at The DSW Group, Ltd., a nationally recognized training and development firm.

    Neal has a degree in Computer Science from Georgia State University specializing in languages and compilers and a minor in mathematics specializing in statistical analysis. He is an internationally recognized expert on software development and delivery, especially in the intersection of agile engineering techniques and software architecture. Neal authored magazine articles, seven books (and counting), dozens of video presentations, and spoken at hundreds of developers conferences worldwide. His topics include software architecture, continuous delivery, functional programming, cutting edge software innovations, and includes a business-focused book and video in improving technical presentations. His primary consulting focus is the design and construction of large-scale enterprise applications. If you have an insatiable curiosity about Neal, visit his web site at nealford.com.

Schedule

The timeframes are only estimates and may vary according to how the class is progressing

Why distributed computing? (10 minutes)

  • Lecture: The problem; integration hubs; hubs to service buses
  • Hands-on exercise: Reuse via centralizing
  • Q&A

Understanding architectural coupling (20 minutes)

  • Lecture: Afferent/efferent coupling; modules, components, and services; architectural quantum; partitioning—technical and domain
  • Hands-on exercise: Separate domain from technical
  • Q&A

ESB-driven SOA (25 minutes)

  • Lecture: Pattern components; taxonomy—business services, enterprise services, applications services, infrastructure services, and service bus (integration, orchestration, and discovery); operational aspects; code reuse; the good, the bad, and the ugly
  • Hands-on exercise: Determine the suitability of SOA
  • Q&A

Break (10 minutes)

Microservices architecture (25 minutes)

  • Lecture: Pattern components; taxonomy—bounded contexts, orchestration, and APIs; sidecars and service meshes; the good, the bad, and the ugly
  • Hands-on exercise: Determine the suitability of microservices
  • Q&A

Service-based architecture (25 minutes)

  • Lecture: Pattern components; taxonomy—domain services, orchestration, databases, and integration hubs; the good, the bad, and the ugly
  • Hands-on exercise: Determine the suitability of service-based architecture
  • Q&A

Break (10 minutes)

Restructuring architecture (40 minutes)

  • Lecture: Finding architectural seams using quanta; from monolith to microservices; from monolith to service-based architecture; dealing with coupling points—share, split, and duplicate; iterative architecture; evolutionary architecture; fitness functions
  • Hands-on exercise: Find seams; find coupling points; build fitness functions
  • Q&A

Wrap-up and Q&A (15 minutes)

  • Lecture: Domain-architecture isomorphism; choosing the correct architecture; supporting engineering practices