Index

A

• Abstract Factory pattern
  • benefits / Abstract factory design pattern
  • applying, common problems / Common problems where you should apply the Abstract factory design pattern
  • implementing, in Spring Framework / Implementing the Abstract factory design pattern in the Spring Framework
  • sample implementation / Sample implementation of the Abstract Factory design pattern, Sample implementation of FactoryBean interface
  • used, for resolving dependency / Resolving disambiguation in Autowiring DI pattern
  • implementing, in Spring (FactoryBean interface) / Implementing the Abstract Factory Pattern in Spring (FactoryBean interface)
  • implementing, in Spring / Implementation of FactoryBean interface in Spring
• AB testing strategies / Automation in microservices environment
• Accordance / Monitoring microservice dependency
• accountCache / The @Cacheable annotation
• AccountServiceImpl class / Enabling caching via the Proxy pattern
• ACID / Microservices with polyglot architecture
• active object pattern
  • about / Active object pattern
  • proxy / Active object pattern
  • servant / Active object pattern
  • activation list / Active object pattern
• Actuator / Monitoring tools
• advice
  • about / Advice
  • before / Advice, Advice type - Before
  • after / Advice, Advice Types: After
  • after-returning / Advice
  • after-throwing / Advice
  • around / Advice, Advice Types - Around
  • implementing / Implementing Advice
  • before, example / Before Advice example
  • after returning / Advice Types: After Returning
  • after returning, example / After Returning Advice example
  • after throwing / Advice Types: After Throwing
  • after throwing, example / After Throwing Advice example
  • after, example / After Advice example
  • around, example / Around Advice example
• advised method / Advice
• after advice / How Spring AOP works
• agents / CoreOS Fleet
• Aggregate Hystrix streams
  • with Turbine / Aggregate Hystrix streams with Turbine
• Airbnb
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?
• Alpine / Benefits of containers
• Amazon
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?
• Amazon EC2 Container Services (ECS) / CoreOS Fleet
• AMQP / What are Microservices?
• Annotation
  • used, for enabling caching proxy / Enabling the caching proxy using Annotation
• annotation-based configuration
  • using, with dependency injection pattern / Dependency injection pattern with Annotation-based configuration
• antifragility / Antifragility, fail fast, and self healing
• AOP proxies / Understanding AOP proxies
• Apache Camel / Service-oriented application
• Apex / Serverless computing
• AppConfig.javaconfiguration class
  • creating / Creating a Java configuration class - AppConfig.java
  • Spring beans, declaring into configuration class / Declaring Spring beans into configuration class
  • Spring beans, injecting / Injecting Spring beans
  • dependency injection pattern configuration, approach / Best approach to configure the dependency injection pattern with Java
• AppDynamics / Monitoring tools, Monitoring microservice dependency
• application development
  • simplifying, with Spring / Simplifying application development using Spring and its pattern
  • POJO pattern, using / Using the power of the POJO pattern
  • dependencies between POJOs, injecting / Injecting dependencies between POJOs
  • DI pattern, used for dependent components / Using DI pattern for dependent components
  • aspects, applying for cross-cutting concerns / Applying aspects for cross cutting concerns
• Application Performance Monitoring (APM) / Monitoring challenges
• application requirements / Understanding application requirement over the years
• approaches, for monitoring microservices
  • Application Performance Monitoring (APM) / Monitoring challenges
  • synthetic monitoring / Monitoring challenges
  • Real user monitoring (RUM) / Monitoring challenges
• Archiva / Bundle dependencies
• aspect
  • about / Aspect, Creating aspects
  • defining, Annotation used / Define aspects using Annotation
  • defining, XML configuration used / Define aspects using XML configuration
• Aspect-Oriented Programming (AOP)
  • about / Introducing Spring Framework, Applying aspects for cross cutting concerns, What is Aspect-Oriented Programming?
  • resolved problems / Problems resolved by AOP
  • terminology and concepts / Core AOP terminology and concepts
• Aurora / Apache Mesos
• autoscaling
  • about / Understanding autoscaling
  • with resource constraints / Understanding autoscaling
  • in specific time periods / Understanding autoscaling
  • based on message queue length / Understanding autoscaling
  • based on business parameters / Understanding autoscaling
  • predictive autoscaling / Understanding autoscaling
• autowiring
  • about / What are Stereotype annotations?
  • beans, annotating / Annotating beans for autowiring
  • @Autowired, using with setter method / Using @Autowired with setter method
  • @Autowired, using with fields / Using @Autowired with the fields
• Autowiring DI pattern
  • and disambiguation / The Autowiring DI pattern and disambiguation
  • disambiguation, resolving / Resolving disambiguation in Autowiring DI pattern
• Avro / What are Microservices?
• AWS EC2
  • Docker, installing / Installing Docker on AWS EC2
• AWS Lambda / Serverless computing
• Azure Container Services (ACS) / CoreOS Fleet
• Azure Functions / Serverless computing
• Azure service fabric
  • about / Microservice frameworks
  • URL / Microservice frameworks

B

• back-pressure mechanism / Back-pressure
• Backend as a Service (BaaS) / Microservice use cases
• before advice / How Spring AOP works
• benefits, containers
  • self contained / Benefits of containers
  • lightweight / Benefits of containers
  • scalability / Benefits of containers
  • portability / Benefits of containers
  • license cost / Benefits of containers
  • DevOps / Benefits of containers
  • version controlled / Benefits of containers
  • reusable / Benefits of containers
  • immutable containers / Benefits of containers
• benefits, microservices
  • polyglot architecture, supporting / Supports polyglot architecture
  • experimentation, enabling / Enables experimentation and innovation
  • innovation, enabling / Enables experimentation and innovation
  • elastic scalability / Elastically and selectively scalable
  • selective scalability / Elastically and selectively scalable
  • substitution, allowing / Allows substitution
  • organic systems build, enabling / Enables to build organic systems
  • technology debt, managing / Helps managing technology debt
  • versions co-existence, allowing / Allowing co-existence of different versions
  • self-organizing systems, building / Supporting building self-organizing systems
  • event-driven architecture, supporting / Supporting event-driven architecture
  • DevOps, enabling / Enables DevOps
