0MQ (ZeroMQ), 183
acceptance tests, 59
acceptance-driven design (ATDD), 216
ActiveMQ, 183
causes of bad architecture, 110–111
changes in microservices, 111
changes to overall architecture, 111–112
code reuse versus redundancy, 114–115
overview, 110
rewriting, 117
spawning new services, 116–117
Advanced Message Queuing Protocol (AMQP), 182
advantages of microservices. See microservice advantages
AJAX (Asynchronous JavaScript and XML), 170
Amazon
AWS (Amazon Web Services), 338
Cloud
JVM-based microservices in, 338–340
DynamoDB, 338
Elastic Beanstalk, 349
ElastiCache, 338
Kinesis, 338
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
@RibbonClient, 334
@SpringBootApplication, 307–308
Ansible, 255
Apache
Mesos, 265
Qpid, 182
Thrift, 180
API keys, 157
application.properties file, 313
applications
e-commerce legacy application
team creation, 16
e-commerce legacy application scenario
approach, 14
influence on organization, 18
microservice advantages, 12–13, 17
microservices-based application example
deployment with Docker, 313–314
integration of other technologies, 335–336
JVM-based microservices in Amazon Cloud, 338–340
resilience with Hystrix, 329–333
application-test.properties file, 229, 233
arbitrary test frameworks, 232
architecture
architecture management
effect on departments, 291–292
of individual microservices
CQRS (Command Query Responsibility Segregation), 195–197
hexagonal architecture, 199–202
microservice implementation and, 296–297
technical architecture, 208–211
macro/micro architecture
definition of, 277
domain architecture, 282
extent of, 279
operations and, 281
operations challenges, 239–240
of microservice-based systems
architecture management, 104–110
EDA (event-driven architecture), 134–135
legacy application integration, 126–134
overview, 99
technical architecture, 136–138
techniques to adjust architecture, 110–118
refactoring, 75
sample microservices-based application
deployment with Docker, 313–314
integration of other technologies, 335–336
JVM-based microservices in Amazon Cloud, 338–340
resilience with Hystrix, 329–333
SOA (service-oriented architecture)
compared to microservices, 87–92
coordination, 86
introducing, 84
orchestration, 86
versioning, 85
sustainable architecture, 29
three-tier architecture, 71
Asynchronous JavaScript and XML (AJAX), 170
ATDD (acceptance test-driven design), 216
ATOM Feeds, 183
atomicity, 31
authentication, 329
authorization
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
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
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
CDMs (canonical data models), 47–50
nanoservices and, 347
overview, 52
sample microservices-based application, 305–306
building sample microservices-based application, 311–313
business advantages of microservices, 65–67
CA Opscenter, 251
cache (REST), 176
calling
Lambda functions, 348
callMicroservice() function, 334
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
operations
micro and macro architecture, 239–240
templates, 240
overview, 8
summary, 78
technical challenges
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
client-based load balancing, 147–148
client-level integration, 190–191
cloud
Amazon Cloud
JVM-based microservices in, 338–340
Cloud Foundry, Spring Cloud for, 310
cluster environments, 324
CMS (content management systems), 130
Coda Hale Metrics, 340
code ownership, collective, 273–276
cohesion, 194
collaboration between Bounded Contexts, 44–45
collective code ownership, 273–276
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
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
implementation, 186
distributed communication, 28–29
between Docker containers, 263
between Erlang processes, 360–361
levels of, 163
messaging
REST (representational state transfer)
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
conformist collaboration, 44
consistency
definition of, 31
size of microservices and, 31–32
Consul, 143
consumer contracts, 231
consumer-driven contract tests
overview, 230
sample microservices-based application, 337
containers (Docker), 262–263, 318–319
content filters, 128
content management systems (CMS), 130
content-based routers, 127
contexts, bounded. See Bounded Contexts
legacy application modernization, 12
operations
testing, 220
continuous deployment, 257
contract tests
overview, 230
control of operations, 259–260
Conway, Melvin Edward, 35
Conway’s Law
challenges associated with, 273–274
reasons for, 36
coordination
microservice-based systems, 139–141
pull requests for, 276
SOA (service-oriented architecture), 86
CORBA (Common Object Request Broker Architecture), 70
correlating data with events, 249
correlation IDs, 245
CORS (cross-origin resource sharing), 166–167
CQRS (Command Query Responsibility Segregation)
challenges, 197
microservices and, 196
CRM (customer relationship management), 82–83, 88–90
cross-functional teams, 285–290
cross-origin resource sharing (CORS), 166–167
customer relationship management (CRM), 82–83, 88–90
CustomerConsumerDrivenContractTest class, 337
customer/supplier collaboration, 44
dashboard (Hystrix), 331
data replication
batch, 186
implementation, 186
overview, 129–130, 184–185, 191–192
data storage for sample microservices-based application, 304–305
databases
Amazon DynamoDB, 338
legacy application integration, 133–134
Datensparsamkeit, 157
Bounded Contexts
CDMs (canonical data models), 47–50
nanoservices and, 347
overview, 52
sample microservices-based application, 305–306
CDMs (canonical data models), avoiding, 47–50
summary, 52
ubiquitous language, 41
declarative services (OSGi), 352
delivery. See continuous delivery
departments
architecture leading to, 291–292
microservice implementation and, 296
dependencies
dependency management
unintended domain-based dependencies, 102–103
deployment
combined versus separate, 258–259
deployment monoliths
migrating to microservices, 370–371
overview, 4
problems with, 121
technical coordination, 271
deployment strategies, 256–258
installation and configuration, 256
sample microservices-based application, 313–314
migrating to microservices, 370–371
overview, 4
problems with, 121
technical coordination, 271
desktop applications, nanoservices and, 346
Developer Anarchy, 284
development
signaling systems
microservice advantages, 20–21, 22
suitability of microservices for, 22–23
sustainable development, 6, 57
test-driven development, 214–215
directories
docker-vagrant, 318
log-analysis, 341
distributed communication, 28–29
distributed systems
distributed communication, 28–29
distribution by domain. See DDD (domain-driven design)
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
overview, 255
registry, 264
sample microservices-based application deployment, 313–314
docker kill command, 319
docker log command, 318
docker ps command, 319
docker rm command, 319
docker run command, 334
Docker Swarm, 265
docker-compose command, 323, 334
docker-machine command, 320–321
docker-vagrant directory, 318
documentation
microservice-based system architecture, 159–161
Spring Guides, 311
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
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
DynamoDB, 338
EC2 (Elastic Computing Cloud), 349
Echo Verticles (Vert.x), 358–359
e-commerce legacy application scenario
approach, 14
influence on organization, 18
microservice advantages, 12–13, 17
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
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
Enterprise Integration Patterns, 127–129
Enterprise JavaBeans (EJB), 70
entities, 41
E-Post Development GmbH, 122
erosion of microservices, avoiding, 122–123
ESI (Edge Side Includes), 171–172
etcd, 139
Eureka
configuration, 325
server, 326
evaluation of nanoservices, 366–367
Evans, Eric, 40
event-driven architecture (EDA), 134–135
events
correlating data with, 249
EDA (event-driven architecture), 134–135
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
factories, 42
fail fast, 205
Fat JARs, 359
Feign, 311
files
application.properties, 313
application-test.properties, 229, 233
JAR (Java archive) files, 307, 354
log analysis, 341
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
flexible transport (SOAP), 179–180
functions. See also commands
callMicroservice(), 334
findAll(), 330
Lambda functions, 348
George, Fred, 284
Gephi, 107
global architecture, 122
Grafana, 250
grants, authorization, 153–154
Graphite, 250
Graylog, 244
growth, planning for
deployment monoliths, 121
erosion of microservices, avoiding, 122–123
global architecture, 122
new functionality, incorporating, 123–125
replaceability, 121
HAL (Hypertext Application Language), 177
handshaking, 205
HAProxy, 146
HATEOAS (Hypermedia as the Engine of Application State), 177
Heusingfeld, Alexander, 287
hexagonal architecture
versus layered architecture, 200
microservices and, 201
high cohesion, 102
high technological complexity, 21–22
HornetQ, 183
hosts, open, 45
HP Operations Manager, 251
HTML (Hypertext Markup Language)
HTML-based user interfaces
organizational levels, 173
ROCA (resource-oriented client architecture), 168–169
overview, 178
HTTP (Hypertext Transfer Protocol)
httpd, 145
RESTful-HTTP interfaces, 50, 175–179
httpd, 145
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
@RibbonClient, 334
@SpringBootApplication, 307–308
circuit breaker, 329
configuration, 333
dashboard, 331
resilience and stability, 207–208
@HystrixCommand, 330
IBM Tivoli, 251
Icinga, 250
IDs, correlation IDs, 245
implementation of microservices. See also benefits of microservices; organizational effects of microservices
consumer-driven contract tests, 231–232
data replication, 186
microservice implementation without organizational changes, 295–297
sample microservices-based application
deployment with Docker, 313–314
integration of other technologies, 335–336
JVM-based microservices in Amazon Cloud, 338–340
resilience with Hystrix, 329–333
summary, 372
without organizational changes, 295–297
independence
technical independence, 63, 270–273
infrastructure
influence on microservice size, 30–31
legacy applications and, 131
PaaS (platform as a service), 266
virtualization with Docker, 261–265
installation
deployments, 256
Docker Machine, 321
scripts, 254
Vagrant, 318
installation scripts, 254
integration
data replication
batch, 186
implementation, 186
integration platforms, 83
integration tests, 216, 226–227
legacy applications
CMS (content management systems), 130
Enterprise Integration Patterns, 127–129
infrastructure and, 131
limited integration, 129
UIs (user interfaces), 129–130
messaging
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
separating, 188
SOA (service-oriented architecture), 85–86
versioning, 192
introducing
microservices
summary, 372
SOA (service-oriented architecture), 84
intrusion detection, 157
isolation, 32
JAR (Java archive) files, 307, 354
Java
JAR (Java archive) files, 307, 354
Java EE
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
Spring Framework
Spring Data REST, 307
Java EE
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
overview, 178
JavaScript Object Notation. See JSON (JavaScript Object Notation)
JavaScript Object Notation (JSON), 178
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
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
Kerberos, 155
kernels, shared, 108
Kinesis, 338
languages
Elixir, 363
HAL (Hypertext Application Language), 177
HTML (Hypertext Markup Language), 178
Java
published language, 45
ubiquitious language, 41
XML (Extensible Markup Language), 177–178
large-scale structure, DDD (domain-driven design) and, 46–47
layered architecture, 200
leadership, technical, 284
leaseRenewalIntervalInSeconds property (Eureka), 325
legacy applications
development, 6
integration
CMS (content management systems), 130
Enterprise Integration Patterns, 127–129
infrastructure and, 131
limited integration, 129
UIs (user interfaces), 129–130
modernization scenario
approach, 14
influence on organization, 18
microservice advantages, 12–13, 17
team creation, 16
levelized structure maps (LSMs), 104
levels
libraries
Coda Hale Metrics, 340
limitations, Conway’s Law as, 36–38
limited integration, 129
Linux servers, 264
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
sample microservices-based application, 333–334
load tests, 217
log analysis, 341
logging
correlation IDs, 245
ELK (Elasticsearch, Logstash, Kibana) stack, 242–244
Graylog, 244
log analysis, 341
Splunk, 244
stakeholders, 245
logic layer integration, 191
loose coupling, 102
LSMs (levelized structure maps), 104
macro architecture
definition of, 277
domain architecture, 282
extent of, 279
operations and, 281
operations challenges, 239–240
manual tests, 217
maps
LSMs (levelized structure maps), 104
Mesosphere, 324
message filters, 127
message routers, 127
message translators, 127
message-driven components, 210
messaging
message filters, 127
message routers, 127
message translators, 127
metrics, monitoring. See monitoring
Metrics framework, 252
micro architecture
definition of, 277
domain architecture, 282
operations challenges, 239–240, 281
choice of technologies, 7
independent scaling, 7
legacy application development, 6
modularization, 5
organizational benefits, 63–65
sustainable development, 6
technical benefits
choice of technologies, 7, 62–63
continuous delivery, 7–8, 59–60
independent scaling, 7
microservice replacement, 56–57
modularization, 5
sustainable development, 6, 57
microservice challenges
operations
micro and macro architecture, 239–240
templates, 240
overview, 8
summary, 78
technical challenges
unreliable communication, 73
microservice-based systems
architecture management
domain architecture
dependency management, 101–104
Otto GmbH example, 101
overview, 100
EDA (event-driven architecture), 134–135
legacy application integration
CMS (content management systems), 130
Enterprise Integration Patterns, 127–129
infrastructure and, 131
limited integration, 129
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
overview, 99
planning for growth
deployment monoliths, 121
erosion of microservices, avoiding, 122–123
global architecture, 122
new functionality, incorporating, 123–125
replaceability, 121
scalability
advantages of microservices, 150
throughput and response times, 151
security
availability, 159
confidentiality, 158
Datensparsamkeit, 157
firewalls, 157
integrity, 158
intrusion detection, 157
Kerberos, 155
technical architecture, 136–138
techniques to adjust architecture
causes of bad architecture, 110–111
changes in microservices, 111
changes to overall architecture, 111–112
code reuse versus redundancy, 114–115
overview, 110
rewriting, 117
spawning new services, 116–117
middleware, uncoupling via, 206
minimizing expenditures with testing, 214
minimum size of microservices, 344–345
Moco, 229
mod_include, 171
mod_proxy_balancer, 145
modernizing legacy applications
approach, 14
sample scenarios
influence on organization, 18
microservice advantages, 12–13, 17
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
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
versus testing, 249
monoliths. See deployment monoliths
mountebank, 229
multiple services, splitting into, 116–117
multiple single-page apps. See SPAs (single-page apps)
mvn package command, 311
Nagios, 250
nanoservices
Java EE
nanoservices with, 355
overview, 343
networking, Vagrant, 317
NewRelic, 251
ngx_http_ssi_module, 171
NUMMI car factory, 279
OAM (operations and maintenance support), 362
open host services, 45
Open Telecom Platform (OTP) framework, 360
operations
challenges
micro and macro architecture, 239–240
templates, 240
combined versus separate, 258–259
deployment strategies, 256–258
installation and configuration, 256
risks associated with, 256
infrastructure
PaaS (platform as a service), 266
virtualization with Docker, 261–265
logging
correlation IDs, 245
ELK (Elasticsearch, Logstash, Kibana) stack, 242–244
Graylog, 244
Splunk, 244
stakeholders, 245
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
versus testing, 249
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
implementation without organizational changes, 295–297
macro/micro architecture
definition of, 277
domain architecture, 282
extent of, 279
operations and, 281
technical leadership, 284
organizational-level interfaces, 173
OTP (Open Telecom Platform) framework, 360
Otto GmbH, 101
outdated documentation, 160
ownership, collective code ownership, 273–276
PaaS (platform as a service), 266
package managers, 255
Packetbeat, 251
Pact, 233
pact-jvm, 233
Pacto, 233
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
deployment monoliths, 121
erosion of microservices, avoiding, 122–123
global architecture, 122
new functionality, incorporating, 123–125
replaceability, 121
platform as a service (PaaS), 266
Play, 210
portals (SOA), 83
Prana, 336
preferIpAddress property (Eureka), 325
programs. See tools
projects
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
Qpid (Apache), 182
RabbitMQ, 182
Reactive Manifesto, 207, 209–210
reasons for microservices. See benefits of microservices
reference environments, 228
registry (Docker), 264
Remedy, 251
remote procedure call (RPC), 179
replaceability
influence on microservice size, 31
system planning, 121
replicating data
batch, 186
implementation, 186
overview, 129–130, 184–185, 191–192
repositories, 42
representational state transfer. See REST (representational state transfer)
requests, pull, 276
resilience
circuit breaker design, 203–204
fail fast, 205
handshaking, 205
Reactive Manifesto, 207
sample microservices-based application
annotations, 330
circuit breaker, 329
configuration, 333
dashboard, 331
overview, 329
steady state, 205
test harnesses, 206
timeouts, 203
uncoupling via middleware, 206
resource-oriented client architecture (ROCA), 168–169
response times, 151
responsiveness, 209
REST (representational state transfer)
RESTful-HTTP interfaces, 50
Spring Data REST, 307
reuse of code, 114–115, 292–295
rewriting services, 117
@RibbonClient, 334
Riemann, 250
ROCA (resource-oriented client architecture), 168–169
roll forward, 257
rollbacks, 256
routing
Enterprise Integration Patterns, 127–129
HTML-based user interfaces, 169–170
RPC (remote procedure call), 179
rpm, 255
RxJava, 210
RxJS, 210
Salt, 255
SAML, 155
sample microservices-based application
deployment with Docker, 313–314
integration of other technologies, 335–336
JVM-based microservices in Amazon Cloud, 338–340
resilience with Hystrix
annotations, 330
circuit breaker, 329
configuration, 333
dashboard, 331
overview, 329
Spring Framework
HSQL database, 307
Spring Data REST, 307, 319–320
testing
consumer-driven contract tests, 337
overview, 336
Vagrant
how it works, 314
installation, 318
networking, 317
scalability
advantages of microservices, 150
AutoScaling, 339
ELK (Elasticsearch, Logstash, Kibana) stack, 243–244
independent scaling, 7, 61, 67
throughput and response times, 151
scenarios
legacy application modernization
approach, 14
influence on organization, 18
microservice advantages, 12–13, 17
signaling systems
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
Datensparsamkeit, 157
firewalls, 155
integrity, 158
intrusion detection, 157
Kerberos, 155
SAML, 155
Spring Cloud Security, 309
SSL/TLS, 155
self-contained system (SCS), 51
Semantic Versioning, 189
seneca.act() function, 364
seneca.add() function, 364
seneca.listen() function, 364
separate ways, 45
separating interfaces, 188
Server Side Includes (SSI), 171–172
servers
Eureka, 326
“pets vs. cattle” slogan (DevOps), 287–288
Serverspec, 235
service discovery
BIND (Berkeley Internet Name Domain Server), 142–143
Consul, 143
DNS (Domain Name System), 142
Eureka
configuration, 325
server, 326
service-oriented architecture. See SOA (service-oriented architecture)
Seyren, 250
shared integration tests, 223–224
shared libraries, 112–113, 292–293
signaling system development
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
distributed communication, 28–29
LOC (lines of code), 28
modularization, 28
replaceability, 31
sustainable architecture, 29
team size, 30
project size, 65
summary, 52
small systems, starting with, 120–121
SNS (Simple Notification Service), 348
SOA (service-oriented architecture)
compared to microservices
communication, 87
orchestration, 87
synergies, 91
table of differences, 91
coordination, 86
introducing, 84
orchestration, 86
versioning, 85
SOAP (Simple Object Access Protocol), 179–180
software development
sustainable software development, 57, 67
test-driven development, 214–215
spigo, 110
Splunk, 244
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 Security, 309
Spring Cloud Sleuth, 310
Spring Cloud Stream, 310
Spring Cloud Zookeeper, 310
Spring Data REST, 307
Spring Framework
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
circuit breaker design, 203–204
fail fast, 205
handshaking, 205
overview, 203
Reactive Manifesto, 207
steady state, 205
test harnesses, 206
timeouts, 203
uncoupling via middleware, 206
for logs, 245
statelessness, 209
StatsD, 252
steady state, 205
strategies (deployment), 256–258
strong modularization, 67
Structure 101, 107
stubby4j, 229
sustainable architecture, 29
sustainable development, 6, 57, 67
synchronous RESTful HTTP, 179
synergies between SOA and microservices, 91
system architecture
architecture management
domain architecture
dependency management, 101–104
Otto GmbH example, 101
overview, 100
EDA (event-driven architecture), 134–135
legacy application integration
CMS (content management systems), 130
Enterprise Integration Patterns, 127–129
infrastructure and, 131
limited integration, 129
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
overview, 99
planning for growth
deployment monoliths, 121
erosion of microservices, avoiding, 122–123
global architecture, 122
new functionality, incorporating, 123–125
replaceability, 121
scalability
advantages of microservices, 150
throughput and response times, 151
security
API keys, 157
availability, 159
certificates, 157
confidentiality, 158
Datensparsamkeit, 157
firewalls, 157
integrity, 158
intrusion detection, 157
Kerberos, 155
SAML, 155
SSL/TLS, 156
technical architecture, 136–138
techniques to adjust architecture
causes of bad architecture, 110–111
changes in microservices, 111
changes to overall architecture, 111–112
code reuse versus redundancy, 114–115
overview, 110
rewriting, 117
spawning new services, 116–117
system metaphor, 46
teams
creating, 16
size of, 30
us versus them attitude, 288
technical architecture, 136–138
technical benefits
microservice replacement, 56–57
scaling, 61
sustainable software development, 57
technical challenges
unreliable communication, 73
technical evaluation of nanoservices, 366–367
technical leadership, 284
technical standards, testing, 233–235
technologies
high technological complexity, 21–22
sample microservices-based application
HSQL database, 307
Spring Data REST, 307, 319–320
for service discovery, 142–143
SOA (service-oriented architecture), 86–87
technology stack per team, 21
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
bottlenecks during, 13
continuous delivery pipeline, 220
macro/micro architecture, 282–284
versus monitoring, 249
sample microservices-based application
consumer-driven contract tests, 337
overview, 336
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
three-tier architecture, 71
Thrift, 180
throughput, 151
timeouts, 203
Tivoli, 251
Tolerant Reader concept, 190
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
Consul, 143
DNS (Domain Name System), 142
Docker
cluster environments, 324
overview, 255
registry, 264
sample microservices-based application deployment, 313–314
Docker Swarm, 265
etcd, 139
Eureka
configuration, 325
server, 326
Feign, 311
Gephi, 107
Grafana, 250
Graphite, 250
HAProxy, 146
HornetQ, 183
httpd, 145
Hystrix
annotations, 330
circuit breaker, 329
configuration, 333
dashboard, 331
resilience and stability, 207–208
Icinga, 250
jQAssistant, 107
Kerberos, 155
Mesos, 324
Mesosphere, 324
Metrics framework, 252
Moco, 229
mountebank, 229
Nagios, 250
nginx, 145
Operations Manager, 251
Opscenter, 251
package managers, 255
Packetbeat, 251
Pact, 233
Pacto, 233
Puppet, 255
RabbitMQ, 182
Remedy, 251
Riemann, 250
Salt, 255
SAML, 155
Serverspec, 235
Seyren, 250
Spring Framework
Spring Cloud Config, 139
Spring Data REST, 307
Squid, 171
SSL/TLS, 155
StatsD, 252
Structure 101, 107
stubby4j, 229
Tivoli, 251
Turbine, 311
uniform tools, 239
Vagrant
how it works, 314
installation, 318
networking, 317
Varnish, 171
VirtualBox, 318
WireMock, 229
transactions
influence on microservice size, 31–33
TSL, 155
ubiquitious language, 41
integration
HTML-based user interfaces, 168–175
SPAs (single-page apps), 164–168
SCS (self-contained system), 51
technical alternatives, 50
uncoupling via middleware, 206
uniformity
uniform tools, 239
via asset servers, 166–167, 311
unintended domain-based dependencies, 102–103
UNIX, 3
unreliable communication, 73
updating Docker containers, 319
“us versus them” attitude, 288
user interfaces. See UIs (user interfaces)
Vagrant
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
value objects, 41
Varnish, 171
v.cpus setting (Vagrantfile), 318
versioning
interfaces, 192
Semantic Versioning, 189
SOA (service-oriented architecture), 85
version control, 77
viewing Docker containers, 318–319
virtual machines, 260
VirtualBox, 318
virtualization (Docker), 261–265
v.memory setting (Vagrantfile), 318
WAR (web application archive), 258, 307, 354
web integration. See UIs (user interfaces)
WireMock, 229
XML (Extensible Markup Language), 177–178
zanox AG, 338
ZeroMQ, 183
ZMQ, 183
zypper, 255