authorization

embedded PDP

OPA

XACML ( see eXtensible Access Control Markup Language (XACML))

Checkout microservice

components

failure conditions

heartbeats

message acknowledgements

message broker (RabbitMQ/ActiveMQ)

single receiver-based communication

versions

admin

analytics/observability

components

creator

definition

gateway

GraphQL

micro-gateway

microservices architecture

monetization

OpenAPI

publisher/lifecycle manager

QoS

and service mesh

Store/developer portal

subscriber

data formats

definition

Docker and Kubernetes integration

graphical syntax and source syntax

HTTP service

network-aware abstractions

observablity

remote endpoints

resilient and safe integration

architecture

DNS/HTTP

service

Docker ( see Docker)

foo and bar, localhost

FreeBSD

Linux cgroups and namespaces

A/B testing

blue-green deployment

canary releases

composite services/client-side mashups

materialize view, asynchronous events

RDBMS

caching

database per microservice

polyglot persistence

shared database ( see Shared database)

transactions ( see Transactions)

multiple services per host

service per container

service per host

service per virtual machine

bounded contexts

context map

DDD ( see Domain-driven design (DDD))

12 Factor App ( see 12 Factor App)

quicksort-sorting algorithm

relational patterns ( see Relational patterns)

SOA

automation

cohesion and coupling

observability

resilience ( see Resilience)

Dropwizard

Istio

JAX-RS

Lagom

Netflix OSS

service per host model

Spring Boot ( see Spring Boot)

telemetry and observability

Vert.x

commit phase

limitations, two-phase commit

Saga

voting/commit-request phase

architecture

containers

control groups and namespaces

host machine

images

installation

microservice deployment

repository

type-2 hypervisor

virtual machine, isolation

communication

cURL

inventory and orderprocessing

launching application

multi-container environments

Order Processing

YAML file

business logic

communication

Conway’s law

crypto-currency domain

customer management

description

divide and conquer

e-commerce application

relational patterns ( see Relational patterns)

sub-domains

ubiquitous language

Akka

Apache Camel

Apache NiFi

Ballerina ( see Ballerina)

Go

Jetty HTTP library

Netflix Conductor

Node.js

Rust and Python

Spring Integration

Vert.x

Zeebe

integration services ( see Integration services)

smart endpoints and dumb pipes

and SOA

architecture

client

cluster per region

Netflix

REST API and Java client library

server

Spring Boot

event consumer (event sink)

event publisher (event source)

interactions

message broker

EDA

microservices architecture

notification

sourcing

state-changing

centralized/remote, PDP

component architecture

reference architecture

request in JSON

admin processes

APIs

backing services

build, release and run

codebase

concurrency

configuration

culture

dependencies

dev/prod parity

disposability

logs

Netflix build process

port binding

processes

security

shared nothing architecture

telemetry

config file

definition

Docker container

microservices deployment

publishing logs

third-party systems

creating alerts

dashboard

definition

client application

communication between microservices

definition

development

error-handling

HTTP1.1

HTTP2

IDL file

inter-service communication

inventory microservice

Order Processing

Maven pom.xml file

protobuf-maven-plugin plugin

protocol buffers

active composition/orchestration

anti-corruption layer

anti-patterns

business functionality

container-native and DevOps

data formats

Dropwizard ( see Dropwizard)

ESB-based approach

governance

hybrid of active and reactive composition

network communication abstractions

reactive composition/choreography

requirements

resiliency patterns ( see Resiliency patterns)

Service Mesh

smart endpoints and dumb pipes

Spring Boot ( see Spring Boot)

stateless, stateful, and long-running services

strangler façade

asynchronous communication

fundamentals

message formats

service definitions and contracts

synchronous communication

architecture

BookInfo use case

Citadel

control plane

data plane

definition

deployment descriptors

Docker image and Kubernetes

Envoy proxy

HelloWorld service

Mixer

observability

Pilot

policy enforcement

request flow

security

traffic-management

VirtualService and Gateway

base64 encoding

base64url-decode

claim set

cryptographic elements

IETF standard

JWS and JWE

transport data, interested parties

trust and user identity

ActiveMQ

brokers

consumers

distributed commit log

message

order_update

partitions

