Book Image

Hands-On Microservices with Spring Boot and Spring Cloud

By : Magnus Larsson

Book Image

Hands-On Microservices with Spring Boot and Spring Cloud

By: Magnus Larsson

Overview of this book

Microservices architecture allows developers to build and maintain applications with ease, and enterprises are rapidly adopting it to build software using Spring Boot as their default framework. With this book, you’ll learn how to efficiently build and deploy microservices using Spring Boot. This microservices book will take you through tried and tested approaches to building distributed systems and implementing microservices architecture in your organization. Starting with a set of simple cooperating microservices developed using Spring Boot, you’ll learn how you can add functionalities such as persistence, make your microservices reactive, and describe their APIs using Swagger/OpenAPI. As you advance, you’ll understand how to add different services from Spring Cloud to your microservice system. The book also demonstrates how to deploy your microservices using Kubernetes and manage them with Istio for improved security and traffic management. Finally, you’ll explore centralized log management using the EFK stack and monitor microservices using Prometheus and Grafana. By the end of this book, you’ll be able to build microservices that are scalable and robust using Spring Boot and Spring Cloud.

Title Page

Copyright and Credits

Copyright and Credits

Hands-On Microservices with Spring Boot and Spring Cloud

About Packt

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Introduction to Microservices

Introduction to Microservices

Technical requirements

My way into microservices

Defining a microservice

Challenges with microservices

Design patterns for microservices

Software enablers

Other important considerations

Introduction to Spring Boot

Introduction to Spring Boot

Technical requirements

Learning about Spring Boot

Beginning with Spring WebFlux

Exploring SpringFox

Understanding Spring Data

Understanding Spring Cloud Stream

Learning about Docker

Creating a Set of Cooperating Microservices

Creating a Set of Cooperating Microservices

Technical requirements

Introducing the microservice landscape

Generating skeleton microservices

Adding RESTful APIs

Adding a composite microservice

Adding error handling

Testing APIs manually

Adding automated microservice tests in isolation

Adding semi-automated tests of a microservice landscape

Deploying Our Microservices Using Docker

Deploying Our Microservices Using Docker

Technical requirements

Introduction to Docker

Challenges with running Java in Docker

Using Docker with one microservice

Managing a landscape of microservices using Docker Compose

Testing them all together automatically

Adding an API Description Using OpenAPI/Swagger

Adding an API Description Using OpenAPI/Swagger

Technical requirements

Introduction to using SpringFox

Changes in the source code

Building and starting the microservice landscape

Trying out the Swagger documentation

Adding Persistence

Adding Persistence

Technical requirements

But first, let's see where we are heading

Adding a persistence layer to the core microservices

Writing automated tests that focus on persistence

Using the persistence layer in the service layer

Extending the composite service API

Adding databases to the Docker Compose landscape

Manual tests of the new APIs and the persistence layer

Updating the automated tests of the microservice landscape

Developing Reactive Microservices

Developing Reactive Microservices

Technical requirements

Choosing between non-blocking synchronous APIs and event-driven asynchronous services

Developing non-blocking synchronous REST APIs using Spring

Developing event-driven asynchronous services

Running manual tests of the reactive microservice landscape

Running automated tests of the reactive microservice landscape

Introduction to Spring Cloud

Introduction to Spring Cloud

Technical requirements

The evolution of Spring Cloud

Using Netflix Eureka as a discovery service

Using Spring Cloud Gateway as an edge server

Using Spring Cloud Config for centralized configuration

Using Resilience4j for improved resilience

Using Spring Cloud Sleuth and Zipkin for distributed tracing

Adding Service Discovery Using Netflix Eureka and Ribbon

Adding Service Discovery Using Netflix Eureka and Ribbon

Technical requirements

Introducing service discovery

Setting up a Netflix Eureka server

Connecting microservices to a Netflix Eureka server

Setting up configuration for use in the development process

Trying out the discovery service

