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
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
- 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
- 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