• best practices
  • for configuring, DI pattern / Best practices for configuring the DI pattern
  • for JDBC / Best practices for Jdbc and configuring JdbcTemplate
• bill-of-materials (BOM) / Developing our first Spring Boot microservice
• blocking calls / Blocking calls
• Booking / Allows substitution
• Booking Service / An example of a travel agent portal
• Boot2Docker / Introduction to Docker
• bootfs / The Docker image
• breed integration
  • about / Best of the breed integration
  • log shippers / Log shippers
  • log stream processors / Log stream processors
  • log storage / Log storage
  • dashboards / Dashboards
• BrightWork / Serverless computing
• BrownField microservices
  • executing, on EC2 / Running BrownField services on EC2
  • Mesos, implementing / Implementing Mesos and Marathon for BrownField microservices
  • Marathon, implementing / Implementing Mesos and Marathon for BrownField microservices
• BrownField PSS
  • architecture, summarizing / Summarising the BrownField PSS architecture
  • challenges / Understanding gaps in the BrownField PSS microservices
• BrownField PSS services
  • preparing / Preparing BrownField PSS services
  • deploying / Deploying BrownField PSS services
• Builder design pattern
  • about / Builder design pattern, Common problems where you should apply Builder pattern
  • benefits / Benefits of the Builder pattern:
  • UML class structure / UML class structure
  • implementing, in Spring Framework / Implementing the Builder pattern in the Spring Framework
  • applying, to common issues / Sample implementation of the Builder design pattern
  • implementation, for creating embedded data source / Implementing the Builder pattern to create an embedded data source
• Business Layer / What are Microservices?

C

• @CachePut annotation
  • cache key, customizing / Customizing the cache key
  • conditional caching / Conditional caching
• cache
  • about / What is cache?
  • enabling, via Proxy pattern / Enabling caching via the Proxy pattern
• cache abstraction
  • about / Understanding cache abstraction
  • caching declaration / Understanding cache abstraction
  • cache configuration / Understanding cache abstraction
• cache storage configuration
  • about / Configuring the cache storage
  • CacheManager, setting up / Setting up the CacheManager
• caching
  • using / Where do we use caching?
  • best practices, in web application / Top caching best practices to be used in a web application
• caching proxy
  • enabling, Annotation used / Enabling the caching proxy using Annotation
  • enabling, XML namespace used / Enabling the Caching Proxy using the XML namespace
• Calico / What are containers?
• Cassandra / Technology as a catalyst for microservices evolution
• Catchpoint / Monitoring tools
• centralized logging solution
  • about / Centralized logging solution
  • components / Centralized logging solution
• cgroups / The Docker container, Mesos in details
• Chalice for Python / Serverless computing
• characteristics, microservices
  • services / Services are first class citizens
  • lightweight / Microservices are lightweight
  • polyglot architecture / Microservices with polyglot architecture
  • environment, automation / Automation in microservices environment
  • supporting ecosystem / Microservices with a supporting ecosystem
  • distributed / Microservices are distributed and dynamic
  • 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, services
  • service contract / Characteristics of service in a microservice
  • loose coupling / Characteristics of service in a microservice
  • service abstraction / Characteristics of service in a microservice
  • reuse / Characteristics of service in a microservice
  • statelessness / Characteristics of service in a microservice
  • discoverable / Characteristics of service in a microservice
  • interoperable / Characteristics of service in a microservice
  • composeability / Characteristics of service in a microservice
• Circonus / Monitoring tools
• Circuit Breaker
  • URL / Spring Cloud Hystrix for fault-tolerant microservices
  • about / Spring Cloud Hystrix for fault-tolerant microservices
• Cloud
  • about / DevOps, Cloud, and Containers
  • as self-service infrastructure, for microservices / Cloud and Containers as the self-service infrastructure for microservices
  • microservices, deploying on / Microservices on Cloud
• Cloud Foundry Diego / CoreOS Fleet
• Cloud Monitoring / Monitoring tools
• CloudTrail / Cloud services
• CloudWatch / Monitoring tools
• code scattering / Applying aspects for cross cutting concerns
• code tangling / Applying aspects for cross cutting concerns
• collectd / Monitoring tools
• Command Query Responsibility Segregation (CQRS) / Microservice use cases
• components, centralized logging solution
  • log streams / Centralized logging solution
  • log shippers / Centralized logging solution
  • log store / Centralized logging solution
  • log stream processor / Centralized logging solution
  • log dashboard / Centralized logging solution
• component scanning
  • about / What are Stereotype annotations?
  • used, for searching beans / Searching beans using component scanning
• concurrency module
  • best practices / Best practices for concurrency module
• Config Client / Spring Cloud Config
• Config Server
  • about / Spring Cloud Config
  • microservices, building / Building microservices with Config Server
  • setting up / Setting up the Config Server
  • accessing, from clients / Accessing the Config Server from clients
  • high availability, setting up / Setting up high availability for the Config Server
  • health, monitoring / Monitoring Config Server health
• constructor based dependency injection
  • advantages / Constructor-based dependency injection pattern
  • disadvantages / Constructor-based dependency injection pattern
  • example / Constructor-based dependency injection pattern
  • versus setter-based dependency injection / Setter-based dependency injection
• containerization
  • future / Future of containerization
• container orchestration
  • about / Container orchestration
  • importance / Why is container orchestration is important
  • actions / What does container orchestration do?
  • relationship, with microservices / Relationship with microservices
  • relationship, with virtualization / Relationship with virtualization
  • solutions / Container orchestration solutions
  • Mesos, using / Container orchestration with Mesos and Marathon
  • Marathon, using / Container orchestration with Mesos and Marathon
• container orchestration solutions
  • Docker Swarm / Docker Swarm
  • Kubernetes (k8s) / Kubernetes
  • Apache Mesos / Apache Mesos
  • HashiCorp Nomad / HashiCorp Nomad
  • CoreOS Fleet / CoreOS Fleet
• containers
  • about / DevOps, Cloud, and Containers, What are containers?
  • as self-service infrastructure, for microservices / Cloud and Containers as the self-service infrastructure for microservices
  • versus Virtual Machine (VM) / Difference between VM and containers
  • benefits / Benefits of containers
  • and microservices, relationship between / Microservices and containers
