Index

Symbols

0MQ (ZeroMQ), 183

A

acceptance tests, 59

acceptance-driven design (ATDD), 216

ACID, 31–33

ActiveMQ, 183

adjusting architecture

causes of bad architecture, 110–111

challenges with, 117–118

changes in microservices, 111

changes to overall architecture, 111–112

code reuse versus redundancy, 114–115

code transfer, 113–114

overview, 110

rewriting, 117

shared libraries, 112–113

shared services, 115–116

spawning new services, 116–117

Advanced Message Queuing Protocol (AMQP), 182

advantages of microservices. See microservice advantages

aggregates, 41–42

agile architecture, 75–76

AJAX (Asynchronous JavaScript and XML), 170

Amazon

AWS (Amazon Web Services), 338

Cloud

CloudWatch, 340, 349

JVM-based microservices in, 338–340

DynamoDB, 338

Elastic Beanstalk, 349

ElastiCache, 338

Kinesis, 338

Lambda, 347–349

modernization scenario example, 18–19

AMQP (Advanced Message Queuing Protocol), 182

AngularJS, 165

annotations (Hystrix), 330

@Autowired, 334

@EnableCircuitBreaker, 330

@EnableDiscoveryClient, 324–325

@EnableEurekaClient, 324–325, 332

@EnableEurekaServer, 326

@EnableHystrix, 330

@EnableHystrixDashboard, 331, 332

@EnableTurbine, 332

@EnableZuulProxy, 328

@HystrixCommand, 330

@RequestMapping, 307–308

@RestController, 307–308

@RibbonClient, 334

@SpringBootApplication, 307–308

Ansible, 255

anticorruption layer, 44, 109

Apache

Kafka, 183, 338

Mesos, 265

Qpid, 182

Thrift, 180

Zookeeper, 139, 310

API keys, 157

application.properties file, 313

applications

e-commerce legacy application

migration status, 15–16

team creation, 16

e-commerce legacy application scenario

Amazon example, 18–19

approach, 14

challenges, 14–15

feature development, 17–18

general description, 11–12

influence on organization, 18

microservice advantages, 12–13, 17

microservices-based application example

build, 311–313

communication, 327–329

deployment with Docker, 313–314

Docker Compose, 321–324

Docker Machine, 320–321

domain architecture, 304–306

integration of other technologies, 335–336

JVM-based microservices in Amazon Cloud, 338–340

load balancing, 333–334

overview, 303–304

resilience with Hystrix, 329–333

service discovery, 324–326

Spring Framework, 306–311

summary, 341–342

testing, 336–337

Vagrant, 314–320

application-test.properties file, 229, 233

arbitrary test frameworks, 232

architecture

agile architecture, 75–76

architecture management

Context Maps, 108–109

cycle-free software, 104–105

importance of, 107–108

tools for, 104–107

effect on departments, 291–292

of individual microservices

CQRS (Command Query Responsibility Segregation), 195–197

domain architecture, 193–194

event sourcing, 197–199

hexagonal architecture, 199–202

microservice implementation and, 296–297

resilience, 203–208

stability, 203–208

summary, 211–212

technical architecture, 208–211

macro/micro architecture

creating, 278–279

definition of, 277

domain architecture, 282

extent of, 279

operations and, 281

operations challenges, 239–240

responsibility for, 277–278

technologies, 280–281

testing, 282–284

of microservice-based systems

architecture management, 104–110

configuration, 139–141

documentation, 159–161

domain architecture, 100–104

EDA (event-driven architecture), 134–135

legacy application integration, 126–134

load balancing, 144–148

overview, 99

planning for growth, 118–125

scalability, 148–151

security, 151–159

service discovery, 141–143

summary, 161–162

technical architecture, 136–138

techniques to adjust architecture, 110–118

refactoring, 75

requirements and, 74–75

sample microservices-based application

build, 311–313

communication, 327–329

deployment with Docker, 313–314

Docker Compose, 321–324

Docker Machine, 320–321

domain architecture, 304–306

integration of other technologies, 335–336

JVM-based microservices in Amazon Cloud, 338–340

load balancing, 333–334

overview, 303–304

resilience with Hystrix, 329–333

service discovery, 324–326

Spring Framework, 306–311

summary, 341–342

testing, 336–337

Vagrant, 314–320

SOA (service-oriented architecture)

characteristics of, 81–82

communication, 83–84

compared to microservices, 87–92

coordination, 86

interfaces, 85–86

introducing, 84

landscape, 82–83

orchestration, 86

services in, 84–85

technologies, 86–87

versioning, 85

sustainable architecture, 29

three-tier architecture, 71

artifacts, 238–239

asset servers, 166–167

Asynchronous JavaScript and XML (AJAX), 170

ATDD (acceptance test-driven design), 216

ATOM Feeds, 183

atomicity, 31

authentication, 329

authorization

OAuth2, 152–156

Spring Cloud Security, 329

automation (deployment), 254–255

AutoScaling, 339

@Autowired, 334

availability, 159

avoiding

CDMs (canonical data models), 47–50

erosion of microservices, 122–123

AWS (Amazon Web Services), 338

Azure Service Bus, 183

B

back-end interfaces, 174–175

bad architecture, causes of, 110–111

balancing load. See load balancing

batch data replication, 186

BDD (behavior-driven design), 216

BEAM (Bogdan/ Björn’s Erlang Abstract Machine), 360

behavior specification, 239

behavior-driven design (BDD), 216

benefits of microservices. See microservice advantages

Berkeley Internet Name Domain Server (BIND), 142–143

big systems, starting with, 119–120

BigPipe, 170–171

BIND (Berkeley Internet Name Domain Server), 142–143

blue/green deployment, 220, 257

blueprints (OSGi), 352

BMC Remedy, 251

Bogdan/ Björn’s Erlang Abstract Machine (BEAM), 360

bottlenecks during testing, 13

Bounded Contexts

CDMs (canonical data models), 47–50

collaboration between, 44–45

Context Maps, 108–109

example, 42–44

large-scale structure, 46–47

microservices and, 45–46

nanoservices and, 347

overview, 52

sample microservices-based application, 305–306

breaking up code, 126–127

building sample microservices-based application, 311–313

bulkhead, 204–205

bundles, 350–353

business advantages of microservices, 65–67

C

CA Opscenter, 251

cache (REST), 176

calling

Lambda functions, 348

Seneca functions, 363–365

callMicroservice() function, 334

canary releasing, 220, 257

canonical data models (CDMs), avoiding, 47–50

capacity tests, 59

CatalogConsumerDrivenContractTest class, 337

