Index
A
- acceptance testing, Types of Tests
- access by reference, Access by Reference
- accountability, People
- adaptability, Summary
- Aegisthus project, Backup Data Pump
- aggregated logs, Logs, Logs, and Yet More Logs…
- antifragile systems, Microservices, The Antifragile Organization-Isolation
- AP system
- API key-based authentication, API Keys, It’s All About the Keys
- application containers, Application Containers
- architects (see systems architects)
- architectural principles
- architectural safety, Architectural Safety, Architectural Safety Measures
- artifacts
- asynchronous collaboration
- ATOM specification, Technology Choices
- authentication/authorization, Authentication and Authorization-The Deputy Problem
- automation
- autonomy
- autoscaling, Autoscaling
- availability
B
- backends for frontends (BFFs), Backends for Frontends
- backup data pumps, Backup Data Pump
- backups, encryption of, Encrypt Backups
- blue/green deployment, Separating Deployment from Release
- bottlenecks, Delivery Bottlenecks
- bounded contexts
- Brakeman, Baking Security In
- breaking changes
- brittle tests, Flaky and Brittle Tests
- brittleness, Brittleness
- build pipelines, Build Pipelines and Continuous Delivery
- bulkheads, Bulkheads
- bundled service release, And the Inevitable Exceptions
- business capabilities, Business Capabilities
- business concepts, Communication in Terms of Business Concepts
- business-facing tests, Types of Tests
C
- caching
- benefits of, Caching
- cache failures, Hiding the Origin
- cache poisoning, Cache Poisoning: A Cautionary Tale
- client-side, Client-Side, Proxy, and Server-Side Caching
- for writes, Caching for Writes
- in HTTP, Caching in HTTP
- proxy, Client-Side, Proxy, and Server-Side Caching
- server-side, Client-Side, Proxy, and Server-Side Caching
- canary releasing, Canary Releasing
- CAP theorem, CAP Theorem-And the Real World
- cascading failures, The Cascade
- certificate management, Client Certificates
- Chaos Gorilla, The Antifragile Organization
- Chaos Monkey, The Antifragile Organization
- choreographed architecture, Orchestration Versus Choreography
- circuit breakers, Tailored Service Template, Circuit Breakers
- circuit_breaker mixin for Ruby, Bulkheads
- class-responsibility-collaboration (CRC), Cost of Change
- client certificates, Client Certificates
- client libraries, Client Libraries
- client-side caching, Client-Side, Proxy, and Server-Side Caching
- code reuse, DRY and the Perils of Code Reuse in a Microservice World
- coding architect, Zoning
- cohesion, Small, and Focused on Doing One Thing Well, High Cohesion
- Cohn's Test Pyramid, Test Scope
- collaboration, Summary
- Command-Query Responsibility Segregation (CQRS), CQRS
- commits, two-phase, Distributed Transactions
- communication
- compensating transactions, Abort the Entire Operation
- composability, Composability
- configuration drift, Immutable Servers
- configuration, service, Service Configuration
- confused deputy problem, The Deputy Problem
- consistency
- constraints, Constraints
- Consul, Consul
- consumer-driven contracts (CDCs), Consumer-Driven Tests to the Rescue-It’s About Conversations
- content delivery network (CDN), Client-Side, Proxy, and Server-Side Caching
- content management systems (CMS), Example: CMS as a service
- continuous delivery (CD), Microservices, Build Pipelines and Continuous Delivery
- continuous integration (CI)
- Conway's law
- coordination process, Distributed Transactions
- core team, Role of the Custodians
- CoreOS, Docker
- correlation IDs, Correlation IDs
- CP system, AP or CP?
- cross-functional requirements (CFR), Cross-Functional Testing, How Much Is Too Much?
- custodians, Role of the Custodians
- custom images, Custom Images
- Customer Relationship Management (CRM), Example: The multirole CRM system
- customers, interfacing with
D
- data
- data encryption, Go with the Well Known
- data pumps
- database decomposition, The Database-Understanding Root Causes
- breaking foreign key relationships, Example: Breaking Foreign Key Relationships
- incremental approach to, Cost of Change
- overview of, Summary
- refactoring databases, Staging the Break
- selecting separation points, Getting to Grips with the Problem
- selecting separation timing, Understanding Root Causes
- shared data, Example: Shared Data
- shared static data, Example: Shared Static Data
- shared tables, Example: Shared Tables
- transactional boundaries, Transactional Boundaries
- database integration, The Shared Database
- database scaling
- decision-making guidelines, A Principled Approach-A Real-World Example
- decompositional techniques
- decoupling, Autonomous, Orchestration Versus Choreography
- degrading functionality, Degrading Functionality
- delivery bottlenecks, Delivery Bottlenecks
- deployment
- artifacts, images as, Images as Artifacts
- artifacts, operating system, Operating System Artifacts
- artifacts, platform-specific, Platform-Specific Artifacts
- automation, Automation
- blue/green deployment, Separating Deployment from Release
- build pipeline, Build Pipelines and Continuous Delivery
- bundled service release, And the Inevitable Exceptions
- continuous integration basics, A Brief Introduction to Continuous Integration
- continuous integration checklist, Are You Really Doing It?
- continuous integration in microservices, Mapping Continuous Integration to Microservices
- custom images, Custom Images
- environment definition, Environment Definition
- environments to consider, Environments
- immutable servers, Immutable Servers
- interfaces, A Deployment Interface
- microservices vs. monolithic systems, Ease of Deployment, Deployment
- overview of, Summary
- separating from release, Separating Deployment from Release
- service configuration, Service Configuration
- virtualization approach, From Physical to Virtual
- virtualization, hypervisors, Traditional Virtualization
- virtualization, traditional, Traditional Virtualization
- virtualization, type 2, Traditional Virtualization
- deputy problem, The Deputy Problem
- design principles, Principles, Bringing It All Together-Highly Observable
- (see also architectural principles)
- design/delivery practices
- directory service, Common Single Sign-On Implementations
- DiRT (Disaster Recovery Test), The Antifragile Organization
- distributed systems
- distributed transactions, Distributed Transactions
- DNS service, DNS
- Docker, Docker
- documentation
- domain-driven design, Microservices
- Dropwizard, Tailored Service Template
- DRY (Don't Repeat Yourself), DRY and the Perils of Code Reuse in a Microservice World
- dummies, Mocking or Stubbing
- durability, How Much Is Too Much?
- dynamic service registries
E
- empathy, Summary
- encryption, Go with the Well Known
- end-to-end tests
- appropriate uses for, Test Journeys, Not Stories, So Should You Use End-to-End Tests?
- Cohn's Test Pyramid, Test Scope
- creation of, Who Writes These Tests?
- drawbacks of, Flaky and Brittle Tests
- feedback cycle, The Great Pile-up
- implementation of, Those Tricky End-to-End Tests
- metaversion, The Metaversion
- scope of, End-to-End Tests
- timing of, How Long?
- endpoints
- environments
- Erlang modules, Modules
- Eureka, Eureka
- event data pumps, Event Data Pump
- event sourcing, CQRS
- event-based collaboration, Synchronous Versus Asynchronous
- eventual consistency, Try Again Later, Sacrificing Consistency
- evolutionary architects (see systems architects)
- exception handling, Exception Handling
- exemplars, Exemplars
- exploratory testing, Types of Tests
F
- failure bots, The Antifragile Organization
- failures
- fakes, Mocking or Stubbing
- feature-based teams, Feature Teams
- firewalls, Firewalls
- flaky tests, Flaky and Brittle Tests
- foreign key relationships, breaking, Example: Breaking Foreign Key Relationships
- FPM package manager tool, Operating System Artifacts
- functionality, degrading, Degrading Functionality
H
- habitable systems, An Evolutionary Vision for the Architect
- HAL (Hypertext Application Language), HAL and the HAL Browser
- hash-based messaging code (HMAC), HMAC Over HTTP
- HATEOS principle, Hypermedia As the Engine of Application State
- heterogeneity
- hexagonal architecture, Microservices
- hidden models, Shared and Hidden Models
- high cohesion, High Cohesion
- HMAC (hash-based messaging code), HMAC Over HTTP
- HTTP (Hypertext Transfer Protocol)
- HTTP(S) Basic Authentication, HTTP(S) Basic Authentication
- humane registry, HAL and the HAL Browser
- hypermedia, Hypermedia As the Engine of Application State
- hypervisors, Traditional Virtualization
- Hystrix library, Tailored Service Template, Bulkheads
I
- idempotent operations, Idempotency
- identity provider, Common Single Sign-On Implementations
- images
- immutable servers, Immutable Servers
- infrastructure automation, Microservices
- integration
- access by reference, Access by Reference
- asynchronous event-based collaboration, Implementing Asynchronous Event-Based Collaboration
- customer interface, Interfacing with Customers
- DRY (Don't Repeat Yourself), DRY and the Perils of Code Reuse in a Microservice World
- goals for, Looking for the Ideal Integration Technology
- guidelines for, Summary
- importance of, Integration
- orchestration vs. choreography, Orchestration Versus Choreography
- reactive extensions, Reactive Extensions
- remote procedure calls, Remote Procedure Calls
- REST (Representational State Transfer), REST
- services as state machines, Services as State Machines
- shared databases, The Shared Database
- synchronous vs. asynchronous communication, Synchronous Versus Asynchronous
- third-party software, Integrating with Third-Party Software
- user interfaces, User Interfaces
- versioning, Versioning
- interfaces
- internal implementation detail, Hide Internal Implementation Detail
- internal open source model, Internal Open Source
- intrusion detection systems (IDS), Intrusion Detection (and Prevention) System
- intrusion prevention systems (IPS), Intrusion Detection (and Prevention) System
- isolation, Isolation
- IT architects (see systems architects)
L
- latency, How Much Is Too Much?
- Latency Monkey, The Antifragile Organization
- layered architectures, Microservices
- libraries
- Linux containers, Linux Containers
- load balancing, Load Balancing
- load shedding, Bulkheads
- local calls, Local Calls Are Not Like Remote Calls
- logs
- logstash, Logs, Logs, and Yet More Logs…
- loose coupling, Loose Coupling, Orchestration Versus Choreography, Loose and Tightly Coupled Organizations
M
- man-in-the-middle attacks, Allow Everything Inside the Perimeter
- Marick's quadrant, Types of Tests
- maturity, Maturity
- mean time between failures (MTBF), Mean Time to Repair Over Mean Time Between Failures?
- mean time to repair (MTTR), Mean Time to Repair Over Mean Time Between Failures?
- message brokers, Technology Choices
- metrics
- Metrics library, Tailored Service Template
- microservices
- appropriate application of, When Shouldn’t You Use Microservices?
- autonomy and, Autonomous, Building a Team
- benefits of, Microservices
- composability of, Composability
- definition of term, What Are Microservices?
- deployment ease of, Ease of Deployment
- drawbacks of, No Silver Bullet, When Shouldn’t You Use Microservices?
- key principles of, Bringing It All Together
- organizational alignment and, Organizational Alignment
- origins of, Microservices
- replaceability and, Optimizing for Replaceability
- resilience of, Resilience
- scaling and, Scaling
- size and, Small, and Focused on Doing One Thing Well
- technology heterogeneity of, Technology Heterogeneity
- vs. modules, Modules
- vs. service-oriented architecture, What About Service-Oriented Architecture?
- vs. shared libraries, Shared Libraries
- microservices at scale
- antifragile systems, The Antifragile Organization
- architectural safety measures, Architectural Safety Measures
- autoscaling, Autoscaling
- caching, Caching
- caching for writes, Caching for Writes
- CAP theorem, CAP Theorem
- cross-functional requirements (CFR), How Much Is Too Much?
- dealing with failures, Failure Is Everywhere
- degrading functionality, Degrading Functionality
- documenting services, Documenting Services
- dynamic service registries, Dynamic Service Registries
- idempotent operations, Idempotency
- scaling, Scaling
- scaling databases, Scaling Databases
- self-describing systems, HAL and the HAL Browser
- service discovery, Service Discovery
- middleware, Technology Choices
- mocking vs. stubbing, Mocking or Stubbing
- modeling services
- modular decomposition, Modules
- modules, Modules and Services
- monitoring
- cascading failures, The Cascade
- central logging, Logs, Logs, and Yet More Logs…
- complexities of, Monitoring
- correlation IDs, Correlation IDs
- displaying/sharing results, Consider the Audience
- metric tracking across multiple services, Metric Tracking Across Multiple Services
- multiple services/multiple servers, Multiple Services, Multiple Servers
- overview of, Summary
- real-time reporting, The Future
- semantic, Implementing Semantic Monitoring
- service metrics, Service Metrics
- single service/multiple servers, Single Service, Multiple Servers
- single service/single server, Single Service, Single Server
- standardization of, Standardization
- standards establishment and, Monitoring
- synthetic, Synthetic Monitoring
- monolithic systems
- Moore's law, Conway’s Law and System Design
- Mountebank, A Smarter Stub Service
- MTBF (mean time between failures), Mean Time to Repair Over Mean Time Between Failures?
- MTTR (mean time to repair), Mean Time to Repair Over Mean Time Between Failures?
O
- on-demand provisioning systems, Scaling
- on-demand virtualization, Microservices
- onion architecture, The Technical Boundary
- Open Web Application Security Project (OWASP), Baking Security In
- OpenID Connect, Common Single Sign-On Implementations, Use SAML or OpenID Connect
- operating system artifacts, Operating System Artifacts
- operating systems security, Operating System
- orchestration architecture, Orchestration Versus Choreography
- organizational alignment, Organizational Alignment
- organizational structure
- orphaned services, The Orphaned Service?
- OSGI (Open Source Gateway Initiative), Modules
- ownership
P
- Packer, Custom Images
- Pact, Pact
- Pacto, Pact
- partition tolerance
- passwords, Go with the Well Known
- performance tests, Performance Tests
- platform as a service (PaaS), Platform as a Service
- platform-specific artifacts, Platform-Specific Artifacts
- Polly for .NET, Bulkheads
- Postel's Law, Defer It for as Long as Possible
- predictive scaling, Autoscaling
- principal party, Authentication and Authorization
- privacy issues, Be Frugal
- property testing, Types of Tests
- proxy caching, Client-Side, Proxy, and Server-Side Caching
R
- RabbitMQ, Technology Choices
- RDBMS (relational database management systems), Scaling for Reads
- reactive extensions (Rx), Reactive Extensions
- reactive scaling, Autoscaling
- read replicas, Scaling for Reads
- redesign, Starting Again
- refactoring databases, Staging the Break
- remote procedure calls, Remote Procedure Calls-Is RPC Terrible?
- replaceability, Optimizing for Replaceability
- reporting databases
- request/response collaboration, Synchronous Versus Asynchronous
- resilience engineering, Resilience, Caching for Resilience
- resources, REST
- response time, How Much Is Too Much?
- REST (Representational State Transfer), REST-Downsides to REST Over HTTP
- reverse proxy, Client-Side, Proxy, and Server-Side Caching
- Riemann, The Future
- risk, spreading, Spreading Your Risk
- Robustness principle, Defer It for as Long as Possible
- Rx (reactive extensions), Reactive Extensions
S
- SAML, Common Single Sign-On Implementations, Use SAML or OpenID Connect
- SAN (storage area networks), Spreading Your Risk
- scaling, Scaling-Starting Again
- autoscaling, Autoscaling
- benefits of, Scaling
- databases, Scaling Databases
- load balancing, Load Balancing
- reasons for, Scaling
- splitting workloads, Splitting Workloads
- spreading risk, Spreading Your Risk
- vertical, Go Bigger
- vs. redesign, Starting Again
- worker-based systems, Worker-Based Systems
- seams, concept of, It’s All About Seams
- security, Security-Summary
- attacks, defending from, Defense in Depth
- authentication/authorization, Authentication and Authorization
- backups, Backup Data Pump, Encrypt Backups
- education/awareness of, Baking Security In
- encryption, Go with the Well Known
- example setup, A Worked Example
- external verification of, External Verification
- firewalls, Firewalls
- human element of, The Human Element
- importance of, Security
- intrusion detection/prevention, Intrusion Detection (and Prevention) System
- key storage, It’s All About the Keys
- logs, Logging
- man-in-the-middle attacks, Allow Everything Inside the Perimeter
- operating systems, Operating System
- overview of, Summary
- passwords, Go with the Well Known
- privacy issues, Be Frugal
- securing data at rest, Securing Data at Rest
- service-to-service authentication/authorization, Service-to-Service Authentication and Authorization
- tool selection, The Golden Rule
- virtual private clouds, Network Segregation
- Security Development Lifecycle, Baking Security In
- self-describing systems, HAL and the HAL Browser
- semantic monitoring, So Should You Use End-to-End Tests?, Synthetic Monitoring
- semantic versioning, Use Semantic Versioning
- server-side caching, Client-Side, Proxy, and Server-Side Caching
- service accounts, Use SAML or OpenID Connect
- service boundaries, Zoning
- (see also modeling services)
- service calls, data retrieval via, Data Retrieval via Service Calls
- service configuration, Service Configuration
- service discovery, Service Discovery
- service ownership
- service provider, Common Single Sign-On Implementations
- service separation, staging, Staging the Break
- (see also database decomposition)
- service templates, Tailored Service Template
- service tests
- service-oriented architectures (SOA)
- service-to-host mapping, Service-to-Host Mapping-Platform as a Service
- service-to-service authentication/authorization, Service-to-Service Authentication and Authorization-The Deputy Problem
- sharding, Scaling for Writes
- shared code, DRY and the Perils of Code Reuse in a Microservice World
- shared data, Example: Shared Data
- shared libraries, Shared Libraries
- shared models, Shared and Hidden Models
- shared static data, Example: Shared Static Data
- shared tables, Example: Shared Tables
- sharing behavior, The Shared Database
- single sign-on (SSO), Common Single Sign-On Implementations-Single Sign-On Gateway
- smoke test suites, Separating Deployment from Release
- spies, Mocking or Stubbing
- SSH-multiplexing, Single Service, Multiple Servers
- SSL certificates, HTTP(S) Basic Authentication
- SSL termination, Load Balancing
- standards enforcement
- standards establishment, The Required Standard-Architectural Safety
- static data, Example: Shared Static Data
- Strangler Application Pattern, The Strangler Pattern, Architectural Safety Measures
- strategic goals
- stubbing vs. mocking, Mocking or Stubbing
- Suro, The Future
- Swagger, Swagger
- synchronous communication, Synchronous Versus Asynchronous
- synthetic monitoring, Synthetic Monitoring
- system design
- accountability and, People
- adapting to communication pathways, Adapting to Communication Pathways
- bounded contexts, Bounded Contexts and Team Structures
- case study, Case Study: RealEstate.com.au
- Conway's law of, Conway’s Law and System Design
- delivery bottlenecks, Delivery Bottlenecks
- effect on organizational structure, Conway’s Law in Reverse
- feature teams, Feature Teams
- internal open source model, Internal Open Source
- organizational structure and, Evidence
- orphaned services, The Orphaned Service?
- overview of, Summary
- role of custodians, Role of the Custodians
- service maturity, Maturity
- service ownership, Service Ownership
- shared service ownership, Drivers for Shared Services
- tooling, Tooling
- systems architects
- challenges faced by, Summary
- decision-making guidelines for, A Principled Approach
- exception handling, Exception Handling
- governance, Governance and Leading from the Center
- responsibilities of, Inaccurate Comparisons, Technical Debt, Summary
- role of, An Evolutionary Vision for the Architect
- service boundaries and, Zoning
- standards enforcement by, Governance Through Code-Tailored Service Template
- standards establishment by, The Required Standard
- team building by, Building a Team
- team participation by, Zoning
- technical debt and, Technical Debt
T
- tables, shared, Example: Shared Tables
- tailored service templates, Tailored Service Template
- team building, Building a Team
- team structures, Bounded Contexts and Team Structures
- technical boundaries, The Technical Boundary
- technical debt, Technical Debt
- technology heterogeneity, Technology Heterogeneity
- technology-agnostic APIs, Keep Your APIs Technology-Agnostic
- technology-facing tests, Types of Tests
- templates, Tailored Service Template
- test doubles, Mocking or Stubbing
- Test Pyramid, Test Scope, Consumer-Driven Tests to the Rescue
- test snow cone, How Many?
- test-driven design (TDD), Unit Tests
- testing
- canary releasing, Canary Releasing
- considerations for, Trade-Offs
- consumer-driven tests, Consumer-Driven Tests to the Rescue
- cross-functional, Cross-Functional Testing
- end-to-end tests, Those Tricky End-to-End Tests
- MTTR over MTBF, Mean Time to Repair Over Mean Time Between Failures?
- overview of, Summary
- performance tests, Performance Tests
- post-production, Testing After Production
- scope of, Test Scope
- selecting number of, How Many?
- semantic monitoring, So Should You Use End-to-End Tests?
- separating deployment from release, Separating Deployment from Release
- service test implementation, Implementing Service Tests
- types of tests, Types of Tests
- third-party software, Integrating with Third-Party Software-The Strangler Pattern, Data Retrieval via Service Calls
- tight coupling, Loose Coupling, Loose and Tightly Coupled Organizations
- time to live (TTL), DNS
- timeouts, Timeouts
- transaction managers, Distributed Transactions
- transactional boundaries, Transactional Boundaries-So What to Do?
- transactions
- Transport Layer Security (TLS), Client Certificates
- two-phase commits, Distributed Transactions
- type 2 virtualization, Traditional Virtualization
Building Microservices
Published by
O'Reilly Media, Inc., 2015