• Container technologies / Microservices are autonomous
• Content Management System (CMS) / An example of a travel agent portal
• continuous integration (CI) / Automation in microservices environment
• Conway's law
  • about / Microservice use cases
  • URL / Microservice use cases
• core design patterns
  • creational design pattern / Common GoF Design Pattern overview
  • structural design pattern / Common GoF Design Pattern overview
  • Behavioral design patterns / Common GoF Design Pattern overview
• Core Legacy System / Business demand as a catalyst for microservices evolution
• CouchDB / Technology as a catalyst for microservices evolution
• creational design pattern
  • about / Creational design patterns
  • factory design pattern / Factory design pattern
  • Abstract Factory pattern / Abstract factory design pattern
• cross-cutting concerns
  • template pattern, applying to eliminate boilerplate code / Applying the template pattern to eliminate boilerplate code
  • about / What are cross-cutting concerns?, What is Aspect-Oriented Programming?
• Cross Origin Resource Sharing (CORS)
  • enabling, for microservices interactions / Enabling cross origin for microservices interactions
  • about / Enabling cross origin for microservices interactions
• Cucumber / Automation in microservices environment
• custom caching annotations
  • creating / Creating custom caching annotations
• Customer Notification Service / Putting it all together - Developing a customer registration microservice example
• Customer Profile Service / Putting it all together - Developing a customer registration microservice example
• customer registration microservice example
  • developing / Putting it all together - Developing a customer registration microservice example
• custom health module
  • adding / Adding a custom health module
• custom metrics
  • building / Building custom metrics

D

• Dalston SR1 / Spring Cloud releases
• Dapper / Distributed tracing with Spring Cloud Sleuth
• data-access
  • designing, approaches / The best approach to designing your data-access
• data access object (DAO) pattern
  • about / The best approach to designing your data-access
  • used, for abstracting database access / Abstracting database access using the DAO pattern
  • using, with Spring Framework / The DAO pattern with the Spring Framework
• Data analysis
  • Data Lake, using / Data analysis using Data Lake
• Database Layer / What are Microservices?
• Data Centre Operating System (DCOS)
  • about / Mesos in details
  • used, for implementing Marathon / Implementing Mesos and Marathon with DCOS
  • used, for implementing Mesos / Implementing Mesos and Marathon with DCOS
  • reference / Implementing Mesos and Marathon with DCOS
  • differentiating, with Spring Cloud approach / Implementing Mesos and Marathon with DCOS
• Datadog / Monitoring tools
• Dataloop / Monitoring tools
• data source
  • configuring / Configuring the data source and object pool pattern
  • configuring, JDBC driver used / Configuring a data source using a JDBC driver
  • configuring, pool connections used / Configuring the data source using pool connections
• Declarative Annotation-based caching
  • about / Declarative Annotation-based caching
  • @Cacheable annotation / The @Cacheable annotation
  • @CachePut annotation / The @CachePut annotation
  • @CacheEvict annotation / The @CacheEvict annotation
  • @Caching annotation / The @Caching annotation
  • @CacheConfig annotation / The @CacheConfig annotation
• Declarative XML-based caching / Declarative XML-based caching
• Decorator design pattern
  • used, for proxying classes / Proxying classes using Decorator pattern in Spring
• dependency injection (DI) pattern
  • about / Introducing Spring Framework, Simplifying application development using Spring and its pattern, The dependency injection pattern
  • working / How DI works and makes things easy for development and testing
  • factory helper pattern, using / Using factory helper pattern for dependent components
  • used, for dependent components / Using DI pattern for dependent components
  • used, for solving issues / Solving problems using the dependencies injection pattern
  • avoiding / Without dependency injection
  • using / With dependency injection pattern
  • types / Types of dependency injection patterns
  • constructor-based / Constructor-based dependency injection pattern
  • setter-based / Setter-based dependency injection
  • configuring, with Spring / Configuring the dependency injection pattern with Spring
  • Java-based configuration, using with / Dependency injection pattern with Java-based configuration
  • XML-based configuration, using / Dependency injection pattern with XML-based configuration
  • annotation-based configuration, using / Dependency injection pattern with Annotation-based configuration
  • Stereotype annotations / What are Stereotype annotations?
  • configuring, best practices / Best practices for configuring the DI pattern
• dependency injector / With dependency injection pattern
• design patterns
  • about / Simplifying application development using Spring and its pattern, Introducing the power of design patterns
  • characteristics / Introducing the power of design patterns
• development environment
  • setting up / Setting up a development environment
• Device42 / Monitoring microservice dependency
• DevOps
  • URL / What are Microservices?
  • about / DevOps, Cloud, and Containers
  • practice, for microservices / DevOps as the practice and process for microservices
  • process, for microservices / DevOps as the practice and process for microservices
• Digital Performance Monitoring (DPM) / Monitoring challenges
• discovery
  • with Eureka / Eureka for registration and discovery
• Docker
  • about / Technology as a catalyst for microservices evolution, Isolation between build, release, and run, Introduction to Docker, The missing pieces
  • key components / Key components of Docker
  • microservices, deploying / Deploying microservices into Docker
  • URL / Deploying microservices into Docker
  • RabbitMQ, executing / Running RabbitMQ on Docker
  • installing, on AWS EC2 / Installing Docker on AWS EC2
• Docker Hub
  • URL / The Docker registry, Setting up the Docker Hub
  • setting up / Setting up the Docker Hub
  • microservices, publishing / Publish microservices to the Docker Hub
• Dockerization / Introduction to Docker
• Docker registry
  • using / Using the Docker registry
• Docker Trusted Registry (DTR) / The Docker registry
• Drawbridge / What are containers?
• Dynatrace / Monitoring tools, Monitoring microservice dependency

E

• eBay
  • URL / Microservices early adopters - Is there a common theme?
  • about / Microservices early adopters - Is there a common theme?
• EC2
  • BrownField microservices, executing / Running BrownField services on EC2
• EC2 Container Service (ECS) / Introduction to Docker
• Eclipse / Setting up a development environment
• Ehcache-based cache
  • about / Ehcache-based cache
  • XML-based configuration / XML-based configuration
