Overview of the Eventuate Tram Customers and Orders application

Jun 13, 20205 likes1,790 views

Chris Richardson

This Spring Boot/JPA application illustrates how to use the Saga and CQRS patterns in a microservice architecture.

@crichardson
About the example
Demonstrates two key patterns:
Sagas - implement transactions that span services, https://
microservices.io/patterns/data/saga.html
CQRS - implement queries that retrieve data from multiple
services, https://microservices.io/patterns/data/cqrs.html
Built using Spring Boot, JPA and the Eventuate Tram
framework
https://github.com/eventuate-tram/eventuate-tram-examples-customers-and-orders/
Note: this presentation describes the development branch , which
reorganized/renamed the service modules.
These changes will soon be merged into master

@crichardson
System operations
CustomersAndOrdersApplication
≪commands≫
createCustomer(name, creditLimit)
createOrder(customerId, orderTotal)
cancelOrder(orderID)
≪queries≫
ﬁndOrder(orderId)
ﬁndOrderHistory(customerId)

@crichardson
Customer Service - domain
model

@crichardson
Order Service - domain model

@crichardson
Order History Service - canvas

@crichardson
Technical architecture
Service:
REST endpoint
Pub/sub events
Relational database - MySQL database
Message broker
Eventuate CDC - implements the Transaction Outbox pattern

@crichardson
Using the Saga pattern
Customer has a credit limit
createOrder()
Creates Order
Reserves credit
cancelOrder()
Updates Order
Releases credit
Event-driven
a.k.a
Choreography-based sagas
https://microservices.io/patterns/data/saga.html

Using the CQRS pattern
ﬁndOrderHistory()
Returns customers and
their orders
Order History Service
uses events to maintain a
replica in MongoDB
https://microservices.io/patterns/data/cqrs.html

@crichardson
Customer Service
Customer
Controller
Message
Producer
createCustomer()
Customer* Events
Order
Event
Consumer
Order* events
Customer
Database
≪entity≫
Customer
Customer
Repository
≪service≫
Customer
Service
Domain
Event
Publisher
POST /customers

Customer Service - code
customer-service-api-
messaging - events
published by the service
customer-service-api-web
- DTOs for REST
resources
customer-service - service
implementation

@crichardson
Order Service
Order Controller
Message
Producer
createOrder()
cancelOrder()
Order* Events
Customer
Event
Consumer
Customer* events
Order
Database
≪entity≫
Order
Order
Repository
≪service≫
Order
Service
Domain
Event
Publisher
POST /customers

Order Service - code
order-service-api-
messaging - events
published by the service
order-service-api-web -
DTOs for REST requests
and responses
order-service - service
implementation

@crichardson
Order History Service
CustomerOrder
HistoryController
ﬁndOrderHistory()
Order
History
Event
Consumer
Order* events
Order
History
Databas
CustomerView
Repository
≪service≫Ord
erHistory
ViewService
POST /customers
Customer* events

Order History Service - code
order-history-service-api-
web - DTOs for REST
requests and responses
order-service - service
implementation

@crichardson
Using the Saga pattern
https://microservices.io/patterns/data/saga.html

@crichardson
createOrder() sequence
diagram

@crichardson
cancelOrder() sequence
diagram

@crichardson
Using the CQRS pattern
https://microservices.io/patterns/data/cqrs.html

@crichardson
Implementing ﬁndOrderHistory()

@crichardson
@crichardson chris@chrisrichardson.net
http://eventuate.io
Questions?

Kubernetes has the concept of resource requests and limits. Pods get scheduled on the nodes based on their requests and optionally limited in how much of the resource they can consume. Understanding and optimizing resource requests/limits is crucial both for reducing resource "slack" and ensuring application performance/low-latency. This talk shows our approach to monitoring and optimizing Kubernetes resources for 80+ clusters to achieve cost-efficiency and reducing impact for latency-critical applications. All shown tools are Open Source and can be applied to most Kubernetes deployments.

Diabetes MellitusMD Abdul Haleem

