Mastering Spring Cloud电子书

Title Page

Copyright and Credits

Mastering Spring Cloud

Packt Upsell

Why subscribe?

PacktPub.com

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

Download the example code files

Conventions used

Get in touch

Reviews

Introduction to Microservices

The blessings of microservices

Building microservices with Spring Framework

Cloud-native development

Learning the microservices architecture

Understanding the need for service discovery

Communication between services

Failures and circuit breakers

Summary

Spring for Microservices

Introducing Spring Boot

Developing applications with Spring Boot

Customizing configuration files

Creating RESTful Web Services

API Documentation

Using Swagger 2 together with Spring Boot

Testing API with Swagger UI

Spring Boot Actuator features

Application information

Health information

Metrics

Developer tools

Integrating application with database

Building a sample application

Running the application

Summary

Spring Cloud Overview

Beginning with the basics

Netflix OSS

Service discovery with Eureka

Routing with Zuul

Load balancing with Ribbon

Writing Java HTTP clients

Latency and fault tolerance with Hystrix

Configuration management with Archaius

Discovery and distributed configuration

An alternative – Consul

Apache Zookeeper

Miscellaneous projects

Distributed tracing with Sleuth

Messaging and integration

Cloud platform support

Other useful libraries

Security

Automated testing

Cluster features

Projects overview

Release trains

Summary

Service Discovery

Running Eureka on the server side

Enabling Eureka on the client side

Deregistration on shutdown

Using discovery client programmatically

Advanced configuration settings

Refreshing the registry

Changing the instance identificator

Preferring the IP address

Response cache

Enabling secure communication between client and server

Registering a secure service

Eureka API

Replication and high availability

Architecture of the sample solution

Building the example application

Failover

Zones

Zones with a standalone server

Building an example application

Summary

Distributed Configuration with Spring Cloud Config

Introduction to HTTP API resources

Native profile support

Building a server-side application

Building a client-side application

Adding a Eureka Server

Client-side bootstrap approaches

Config Server discovery

Repository backend types

Filesystem backend

Git backend

Different protocols

Using placeholders in URIs

Building a server application

Client-side configuration

Multiple repositories

Vault backend

Getting started with Vault

Integration with Spring Cloud Config

Client-side configuration

Additional features

Fail on start and retry

Secure client

Reload configuration automatically

Solution architecture

Reload configuration with @RefreshScope

Consuming events from a message broker

Monitoring repository changes on a Config Server

Simulating change events manually

Testing locally with a GitLab instance

Summary

Communication Between Microservices

Different styles of communication

Synchronous communication with Spring Cloud

Load balancing with Ribbon

Enabling communication between microservices using the Ribbon client

Static load balancing configuration

Calling other services

Using RestTemplate together with service discovery

Building example application

Using Feign client

Support for different zones

Enabling Feign for an application

Building Feign interfaces

Launching microservices

Inheritance support

Creating a client manually

Client customization

Summary

Advanced Load Balancing and Circuit Breakers

Load balancing rules

The WeightedResponseTime rule

Introducing Hoverfly for testing

Testing the rule

Customizing the Ribbon client

The circuit breaker pattern with Hystrix

Building an application with Hystrix

Implementing Hystrix's commands

Implementing fallback with cached data

The tripping circuit breaker

Monitoring latency and fault tolerance

Exposing Hystrix's metrics stream

Hystrix dashboard

Building an application with the dashboard

Monitoring metrics on the dashboard

Aggregating Hystrix's streams with Turbine

Enabling Turbine

Enabling Turbine with streaming

Failures and the circuit breaker pattern with Feign

Retrying the connection with Ribbon

Hystrix's support for Feign

Summary

Routing and Filtering with API Gateway

Using Spring Cloud Netflix Zuul

Building a gateway application

Integration with service discovery

Customizing route configuration

Ignoring registered services

Explicity set service name

Route definition with the Ribbon client