CDCs (consumer-driven contracts), 231

CDMs (canonical data models), avoiding, 47–50

central load balancers, 145

certificates, 157

challenges of microservices

architecture, 74–76

Conway’s Law, 273–274

infrastructure, 76–77

operations

artifacts, 238–239

micro and macro architecture, 239–240

templates, 240

overview, 8

summary, 78

technical challenges

code dependencies, 71–72

overview, 69–71

technology pluralism, 73–74

unreliable communication, 73

changes of perspective, DevOps and, 288–289

changing architecture. See adjusting architecture

Chef, 255

circuit breaker design

Hystrix, 329

resilience and stability, 203–204

classes

CatalogConsumerDrivenContractTest, 337

CustomerConsumerDrivenContractTest, 337

OrderTestApp, 336

SpringRestDataConfig, 304–305

clients

client libraries, 292–293

client-based load balancing, 147–148

client-level integration, 190–191

Eureka, 324–325

mobile clients, 172–173

rich clients, 172–173

cloud

Amazon Cloud

CloudWatch, 340, 349

JVM-based microservices in, 338–340

Spring Cloud, 308–310

Spring Cloud Netflix, 310–311

Cloud Foundry, Spring Cloud for, 310

CloudWatch, 340, 349

cluster environments, 324

CMS (content management systems), 130

Coda Hale Metrics, 340

code dependencies, 71–72

code ownership, collective, 273–276

code reuse, 114–115, 292–295

code transfer, 113–114

cohesion, 194

collaboration between Bounded Contexts, 44–45

collectd, 252–253

collective code ownership, 273–276

combined deployment, 258–259

Command Query Responsibility Segregation. See CQRS (Command Query Responsibility Segregation)

commands. See also functions

docker kill, 319

docker log, 318

docker ps, 319

docker rm, 319

docker run, 334

docker-compose, 323, 334

docker-machine, 320–321

mvn package, 311

vagrant destroy, 319

vagrant halt, 319

vagrant provision, 319

vagrant ssh, 318

vagrant up, 319

commit phase, 59

Common Object Request Broker Architecture (CORBA), 70

communication

data replication

batch, 186

consistency, 185–186

event, 186–187

implementation, 186

overview, 184–185

redundancy, 185–186

distributed communication, 28–29

between Docker containers, 263

between Erlang processes, 360–361

external interfaces, 187–190

internal interfaces, 187–190

levels of, 163

messaging

advantages of, 180–181

technologies, 182–184

transactions and, 181–182

REST (representational state transfer)

definition of, 175–179

load balancing, 144–145

RESTful-HTTP interfaces, 50

Spring Data REST, 307

sample microservices-based application, 305, 327–329

in SOA (service-oriented architecture), 83–84, 87

SOAP (Simple Object Access Protocol), 179–180

UIs (user interfaces)

HTML-based user interfaces, 168–175

SPAs (single-page apps), 164–168

unreliable communication, 73

compromises, nanoservices and, 345

confidentiality, 158

configuration

Eureka, 325

Hystrix, 333

microservice-based systems, 139–141

operations, 256

Spring Cloud Config, 139, 309–310

Vagrant, 315–317

conformist collaboration, 44

consistency

data replication, 185–186

definition of, 31

problems with, 139–140

size of microservices and, 31–32

Consul, 143

consumer contracts, 231

consumer-driven contract tests

contract types, 230–231

implementation, 231–232

overview, 230

sample microservices-based application, 337

tools, 232–233

containers (Docker), 262–263, 318–319

content enricher, 128–129

content filters, 128

content management systems (CMS), 130

content-based routers, 127

Context Maps, 108–109

contexts, bounded. See Bounded Contexts

continuous delivery

advantages of, 7–8

challenges, 76–77

legacy application modernization, 12

operations

challenges of, 238–240

control, 259–260

deployment, 254–259

infrastructure, 260–266

logging, 241–246

monitoring, 246–253

summary, 266–267

pipeline, 59–60, 67

testing, 220

continuous deployment, 257

contract tests

contract types, 230–231

implementation, 231–232

overview, 230

control of operations, 259–260

Conway, Melvin Edward, 35

Conway’s Law

challenges associated with, 273–274

definition of, 35, 52, 273

as enabler, 38–39

as limitation, 36–38

microservices and, 39–40

reasons for, 36

coordination

of deployments, 85–86

microservice-based systems, 139–141

pull requests for, 276

SOA (service-oriented architecture), 86

CORBA (Common Object Request Broker Architecture), 70

CoreOS, 265, 324

correlating data with events, 249

correlation IDs, 245

CORS (cross-origin resource sharing), 166–167

CQRS (Command Query Responsibility Segregation)

advantages of, 196–197

challenges, 197

microservices and, 196

overview, 195–196

CRM (customer relationship management), 82–83, 88–90

cross-functional teams, 285–290

cross-origin resource sharing (CORS), 166–167

customer interface, 290–292

customer relationship management (CRM), 82–83, 88–90

CustomerConsumerDrivenContractTest class, 337

customer/supplier collaboration, 44

cycle-free software, 104–105

cyclic dependencies, 103–104

D

dashboard (Hystrix), 331

data replication

batch, 186

consistency, 185–186

event, 186–187

implementation, 186

overview, 129–130, 184–185, 191–192

redundancy, 185–186

data security, 158–159

data storage for sample microservices-based application, 304–305

databases

Amazon DynamoDB, 338

HSQL database, 307, 319–320

legacy application integration, 133–134

Datensparsamkeit, 157

DDD (domain-driven design)

Bounded Contexts

CDMs (canonical data models), 47–50

collaboration between, 44–45

Context Maps, 108–109

example, 42–44

large-scale structure, 46–47

microservices and, 45–46

nanoservices and, 347

overview, 52

sample microservices-based application, 305–306

building blocks, 41–42

CDMs (canonical data models), avoiding, 47–50

large-scale structure, 46–47

overview, 40–41, 194

strategic design, 100–101

summary, 52

ubiquitous language, 41

declarative services (OSGi), 352

delegation to teams, 238–239

delivery. See continuous delivery

departments

architecture leading to, 291–292

microservice implementation and, 296

dependencies

code dependencies, 71–72

dependency management

cyclic dependencies, 103–104

overview, 101–102

unintended domain-based dependencies, 102–103

hidden dependencies, 133–134

deployment

automation, 254–255

combined versus separate, 258–259

coordination of, 85–86

deployment monoliths

migrating to microservices, 370–371

overview, 4

problems with, 121

technical coordination, 271

deployment strategies, 256–258