This document provides an overview of diabetes mellitus (DM), including the three main types (Type 1, Type 2, and gestational diabetes), signs and symptoms, complications, pathophysiology, oral manifestations, dental management considerations, emergency management, diagnosis, and treatment. DM is caused by either the pancreas not producing enough insulin or cells not responding properly to insulin, resulting in high blood sugar levels. The document compares and contrasts the characteristics of Type 1 and Type 2 DM.

Power Point Presentation on Artificial Intelligence Anushka Ghosh

Republic Act No. 11313 Safe Spaces Act (Bawal Bastos Law).pptxmaricelabaya1

The document summarizes key aspects of the Safe Spaces Act, which aims to address gender-based sexual harassment. It defines harassment in public spaces, online, and work/educational settings. Acts considered harassment include catcalling, unwanted comments on appearance, stalking, and distributing intimate photos without consent. Those found guilty face penalties like imprisonment or fines. The law also requires employers and educational institutions to disseminate the law, prevent harassment, and address complaints through committees.

HypertensionRatheeshkrishnakripa

This document defines hypertension and describes its types, etiology, risk factors, pathophysiology, clinical features, diagnostic evaluations, and management. Hypertension is defined as a systolic blood pressure of 140 mmHg or higher and/or a diastolic blood pressure of 90 mmHg or higher. It is managed primarily through lifestyle modifications like diet and exercise changes as well as pharmacological therapies including diuretics, beta blockers, ACE inhibitors, and calcium channel blockers. Nursing care involves monitoring the patient's condition, educating on lifestyle changes, and ensuring proper treatment adherence.

Nursing processDr. Binu Babu Nursing Lectures Incredibly Easy

The document discusses the nursing process, which includes assessment, nursing diagnosis, planning, implementation, and evaluation. It describes each component in detail. Assessment involves collecting client data through various methods. Nursing diagnosis identifies client problems based on the assessment. Planning establishes goals and interventions. Implementation carries out the planned interventions. Evaluation assesses client progress and intervention effectiveness. The nursing process is a systematic approach to providing individualized care.

