ebook img

Learn Microservices with Spring Boot: A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud-Native Patterns, and Containerization PDF

435 Pages·2020·12.858 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Learn Microservices with Spring Boot: A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud-Native Patterns, and Containerization

Learn Microservices with Spring Boot A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud-Native Patterns, and Containerization — Second Edition — Moisés Macero García Learn Microservices with Spring Boot A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud-Native Patterns, and Containerization Second Edition Moisés Macero García Learn Microservices with Spring Boot: A Practical Approach to RESTful Services Using an Event-Driven Architecture, Cloud- Native Patterns, and Containerization Moisés Macero García New York, NY, USA ISBN-13 (pbk): 978-1-4842-6130-9 ISBN-13 (electronic): 978-1-4842-6131-6 https://doi.org/10.1007/978-1-4842-6131-6 Copyright © 2020 by Moisés Macero García This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Coordinating Editor: Mark Powers Cover designed by eStudioCalamar Cover image by Ash from Modern Afflatus on Unsplash (www.unsplash.com) Distributed to the book trade worldwide by Apress Media, LLC, 1 New York Plaza, New York, NY 10004, U.S.A. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www. springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights, please e-mail [email protected]. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484261309. For more detailed information, please visit www.apress.com/source-code. Printed on acid-free paper To my family, especially to my mom and my wife. All of you keep teaching me many things, amongst them care, love, and curiosity, the most important learnings in life. In memory of my dad, an engineer at heart. You encouraged me to keep learning, sparked my curiosity thanks to your inventions, and taught me to be pragmatic to solve the problem at hand. This book has a bit of all of you. Table of Contents About the Author ���������������������������������������������������������������������������������������������������xiii About the Technical Reviewers �������������������������������������������������������������������������������xv Chapter 1: Setting the Scene ������������������������������������������������������������������������������������1 Who Are You? ��������������������������������������������������������������������������������������������������������������������������������2 How Is This Book Different from Other Books and Guides? ����������������������������������������������������������3 Learning: An Incremental Process �������������������������������������������������������������������������������������������3 Is This a Guide or a Book? �������������������������������������������������������������������������������������������������������4 From Basics to Advanced Topics ���������������������������������������������������������������������������������������������������4 Skeleton with Spring Boot, the Professional Way ��������������������������������������������������������������������5 Test-Driven Development ��������������������������������������������������������������������������������������������������������5 Microservices ��������������������������������������������������������������������������������������������������������������������������6 Event-Driven System ���������������������������������������������������������������������������������������������������������������6 Nonfunctional Requirements ���������������������������������������������������������������������������������������������������6 Online Content ������������������������������������������������������������������������������������������������������������������������������7 Summary���������������������������������������������������������������������������������������������������������������������������������������7 Chapter 2: Basic Concepts ����������������������������������������������������������������������������������������9 Spring��������������������������������������������������������������������������������������������������������������������������������������������9 Spring Boot ���������������������������������������������������������������������������������������������������������������������������������10 Lombok and Java ������������������������������������������������������������������������������������������������������������������������12 Testing Basics �����������������������������������������������������������������������������������������������������������������������������15 Test-Driven Development ������������������������������������������������������������������������������������������������������15 Behavior-Driven Development �����������������������������������������������������������������������������������������������15 JUnit ��������������������������������������������������������������������������������������������������������������������������������������16 Mockito ����������������������������������������������������������������������������������������������������������������������������������17 AssertJ ����������������������������������������������������������������������������������������������������������������������������������20 v Table of ConTenTs Testing in Spring Boot �����������������������������������������������������������������������������������������������������������������21 Logging ���������������������������������������������������������������������������������������������������������������������������������������21 Summary and Achievements ������������������������������������������������������������������������������������������������������23 Chapter 3: A Basic Spring Boot Application �����������������������������������������������������������25 Setting Up the Development Environment ����������������������������������������������������������������������������������26 The Skeleton Web App ����������������������������������������������������������������������������������������������������������������27 Spring Boot Autoconfiguration ����������������������������������������������������������������������������������������������������31 Three-Tier, Three-Layer Architecture ������������������������������������������������������������������������������������������36 Modeling Our Domain �����������������������������������������������������������������������������������������������������������������39 Domain Definition and Domain-Driven Design ����������������������������������������������������������������������39 Domain Classes ���������������������������������������������������������������������������������������������������������������������41 Business Logic ����������������������������������������������������������������������������������������������������������������������������43 What We Need �����������������������������������������������������������������������������������������������������������������������44 Random Challenges ���������������������������������������������������������������������������������������������������������������44 Attempt Verification ���������������������������������������������������������������������������������������������������������������48 Presentation Layer ����������������������������������������������������������������������������������������������������������������������52 REST ��������������������������������������������������������������������������������������������������������������������������������������52 REST APIs with Spring Boot ���������������������������������������������������������������������������������������������������53 Designing Our APIs ����������������������������������������������������������������������������������������������������������������55 Our First Controller ����������������������������������������������������������������������������������������������������������������56 How Automatic Serialization Works ���������������������������������������������������������������������������������������58 Testing Controllers with Spring Boot �������������������������������������������������������������������������������������61 Summary and Achievements ������������������������������������������������������������������������������������������������������73 Chapter 4: A Minimal Front End with React������������������������������������������������������������75 A Quick Intro to React and Node �������������������������������������������������������������������������������������������������76 Setting Up the Development Environment ����������������������������������������������������������������������������������76 The React Skeleton ���������������������������������������������������������������������������������������������������������������������78 A JavaScript Client ����������������������������������������������������������������������������������������������������������������������80 vi Table of ConTenTs The Challenge Component ����������������������������������������������������������������������������������������������������������81 The Main Structure of a Component ��������������������������������������������������������������������������������������85 Rendering ������������������������������������������������������������������������������������������������������������������������������87 Integration with the App ��������������������������������������������������������������������������������������������������������89 Running Our Front End for the First Time ������������������������������������������������������������������������������������90 Debugging �����������������������������������������������������������������������������������������������������������������������������������91 Adding CORS Configuration to the Spring Boot App ��������������������������������������������������������������������93 Playing with the Application ��������������������������������������������������������������������������������������������������������94 Deploying the React App �������������������������������������������������������������������������������������������������������������95 Summary and Achievements ������������������������������������������������������������������������������������������������������98 Chapter 5: The Data Layer ������������������������������������������������������������������������������������101 The Data Model �������������������������������������������������������������������������������������������������������������������������102 Choosing a Database ����������������������������������������������������������������������������������������������������������������105 SQL vs� NoSQL ���������������������������������������������������������������������������������������������������������������������105 H2, Hibernate, and JPA ��������������������������������������������������������������������������������������������������������106 Spring Boot Data JPA ����������������������������������������������������������������������������������������������������������������107 Dependencies and Autoconfiguration ����������������������������������������������������������������������������������107 Spring Boot Data JPA Technology Stack ������������������������������������������������������������������������������111 Data Source (Auto)configuration �����������������������������������������������������������������������������������������113 Entities ��������������������������������������������������������������������������������������������������������������������������������������115 Repositories ������������������������������������������������������������������������������������������������������������������������������120 Storing Users and Attempts ������������������������������������������������������������������������������������������������������124 Displaying Last Attempts ����������������������������������������������������������������������������������������������������������130 Service Layer �����������������������������������������������������������������������������������������������������������������������130 Controller Layer �������������������������������������������������������������������������������������������������������������������132 User Interface ����������������������������������������������������������������������������������������������������������������������138 Playing with the New Feature ���������������������������������������������������������������������������������������������������144 Summary and Achievements ����������������������������������������������������������������������������������������������������146 vii Table of ConTenTs Chapter 6: Starting with Microservices ����������������������������������������������������������������149 The Small Monolith Approach ���������������������������������������������������������������������������������������������������149 Why a Small Monolith? �������������������������������������������������������������������������������������������������������������150 The Problems with Microservices from Day Zero ����������������������������������������������������������������150 Small Monoliths Are for Small Teams ����������������������������������������������������������������������������������151 Embracing Refactoring ��������������������������������������������������������������������������������������������������������152 Planning the Small Monolith for a Future Split �������������������������������������������������������������������������152 New Requirements and Gamification����������������������������������������������������������������������������������������154 Gamification: Points, Badges, and Leaderboards ����������������������������������������������������������������155 Moving to Microservices �����������������������������������������������������������������������������������������������������������156 Independent Workflows �������������������������������������������������������������������������������������������������������157 Horizontal Scalability �����������������������������������������������������������������������������������������������������������158 Fine-Grained Nonfunctional Requirements �������������������������������������������������������������������������160 Other Advantages ����������������������������������������������������������������������������������������������������������������160 Disadvantages ���������������������������������������������������������������������������������������������������������������������161 Architecture Overview���������������������������������������������������������������������������������������������������������������163 Designing and Implementing the New Service �������������������������������������������������������������������������164 Interfaces ����������������������������������������������������������������������������������������������������������������������������165 The Spring Boot Skeleton for Gamification��������������������������������������������������������������������������165 Domain ��������������������������������������������������������������������������������������������������������������������������������166 Service ��������������������������������������������������������������������������������������������������������������������������������172 Data �������������������������������������������������������������������������������������������������������������������������������������183 Controller �����������������������������������������������������������������������������������������������������������������������������186 Configuration �����������������������������������������������������������������������������������������������������������������������188 Changes in Multiplication Microservice ������������������������������������������������������������������������������190 UI �����������������������������������������������������������������������������������������������������������������������������������������195 Playing with the System �����������������������������������������������������������������������������������������������������������201 Fault Tolerance ��������������������������������������������������������������������������������������������������������������������������203 The Challenges Ahead ���������������������������������������������������������������������������������������������������������������205 Tight Coupling ����������������������������������������������������������������������������������������������������������������������206 Synchronous Interfaces vs� Eventual Consistency ��������������������������������������������������������������206 viii Table of ConTenTs Transactions ������������������������������������������������������������������������������������������������������������������������211 API Exposure ������������������������������������������������������������������������������������������������������������������������213 Summary and Achievements ����������������������������������������������������������������������������������������������������213 Chapter 7: Event-Driven Architectures �����������������������������������������������������������������215 Core Concepts ���������������������������������������������������������������������������������������������������������������������������215 The Message Broker ������������������������������������������������������������������������������������������������������������216 Events and Messages ����������������������������������������������������������������������������������������������������������218 Thinking in Events ���������������������������������������������������������������������������������������������������������������219 Asynchronous Messaging ����������������������������������������������������������������������������������������������������223 Reactive Systems ����������������������������������������������������������������������������������������������������������������226 Pros and Cons of Going Event-Driven ���������������������������������������������������������������������������������������226 Messaging Patterns ������������������������������������������������������������������������������������������������������������������229 Publish-Subscribe ���������������������������������������������������������������������������������������������������������������230 Work Queues �����������������������������������������������������������������������������������������������������������������������230 Filtering �������������������������������������������������������������������������������������������������������������������������������230 Data Durability ���������������������������������������������������������������������������������������������������������������������230 Message Broker Protocols, Standards, and Tools ���������������������������������������������������������������������231 AMQP and RabbitMQ �����������������������������������������������������������������������������������������������������������������232 Overall Description ��������������������������������������������������������������������������������������������������������������233 Exchange Types and Routing �����������������������������������������������������������������������������������������������234 Message Acknowledgments and Rejection �������������������������������������������������������������������������236 Setting Up RabbitMQ �����������������������������������������������������������������������������������������������������������������237 Spring AMQP and Spring Boot���������������������������������������������������������������������������������������������������239 Solution Design �������������������������������������������������������������������������������������������������������������������������239 Adding the AMQP Starter �����������������������������������������������������������������������������������������������������241 Event Publishing from Multiplication �����������������������������������������������������������������������������������243 Gamification as a Subscriber ����������������������������������������������������������������������������������������������250 Analysis of Scenarios ����������������������������������������������������������������������������������������������������������������259 Happy Flow ��������������������������������������������������������������������������������������������������������������������������260 Gamification Becomes Unavailable �������������������������������������������������������������������������������������266 ix Table of ConTenTs The Message Broker Becomes Unavailable ������������������������������������������������������������������������269 Transactionality �������������������������������������������������������������������������������������������������������������������270 Scaling Up Microservices ����������������������������������������������������������������������������������������������������274 Summary and Achievements ����������������������������������������������������������������������������������������������������279 Chapter 8: Common Patterns in Microservice Architectures �������������������������������283 Gateway ������������������������������������������������������������������������������������������������������������������������������������284 Spring Cloud Gateway ���������������������������������������������������������������������������������������������������������286 The Gateway Microservice ��������������������������������������������������������������������������������������������������290 Changes in Other Projects ���������������������������������������������������������������������������������������������������294 Running the Gateway Microservice �������������������������������������������������������������������������������������296 Next Steps ���������������������������������������������������������������������������������������������������������������������������297 Health ����������������������������������������������������������������������������������������������������������������������������������������298 Spring Boot Actuator �����������������������������������������������������������������������������������������������������������299 Including Actuator in Our Microservices������������������������������������������������������������������������������302 Service Discovery and Load Balancing �������������������������������������������������������������������������������������304 Consul ����������������������������������������������������������������������������������������������������������������������������������310 Spring Cloud Consul ������������������������������������������������������������������������������������������������������������312 Spring Cloud Load Balancer ������������������������������������������������������������������������������������������������319 Service Discovery and Load Balancing in the Gateway �������������������������������������������������������323 Playing with Service Discovery and Load Balancing �����������������������������������������������������������327 Configuration per Environment �������������������������������������������������������������������������������������������������337 Configuration in Consul �������������������������������������������������������������������������������������������������������340 Spring Cloud Consul Config �������������������������������������������������������������������������������������������������341 Implementing Centralized Configuration �����������������������������������������������������������������������������343 Centralized Configuration in Practice ����������������������������������������������������������������������������������347 Centralized Logs �����������������������������������������������������������������������������������������������������������������������355 Log Aggregation Pattern ������������������������������������������������������������������������������������������������������356 A simple Solution for Log Centralization �����������������������������������������������������������������������������357 Consuming Logs and Printing Them ������������������������������������������������������������������������������������361 x

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.