installation and configuration, 256

risk mitigation, 220–222, 256

sample microservices-based application, 313–314

separate deployment, 270–271

deployment monoliths

migrating to microservices, 370–371

overview, 4

problems with, 121

technical coordination, 271

desktop applications, nanoservices and, 346

Developer Anarchy, 284

development

signaling systems

challenges, 21–22

general description, 19–20

microservice advantages, 20–21, 22

suitability of microservices for, 22–23

sustainable development, 6, 57

test-driven development, 214–215

DevOps, 285–290

directories

docker-vagrant, 318

log-analysis, 341

distributed communication, 28–29

distributed systems

distributed communication, 28–29

distributed tracing, 245–246

distribution by domain. See DDD (domain-driven design)

overview, 8, 20

DNS (Domain Name System), 142

Docker

cluster environments, 324

commands

docker kill, 319

docker log, 318

docker ps, 319

docker rm, 319

docker run, 334

containers, 262–263, 318–319

Docker Compose, 321–324

Docker Machine, 320–321

file system, 261–263

overview, 255

registry, 264

sample microservices-based application deployment, 313–314

servers, 264–265

Docker Compose, 265, 321–324

docker kill command, 319

docker log command, 318

Docker Machine, 265, 320–321

docker ps command, 319

docker rm command, 319

docker run command, 334

Docker Swarm, 265

docker-compose command, 323, 334

Dockerfile, 313–314

docker-machine command, 320–321

docker-vagrant directory, 318

documentation

microservice-based system architecture, 159–161

Spring Guides, 311

testing as, 214–215

domain architecture

importance of, 8

of individual microservices, 193–194

macro/micro architecture, 282

of microservice-based systems

dependency management, 101–104

Otto GmbH example, 101

overview, 100

strategic design, 100–101

sample microservices-based application, 304–306

Domain Name System (DNS), 142

domain-driven design. See DDD (domain-driven design)

dpkg, 255

durability, 32

dynamic environments, monitoring in, 250

dynamic scaling, 148–150

DynamoDB, 338

E

EC2 (Elastic Computing Cloud), 349

Echo Verticles (Vert.x), 358–359

e-commerce legacy application scenario

Amazon example, 18–19

approach, 14

challenges, 14–15

feature development, 17–18

general description, 11–12

influence on organization, 18

microservice advantages, 12–13, 17

migration status, 15–16

team creation, 16

EDA (event-driven architecture), 134–135

Edge Side Includes (ESI), 171–172

EJB (Enterprise JavaBeans), 70

Elastic Beanstalk, 349

Elastic Computing Cloud (EC2), 349

Elastic Load Balancing (ELB), 146, 339

ElastiCache, 338

elasticity, 210

Elasticsearch, 242–244

ELB (Elastic Load Balancing), 146, 339

Elixir, 363

ELK (Elasticsearch, Logstash, Kibana) stack, 242–244

Ember.js, 165

@EnableCircuitBreaker, 330

@EnableDiscoveryClient, 324–325

@EnableEurekaClient, 324–325, 332

@EnableEurekaServer, 326

@EnableHystrix, 330

@EnableHystrixDashboard, 331, 332

enabler, Conway’s Law as, 38–39

@EnableTurbine, 332

@EnableZuulProxy, 328

enabling monitoring, 252

encapsulation, 194

engines, process, 208–209

Enterprise Integration Patterns, 127–129

Enterprise JavaBeans (EJB), 70

entities, 41

E-Post Development GmbH, 122

Erlang, 360–363

erosion of microservices, avoiding, 122–123

ESI (Edge Side Includes), 171–172

etcd, 139

Eureka

client, 324–325

configuration, 325

overview, 143, 311, 324

server, 326

evaluation of nanoservices, 366–367

Evans, Eric, 40

event-driven architecture (EDA), 134–135

events

correlating data with, 249

data replication, 186–187

EDA (event-driven architecture), 134–135

event sourcing, 197–199

evolving order, 47

example application. See sample microservices-based application

expenditures, minimizing with testing, 214

exploratorive tests, 59

Ext JS, 165

Extensible Markup Language (XML), 177–178

external interfaces, 85, 187–190

F

Facebook BigPipe, 170–171

factories, 42

fail fast, 205

Fat JARs, 359

Feign, 311

file system (Docker), 261–263

files

application.properties, 313

application-test.properties, 229, 233

Dockerfile, 313–314

JAR (Java archive) files, 307, 354

log analysis, 341

MANIFEST.MF, 350–351

pom.xml, 311–312

Vagrantfile, 315–317

WAR (web application archive), 307, 354

filters

content filters, 128

message filters, 127

Zuul filters, 329

findAll() function, 330

firewalls, 157

First Rule of Distributed Object Design, 29

flexibility (SOA), 87–88

flexible transport (SOAP), 179–180

front-end servers, 171–172

functions. See also commands

callMicroservice(), 334

findAll(), 330

Lambda functions, 348

Seneca, 363–365

G

Gentsch, Lars, 122–123

George, Fred, 284

Gephi, 107

global architecture, 122

Grafana, 250

grants, authorization, 153–154

Graphite, 250

Graylog, 244

growth, planning for

big systems, 119–120

deployment monoliths, 121

erosion of microservices, avoiding, 122–123

global architecture, 122

new functionality, incorporating, 123–125

overview, 118–122

replaceability, 121

small systems, 120–121

H

HAL (Hypertext Application Language), 177

handshaking, 205

HAProxy, 146

Hashicorp Vault, 157–158

HATEOAS (Hypermedia as the Engine of Application State), 177

Heusingfeld, Alexander, 287

hexagonal architecture

example, 201–202

versus layered architecture, 200

microservices and, 201

overview, 199–200

hidden dependencies, 132–133

high cohesion, 102

high technological complexity, 21–22

HornetQ, 183

hosts, open, 45

HP Operations Manager, 251

HSQL database, 307, 319–320

HTML (Hypertext Markup Language)

HTML-based user interfaces

back end, 174–175

front-end servers, 171–172

JavaScript, 170–171

mobile clients, 172–173

organizational levels, 173

ROCA (resource-oriented client architecture), 168–169

routing, 169–170

overview, 178

HTTP (Hypertext Transfer Protocol)

httpd, 145

load balancing, 144–145

RESTful-HTTP interfaces, 50, 175–179

httpd, 145

hype versus reality, 371–372

Hypermedia as the Engine of Application State (HATEOAS), 177

Hypertext Application Language (HAL), 177

Hypertext Markup Language. See HTML (Hypertext Markup Language)

