Mastering Spring Cloud
Piotr Minkowski更新时间：2021-08-27 18:57:50
最新章节：Leave a review - let other readers know what you think封面
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
更新时间：2021-08-27 18:57:50