Index

A

• ActiveMQ
  • starting / Starting ActiveMQ
  • topic, creating / Creating a topic
• Amazon Machine Images (AMI) / Suitability
• Amazon Web Services (AWS) / XaaS
• Anything as a Service (XaaS)
  • about / XaaS
  • building, design concerns / Key design concerns when building XaaS
• API aggregation pattern
  • benefits / API aggregation
  • trade-offs / API aggregation
• API design concerns
  • about / API design concerns
  • API resource identification / API resource identification
  • API design guidelines / API design guidelines
• API design guidelines
  • about / API design guidelines
  • naming and associations / Naming and associations
  • base URL, for resource / Base URLs for a resource
  • errors, handling / Handling errors
  • service versioning / Versioning
  • pagination / Pagination
  • attributes / Attributes
  • data formats / Data formats
  • client support for limited HTTP methods / Client support for limited HTTP methods
  • authentication and authorization / Authentication and authorization
  • endpoint redirection / Endpoint redirection
  • content negotiation / Content negotiation
  • secure / Secure
• API gateway deployment models
  • about / API gateway deployment models
  • type of client or channel / API gateway deployment models
  • data transformation / API gateway deployment models
  • versioning / API gateway deployment models
  • orchestration / API gateway deployment models
  • service discovery / API gateway deployment models
  • timeouts, handling / API gateway deployment models
  • data caching / API gateway deployment models
  • service invocation / API gateway deployment models
  • service metering/throttling / API gateway deployment models
  • API monitoring / API gateway deployment models
• API gateways
  • role / Role of API gateways
  • benefits / Benefits of an API gateway
• API modeling
  • about / API modeling
  • Open API / Open API
  • RESTful API Modeling Language (RAML) / RESTful API Modeling Language (RAML)
• API resource identification
  • about / API resource identification
  • system API / System API
  • process API / Process API
  • channel API / Channel API
• application decoupling
  • about / Application decoupling
  • bounded context/domain-driven design / Bounded context/domain-driven design
  • classification into up/downstream services / Classification into up/downstream services
  • business events / Business events
• application portfolio rationalization
  • about / Application portfolio rationalization
  • analysis, business and technical parameters / Portfolio analysis – business and technical parameters
• Application Programming Interface (API)
  • popularity / Rise and popularity of the APIs
• architecture runway
  • defining / Defining the architecture runway
• artificial intelligence (AI) / Azure platform
• asynchronous processing
  • fire-and-forget / Asynchronous messaging
  • request/response / Asynchronous messaging
• authentication services, features
  • multi-factor authentication (MFA) / Integration with third-party APIs
  • user management / Integration with third-party APIs
  • plugins/widgets / Integration with third-party APIs
• AWS Platform
  • about / AWS platform
  • Application / AWS platform
  • Database / AWS platform
  • DevOps / AWS platform
  • Security / AWS platform
  • Mobile / AWS platform
  • Analytics / AWS platform
  • deployment options / AWS platform deployment options
• AWS Platform deployment options
  • about / AWS platform deployment options
  • Spring Boot API, deploying to Beanstalk / Deploying Spring Boot API to Beanstalk
  • Spring Boot App, deploying to Elastic Container Service / Deploying Spring Boot App to the Elastic Container Service
  • AWS Lambda, deploying / Deploying to AWS Lambda
• Azure
  • platform / Azure platform
  • reference / Azure platform deployment options
• Azure cloud functions
  • about / Azure cloud functions
  • environment setup / Environment setup
  • Java functions project / Creating a new Java functions project
  • Java function, building / Building and running the Java function
  • code / Diving into code
• Azure platform
  • deployment options / Azure platform deployment options

B

• Backend as a Service (BaaS) / Integration with third-party APIs
• behavior-driven development (BDD) / Testing and development, BDD
• benefits, API gateways
  • separation of concerns / Benefits of an API gateway
  • consumer oriented / Benefits of an API gateway
  • API oriented / Benefits of an API gateway
  • orchestration / Benefits of an API gateway
  • monitor / Benefits of an API gateway
• blue-green deployment / Blue-green deployment

C