Hypertext Transfer Protocol. See HTTP (Hypertext Transfer Protocol)

Hypoport AG, 258

Hystrix

annotations, 330

@Autowired, 334

@EnableCircuitBreaker, 330

@EnableDiscoveryClient, 324–325

@EnableEurekaClient, 324–325, 332

@EnableEurekaServer, 326

@EnableHystrix, 330

@EnableHystrixDashboard, 331, 332

@EnableTurbine, 332

@EnableZuulProxy, 328

@HystrixCommand, 330

@RequestMapping, 307–308

@RestController, 307–308

@RibbonClient, 334

@SpringBootApplication, 307–308

circuit breaker, 329

configuration, 333

dashboard, 331

overview, 311, 329

resilience and stability, 207–208

Turbine, 331–332

@HystrixCommand, 330

I

IBM Tivoli, 251

Icinga, 250

IDs, correlation IDs, 245

immutable servers, 140, 255

implementation of microservices. See also benefits of microservices; organizational effects of microservices

approaches, 370–371

consumer-driven contract tests, 231–232

data replication, 186

external interfaces, 188–189

hype versus reality, 371–372

microservice implementation without organizational changes, 295–297

sample microservices-based application

build, 311–313

communication, 327–329

deployment with Docker, 313–314

Docker Compose, 321–324

Docker Machine, 320–321

domain architecture, 304–306

integration of other technologies, 335–336

JVM-based microservices in Amazon Cloud, 338–340

load balancing, 333–334

overview, 303–304

resilience with Hystrix, 329–333

service discovery, 324–326

Spring Framework, 306–311

summary, 341–342

testing, 336–337

Vagrant, 314–320

summary, 372

without organizational changes, 295–297

independence

independent scaling, 7, 61

technical independence, 63, 270–273

infrastructure

challenges, 76–77

influence on microservice size, 30–31

legacy applications and, 131

overview, 260–261

PaaS (platform as a service), 266

virtualization with Docker, 261–265

innoQ, 47, 287

installation

deployments, 256

Docker Machine, 321

scripts, 254

tools, 140–141

Vagrant, 318

installation scripts, 254

installation tools, 140–141

integration

data replication

batch, 186

consistency, 185–186

event, 186–187

implementation, 186

overview, 184–185

redundancy, 185–186

external interfaces, 187–190

integration platforms, 83

integration tests, 216, 226–227

internal interfaces, 187–190

legacy applications

breaking up code, 126–127

CMS (content management systems), 130

databases, 133–134

Enterprise Integration Patterns, 127–129

hidden dependencies, 132–133

infrastructure and, 131

limited integration, 129

overview, 57–58, 67, 126–127

UIs (user interfaces), 129–130

levels of, 163, 190–192

messaging

advantages of, 180–181

technologies, 182–184

transactions and, 181–182

of other systems, 21

REST (representational state transfer), 175–179

shared integration tests, 223–224

SOAP (Simple Object Access Protocol), 179–180

UIs (user interfaces)

HTML-based user interfaces, 168–175

SPAs (single-page apps), 164–168

integration tests, 216, 226–227

integrity, 158

interfaces

control via, 260

customer interface, 290–292

external interfaces, 187–190

internal interfaces, 187–190

Postel’s Law, 189–190

separating, 188

SOA (service-oriented architecture), 85–86

versioning, 192

internal interfaces, 187–190

introducing

microservices

approaches, 370–371

hype versus reality, 371–372

summary, 372

SOA (service-oriented architecture), 84

intrusion detection, 157

isolation, 32

J

JAR (Java archive) files, 307, 354

Java

bundles, 350–353

JAR (Java archive) files, 307, 354

Java EE

example, 356–357

microservices with, 355–356

nanoservices with, 355

overview, 354

JMS (Java Messaging Service), 183

JPA (Java Persistence API), 354

JRE (Java Runtime Environment), 307

JSF (Java ServerFaces), 354

JTA (Java Transaction API), 354

JVM-based microservices in Amazon Cloud, 73–74

OSGi, 350–353

Spring Framework

HSQL database, 307, 319–320

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Netflix, 310–311

Spring Data REST, 307

Java EE

example, 356–357

microservices with, 355–356

nanoservices with, 355

overview, 354

Java Messaging Service (JMS), 183

Java Persistence API (JPA), 354

Java Runtime Environment (JRE), 307

Java ServerFaces (JSF), 354

Java Transaction API (JTA), 354

Java Virtual Machine (JVM), 73–74

JavaScript

HTML-based user interfaces, 170–171

JSON (JavaScript Object Notation)

JWE (JSON Web Encryption), 154–155

JWT (JSON Web Token), 154–155

overview, 178

Seneca, 363–365

JavaScript Object Notation. See JSON (JavaScript Object Notation)

JavaScript Object Notation (JSON), 178

Jetty, 338–339

JMS (Java Messaging Service), 183

JPA (Java Persistence API), 354

jQAssistant, 107

JRE (Java Runtime Environment), 307

JSF (Java ServerFaces), 354

JSON (JavaScript Object Notation)

JWE (JSON Web Encryption), 154–155

JWT (JSON Web Token), 154–155

overview, 178

JTA (Java Transaction API), 354

JUnit tests, 232

JVM (Java Virtual Machine), 73–74

JVM-based microservices in Amazon Cloud, 338–340

JWE (JSON Web Encryption), 154–155

JWT (JSON Web Token), 154–155

K

Kafka (Apache), 183, 338

Kerberos, 155

kernels, shared, 108

Kibana, 242–244

Kinesis, 338

Kubernetes, 265, 324

L

Lambda (Amazon), 347–349

landscape (SOA), 82–83

languages

Elixir, 363

Erlang, 360–363

HAL (Hypertext Application Language), 177

HTML (Hypertext Markup Language), 178

Java

bundles, 350–353

Java EE, 354–357

OSGi, 350–353

published language, 45

ubiquitious language, 41

XML (Extensible Markup Language), 177–178

large-scale structure, DDD (domain-driven design) and, 46–47

latency, 69–70

layered architecture, 200

leadership, technical, 284

leaseRenewalIntervalInSeconds property (Eureka), 325

legacy applications

development, 6

integration

breaking up code, 126–127

CMS (content management systems), 130

databases, 133–134

Enterprise Integration Patterns, 127–129

hidden dependencies, 132–133

infrastructure and, 131

limited integration, 129

overview, 57–58, 67, 126–127

UIs (user interfaces), 129–130

modernization scenario

Amazon example, 18–19

approach, 14

challenges, 14–15

feature development, 17–18