Αφίσες γραμματικής, ορθογραφίας, μαθηματικών για παιδιά του δημοτικού (https:...Παπαδημητρακοπούλου Τζένη

AnemiaDr.Sabari Nathan

This document provides information about anemia. It begins with an introduction stating that anemia is a major problem in India, affecting many women and contributing to maternal deaths. The objectives of the document are then outlined, including defining anemia, classifying types, and discussing causes, symptoms, investigations, treatment and prevention. Several types of anemia are described such as iron deficiency, megaloblastic, and sickle cell anemia. Risk factors, signs and symptoms, normal values, and investigations like hematocrit and hemoglobin levels are explained. The document concludes with sections on management, treatment recommendations including iron supplementation, and benefits of therapy like improved cognition and survival.

An overview of the Eventuate PlatformChris Richardson

Saturn 2018: Managing data consistency in a microservice architecture using S...Chris Richardson

A revised and extended version that I gave at Saturn 2018. The services in a microservice architecture must be loosely coupled and so cannot share database tables. What’s more, two phase commit (a.k.a. a distributed transaction) is not a viable option for modern applications. Consequently, a microservices application must use the Saga pattern, which maintains data consistency using a series of local transactions. In this presentation, you will learn how sagas work and how they differ from traditional transactions. We describe how to use sagas to develop business logic in a microservices application. You will learn effective techniques for orchestrating sagas and how to use messaging for reliability. We will describe the design of a saga framework for Java and show a sample application.

Developing event-driven microservices with event sourcing and CQRS (london Ja...Chris Richardson

This is a talk I gave to the London Java Community in June 2016 In a microservices architecture, each service has its own database. While this ensures that services are loosely coupled it creates a problem: how do you maintain consistency across services without using 2PC? In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Separation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.

MicroCPH - Managing data consistency in a microservice architecture using SagasChris Richardson

This document summarizes Chris Richardson's presentation on using sagas to maintain data consistency in a microservices architecture. Richardson explains that ACID transactions cannot be used across services due to limitations of distributed transactions. Instead, sagas can be used, where each service performs a local transaction and messages are passed between services. There are two main approaches to coordinating sagas: choreography-based using domain events, and orchestration-based where a central saga manages the process. Countermeasures like semantic locking are also needed to prevent data anomalies from the lack of isolation in sagas.

Mucon: Not Just Events: Developing Asynchronous MicroservicesChris Richardson

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. Chris will share with you how to implement transactions using sagas, which are sequences of local transactions. You will learn how to coordinate sagas using either events or command messages. Chris will also explore how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain easily queried replicas.

Event Sourcing & CQRS, Kafka, Rabbit MQAraf Karsh Hamid

Building and deploying microservices with event sourcing, CQRS and Docker (Be...Chris Richardson

This document discusses building and deploying microservices using event sourcing, CQRS and Docker. It covers an overview of event sourcing and how it solves data consistency issues in microservice architectures. CQRS is used to implement materialized views for queries. Spring Boot is recommended for building microservices and Docker is used to package the microservices. A continuous integration pipeline is used to build, test, publish Docker images and deploy updates.

React js Demo ExplanationRama Krishna Vankam

Rama Krishna is an online trainer based in Hyderabad, India with over 11 years of experience in frontend and backend development. He provides training in various technologies including ReactJS, Angular, NodeJS, and more. This document outlines his experience and skills, provides a detailed course outline for a ReactJS training, and shares positive testimonials from past students who praise his teaching abilities and patience.

Data Pipelines with Apache KafkaBen Stopford

Kafka is a distributed streaming platform that allows for publishing and subscribing to streams of records. It provides low latency and high throughput processing of streams of records. Key features include replication across clusters for fault tolerance, partitioning for scalability, and ordering of records. Common uses of Kafka include building event driven microservices, stream processing, and serving as the data backbone for real-time analytics applications.

MicroService ArchitectureFred George

Fred George describes his personal journey discovering microservice architecture over 15 years working on large software projects. He details how his projects evolved from monolithic 1 million line applications to small, independent services. This allowed for improved agility, with services being short-lived and able to deploy several times a day. George also discusses challenges faced and lessons learned around loosely coupling services, managing data across services, and establishing practices for a "living software" system with continuous deployment of services.

Sinatra Rack And MiddlewareBen Schwarz

This document discusses Sinatra, a Ruby web application framework built with Rack middleware. It provides examples of basic Sinatra applications and routes, and discusses how Sinatra apps can also be used as Rack middleware. It promotes some projects by the author including Amnesia for Memcached stats, Munch for recipe search, and Postie for postcode services implemented as Rack middleware. It also discusses related tools like Shotgun for reloading and Rack middleware like Rack::Cache.

REST APIs with SpringJoshua Long

Concurrent Programming Using the DisruptorTrisha Gee

YOW2018 - Events and Commands: Developing Asynchronous MicroservicesChris Richardson

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. I describe how to implement transactions using sagas, which are sequences of local transactions, coordinated using messages. You will learn how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain replicas. I describe how to use event sourcing, which is an event-centric approach to business logic and persistence, in a microservice architecture.

Domain Driven Design Araf Karsh Hamid

This document discusses domain-driven design (DDD) concepts for transforming a monolithic application to microservices, including: 1. Classifying applications into areas like lift and shift, containerize, refactor, and expose APIs to prioritize high business value, low complexity projects. 2. Focusing on shorter duration projects from specifications to operations. 3. Designing around business capabilities, processes, and forming teams aligned to capabilities rather than technology. 4. Key DDD concepts like ubiquitous language, bounded contexts, and context maps to decompose the domain model into independently deployable microservices.

Introduction to RxJSBrainhub

RxJS is a library for reactive programming that allows composing asynchronous and event-based programs using observable sequences. It provides the Observable type for pushing multiple values to observers over time asynchronously. Operators allow transforming and combining observables. Key types include Observable, Observer, Subject, BehaviorSubject, and ReplaySubject. Subjects can multicast values to multiple observers. Overall, RxJS is useful for handling asynchronous events as collections in a declarative way.

Developing event-driven microservices with event sourcing and CQRS (svcc, sv...Chris Richardson

Modern, cloud-native applications typically use a microservices architecture in conjunction with NoSQL and/or sharded relational databases. However, in order to successfully use this approach you need to solve some distributed data management problems including how to maintain consistency between multiple databases without using 2PC. In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Segregation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.

Microservices Part 3 Service Mesh and KafkaAraf Karsh Hamid

Understand the Microservices Architecture concepts Understand Event Sourcing and CQRS Understanding Domain Driven Design Understanding Functional Reactive Programming Understanding Distributed Transaction Management Understanding Microservices Messaging Setting up Micro services Infrastructure (API Gateway, Service Discovery, Load Balancer, Circuit Breaker) https://github.com/meta-magic/microservice_workshop

React HooksJoao Marins

React Hooks are functions that allow you to "hook into" React state and lifecycle features from function components. Some key hooks include useState, useContext, and useEffect. Hooks make it easier to reuse stateful logic between components and simplify component logic. However, hooks should only be called from React functions and not in loops, conditions, or nested functions. Overall, hooks provide more powerful features to function components and opportunities to write code in a more functional style.

Micro services ArchitectureAraf Karsh Hamid

The document provides an overview of microservices architecture. It discusses key characteristics of microservices such as each service focusing on a specific business capability, decentralized governance and data management, and infrastructure automation. It also compares microservices to monolithic and SOA architectures. Some design styles enabled by microservices like domain-driven design, event sourcing, and functional reactive programming are also covered at a high level. The document aims to introduce attendees to microservices concepts and architectures.

Microservices: Decomposing Applications for Deployability and Scalability (ja...Chris Richardson

Today, there are several trends that are forcing application architectures to evolve. Users expect a rich, interactive and dynamic user experience on a wide variety of clients including mobile devices. Applications must be highly scalable, highly available and run on cloud environments. Organizations often want to frequently roll out updates, even multiple times a day. Consequently, it's no longer adequate to develop simple, monolithic web applications that serve up HTML to desktop browsers.In this talk we describe the limitations of a monolithic architecture. You will learn how to use the scale cube to decompose your application into a set of narrowly focused, independently deployable services. We will also discuss how an event-based approach addresses the key challenges of developing applications with this architecture.

Microservices + Events + Docker = A Perfect Trio (dockercon)Chris Richardson

Microservices are an essential enabler of agility but developing and deploying them is a challenge. In order for microservices to be loosely coupled,each service must have its own datastore. This makes it difficult to maintain data consistency across services. Deploying microservices is also a complex problem since an application typically consists of 10s or 100s of services, written in a variety of languages and frameworks. In this presentation, you will learn how to solve these problems by using an event-driven architecture to maintain data consistency and by using Docker to simplify deployment.

More Related Content

What's hot (20)

An overview of the Eventuate PlatformChris Richardson

Saturn 2018: Managing data consistency in a microservice architecture using S...Chris Richardson

Developing event-driven microservices with event sourcing and CQRS (london Ja...Chris Richardson

MicroCPH - Managing data consistency in a microservice architecture using SagasChris Richardson

Mucon: Not Just Events: Developing Asynchronous MicroservicesChris Richardson

Event Sourcing & CQRS, Kafka, Rabbit MQAraf Karsh Hamid

Building and deploying microservices with event sourcing, CQRS and Docker (Be...Chris Richardson

React js Demo ExplanationRama Krishna Vankam

Data Pipelines with Apache KafkaBen Stopford

MicroService ArchitectureFred George

Sinatra Rack And MiddlewareBen Schwarz

REST APIs with SpringJoshua Long

Concurrent Programming Using the DisruptorTrisha Gee

YOW2018 - Events and Commands: Developing Asynchronous MicroservicesChris Richardson

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. I describe how to implement transactions using sagas, which are sequences of local transactions, coordinated using messages. You will learn how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain replicas. I describe how to use event sourcing, which is an event-centric approach to business logic and persistence, in a microservice architecture.

Domain Driven Design Araf Karsh Hamid

Introduction to RxJSBrainhub

Developing event-driven microservices with event sourcing and CQRS (svcc, sv...Chris Richardson

Microservices Part 3 Service Mesh and KafkaAraf Karsh Hamid

React HooksJoao Marins

Micro services ArchitectureAraf Karsh Hamid

An overview of the Eventuate PlatformChris Richardson

Saturn 2018: Managing data consistency in a microservice architecture using S...Chris Richardson

Developing event-driven microservices with event sourcing and CQRS (london Ja...Chris Richardson

MicroCPH - Managing data consistency in a microservice architecture using SagasChris Richardson

Mucon: Not Just Events: Developing Asynchronous MicroservicesChris Richardson

Event Sourcing & CQRS, Kafka, Rabbit MQAraf Karsh Hamid

Building and deploying microservices with event sourcing, CQRS and Docker (Be...Chris Richardson

React js Demo ExplanationRama Krishna Vankam

Data Pipelines with Apache KafkaBen Stopford

MicroService ArchitectureFred George

Sinatra Rack And MiddlewareBen Schwarz

REST APIs with SpringJoshua Long

Concurrent Programming Using the DisruptorTrisha Gee

YOW2018 - Events and Commands: Developing Asynchronous MicroservicesChris Richardson

Domain Driven Design Araf Karsh Hamid

Introduction to RxJSBrainhub

Developing event-driven microservices with event sourcing and CQRS (svcc, sv...Chris Richardson

Microservices Part 3 Service Mesh and KafkaAraf Karsh Hamid

React HooksJoao Marins

Micro services ArchitectureAraf Karsh Hamid

Similar to Overview of the Eventuate Tram Customers and Orders application (20)

Microservices: Decomposing Applications for Deployability and Scalability (ja...Chris Richardson

Microservices + Events + Docker = A Perfect Trio (dockercon)Chris Richardson

Microservices + Events + Docker = A Perfect Trio by Docker Captain Chris Rich...Docker, Inc.

The document discusses how microservices, events, and Docker form a perfect trio for developing and deploying applications. It covers how microservices can help accelerate development but also introduce complexity that events and Docker can help address. Events are proposed to maintain data consistency between microservices rather than distributed transactions. Docker is presented as a way to containerize microservices for improved isolation, manageability and efficient deployment and scaling. The overall presentation argues this combination of techniques can help build large, complex applications.

Events on the outside, on the inside and at the core (jaxlondon)Chris Richardson

This presentation looks at the importance of events and the role that they play in software applications. We describe how events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You will learn how the microservices inside a system can use events to maintain data consistency. We discuss how easy it is to implement both these mechanisms by developing your core business logic using an event-centric approach.

Events on the outside, on the inside and at the core - Chris RichardsonJAXLondon_Conference

The document discusses event sourcing and how it enables an event-driven enterprise architecture. It describes how event sourcing works by having applications persist all state changes as a sequence of events rather than current state. These events can then be used to rebuild state. When requests are received, past events are replayed to determine the current state. New events generated from requests are published for other applications. This allows for distributed transaction processing without two-phase commit and enables eventual consistency across services.

Introduction to MicroServices (Oakjug)Chris Richardson

Chris Richardson is a consultant who helps organizations adopt microservice architectures. He discusses how monolithic applications can be difficult to develop, deploy and scale. Decomposing applications into independent microservices allows each service to be developed, deployed and scaled independently. This improves development speed, fault isolation and allows each service to use different technologies. However, developing distributed systems is complex and requires careful coordination between services. Microservices are best adopted later once an application needs to be scaled rather than from the beginning.

Futures and Rx Observables: powerful abstractions for consuming web services ...Chris Richardson

A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone. In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.

Developing event-driven microservices with event sourcing and CQRS (Shanghai)Chris Richardson

This is a talk I gave in Shanghai on July 4th 2016 In a microservices architecture, each service has its own database. While this ensures that services are loosely coupled it creates a problem: how do you maintain consistency across services without using 2PC? In this talk you will learn more about these issues and how to solve them by using an event-driven architecture. We will describe how event sourcing and Command Query Responsibility Separation (CQRS) are a great way to realize an event-driven architecture. You will learn about a simple yet powerful approach for building, modern, scalable applications.

Designing loosely coupled servicesChris Richardson

Skillsmatter CloudNative eXchange 2020 The microservice architecture is a key part of cloud native. An essential principle of the microservice architecture is loose coupling. If you ignore this principle and develop tightly coupled services the result will mostly likely be yet another "microservices failure story”. Your application will be brittle and have all of disadvantages of both the monolithic and microservice architectures. In this talk you will learn about the different kinds of coupling and how to design loosely coupled microservices. I describe how to minimize design time and increase the productivity of your DevOps teams. You will learn how how to reduce runtime coupling and improve availability. I describe how to improve availability by minimizing the coupling caused by your infrastructure.

Building a SaaS using WSO2 StratosWSO2

This document summarizes a webinar about building software as a service (SaaS) applications using WSO2 Stratos. It discusses key concepts of SaaS and PaaS including multi-tenancy, elastic scaling, metering and billing. It also provides an overview of the Stratos architecture, how it uses cartridges to deploy different platforms and applications, and how it provides shared services to applications.

SVCC Developing Asynchronous, Message-Driven Microservices Chris Richardson

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. I describe how to implement transactions using sagas, which are sequences of local transactions, coordinated using messages. You will learn how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain replicas. I describe the key role that messaging plays a microservice architecture. Given at Silicon Valley Code Camp 2018

OReilly SACON2018 - Events on the outside, on the inside, and at the coreChris Richardson

Events are very much on the edge of traditional applications, which use them as an application integration mechanism. The classic example is an ecommerce system. When a customer places an order, the order management application publishes an event, which triggers the fulfillment application to action. But today, microservices and DDD—which is a great foundation for microservices—are at the core of the application. Events play an essential role in modern applications. Chris Richardson explains why events are a key application integration mechanism and how they are used by applications to communicate with the outside world. You’ll learn how the microservices inside an application use events to maintain data consistency and discover how to go one step further and make events an integral part of your domain logic.

Developing applications with a microservice architecture (SVforum, microservi...Chris Richardson

Building and deploying microservices with event sourcing, CQRS and Docker (Ha...Chris Richardson

In this talk we share our experiences developing and deploying a microservices-based application. You will learn about the distributed data management challenges that arise in a microservices architecture. We will describe how we solved them using event sourcing to reliably publish events that drive eventually consistent workflows and pdate CQRS-based views. You will also learn how we build and deploy the application using a Jenkins-based deployment pipeline that creates Docker images that run on Amazon EC2.

Decompose your monolith: Six principles for refactoring a monolith to microse...Chris Richardson

Developing applications with a microservice architecture (svcc)Chris Richardson

The micro-service architecture, which structures an application as a set of small, narrowly focused, independently deployable services, is becoming an increasingly popular way to build applications. This approach avoids many of the problems of a monolithic architecture. It simplifies deployment and let’s you create highly scalable and available applications. In this talk we describe the micro-service architecture and how to use it to build complex applications. You will learn how techniques such as Command Query Responsibility Segregation (CQRS) and Event Sourcing address the key challenges of developing applications with this architecture. We will also cover some of the various frameworks such as NodeJS and Spring Boot that you can use to implement micro-services.

#JaxLondon keynote: Developing applications with a microservice architectureChris Richardson

The document summarizes Chris Richardson's presentation on developing applications with a microservice architecture. The presentation discusses how decomposing monolithic applications into microservices improves deployability, scalability, and simplifies adopting new technologies. It covers the benefits of microservices, including improved fault isolation, reduced commitment to technology stacks, and easier scaling of development. It also discusses challenges like complexity in developing, testing, and operating distributed systems.

Developing Applications with a Micro Service Architecture - Chris RichardsonJAXLondon2014

The document summarizes Chris Richardson's presentation on developing applications with a microservice architecture. The presentation discusses how decomposing monolithic applications into microservices improves deployability, scalability, and simplifies adopting new technologies. It covers strategies for decomposing applications, using an API gateway, and mechanisms for inter-service communication like HTTP and messaging. Complexities of developing distributed systems with microservices are also addressed.

UDDI from JAVA Web services uday katti

This document discusses various topics related to implementing web services using UDDI registries, including: 1) The four main types of web service implementations: simple services, composite services, middleware services, and service buses. 2) Extending UDDI registries to add additional elements like discovery URLs. 3) Using private UDDI registries within organizations for purposes like application integration and as marketplace or portal registries.

Knowledge management and information systemnihad341