• elastic / Reactive microservices
• Elastic Search / Microservices with polyglot architecture
• Elasticsearch, Logstash and Kibana (ELK) / Custom logging implementation, Monitoring tools
• embedded data source
  • creating, by implementing Builder pattern / Implementing the Builder pattern to create an embedded data source
• engine / CoreOS Fleet
• enterprise applications
  • service layer / The best approach to designing your data-access
  • data access layer / The best approach to designing your data-access
  • infrastructure layer / The best approach to designing your data-access
• Enterprise Integration Patterns (EIP) / Service-oriented integration
• Enterprise Service Bus (ESB)
  • about / Microservices are distributed and dynamic, Service-oriented integration
• Erlang / Microservices with polyglot architecture
• Eureka
  • used, for registration / Eureka for registration and discovery
  • used, for discovery / Eureka for registration and discovery
  • dynamic service registration / Understanding dynamic service registration and discovery
  • discovery / Understanding dynamic service registration and discovery
  • about / Understanding Eureka
  • Eureka Server, setting up / Setting up the Eureka Server
  • high availability / High availability for Eureka
• Eureka Client / Understanding Eureka
• Eureka Server / Understanding Eureka, Zuul proxy as the API Gateway
• examples, microservices
  • holiday portal / An example of a holiday portal
  • travel agent portal / An example of a travel agent portal
• Executor / Mesos architecture

F

• Fabric8
  • about / Microservice frameworks
  • URL / Microservice frameworks
• factory design pattern
  • benefits / Factory design pattern
  • issues / Factory design pattern
  • implementing, in Spring Framework / Implementing the Factory design pattern in Spring Framework
  • sample implementation / Sample implementation of the Factory design pattern
• Fail Fast / Antifragility, fail fast, and self healing
• Fake SMTP server
  • URL / Putting it all together - Developing a customer registration microservice example
• Fares / Allows substitution
• Fenzo / Apache Mesos
• Fleet / CoreOS Fleet
• Fluentd / Log shippers
• Flume / Log stream processors, Data analysis using Data Lake
• Flux / Reactive microservices using Spring WebFlux, Processor
• Flux type / The Annotation-based programming model
• followers / HashiCorp Nomad
• frameworks, microservice
  • Lagom / Microservice frameworks
  • WSO2 Microservices For Java - MSF4J / Microservice frameworks
  • Spark / Microservice frameworks
  • Seneca / Microservice frameworks
  • Vert.x / Microservice frameworks
  • Restlet / Microservice frameworks
  • Payra-micro / Microservice frameworks
  • Jooby / Microservice frameworks
  • Go-fasthttp / Microservice frameworks
  • JavaLite / Microservice frameworks
  • Fabric8 / Microservice frameworks
  • Hook.io / Microservice frameworks
  • Vamp / Microservice frameworks
  • Go Kit / Microservice frameworks
  • Micro / Microservice frameworks
  • Lumen / Microservice frameworks
  • Restx / Microservice frameworks
  • Gizmo / Microservice frameworks
  • Azure service fabric / Microservice frameworks
• Functions as a Service (FaaS) / Serverless computing

G

• Gang of Four (GOF) pattern
  • overview / Common GoF Design Pattern overview
• gateway / The Docker container
• Gilt
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?
• Gizmo
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Go-fasthttp
  • URL / Microservice frameworks
  • about / Microservice frameworks
• Go Kit
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Google Cloud Functions / Serverless computing
• Google Cloud Logging / Cloud services
• Google Container Engine / CoreOS Fleet
• Gordon / Serverless computing
• Gradle / Bundle dependencies, Setting up a development environment
• Grafana / Dashboards
• Graphite / Dashboards, Monitoring tools
• graylog / Externalizing logs, Off-the-shelf solutions
• Guest OS / Difference between VM and containers

H

• Hadoop / Technology as a catalyst for microservices evolution
• Hadoop Distributed File System (HDFS) / Supports polyglot architecture, Lambda architecture
• Half-Sync/Half-Async patterns
  • about / Half-Sync/Half-Async patterns
  • Synchronous Task Layer / Half-Sync/Half-Async patterns
  • Queuing Layer / Half-Sync/Half-Async patterns
  • Asynchronous Task Layer / Half-Sync/Half-Async patterns
• HATEOAS-enabled Spring Boot microservice / HATEOAS-enabled Spring Boot microservice
• Hexagonal Architecture
  • about / What are Microservices?
  • URL / What are Microservices?
• high availability
  • setting up, for Config Server / Setting up high availability for the Config Server
  • URL / Setting up high availability for the Config Server
  • setting up for Rabbit MQ, URL / Setting up high availability for the Config Server
• holiday portal / An example of a holiday portal
• honeycomb analogy / Microservices - The honeycomb analogy, A reactive microservice-based order management system
• Hook.io
  • about / Microservice frameworks
  • URL / Microservice frameworks
• HTrace / Distributed tracing with Spring Cloud Sleuth
• Hyper-V / Microservices are lightweight, Difference between VM and containers
• HyperMedia As The Engine Of Application State (HATEOAS) / HATEOAS-enabled Spring Boot microservice
• Hypertext Application Language (HAL) / HATEOAS-enabled Spring Boot microservice
• Hystrix
  • URL / Spring Cloud Hystrix for fault-tolerant microservices

I

• IBM OpenWhisk / Serverless computing
• In-Memory Data Grid (IMDG) / Elastically and selectively scalable
• infrastructure as code / Cloud and Containers as the self-service infrastructure for microservices
• Integration Platform as a Service (iPaaS)
  • about / Technology as a catalyst for microservices evolution
• IntelliJ IDEA / Setting up a development environment
• Internet of Things (IoT) / Business demand as a catalyst for microservices evolution
• Inversion of Control (IoC) pattern / With dependency injection pattern

J

• Java-based configuration
  • using, with Java-based configuration / Dependency injection pattern with Java-based configuration
• Java 8 / Benefits of containers
• JavaLite
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Java Logging (JUL) / Understanding log management challenges
• Java Management Extensions (JMX) / Introducing Spring Framework
• Java Message Service (JMS) / Introducing Spring Framework, What are Microservices?, Service-oriented integration
• JBoss / Microservices are autonomous
• JConsole
  • used, for monitoring / Monitoring using JConsole
