Book Image

Spring Microservices

By : Rajesh R V
Book Image

Spring Microservices

By: Rajesh R V

Overview of this book

The Spring Framework is an application framework and inversion of the control container for the Java platform. The framework's core features can be used by any Java application, but there are extensions to build web applications on top of the Java EE platform. This book will help you implement the microservice architecture in Spring Framework, Spring Boot, and Spring Cloud. Written to the latest specifications of Spring, you'll be able to build modern, Internet-scale Java applications in no time. We would start off with the guidelines to implement responsive microservices at scale. We will then deep dive into Spring Boot, Spring Cloud, Docker, Mesos, and Marathon. Next you will understand how Spring Boot is used to deploy autonomous services, server-less by removing the need to have a heavy-weight application server. Later you will learn how to go further by deploying your microservices to Docker and manage it with Mesos. By the end of the book, you'll will gain more clarity on how to implement microservices using Spring Framework and use them in Internet-scale deployments through real-world examples.
Table of Contents (18 chapters)
Spring Microservices
Credits
About the Author
Acknowledgments
About the Reviewer
www.PacktPub.com
Preface
Index

Index

A

  • agents
    • about / Fleet
  • Agile software development
    • URL / The Agile practice
  • Airbnb
    • URL / Microservices early adopters
    • about / Microservices early adopters
  • Amazon
    • about / Microservices early adopters
    • URL / Microservices early adopters
  • Amazon EC2 Container Service (ECS) / Introduction to Docker
  • Angel
    • about / Spring Cloud releases
  • Apache Mesos
    • about / Apache Mesos
  • application
    • autoscaling / Autoscaling an application
  • application information
    • configuring / Configuring application information
  • appropriate microservice boundaries
    • establishing / Establishing appropriate microservice boundaries
  • architecture, Mesos
    • about / The Mesos architecture
    • master / The Mesos architecture
    • slave / The Mesos architecture
    • ZooKeeper / The Mesos architecture
    • framework / The Mesos architecture
  • autoconfig
    • about / Spring Boot actuators
  • autoscaling
    • about / Understanding the concept of autoscaling
    • benefits / The benefits of autoscaling
    • different autoscaling models / Different autoscaling models
    • in cloud / Autoscaling in the cloud
  • autoscaling approaches
    • about / Autoscaling approaches
    • scaling, with resource constraints / Scaling with resource constraints
    • scaling, during specific time periods / Scaling during specific time periods
    • scaling, based on message queue length / Scaling based on the message queue length
    • scaling, based on business parameters / Scaling based on business parameters
    • predictive autoscaling / Predictive autoscaling
  • autoscaling ecosystem
    • about / The capabilities required for an autoscaling system
    • Microservices / The capabilities required for an autoscaling system
    • service registry / The capabilities required for an autoscaling system
    • load balancer / The capabilities required for an autoscaling system
    • life cycle manager / The capabilities required for an autoscaling system
  • AWS
    • setting up / Setting up AWS
  • AWS Lambda
    • reference / Imperative architecture evolution

B

  • Backend as a Service (BaaS) / Microservice use cases
  • benefits, microservices
    • about / Microservices benefits
    • polyglot architecture support / Supports polyglot architecture
    • experimentation, enabling / Enabling experimentation and innovation
    • innovation, enabling / Enabling experimentation and innovation
    • elastically scalable / Elastically and selectively scalable
    • selectively scalable / Elastically and selectively scalable
    • substitution, allowing / Allowing substitution
    • build organic systems, enabling / Enabling to build organic systems
    • technology debt, reducing / Helping reducing technology debt
    • coexistence of different versions, allowing / Allowing the coexistence of different versions
    • self-organizing systems, building / Supporting the building of self-organizing systems
    • event-driven architecture, supporting / Supporting event-driven architecture
    • DevOps, enabling / Enabling DevOps
  • best-of-the-breed components
    • log shippers / Log shippers
    • log storage / Log storage
    • dashboards / Dashboards
  • bill of materials (BOM) / Examining the POM file
  • Bin packing algorithm / What does cluster management do?
  • Boot2Docker / Introduction to Docker
  • bounded context
    • about / Establishing appropriate microservice boundaries
  • Brixton
    • about / Spring Cloud releases
  • BrownField PSS
    • environment, setting up for / Setting up the environment for BrownField PSS
  • BrownField PSS architecture
    • defining / Summarizing the BrownField PSS architecture
  • BrownField PSS microservices
    • limitations / Understanding the gaps in BrownField PSS microservices
  • BrownField PSS microservices, autoscaling
    • about / Autoscaling BrownField PSS microservices
    • capabilities / The capabilities required for an autoscaling system
    • custom life cycle manager, implementing with Spring Boot / Implementing a custom life cycle manager using Spring Boot
    • deployment topology / Understanding the deployment topology
    • execution flow / Understanding the execution flow
    • life cycle manager code / A walkthrough of the life cycle manager code
    • life cycle manager, running / Running the life cycle manager
  • BrownField PSS services
    • preparing / Preparing BrownField PSS services
    • deploying / Deploying BrownField PSS services
    • reviewing / Reviewing the deployment
  • BrownField services
    • running, on EC2 / Running BrownField services on EC2
  • business case
    • defining / The business case
  • Business Process Management (BPM)
    • about / Role of BPM and workflows
    • use cases / Role of BPM and workflows

