Preface

• Who this book is for
• What this book covers
• To get the most out of this book
• Get in touch

1. Getting Started with Microservice Development Using Spring Boot FREE CHAPTER

2. Introduction to Microservices

• Technical requirements
• Getting the most out of this book – get to know your free benefits
• My way into microservices
• Enter microservices
• Defining a microservice
• Challenges with microservices
• Design patterns for microservices
• Software enablers
• Other important considerations
• Summary

3. Introduction to Spring Boot

• Technical requirements
• Spring Boot
• Convention over configuration and fat JAR files
• Code examples for setting up a Spring Boot application
• Migrating a Spring Boot 2 application
• Spring WebFlux
• Code examples of setting up a REST service
• Spring Cloud Stream
• Code examples for sending and receiving messages
• Docker
• Summary
• Questions

4. 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
• Summary
• Questions

5. Deploying Our Microservices Using Docker

• Technical requirements
• Introduction to Docker
• Running our first Docker commands
• Using Docker with one microservice
• Running the container in detached mode
• Managing a landscape of microservices using Docker Compose
• Automating tests of cooperating microservices
• Troubleshooting a test run
• Summary
• Questions

6. Adding an API Description Using OpenAPI

• Technical requirements
• Introduction to using springdoc-openapi
• Adding springdoc-openapi to the source code
• Building and starting the microservice landscape
• Trying out the OpenAPI documentation
• Summary
• Questions

7. Adding Persistence

• Technical requirements
• Chapter objectives
• 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
• Summary
• Questions

8. Developing Reactive Microservices

• Technical requirements
• Choosing between non-blocking synchronous APIs and event-driven asynchronous services
• Developing non-blocking synchronous REST APIs
• Developing event-driven asynchronous services
• Running manual tests of the reactive microservice landscape
• Running automated tests of the reactive microservice landscape
• Summary
• Questions

9. Leveraging Spring Cloud to Manage Microservices

10. Introduction to Spring Cloud

• Technical requirements
• The evolution of Spring Cloud
• Using Netflix Eureka for service discovery
• Using Spring Cloud Gateway as an edge server
• Using Spring Cloud Config for centralized configuration
• Using Resilience4j for improved resilience
• Using Micrometer Tracing and Zipkin for distributed tracing
• Summary
• Questions

11. Adding Service Discovery Using Netflix Eureka

• Technical requirements
• Introducing service discovery
• Setting up a Netflix Eureka server
• Connecting microservices to a Netflix Eureka server
• Setting up the configuration for development use
• Trying out the discovery service
• Starting up the Eureka server again
• Summary
• Questions

12. Using Spring Cloud Gateway to Hide Microservices behind an Edge Server

• Technical requirements
• Adding an edge server to our system landscape
• Setting up Spring Cloud Gateway
• Trying out the edge server
• Summary
• Questions

13. Securing Access to APIs

• Technical requirements
• Introduction to OAuth 2.0 and OpenID Connect
• Securing the system landscape
• Protecting external communication with HTTPS
• Securing access to the discovery server
• Adding a local authorization server
• Protecting APIs using OAuth 2.0 and OpenID Connect
• Testing with the local authorization server
• Testing with an external OpenID Connect provider
• Summary
• Questions

14. Centralized Configuration

• Technical requirements
• Introduction to Spring Cloud Config Server
• Setting up a config server
• Configuring clients of a config server
• Trying out Spring Cloud Config Server
• Summary
• Questions

15. Improving Resilience Using Resilience4j

• Technical requirements
• Introducing the Resilience4j resilience mechanisms
• Adding the resilience mechanisms to the source code
• Trying out the circuit breaker and retry mechanism
• Summary
• Questions

16. Understanding Distributed Tracing

• Technical requirements
• Introducing distributed tracing with Micrometer Tracing and Zipkin
• Adding distributed tracing to the source code
• Trying out distributed tracing
• Summary
• Questions

17. Developing Lightweight Microservices Using Kubernetes

18. 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 local Kubernetes cluster
• Summary
• Questions

19. Deploying Our Microservices to Kubernetes

• Technical requirements
• Replacing Netflix Eureka with Kubernetes Services
• Introducing how Kubernetes will be used
• Using Spring Boot’s support for graceful shutdown and probes for liveness and readiness
• Introducing Helm
• Deploying to Kubernetes for development and test
• Deploying to Kubernetes for staging and production
• Summary
• Questions

20. Implementing Kubernetes Features to Simplify the System Landscape

• Technical requirements
• Replacing the Spring Cloud Config Server
• Replacing the Spring Cloud Gateway
• Automating certificate provisioning
• Testing with Kubernetes ConfigMaps, Secrets, Ingress, and cert-manager
• Verifying that the microservices work without Kubernetes
• Summary
• Questions

21. Using a Service Mesh to Improve Observability and Management

• Technical requirements
• Introducing service meshes using Istio
• Simplifying the microservice landscape
• Replacing the Zipkin server with Istio’s Jaeger component
• 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 updates
• Running tests with Docker Compose
• Summary
• Questions

22. Centralized Logging with the EFK Stack

• Technical requirements
• Introducing Fluentd
• Deploying the EFK stack on Kubernetes
• Trying out the EFK stack
• Summary
• Questions

23. Monitoring Microservices

• Technical requirements
• Introduction to application monitoring using Prometheus and Grafana
• Changes in source code to collect application metrics
• Building and deploying the microservices
• Monitoring microservices using Grafana dashboards
• Setting up alarms in Grafana
• Summary
• Questions

24. Installation Instructions for macOS

• Technical requirements
• Installing the necessary tools
• Accessing the source code
• Summary

25. Installation Instructions for Microsoft Windows with WSL 2 and Ubuntu

• Technical requirements
• Installing the necessary tools
• Accessing the source code
• Summary

26. Native Compiled Java Microservices

• Technical requirements
• When to natively compile Java source code
• Introducing the GraalVM project
• Introducing Spring’s AOT engine
• Handling problems with native compilation
• Changes in the source code
• Testing and compiling Native Images
• Testing with Docker Compose
• Testing with Kubernetes
• Summary
• Questions

27. Unlock Your Book’s Exclusive Benefits

• How to unlock these benefits in three easy steps

28. Other Books You May Enjoy

29. Index