• Jdbc callback interfaces
  • RowMapper, implementing / Jdbc callback interfaces
  • RowMapper class, creating / Creating a RowMapper class
  • RowCallbackHandler, implementing / Implementing RowCallbackHandler
  • ResultSetExtractor, implementing / Implementing ResultSetExtractor
• JDBC driver
  • used, for data source configuration / Configuring a data source using a JDBC driver
• JdbcTemplate
  • working with / Working with JdbcTemplate
  • using / When to use JdbcTemplate
  • creating, in application / Creating a JdbcTemplate in an application
  • JDBC-based repository, implementing / Implementing a JDBC-based repository
  • callback interfaces / Jdbc callback interfaces
  • configuring / Best practices for Jdbc and configuring JdbcTemplate
• JDK 1.8
  • URL / Setting up a development environment
• JEE design patterns
  • about / Common GoF Design Pattern overview
• Jetty / Expose services through port bindings
• jmxtrans / Monitoring tools
• jobs / HashiCorp Nomad
• join points / Core AOP terminology and concepts, Join Point
• Jooby
  • about / Microservice frameworks
  • URL / Microservice frameworks
• JRE / The Docker image

K

• Kafka / Log stream processors
• key capabilities, container orchestration
  • cluster management / What does container orchestration do?
  • deployments / What does container orchestration do?
  • scalability / What does container orchestration do?
  • health / What does container orchestration do?
  • infrastructure abstraction / What does container orchestration do?
  • resource optimizations / What does container orchestration do?
  • resource allocations / What does container orchestration do?
  • service availability / What does container orchestration do?
  • agility / What does container orchestration do?
  • isolation / What does container orchestration do?
• key components, Docker
  • Docker daemon / Key components of Docker, The Docker daemon
  • Docker client / Key components of Docker, The Docker client
  • Docker image / The Docker image
  • Docker containers / The Docker container
  • Docker registry / The Docker registry
  • Dockerfile / Dockerfile
• Kibana / Dashboards
• Kubernetes (k8s) / Automation in microservices environment, Kubernetes
• Kurma / What are containers?

L

• Lagom
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Lambda architecture
  • about / Lambda architecture
  • cognitive computing / Lambda architecture
  • Big Data / Lambda architecture
  • Bots / Lambda architecture
  • IoT / Lambda architecture
  • URL / Centralized logging solution
• Lambda Framework for Java / Serverless computing
• leader/follower pattern / Leader/follower pattern
• Librato / Monitoring tools
• Linux kernel / The Docker image
• Lmctfy / What are containers?
• Logentries / Cloud services
• logging solutions
  • selection / Selection of logging solutions
  • cloud services / Cloud services
  • off-the-shelf solutions / Off-the-shelf solutions
  • breed integration / Best of the breed integration
  • custom logging, implementation / Custom logging implementation
  • Spring Cloud Sleuth, distributed tracing / Distributed tracing with Spring Cloud Sleuth
• Loggly / Externalizing logs, Cloud services, Monitoring tools
• log management, challenges / Understanding log management challenges
• Logplex / Externalizing logs
• Logsene / Cloud services
• Logstash / Externalizing logs, Log shippers
• Lumen
  • URL / Microservice frameworks
  • about / Microservice frameworks
• LXD / What are containers?

M

• manager / Docker Swarm
• Mantl
  • about / Microservice frameworks
  • URL / Microservice frameworks
• MapR / Lambda architecture
• Marathon
  • about / Apache Mesos, Marathon
  • container orchestration / Container orchestration with Mesos and Marathon
  • implementing, with DCOS / Implementing Mesos and Marathon with DCOS
  • installing / Installing Mesos, Marathon, and related components
  • URL, for installation / Installing Mesos, Marathon, and related components
  • executing / Running Mesos and Marathon
• master / Kubernetes
• Maven / Bundle dependencies
• Maven 3.3.1
  • URL / Setting up a development environment
• Mean Time Between Failures (MTBF) / Antifragility, fail fast, and self healing
• Mesos
  • about / Automation in microservices environment
  • chain orchestration / Container orchestration with Mesos and Marathon
  • architecture / Mesos architecture
  • implementing, with DCOS / Implementing Mesos and Marathon with DCOS
  • installing / Installing Mesos, Marathon, and related components
  • installation link / Installing Mesos, Marathon, and related components
  • executing / Running Mesos and Marathon
• Mesos architecture
  • Master / Mesos architecture
  • Slave / Mesos architecture
  • ZooKeeper / Mesos architecture
  • Framework / Mesos architecture
  • Scheduler / Mesos architecture
  • Executor / Mesos architecture
  • workflow diagram / Mesos architecture
• Mesos Master / Mesos architecture
• Mesosphere DCOS / Technology as a catalyst for microservices evolution
• message based / Reactive microservices
• Micro
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Microservice A / Zuul proxy as the API Gateway
• microservices
  • about / What are Microservices?
  • URL / What are Microservices?
  • principles / Principles of microservices
  • characteristics / Characteristics of microservices
  • examples / Microservices examples
  • benefits / Microservices benefits
  • use cases / Microservice use cases
  • monolithic migration / Monolithic migration as the common use case
  • frameworks / Microservice frameworks
  • documenting / Documenting microservices
  • and containers, relationship between / Microservices and containers
  • deploying, into Docker / Deploying microservices into Docker
  • publishing, to Docker Hub / Publish microservices to the Docker Hub
  • deploying, on Cloud / Microservices on Cloud
  • scaling / Scaling microservices
  • relationship / Relationship with microservices
• microservices, monitoring
  • about / Monitoring microservices
  • challenges / Monitoring challenges
  • key areas / Monitoring challenges
  • approaches / Monitoring challenges
  • tools / Monitoring tools
  • dependency, monitoring / Monitoring microservice dependency
  • Spring Cloud Hystrix, used for fault-tolerant microservices / Spring Cloud Hystrix for fault-tolerant microservices
  • Aggregate Hystrix streams, with Turbine / Aggregate Hystrix streams with Turbine