• caching
  • about / Caching
  • local cache / Local cache
• canary deployment / Canary deployment
• capabilities, microservices coordination pattern
  • state management / Capabilities for microservices coordination
  • transaction control / Capabilities for microservices coordination
  • post service call coordination / Capabilities for microservices coordination
  • timeout handling / Capabilities for microservices coordination
  • configurability / Capabilities for microservices coordination
• change data capture (CDC) / Database aggregation
• characteristics, distributed application
  • lightweight runtime containers / Monolithic application to distributed cloud-native application
  • transaction management / Monolithic application to distributed cloud-native application
  • service scaling / Monolithic application to distributed cloud-native application
  • load balancing / Monolithic application to distributed cloud-native application
  • flexible deployment / Monolithic application to distributed cloud-native application
  • configuration / Monolithic application to distributed cloud-native application
  • service discovery / Monolithic application to distributed cloud-native application
  • service versions / Monolithic application to distributed cloud-native application
  • monitoring / Monolithic application to distributed cloud-native application
  • event handling/messaging/asynchronous / Monolithic application to distributed cloud-native application
  • non-blocking I/O / Monolithic application to distributed cloud-native application
  • polyglot services / Monolithic application to distributed cloud-native application
  • high-performance persistence / Monolithic application to distributed cloud-native application
  • health check and recovery / Monolithic application to distributed cloud-native application
  • cross-service security / Monolithic application to distributed cloud-native application
• cloud-native
  • need for / Why go cloud-native?
  • lifting / Lift and shift
  • shifting / Lift and shift
  • serverless / Going serverless
  • and microservices / Cloud-native and microservices
• cloud-native application
  • about / What is cloud-native?
  • bottlenecks / Cloud-native and microservices
• cloud-native application, benefits
  • platform services replacement / Going native
  • application services replacement / Going native
• cloud-native behaviors
  • enabling / Enabling cloud-native behaviors
  • configuration, externalizing / Externalizing configuration
  • service, metering / Metering your services
  • service registration / Service registration and discovery
  • service discovery / Service registration and discovery
• Command Query Responsibility Segregation (CQRS)
  • about / Command Query Responsibility Segregation (CQRS), Monolithic application to distributed cloud-native application
  • applying, for data model and service separation / Applying CQRS to separate data models and services
  • materialized views, on relational database / Materialized views on a relational database
  • NoSQL technologies, using / Elasticsearch and a document database
  • ore product service / Core product service on a document database
  • Product Search service / The product-search service
• commercial off-the-shelf (COTS) / Going native, System API
• containers
  • about / Containers
  • Docker / Docker
• content aggregation patterns
  • about / Content aggregation patterns
  • aggregation by client / Aggregation by client
  • API aggregation / API aggregation
  • microservice aggregation / Microservice aggregation
  • database aggregation / Database aggregation
• continuous deployment (CD) / Deployment patterns
• continuous integration (CI) / Testing and development, Types of testing, Deployment patterns
• control
  • versus delegation / Building your own platform services (control versus delegation)
• coordination models
  • asynchronous parallel / Asynchronous parallel
  • asynchronous sequential / Asynchronous sequential
  • orchestration, using request/response / Orchestration using request/response
  • microservices, collapsing / Collapsing the microservices
• coordination patterns
  • business process management (BPM) / Business process management (BPM)
  • composite services / Composite services, Why composite services?
  • capabilities / Capabilities for microservices coordination
• core product service
  • executing, on document database / Core product service on a document database
  • MongoDB, downloading / Getting MongoDB ready with test data
  • product service, creating / Creating the product service
  • splitting / Splitting the services
• Create, Read, Update, and Delete (CRUD) / Simple product table
• Cucumber
  • need for / Why Cucumber?
  • working / How does Cucumber work?
• customer journey
  • mapping, to domain-driven design / Customer journey mapping to domain-driven design
• customer relationship management (CRM) / System API

D

• data access objects (DAO) / Simple product table
• data architecture, microservices
  • about / Data architecture for microservices
  • Command Query Responsibility Segregation (CQRS) / Command Query Responsibility Segregation (CQRS)
  • data, duplicating / Duplicating data
  • bounded context model / Fit for purpose
