The Art of Decoding Microservices An In-Depth Exploration of Modern Software Architecture (Sumit Bhatnagar, Roshan Mahant) (Z-Library)

Author: Sumit Bhatnagar, Roshan Mahant

其他

No Description

📄 File Format: PDF
💾 File Size: 5.8 MB
41
Views
0
Downloads
0.00
Total Donations

📄 Text Preview (First 20 pages)

ℹ️

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

📄 Page 1
The Art of Decoding Microservices An In-Depth Exploration of Modern Software Architecture — Sumit Bhatnagar Roshan Mahant
📄 Page 2
The Art of Decoding Microservices An In-Depth Exploration of Modern Software Architecture Sumit Bhatnagar Roshan Mahant
📄 Page 3
The Art of Decoding Microservices: An In-Depth Exploration of Modern Software Architecture ISBN-13 (pbk): 979-8-8688-1266-8 ISBN-13 (electronic): 979-8-8688-1267-5 https://doi.org/10.1007/979-8-8688-1267-5 Copyright © 2025 by Sumit Bhatnagar and Roshan Mahant 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: Melissa Duffy Development Editor: Laura Berendson Coordinating Editor: Gryffin Winkler Cover designed by eStudioCalamar 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 orders-ny@springer-sbm.com, 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 booktranslations@springernature.com; for reprint, paperback, or audio rights, please e-mail bookpermissions@springernature.com. 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 http://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 (https://github.com/Apress). For more detailed information, please visit https://www.apress.com/gp/services/source-code. If disposing of this product, please recycle the paper Sumit Bhatnagar Edison, NJ, USA Roshan Mahant Richardson, TX, USA
📄 Page 4
iii Table of Contents About the Authors ������������������������������������������������������������������������������xiii About the Technical Reviewer ������������������������������������������������������������xv Acknowledgments ����������������������������������������������������������������������������xvii Introduction ���������������������������������������������������������������������������������������xix Chapter 1: Evolution of Software Architecture �������������������������������������1 The Early Epoch: Structured Programming �����������������������������������������������������������2 The Golden Age: Object-Oriented Programming ���������������������������������������������������2 Component-Based Software Engineering (CBSE) �������������������������������������������������3 Monolithic Architecture �����������������������������������������������������������������������������������������3 Service-Oriented Architecture (SOA) ���������������������������������������������������������������������4 Microservices Architecture �����������������������������������������������������������������������������������4 Cloud-Native Architectures �����������������������������������������������������������������������������������5 Looking Forward: Serverless and Beyond �������������������������������������������������������������5 Monolithic Architecture �����������������������������������������������������������������������������������������6 Key Characteristics ������������������������������������������������������������������������������������������7 The Trouble with Monolithic Architectures ������������������������������������������������������8 When Monoliths Aren’t Monsters ��������������������������������������������������������������������9 Client-Server Architecture�����������������������������������������������������������������������������������10 Principles of Client-Server Architecture ��������������������������������������������������������11 Components of Client-Server Architecture ����������������������������������������������������11 Benefits of Client-Server Architecture �����������������������������������������������������������12
📄 Page 5
iv Common Patterns in Client-Server Architecture �������������������������������������������13 Real-World Examples ������������������������������������������������������������������������������������14 Service-Oriented Architecture �����������������������������������������������������������������������������15 Key Principles of SOA ������������������������������������������������������������������������������������16 Core Components of SOA�������������������������������������������������������������������������������18 Benefits of SOA ����������������������������������������������������������������������������������������������19 Challenges of SOA �����������������������������������������������������������������������������������������20 Real-World Use Cases �����������������������������������������������������������������������������������20 Best Practices for Implementing SOA ������������������������������������������������������������21 Microservices Architecture ���������������������������������������������������������������������������������23 Key Principles of Microservices ��������������������������������������������������������������������24 Core Components of Microservices ���������������������������������������������������������������25 Benefits of Microservices ������������������������������������������������������������������������������26 Challenges of Microservices �������������������������������������������������������������������������27 Microservices vs� Monolithic Architecture ����������������������������������������������������28 Microservices vs� SOA �����������������������������������������������������������������������������������29 Event-Driven Architecture (EDA) �������������������������������������������������������������������������30 Key Concepts of Event-Driven Architecture ���������������������������������������������������31 Types of Event-Driven Architectures��������������������������������������������������������������32 Benefits of Event-Driven Architecture �����������������������������������������������������������33 Challenges of Event-Driven Architecture �������������������������������������������������������34 Real-World Use Cases �����������������������������������������������������������������������������������35 Implementing Event-Driven Architecture�������������������������������������������������������36 Best Practices for Event-Driven Architecture ������������������������������������������������37 Serverless Architecture ���������������������������������������������������������������������������������������38 Key Concepts of Serverless Architecture ������������������������������������������������������39 Benefits of Serverless Architecture ���������������������������������������������������������������40 Table of ConTenTs
📄 Page 6
v Challenges of Serverless Architecture�����������������������������������������������������������41 Serverless vs� Traditional Architectures ��������������������������������������������������������42 Real-World Use Cases �����������������������������������������������������������������������������������42 Implementing Serverless Architecture ����������������������������������������������������������43 Best Practices for Serverless Architecture ����������������������������������������������������44 Microservices Comparison with Monolithic and SOA Architectures �������������������44 Conclusion ����������������������������������������������������������������������������������������������������������50 Chapter 2: Overview of Microservices ������������������������������������������������53 Definition and Core Concepts ������������������������������������������������������������������������������53 Key Characteristics of Microservices ������������������������������������������������������������54 But, Here’s the Trade-Off… ���������������������������������������������������������������������������55 Core Concepts of Microservices �������������������������������������������������������������������������56 1� Single Responsibility Principle ������������������������������������������������������������������56 2� Independence and Autonomy ��������������������������������������������������������������������64 3� Decentralized Data Management ��������������������������������������������������������������73 4� APIs and Communication ���������������������������������������������������������������������������80 5� Scalability ��������������������������������������������������������������������������������������������������86 6� Resilience and Fault Isolation ��������������������������������������������������������������������91 7� Continuous Delivery and DevOps���������������������������������������������������������������94 8� Polyglot Programming �������������������������������������������������������������������������������97 9� Service Discovery ������������������������������������������������������������������������������������103 10� Load Balancing ��������������������������������������������������������������������������������������111 11� Logging and Monitoring �������������������������������������������������������������������������118 12� Security �������������������������������������������������������������������������������������������������127 Conclusion ��������������������������������������������������������������������������������������������������������133 Table of ConTenTs
📄 Page 7
vi Chapter 3: Designing Microservices �������������������������������������������������135 1� Domain- Driven Design (DDD) ������������������������������������������������������������������������135 Defining Bounded Contexts �������������������������������������������������������������������������137 Modeling Around Business Capabilities ������������������������������������������������������137 Integration and Communication ������������������������������������������������������������������137 Autonomy and Decentralization �������������������������������������������������������������������138 Challenges ���������������������������������������������������������������������������������������������������138 Example: Online Retail Company �����������������������������������������������������������������139 Summary �����������������������������������������������������������������������������������������������������142 2� Bounded Contexts and Service Boundaries ��������������������������������������������������143 Understanding Bounded Contexts ���������������������������������������������������������������143 Principles for Defining Service Boundaries �������������������������������������������������144 Challenges in Defining Boundaries ��������������������������������������������������������������145 Summary �����������������������������������������������������������������������������������������������������146 3� Microservices Design Patterns ���������������������������������������������������������������������146 Key Microservices Design Patterns ������������������������������������������������������������������162 1� API Gateway Pattern ��������������������������������������������������������������������������������162 Summary �����������������������������������������������������������������������������������������������������165 2� Circuit Breaker Pattern ����������������������������������������������������������������������������165 Summary �����������������������������������������������������������������������������������������������������168 3� Event-Driven Architecture Pattern �����������������������������������������������������������168 Summary �����������������������������������������������������������������������������������������������������173 4� Sidecar Pattern ����������������������������������������������������������������������������������������173 Summary �����������������������������������������������������������������������������������������������������176 5� Backends for Frontends (BFF) Pattern�����������������������������������������������������177 Summary �����������������������������������������������������������������������������������������������������180 6� Security Pattern ���������������������������������������������������������������������������������������181 Summary �����������������������������������������������������������������������������������������������������185 Table of ConTenTs
📄 Page 8
vii 7� Observability Pattern �������������������������������������������������������������������������������185 Summary �����������������������������������������������������������������������������������������������������191 Conclusion ��������������������������������������������������������������������������������������������������������191 Chapter 4: Developing Microservices �����������������������������������������������193 Factors to Consider �������������������������������������������������������������������������������������������193 Technology Stack Components �������������������������������������������������������������������������194 Best Practices ����������������������������������������������������������������������������������������������195 Summary �����������������������������������������������������������������������������������������������������196 Building RESTful Services ���������������������������������������������������������������������������������196 Setting Up a Spring Boot Project �����������������������������������������������������������������197 Explanation of Annotations ��������������������������������������������������������������������������201 Summary �����������������������������������������������������������������������������������������������������204 Synchronous vs� Asynchronous Communication ����������������������������������������������204 Synchronous Communication ����������������������������������������������������������������������205 Asynchronous Communication ��������������������������������������������������������������������206 Choosing the Right Communication Style ���������������������������������������������������210 Summary �����������������������������������������������������������������������������������������������������210 Event-Driven Architecture and Messaging ��������������������������������������������������������210 Key Concepts, Benefits, and Drawbacks �����������������������������������������������������211 Summary �����������������������������������������������������������������������������������������������������218 Service Discovery and Load Balancing �������������������������������������������������������������219 Implementing Service Discovery in Java�����������������������������������������������������220 Explanation ��������������������������������������������������������������������������������������������������222 Summary �����������������������������������������������������������������������������������������������������223 API Gateways and Rate Limiting �����������������������������������������������������������������������224 Implementing Spring Cloud API Gateway ����������������������������������������������������225 Summary �����������������������������������������������������������������������������������������������������227 Table of ConTenTs
📄 Page 9
viii Resilience and Fault Tolerance �������������������������������������������������������������������������227 Implementing Resilience4j ��������������������������������������������������������������������������228 In This Example �������������������������������������������������������������������������������������������231 Summary �����������������������������������������������������������������������������������������������������233 Conclusion ��������������������������������������������������������������������������������������������������������233 Chapter 5: Testing, Deploying, and Scaling Microservices ���������������235 Unit Testing �������������������������������������������������������������������������������������������������������236 Example: Unit Testing with JUnit and Mockito ���������������������������������������������236 Breakdown of the Code �������������������������������������������������������������������������������238 Integration Testing for Microservices in Java ���������������������������������������������������239 Example: Integration Testing with Spring Boot ��������������������������������������������240 Short Explanation ����������������������������������������������������������������������������������������242 End-to-End Testing for Microservices in Java���������������������������������������������������242 Example: End-to-End Testing �����������������������������������������������������������������������243 Explanation ��������������������������������������������������������������������������������������������������244 Summary �����������������������������������������������������������������������������������������������������244 Contract Testing ������������������������������������������������������������������������������������������������244 Why Contract Testing Matters ����������������������������������������������������������������������245 The Challenges ��������������������������������������������������������������������������������������������245 Example: Contract Testing Using Pact ���������������������������������������������������������246 Explanation ��������������������������������������������������������������������������������������������������252 Summary �����������������������������������������������������������������������������������������������������253 Deploying and Scaling Microservices ���������������������������������������������������������������253 Kubernetes for Orchestration ����������������������������������������������������������������������255 Example: Kubernetes with Docker ���������������������������������������������������������������256 Example: Kubernetes Deployment ���������������������������������������������������������������257 Explanation ��������������������������������������������������������������������������������������������������259 Table of ConTenTs
📄 Page 10
ix Summary �����������������������������������������������������������������������������������������������������260 Scaling Microservices ���������������������������������������������������������������������������������261 Summary �����������������������������������������������������������������������������������������������������262 Conclusion ��������������������������������������������������������������������������������������������������������262 Chapter 6: Microservices Security, Monitoring, and Maintenance ������������������������������������������������������������������������������265 Authentication and Authorization ����������������������������������������������������������������������265 Why It Matters ���������������������������������������������������������������������������������������������266 Ways of Authentication ��������������������������������������������������������������������������������267 Ways of Authorization ����������������������������������������������������������������������������������267 Implementing Authentication and Authorization in Java �����������������������������268 Summary �����������������������������������������������������������������������������������������������������271 Securing Service- to-Service Communication ���������������������������������������������������272 Understanding What We Need: Service-to- Service Communication Security �������������������������������������������������������������������������������������������������������272 Summary �����������������������������������������������������������������������������������������������������273 Centralized Logging with ELK Stack �����������������������������������������������������������������274 The ELK Stack at Work ��������������������������������������������������������������������������������274 Summary �����������������������������������������������������������������������������������������������������279 Monitoring Health and Performance �����������������������������������������������������������������280 Implementing Health Checks with Spring Boot Actuator �����������������������������281 Explanation ��������������������������������������������������������������������������������������������������283 Actuator with Kubernetes ����������������������������������������������������������������������������285 How They Work in Kubernetes ���������������������������������������������������������������������287 Metrics Collection and Monitoring with Prometheus and Grafana ��������������������287 Setting Up Prometheus ��������������������������������������������������������������������������������288 Visualizing Metrics with Grafana �����������������������������������������������������������������290 Example Java Application Metrics Dashboard in Grafana ���������������������������290 Summary �����������������������������������������������������������������������������������������������������293 Table of ConTenTs
📄 Page 11
x Versioning and Backward Compatibility �����������������������������������������������������������294 Implementing Versioning and Backward Compatibility �������������������������������295 Summary �����������������������������������������������������������������������������������������������������297 Conclusion ��������������������������������������������������������������������������������������������������������297 Chapter 7: Lessons from Case Studies, Avoiding Pitfalls, and Shaping the Future ��������������������������������������������������������������������299 Case Study 1: Netflix �����������������������������������������������������������������������������������������299 Case Study 2: Amazon ���������������������������������������������������������������������������������������301 Lessons Learned from Successful Implementations �����������������������������������302 Antipatterns and Common Pitfalls ��������������������������������������������������������������������305 Future of Microservices ������������������������������������������������������������������������������������309 Trends and Predictions ��������������������������������������������������������������������������������309 Microservices in AI and IoT �������������������������������������������������������������������������������314 What Are the Advantages of Microservices for AI and IoT? �������������������������315 Some Challenges �����������������������������������������������������������������������������������������316 Conclusion ��������������������������������������������������������������������������������������������������������317 Chapter 8: Conclusion and Quick Recap �������������������������������������������319 Basic Principles and Ideas ��������������������������������������������������������������������������������319 Development and Distinctions from Classical Architectures ����������������������������320 Design and Development ����������������������������������������������������������������������������������320 Deployment and Security ����������������������������������������������������������������������������������320 Testing and Monitoring �������������������������������������������������������������������������������������321 Practices and Practical Case Studies����������������������������������������������������������������321 Next Future Trends ��������������������������������������������������������������������������������������������321 One Last Thing to Say ���������������������������������������������������������������������������������������322 Table of ConTenTs
📄 Page 12
xi Appendix A: Glossary ������������������������������������������������������������������������325 Appendix B: Closure and Final Thoughts ������������������������������������������333 Index �������������������������������������������������������������������������������������������������337 Table of ConTenTs
📄 Page 13
xiii About the Authors Sumit Bhatnagar has nearly two decades of hands-on experience in the IT industry, serving as a visionary leader and a respected authority in the realm of modern software architecture. Specializing in J2EE, microservices, and cloud- based applications, Sumit has a proven track record of delivering cutting-edge solutions in the financial domain. An accomplished project leader, Sumit combines deep technical expertise with strategic insight, seamlessly bridging the gap between innovation and implementation. His contributions to the industry have earned him prestigious accolades at a global platform. As a distinguished member of the Forbes Technology Council and IEEE, Sumit is at the forefront of technological advancement, continually shaping the future of software development. His extensive portfolio of published research papers and thought leadership in renowned journals underscores his commitment to pushing the boundaries of what’s possible. In The Art of Decoding Microservices: An In-Depth Exploration of Modern Software Architecture, Sumit leverages his vast experience and deep understanding to provide readers with a comprehensive guide to mastering microservices. Whether you’re a seasoned developer or an aspiring architect, this book is your gateway to understanding and implementing robust, scalable, and resilient software solutions.
📄 Page 14
xiv Roshan Mahant is a seasoned expert in strategizing and designing IT solutions, with a strong emphasis on successful execution. As a Senior Technical Consultant at Launch IT Corp, he specializes in e-governance platform enhancements, particularly in public sector IT modernization using the microservices architecture, and the Amanda e-governance licensing platform. Over his 15-year career, Roshan has mastered holistic analysis, systems integration, architecture design, and strategic consulting, enabling the transformation of critical governance functions across various state agencies. His work has significantly impacted several government boards, including the Iowa Board of Nursing and the Michigan Gaming Control Board. Before joining Launch IT Corp, Roshan served as the Director of Access Technologies, where he developed innovative mentoring techniques and software products. With a master’s degree in CAD/CAM from Nagpur University, Roshan continues to contribute to the field through research papers, conference reviews, and technical book critiques, earning him various esteemed memberships and awards. abouT The auThors
📄 Page 15
xv Andres Sacco has been working as a developer since 2007 in different languages, including Java, PHP, Node.js, Scala, and Kotlin. His background is mostly in Java and the libraries or frameworks associated with this language. In most of the companies he worked for, he researched new technologies to improve the performance, stability, and quality of the applications of each company. Recently, he published a book on Apress about the latest version of Scala. He also published a set of theoretical-practical projects about uncommon testing methods, such as architecture tests and chaos engineering. About the Technical Reviewer
📄 Page 16
xvii Acknowledgments Writing this book has been a journey filled with hard work, learning, and inspiration, and it wouldn’t have been possible without the incredible support and encouragement I’ve received along the way from my family and friends. To my son, Aaren—this book is dedicated to you. Your curiosity, resilience, and boundless enthusiasm are my greatest motivation. May you always explore the world with a sense of wonder and creativity, finding your own path just as I have found mine. Finally, to every reader of this book: may it serve as a stepping stone in your journey through the world of microservices. Here’s to the continuous pursuit of knowledge and growth. —Sumit This book is a culmination of countless hours of dedication, exploration, and passion for the world of microservices. I am deeply grateful to all those who have contributed to my journey and to the development of this work. This book is dedicated to my beloved son, Ved. Your bright spirit, determination, and joyful energy inspire me every day. May you follow your dreams with the same passion and commitment that brought this book to life. I am also immensely grateful to my family and friends whose patience and support have been unwavering throughout this journey. Thank you all for helping make this book a reality. —Roshan
📄 Page 17
xix Introduction Purpose of the Book Are you getting started with software development and architecture and feeling overwhelmed by the microservices landscape—or maybe you have been developing software for years and want to improve your understanding of the world of microservices? This book is for you. Whether you are looking for an introduction or are already knee-deep in this landscape, The Art of Decoding Microservices: An In-Depth Exploration of Modern Software Architecture cuts through the jargon and complexity to provide a comprehensive introduction to microservices that you can understand and apply. The aim is to educate developers, architects, DevOps engineers, and IT leaders about how to develop and build microservices—whether it’s a greenfield project or a renovation of an existing system. We’ll teach you the basics, dive into advanced patterns, and point out common failures so you can avoid the headaches. Underpinning the book is the belief that microservices are more than a mere technical wave: they are business enablers, allowing you to be more agile, more scalable, and better equipped for digital transformation. You’ll certainly come away with insight into best practice, but also confidence in your ability to make better decisions, to innovate, and to manage in this ever-changing world of software. Designed to be your trusted companion, this book is theory-rich and chock-full of hands-on examples of how to design and build systems. Whether you’re a novice microservices player looking to learn the ropes or an experienced systems professional seeking to tune your systems, you’ll find a host of tools and practical guidance to help you achieve your architectural goals… and maybe even have some fun along the way.
📄 Page 18
xx Who Should Read This Book? If you’re involved in software development and architecture and need to cut through the buzz, The Art of Decoding Microservices: An In-Depth Exploration of Modern Software Architecture is the book you’ve been looking for. It’s both a beginner’s guide and a Swiss Army knife, a handy reference for those making their first foray into microservices as well as a refreshing and clear text for those who have been around the block a couple of times already. From novice to microservices seasoned veteran, there is something for everyone in this book. Newcomers will benefit from an accessible, jargon- free introduction to microservices, while seasoned practitioners will find advanced patterns and tools that take their systems to the next level. You’ll learn how to build scalable, resilient, and maintainable systems, based on real-world examples and case studies. You’ll learn the nitty-gritty of CI/CD pipelines, container orchestration, and service monitoring, so you have a playbook for keeping microservices running. You’ll also receive both strategic advice and practical tips for going from monolith to microservices, so you’ll be better prepared to tackle your own migration. This book bridges the gap between theory and practice, providing a wealth of information for study and innovation. You will be equipped to assess the technical and business pros and cons of adopting microservices so you can make the right decisions for your organization and its future. Whether you’re in the trenches of code, leading a team, or making strategic decisions about your company’s tech stack, The Art of Decoding Microservices will help you gain the knowledge you need to succeed in this fast-paced world of software development. It’s helpful to have a basic understanding of software development and architecture before jumping into the deep end—but don’t worry; we’ll take you from novice to ninja in no time. Enjoy! InTroduCTIon
📄 Page 19
xxi What You Will Learn In this book, you will learn: What are microservices? And why should you care? The first few chapters of this book answer those questions and more, explaining what exactly a microservice is, how it differs from a monolithic architecture, and why adopting this style of software design can bring tremendous value to your organization. Designing Microservices: You’ll learn important design principles for microservices, including how to decompose a monolith into microservices and how to design for failure. Microservices Communication: Learn about the various “speaking styles” of a microservices architecture, such as the difference between synchronous and asynchronous communication and when to use each. Deployment and Scaling: What is containerization? How can we orchestrate applications with packages such as Kubernetes? How can we scale microservices for more load? Security and Monitoring: How to secure your microservices in a distributed system, and how to monitor the health of your system and the performance of your services. InTroduCTIon
📄 Page 20
xxii Case Studies: Real-world examples of businesses that made the move to a microservices architecture, what the problems were, and how they dealt with them. Best Practices and Antipatterns: The book ends with a chapter on best practices and antipatterns you should have in mind when working with microservices. By the end of the book, the reader will have a solid understanding of microservices architecture and will be ready to apply these ideas to design, build, and run highly scalable, resilient, and efficient microservices-based systems. How to Use This Book Following along with the text, this book will take you on a tour of microservices, from the foundations of the architecture to its most complex twists and turns. Whether you’re getting started with microservices or are already a veteran, here’s how to get the most out of this book. Start at the Beginning for a Complete Understanding: If you’re just beginning with microservices, please start at Chapter 1. No skipping ahead. Each chapter follows on from the previous one, in a natural progression that will ease your way into the more difficult material later on. But Don’t Miss the Big Picture: The book is designed to walk you through from basics to more advanced topics. You don’t build a house by starting with the roof. As you progress through the logical flow, you’ll build the foundation before you venture into the deep waters of microservices. InTroduCTIon
The above is a preview of the first 20 pages. Register to read the complete e-book.

💝 Support Author

0.00
Total Amount (¥)
0
Donation Count

Login to support the author

Login Now
Back to List