general description, 11–12

influence on organization, 18

microservice advantages, 12–13, 17

migration status, 15–16

team creation, 16

levelized structure maps (LSMs), 104

levels

of independence, 271–273

of integration, 163, 190–192

libraries

client libraries, 292–293

Coda Hale Metrics, 340

shared libraries, 112–113

limitations, Conway’s Law as, 36–38

limited integration, 129

lines of code (LOC), 28, 343

Linux containers, 262–263

Linux servers, 264

load balancing

architecture and, 148

central load balancers, 145

client-based load balancing, 147–148

ELB (Elastic Load Balancing), 146, 339

load balancers (HTTP), 176

number of load balancers, 145

REST/HTTP, 144–145

sample microservices-based application, 333–334

service discovery, 146–147

technologies, 145–146

load tests, 217

LOC (lines of code), 28, 343

log analysis, 341

logging

correlation IDs, 245

ELK (Elasticsearch, Logstash, Kibana) stack, 242–244

Graylog, 244

log analysis, 341

for microservices, 241–242

Splunk, 244

stakeholders, 245

Zipkin, 245–246

logic layer integration, 191

Logstash, 242–244

loose coupling, 102

LSMs (levelized structure maps), 104

M

macro architecture

creating, 278–279

definition of, 277

domain architecture, 282

extent of, 279

operations and, 281

operations challenges, 239–240

responsibility for, 277–278

technologies, 280–281

testing, 282–284

MANIFEST.MF file, 350–351

manual tests, 217

maps

Context Maps, 108–109

LSMs (levelized structure maps), 104

Maven, 311–313

Mesos, 265, 324

Mesosphere, 324

message filters, 127

message routers, 127

message translators, 127

message-driven components, 210

messaging

advantages of, 180–181

message filters, 127

message routers, 127

message translators, 127

technologies, 182–184

transactions and, 181–182

metadata, 159–160

metrics, monitoring. See monitoring

Metrics framework, 252

micro architecture

creating, 278–279

definition of, 277

domain architecture, 282

operations challenges, 239–240, 281

responsibility for, 277–278

technologies, 280–281

testing, 282–284

microservice advantages

business advantages, 65–67

choice of technologies, 7

continuous delivery, 7–8

independent scaling, 7

legacy application development, 6

modularization, 5

organizational benefits, 63–65

overview, 4–5, 270

replaceability, 5–6

sustainable development, 6

technical benefits

choice of technologies, 7, 62–63

continuous delivery, 7–8, 59–60

independence, 63, 270–273

independent scaling, 7

legacy integration, 6, 57–58

microservice replacement, 56–57

modularization, 5

overview, 55–56

replaceability, 5–6

robustness, 61–62

scaling, 7, 61

sustainable development, 6, 57

time to market, 6–7

time to market, 6–7

microservice challenges

architecture, 74–76

of Conway’s Law, 273–274

infrastructure, 76–77

operations

artifacts, 238–239

micro and macro architecture, 239–240

templates, 240

overview, 8

summary, 78

technical challenges

code dependencies, 71–72

overview, 69–71

technology pluralism, 73–74

unreliable communication, 73

microservice definition, 3–4

microservice-based systems

architecture management

Context Maps, 108–109

cycle-free software, 104–105

importance of, 107–108

tools for, 104–107

configuration, 139–141

documentation, 159–161

domain architecture

dependency management, 101–104

Otto GmbH example, 101

overview, 100

strategic design, 100–101

EDA (event-driven architecture), 134–135

legacy application integration

breaking up code, 126–127

CMS (content management systems), 130

databases, 133–134

Enterprise Integration Patterns, 127–129

hidden dependencies, 132–133

infrastructure and, 131

limited integration, 129

overview, 126–127

UIs (user interfaces), 129–130

load balancing

architecture and, 148

central load balancers, 145

client-based load balancing, 147–148

number of load balancers, 145

REST/HTTP, 144–145

service discovery, 146–147

technologies, 145–146

overview, 99

planning for growth

big systems, 119–120

deployment monoliths, 121

erosion of microservices, avoiding, 122–123

global architecture, 122

new functionality, incorporating, 123–125

overview, 118–119

replaceability, 121

small systems, 120–121

scalability

advantages of microservices, 150

dynamic scaling, 148–150

sharding, 150–151

throughput and response times, 151

security

availability, 159

confidentiality, 158

data security, 158–159

Datensparsamkeit, 157

firewalls, 157

Hashicorp Vault, 157–158

integrity, 158

intrusion detection, 157

JWT (JSON Web Token), 154–155

Kerberos, 155

OAuth2, 152–156

overview, 151–152

service discovery, 141–143

summary, 161–162

technical architecture, 136–138

techniques to adjust architecture

causes of bad architecture, 110–111

challenges with, 117–118

changes in microservices, 111

changes to overall architecture, 111–112

code reuse versus redundancy, 114–115

code transfer, 113–114

overview, 110

rewriting, 117

shared libraries, 112–113

shared services, 115–116

spawning new services, 116–117

middleware, uncoupling via, 206

migration status, 15–16

minimizing expenditures with testing, 214

minimum size of microservices, 344–345

mitigating risk, 220–222, 256

mobile clients, 172–173

mocks, 215–216

Moco, 229

mod_include, 171

mod_proxy_balancer, 145

modernizing legacy applications

approach, 14

overview, 57–58

sample scenarios

challenges, 14–15

feature development, 17–18

general description, 11–12

influence on organization, 18

microservice advantages, 12–13, 17

migration status, 15–16

team creation, 16

modularization

influence on microservice size, 28

overview, 5

sample microservices-based application, 306

SPAs (single-page apps), 167–168

strong modularization, 67

Möllering, Sascha, 338–340

monitoring

additional metrics, 248

with Amazon CloudWatch, 340

basic information, 247

correlation with events, 249

dynamic environments, 250

enabling, 252

Erlang, 361

with Hystrix dashboard, 331

overview, 77, 246–247

stakeholders, 248–249

technologies for, 250–253

versus testing, 249

monoliths. See deployment monoliths

mountebank, 229

Müller, Jörg, 258–259

multiple services, splitting into, 116–117

multiple single-page apps. See SPAs (single-page apps)

mvn package command, 311

N

Nagios, 250

nanoservices

advantages of, 344–346

Amazon Lambda, 347–349

definition of, 346–347

Erlang, 360–363

Java EE

microservices with, 355–356

nanoservices with, 355

overview, 354, 355

OSGi, 350–353

overview, 343

Seneca, 363–365

technical evaluation, 366–367

Vert.x, 357–359