• database aggregation pattern
  • benefits / Database aggregation
  • trade-offs / Database aggregation
• data duplication
  • about / Duplicating data
  • benefits / Benefits
  • cons / Cons
• data updates
  • event, raising / Raising an event on data updates
  • Spring JMSTemplate, used for sending messages / Using Spring JMSTemplate to send a message
• data update services
  • about / Data update services
  • REST conventions / REST conventions
  • validations / Validations and error messages
  • error messages / Validations and error messages
  • for CQRS / Data updates for CQRS
  • asynchronous messaging / Asynchronous messaging
  • golden source update / Golden source update
  • event, raising / Raising an event on data updates
  • query model update / Query model update
• deployment models
  • about / Deployment models
  • virtualization / Virtualization
  • PaaS / PaaS
  • containers / Containers
  • Docker images, building / Building Docker images
• deployment options, Azure platform
  • Spring Boot API, deploying to Azure App service / Deploying Spring Boot API to Azure App Service
  • Docker container, deploying to Azure Container Service / Deploying Docker containers to Azure Container Service
  • Spring Boot API, deploying to Azure Service Fabric / Deploying Spring Boot API to Azure Service Fabric
  • cloud functions / Azure cloud functions
• deployment patterns
  • about / Design and deployment patterns, Deployment patterns, Deployment patterns
  • multiple services per WAR file / Multiple services per WAR file
  • service per WAR/EAR / Service per WAR/EAR
  • service per process / Service per process
  • service per Docker container / Service per Docker container
  • service per VM / Service per VM
  • service per host / Service per host
  • release patterns / Release patterns
  • blue-green deployment / Blue-green deployment
  • canary deployment / Canary deployment
  • dark release / Dark release
  • CI/CD, applying for automation / Applying CI/CD to automate, Summary
• design considerations
  • lightweight runtime / Selecting a framework
  • high resiliency / Selecting a framework
  • measurable and monitorable / Selecting a framework
  • efficient / Selecting a framework
• design guidelines, microservice
  • lightweight / Microservice design guidelines
  • reactive / Microservice design guidelines
  • stateless / Microservice design guidelines
  • atomic / Microservice design guidelines
  • externalized configuration / Microservice design guidelines
  • consistent / Microservice design guidelines
  • resilient / Microservice design guidelines
  • good citizens / Microservice design guidelines
  • versioned / Microservice design guidelines
• design patterns
  • about / Design patterns
  • content aggregation patterns / Content aggregation patterns
  • coordination patterns / Coordination patterns
  • coordination models / Coordination models
• designs concerns, Anything as a Service (XaaS)
  • multi-tenancy / Key design concerns when building XaaS
  • faster provisioning / Key design concerns when building XaaS
  • auditing / Key design concerns when building XaaS
  • security / Key design concerns when building XaaS
  • data storage / Key design concerns when building XaaS
  • monitoring / Key design concerns when building XaaS
  • error handling / Key design concerns when building XaaS
  • automated build/deployment / Key design concerns when building XaaS
  • customer tiers / Key design concerns when building XaaS
  • feature flags / Key design concerns when building XaaS
  • self-service portal / Key design concerns when building XaaS
  • software development kits (SDKs) / Key design concerns when building XaaS
  • documentation and community support / Key design concerns when building XaaS
  • product roadmap / Key design concerns when building XaaS
• developer toolbox
  • setting up / Setting up your developer toolbox
  • integrated development environment (IDE), obtaining / Getting an IDE
  • internet connectivity, setting up / Setting up internet connectivity
• development life cycle
  • about / Understanding the development life cycle
  • requirements/user stories / Requirements/user stories
  • architecture / Architecture
  • design / Design
  • testing phase / Testing and development
  • building phase / Building and deployment
  • deployment phase / Building and deployment
• distributed application
  • developer build / Developer build
• distributed cache / Distributed cache
• distributed cloud-native application
  • monolithic application / Monolithic application to distributed cloud-native application
• Docker images, building
  • about / Building Docker images
  • Eureka server, using / Eureka server
  • product API, working on / Product API
  • external Postgres container, connecting to / Connecting to an external Postgres container
