Symbols

2PC (two-phase commit) protocol 107

A

abstraction 66

acbuild command-line tool 217

acceptance testing 257

accidental complexity 12

ACID transaction 106

actions 92–94

activity feeds 126

Advanced Message Queuing Protocol (AMQP) 63, 162

aggregating data 59

aggregation 59–60

alerts

raising 291–293

setting up 287–291

alignment 9–10

ambiguity 99–102

AMQP (Advanced Message Queuing Protocol) 63, 162

analytics 127–127

anemic services 30

API gateways 39–39, 68–68

Apollo 71

application boundaries 66–71

applications

distributed 106–108

observing 293–295

architecture

of CQRS pattern 124–125

of microservices 51–52–56, 74

role of 341–343

artifacts

configuring 206–207

defining 200–200

immutability of 201–201

publishing 254–254

standardizing 22–23

types of 201–206

asset information 81

asynchronous communication patterns 63–64

asynchronous messages 62–63

autohealing 190

automated deployments 42–43

automated tests 257

automation

of production environments 191–191

overview of 9–9, 189–189

autonomy

lack of 332–332

overview of 8–8, 329–329

autoscaling 190, 194

availability

automation 189–189

calculating 130

manual change management 189–189

prioritizing 123

small releases 189–189

B

backends for frontends . See BFF (backends for frontends)

backends for frontends . See BFF (backends for frontends)

balancing 177–180

BDD (behavior-driven development) 78

BEAM (Erlang virtual machine) 182

BFF (backends for frontends) 69–69

binary dependencies 200

blue-green deploys pattern 210

bootstrapping 164–164

bottlenecks 154

boundaries . See application boundaries

boundaries . See application boundaries

boundary layer 66

bounded contexts 67, 79

build pipelines

configuring 247–250

procedural versus declarative 263–263

bus factor 41

business capabilities, scoping by 78–87

busybox 241

C

cachetools library 144

caching 67, 143–144

canaries

on GCE 211–213

overview of 236–240

capacity 196–196

CAP theorem 108, 123

cascading failures 136–139

categories 301–301

chaos testing 152, 154–155

Chaos Toolkit 155

ChargeFailed event 110

chassis 160–163

choreographed interactions 110

choreographed sagas 112–115

choreography 37–39, 94–94, 109–110

circuit breakers 146–148

Clair 220

clients 71–74

clusters, deploying to 224–242

coarse-grained services

overview of 87–87

starting with 99–100

codebases 329

code deployment 259

coherence 335

collaboration . See service collaboration

collaboration . See service collaboration

collaborators 37

command-query responsibility segregation pattern . See CQRS (command-query responsibility segregation) pattern

command-query responsibility segregation pattern . See CQRS (command-query responsibility segregation) pattern

commands, separating queries from 123–125

commit phase, 2PC 108

communication

as sources of failures 135–135

asynchronous communication 149–149

asynchronous communication patterns 63–64

asynchronous messages 62–63

by group size 327

designing 139–149

event-based communication 108–110

locating services 65–65

overview of 21–21

standardizing 156

synchronous messages

choosing transport 62–62

drawbacks of 62–62

when to use 61–62

using service mesh 157

communication broker 63

compensating actions 113

components

adding to Docker compose files 276–276

of master nodes 230–230

of worker nodes 231–231

compose files 276–276

configuration drift 201

configuring

build pipelines 247–250

Grafana 280–282

Prometheus 280–280

service artifacts 206–207

StatsD exporter 277–279

ConnectionError exception 179

consistency patterns 118–119

constraints 103

Consul 65

consumer-driven gateways 70–71

containerizing services 215–224

containers

overview of 22, 205–206

running 220–222

container schedulers 210–210

contexts, nested 86–86

continuous delivery 245

continuous deployment 245

contracts

between services 16–16

overview of 37–37

control 103

Conway's Law 327–328

coordinators 59

correlation IDs 120

CQRS (command-query responsibility segregation) pattern

architecture of 124–125

challenges 125–127

optimistic updates 126–126

overview of 63

polling 127–127

publish/subscribe 127–127

critical paths 60–60

cross-functionally 330

CRUD (create, read, update, delete) 30, 108

cyclic dependencies 114

D

DAG (direct acyclic graph) 314

dark launches 264–264

data

aggregating 59

storing copies of 122–123

stubbed 145–145

data composition 121

data warehouses 127

DDD (domain-driven design) 79

deadlines 145

decomposition

preparing for 100–100

scaling through 6–7

degradation 143–143