Netflix, 310–311, 371

networking, Vagrant, 317

NewRelic, 251

nginx, 145, 171

ngx_http_ssi_module, 171

Node.js, 363–364

NUMMI car factory, 279

O

OAM (operations and maintenance support), 362

OAuth2, 152–156

open host services, 45

open source projects, 293–295

Open Telecom Platform (OTP) framework, 360

operations

challenges

artifacts, 238–239

micro and macro architecture, 239–240

overview, 76–77

templates, 240

control, 259–260

deployment

automation, 254–255

combined versus separate, 258–259

deployment strategies, 256–258

installation and configuration, 256

risks associated with, 256

DevOps, 285–290

infrastructure

overview, 260–261

PaaS (platform as a service), 266

virtualization with Docker, 261–265

logging

correlation IDs, 245

ELK (Elasticsearch, Logstash, Kibana) stack, 242–244

Graylog, 244

for microservices, 241–242

Splunk, 244

stakeholders, 245

Zipkin, 245–246

macro/micro architecture, 281

microservice implementation and, 296–297

monitoring

additional metrics, 248

basic information, 247

correlation with events, 249

dynamic environments, 250

enabling, 252

overview, 246–247

stakeholders, 248–249

technologies for, 250–253

versus testing, 249

summary, 266–267

operations and maintenance support (OAM), 362

Operations Manager, 251

Opscenter, 251

orchestration (SOA), 83, 86–87

order systems, 83

OrderTestApp class, 336

organizational effects of microservices

benefits of microservices, 63–65, 270–273

collective code ownership, 273–276

customer interface, 290–292

DevOps, 285–290

implementation without organizational changes, 295–297

macro/micro architecture

creating, 278–279

definition of, 277

domain architecture, 282

extent of, 279

operations and, 281

responsibility for, 277–278

technologies, 280–281

testing, 282–284

overview, 18, 269

reusable code, 292–295

summary, 297–299

technical leadership, 284

organizational-level interfaces, 173

OSGi, 350–353

OTP (Open Telecom Platform) framework, 360

Otto GmbH, 101

outdated documentation, 160

ownership, collective code ownership, 273–276

P

PaaS (platform as a service), 266

package managers, 255

Packetbeat, 251

Pact, 233

pact-jvm, 233

Pacto, 233

parallel work, 12, 65–67

personification of servers, avoiding, 287–288

perspectives, DevOps and, 288–289

“pets vs. cattle” slogan (DevOps), 287–288

pipeline, continuous delivery, 59–60, 67

planning for growth

big systems, 119–120

deployment monoliths, 121

erosion of microservices, avoiding, 122–123

global architecture, 122

new functionality, incorporating, 123–125

overview, 118–119

replaceability, 121

small systems, 120–121

platform as a service (PaaS), 266

Play, 210

pluralism, 73–74

pom.xml files, 311–312

portals (SOA), 83

Postel’s Law, 189–190

Prana, 336

preferIpAddress property (Eureka), 325

process engines, 208–209

programs. See tools

projects

open source projects, 293–295

project size, 65

Protocol Buffer, 178

provider contracts, 230

proxy-based load balancing, 144–145

published language, 45

pull requests for coordination, 276

Puppet, 255

Q-R

Qpid (Apache), 182

RabbitMQ, 182

Reactive Manifesto, 207, 209–210

reactive systems, 209–210

reasons for microservices. See benefits of microservices

redundancy, 114–115, 185–186

refactoring, 8, 29–30, 75

reference environments, 228

registry (Docker), 264

Release It!, 62, 203

Remedy, 251

remote procedure call (RPC), 179

replaceability

advantages of, 56–57

influence on microservice size, 31

overview, 5–6, 67

system planning, 121

replicating data

batch, 186

consistency, 185–186

event, 186–187

implementation, 186

overview, 129–130, 184–185, 191–192

redundancy, 185–186

repositories, 42

representational state transfer. See REST (representational state transfer)

@RequestMapping, 307–308

requests, pull, 276

resilience

bulkhead, 204–205

circuit breaker design, 203–204

fail fast, 205

handshaking, 205

Hystrix, 207–208

overview, 203, 209

Reactive Manifesto, 207

sample microservices-based application

annotations, 330

circuit breaker, 329

configuration, 333

dashboard, 331

overview, 329

Turbine, 331–332

steady state, 205

test harnesses, 206

timeouts, 203

uncoupling via middleware, 206

resource-oriented client architecture (ROCA), 168–169

response times, 151

responsibility layers, 46–47

responsiveness, 209

REST (representational state transfer)

definition of, 175–179

load balancing, 144–145

RESTful-HTTP interfaces, 50

Spring Data REST, 307

@RestController, 307–308

reuse of code, 114–115, 292–295

rewriting services, 117

Ribbon, 310, 333–334

@RibbonClient, 334

rich clients, 172–173

Riemann, 250

risk mitigation, 220–222, 256

robustness, 61–62

Robustness Principle, 189–190

ROCA (resource-oriented client architecture), 168–169

roll forward, 257

rollbacks, 256

routers, 127–129

routing

Enterprise Integration Patterns, 127–129

HTML-based user interfaces, 169–170

Zuul, 327–328

RPC (remote procedure call), 179

rpm, 255

RSpec, 232–233

RxJava, 210

RxJS, 210

S

Salt, 255

SAML, 155

sample microservices-based application

build, 311–313

communication, 327–329

deployment with Docker, 313–314

Docker Compose, 321–324

Docker Machine, 320–321

domain architecture, 304–306

integration of other technologies, 335–336

JVM-based microservices in Amazon Cloud, 338–340

load balancing, 333–334

overview, 303–304

resilience with Hystrix

annotations, 330

circuit breaker, 329

configuration, 333

dashboard, 331

overview, 329

Turbine, 331–332

service discovery, 324–326

Spring Framework

HSQL database, 307

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Netflix, 310–311

Spring Data REST, 307, 319–320

summary, 341–342

testing

consumer-driven contract tests, 337

overview, 336

stubs, 336–337

Vagrant

configuration, 315–317

how it works, 314

installation, 318

networking, 317

Scala, 64, 210

scalability

advantages of microservices, 150

AutoScaling, 339

dynamic scaling, 148–150

ELK (Elasticsearch, Logstash, Kibana) stack, 243–244

independent scaling, 7, 61, 67

sharding, 150–151

throughput and response times, 151

scenarios

legacy application modernization

approach, 14

challenges, 14–15

feature development, 17–18

general description, 11–12

influence on organization, 18

microservice advantages, 12–13, 17

