Hands-On Microservices with Spring Boot and Spring Cloud: Build and deploy Java microservices using Spring Cloud, Istio, and Kubernetes

My way into microservices

Defining a microservice

Challenges with microservices

Design patterns for microservices

Software enablers

Other important considerations

Introduction to Spring Boot

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

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

Challenges with running Java in Docker

Introduction to 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

Introduction to using SpringFox

Changes in the source code

Building and starting the microservice landscape

Trying out the Swagger documentation

Adding Persistence

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

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

Section 2: Leveraging Spring Cloud to Manage Microservices

Introduction to Spring Cloud

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

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

Adding an edge server to our system landscape

Setting up a Spring Cloud Gateway

Trying out the edge server

Securing Access to APIs

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

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

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

Introducing distributed tracing with Spring Cloud Sleuth and Zipkin

Adding distributed tracing to the source code

Trying out distributed tracing

Section 3: Developing Lightweight Microservices Using Kubernetes

Introduction to Kubernetes

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

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

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

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

Deploying the EFK stack on Kubernetes

Configuring Fluentd

Trying out the EFK stack

Monitoring Microservices

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