Table Of ContentMicroservices with Spring Boot
and Spring Cloud
Second Edition
Build resilient and scalable microservices using Spring
Cloud, Istio, and Kubernetes
Magnus Larsson
BIRMINGHAM—MUMBAI
Microservices with Spring Boot and Spring Cloud
Second Edition
Copyright © 2021 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system,
or transmitted in any form or by any means, without the prior written permission of the
publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the
information presented. However, the information contained in this book is sold without
warranty, either express or implied. Neither the author, nor Packt Publishing or its
dealers and distributors, will be held liable for any damages caused or alleged to have
been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the
companies and products mentioned in this book by the appropriate use of capitals.
However, Packt Publishing cannot guarantee the accuracy of this information.
Producer: Caitlin Meadows
Acquisition Editor – Peer Reviews: Saby Dsilva
Project Editor: Rianna Rodrigues
Content Development Editor: Lucy Wan
Copy Editor: Safis Editing
Technical Editor: Aniket Shetty
Proofreader: Safis Editing
Indexer: Pratik Shirodkar
Presentation Designer: Ganesh Bhadwalkar
First published: September 2019
Second edition: July 2021
Production reference: 1270721
Published by Packt Publishing Ltd.
Livery Place
35 Livery Street
Birmingham
B3 2PB, UK.
ISBN 978-1-80107-297-7
www.packt.com
Contributors
About the author
Magnus Larsson has been in the IT industry for 35 years, working as a consultant
for large companies in Sweden such as Volvo, Ericsson, and AstraZeneca. In the past,
he struggled with the challenges associated with distributed systems. Today, these
challenges can be handled with open source tools such as Spring Cloud, Kubernetes,
and Istio. Over the last years, Magnus has been helping customers use these tools
and has also given several presentations and written blog posts on the subject.
I would like to thank the following people:
Caitlin Meadows, Lucy Wan, Rianna Rodrigues, and Aniket Shetty from
Packt Publishing for their support.
To my wife, Maria, thank you for all of your support and understanding
throughout the process of writing this book.
About the reviewer
Kirill Merkushev is an engineer with a wide background in server-side
development, infrastructure, and test automation. Starting off as an intern in
Personal Services at Yandex, he quickly became a team lead, helping others to
automate any kind of development process. He worked on a number of internal
projects with amazing people who really love their job! In that kind of environment,
it was incredibly easy for him to learn new approaches, frameworks, and languages.
Given the size of Yandex and its services, it was a great chance to try out things at
scale. For example, early reactive libraries in Java, the freshly released Spring Boot,
the rock-solid Apache Camel, and golang.
During that time he became an open source expert, maintaining several projects
including the Jenkins GitHub plugin, Aerokube Selenoid, and dozens of small
libraries. After 7 years at Yandex, an opportunity to work in Germany in a small but
quite promising health-tech startup called Vivy brought him to Berlin, where new
challenges emerged, like how to build an event-sourced system, use encryption for
good, and operate an internal Apache Pulsar cluster.
Now he is a happy power user of Testcontainers, father of two kids, Brompton rider,
and a reviewer of this book!
I'd like to thank Sergei Egorov, who has shared tons of knowledge with me;
Andrei Andryashin, who helped me with my first server-side development
issues; Artem Eroshenko, who taught me how to give my first public talks;
obviously, my wife, who makes it possible for me to code and review books
in a comfortable environment any time of day; and my sons, who can
already understand that daddy is actually working when he sits all day long
in front of a PC!
Table of Contents
Preface xvii
Part I - Getting Started with Microservice Development
Using Spring Boot 1
Chapter 1: Introduction to Microservices 3
Technical requirements 3
My way into microservices 4
Benefits of autonomous software components 5
Challenges with autonomous software components 8
Enter microservices 9
A sample microservice landscape 10
Defining a microservice 11
Challenges with microservices 13
Design patterns for microservices 14
Service discovery 15
Problem 15
Solution 16
Solution requirements 16
Edge server 16
Problem 17
Solution 17
Solution requirements 17
Reactive microservices 18
Problem 18
Solution 18
Solution requirements 18
[ i ]
Table of Contents
Central configuration 19
Problem 19
Solution 19
Solution requirements 20
Centralized log analysis 20
Problem 20
Solution 21
Solution requirements 22
Distributed tracing 22
Problem 22
Solution 23
Solution requirements 23
Circuit breaker 24
Problem 24
Solution 24
Solution requirements 24
Control loop 25
Problem 25
Solution 26
Solution requirements 26
Centralized monitoring and alarms 26
Problem 26
Solution 26
Solution requirements 27
Software enablers 28
Other important considerations 29
Summary 31
Chapter 2: Introduction to Spring Boot 33
Technical requirements 34
Spring Boot 34
Convention over configuration and fat JAR files 35
Code examples for setting up a Spring Boot application 36
The magic @SpringBootApplication annotation 36
Component scanning 37
Java-based configuration 38
Spring WebFlux 39
Code examples of setting up a REST service 40
Starter dependencies 40
Property files 41
Sample RestController 42
springdoc-openapi 42
Spring Data 43
Entity 44
Repositories 46
Spring Cloud Stream 47
[ ii ]
Table of Contents
Code examples for sending and receiving messages 48
Docker 50
Summary 53
Questions 54
Chapter 3: Creating a Set of Cooperating Microservices 55
Technical requirements 56
Introducing the microservice landscape 56
Information handled by the microservices 57
Product service 57
Review service 57
Recommendation service 57
Product composite service 58
Infrastructure-related information 58
Temporarily replacing service discovery 58
Generating skeleton microservices 59
Using Spring Initializr to generate skeleton code 59
Setting up multi-project builds in Gradle 63
Adding RESTful APIs 65
Adding an API and a util project 65
The API project 66
The util project 68
Implementing our API 69
Adding a composite microservice 72
API classes 73
Properties 74
Integration component 74
Composite API implementation 78
Adding error handling 79
The global REST controller exception handler 80
Error handling in API implementations 80
Error handling in the API client 81
Testing APIs manually 82
Adding automated microservice tests in isolation 86
Adding semi-automated tests of a microservice landscape 89
Trying out the test script 90
Summary 91
Questions 92
Chapter 4: Deploying Our Microservices Using Docker 93
Technical requirements 94
Introduction to Docker 94
Running our first Docker commands 95
[ iii ]
Table of Contents
Challenges with running Java in Docker 97
Limiting available CPUs 98
Limiting available memory 99
Using Docker with one microservice 100
Changes in source code 101
Building a Docker image 105
Starting up the service 106
Running the container detached 108
Managing a landscape of microservices using Docker Compose 109
Changes in the source code 109
Starting up the microservice landscape 112
Automating tests of cooperating microservices 115
Troubleshooting a test run 118
Summary 120
Questions 120
Chapter 5: Adding an API Description Using OpenAPI 121
Technical requirements 122
Introduction to using springdoc-openapi 122
Adding springdoc-openapi to the source code 125
Adding dependencies to the Gradle build files 125
Adding OpenAPI configuration and general API documentation
to the ProductCompositeService 126
Adding API-specific documentation to the ProductCompositeService
interface 128
Building and starting the microservice landscape 132
Trying out the OpenAPI documentation 133
Summary 140
Questions 140
Chapter 6: Adding Persistence 141
Technical requirements 142
Chapter objectives 142
Adding a persistence layer to the core microservices 145
Adding dependencies 145
Storing data with entity classes 146
Defining repositories in Spring Data 149
Writing automated tests that focus on persistence 151
Using Testcontainers 151
Writing persistence tests 154
Using the persistence layer in the service layer 159
Logging the database connection URL 160
[ iv ]
Table of Contents
Adding new APIs 160
Calling the persistence layer from the service layer 161
Declaring a Java bean mapper 163
Updating the service tests 164
Extending the composite service API 166
Adding new operations in the composite service API 167
Adding methods in the integration layer 169
Implementing the new composite API operations 170
Updating the composite service tests 172
Adding databases to the Docker Compose landscape 173
The Docker Compose configuration 173
Database connection configuration 175
The MongoDB and MySQL CLI tools 177
Manual tests of the new APIs and the persistence layer 178
Updating the automated tests of the microservice landscape 181
Summary 183
Questions 184
Chapter 7: Developing Reactive Microservices 185
Technical requirements 186
Choosing between non-blocking synchronous APIs and event-driven
asynchronous services 186
Developing non-blocking synchronous REST APIs 188
An introduction to Project Reactor 188
Non-blocking persistence using Spring Data for MongoDB 190
Changes in the test code 191
Non-blocking REST APIs in the core services 192
Changes in the APIs 192
Changes in the service implementations 193
Changes in the test code 194
Dealing with blocking code 194
Non-blocking REST APIs in the composite services 197
Changes in the API 198
Changes in the service implementation 198
Changes in the integration layer 199
Changes in the test code 201
Developing event-driven asynchronous services 202
Handling challenges with messaging 202
Consumer groups 204
Retries and dead-letter queues 205
Guaranteed order and partitions 206
Defining topics and events 208
Changes in the Gradle build files 210
[ v ]
