Practical Microservices Architectural Patterns (eBook)

Event-Based Java Microservices with Spring Boot and Spring Cloud

Binildas Christudas (Autor)

eBook Download: PDF

2019 | 1. Auflage
XXXII, 916 Seiten
Apress (Verlag)
978-1-4842-4501-9 (ISBN)

Infos

Take your distributed applications to the next level and see what the reference architectures associated with microservices can do for you. This book begins by showing you the distributed computing architecture landscape and provides an in-depth view of microservices architecture. Following this, you will work with CQRS, an essential pattern for microservices, and get a view of how distributed messaging works. Moving on, you will take a deep dive into Spring Boot and Spring Cloud. 

Coming back to CQRS, you will learn how event-driven microservices work with this pattern, using the Axon 2 framework. This takes you on to how transactions work with microservices followed by advanced architectures to address non-functional aspects such as high availability and scalability. In the concluding part of the book you develop your own enterprise-grade microservices application using the Axon framework and true BASE transactions, while making it as secure as possible.

What You Will Learn

• Shift from monolith architecture to microservices 
• Work with distributed and ACID transactions
• Build solid architectures without two-phase commit transactions
  
• Discover the high availability principles in microservices
  

Who This Book Is For

Java developers with basic knowledge of distributed and multi-threaded application architecture, and no knowledge of Spring Boot or Spring Cloud. Knowledge of CQRS and event-driven architecture is not mandatory as this book will cover these in depth.

Binildas provides technical architecture consultancy for IT solutions. He has over 20 years of IT experience, mostly in Microsoft and Oracle technologies. Distributed computing and service-oriented integration are his main skills, with extensive hands-on experience in Java and C# programming. A well-known and highly sought-after thought leader, Binil has designed and built many highly scalable middle-tier and integration solutions for several top-notch clients including Fortune 500 companies. He has been previously employed by multiple IT consulting firms including Infosys, India and Tata Consultancy Services and currently works for IBS Software Private Limited, as their chief architect and head of technology where he leads technology and architecture strategies for IBS's product portfolio.

Binil is a Sun Certified Programmer (SCJP), Developer (SCJD), Business Component Developer (SCBCD) and Enterprise Architect (SCEA), Microsoft Certified Professional (MCP) and Open Group (TOGAF8) Certified Enterprise Architecture Practitioner. He is also a Licensed Zapthink Architect (LZA) in SOA. IBS has applied for his proposal titled 'A Method and a System for Facilitating Multitenancy of Services' to be a patent with the USPTO.

Inhalt