C

  • Calico
    • about / What are containers?
  • candidate tests, for automation
    • about / Different candidate tests for automation
    • automated sanity tests / Automated sanity tests
    • regression testing / Regression testing
    • automated functional testing / Automated functional testing
    • automated acceptance testing / Automated acceptance testing
    • performance testing / Performance testing
    • real user flow simulation or journey testing / Real user flow simulation or journey testing
    • automated security testing / Automated security testing
    • exploratory testing / Exploratory testing
    • A/B testing / A/B testing, canary testing, and blue-green deployments
    • canary testing / A/B testing, canary testing, and blue-green deployments
    • blue-green deployments / A/B testing, canary testing, and blue-green deployments
    • nonfunctional tests / Other nonfunctional tests
    • Testing in Production (TiP) / Testing in production
    • antifragility testing / Antifragility testing
  • CDNs (Content Delivery Networks)
    • about / Microservices to the rescue
  • centralized logging solution
    • about / A centralized logging solution
    • log streams / A centralized logging solution
    • log shippers / A centralized logging solution
    • log store / A centralized logging solution
    • log stream processor / A centralized logging solution
    • log dashboard / A centralized logging solution
  • cgroups / Docker containers, Diving deep into Mesos
  • characteristics, of microservices
    • about / Characteristics of microservices
    • services are first-class citizens / Services are first-class citizens
    • characteristics of services / Characteristics of services in a microservice
    • lightweight / Microservices are lightweight
    • polyglot architecture / Microservices with polyglot architecture
    • automation / Automation in a microservices environment
    • supporting ecosystem / Microservices with a supporting ecosystem
    • distributed and dynamic / Microservices are distributed and dynamic
    • antifragility / Antifragility, fail fast, and self-healing
    • fail fast / Antifragility, fail fast, and self-healing
    • self-healing / Antifragility, fail fast, and self-healing
  • characteristics of services, microservices
    • service contract / Characteristics of services in a microservice
    • loose coupling / Characteristics of services in a microservice
    • service abstraction / Characteristics of services in a microservice
    • service reuse / Characteristics of services in a microservice
    • statelessness / Characteristics of services in a microservice
    • services are discoverable / Characteristics of services in a microservice
    • service interoperability / Characteristics of services in a microservice
    • service composeability / Characteristics of services in a microservice
  • circuit breaker pattern
    • reference / Spring Cloud Hystrix for fault-tolerant microservices
  • cloud
    • as self-service infrastructure, for microservices / Cloud as the self-service infrastructure for Microservices
  • cluster management
    • about / Why cluster management is important
    • features / Why cluster management is important
    • functioning / What does cluster management do?
    • relationship with microservices / Relationship with microservices
    • relationship with virtualization / Relationship with virtualization
    • with Mesos and Marathon / Cluster management with Mesos and Marathon
  • cluster management solutions
    • about / Cluster management solutions
    • Docker Swarm / Docker Swarm
    • Kubernetes / Kubernetes
    • Apache Mesos / Apache Mesos
    • Nomad / Nomad
    • Fleet / Fleet
  • Command Query Responsibility Segregation (CQRS) / Single responsibility
  • Command Query Responsibility segregations (CQRS) / Microservice use cases
  • communication styles, designing
    • synchronous style communication / Synchronous style communication
    • asynchronous style communication / Asynchronous style communication
    • style, selecting / How to decide which style to choose?
  • components, Spring Cloud
    • Netflix OSS / Spring Cloud and Netflix OSS
  • comprehensive microservice example
    • developing / Developing a comprehensive microservice example
  • Config server URL
    • defining / Understanding the Config server URL
    • references / Understanding the Config server URL
    • Config Server, accessing from clients / Accessing the Config Server from clients
  • configurable items (CIs) / Operation overheads
  • Configuration Management Database (CMDB) / Operation overheads
  • containerization
    • about / The future of containerization – unikernels and hardened security
    • future / The future of containerization – unikernels and hardened security
    • unikernels / The future of containerization – unikernels and hardened security
    • security issues / The future of containerization – unikernels and hardened security
  • containers
    • about / What are containers?
    • versus, virtual machines (VMs) / The difference between VMs and containers
    • benefits / The benefits of containers
    • self-contained / The benefits of containers
    • lightweight / The benefits of containers
    • scalable / The benefits of containers
    • portable / The benefits of containers
    • lower license cost / The benefits of containers
    • DevOps / The benefits of containers
    • version controlled / The benefits of containers
    • reusable / The benefits of containers
    • immutable containers / The benefits of containers
  • Content Management System (CMS) / An example of a travel agent portal
  • continuous delivery pipeline, automating
    • about / Automating the continuous delivery pipeline
    • development stage / Development
    • continuous integration / Continuous integration
    • automated testing / Automated testing
    • continuous deployment / Continuous deployment
    • monitoring and feedback / Monitoring and feedback
  • continuous integration (CI)
    • about / Pain points
  • Continuous Integration (CI) tools / Automation in a microservices environment
  • continuous integration workflow
    • about / Continuous integration
    • build and QA / Continuous integration
    • packaging / Continuous integration
    • integration tests / Continuous integration
  • Conveys law
    • reference / Microservice use cases
  • core capabilities, microservices capability model
    • about / Core capabilities
    • service listeners / Core capabilities
    • storage capability / Core capabilities
    • business capability definition / Core capabilities
    • event sourcing / Core capabilities
    • service endpoints and communication protocols / Core capabilities
    • API gateway / Core capabilities
    • user interfaces / Core capabilities
  • Corporate Customer microservice
    • about / Enabling to build organic systems
  • create, read, update, and delete (CRUD) / Developing a comprehensive microservice example
  • cross-origin
    • enabling, for microservices / Enabling cross-origin access for microservices
  • Customer microservices
    • about / Enabling to build organic systems
  • Customer Profile microservice
    • about / Services are first-class citizens
    • Register Customer / Services are first-class citizens
    • Get Customer / Services are first-class citizens
  • Customer service
    • about / Allowing the coexistence of different versions
  • custom health module
    • adding / Adding a custom health module
    • custom metrics, building / Building custom metrics