Adding a prefix to the path

Connection settings and timeouts

Secure headers

Management endpoints

Providing Hystrix fallback

Zuul filters

Predefined filters

Custom implementations

Using Spring Cloud Gateway

Enable Spring Cloud Gateway for a project

Built-in predicates and filters

Gateway for microservices

Integration with service discovery

Summary

Distributed Logging and Tracing

Best logging practices for microservices

Logging with Spring Boot

Centralizing logs with ELK Stack

Setting up ELK Stack on the machine

Integrating an application with ELK Stack

Using LogstashTCPAppender

Using AMQP appender and a message broker

Spring Cloud Sleuth

Integrating Sleuth with an application

Searching events using Kibana

Integrating Sleuth with Zipkin

Running the Zipkin server

Building the client application

Analyze data with the Zipkin UI

Integration via message broker

Summary

Additional Configuration and Discovery Features

Using Spring Cloud Consul

Running Consul agent

Integration on the client side

Service discovery

Health check

Zones

Client settings customization

Running in clustered mode

Distributed configuration

Managing properties in Consul

Client customization

Watching configuration changes

Using Spring Cloud Zookeeper

Running Zookeeper

Service discovery

Client implementation

Zookeeper dependencies

Distributed configuration

Summary

Message-Driven Microservices

Learning about Spring Cloud Stream

Building a messaging system

Enabling Spring Cloud Stream

Declaring and binding channels

Customizing connectivity with the RabbitMQ broker

Integration with other Spring Cloud projects

The publish/subscribe model

Running a sample system

Scaling and grouping

Running multiple instances

Consumer groups

Partitioning

Configuration options

Spring Cloud Stream properties

Binding properties

The consumer

The producer

The advanced programming model

Producing messages

Transformation

Consuming messages conditionally

Using Apache Kafka

Running Kafka

Customizing application settings

Kafka Streams API support

Configuration properties

Multiple binders

Summary

Securing an API

Enabling HTTPS for Spring Boot

Secure discovery

Registering a secure application

Serving Eureka over HTTPS

Keystore generation

Configurating SSL for microservices and Eureka server

Secure configuration server

Encryption and decryption

Configuring authentication for a client and a server

Authorization with OAuth2

Introduction to OAuth2

Building an authorization server

Client configuration

Using the JDBC backend store

Inter-service authorization

Enabling SSO on the API gateway

Summary

Testing Java Microservices

Testing strategies

Testing Spring Boot applications

Building the sample application

Integration with the database

Unit tests

Component tests

Running tests with an in-memory database

Handling HTTP clients and service discovery

Implementing sample tests

Integration tests

Categorizing tests

Capturing HTTP traffic

Contract tests

Using Pact

Consumer side

Producer side

Using Spring Cloud Contract

Defining contracts and generating stubs

Verifying a contract on the consumer side

Scenarios

Performance testing

Gatling

Enabling Gatling

Defining the test scenario

Running a test scenario

Summary

Docker Support

Introducing Docker

Installing Docker

Commonly used Docker commands

Running and stopping a container

Listing and removing containers

Pulling and pushing images

Building an image

Networking

Creating a Docker image with microservices

Dockerfiles

Running containerized microservices

Building an image using the Maven plugin

Advanced Docker images

Continuous Delivery

Integrating Jenkins with Docker

Building pipelines

Working with Kubernetes

Concepts and components

Running Kubernetes locally via Minikube

Deploying an application

Maintaining a cluster

Summary

Spring Microservices on Cloud Platforms

Pivotal Cloud Foundry

Usage models

Preparing the application

Deploying the application

Using CLI

Binding to services

Using the Maven plugin

Maintenance

Accessing deployment details

Managing application life cycles

Scaling

Provisioning brokered services

The Heroku platform

Deployment methods

Using the CLI

Connecting to the GitHub repository

Docker Container Registry

Preparing an application

Testing deployments

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think