Table of Contents 5
About the Author 21
About the Technical Reviewer 22
Acknowledgments 23
Foreword 24
Introduction 28
Chapter 1: Distributed Computing Architecture Landscape 30
System Architectures 31
Mainframe Architecture 33
Client-Server Architecture 33
Three-Tier Architecture 33
N-Tier Architecture 34
Network Architectures 34
Point to Point 35
Hub and Spoke 35
Enterprise Message Bus 35
Enterprise Service Bus (ESB) 36
Software Architectures 36
Application Tiers 36
Application Layers 37
The Application Architecture Landscape 37
Typical Application Architecture 38
Typical Deployment Architecture 40
The Scalability Dilemma 42
Application State 42
The Dependency Nightmare 44
The Application Monolith 45
The Scalable Architecture 46
Stateless Design 47
Divide and Conquer 47
Summary 48
Chapter 2: Introducing Microservices 49
The Modular Monolith 49
The Modular Organization 50
The Monolith Application 51
Monolith Application Boundary 52
Monolith Intermodule Dependency 53
The Scalability Dilemma 54
Monolith Technology Constraints 56
Introducing Microservices 57
Independent Modules 57
Intermodule Communication 58
The Microservices 59
Summary 62
Chapter 3: Microservices in Depth 63
Look and Feel of a Microservice 64
The E-Commerce Microservice 64
No Tier, Distributed 65
The Micromonolith 66
Understanding Self-Contained Microservices 68
Resemblance of Microservices to SOA 69
Message-Oriented Microservices 72
Advanced Microservices Capabilities 74
Fail-Safe Microservices 74
Scalable Microservices 75
Extensible Microservices 79
Summary 80
Chapter 4: Microservices Architecture 82
Architecture for Digital Business 83
The Digital Era 83
The Digital App 84
The Mesh App and Service Architecture 85
The Context for Microservices 87
Granularity of Services 87
The Gateway 91
Domain-Centric Partition 92
The Cloud Native Shift 94
Web Scale Computing 95
The Indispensable Cloud 95
Cloud Architecture Model 95
Cloud Service Model 98
SaaS Maturity Models 99
Virtualization 102
Virtualized Servers vs. Containers 102
The Architecture of Microservices 106
Inversion of Architecture 106
The Inner Architecture Perspective 107
The Outer Architecture Perspective 110
The Big Picture of MASA 112
Summary 113
Chapter 5: Essential Patterns for Microservices 114
Orthogonal Scale Out of Services 115
Write vs. Read Transactions 115
The Look-to-Book Challenge 116
CQRS: Command Query Responsibility Segregation 117
Traditional vs. CQRS-Based Software Systems 117
The Nomenclature in CQRS 123
Event-Based CQRS Architecture 123
A Meta Model for Event-Based CQRS Design 123
Command Query Segregation Using Events 127
Scale Out for CQRS-Based Microservices 129
Summary 131
Chapter 6: Distributed Messaging 132
Messaging for Resiliency 132
Message Persistence 132
Design for Various Operational Characteristics of Microservices 134
A Chain Is As Strong As Its Weakest Link 135
Synchronous vs. Asynchronous 137
Synchronous Interactions Between Microservices 137
Asynchronous Interactions Between Microservices 140
Send and Receive Messages to a Single Node RabbitMQ Broker 145
RabbitMQ Message Sender 145
RabbitMQ Message Receiver 146
Build and Run the RabbitMQ Sample 148
Maven Build 148
Ant Build 149
Send and Receive Messages to RabbitMQ Using Spring AMQP 151
Spring AMQP Message Listener 151
Spring AMQP Message Producer 154
Build and Run the Spring AMQP RabbitMQ Sample 155
Send and Receive Messages to Multi-Node RabbitMQ Cluster 157
Tying the Knots Between the Consumer and Producer 161
Correlation ID 161
Code a Custom Network Server to Handle Concurrent Heavy Traffic 162
The Simultaneous Exhibition Game 170
Message Correlation and Microservices 172
Summary 172
Chapter 7: Spring Boot 173
Performing Data Operations Using Spring Boot and MongoDB 174
Creating a Spring Boot Project Template Using the Spring Initializer 175
Spring Boot Starter Parent 177
Spring Boot Dependencies 178
Spring Boot Maven Plugin 179
Design and Code the Domain Entities 180
Code the Repositories 181
Code the Boot Application Executable 183
Build and Package the Spring Boot Application 183
Run and Test the Spring Boot Application 184
Developing Using the Spring HAL Browser, HATEOAS 189
The HAL Browser 189
Test HAL REST End Points Using RestTemplate 194
Develop a RESTful Web Service 197
REST Basics 197
HTTP Methods for CRUD Resources 198
Develop a REST Controller in Spring Boot 199
Test the REST Controller Using RestTemplate 205
Summary 208
Chapter 8: Spring Cloud 209
Spring Cloud for Microservices Architecture 210
Feign Client Usage in Spring Cloud 210
Design a Feign Client Scenario 211
Code Using Feign Client 214
Build and Test the Feign Client 216
Hystrix Fallback 218
Design a Hystrix Fallback Scenario 218
Code the Hystrix Fallback Scenario 221
Build and Test the Hystrix Fallback Scenario 224
Hystrix Dashboard 226
Redesign a Hystrix Fallback Method 226
Code the New Design of Hystrix 227
Build and Test the Hystrix Fallback Scenario 231
Inspect Hystrix Dashboard 232
Ribbon, the Client-Side Load Balancer 234
Design a Ribbon Client Scenario 234
Code to Use Ribbon Client 235
Build and Test the Ribbon Client 236
Eureka, the Service Registry 238
Design a Eureka-Enabled Scenario 239
Code to Use Eureka 240
Build and Test the Eureka Sample 246
Bootstrap Your Bootstrap Server 251
Zuul, the API Gateway 252
The Bootstrap URL 252
Design a Zuul-Enabled Scenario 257
Code to Use Zuul 258
Build and Test the Zuul Sample 261
The Config Server 263
Design a Configuration Scenario 264
Code to Use Config Server 264
Build and Test the Config Server 268
Summary 270
Chapter 9: High Availability and  Microservices 271
High Availability 272
Measuring High Availability 272
Baselining High Availability 273
Decomposing High Availability 273
DNS Redundancy 273
DNS Load Balancing 275
ISP Redundancy 277
Application Architecture Redundancy 279
Data and Storage Redundancy 281
Highly Available Microservices 285
A Highly Available Spring Cloud Microservice Demonstration 287
Design a Highly Available Microservice Scenario 287
Code to Demonstrate Highly Available Microservices 289
Build and Test the Microservices High Availability 297
Summary 302
Chapter 10: Microservice Performance 304
Communication Across the Outer Architecture 304
Asynchronous HTTP 306
The Bad and the Ugly Part of HTTP 306
APIs for Asynchronous HTTP Processing 306
Design a Scenario to Demo Async HTTP Between Microservices 310
Code to Use Async HTTP in Spring Boot 311
Build and Test Asynchronous HTTP Between Microservices 316
Google Protocol Buffer Between Spring Boot Microservices 321
Protocol Buffer 321
A Scenario to Demonstrate Protocol Buffer Between Microservices 324
Code to Use Protocol Buffer in Spring Boot 325
Build and Test the Protocol Buffer Between Microservices 332
The Impact of Using Protocol Buffer 334
Protocol Buffer Encoding 334
XML Encoding 335
JSON Encoding 337
Summary 339
Chapter 11: Events, Eventuality, and  Consistency 340
Event-Driven Architecture 341
Events 341
EDA Components 341
Microservices and Event-Driven Architecture 344
Evolution of Microservices 344
Eventual Consistency and Microservices 348
Microservices and the CAP Theorem 351
The Scale Cube 352
The CAP Theorem 354
BASE (Basically Available, Soft State, Eventually Consistent) Systems 357
CAP Pyramid 358
Summary 360
Chapter 12: Axon for CQRS Architecture 361
Introducing Axon, the CQRS Framework 362
What Is Axon? 362
Where Can You Use Axon? 363
What You Need to Run Axon 366
Command and Event Handling in the Same JVM 366
The Sample Scenario 366
Code the Sample Scenario 369
Build and Test the Example Scenario 381
Distributed Command and Event Handling 384
The Example Scenario 385
Code the Example Scenario 388
Microservice 1: 01-Ecom-web 388
Microservice 2: 02-Ecom-CreateCommandRestController 389
Microservice 3: 03-Ecom-HandleCommandAndCreateEvent 392
Microservice 4: 04-Ecom-EventHandleCore 398
Microservice 5: 05-Ecom-EventHandlerAudit 399
Build and Test the Example Scenario 399
Microservice 1: 01-Ecom-web 400
Microservice 2: 02-Ecom-CreateCommandRestController 401
Microservice 3: 03-Ecom-HandleCommandAndCreateEvent 402
Microservice 4: 04-Ecom-EventHandleCore 403
Microservice 5: 05-Ecom-EventHandlerAudit 404
Summary 407
Chapter 13: Distributed Transactions 408
The Two Generals Paradox 409
Illustrating the Two Generals Paradox 409
Solution Approaches 410
Microservices as Generals 411
TCP/IP, the Valley Between the Generals 411
Transactions 413
Hardware Instruction Sets at the Core of Transactions 413
The ACID in the Transaction 413
Transaction Models 415
Transaction Attributes in EJB vs. Spring 416
Transaction Isolation Mechanisms 417
Transaction Isolation Levels 417
Transaction Concurrency 418
Transaction Isolation Control Methods 419
Enterprise Transaction Categories 420
ACID Transactions 420
BASE = ACID in Slices 421
BASE Transactions 422
Relaxed BASE Transactions 423
ACID vs. BASE 426
Distributed Transactions Revisited 427
Local Transactions 427
Distributed Transactions 429
Distributed Transactions in Java 430
Distributed Transaction Example Using MySQL, ActiveMQ, Derby, and Atomikos 430
The Example Scenario 431
Code the Example Scenario 432
Microservice 1: Quote Processing (Broker-MySQL-ActiveMQ) 432
Microservice 2: Broker-Web 453
Microservice 3: Quote Settlement (Settlement-ActiveMQ-Derby) 454
Microservice 4: Settlement-Web 464
Build and Test the Example’s Happy Flow 465
Microservice 1: Quote Processing Microservice 468
Microservice 2: Broker Web Microservice 469
Microservice 3: Quote Settlement Microservice 470
Microservice 4: Settlement Web Microservice 471
Test the Transaction Rollback Scenario 476
Simulating Relaxed Base Anomalies 480
Test the Lost Message Scenario 481
Test the Duplicate Message Sent Scenario 483
Test the Duplicate Message Consumption Scenario 487
Test the Message Consumed, Processing Failure Scenario 491
Test the Message Redelivery Scenario 493
Common Messaging Pitfalls 496
Test the Message Received Out of Order Scenario 497
Summary 504
Chapter 14: Transactions and Microservices 505
Partitioning and Microservices 506
Microservices and Distributed Data 507
Idempotent Operations and Microservices 510
Global vs. Local Resources 511
Distributed Transactions Example: Refactoring Towards Less ACID 517
Towards Relaxed BASE: Redesign For Dealing with Duplicates and Out-Of-Order Messages 518
Code the Relaxed Example Scenario 522
Microservice 3: Quote Settlement (Settlement-ActiveMQ-Derby) 522
Build and Test the Duplicate Message Being Sent Scenario 532
Microservice 1: Quote Processing Microservice 535
Microservice 2: Broker Web Microservice 536
Microservice 3: Quote Settlement Microservice 537
Microservice 4: Settlement Web Microservice 538
Test the Duplicate Message Consumption Scenario 545
Test the Message Received Out of Order Scenario 548
Choosing Transaction Options 558
Message Queues, Peek, and Client Acknowledge 559
Summary 563
Chapter 15: Transactions Optimized for Microservices 564
Saga for Microservices Transactions 564
Saga Explained 565
Distributed Saga 566
Saga Example Code Using Axon 576
Design the Example Saga Scenario 577
Code the Example Saga Scenario 588
Microservice 1: 01-Ecom-web 588
Microservice 2: 02-Ecom-CreateCommandRestController 588
Microservice 3: 03-Ecom-HandleCommandAndCreateEvent 590
Microservice 4: 04-Ecom-EventHandleCore 595
Microservice 5: 05-Ecom-EventHandlerAudit 597
Build and Test the Saga Example 598
Microservice 1: 01-Ecom-web 599
Microservice 2: 02-Ecom-CreateCommandRestController 600
Microservice 3: 03-Ecom-HandleCommandAndCreateEvent 601
Microservice 4: 04-Ecom-EventHandleCore 602
Microservice 5: 05-Ecom-EventHandlerAudit 603
Summary 608
Chapter 16: Advanced High Availability and Scalability 609
High Availability and Scalability Templates Using an Oracle DB as a Reference 610
The Simple, Inception Architecture 610
The Simple, Scaled Out Architecture 613
Architecture to Address the Database Bottleneck 616
Independent Read and Write Scalability to Improve Efficiency 618
Sharding for Web Scale Architecture 621
Good Architecture, But We Need Better and Simpler 622
Highly Available and Scalable CQRS Example in Axon 623
Design the Sample Scenario 623
Code the Sample Scenario 625
Build and Test the High Availability Scenario 625
Microservice 1: 01-Ecom-web 627
Microservice 2: 02-Ecom-CreateCommandRestController 628
Microservice 3: 03-Ecom-HandleCommandAndCreateEvent 629
Microservice 4: 04-Ecom-EventHandleCore 630
Microservice 5: 05-Ecom-EventHandlerAudit 632
Scaling Aggregate Root Entities in Write Nodes for AXON CQRS 635
Concurrently Modify Requests to Clone of Same Entity 635
Optimistic Locking 638
Conflict Detection and Resolution in Axon 639
Example Demonstrating Optimistic Locking in Axon CQRS 640
Design the Sample Scenario 640
Code the Sample Scenario 642
Build and Test the Sample Scenario 645
Summary 657
Chapter 17: Axon CQRS Microservices E-Commerce 658
Revisiting a Traditional E-Commerce Application 659
The E-Commerce Business Summarized 659
E-Commerce Architecture Revisited 660
The E-Commerce Microservice Application 662
Logical Architecture for a Microservice-Based E-Commerce Architecture 663
The ACID Within the BASE 664
The Design of the E-Commerce Microservices 664
Technical Architecture for the Microservice-Based E-Commerce Architecture 665
Design and Code the E-Commerce Microservice Application 667
Listing Product Categories and Products 667
Listing Product Details Mashed Up with Inventory Data 669
Add a Product to the Cart 671
Create a New Order 671
Cancel an Order 681
Ship an Order Received 687
Deliver a Shipped Order 692
Delivery Failure for a Shipped Order 697
Retrieve Order History Views 702
Design and Code the E-Commerce Microservice Infrastructure 703
Config Server 703
Service Registry 705
API Gateway 705
Configure the E-Commerce Microservice Application 712
Set Up the Environment Infrastructure for the E-Commerce Microservice Application 719
Build and Run E-Commerce Microservice Application 722
Test the E-Commerce Microservice Use Cases 730
View Product Category and Product Details 732
Add to Cart 733
User Profile Creation 734
Create a New Order 737
Ship a New Order 740
Deliver Successfully the Shipped Order 742
Delivery Failure for the Shipped Order 744
Cancel a New Order 746
Reverting the Inventory 750
Summary 751
Chapter 18: Microservices Security 752
OAuth 2.0 and Microservices 753
OAuth 2.0 753
OAuth 2.0 Roles 753
OAuth 2.0 Client vs. User Agent 754
Trusted vs. Untrusted Clients 754
Classic Three-Tier Monolith 754
Classical Three-Tier Monolith with HTTP Front 756
Microservices with an API Gateway 758
Client App with No Server 760
The Authorization Code Grand Types 761
Tokens for Scalable API Invocations 765
Session IDs 765
Tokens 765
JSON Web Token (JWT) 766
Design Security for the Example Microservices Application 769
Security Architecture for Microservices 769
Asymmetric Signing and Reference Tokens 771
Code Security into Microservices E-Commerce Application 773
Enable the Web App to Handle Security 773
Zuul, the API Gateway as OAuth Client 780
Authorization Server 784
Resource Server 791
Set Up the E-Commerce Microservice Application 795
Configure the Application 795
Set Up the Environment Infrastructure 795
Build and Run the Application 795
Test the Application 796
Summary 796
Chapter 19: Axon Microservices and BASE Transactions 797
Command and Event Handling in the Same JVM Using Axon 3 798
Design the Example Scenario 798
Code the Example Scenario 799
Build and Test the Example Scenario 803
Distributed Command and Event Handling Using Axon 3 804
Design Distributed Command Bus with Spring Cloud 804
Code the Example Scenario 806
Microservice 1: 00-Ecom-registry 807
Microservice 2: 01-Ecom-web 807
Microservice 3: 02-Ecom-CreateCommandRestController 807
Microservice 4: 03-Ecom-HandleCommandAndCreateEvent 810
Microservice 5: 04-Ecom-EventHandleCore 810
Microservice 6: 05-Ecom-EventHandlerAudit 812
Build and Test the Example Scenario 813
Axon 3 CQRS Microservices E-Commerce with BASE Transactions 813
Removing the ACID Knot Between the Order and Inventory Domains 813
Partitioning the Order and Inventory Domains into Separate Microservices 826
Sagas for Deterministic Eventual Consistency 827
Configure the E-Commerce Microservice Application 828
Build and Run the E-Commerce Microservice Application 828
Command and Event Handling in the Same JVM Using Axon 4 829
Distributed Command and Event Handling Using Axon 4 829
Summary 830
Appendix A: Install, Configure, and Run MongoDB 831
Introducing MongoDB 831
The MongoDB Document 832
Install and Configure MongoDB 832
Download MongoDB Community Edition 832
Install and Configure MongoDB 833
Start Using MongoDB 834
Start and Connect to MongoDB 835
Execute Basic Data Manipulations with MongoDB 836
Robomongo, A GUI for MongoDB 840
Download and Install Robomongo Community Edition 840
Start and Connect to MongoDB Using Robomongo 841
Execute Basic Data Manipulation with MongoDB 842
Summary 843
Appendix B: Install, Configure, and Run RabbitMQ Cluster 844
Introducing RabbitMQ 844
Set Up RabbitMQ 845
Download and Install Erlang 845
Install and Configure RabbitMQ 846
Start Using RabbitMQ 846
Enable Management Plugin 847
Start RabbitMQ Server 847
View RabbitMQ Management Console 848
Set Up a RabbitMQ Cluster 849
Configure RabbitMQ Cluster 849
Bring Up the RabbitMQ Cluster 851
Restart a RabbitMQ Cluster 857
Connect to a RabbitMQ Cluster from a Client 858
Summary 858
Appendix C: Install, Configure, and  Run Nginx Reverse Proxy 859
Install Nginx 859
Start Using Nginx 860
Start Using Nginx as Reverse Proxy 860
Configure HTTP Reverse Proxy 861
Configure TCP Reverse Proxy 861
Summary 862
Appendix D: cURL and Postman 863
cURL Operations for HTTP 863
HTTP GET to Retrieve an Entity 864
HTTP POST to Create an Entity 865
HTTP PUT to Replace an Entity 867
HTTP PATCH to Modify an Entity 869
HTTP DELETE to Delete an Entity 870
Postman for HTTP Operations 871
HTTP GET Using Postman to Retrieve an Entity 871
Summary 871
Appendix E: Apache TCPMon 872
Install TCPMon 872
Start Using TCPMon 873
Set Up TCPMon as a Proxy 873
Summary 875
Appendix F: ActiveMQ 876
Install and Configure ActiveMQ 876
Start Using ActiveMQ 877
View ActiveMQ Management Console 879
Configure ActiveMQ 880
Summary 882
Appendix G: Derby 883
Install and Configure Derby 883
Start and Stop Derby Server in Network Mode 884
Create a New Derby Database 885
Execute Basic Commands in Derby Database 888
Summary 890
Appendix H: MySQL 891
Install MySQL 891
Initialize the Data Directory 892
Start MySQL Server 893
Connect to MySQL Server 893
Test the MySQL Server Installation 895
Disconnect from MySQL Server 895
Create and Select a Database 895
Create Tables 897
Add User Accounts to MySQL Server 898
Stop MySQL Server 898
Summary 898
Index 899

Produkt-Details

• Erscheint lt. Verlag: 25.6.2019
• Zusatzinfo: XXXII, 902 p. 298 illus.
• Sprache: englisch
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• Themenwelt: Informatik ► Theorie / Studium ► Compilerbau
• Schlagworte: Architecture • axon • Base • CQRS • Microservices • Patterns • Spring • springboot • springcloud
• ISBN-10: 1-4842-4501-6 / 1484245016
• ISBN-13: 978-1-4842-4501-9 / 9781484245019