D

  • data analysis
    • data lakes, used / Data analysis using data lakes
  • Database Lifecycle Management (DLM) / Addressing challenges around databases
  • data lake
    • about / Data analysis using data lakes
  • default embedded web server
    • changing / Changing the default embedded web server
  • dependencies, microservice boundaries
    • events, as opposed to query / Events as opposed to query
    • events, as opposed to synchronous updates / Events as opposed to synchronous updates
    • requirements, challenging / Challenge requirements
    • service boundaries, challenging / Challenge service boundaries
    • dependency graph / Final dependency graph
  • development environment
    • setting up / Setting up a development environment
  • development philosophy
    • selecting / Choosing a development philosophy
    • design thinking / Design thinking
    • start-up model / The start-up model
    • Agile practice / The Agile practice
  • development stage
    • about / Development
    • source code / Development
    • unit test cases / Development
    • consumer-driven contracts / Development
    • mock testing / Development
    • behavior driven design (BDD) / Development
    • source code repository / Development
    • build tool / Development
    • artifact repository / Development
    • database schemas / Development
  • DevOps
    • about / What are microservices?
    • URL / What are microservices?
    • defining / The new mantra of lean IT – DevOps
    • wastage, reducing / Reducing wastage
    • tasks, automating / Automating every possible step
    • value-driven delivery / Value-driven delivery
    • development and operations, bridging / Bridging development and operations
    • as practice and process, for microservices / DevOps as the practice and process for microservices
  • DevOps-style microservice life cycle process
    • defining / Defining a DevOps-style microservice life cycle process
    • continuous integration (CI) / Defining a DevOps-style microservice life cycle process, Continuous integration
    • continuous delivery (CD) / Defining a DevOps-style microservice life cycle process
    • continuous deployment / Defining a DevOps-style microservice life cycle process
    • Application Release Automation (ARA) / Defining a DevOps-style microservice life cycle process
    • value-driven planning / Value-driven planning
    • Agile development / Agile development
    • continuous testing / Continuous testing
    • continuous release / Continuous release
    • continuous monitoring and feedback / Continuous monitoring and feedback
  • Docker
    • about / What are containers?, Introduction to Docker
    • key components / The key components of Docker
    • concepts / Docker concepts
    • microservices, deploying / Deploying microservices in Docker
    • URL / Deploying microservices in Docker
    • RabbitMQ, running on / Running RabbitMQ on Docker
  • Docker client
    • about / The Docker client
  • Docker concepts
    • Docker images / Docker images
    • Docker containers / Docker containers
    • Docker registry / The Docker registry
    • Dockerfile / Dockerfile
  • Docker daemon
    • about / The Docker daemon
  • Docker file
    • contents / Deploying microservices in Docker
  • Docker Hub account
    • reference / Setting up the Docker Hub
  • Dockerization / Introduction to Docker
  • Docker registry
    • using / Using the Docker registry
    • Docker hub, setting up / Setting up the Docker Hub
    • microservices, publishing to Docker hub / Publishing microservices to the Docker Hub
  • Docker Swarm
    • about / Docker Swarm
  • domain-driven design (DDD)
    • about / Establishing appropriate microservice boundaries
    • URL / Establishing appropriate microservice boundaries
  • Drawbridge
    • about / What are containers?
  • Drools
    • about / Rules engine – shared or embedded?
  • dump
    • about / Spring Boot actuators
  • dynamic discovery
    • defining / Understanding dynamic service registration and discovery
  • dynamic resource provisioning and deprovisioning / Understanding the concept of autoscaling
  • dynamic service registration
    • defining / Understanding dynamic service registration and discovery