• microservices evolution
  • about / Evolution of microservices
  • business demand, as catalyst / Business demand as a catalyst for microservices evolution
  • technology, as catalyst / Technology as a catalyst for microservices evolution
  • imperative architecture evolution / Imperative architecture evolution
• monitor object pattern
  • about / Monitor object pattern
  • monitor object / Monitor object pattern
  • synchronized method / Monitor object pattern
  • monitor conditions / Monitor object pattern
• Mono / Processor
• Mono type / The Annotation-based programming model

N

• Nagios / Monitoring tools
• namespace / The Docker container
• Neo 4j / Technology as a catalyst for microservices evolution
• NetBeans / Setting up a development environment
• Netflix
  • URL / Microservices early adopters - Is there a common theme?
  • about / Microservices early adopters - Is there a common theme?
• New Event Aggregation Service / Supporting event-driven architecture
• New Relic / Monitoring tools, Monitoring microservice dependency
• New Relic synthetic / Monitoring tools
• NewSQL / Technology as a catalyst for microservices evolution
• Nexus / Bundle dependencies
• Nike
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?
• nodes / Docker Swarm, Kubernetes
• Nomad / HashiCorp Nomad
• non-blocking calls / Non-blocking calls
• NoSQL / Technology as a catalyst for microservices evolution
• Notification Services / An example of a travel agent portal
• NuoDB / Technology as a catalyst for microservices evolution

O

• OAuth2
  • microservice, securing / Securing microservice with OAuth2
• Object-oriented programming (OOP) / What is Aspect-Oriented Programming?
• object pooling
  • connection pooling / Best practices for Jdbc and configuring JdbcTemplate
  • statement pooling / Best practices for Jdbc and configuring JdbcTemplate
• object pool pattern
  • configuring / Configuring the data source and object pool pattern
• Open Container Initiative (OCI) / Future of containerization
• Orbitz
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?
• Order Event / Supporting event-driven architecture, Reactive microservices
• organizations, using microservices
  • Netflix / Microservices early adopters - Is there a common theme?
  • Uber / Microservices early adopters - Is there a common theme?
  • Airbnb / Microservices early adopters - Is there a common theme?
  • Orbitz / Microservices early adopters - Is there a common theme?
  • eBay / Microservices early adopters - Is there a common theme?
  • Amazon / Microservices early adopters - Is there a common theme?
  • Gilt / Microservices early adopters - Is there a common theme?
  • Twitter / Microservices early adopters - Is there a common theme?
  • Nike / Microservices early adopters - Is there a common theme?
• oversubscriptions / What does container orchestration do?

P

• Papertrial / Cloud services
• pay as you use model / Serverless computing
• Payment Card Industry Data Security Standard (PCIDSS) / An example of a travel agent portal
• Payra-micro
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Pingdom / Monitoring tools
• Plain Old Java Object (POJO) / Service-oriented application, Adding a custom health module
• Platform as a Service (PaaS) / Technology as a catalyst for microservices evolution
• pods / Kubernetes
• pointcut
  • about / Core AOP terminology and concepts, Pointcut
  • defining / Defining pointcuts
  • writing / Writing pointcuts
• polyglot architecture
  • supporting / Supports polyglot architecture
• pool connections
  • used, for data source configuration / Configuring the data source using pool connections
• Ports and Adapters pattern / What are Microservices?
• Presentation Layer / What are Microservices?
• Pricing / Allows substitution
• principles, microservices
  • single responsibility per service / Single responsibility per service
  • autonomous / Microservices are autonomous
• program-to-interface (P2I) / Using factory helper pattern for dependent components
• Project Object Model (POM) / Bundle dependencies
• Prometheus / Monitoring tools
• Promise theory / Reactive microservices
• Protocol Buffers / What are Microservices?
• Prototype design pattern
  • about / Prototype design pattern
  • benefits / Benefits of the Prototype design pattern
  • UML class structure / UML class structure
  • sample implementation / Sample implementation of the Prototype design pattern
• Proxy design pattern
  • caching, enabling via / Enabling caching via the Proxy pattern

Q

• QBit / Reactive microservices
• Quality of Services (QoS) / Elastically and selectively scalable

R

• RabbitMQ
  • using, in reactive microservices / Reactive microservices using Spring Boot and RabbitMQ
  • URL / Reactive microservices using Spring Boot and RabbitMQ
  • executing, on Docker / Running RabbitMQ on Docker
• reactive manifesto
  • URL / Reactive microservices
• reactive microservices
  • about / Reactive microservices, Reactive Spring Boot microservices
  • order management system / A reactive microservice-based order management system
  • Spring WebFlux, using / Reactive microservices using Spring WebFlux
  • Reactive Streams / Understanding Reactive Streams
  • Spring Boot, using / Reactive microservices using Spring Boot and RabbitMQ
  • Rabbit MQ, using / Reactive microservices using Spring Boot and RabbitMQ
  • Spring Cloud Streams / Streams for reactive microservices
• reactive pattern
  • about / Understanding the reactive pattern
  • traits / The reactive pattern traits
• reactive Spring Boot application
  • URL / Reactive microservices using Spring WebFlux
• Reactive Streams / Reactive Streams
  • about / Reactive microservices using Spring WebFlux, Understanding Reactive Streams
  • Publisher / Publisher
  • subscriber / Subscriber
  • Subscription / Subscription
  • Processor / Processor
• reactor pattern
  • about / Reactor pattern
  • resources / Reactor pattern
  • synchronous event demultiplexer / Reactor pattern
  • dispatcher / Reactor pattern
  • Request Handler / Reactor pattern
• Reactor project
  • URL / Reactive microservices using Spring WebFlux
• Real user monitoring (RUM) / Monitoring challenges
• Red Hat Funktion / Serverless computing
• registration
  • with Eureka / Eureka for registration and discovery
• request body conversion / Request and response body conversion
• resilience
  • replication / Resilience
  • isolation / Resilience
  • containment / Resilience
  • delegation / Resilience
• resilient / Reactive microservices
• resolved problems, Aspect-Oriented Programming (AOP)
  • about / Problems resolved by AOP
  • code tangling / Code tangling
  • code scattering / Code scattering
  • working, for problem resolution / How AOP Works to solve problems
