x

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

Event-Driven Microservices

      • Why a Pattern Language for Microservices?  (Free)

        Rather than blindly advocate for using microservices we strive to present a more balanced view and describe the drawbacks as well as the benefits. We primarily present architectural and design decisions in the form of a pattern language. This segment describes the motivations for using patterns and presents an overview of the microservices pattern language.
      • 00:15:10

      • Monolithic Architecture

        The monolithic architecture is widely used. In this section we take a look at both the benefits and drawbacks of using this approach.
      • 00:10:42

      • Benefits and Drawbacks of Microservices

        The microservice architecture is no silver bullet. In this section, you will learn about the benefits and the drawbacks of using microservices as well as the issues that you need to address.
      • 00:19:43

      • Partitioning Strategies

        One key decision you must make when using microservices is how to partition your application into microservices. This segment describes some partitioning strategies, as well as the challenges and pitfalls.
      • 00:14:07

      • Deployment Patterns Overview

        Once you have developed your microservices you need to deploy it. In this segment we outline the issues that you need to address.
      • 00:04:05

      • Multiple Services Per Host

        One way to deploy your microservices is the traditional approach of running multiple service instances on the same host (physical or virtual server). This segments describes the benefits and drawbacks of this approach.
      • 00:05:20

      • Services Per VM

        This segment describes the more modern approach of running each service instance in it's own virtual machine. You will learn about the pros and cons.
      • 00:05:58

      • Service Per Container

        Today, Docker is all the rage. In this segment, we look at the benefits and drawbacks of deploying services as containers.
      • 00:06:02

      • Communication Patterns Overview

        When you build an application with a microservice architecture you are building a distributed system. Consequently, you must tackle several inter-process communication (IPC) problems.
      • 00:03:07

      • Communication Patterns: API Gateway

        One issue you must solve is how do clients of the application (e.g. web applications and mobile clients) communicate with the microservices that now comprise the application. In this segment, we explore the issues and describe a solution known as an API Gateway.
      • 00:12:04

      • Communication Patterns: Service Discovery

        In order for a client to make, for example, an HTTP request to a service, it must know the network location of a service instance. In a modern application, however, you can't simply hardwire ip addresses and ports into each client. In this segment, we explore the problem and describe various ways to implement service discovery.
      • 00:11:01

      • Communication Patterns: Service Registration

        A service instance must be registered with a service registry in order for it to be discovered by a client. This segment compares and contrasts the two main solutions to this problem.
      • 00:07:48

      • Microservice Chassis

        You typically begin a software development project by spending a significant amount of time putting in place the mechanisms to handle concerns such as externalized configuration, logging, and health checks. If you are building a monolithic application this is something you only do once at the start of a long project and so the time spent is not significant. In contrast, in a microservices architecture you frequently create new services, which might be relatively small or short-lived. In this segment, we look at the idea of a microservices chassis, which is a framework that provides this kind of functionality out of the box and makes it easy to write new services.
      • 00:07:18

      • The Problem of Microservices and Data Consistency

        Each microservices has its own data store in order to ensure loose coupling. However, this makes it difficult to maintain consistency across multiple services. You can't, for example, use distributed transactions (2PC).
      • 00:12:23

      • Using Events to Maintain Data Consistency

        An event-driven architecture is a great way to maintain data consistency without using distributed transactions (2PC). We describe some solutions of a key problem in an event-driven architecture: how to reliably update the datastore and publish events.
      • 00:12:52

      • Overview of Event Sourcing

        Event sourcing is a radically different way of implementing an event-driven architecture. Rather than store the current state of a business object, an application persists a sequence of state changing events. In this segment, we explore event sourcing and it's benefits and drawbacks.
      • 00:18:08

      • Event Sourcing Domain Model

        In this segment, we look at a simple example that illustrates how to write business logic that uses event sourcing.
      • 00:10:21

      • Implementing Queries in an Event Source Application

        One challenge of using event sourcing is that an event store is usually designed to support just one query: retrieving an entity's events by it's primary key. Other queries are often inefficient, overly complex or simply not possible. To implement these queries efficiently you need to maintain one or more materialized views. In this segment, we look at how to do this using Command Query Responsibility Segregation (CQRS).
      • 00:10:38

      • Event Sourcing and Microservices

        One great side effect of using event sourcing is that it modularizes your application's business logic. Consequently, you can easily deploy your application as either a monolith or as microservices.
      • 00:03:45

      • Incrementally Refactoring a Monolith Into Microservices

        Let's imagine that you desperately need to accelerate the velocity of your development by adopting the microservice architecture. But what can you do if your application is a monstrous monolith? Don't worry, there is a strategy for incrementally refactoring your monolith into a set of microservices.
      • 00:03:49

      • Strategy #1: Stop Digging

        The "Law of holes" says that you are in a hole then you should stop digging. In other words, don't make your monolith bigger. Instead new functionality should be implemented as services.
      • 00:03:01

      • Refactoring Case Study

        In this segment, we look at an example of how to enhance the functionality of a monolithic application by implementing that new functionality as a microservice.
      • 00:10:04

Event-Driven Microservices

  • Publisher: O'Reilly Media
  • Released: March 2016
  • Run time: 4 hours 47 minutes

Software developers and architects increasingly turn to microservices as a framework for improving the agility and velocity of their development efforts. But is it the right approach? This video presents a balanced view of the benefits and drawbacks of microservices. It outlines the motivations driving the adoption of microservices; compares and contrasts it to monolithic architecture; describes solutions to key problems such as inter-service communication and distributed data management; and moves on to a set of strategies for refactoring a monolithic application into a set of microservices.

  • Understand how microservice architecture tames complexity in large applications
  • Discover strategies for partitioning an application into microservices
  • Examine deployment patterns like multiple services per host and service per virtual machine
  • Understand the issues surrounding API gateways, service discovery, and service registration
  • Discover the microservice chassis - a framework for easily creating small short lived services
  • Explore the problem of data consistency in microservices and solutions to that problem
  • Learn about event sourcing, implementing queries, and command query responsibility segregation

Chris Richardson is a developer, architect, Java Champion, and JavaOne rock star. He wrote POJOs in Action (which describes how to build enterprise Java applications with frameworks such as Spring and Hibernate) and was the founder of the original CloudFoundry.com, an early Java PaaS for Amazon EC2. He is the creator of microservices.io and is working on his third startup: a platform for developing reactive microservices.

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.