E

  • eBay
    • URL / Microservices early adopters
    • about / Microservices early adopters
  • ecosystem capabilities
    • building / Building ecosystem capabilities
  • elasticity / Understanding the concept of autoscaling
  • Elasticsearch
    • URL / A custom logging implementation
  • engine
    • about / Fleet
  • Enterprise Application integration (EAI)
    • about / Integration with other systems
  • Enterprise Integration Patterns (EIP) / Service-oriented integration
  • Enterprise Service Bus (ESB) / Microservices are distributed and dynamic
  • Eureka
    • defining / Understanding Eureka
    • high availability / High availability for Eureka
  • Eureka server
    • setting up / Setting up the Eureka server
  • evolution
    • planning / Plan the evolution
  • evolution, microservices
    • about / The evolution of microservices
    • business demand, as catalyst / Business demand as a catalyst for microservices evolution
    • technology, as catalyst / Technology as a catalyst for the microservices evolution
    • imperative architecture evolution / Imperative architecture evolution
  • examples, microservices
    • about / Microservices examples
    • holiday portal / An example of a holiday portal
    • microservice-based order management system / A microservice-based order management system
    • travel agent portal / An example of a travel agent portal

F

  • factors
    • defining / Prioritizing microservices for migration
  • FakeSMTP
    • URL / Developing a comprehensive microservice example
  • Feign
    • defining / Feign as a declarative REST client
  • Fleet
    • about / Fleet
  • Fly By Points / An example of a holiday portal
  • followers
    • about / Nomad

G

  • gateway / Docker containers
  • Gilt
    • URL / Microservices early adopters
    • about / Microservices early adopters
  • Guest OS
    • about / The difference between VMs and containers

H

  • HAL (Hypertext Application Language) browser / Developing the Spring Boot microservice using Spring Initializr – the HATEOAS example
  • HATEOAS example / Developing the Spring Boot microservice using Spring Initializr – the HATEOAS example
  • health
    • about / Spring Boot actuators
  • hexagonal architecture, microservices
    • reference / What are microservices?
  • high availability
    • URL / Setting up high availability for the Config server
  • high availability, of Zuul
    • about / High availability of Zuul
    • Eureka client / High availability of Zuul when the client is also a Eureka client
    • not a Eureka client / High availability when the client is not a Eureka client
  • honeycomb analogy
    • about / Microservices – the honeycomb analogy

I

  • in-memory data grid (IMDG) / Elastically and selectively scalable
  • info
    • about / Spring Boot actuators
  • infrastructure
    • autoscaling / Autoscaling the infrastructure
  • infrastructure as code / Cloud as the self-service infrastructure for Microservices
  • infrastructure capabilities, microservices capability model
    • about / Infrastructure capabilities
    • cloud / Infrastructure capabilities
    • containers or virtual machines / Infrastructure capabilities
    • cluster control and provisioning / Infrastructure capabilities
    • application life cycle management / Infrastructure capabilities
  • INPUT queue / Supporting the building of self-organizing systems
  • instance ID / Preparing BrownField PSS services
  • Integration Platform as a Service (iPaaS) / Technology as a catalyst for the microservices evolution
  • Intelligent Business Process Management (iBPM) / Role of BPM and workflows

J

  • JDK 1.8
    • reference / Setting up a development environment
  • jobs
    • about / Nomad
  • JSch (Java Secure Channel) / A walkthrough of the life cycle manager code
  • JSON structure
    • id / Deploying BrownField PSS services
    • cpus / Deploying BrownField PSS services
    • mem / Deploying BrownField PSS services
    • instances / Deploying BrownField PSS services
    • container / Deploying BrownField PSS services
    • image / Deploying BrownField PSS services
    • network / Deploying BrownField PSS services
    • portMappings / Deploying BrownField PSS services

K

  • kernel namespace / Docker containers
  • key capabilities, cluster management software
    • about / What does cluster management do?
    • cluster management / What does cluster management do?
    • deployments / What does cluster management do?
    • scalability / What does cluster management do?
    • health / What does cluster management do?
    • infrastructure abstraction / What does cluster management do?
    • resource optimization / What does cluster management do?
    • resource allocation / What does cluster management do?
    • service availability / What does cluster management do?
    • agility / What does cluster management do?
    • isolation / What does cluster management do?
  • key components, automated microservices deployment topology
    • about / Scaling microservices with Spring Cloud
    • Eureka / Scaling microservices with Spring Cloud
    • Eureka client / Scaling microservices with Spring Cloud
    • Ribbon client / Scaling microservices with Spring Cloud
  • key components, Docker
    • about / The key components of Docker
    • Docker daemon / The key components of Docker
    • Docker client / The key components of Docker
  • Kubernetes
    • about / Kubernetes
  • Kurma
    • about / What are containers?

L

  • Lambda architecture
    • reference / A centralized logging solution
  • leader
    • about / Nomad
  • libraries
    • about / Microservices development governance, reference architectures, and libraries
  • life cycle manager / Autoscaling BrownField PSS microservices
    • about / The capabilities required for an autoscaling system, A place for the life cycle manager
    • metrics collection / The capabilities required for an autoscaling system
    • scaling policies / The capabilities required for an autoscaling system
    • decision engine / The capabilities required for an autoscaling system
    • deployment rules / The capabilities required for an autoscaling system
    • deployment engine / The capabilities required for an autoscaling system
    • updating / Updating the life cycle manager
    • rewriting, with Mesos and Marathon / Rewriting the life cycle manager with Mesos and Marathon
  • Lmctfy
    • about / What are containers?
  • logging solutions
    • selecting / The selection of logging solutions
    • cloud services / Cloud services
    • off-the-shelf solutions / Off-the-shelf solutions
    • best-of-the-breed integration / Best-of-breed integration
    • custom logging implementation / A custom logging implementation
    • distributed tracing, with Spring Cloud Sleuth / Distributed tracing with Spring Cloud Sleuth
  • log management challenges
    • about / Understanding log management challenges
  • Loyalty Points microservice
    • about / Enabling to build organic systems
  • LXD
    • about / What are containers?