• document database
  • and Elasticsearch / Elasticsearch and a document database
  • using / Why not use only a document database or Elasticsearch?

E

• Eclipse
  • reference / Getting an IDE
• Elastic Container Service (ECS) / Deploying Docker containers, Deploying Spring Boot App to the Elastic Container Service
• Elasticsearch
  • and document database / Elasticsearch and a document database
  • using / Why not use only a document database or Elasticsearch?
• enterprise resource planning (ERP) / System API

F

• 12-factor app
  • about / The 12-factor app
  • single codebase / The 12-factor app
  • dependencies / The 12-factor app
  • config / The 12-factor app
  • backing services / The 12-factor app
  • build, release and run process / The 12-factor app
  • processes / The 12-factor app
  • port binding / The 12-factor app
  • concurrency / The 12-factor app
  • disposability / The 12-factor app
  • dev/prod parity / The 12-factor app
  • logs / The 12-factor app
  • admin processes / The 12-factor app
  • microservices-enabling service ecosystem / Microservices-enabling service ecosystem
• features, microservice
  • single responsibility principle / Microservice identification
  • granular / Microservice identification
  • bounded / Microservice identification
  • independent / Microservice identification
• format validations
  • data validations / Data validations
  • business validations / Business validations
  • exceptions / Exceptions and error messages
  • error messages / Exceptions and error messages
• framework
  • selecting / Selecting a framework
  • design considerations / Selecting a framework
  • reference / Selecting a framework
  • Dropwizard / Dropwizard
  • Vert.x / Vert.x
  • Spring Boot / Spring Boot

G

• get services implementation
  • about / Implementing the get services
  • product table, using / Simple product table
  • caching / Caching
  • distributed cache / Distributed cache
  • CQRS, applying for data model and services / Applying CQRS to separate data models and services
• Gherkin / Why Cucumber?
• Git client / Getting an IDE
• GoInstant / Integration with third-party APIs
• golden source update
  • about / Golden source update
  • service methods / Service methods
• Google Cloud Platform (GCP) / XaaS

H

• HTTP / The trio – REST, HTTP, and JSON

I

• Infrastructure as a Service (IaaS) / Why go cloud-native?, XaaS
• integrated development environment (IDE) / Getting an IDE
• integration testing / Integration testing
• Internet of Things (IoT) / Why go cloud-native?, Azure platform, Building your own platform services (control versus delegation)

J

• JaCoCo
  • integrating / Integrating JaCoCo
• Java Persistence API (JPA) / Simple product table
• JavaScript Object Notation (JSON) / The trio – REST, HTTP, and JSON

L

• Lightweight Directory Access Protocol (LDAP) / XaaS
• load testing / Load testing
• local cache
  • about / Local cache, Under the hood
  • limitations / Limitations of a local cache

M

• Machine Learning (ML) / Monolithic application to distributed cloud-native application
• Maven support / Getting an IDE
• microservice
  • service-oriented architecture (SOA), differences / Differences between microservices and service-oriented architecture (SOA)
  • types / Service granularity
  • atomic or system services / Service granularity
  • composite (process service) / Service granularity
  • experience services / Service granularity
  • design guidelines / Microservice design guidelines
  • dynamic service registry / Microservice design guidelines
  • log aggregation / Microservice design guidelines
  • external configuration / Microservice design guidelines
  • provisioning and auto-scaling / Microservice design guidelines
  • API gateway / Microservice design guidelines
  • data architecture / Data architecture for microservices
• microservice adoption
  • about / Microservice adoption
  • monolithic transformation / Monolithic transformation
• microservice aggregation pattern
  • benefits / Microservice aggregation
  • trade-offs / Microservice aggregation
• microservices-enabling service ecosystem
  • service discovery / Microservices-enabling service ecosystem
  • config server / Microservices-enabling service ecosystem
  • service management/monitoring / Microservices-enabling service ecosystem
  • container management/orchestration / Microservices-enabling service ecosystem
  • log aggregation / Microservices-enabling service ecosystem
  • API Gateway/management / Microservices-enabling service ecosystem
  • DevOps / Microservices-enabling service ecosystem
