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