M

  • manager
    • about / Docker Swarm
  • mappings
    • about / Spring Boot actuators
  • Marathon
    • about / Marathon
    • features / Marathon
    • implementing, for BrownField microservices / Implementing Mesos and Marathon for BrownField microservices
    • reference / Installing ZooKeeper, Mesos, and Marathon
    • installing / Installing ZooKeeper, Mesos, and Marathon
    • running as services / Running Mesos, Marathon, and ZooKeeper as services
  • Marathon autoscale
    • about / A place for the life cycle manager
  • master
    • about / Kubernetes
  • Maven 3.3.1
    • reference / Setting up a development environment
  • Mean Time Between Failures (MTBF) / Antifragility, fail fast, and self-healing
  • Mean Time To Recover (MTTR) / Antifragility, fail fast, and self-healing
  • Mesos
    • about / Diving deep into Mesos
    • architecture / The Mesos architecture
    • workflow diagram / The Mesos architecture
    • implementing, for BrownField microservices / Implementing Mesos and Marathon for BrownField microservices
    • reference / Installing ZooKeeper, Mesos, and Marathon
    • installing / Installing ZooKeeper, Mesos, and Marathon
    • configuring / Configuring Mesos
    • running as services / Running Mesos, Marathon, and ZooKeeper as services
  • Mesos slave
    • running, in command line / Running the Mesos slave in the command line
  • metrics
    • about / Spring Boot actuators
  • Microservice A / Establishing self-organizing teams
  • Microservice B / Establishing self-organizing teams
  • microservice boundaries
    • autonomous functions / Autonomous functions
    • size, of deployable unit / Size of a deployable unit
    • subdomain / Most appropriate function or subdomain
    • most appropriate function / Most appropriate function or subdomain
    • polyglot architecture / Polyglot architecture
    • selective scaling / Selective scaling
    • agile teams / Small, agile teams
    • single responsibility / Single responsibility
    • replicability / Replicability or changeability
    • changeability / Replicability or changeability
    • coupling / Coupling and cohesion
    • microservice, as product / Think microservice as a product
    • identifying / Identification of microservices boundaries
    • dependencies, analyzing / Analyze dependencies
  • microservice capability model
    • reviewing / Reviewing the microservice capability model, Reviewing the microservice capability model, Reviewing the microservice capability model, Reviewing the microservice capability model, Reviewing the microservice capability model
  • microservice monitoring
    • about / Monitoring microservices
    • objectives / Monitoring microservices
    • challenges / Monitoring challenges
    • metrics sources and data collectors / Monitoring challenges
    • aggregation and correlation of metrics / Monitoring challenges
    • processing metrics and actionable insights / Monitoring challenges
    • alerts / Monitoring challenges
    • actions / Monitoring challenges
    • dashboards / Monitoring challenges
    • Application Performance Monitoring (APM) approach / Monitoring challenges
    • synthetic monitoring / Monitoring challenges
    • real user monitoring (RUM) / Monitoring challenges
    • user experience monitoring / Monitoring challenges
    • tools / Monitoring tools
    • microservice dependencies, monitoring / Monitoring microservice dependencies
    • Spring Cloud Hystrix, for fault-tolerant microservices / Spring Cloud Hystrix for fault-tolerant microservices
    • Hystrix streams, aggregating with Turbine / Aggregating Hystrix streams with Turbine
  • microservices
    • evolution / The evolution of microservices
    • about / What are microservices?
    • hexagonal architecture / What are microservices?
    • architecture / What are microservices?
    • honeycomb analogy / Microservices – the honeycomb analogy
    • principles / Principles of microservices
    • Order / Single responsibility per service
    • Customer / Single responsibility per service
    • Product / Single responsibility per service
    • characteristics / Characteristics of microservices
    • examples / Microservices examples
    • benefits / Microservices benefits, The business case
    • relationship, with other architecture / Relationship with other architecture styles
    • use cases / Microservice use cases
    • documenting / Documenting microservices
    • defining / Microservices to the rescue
    • prioritizing, for migration / Prioritizing microservices for migration
    • data synchronization, during migration / Data synchronization during migration
    • reference data, managing / Managing reference data
    • scaling, with Spring Cloud / Scaling microservices with Spring Cloud
    • and containers / Microservices and containers
    • deploying, in Docker / Deploying microservices in Docker
  • microservices, on cloud
    • about / Microservices on the cloud
    • Docker, installing on AWS EC2 / Installing Docker on AWS EC2
  • microservices-based architecture
    • examining / What are microservices?
  • microservices capabilities
    • reviewing / Reviewing microservices capabilities
  • microservices capability model
    • about / The microservices capability model
    • core capabilities / The microservices capability model, Core capabilities
    • supporting capabilities / The microservices capability model, Supporting capabilities
    • infrastructure capabilities / The microservices capability model, Infrastructure capabilities
    • governance capabilities / The microservices capability model
    • process and governance capabilities / Process and governance capabilities
    • reviewing / Reviewing the microservices capability model
  • microservices challenges
    • about / Microservices challenges
    • data islands / Data islands
    • logging / Logging and monitoring
    • monitoring / Logging and monitoring
    • dependency management / Dependency management
    • organization culture / Organization culture
    • governance challenges / Governance challenges
    • operation overheads / Operation overheads
    • microservices, testing / Testing microservices
    • infrastructure provisioning / Infrastructure provisioning
  • microservices development
    • practice points / Practice points for microservices development
  • microservices development teams
    • about / Microservices development governance, reference architectures, and libraries
  • Minimum Viable Product (MVP)
    • using / Using the concept of Minimum Viable Product
    • about / Using the concept of Minimum Viable Product
  • Minimum Viable Products (MVPs) / Replicability or changeability
  • modules
    • migrating / Migrate modules only if required