Using Spring Cloud Gateway to Hide Microservices Behind an Edge Server

Using Spring Cloud Gateway to Hide Microservices Behind an Edge Server

Technical requirements

Adding an edge server to our system landscape

Setting up a Spring Cloud Gateway

Trying out the edge server

Securing Access to APIs

Securing Access to APIs

Technical requirements

Introduction to OAuth 2.0 and OpenID Connect

Securing the system landscape

Adding an authorization server to our system landscape

Protecting external communication with HTTPS

Securing access to the discovery service, Netflix Eureka

Authenticating and authorizing API access using OAuth 2.0 and OpenID Connect

Testing with the local authorization server

Testing with an OpenID Connect provider – Auth0

Centralized Configuration

Centralized Configuration

Technical requirements

Introduction to the Spring Cloud Configuration server

Setting up a config server

Configuring clients of a config server

Structuring the configuration repository

Trying out the Spring Cloud Configuration server

Improving Resilience Using Resilience4j

Improving Resilience Using Resilience4j

Technical requirements

Introducing the Resilience4j circuit breaker and retry mechanism

Adding a circuit breaker and retry mechanism to the source code

Trying out the circuit breaker and retry mechanism

Understanding Distributed Tracing

Understanding Distributed Tracing

Technical requirements

Introducing distributed tracing with Spring Cloud Sleuth and Zipkin

Adding distributed tracing to the source code

Trying out distributed tracing

Introduction to Kubernetes

Introduction to Kubernetes

Technical requirements

Introducing Kubernetes concepts

Introducing Kubernetes API objects

Introducing Kubernetes runtime components

Creating a Kubernetes cluster using Minikube

Trying out a sample deployment

Managing a Kubernetes cluster

Deploying Our Microservices to Kubernetes

Deploying Our Microservices to Kubernetes

Technical requirements

Replacing Netflix Eureka with Kubernetes services

Introducing Kustomize

Deploying to Kubernetes for development and test

Deploying to Kubernetes for staging and production

Performing a rolling upgrade

Rolling back a failed deployment

Implementing Kubernetes Features as an Alternative

Implementing Kubernetes Features as an Alternative

Technical requirements

Replacing the Spring Cloud Config Server

Replacing the Spring Cloud Gateway

Testing with Kubernetes ConfigMaps, secrets, and ingress resource

Automating the provision of certificates

Verifying that microservices work without Kubernetes

Using a Service Mesh to Improve Observability and Management

Using a Service Mesh to Improve Observability and Management

Technical requirements

Introduction to service mesh using Istio

Deploying Istio in a Kubernetes cluster

Creating the service mesh

Observing the service mesh

Securing a service mesh

Ensuring that a service mesh is resilient

Performing zero-downtime deployments

Running tests with Docker Compose

Centralized Logging with the EFK Stack

Centralized Logging with the EFK Stack

Technical requirements

Configuring Fluentd

Deploying the EFK stack on Kubernetes

Trying out the EFK stack

Monitoring Microservices

Monitoring Microservices

Technical requirements

Introduction to performance monitoring using Prometheus and Grafana

Changes in source code for collecting application metrics

Building and deploying the microservices

Monitoring microservices using Grafana dashboards

Setting up alarms in Grafana

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Using Spring Cloud Sleuth and Zipkin for distributed tracing

To understand what is going on in a distributed system such as a system landscape of cooperating microservices, it is crucial to be able to track and visualize how requests and messages flow between microservices when processing an external call to the system landscape.

Refer to Chapter 1, Introduction to Microservices, the Distributed tracing section, for more information on this subject.

Spring Cloud comes with Spring Cloud Sleuth, which can mark requests and messages/events that are part of the same processing flow with a common correlation ID.

Spring Cloud Sleuth can also decorate log messages with correlation IDs to make it easier to track log messages from different microservices that come from the same processing flow. Zipkin is a distributed tracing system...