Confirm Download

Simultaneous file downloading works best in FireFox, Chrome, and Safari browsers. Please keep this window open until all downloads are complete. Some customers prefer using file download managers for Chrome or Firefox to better manage large and multiple file downloads.

Cancel Download

Service-Based Architectures

      • Microservices Architecture Pattern Elements

        This segment highlights the characteristics of microservice architectures. It covers the organization of components, the important principles, and some differentiating engineering practices.
      • 00:31:50

      • SOA Architecture Pattern Elements

        This segment highlights the characteristics of microservice architectures. It covers the organization of components, the important principles, and some differentiating engineering practices.
      • 00:23:29

      • Service Based Architecture Microservices Hybrids

        This segment discusses the various hybrid service-based architectures you can build that fall right between the small and simple microservices architecture and the large and complex service-oriented architecture. The variances and hybrids we will be discussing include service granularity, database scope, and the use of an integration hub over a lightweight message broker.
      • 00:13:57

      • Microservices and Service Based Governance

        Governance covers the way services are identified, curated, and managed. Different service styles feature different governance models, which are highlighted in this segment.
      • 00:10:28

      • Coupling and Cohesion

        Software architecture is often the tension between cohesion and coupling. This segment defines a variety of coupling styles, both at the language and component level, and discusses architectural concerns around coupling. We also include visualization tools and advice for decomposing monolithic architectures.
      • 00:28:14

      • Comparing Microservices: Service-Based and SOA

        This segment discusses the difference between the variety service-based of architectural styles, including microservices, service-oriented architecture (SOA), and service-based hybrids. The differences discussed in this segment will include architecture capabilities, architecture characteristics, and service differences.
      • 00:31:51

      • Service Orchestration

        Orchestration describes how services interact. This segment discusses different orchestration styles, along with pros and cons and engineering impacts.
      • 00:10:34

      • Remote Access Protocol Comparison

        Service-based architectures are fundamentally distributed; this segment compares different popular integration architecture styles, along with suitability and applicability.
      • 00:40:01

      • Distributed Architecture Challenges

        Moving from internal coupling to integration coupling is rife with issues. Distributed architectures provide unique challenges, highlighted in this segment.
      • 00:18:28

      • Devops Practices  (Free)

        Microservice architectures feature distinct engineering practices. This segment covers many of the common engineering practices common in these architectural styles.
      • 00:30:00

      • Microservices Testing  (Free)

        Microservice architectures and Continuous Delivery environments are common, including the important topic of testing. Microservices have many internal moving parts; this segment describes common testing scenarios for different parts and levels of testing.
      • 00:12:10

      • Organizational Change  (Free)

        One unexpected side effect of adapting a service-based architecture is the efficacy of combining the architecture with team structure. This segment investigates the impact of Conway's Law on team size and organization.
      • 00:16:02

      • Migration Paths and Drivers

        In this segment we will discuss the drivers and justification for moving from a monolithic or service-oriented architecture to a microservices architecture.
      • 00:14:48

      • Migration Challenges

        Moving from a monolithic "share everything" architecture to a service-based "share as little as possible" architecture is rife with challenges and issues. In this segment we will explore some of these challenges and also solutions for overcoming those challenges. Specifically, we will be discussing techniques for determining the right level of service granularity for your services, decoupling complex inheritance structures, and dealing with shared components between services.
      • 00:11:23

      • Migration Steps - Introduction and Planning

        There are several well-defined steps involved with migrating from a monolithic architecture to a service-based or microservices architecture. In this segment we will introduce the steps involved and dive into the details of the initial planning step.
      • 00:13:46

      • Migration Steps - Separation

        This segment will focus on the techniques involved with separating the user interface layer form the business layer to facilitate the refactoring of the backend components into a service-based and microservices architecture.
      • 00:05:56

      • Migration Steps - Proxy Layer

        One technique while migrating from a monolithic application to a service-based or microservices architecture is adding a proxy layer between the user interface layer and the business layer so that changes to the existing code base can be reduced or even eliminated. In this segment we will show you the techniques for adding proxy modules to isolate change suring the migration effort.
      • 00:10:14

      • Migration Steps - Refactoring

        The final step in refactoring from a monolithic architecture to a microservices architecture is service migration. In this segment we will demonstrate the techniques for migrating the source code over to service components.
      • 00:20:08

      • UI Evolution and Refactoring

        You often need to decouple evolutionary service changes from user interface changes. This segment discusses tools and techniques that allow you do decouple the user interface from underlying service changes.
      • 00:13:34

Service-Based Architectures

  • Publisher: O'Reilly Media
  • Released: July 2015
  • Run time: 6 hours 4 minutes

Explore a variety of service-based architectures—including immensely popular microservices—in this video course from Neal Ford and Mark Richards. Through a series of instructive visuals, you’ll be able to compare and contrast these architectures in several ways, including their structure, engineering practices, and deployment. You’ll also examine the challenges of migrating from monolithic service-oriented architectures (SOA) to smaller service-based models, and the effects this change can have on team building and company culture in general.

Through the course of this video, you will:

  • Learn microservice principles and the organization of its components
  • Review the common engineering practices used in microservice architectures
  • Examine remote-access protocols of different service-based architecture styles
  • Explore microservice-testing scenarios, especially in Continuous Delivery environments
  • Manage shared components between services, and define your level of service granularity
  • Learn about governance: how to identify, curate, and manage service architectures
  • Use well-defined steps to migrate from a large SOA to a service-based architecture
  • Consider hybrid service-based architectures that fall between microservices and SOAs
  • Understand microservices with regard to Conway’s Law on team size and organization

About the presenters:

Neal is Director, Software Architect, and Meme Wrangler at ThoughtWorks, a global IT consultancy with an exclusive focus on end-to-end software development and delivery. Before joining ThoughtWorks, Neal was the Chief Technology Officer at The DSW Group, Ltd., a nationally recognized training and development firm.

Mark Richards is an experienced hands-on software architect involved in the architecture, design, and implementation of microservices architectures, service oriented architectures, and distributed systems in J2EE and other technologies.

About the O’Reilly Software Architecture Series

Clearing a path from developer to architect and enriching that path once you arrive.

Software architecture is a fast-moving, multidisciplinary subject where entire suites of "best practices" become obsolete practically overnight. No single path or curriculum exists, and different types of architecture—application, integration, enterprise—require different subject emphasis. Whether you’re at the outset of a career as an architect or in the midst of such a career, series editor Neal Ford has curated this collection of tools and guides for aspiring and seasoned architects alike.