N

  • Netflix
    • URL / Microservices early adopters
    • about / Microservices early adopters, Spring Cloud and Netflix OSS
  • Netflix Open Source Software (Netflix OSS)
    • about / Spring Cloud and Netflix OSS
  • Nike
    • URL / Microservices early adopters
    • about / Microservices early adopters
  • nodes
    • about / Docker Swarm, Kubernetes
  • Nomad
    • about / Nomad

O

  • OAuth
    • reference / Securing a microservice with OAuth2
  • Orbitz
    • about / Microservices early adopters
    • URL / Microservices early adopters
  • Order Event / Supporting event-driven architecture
  • OUTPUT queue / Supporting the building of self-organizing systems
  • oversubscription / What does cluster management do?

P

  • patterns and common design decisions
    • about / Patterns and common design decisions
    • appropriate microservice boundaries, establishing / Establishing appropriate microservice boundaries
    • communication styles, designing / Designing communication styles
    • orchestration / Orchestration of microservices
    • number of endpoints / How many endpoints in a microservice?
    • microservice, on VM / One microservice per VM or multiple?
    • microservice, on multiple VMs / One microservice per VM or multiple?
    • rules engine / Rules engine – shared or embedded?
    • role, of BPM and workflows / Role of BPM and workflows
    • data store, sharing / Can microservices share data stores?
    • transaction boundaries, setting up / Setting up transaction boundaries
    • service endpoint design consideration / Service endpoint design consideration
    • shared libraries, handling / Handling shared libraries
    • user interfaces, in microservices / User interfaces in microservices
    • API gateways, using in microservices / Use of API gateways in microservices
    • ESB and iPaaS, using with microservices / Use of ESB and iPaaS with microservices
    • service versioning considerations / Service versioning considerations
    • design, for cross origin / Design for cross origin
    • shared reference data, handling / Handling shared reference data
    • bulk operations, in microservices / Microservices and bulk operations
  • Plain Old Java Objects (POJO) services / Service-oriented application
  • Platform as a Services (PaaS) / Technology as a catalyst for the microservices evolution
  • pods
    • about / Kubernetes
  • POJO (Plain Old Java Object)
    • about / Components of Spring Cloud
  • pom file
    • reference / Examining the POM file
  • practice points, microservices development
    • about / Practice points for microservices development
    • business motivation and value / Understanding business motivation and value
    • mindset, changing from project to product development / Changing the mindset from project to product development
    • development philosophy, selecting / Choosing a development philosophy
    • Minimum Viable Product (MVP), using / Using the concept of Minimum Viable Product
    • legacy hotspot / Overcoming the legacy hotspot
    • challenges around databases, addressing / Addressing challenges around databases
    • self-organizing teams, establishing / Establishing self-organizing teams
    • self-service cloud, building / Building a self-service cloud
    • microservices ecosystem, building / Building a microservices ecosystem
    • DevOps-style microservice life cycle process, defining / Defining a DevOps-style microservice life cycle process
    • continuous delivery pipeline, automating / Automating the continuous delivery pipeline
    • automated configuration management / Automated configuration management
  • principles, of microservices
    • about / Principles of microservices
    • single responsibility principle / Single responsibility per service
    • autonomous services / Microservices are autonomous
  • process and governance capabilities, microservices capability model
    • about / Process and governance capabilities
    • DevOps / Process and governance capabilities
    • DevOps tools / Process and governance capabilities
    • microservices repositor / Process and governance capabilities
    • microservice documentation / Process and governance capabilities
    • reference architecture and libraries / Process and governance capabilities
  • protocol selection
    • about / Protocol selection
    • message-oriented services / Message-oriented services
    • HTTP and REST endpoints / HTTP and REST endpoints
    • optimized communication protocols / Optimized communication protocols
    • API documentations / API documentations
  • PSS application
    • defining / Understanding the PSS application
    • business process view / Business process view
    • functional view / Functional view
    • architectural view / Architectural view
    • design view / Design view
    • implementation view / Implementation view
    • deployment view / Deployment view
    • about / Death of the monolith
    • limitation / Pain points
    • stop gap fix / Stop gap fix
    • shared data / Shared data
    • single database / Single database
    • domain boundaries / Domain boundaries
  • PSS Implementation, BrownField
    • reviewing / Reviewing BrownField's PSS implementation