• resource management problem / The resource management problem
• response body conversion / Request and response body conversion
• responsive / Reactive microservices
• RESTful microservices
  • building, with Spring Boot / Spring Boot for building RESTful microservices
• Restlet
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Restx
  • URL / Microservice frameworks
  • about / Microservice frameworks
• Riemann / Monitoring tools
• Rocket / What are containers?
• rootfs / The Docker image
• Runscope / Monitoring tools
• Ruxit / Monitoring tools
• RxJava / Reactive microservices
• RxJS / Reactive microservices

S

• Scale Cube
  • about / Elastically and selectively scalable
  • URL / Elastically and selectively scalable
• Scheduler / Mesos architecture
• security
  • implementing / Implementing security
  • microservice, securing / Securing a microservice with basic security
  • microservice, securing with OAuth2 / Securing microservice with OAuth2
• Selenium / Automation in microservices environment
• Seneca
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Sensu / Monitoring tools
• Serverless / Serverless computing
• serverless computing / Serverless computing
• Service-Oriented Architecture (SOA)
  • about / Evolution of microservices, Service-Oriented Architecture (SOA)
  • URL / Characteristics of service in a microservice, Service-Oriented Architecture (SOA)
  • srvice-oriented integration / Service-oriented integration
  • legacy modernization / Legacy modernization
  • application / Service-oriented application
  • used, for monolithic migration / Monolithic migration using SOA
• Service-Oriented Integration (SOI) / Service-oriented integration
• services
  • about / Services are first class citizens
  • characteristics / Characteristics of service in a microservice
• setter-based dependency injection
  • about / Setter-based dependency injection
  • advantages / Setter-based dependency injection
  • disadvantages / Setter-based dependency injection
  • example / Setter-based dependency injection
  • versus constructor / Setter-based dependency injection
• Simian Army / Antifragility, fail fast, and self healing
• Simple Mail Transfer Protocol (SMTP) / Supporting building self-organizing systems
• Singleton design pattern
  • about / Singleton design pattern
  • early instantiation / Singleton design pattern
  • lazy instantiation / Singleton design pattern
  • benefits / Singleton design pattern
  • applying, in issues / Common problems where you should apply Singleton pattern
  • implementation, Spring Framework / Singleton design pattern implementation in the Spring Framework
  • sample implementation / Sample implementation of the Singleton design pattern
• software defined infrastructure / Cloud and Containers as the self-service infrastructure for microservices
• SOLID design pattern
  • about / Single responsibility per service
  • URL / Single responsibility per service
• Span / Distributed tracing with Spring Cloud Sleuth
• Spark Streaming / Log stream processors, Data analysis using Data Lake
• Sparta for Go / Serverless computing
• Spigo / Monitoring tools
• Splunk / Externalizing logs, Off-the-shelf solutions, Monitoring tools
• Spring
  • used, for simplifying application development / Simplifying application development using Spring and its pattern
  • Template Design pattern / The Template Design pattern in Spring
  • dependency injection pattern, configuring / Configuring the dependency injection pattern with Spring
  • Proxy pattern / Proxy pattern in Spring
• Spring 5 Framework
  • reactive, implementing / Implementing reactive with the Spring 5 Framework
• Spring AOP
  • working / How Spring AOP works
• Spring beans, injecting
  • constructor injection, using / Using constructor injection
  • setter injection, using / Using setter injection
• Spring beans, Spring container
  • bean / Life of a bean in the container
  • life cycle / Life of a bean in the container
  • about / With dependency injection pattern
• Spring Boot
  • about / Microservice frameworks, Getting started with Spring Boot
  • used, for building RESTful microservices / Spring Boot for building RESTful microservices
  • using, in reactive microservices / Reactive microservices using Spring Boot and RabbitMQ
• Spring Boot actuators
  • used, for microservices instrumentation / Spring Boot actuators for microservices instrumentation
  • monitoring, JConsole used / Monitoring using JConsole
  • monitoring, SSH used / Monitoring using ssh
  • custom health module, adding / Adding a custom health module
  • custom metrics, building / Building custom metrics
• Spring Boot CLI / Getting started with Spring Boot
• Spring Boot microservice
  • developing / Developing a Spring Boot microservice, Developing our first Spring Boot microservice
  • reference / Developing a Spring Boot microservice
  • URL, for dependencies / Developing our first Spring Boot microservice
  • testing / Testing Spring Boot microservice
• Spring Cloud
  • about / Microservice frameworks, What is Spring Cloud?
  • releases / Spring Cloud releases
• Spring Cloud Bus
  • for propagating configuration changes / Spring Cloud Bus for propagating configuration changes
• Spring Cloud Config Server
  • about / Spring Cloud Config
  • microservices, building with Config Server / Building microservices with Config Server
  • Config Server, setting up / Setting up the Config Server
  • Config Server URL / Understanding the Config Server URL
  • Config Server, accessing from clients / Accessing the Config Server from clients
  • 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 Config Server health
  • Config Server, for configuration files / Config Server for configuration files
  • Config Server, using / Completing changes to use Config Server
• Spring Cloud Data Flow / Log stream processors, Data analysis using Data Lake
• Spring Cloud Hystrix
  • using / Spring Cloud Hystrix for fault-tolerant microservices
• Spring Cloud Security
  • used, for protecting microservices / Protecting microservices with Spring Cloud Security
• Spring Cloud Sleuth
  • distributed tracing / Distributed tracing with Spring Cloud Sleuth
• Spring Cloud Stream / Log stream processors
• Spring Cloud Streams
  • about / Reactive microservices, Data analysis using Data Lake
  • using, in reactive microservices / Streams for reactive microservices
• Spring Cloud Streams modules / Log stream processors, Data analysis using Data Lake
• Spring container
  • using / Using a Spring container to manage beans with the Factory pattern
  • application contexts / Using a Spring container to manage beans with the Factory pattern
  • Bean factory / Using a Spring container to manage beans with the Factory pattern
  • bean factory / Bean factory
  • creating, with application context / Creating a container with an application context
• Spring Framework
  • about / Introducing Spring Framework
  • benefits / Introducing Spring Framework