price_update

producers

Product Management service

publisher-subscriber scenario

RabbitMQ

topics

architecture

deployment

Kubectl

Minikube

package management

pods

ReplicaSet

services

testing

YAML file

Avro

JSON and XML

protocol buffers

description

Docker and Kubernetes

hello world HTTP service

Maven dependency

@Package

@Runtime

Spring Boot

autonomous

benefits

business capabilities

decentralized data management

description

ESB

failure tolerance

guidelines

liabilities

monolithic applications

observability

online retail application

service governance

API management/gateway

components

decentralized process

development lifecycle management

lifecycle stages

observability

QoS

service definition

service registry and discovery

SOA governance

APIs

characteristics

components

online retail application

and shared databases

SOA and ESB

anti-fragile organization

API gateway

Chaos Monkey

Conductor

Archaius

deployment

Eureka

Hystrix

Nebula

Ribbon

Spinnaker

Zuul

asynchronous communication

databases/JDBC

HTTP

JMS

synchronous communication

Twitter

web APIs

actuator endpoints

authorization server

client, authorization server, resource server, and resource owner

control access

edge security, API gateway

end-to-end communication

Flickr API

grant types

protecting microservice

protocol

reference and self-contained tokens

self-contained access tokens (JWT)

service-to-service communication

TLS

data collection

distributed tracing

Fluentd ( see Fluentd)

Grafana ( see Grafana)

logging

metrics

open tracing

Prometheus

tracing

Zipkin ( see Zipkin)

description

programming languages

Spring Boot

attributes

centralized/remote XACML

embedded XACML

immutable server

monolithic

ownership of PIPs

performance cost

building graphs

definition

setting up

Spring Boot microservice

traced data, connected microservices

anti-corruption layer

big ball of mud

conformist

customer/supplier

open host service

partnership

published language

separate ways

shared kernel

HTTP POST message

Order Processing

resources

Richardson Maturity Model

bulkheads

circuit breaker

distributed system

fail fast

failures

handshaking

let it crash approach

Netflix

redundancy

shed load

steady state

test harness

timeouts

bulkhead

circuit breaker

distributed computing

fail fast

@HystrixCommand

load balancing and failover

timeout

HTTP verbs

hypermedia controls

resource URIs

RESTful microservices

Swamp of PoX

BPMN solutions

centralized database

DAG

distributed transactions

log

SEC

sub-transactions

travel agent service

access control ( see Access control)

API gateway pattern

development lifecycle and test automation strategy

DevOps security

monolith vs. microservices

OAuth 2.0 ( see OAuth 2.0)

Service Mesh

service-to-service communication

benefits

communication

introspection endpoint

microservices architecture

motorcycle

pdp endpoint

token endpoint

userinfo endpoint

application network functions

business logic

cons

control plane

deployment

ESB, smart endpoints and dumb pipes

inception of

inter-service communication protocols

Istio ( see Istio)

language-agnostic

Linkerd

management

microservice components and service-to-service communication

network functions

observability

primitive network functions

pros

resiliency, inter-service communications

routing

security

service discovery

service interactions and responsibilities

service-to-service communication

sidecar

and ESB ( see Enterprise Service Bus (ESB))

governance

layered architecture, e-commerce application

Service Mesh ( see Service Mesh)

asynchronous events

data composition ( see Data composition)

foreign key (FK) relationship

and monolithic applications

shared tables

static data

synchronous lookups

system of record

actuator

commands

configurations

configuration server

data formats

definition

git command

GraphQL

Hello World!

microservices implementation

network communication abstractions

OAuth 2.0 ( see OAuth 2.0)

observability

resiliency patterns

RESTful services

service-to-service communication

setting up Java/Maven

Spring Cloud

Spring Cloud Sleuth

Spring Initializer

distributed tracing

multiple microservices

spans

Spring Boot

definition

microservices architecture

processors

SQL

ACID properties

database log mining

distributed, two-phase commit

event sourcing

local, publishing events

monolithic applications

Saga ( see Saga)

Citadel

enable

handshaking

mutual authentication

application.properties file

dependency graph

event-driven log aggregation architecture

Order Processing and inventory microservices

publish logs

setting up

tracing information

web-based console