delivery pipelines, building

dark launches 264–264

deployment pipeline 244–246

feature flags 23–24, 265–266

dependencies 135–135

deploying

microservices 21–24

services 187–191–199, 213

to clusters 224–242

to production 259–261

to staging 255–257

to underlying hosts 207–210

without downtime 210–213

deployment pipelines 57, 190, 244–246

deployment process 8, 43

deployments

automated 42–43

quality-controlled 42–43

deployment target 190

described feature 166

design reviews 345–345

development process 43

direct acyclic graph (DAG) 314

distributed applications 106–108

distributed computing 13, 129

distributed systems 16–16

divergence . See technical divergence

divergence . See technical divergence

docker-compose, installing 140

docker-compose up command 180, 281

Docker platform 276–276

docker version command 355

documentation 346–346

domain-driven design (DDD) 79

domain modeling 78–79

domains . See modeling domains

domains . See modeling domains

domain-specific language (DSL) 217, 247

downtime 130

DRY (don't repeat yourself) 104, 183, 339

DSL (domain-specific language) 217, 247

E

edge capabilities 67

edge side includes (ESI) 73

elastic load balancer (ELB) 65

Elasticsearch, Logstash, and Kibana (ELK) . See ELK (Elasticsearch, Logstash, and Kibana)-based solutions

Elasticsearch, Logstash, and Kibana (ELK) . See ELK (Elasticsearch, Logstash, and Kibana)-based solutions

Elasticsearch engine 305–305

ELB (elastic load balancer) 65

ELK (Elasticsearch, Logstash, and Kibana)-based solutions 304–306

end-to-end responsibility 71, 329–330

engineering culture 26–27

enterprise service buses (ESBs) 6

environments, staging . SeeAlso production environments

environments, staging . SeeAlso production environments

Erlang virtual machine (BEAM) 182

ERROR level 301

error reporting 174–175

errors 273–273

ESBs (enterprise service buses) 6

ESI (edge side includes) 73

event backbone 63

event-based communication 108–110

events 109–110

event sourcing 119–120

eventual consistency 108

expectations, setting 104

explicit interfaces 104

exponential back-off strategy 142, 142

F

failures

cascading 136–139

sources of 133–136

failure zones 195–195

fallbacks 143–145

fault tolerance

overview of 42

validating 152–155

feature flags 265–266

features

building 32–39

designing 75–104

taking to production 40–45

feedback loops 139

flags 265–266

flat services 59

Flipper 265

Fluentd-based solutions 306–

Fluentd daemon 304, 307

frameworks

building reusable 159–183

overview of 156–156

friction 13–13, 258

frontends

BFF (backends for frontends) 69–69

frontend monoliths 71–71

micro-frontends 72–74

full staging environments 258

functional redundancy 144–144

functions

grouping teams across 332–333

grouping teams by 330–332

G

gateways

API gateways 39–39, 68–68

consumer-driven gateways 70–71

gauges 273–273

GCE (Google Kubernetes Engine)

canaries on 211–213

rolling deploys on 211–213

GCP (Google Cloud Platform) 191

GDPR (General Data Protection Regulation) 313

GKE (Google Kubernetes Engine) . See GCE (Google Kubernetes Engine)

GKE (Google Kubernetes Engine) . See GCE (Google Kubernetes Engine)

Google Cloud Platform (GCP) 191

Google Compute Engine (GCE) 191

Google Kubernetes Engine (GKE) 225

graceful degradation 143–143

Grafana tool

configuring 280–282

monitoring systems with 275–291

GraphQL 70, 71

Gunicorn web server 226

H

half open circuit breaker 148

HAProxy 197

hardware as source of failure 134–134

health checks 135, 150, 233–235

Helm application package manager 350–350

heterogeneity

overview of 182–183

technical heterogeneity 12–12

high cohesion 4

higher order services 59–60

histograms 274–274

holdings 130, 136

homogeneity 343–343

horizontal decomposition 9

hosts

multiple scheduled services per 209–210

multiple static services per 208–208

single service to 207–207

underlying, deploying services to 207–210

HTTP liveness check 151

I

IaaS (infrastructure as a service) 191

idempotent 140

identifiers 301–301

images

building 218–220, 251–252

overview of 216–218

storing 223–224

immutability 201–201, 201, 341

infrastructure as a service (IaaS) 191

infrastructures 9, 191, 335–337

inner-source model 344

installing Jenkins, on Minikube 349–356

instance group 194

interactions, choreographed 110

interfaces 104

internal load balancing 198

interruption 118–118

interwoven sagas 117–118

investment strategies

creating 79–85

placing orders 88–92

InvestmentStrategies service 96

isolated staging environments 258

isolation 46–46

J

Jaeger 315, 316

Java virtual machine (JVM) 182

Jenkins Pipeline 263

Jenkins tool

building pipelines with 246–261

installing on Minikube 349–356

running on Kubernetes 349–356

jitter 142, 148

job queues 63–64

JVM (Java virtual machine) 182

K

Kibana plugin 305–305

KPIs (key performance indicators) 330

ksonnet 256

kubectl command-line tool 227

kube-proxy 231

Kubernetes platform, running Jenkins on . SeeAlso GCE (Google Kubernetes Engine)

configuring RBAC 353–354

creating namespaces 350–351

creating volume 350–351

Kubernetes platform, running Jenkins on . SeeAlso GCE (Google Kubernetes Engine)

installing Jenkins 351–353

setting up Helm 350–350

testing 354–356

L

latency 272–272

launches 264–264

levels 301–301

limiting 177–180

Linkerd 157

liveness health check 233

living documentation 346–346

load/capacity tests 257

load balancers 56, 150–151, 196–198, 228–230

load testing 152, 153–154

locking 118–118

logging 176–177

login screen, Grafana 282

logs 67, 305

logstash-formatter library 176, 312

Logstash tool 302, 305–305

loose coupling 4, 8

M

managed registries 223

manual tests 257

mapping runtime platforms 57–57

market-data 130, 136

MarketDataClient class 140

master nodes 230–230

messages . SeeAlso asynchronous messages; synchronous messages

messages . SeeAlso asynchronous messages; synchronous messages

metric collection infrastructure 276–282

metrics

overview of 67, 172–174

types of 273–274

micro-frontends 72–74

microservice platforms 56–57

microservices

advantages of 11–13, 30–32

architecture of 51–52–56, 74

challenges of 13–18

deploying 21–24

designing 19–21

development lifecycle of 18–25

identifying by modeling domains 33–35

key principles of 7–10

observing 24–25

scaling through decomposition 6–7

scaling up development of 45–46

microservices . SeeAlso services

users of 10–11

microservice scoping 52

microservice teams 325–348

migration 100–102

Minikube tool, installing Jenkins on 349–356

MkDocs 346

modeling domains 33–35

model-view controller (MVC) 19

modes of failure 13

monitoring systems 269–295

monoliths 19–19, 71–71, 106, 110

multispeed development 103

MVC (model-view controller) 19

N

nameko framework 166

namespaces 350–351

nested contexts 86–86

network communication 61

nginx.conf file 222

NGINX container 221

NodePort service 229

nonbackwards-compatible functionality 135

noncritical paths 60–60

nonfunctional testing 257

notifications, sending 96–97

nslookup 241

O

object-oriented applications 93

object-relational mapping (ORM) 161

observability 18–18, 171–177

observable services 43

on-call support 337–338

OpenAPI specification 82

open source models 343–344

OpenTracing API 314

operating system packages 203–203

optimistic updates 126–126

orchestrated sagas 115–117

orchestration 94–94

OrderCreated event 64, 109

OrderPlaced event 38

OrderRequested event 109

organizations, ownership in 103–104

ORM (object-relational mapping) 161

ownership 103–104, 328–329–331, 331

P

PaaS (platform as a service) 57, 209

paths

critical 60–60

noncritical 60–60

patterns, consistency patterns . SeeAlso CQRS (command-query responsibility segregation) pattern

patterns, consistency patterns . SeeAlso CQRS (command-query responsibility segregation) pattern

pipelines . SeeAlso delivery pipelines

building reusable 262–263

building with Jenkins 246–261

pipelines . SeeAlso delivery pipelines

overview of 57, 246

procedural versus declarative build pipelines 263–263

pip tool 219

PlaceStrategyOrders service 88, 89, 91, 91

platform as a service (PaaS) 57, 209

platforms, mapping runtime platforms . SeeAlso microservice platforms

platforms, mapping runtime platforms . SeeAlso microservice platforms

pods

designing 226–228

running 226–228–232, 233

point-to-point communication 36

polling 127–127

positive feedback 136

prepare phase, 2PC 108

principles 342

production

deploying to 259–261

taking features to 40–45

production environments 189–190

product mode 334

Prometheus ecosystem

configuring 280–280

monitoring systems with 275–291

protocol buffers 346

provisioning virtual machines 192–193

public images, Docker 220

publish-subscribe 64–64, 127–127

Python chassis 166

Q

quality-controlled deployments 42–43

queries 105–120–127, 128

queues . See job queues

queues . See job queues

R

rabbitmq_queue_messages metric 290

RabbitMQ broker 167, 282–284

rate limits 67, 152–152

RBAC (role-based access control) 353–354

readability of logs 301–303

readiness checks 151, 233

recovery_timeout parameter 179

redundancy 144–144

releases 189–189

reliability

defining 130–132

maximizing 150–155

overview of 42

validating 152–155

remote_hello method 168

ReplicaSet 226

replication lag 125

reporting 127–127

request for comments (RFC) 345

resiliency 9–9–21, 21, 43–43

retirement 100–102

retries 140–143

RFC (request for comments) 345

risk, reducing 13–13, 164–164

robust monitoring stacks 270–274

role-based access control . See RBAC (role-based access control)

role-based access control . See RBAC (role-based access control)

rolling back 114, 241–241, 259

rolling deploys 211–213

round-robin algorithm 167

routing components 190

RPC-facing services 150

rpc-market_service queue, RabbitMQ 177

run the packer build command 204

runtime management 190

runtime platforms 57–57, 190

S

sagas 111–120

saturation 273–273

scalability 42

scaling up microservice development 45–46

scanning tools 220

scheduled services, multiple per host 209–210

scheduling models 210–210

scoping 15–15

Scripted Pipeline 247

secure operation 190

security 220

security tests 257

self-healing 195–196

sending notifications 96–97

server images 203–204

server management 201

service artifact 199

service collaboration 36–37

service discovery 65, 167–170

service health 150–151

service mesh 157–158

service migration 102

service-oriented architectures (SOAs) 6

service partitioning 99

service practices as source of failures 136–136

service responsibility 37–37

services

aggregation 59–60

API gateways 39–39

behavior across 297–300

building artifacts 199–207

capabilities of 58–59

challenges of designing 132–139

coarse-grained

overview of 87–87

starting with 99–100

connecting multiple 241–242

containerizing 215–224

contracts between 16–16

critical paths 60–60

deploying 187–191–199, 213

designing 129–158

designing reliable communication 139–149

higher order services 59–60

interactions between tracing and 313–320

locating 65–65

maximizing reliability of 150–155

nested contexts and 86–86

noncritical paths 60–60

ownership in organizations 103–104

run multiple instances of 194–196

safety of 156–158

scoping 20–20

setting up tracing in 315–320

to underlying hosts 207–210

without downtime 210–213

service teams 87

service to host models 207–210

sharding 6

short-circuiting 118–118

silos 332–332

smoke tests 259

SOAs (service-oriented architectures) 6

sources 301–301

spans 314–315

stability 189–189

stacks . See robust monitoring stacks

stacks . See robust monitoring stacks

staging

deploying to 255–257

environments 258–258

standardizing communication 156

startup logs 205

startups 192–192

state changes 231–231

static services 208–208

StatsD exporter 172, 173, 174, 277–279

statsd-exporter container 277

STDOUT (standard output) 304

stores 92–94

storing

copies of data 122–123

images 223–224

stubbed data 145–145

subtasks, sagas 112

supporting notifications 97

synchronous communication 36, 163

synchronous messages

choosing transport 62–62

drawbacks of 62–62

when to use 61–62

synchronous requests 62

systems . See monitoring systems

systems . See monitoring systems

T

tarballs 223

team models 330–340

teams, challenges of 16–16

technical capabilities

overview of 59

sending notifications 96–97

when to use 98–98

technical divergence 45–46

technical heterogeneity 12–12

tenacity library 140

testing

chaos testing 154–155

Jenkins on Minikube 354–356

load testing 153–154

three-tier architecture 19, 52

timeouts 145–146

timestamps 300–300

Togglz 265

traces, visualizing 320–324

tracing

interactions between services and 313–320

setting up in services 315–320

spans and 314–315

TradeExecuted event 38

traffic 273–273

transactions 105–128

transparency 9–9, 42, 43–45

transport 62–62

transport-related boilerplate 163

truck factor 41

try-finally statement 253

two-phase commit (2PC) protocol 107

U

updates, optimistic 126–126

upstream collaborators 37

uptime 130

use case, scoping by 87–94

user management 80

V

vault 207

VMs (virtual machines) 56, 192–193

volatility 78, 94–96

volume 350–351

W

worker nodes, components of 231–231

workflow tools 117

workspaces 247

Z

zero-downtime deployments 210