• Spring Framework 5 / Microservice frameworks
• Spring Framework 5.0
  • features / New features in Spring Framework 5.0
• Spring Initializr
  • URL / Getting started with Spring Boot, HATEOAS-enabled Spring Boot microservice
  • about / HATEOAS-enabled Spring Boot microservice
• Spring Integration / Service-oriented application
• Spring Inversion of Control (IOC) / Introducing Spring Framework
• Spring modules
  • about / Spring modules
  • core Spring container / Core Spring container
  • AOP module / Spring's AOP module
  • data access and integration / Spring DAO - data access and integration
  • ORM / Spring's ORM
  • web MVC / Spring web MVC
• Spring Reactive / Reactive microservices
• Spring Streams / Microservice frameworks
• Spring Tool Suite (STS) / Getting started with Spring Boot
• Spring Tool Suite 3.8.2 (STS)
  • URL / Setting up a development environment
• Spring Web reactive module
  • about / Spring Web reactive module
  • comparisons / Spring Web reactive module
  • implementing, at server side / Implementing a reactive web application at the server side
  • annotation-based programming model / Implementing a reactive web application at the server side
  • functional programming model / Implementing a reactive web application at the server side, The functional programming model
  • Reactive Client-Side application, implementing / Implementing a Reactive Client-Side application
• SSH
  • used, for monitoring / Monitoring using ssh
• statd / Monitoring tools
• Stereotype annotations
  • about / What are Stereotype annotations?
  • automatic wiring, creating / What are Stereotype annotations?
  • used, for creating auto searchable beans / Creating auto searchable beans using Stereotype annotations
• Storm / Log stream processors
• strategies, resource allocation
  • spread / What does container orchestration do?
  • bin packing / What does container orchestration do?
  • random / What does container orchestration do?
• subnet / The Docker container
• Sumo Logic / Cloud services
• Swarm Intelligence / Reactive microservices
• Systemd Nspawn / What are containers?

T

• t2.large EC2 / Installing Mesos, Marathon, and related components
• task groups / HashiCorp Nomad
• template design pattern
  • implementing / Implementing the template design pattern
  • traditional JDBC, issues / Problems with the traditional JDBC
  • issues, solving with Spring's JdbcTemplate / Solving problems with Spring's JdbcTemplate
• The Software Development Kit Manager (SDKMAN)
  • URL / Getting started with Spring Boot
• third-party cache implementations
  • about / Third-party cache implementations
  • Ehcache-based cache / Ehcache-based cache
• thread-specific storage pattern / Thread-specific storage pattern
• Thrift / What are Microservices?
• Tomcat / An example of a holiday portal
• Trace / Distributed tracing with Spring Cloud Sleuth, Monitoring tools
• Trace-id / Distributed tracing with Spring Cloud Sleuth
• traits, reactive pattern
  • responsiveness / The reactive pattern traits, Responsiveness
  • resilient / The reactive pattern traits
  • scalable / The reactive pattern traits, Scalable
  • message-driven / The reactive pattern traits
  • resilience / Resilience
  • message-driven architecture / Message-driven architecture
• Travel Agent Portal / An example of a travel agent portal
• Twelve-Factor Apps
  • about / Twelve-Factor Apps
  • single code base / Single code base
  • bundle dependencies / Bundle dependencies
  • configurations, externalizing / Externalizing configurations
  • backing services / Backing services are addressable
  • build stage and release stage, isolating between / Isolation between build, release, and run
  • release stage and run stage, isolating between / Isolation between build, release, and run
  • stateless processes / Stateless, shared nothing processes
  • process share, avoiding / Stateless, shared nothing processes
  • services expose, through port binding / Expose services through port bindings
  • concurrency, for scale out / Concurrency for scale out
  • disposability, with minimal overhead / Disposability, with minimal overhead
  • development, production parity principle / Development, production parity
  • logs, externalizing / Externalizing logs
  • admin processes, packaging / Package admin processes
• Twitter
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?

U

• Uber
  • about / Microservices early adopters - Is there a common theme?
  • URL / Microservices early adopters - Is there a common theme?

V

• Vamp
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Vert.x
  • about / Microservice frameworks
  • URL / Microservice frameworks
• Vertias Risk Advisor (VRA) / Monitoring microservice dependency
• virtual engines (VEs) / What are containers?
• virtual machines (VM)
  • versus containers / Difference between VM and containers
  • about / Difference between VM and containers
• VMWare / Difference between VM and containers

W

• Weave scope / Monitoring tools
• weaving / Weaving
• web application
  • caching best practices / Top caching best practices to be used in a web application
• WebFlux
  • about / Reactive Spring Boot microservices
  • using, in reactive microservices / Reactive microservices using Spring WebFlux
• Weblogic / Microservices are autonomous
• WebSphere / Microservices are autonomous
• Webtask / Serverless computing
• Wildfly Swarm / Microservice frameworks
• wiring / Using DI pattern for dependent components
• WSO2 Microservices For Java - MSF4J
  • URL / Microservice frameworks

X

• XML-based configuration file
  • using, with dependency injection pattern / Dependency injection pattern with XML-based configuration
  • creating / Creating an XML configuration file
  • Spring beans, declaring / Declaring Spring beans in an XML file
  • Spring beans, injecting / Injecting Spring beans
• XML configuration
  • used, for defining aspects / Define aspects using XML configuration
• XML namespace
  • used, for enabling caching proxy / Enabling the Caching Proxy using the XML namespace

Y

• Your Application Classes (POJOs) / Configuring the dependency injection pattern with Spring

Z

• Zabbix / Monitoring tools
• Zen / Difference between VM and containers
• ZeroMQ / What are Microservices?
• Zipkin / Distributed tracing with Spring Cloud Sleuth
• ZooKeeper / Apache Mesos, Mesos architecture
• Zuul proxy
  • using, as API Gateway / Zuul proxy as the API Gateway
  • setting up / Setting up Zuul
  • high availability / High availability of Zuul
  • high availability, with Eureka Client / High availability of Zuul when the client is also a Eureka Client
  • high availability, without Eureka Client / High availability when client is not a Eureka Client
  • completing, for other services / Completing Zuul for all other services