R

  • RabbitMQ
    • running, on Docker / Running RabbitMQ on Docker
  • Rabbit MQ
    • reference / Implementing Spring Boot messaging
    • URL / Setting up high availability for the Config server
  • Random algorithm / What does cluster management do?
  • reactive programming
    • reference / A microservice-based order management system
  • Real Application Cluster (RAC)
    • about / Stop gap fix
  • Real User Monitoring (RUM) tools / Testing in production
  • reference architectures
    • about / Microservices development governance, reference architectures, and libraries
  • relationship, microservices
    • about / Relationship with other architecture styles
    • relations, with SOA / Relations with SOA
    • relations, with Twelve-Factor Apps / Relations with Twelve-Factor apps
  • relationship, microservices with SOA
    • about / Relations with SOA
    • service-oriented integration / Service-oriented integration
    • legacy modernization / Legacy modernization
    • service-oriented application / Service-oriented application
    • monolithic application / Monolithic migration using SOA
  • relationship, microservices with Twelve-Factor Apps
    • about / Relations with Twelve-Factor apps
    • single codebase / A single code base
    • dependencies, bundling / Bundling dependencies
    • configurations, externalizing / Externalizing configurations
    • backing services / Backing services are addressable
    • isolation, between build, release, run stages / Isolation between build, release, and run
    • stateless and share nothing processes / Stateless, shared nothing processes
    • services, exposing through port bindings / Exposing services through port bindings
    • concurrency, scaling out / Concurrency to scale out
    • disposability, with minimal overhead / Disposability with minimal overhead
    • development and production parity / Development and production parity
    • logs, externalizing / Externalizing logs
    • package admin processes / Package admin processes
  • RESTful microservices
    • building, Spring Boot used / Using Spring Boot to build RESTful microservices
  • RESTful service
    • developing / Developing a RESTful service – the legacy approach
  • Ribbon
    • defining, for load balancing / Ribbon for load balancing
    • about / Ribbon for load balancing
  • Rocket
    • about / What are containers?
  • RPM (Requests Per Minute) / Understanding the execution flow

S

  • sales closing transactions / Scaling based on business parameters
  • Scale Cube
    • about / Elastically and selectively scalable
    • reference / Elastically and selectively scalable
  • Search API Gateway microservice / Deploying microservices in Docker
  • Search microservice / Deploying microservices in Docker
  • servers
    • about / Nomad
  • Service-Oriented Integration (SOI) / Service-oriented integration
  • service availability
    • registering / Eureka for registration and discovery
    • and discovery / Eureka for registration and discovery
  • service endpoint design consideration
    • about / Service endpoint design consideration
    • contract design / Contract design
    • protocol selection / Protocol selection
  • session handling
    • and security / Session handling and security
  • shopping logic / Microservices are distributed and dynamic
  • single database
    • native queries / Native queries
    • stored procedures / Stored procedures
  • single sign-on (SSO)
    • about / User interfaces and web applications
  • SMTP server / Supporting the building of self-organizing systems
  • SOA principles
    • reference / Characteristics of services in a microservice
  • software-defined infrastructure / Cloud as the self-service infrastructure for Microservices
  • SOLID design pattern
    • reference / Single responsibility per service
  • span
    • about / Distributed tracing with Spring Cloud Sleuth
  • Spread algorithm / What does cluster management do?
  • Spring Boot
    • used, for building RESTful microservices / Using Spring Boot to build RESTful microservices
    • about / Getting started with Spring Boot
  • Spring Boot actuators
    • about / Spring Boot actuators
    • monitoring, JConsole used / Monitoring using JConsole
    • monitoring, SSH used / Monitoring using SSH
  • Spring Boot command-line tool
    • reference / Developing the Spring Boot microservice using the CLI
  • Spring Boot configuration
    • about / The Spring Boot configuration
    • autoconfiguration / Understanding the Spring Boot autoconfiguration
    • default configuration values, overriding / Overriding default configuration values
    • configuration file location, changing / Changing the location of the configuration file
    • custom properties, reading / Reading custom properties
    • .yaml file, using / Using a .yaml file for configuration
    • multiple configuration profiles, using / Using multiple configuration profiles
    • properties, reading / Other options to read properties
  • Spring Boot Java microservice
    • developing, STS used / Developing the Spring Boot Java microservice using STS
    • pom file, examining / Examining the POM file
    • Application.java, examining / Examining Application.java
    • application.properties, examining / Examining application.properties
    • ApplicationTests.java, examining / Examining ApplicationTests.java
    • testing / Testing the Spring Boot microservice
  • Spring Boot messaging
    • implementing / Implementing Spring Boot messaging
  • Spring Boot microservice
    • developing, CLI used / Developing the Spring Boot microservice using the CLI
    • developing, Spring Initializr used / Developing the Spring Boot microservice using Spring Initializr – the HATEOAS example
  • Spring Boot security
    • implementing / Implementing Spring Boot security
    • microservice, securing with basic security / Securing microservices with basic security
    • microservice, securing with OAuth2 / Securing a microservice with OAuth2
  • Spring Cloud
    • defining / What is Spring Cloud?
    • and Cloud Foundry, comparing / What is Spring Cloud?
    • releases / Spring Cloud releases
    • components / Components of Spring Cloud
    • capabilities / Components of Spring Cloud
    • for scaling microservices / Scaling microservices with Spring Cloud
  • Spring Cloud Config
    • defining / Spring Cloud Config
    • Config server, using / What's next?
    • Config server, setting up / Setting up the Config server
    • Config server URL, defining / Understanding the Config server URL
    • configuration changes, handling / Handling configuration changes
    • Spring Cloud Bus, for propagating configuration changes / Spring Cloud Bus for propagating configuration changes
    • high availability, setting up for Config server / Setting up high availability for the Config server
    • Config server health, monitoring / Monitoring the Config server health
    • Config server, for configuration files / Config server for configuration files
    • changes, completing for Config server usage / Completing changes to use the Config server
  • Spring Cloud examples
    • references / Setting up the Config server
  • Spring Initializr project
    • reference / Getting started with Spring Boot
  • Spring Initilizr
    • reference / Developing the Spring Boot microservice using Spring Initializr – the HATEOAS example
  • Spring Starter project
    • URL / Feign as a declarative REST client
  • Spring Tool Suite 3.7.2 (STS)
    • reference / Setting up a development environment
  • streams
    • for reactive microservices / Streams for reactive microservices
  • subnet / Docker containers
  • supporting capabilities, microservices capability model
    • about / Supporting capabilities
    • software defined load balancer / Supporting capabilities
    • central log management / Supporting capabilities
    • service registry / Supporting capabilities
    • security service / Supporting capabilities
    • service configuration / Supporting capabilities
    • testing tools / Supporting capabilities
    • monitoring and dashboards / Supporting capabilities
    • dependency and CI management / Supporting capabilities
    • Data lake / Supporting capabilities
    • reliable messaging / Supporting capabilities
  • SystemdNspawn
    • about / What are containers?