• minimum viable product (MVP) / Key design concerns when building XaaS
• MongoDB
  • reference / Getting MongoDB ready with test data
• monolithic application
  • transforming, to distributed application / Transformation of a monolithic application to a distributed application
  • breaking / Breaking the monolithic application
  • initial state / Breaking the monolithic application
  • code refactoring / Breaking the monolithic application
  • build process update / Breaking the monolithic application
  • Java version update / Breaking the monolithic application
  • circuit breaker / reactive patterns / Breaking the monolithic application
  • feature flag implementation / Breaking the monolithic application
  • ongoing functional updates / Breaking the monolithic application
  • summarizing / Bringing it all together
• multiple services per WAR file model
  • benefits / Benefits and trade-offs
  • trade-offs / Benefits and trade-offs
  • suitability / Suitability
• Multi Version Concurrency Control (MVCC) / Monolithic application to distributed cloud-native application

N

• Node Package Manager (NPM) / Basic environment setup

O

• Open Web Application Security Project (OWASP) / The role of security

P

• parse / Integration with third-party APIs
• Plain Old Java Object (POJO) class / Writing service and domain objects
• Platform as a Service (PaaS) / Why go cloud-native?, XaaS
• platform services
  • building / Building your own platform services (control versus delegation)
• principles, microservices
  • single-responsibility principle / Cloud-native and microservices
  • sharing, restricting / Cloud-native and microservices
  • reactive / Cloud-native and microservices
  • externalized configuration / Cloud-native and microservices
  • consistent / Cloud-native and microservices
  • resilient / Cloud-native and microservices
  • good citizens / Cloud-native and microservices
  • versioned / Cloud-native and microservices
  • independent deployment / Cloud-native and microservices
• Privacy Enhanced Mail (PEM) / Connecting to the Service Fabric party cluster
• Product API application deployment
  • local cluster, connecting / Connecting to the local cluster
  • connecting, to Service Fabric party cluster / Connecting to the Service Fabric party cluster
• product client
  • creating / Creating a product client
  • lookup / Seeing the lookup in action
• Product Search service
  • about / The product-search service
  • Elasticsearch, with test data / Getting Elasticsearch ready with test data
  • creating / Creating the product-search service
• product service
  • writing / Writing a product service, Writing service and domain objects
  • Maven project, creating / Creating a Maven project
  • Spring Boot application class, writing / Writing a Spring Boot application class
  • domain objects, writing / Writing service and domain objects
  • running / Running the service
  • testing, on browser / Testing the service on the browser
  • deployable service, creating / Creating a deployable
  • registering / Registering a product service
  • testing / Testing the Product service
  • BDD through Cucumber / BDD through Cucumber
  • Spring Boot Test / Spring Boot Test
  • code coverage, using JaCoCo / Code coverage using JaCoCo
  • JaCoCo, integrating / Integrating JaCoCo
• product table
  • using / Simple product table
  • service, executing / Running the service
  • traditional databases, limitations / Limitations of traditional databases
• Project Object Models (POMs) / Spring Boot

Q

• query model update
  • insert method / Insert, update, and delete methods
  • delete methods / Insert, update, and delete methods
  • update method / Insert, update, and delete methods
  • CQRS update scenario, testing / Testing the CQRS update scenario end to end

R

• regression testing / Regression testing
• relational database management systems (RDMBS) / Going native
• release patterns
  • Fat JAR / Release patterns
  • blue-green deployment / Release patterns
  • semantic versioning / Release patterns
  • canary release / Release patterns
  • immutable server / immutable delivery / Release patterns
  • feature toggle / Release patterns
  • dark launch / Release patterns
• REST / The trio – REST, HTTP, and JSON
• REST conventions
  • about / REST conventions
  • product, inserting / Inserting a product
  • product, updating / Updating a product
  • product, deleting / Deleting a product
  • cache invalidation / Cache invalidation
