Mastering Spring Boot 2.0 : build modern, cloud-native, and distributed systems using Spring Boot. / Dinesh Rajput.

Format:

Book

Author/Creator:

Rajput, Dinesh, author.

Language:

English

Subjects (All):

Spring (Software framework).

Computer software--Development.

Computer software.

Web applications--Development.

Web applications.

Physical Description:

1 online resource (1 volume) : illustrations

Edition:

1st edition

Place of Publication:

Birmingham ; Mumbai : Packt, [2018]

System Details:

text file

Summary:

Learn to develop, test, and deploy your Spring Boot distributed application and explore various best practices. About This Book Build and deploy your microservices architecture in the cloud Build event-driven resilient systems using Hystrix and Turbine Explore API management tools such as KONG and API documentation tools such as Swagger Who This Book Is For The book is targeted at experienced Spring and Java developers who have a basic knowledge of working with Spring Boot. The reader should be familiar with Spring Boot basics, and aware of its benefits over traditional Spring Framework-based applications. What You Will Learn Build logically structured and highly maintainable Spring Boot applications Configure RESTful microservices using Spring Boot Make the application production and operation-friendly with Spring Actuator Build modern, high-performance distributed applications using cloud patterns Manage and deploy your Spring Boot application to the cloud (AWS) Monitor distributed applications using log aggregation and ELK In Detail Spring is one of the best frameworks on the market for developing web, enterprise, and cloud ready software. Spring Boot simplifies the building of complex software dramatically by reducing the amount of boilerplate code, and by providing production-ready features and a simple deployment model. This book will address the challenges related to power that come with Spring Boot's great configurability and flexibility. You will understand how Spring Boot configuration works under the hood, how to overwrite default configurations, and how to use advanced techniques to prepare Spring Boot applications to work in production. This book will also introduce readers to a relatively new topic in the Spring ecosystem – cloud native patterns, reactive programming, and applications. Get up to speed with microservices with Spring Boot and Spring Cloud. Each chapter aims to solve a specific problem or teach you a useful skillset. By the end of this book, you will be proficient in building and deploying your Spring Boot application. Style and approach The book takes a practical, example-driven approach to teaching you all the advanced features of Spring Boot 2.0 Downloading the example code for this book You can download the example code files for all Packt books you have purchased from your account at http://www.PacktPub.com. If you purchased this book elsewhere, you can visit http://www.PacktPub.com/support and register to have...

Contents:

Cover

Title Page

Copyright and Credits

Dedication

Packt Upsell

Contributors

Table of Contents

Preface

Chapter 1: Getting Started with Spring Boot 2.0

Introducing Spring Boot

Simplifying Spring application development using Spring Boot

The essential key components of Spring Boot

Spring Boot Starters

Spring Boot Starter Parent POM

Spring Boot auto-configuration

Enabling Spring Boot auto-configuration

Spring Boot CLI

Spring Boot Actuator

Setting up a Spring Boot workspace

Setting up Spring Boot with Maven

Setting up Spring Boot with Gradle

Developing your first Spring Boot application

Using a web interface for Spring Initializr

Creating a Spring Boot project using the STS IDE

Implementing the REST service

New features in Spring Boot 2.0

Summary

Chapter 2: Customizing Auto-Configuration in Spring Boot Application

Understanding auto-configuration

Learning how auto-configuration works

Customizing Spring Boot

Customizing using Spring Boot properties

Replacing generated beans

Disabling specific auto-configuration classes

Changing a library's dependencies

Externalizing configuration with properties

Order of evaluation for overridden properties

Renaming application.properties in the Spring application

Externally configuring application properties

Using the @EnableConfigurationProperties annotation

Fine-tuning with logging

Logging output

Using YAML for configuration

YAML for properties

Multiple profiles inside a single YAML file

Customizing application error pages

Chapter 3: Getting Started with Spring CLI and Actuator

Getting started with using Spring Boot CLI

Installing the Spring Boot CLI

Manually installing from a downloaded distribution

Installation with SDKMAN!

Installing with OSX Homebrew.

MacPorts installation

Command-line completion

Using the Initializr with the Spring Boot CLI

Spring Boot Actuator - taking Application's Insights

Enabling Spring Boot's Actuator in your application

Analyzing the Actuator's endpoints

Exposing configuration details

Exposing metrics endpoints

Exposing application information

Shutting down your application

Customizing your Actuator endpoints

Enabling or disabling endpoints

Changing endpoint IDs

Changing the sensitivity of the Actuator's endpoints

Writing custom health indicators

Creating a custom endpoint

Securing the Actuator endpoints

The Actuator with Spring Boot 2.X

Chapter 4: Getting Started with Spring Cloud and Configuration

Cloud-native application architecture

Microservices architecture

Microservice benefits

Microservice challenges

Introduction to Spring Cloud

Building blocks of the cloud and microservice applications

Usages of Spring Cloud

Configuring the Spring Cloud application

Creating the configuration producer Spring Cloud Config Server

Project setup and dependencies

Implementing Cloud Config Server

Configuring the application.properties file

Creating a Git repository as configuration storage

Running your configuration application

Configuring multiple repositories using patterns

Authentication

Force-pull property

Creating the configuration consumer Spring Cloud Config client