T

  • t2.large / Installing Docker on AWS EC2
  • t2.micro EC2 instances / Setting up AWS
  • target architecture
    • about / Target architecture
    • internal layering, of microservices / Internal layering of microservices
    • microservices, orchestrating / Orchestrating microservices
    • integration, with other systems / Integration with other systems
    • shared libraries, managing / Managing shared libraries
    • exceptions, handling / Handling exceptions
  • target implementation view
    • about / Target implementation view
    • implementation projects / Implementation projects
    • project, running / Running and testing the project
    • project, testing / Running and testing the project
  • target test environments
    • about / Target test environments
    • development environment / Target test environments
    • integration test environment / Target test environments
    • performance and diagnostics / Target test environments
    • functional test environment / Target test environments
    • UAT environment / Target test environments
    • staging / Target test environments
    • production / Target test environments
  • task groups
    • about / Nomad
  • tasks
    • about / Nomad
  • technology metamodel
    • about / The technology metamodel
  • Testing in Production (TiP) / Testing in production
  • test strategy
    • about / Test strategy
  • TPM (Transactions Per Minute) / Understanding the execution flow
  • trace
    • about / Distributed tracing with Spring Cloud Sleuth
  • traditional web application
    • moving, to microservices / Moving from traditional web applications to microservices
  • transaction boundaries
    • setting up / Setting up transaction boundaries
    • use cases, altering / Altering use cases to simplify transactional requirements
    • distributed transaction scenarios / Distributed transaction scenarios
  • transaction processing facility (TPF) / Overcoming the legacy hotspot
  • transition plan
    • establishing / Evolutionary approach
  • transition point of view
    • queries / Evolutionary approach
  • Twitter
    • about / Microservices early adopters
    • URL / Microservices early adopters

U

  • Uber
    • about / Microservices early adopters
    • URL / Microservices early adopters
  • use cases, microservices
    • about / Microservice use cases
    • microservices early adopters / Microservices early adopters
    • monolithic migrations / The common theme is monolithic migrations
  • user interfaces
    • and web applications / User interfaces and web applications

V

  • Veritas Risk Advisor (VRA) / Monitoring microservice dependencies
  • virtual engine (VE)
    • about / What are containers?
  • virtual machines (VMs)
    • versus containers / The difference between VMs and containers
    • Zen / The difference between VMs and containers
    • Hyper-V / The difference between VMs and containers

W

  • web applications
    • and user interfaces / User interfaces and web applications

X

  • XebiaLabs periodic table
    • reference / Automating the continuous delivery pipeline

Z

  • ZooKeeper
    • installing / Installing ZooKeeper, Mesos, and Marathon
    • reference / Installing ZooKeeper, Mesos, and Marathon
    • configuring / Configuring ZooKeeper
    • running as services / Running Mesos, Marathon, and ZooKeeper as services
  • Zuul
    • setting up / Setting up Zuul
    • using / Setting up Zuul
    • high availability / High availability of Zuul
    • completing, for all services / Completing Zuul for all other services
  • Zuul proxy
    • defining, as API gateway / Zuul proxy as the API gateway