• RESTful API Modeling Language (RAML)
  • about / RESTful API Modeling Language (RAML)
  • design / RESTful API Modeling Language (RAML)
  • build / RESTful API Modeling Language (RAML)
  • test / RESTful API Modeling Language (RAML)
  • document / RESTful API Modeling Language (RAML)
  • integrate / RESTful API Modeling Language (RAML)

S

• SaaS / XaaS
• security / The role of security
• Security Assertion Markup Language (SAML) / XaaS
• Semantic Versioning 2.0.0
  • reference / Release patterns
• server-side state management (SSM) / Capabilities for microservices coordination
• service-level agreement (SLA) / Key design concerns when building XaaS
• service-oriented architecture (SOA) / Cloud-native and microservices, Differences between microservices and service-oriented architecture (SOA)
• service per Docker container model
  • benefits / Benefits and trade-offs
  • trade-offs / Benefits and trade-offs
  • suitability / Suitability
• service per host model
  • about / Service per host
  • benefits / Benefits and trade-offs
  • trade-offs / Benefits and trade-offs
  • suitability / Suitability
• service per process model
  • benefits / Benefits and trade-offs
  • trade-offs / Benefits and trade-offs
  • suitability / Suitability
• service per VM model
  • about / Service per VM
  • trade-offs / Benefits and trade-offs
  • benefits / Benefits and trade-offs
  • suitability / Suitability
• service per WAR/EAR model
  • benefits / Benefits and trade-offs
  • trade-offs / Benefits and trade-offs
  • suitability / Suitability
• service registry
  • executing / Running a service registry
• service versioning
  • URL / Versioning
  • accept header / Versioning
  • schema level / Versioning
  • API facade layer / Versioning
• Simple Notification Service (SNS) / Integration with third-party APIs
• Single-Page Applications (SPA) / Channel API
• software development life cycle (SDLC) / XaaS
• split testing / A/B testing
• Spring Boot API, deploying to Azure Service Fabric
  • about / Deploying Spring Boot API to Azure Service Fabric
  • environment setup / Basic environment setup
  • Product API application, packaging / Packaging the product API application
  • Service Fabric cluster, starting / Starting the Service Fabric cluster
  • Product API application, deploying to Service Fabric cluster / Deploying the product API application to the Service Fabric cluster
• Spring Boot API deployment
  • runnable JAR, deploying / Deploying a runnable JAR
  • Docker containers, deploying / Deploying Docker containers
• Spring Boot Test / Spring Boot Test
• Spring Tool Suite (STS) / Getting an IDE
• subject matter expert (SME) / Key design concerns when building XaaS

T

• technical values
  • parameters / Portfolio analysis – business and technical parameters
• technical values parameters
  • retire / Retire
  • retain / Retain
  • consolidate / Consolidate
  • transform / Transform
• test-driven development (TDD) / Testing and development, TDD
• test cases
  • writing / Writing test cases before development
• test doubles
  • about / Test doubles
  • Test Stubs / Test Stubs
  • mock objects / Mock objects
  • mock APIs / Mock APIs
• testing
  • unit testing / Unit testing
  • integration testing / Integration testing
  • load testing / Load testing
  • regression testing / Regression testing
  • code review and coverage, ensuring / Ensuring code review and coverage
• testing patterns
  • about / Testing patterns
  • A/B testing / A/B testing
  • test doubles / Test doubles
• third-party APIs
  • integrating with / Integration with third-party APIs
  • authentication services / Integration with third-party APIs
  • serverless services / Integration with third-party APIs
  • database/storage services / Integration with third-party APIs
  • notification services / Integration with third-party APIs
  • analytics service / Integration with third-party APIs
  • location services / Integration with third-party APIs
  • social integration services / Integration with third-party APIs
  • advertisement services / Integration with third-party APIs
• transaction
  • distributed transaction controls / Capabilities for microservices coordination
  • compensating transaction / Capabilities for microservices coordination

U

• Uniform Resource Identifier (URI) / API design concerns
• unit testing / Unit testing

V

• validations
  • about / Validations and error messages
  • format validations / Format validations
• venture capitalists (VCs) / Key design concerns when building XaaS
• virtual machine (VM) / Lift and shift, Building and deployment
• voice over IP (VoIP) / Integration with third-party APIs