Chapter 5: Spring Cloud Netflix and Service Discovery

Introduction to Spring Cloud Netflix

The need for Service Discovery in the microservices architecture

Implementing Service Discovery - Eureka Server

The Maven build configuration file

The Gradle build configuration file

Enabling the Eureka server as a Discovery Service server.

Implementing Service Discovery - Eureka clients

Adding the Maven dependencies configuration

The Gradle build configuration

Registering a client with Eureka

Consuming the REST service

Using EurekaClient

Using DiscoveryClient

Client-side load balancing using Netflix Ribbon

Using the registry-aware Spring Cloud Netflix FeignClient client

Chapter 6: Building Spring Boot RESTful Microservice

Microservices with Spring Boot

Brief introduction to bootstrap.yml and application.yml

A simple microservice example

Creating a discovery service

Creating a microservice (the Producer)

Creating microservice consumers

Load-balanced RestTemplate

Brief introduction to Spring Data

Apache Ignite repository

Spring Data MongoDB

Spring MongoDB data highlights

Spring Data JPA

Chapter 7: Creating API Gateway with Netflix Zuul Proxy

The need for an API Gateway pattern

Pros of the API Gateway pattern

Cons of the API Gateway pattern

API Gateway pattern components

Implementing API Gateway using Netflix Zuul Proxy

Including Zuul using Maven dependency

Enabling the Zuul service proxy

Configuring Zuul properties

Adding Zuul filters

Registering Zuul filters

Chapter 8: Simplify HTTP API with Feign Client

Declarative REST client - Feign basics

Including Feign in the cloud application

Overriding Feign defaults

Creating Feign clients

Feign inheritance support

Multiple interfaces

Advanced usage of the Feign client

Feign logging

Exception handling

Custom encoders and decoders

Custom encoder

Custom decoder

Feign and Hystrix

Unit testing Feign clients

Chapter 9: Building Event-Driven and Asynchronous Reactive Systems

Event-driven architecture patterns

Mediator topology

Broker topology.

Introduction to reactive programming

Spring Reactive

ReactiveX

Introduction to Command Query Responsibility Segregation

Introduction to the Event Sourcing pattern

Introduction to Eventual consistency

Building an event-driven Reactive Asynchronous System

Introducing Spring Cloud Streaming

Adding Kafka to your application

Installing and running Kafka

Configuration properties for Kafka

Service used to write to Kafka

Rest API controller

Listening to a Kafka topic

Chapter 10: Building Resilient Systems Using Hystrix and Turbine

Circuit-breaker pattern

Using the Hystrix library with a reference implementation

Configuring Hystrix in your application

Maven dependency

Enabling circuit-breaker

Adding the Hystrix annotation in services

Error propagation

Implementing a REST controller in customer service

Building and testing customer service

Customizing the default configuration

Hystrix Metrics Stream

Implementing Hystrix Dashboard in our project

Turbine dashboard

Turbine stream

REST consumer with Hystrix and Feign

Chapter 11: Testing Spring Boot Application

Test-driven development

Unit testing

Advantages

Disadvantages

Other mock libraries

Integration testing

Benefits of testing with Spring

Activating profiles for a test class

JUnit tests for the Spring Boot application

Using Mockito for mocking services

Postman for testing RESTful service contracts

Chapter 12: Containerizing Microservice

Introducing containers to the microservice architecture

Virtual machines versus containers

Benefits of a container-oriented approach

Drawbacks of a container-oriented approach

Key concepts of the containers-oriented approach

Getting started with Docker

Installing Docker

Installing Docker on Linux.

Installing Docker on Windows

Docker commands

Container-specific commands

Docker architecture

Docker Engine

Docker container

Writing Dockerfile

Dockerizing any Spring Boot application

Creating a Docker image using Maven

Getting started with Docker Compose

Installing Docker Compose

Using Docker Compose

Writing a docker-compose file

Orchestration using a docker-compose file

Scaling containers using docker-compose and load balancing

Introducing Kubernetes

Chapter 13: API Management

API Management

Advantages of using API Management software tools

API Management tools

Rate limiting

Implementing rate limiting

Learning about KONG

Microservice REST APIs with the KONG architecture

Using APIs without the KONG architecture

Installing KONG

Using the KONG API

Features of the KONG API

Swagger

Usage of Swagger

Using Swagger in a microservice

Adding a Maven dependency

Configuring Swagger 2 in your project

Configuring Swagger UI in your project

Customizing the Swagger UI meta-configuration

Filtering an API from Swagger's documentation

Customizing with Swagger annotations

Advantages of Swagger

Chapter 14: Deploying in Cloud (AWS)

Spinning up an AWS EC2 instance

Microservices architecture on AWS

Publishing microservices to the Docker Hub

Installing Docker on AWS EC2

Running microservices on AWS EC2

Chapter 15: Production Ready Service Monitoring and Best Practices

Monitoring containers

Logging challenges for the microservices architecture

Centralized logging solution for the microservices architecture

Log aggregation using the ELK stack

Install Elasticsearch

Install Logstash

Install Kibana

Requesting tracing using Sleuth

Requesting tracing with Zipkin.

Adding the Zipkin server to your machine.

Notes:

Description based on print version record.

ISBN:

9781787125148

1787125149

OCLC:

1042168460