migration status, 15–16

team creation, 16, 18–19

signaling systems

challenges, 21–22

general description, 19–20

microservice advantages, 20–21, 22

suitability of microservices for, 22–23

scripts, installation, 254

SCS (self-contained system), 51

security

API keys, 157

availability, 159

certificates, 157

confidentiality, 158

data security, 158–159

Datensparsamkeit, 157

firewalls, 155

Hashicorp Vault, 157–158

integrity, 158

intrusion detection, 157

JWT (JSON Web Token), 154–155

Kerberos, 155

OAuth2, 152–156

overview, 151–152

SAML, 155

Spring Cloud Security, 309

SSL/TLS, 155

self-contained system (SCS), 51

Semantic Versioning, 189

Seneca, 363–365

seneca.act() function, 364

seneca.add() function, 364

seneca.listen() function, 364

separate deployment, 258–259

separate ways, 45

separating interfaces, 188

Server Side Includes (SSI), 171–172

servers

asset servers, 166–167

Docker and, 264–265

Eureka, 326

front-end servers, 171–172

immutable servers, 140, 255

“pets vs. cattle” slogan (DevOps), 287–288

Zuul, 327–329

Serverspec, 235

service discovery

BIND (Berkeley Internet Name Domain Server), 142–143

Consul, 143

DNS (Domain Name System), 142

Eureka

client, 324–325

configuration, 325

overview, 143, 324

server, 326

load balancing, 146–147

overview, 141–142

service-oriented architecture. See SOA (service-oriented architecture)

Seyren, 250

sharding, 150–151

shared integration tests, 223–224

shared kernels, 44, 108

shared libraries, 112–113, 292–293

shared services, 115–116

signaling system development

challenges, 21–22

general description, 19–20

microservice advantages, 20–21, 22

suitability of microservices for, 22–23

Simple Notification Service (SNS), 348

Simple Object Access Protocol (SOAP), 179–180

Simple Queue Service (SQS), 348

single-page apps. See SPAs (single-page apps)

size of microservices

factors influencing

consistency, 31–32

distributed communication, 28–29

infrastructure, 30–31

LOC (lines of code), 28

modularization, 28

overview, 27–28, 33–35

refactoring, 29–30

replaceability, 31

sustainable architecture, 29

team size, 30

transactions, 31–33

overview, 344–345

project size, 65

summary, 52

small systems, starting with, 120–121

SNS (Simple Notification Service), 348

SOA (service-oriented architecture)

characteristics of, 81–82

communication, 83–84

compared to microservices

architecture, 88–90

communication, 87

flexibility, 87–88

orchestration, 87

synergies, 91

table of differences, 91

coordination, 86

interfaces, 85–86

introducing, 84

landscape, 82–83

orchestration, 86

services in, 84–85

technologies, 86–87

versioning, 85

SOAP (Simple Object Access Protocol), 179–180

software development

sustainable software development, 57, 67

test-driven development, 214–215

SPAs (single-page apps)

asset servers, 166–167

SPA modules, 167–168

SPA per microservice, 165–166

technologies, 164–165

spigo, 110

Splunk, 244

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Bus, 310

Spring Cloud Cluster, 310

Spring Cloud Config, 139, 309–310

Spring Cloud Connectors, 310

Spring Cloud Consul, 310

Spring Cloud Data Flow, 310

Spring Cloud Data Tasks, 310

Spring Cloud for Cloud Foundry, 310

Spring Cloud Netflix, 310–311

Spring Cloud Security, 309

Spring Cloud Sleuth, 310

Spring Cloud Stream, 310

Spring Cloud Zookeeper, 310

Spring Data REST, 307

Spring Framework

HSQL database, 307, 319–320

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Netflix, 310–311

Spring Data REST, 307

Spring Guides, 311

@SpringBootApplication, 307–308

SpringRestDataConfig class, 304–305

SQS (Simple Queue Service), 348

Squid, 171

SSI (Server Side Includes), 171–172

SSL/TLS, 155

stability

bulkhead, 204–205

circuit breaker design, 203–204

fail fast, 205

handshaking, 205

Hystrix, 207–208

microservices and, 206–207

overview, 203

Reactive Manifesto, 207

steady state, 205

test harnesses, 206

timeouts, 203

uncoupling via middleware, 206

stakeholders

for logs, 245

for monitoring, 248–249

statelessness, 209

StatsD, 252

status of migration, 15–16

steady state, 205

strategic design, 100–101

strategies (deployment), 256–258

strong modularization, 67

Structure 101, 107

stubby4j, 229

stubs, 216, 228–229, 336–337

sustainable architecture, 29

sustainable development, 6, 57, 67

synchronous RESTful HTTP, 179

synergies between SOA and microservices, 91

system architecture

architecture management

Context Maps, 108–109

cycle-free software, 104–105

importance of, 107–108

tools for, 104–107

configuration, 139–141

documentation, 159–161

domain architecture

dependency management, 101–104

Otto GmbH example, 101

overview, 100

strategic design, 100–101

EDA (event-driven architecture), 134–135

legacy application integration

breaking up code, 126–127

CMS (content management systems), 130

databases, 133–134

Enterprise Integration Patterns, 127–129

hidden dependencies, 132–133

infrastructure and, 131

limited integration, 129

overview, 126–127

UIs (user interfaces), 129–130

load balancing

architecture and, 148

central load balancers, 145

client-based load balancing, 147–148

number of load balancers, 145

REST/HTTP, 144–145

service discovery, 146–147

technologies, 145–146

overview, 99

planning for growth

big systems, 119–120

deployment monoliths, 121

erosion of microservices, avoiding, 122–123

global architecture, 122

new functionality, incorporating, 123–125

overview, 118–119

replaceability, 121

small systems, 120–121

scalability

advantages of microservices, 150

dynamic scaling, 148–150

sharding, 150–151

throughput and response times, 151

security

API keys, 157

availability, 159

certificates, 157

confidentiality, 158

data security, 158–159

Datensparsamkeit, 157

firewalls, 157

Hashicorp Vault, 157–158

integrity, 158

intrusion detection, 157

JWT (JSON Web Token), 154–155

Kerberos, 155

OAuth2, 152–156

overview, 151–152

SAML, 155

SSL/TLS, 156

service discovery, 141–143

summary, 161–162

technical architecture, 136–138

techniques to adjust architecture

causes of bad architecture, 110–111

challenges with, 117–118

changes in microservices, 111

changes to overall architecture, 111–112

code reuse versus redundancy, 114–115

code transfer, 113–114

overview, 110

rewriting, 117

shared libraries, 112–113

shared services, 115–116

spawning new services, 116–117

system metaphor, 46

system testing, 222–224

T

teams

creating, 16

delegating to, 238–239

DevOps, 285–290

size of, 30

us versus them attitude, 288

technical architecture, 136–138

technical benefits

choice of technologies, 62–63

continuous delivery, 59–60

independence, 63, 270–273

legacy integration, 57–58

microservice replacement, 56–57

overview, 55–56

robustness, 61–62

scaling, 61

sustainable software development, 57

technical challenges

code dependencies, 71–72

overview, 69–71

technology pluralism, 73–74

unreliable communication, 73

technical evaluation of nanoservices, 366–367

technical leadership, 284

technical standards, testing, 233–235

technologies

choice of, 7, 62–63

high technological complexity, 21–22

load balancing, 145–146

messaging, 182–184

monitoring tools, 250–253

sample microservices-based application

HSQL database, 307

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Netflix, 310–311

Spring Data REST, 307, 319–320

for service discovery, 142–143

SOA (service-oriented architecture), 86–87

technology stack per team, 21

technology pluralism, 73–74

templates, 240

test harnesses, 206

test pyramid

for individual services, 217–219

for systems, 222

test-driven development, 214–215

testing

arbitrary test frameworks, 232

benefits of, 213–215

bottlenecks during, 13

continuous delivery pipeline, 220

individual services, 227–229

legacy applications, 225–227

macro/micro architecture, 282–284

versus monitoring, 249

risk mitigation, 220–222

sample microservices-based application

consumer-driven contract tests, 337

overview, 336

stubs, 336–337

summary, 235–236

system testing, 222–224

technical standards, 233–235

test pyramid

for individual services, 217–219

for systems, 222

test types

acceptance tests, 59

capacity tests, 59

consumer-driven contract tests, 230–233, 337

exploratorive tests, 59

integration tests, 216, 226–227

JUnit tests, 232

load tests, 217

manual tests, 217

shared integration tests, 223–224

UI tests, 216–217

unit tests, 215–216

three-tier architecture, 71

Thrift, 180

throughput, 151

Tilkov, Stefan, 47–50

time to market, 6–7

timeouts, 203

Tivoli, 251

Tolerant Reader concept, 190

tools

0MQ, 183

ActiveMQ, 183

Ansible, 255

Apache Kafka, 183

Apache Mesos, 265

Apache Qpid, 182

Apache Thrift, 180

Apache Zookeeper, 139

architecture management, 104–107

ATOM Feeds, 183

Azure Service Bus, 183

BIND (Berkeley Internet Name Domain Server), 142–143

Chef, 255

collectd, 252–253

Consul, 143

CoreOS, 265, 324

DNS (Domain Name System), 142

Docker

cluster environments, 324

containers, 262–263, 318–319

file system, 261–263

overview, 255

registry, 264

sample microservices-based application deployment, 313–314

servers, 264–265

Docker Compose, 265, 321–324

Docker Machine, 265, 320–321

Docker Swarm, 265

etcd, 139

Eureka

client, 324–325

configuration, 325

overview, 143, 311, 324

server, 326

Feign, 311

Gephi, 107

Grafana, 250

Graphite, 250

HAProxy, 146

Hashicorp Vault, 157–158

HornetQ, 183

httpd, 145

Hystrix

annotations, 330

circuit breaker, 329

configuration, 333

dashboard, 331

overview, 311, 329

resilience and stability, 207–208

Turbine, 331–332

Icinga, 250

jQAssistant, 107

Kerberos, 155

Kubernetes, 265, 324

Maven, 311–313

Mesos, 324

Mesosphere, 324

Metrics framework, 252

Moco, 229

mountebank, 229

Nagios, 250

nginx, 145

OAuth2, 152–156

Operations Manager, 251

Opscenter, 251

package managers, 255

Packetbeat, 251

Pact, 233

Pacto, 233

Puppet, 255

RabbitMQ, 182

Remedy, 251

Ribbon, 310, 333–334

Riemann, 250

RSpec, 232–233

Salt, 255

SAML, 155

Serverspec, 235

Seyren, 250

Spring Framework

HSQL database, 307, 319–320

Spring Boot, 307–308

Spring Cloud, 308–310

Spring Cloud Config, 139

Spring Cloud Netflix, 310–311

Spring Data REST, 307

Squid, 171

SSL/TLS, 155

StatsD, 252

Structure 101, 107

stubby4j, 229

Tivoli, 251

Turbine, 311

uniform tools, 239

Vagrant

configuration, 315–317

how it works, 314

installation, 318

networking, 317

Varnish, 171

VirtualBox, 318

WireMock, 229

Zuul, 310, 327–329

tracing, 245–246, 310

transactions

influence on microservice size, 31–33

messages and, 181–182

transferring code, 113–114

TSL, 155

Turbine, 331–332

U

ubiquitious language, 41

UIs (user interfaces)

integration

HTML-based user interfaces, 168–175

overview, 129–130

SPAs (single-page apps), 164–168

overview, 47–50, 129–130

SCS (self-contained system), 51

technical alternatives, 50

UI tests, 216–217

uncoupling via middleware, 206

uniformity

uniform tools, 239

via asset servers, 166–167, 311

unintended domain-based dependencies, 102–103

unit tests, 215–216

UNIX, 3

unreliable communication, 73

updating Docker containers, 319

“us versus them” attitude, 288

user interfaces. See UIs (user interfaces)

V

Vagrant

configuration, 315–317

how it works, 314

installation, 318

networking, 317

vagrant destroy command, 319

vagrant halt command, 319

vagrant provision command, 319

vagrant ssh command, 318

vagrant up command, 319

Vagrantfile, 315–317

value objects, 41

Varnish, 171

v.cpus setting (Vagrantfile), 318

versioning

interfaces, 192

Semantic Versioning, 189

SOA (service-oriented architecture), 85

version control, 77

Verticles (Vert.x), 358–359

Vert.x, 210, 357–359

viewing Docker containers, 318–319

virtual machines, 260

VirtualBox, 318

virtualization (Docker), 261–265

v.memory setting (Vagrantfile), 318

W

WAR (web application archive), 258, 307, 354

web integration. See UIs (user interfaces)

Wehrens, Oliver, 133–134

WireMock, 229

X-Y-Z

XML (Extensible Markup Language), 177–178

zanox AG, 338

ZeroMQ, 183

Zipkin, 245–246

ZMQ, 183

Zookeeper (Apache), 139, 310

Zuul, 310, 327–329

zypper, 255