Index

A

• AAA (Authentication, Authorization, and Accounting) / Identifying the fat domains
• active monitoring / Monitoring a single service
• ActiveMQ / ActiveMQ
• Advanced Message Queuing Protocol (AMPQ) / Creating the orchestration controller
• aggregator design pattern
  • about / Understanding the pattern
  • CQRS, applying / Applying CQRS and event sourcing
  • event sourcing / Applying CQRS and event sourcing
  • database, separating / Separating the database
  • microservices, refactoring / Refactoring the microservices
  • microservice communication / Microservice communication
  • scalability / Pattern scalability
  • bottleneck anti-pattern / Bottleneck anti-pattern
  • best practices / Best practices
  • tests, applying / Applying tests
  • functional test / Functional test
  • functional test, writing / Writing the functional test
  • integration test / Integration test
  • advantage / Pros and cons of aggregator design pattern, Pros of aggregator design pattern
  • disadvantage / Pros and cons of aggregator design pattern, Cons of aggregator design pattern
• anemic domains
  • identifying / Identifying anemic domains
• anti-corruption layer (ACL) / Domain-driven design
• Apache Avro
  • URL / Tools for synchronous communication
  • about / Apache Avro
• Apache Benchmark (AB) / Apache Benchmark
• Apache Thrift
  • URL / Tools for synchronous communication
  • about / Apache Thrift
• API gateway / The API gateway
• application
  • about / Knowing the application
  • DDD / Domain-driven design
  • single responsibility principle / Single responsibility principle
  • explicitly published interface / Explicitly published interface
• asynchronous messaging design pattern
  • about / Understanding the pattern
  • scalability / Pattern scalability
  • best practices / Best practices
  • advantage / Pros and cons of the asynchronous messaging design pattern
  • disadvantage / Pros and cons of the asynchronous messaging design pattern

B

• best practices, asynchronous messaging design pattern
  • application, defining / Application definition
  • responses, avoiding / Don’t try to create responses
  • simplicity, maintaining / Keep it simple
• best practices, branch design pattern
  • domain, definition / Domain definition
  • rules, following / Respect the rules
  • physical components / Attention to physical components
  • simplicity, maintaining / Keep it simple
• best practices, chained design pattern
  • pure microservices / Purest microservices
  • consistent data, requesting / Requesting consistent data
  • chaining / Understanding chain in depth
  • communication layer, using / Paying attention to the communication layer
• best practices, proxy design pattern
  • purest pattern / Purest pattern
  • bottleneck, viewing / Looking at the bottleneck
  • proxy, caching / Caching in the proxy
  • response, controlling / Simple response
• Big Ball of Mud anti-pattern
  • about / Big Ball of Mud anti-pattern
  • characteristics / Big Ball of Mud anti-pattern
• binary communication
  • about / Binary communication – direct communication between services, Understanding the aspect
  • used, for direct communication between services / Binary communication – direct communication between services
  • used, for direct communication between service / Binary communication – direct communication between services
  • synchronous communication, tools / Tools for synchronous communication
  • MessagePack / MessagePack
  • gRPC / gRPC
  • Apache Avro / Apache Avro
  • Apache Thrift / Apache Thrift
  • direct communication alerts / Direct communication alerts
• blue/green deployment pattern / The blue/green deployment pattern and Canary releases
• bottleneck anti-pattern / Bottleneck anti-pattern
• Bounded Context
  • reference link / Understanding CQRS
• branch design pattern
  • about / Understanding the pattern
  • rules / Understanding the pattern
  • used, for data orchestration / Data orchestration and response consolidation
  • used, for response consolidation / Data orchestration and response consolidation
  • flow / Data orchestration and response consolidation
  • microservice communication / Microservice communication
  • scalability / Pattern scalability
  • advantage / Pros and cons of the branch design pattern
  • disadvantage / Pros and cons of the branch design pattern
• brown projects / Understanding the pattern

C

• C# / C#
• caching
  • at client level / Caching at the client level
• caching first / The public facing layer
• caching tools
  • about / Caching tools
  • Memcached / Memcached
  • Redis / Redis
• Canary release / The blue/green deployment pattern and Canary releases
• chained design pattern
  • about / Understanding the pattern
  • flow / Understanding the pattern
  • used, for data orchestration / Data orchestration and response consolidation
  • used, for response consolidation / Data orchestration and response consolidation
  • microservice communication / Microservice communication
  • scalability / Pattern scalability
  • best practices / Best practices
  • advantage / Understanding the pros and cons of chained design pattern
  • disadvantage / Understanding the pros and cons of chained design pattern
• Chaos Gorilla / Chaos Monkey
• Chaos Monkey
  • about / Chaos Monkey
  • reference link / Chaos Monkey
  • Chaos Gorilla / Chaos Monkey
  • Conformity Monkey / Chaos Monkey
  • Doctor Monkey / Chaos Monkey
  • Janitor Monkey / Chaos Monkey
  • Latency Monkey / Chaos Monkey
  • Security Monkey / Chaos Monkey
• circuit breaker / Circuit breaker
• Command Query Responsibility Segregation (CQRS)
  • about / Asynchronism and workers, CQRS – query strategy, What is CQRS?, Understanding CQRS, Data orchestration
  • implementing, advantages / Advantages and disvantages of implementing CQRS
  • implementing, disadvantages / Advantages and disvantages of implementing CQRS
  • applying / Applying CQRS and event sourcing
• CommandStack / Understanding CQRS
• communication
  • documentation / Documentation of communication
• complex queries / What is CQRS?
• Conformity Monkey / Chaos Monkey
• containers
  • separating / Separating containers
  • layered services architecture / Layered services architecture
  • UsersService, separating / Separating UsersService
  • preparing, for integration test / Preparing the containers for the integration test
  • about / Service instance per container
• content obsolescence / What is CQRS?
• context maps / Domain-driven design
• continuous delivery / Continuous integration/continuous delivery/continuous deploy
• continuous deploy / Continuous integration/continuous delivery/continuous deploy
• continuous integration (CI) / Release pipelines, Continuous integration/continuous delivery/continuous deploy
• current application status
  • about / Understanding the current application status
  • public facing layer / The public facing layer
  • internal layer / The internal layer
  • general tools / Understanding general tools
  • microservices, communication between / Communication layer and accreditation between services
  • pattern distribution / Pattern distribution
  • fail strategies / Fail strategies
  • API integration / API integration

D

• data
  • deprecating / Depreciating data
  • regionalizing / Regionalizing data
• DataAccess / Layered services architecture
• database
  • about / The databases
  • separating / Separating the database
  • CommandStack container, writing / Writing the CommandStack container
  • News Databases, creating / Creating the news databases
  • QueryStack container, writing / Writing the QueryStack container
• data orchestration
  • shared data pattern, used for / Data orchestration
  • proxy design pattern, used for / Proxy strategy to orchestrator
  • chained design pattern, used for / Data orchestration and response consolidation
  • branch design pattern, used for / Data orchestration and response consolidation
• Death Star / Direct communication alerts
• deployment
  • about / Deployment
  • continuous integration / Continuous integration/continuous delivery/continuous deploy
  • continuous delivery / Continuous integration/continuous delivery/continuous deploy
  • continuous deploy / Continuous integration/continuous delivery/continuous deploy
  • blue/green deployment pattern / The blue/green deployment pattern and Canary releases
  • Canary releases / The blue/green deployment pattern and Canary releases
  • multiple service instance per host / Multiple service instances per host
  • service instance per host / Service instance per host
• direct communication alerts / Direct communication alerts
• Distributed Denial of Service (DDoS) / Defense for malicious requests – Identifying attacks
• Django Framework Rest / Python
• Dockerfile
  • requirements.txt, dependencies / Dependencies with requirements.txt
• Domain-Driven Design (DDD) / Domain-driven design, Understanding the pattern, Data orchestration and response consolidation
• domains
  • migrating, to entity / From domain to entity
• domain structure
  • developing / Developing the structure
  • database / Database
  • programming language and tools / Programming language and tools
• dumb proxy / Dumb proxy

E

• ecosystem
  • using, against failures / Bulkheads – using the ecosystem against failures
  • redundancy, designing / Designing for redundancy
  • partition, by criticality / Partitioning by criticality
  • isolation, designing with / Designing with isolation
  • fail fast / Fail fast
• end-to-end tests / End-to-end tests
• event sourcing
  • about / Event sourcing – data integrity, Understanding event sourcing, Applying CQRS and event sourcing
  • state mutation / State mutation
• explicitly published interface / Explicitly published interface

F

• fail alert tools / Fail alert tools
• fail strategies / Fail strategies
• fasthttp
  • reference link / Handlers
• fasthttprouter
  • reference link / Handlers
• fat domains
  • identifying / Identifying the fat domains
• functional test / Functional test
• Fuzzing / Monkey tests

G

• Go
  • about / Go, Go
  • logs / Logs
  • handlers / Handlers
  • middleware / Middleware
  • tests / Tests
  • package manager / Package manager
  • Golang ORMs / Golang ORMs
• godep
  • reference link / Package manager
• gorilla/mux
  • about / Handlers
  • reference link / Handlers
• green projects/greenfield applications / Understanding the pattern
• gRPC
  • URL / Tools for synchronous communication, Understanding the data contract between services
  • about / gRPC

H

• health checks / Monitoring a single service
• heterogeneous applications / Potentially heterogeneous/polyglot
• HTTP API / The public facing layer

I

• independent deployment / Independently deploy, upgrade, scale, and replace, Independent deployment
• independent upgrade
  • about / Independently deploy, upgrade, scale, and replace, Upgrade
  • rules / Upgrade
• integration test
  • about / Integration test, Integration tests
  • writing / Writing the integration tests
  • containers, preparing / Preparing the containers for the integration test
• interceptor / Explaining the interceptor
• interchange context / Domain-driven design
• internal communication, microservice
  • sequential / Microservice communication
  • threads / Microservice communication
  • message broker / Microservice communication
• Internal Services / Understanding the pattern

J

• Janitor Monkey / Chaos Monkey
• Java / Java
• JavaScript / JavaScript
• JWT (JSON Web Token) / Understanding JWT

K

• Kafka / Kafka

L

• Latency Monkey / Chaos Monkey
• layered services architecture / Layered services architecture
• light weight communication
  • about / Light weight communication
  • synchronous / Synchronous
  • asynchronous / Asynchronous
• Load Balancer / Microservice communication, Understanding the pattern
• locale proof performance
  • about / Locale proof performance
  • AB / Apache Benchmark
  • WRK tool / WRK
  • Locust / Locust
• Locust / Locust
• logrus
  • reference link / Logs
• logs
  • viewing / Looking at the logs

M

• Memcached / Memcached
• message broker
  • used, for async communication between services / Message broker – Async communication between services
  • ActiveMQ / ActiveMQ
  • RabbitMQ / RabbitMQ
  • Kafka / Kafka
  • about / Microservice communication, Microservice communication
  • applying / Applying the message broker
  • containers, working / Making the containers work together
  • proxy/load balancer, updating / Updating the proxy/load balancer
• MessagePack
  • URL / Tools for synchronous communication
  • about / MessagePack
• metrics / The metrics – Understanding the numbers
• Microservice Aggregator / Data orchestration and response consolidation
• microservice communication
  • about / Microservice communication
  • orchestrator, building / Building the orchestrator
  • message broker, applying / Applying the message broker
• microservice domains
  • identifying, for business / Identifying microservice domains for the business
• microservice encapsulation / Best practices
• microservice frameworks
  • about / Microservice frameworks
  • Python / Python
  • Go / Go
• microservices
  • monolithic application, separating into / Breaking a monolithic application into microservices
  • priorities, defining / Defining priorities
  • deadlines, setting / Setting deadlines
  • domain, defining / Defining the domain
  • experiment, performing / Making experiments
  • standards, defining / Defining standards
  • prototype, creating / Creating a prototype
  • sending, to production / Sending to production
  • developing / Developing new microservices, Exposing the microservice data
  • configuration file, writing / Writing the microservice configuration file
  • model, creating / Creating our model
  • data, exposing / Exposing the microservice data
  • app, executing / Preparing the app to run
  • Dockerfile, creating / Creating the Dockerfile
  • refactoring / Refactoring the microservices
  • requirements, selecting / Selecting our requirements
  • framework, configuring / Configuring the framework
  • container, configuring / Configuring the container
  • model, writing / Writing the models
  • service, creating / Creating the service
  • database containers, preparing / Preparing the database containers to work together
  • communication layer, and accreditation between services / Communication layer and accreditation between services
  • data contract, using / Understanding the data contract between services
  • binary communication, applying / Applying binary communication 
• microservices, monitoring
  • about / Monitoring microservices
  • single service, monitoring / Monitoring a single service
  • multiple services, monitoring / Monitoring multiple services
  • logs, viewing / Looking at the logs
  • application errors, learning from / Learning from the errors in the application
  • metrics / The metrics – Understanding the numbers
• microservices structure
  • about / Project structure
  • models.go file / The models.go file
  • app.go file / The app.go file
  • main.go file / The main.go file
• Minimum Viable Product (MVP) / Development of practicality
• mobile applications
  • endpoints / Endpoints for mobile applications
• mock / Unit tests
• monkey test / Monkey tests
• monolithic application
  • separating, into microservices / Breaking a monolithic application into microservices
• multiple service instances per host / Multiple service instances per host
• multiple services
  • monitoring / Monitoring multiple services

N

• Nagios Core
  • reference link / Monitoring multiple services
• Negroni
  • reference link / Middleware
• NewOrchestrator / Microservice communication

O

• Orchestration Process / Data orchestration and response consolidation
• orchestrator
  • about / Layered services architecture
  • building / Building the orchestrator
  • microservice container, preparing / Preparing the microservice container
  • dependencies, writing / Writing the dependencies
  • configuration file, writing / Writing the configuration file
  • server access, writing / Writing the server access
  • controller, creating / Creating the orchestration controller
• Orchestrator Service / The public facing layer

P

• passive monitoring / Monitoring a single service
• pattern distribution / Pattern distribution
• patterns
  • applying, in application / Pattern distribution
• pipelines
  • releasing / Release pipelines
• polyglot / Potentially heterogeneous/polyglot
• POSIX threads (pthreads) / Microservice communication
• process sequence anti-pattern / Process sequence anti-pattern
• programming languages / Programming languages
• programming languages, aspects
  • proficiency / Proficiency
  • performance / Performance
  • practicality, development / Development of practicality
  • ecosystem / Ecosystem
  • scalability cost / Scalability cost
  • application, selecting / Making choices for our application
• proxy / The proxy approach, Proxy strategy to orchestrator
• proxy design pattern
  • about / The proxy approach
  • dumb proxy / Dumb proxy
  • smart proxy / Smart proxy
  • using / Understanding our proxy
  • used, for data orchestration / Proxy strategy to orchestrator
  • microservice communication / Microservice communication
  • scalability / Pattern scalability
  • best practices / Best practices
  • advantages / Pros and cons of proxy design pattern
  • disadvantages / Pros and cons of proxy design pattern
• public facing layer / The public facing layer
• Public Facing Services / Understanding the pattern
• published interfaces
  • about / Explicitly published interface
  • published versioned interfaces / Explicitly published interface
  • small published interfaces / Explicitly published interface
  • published external interfaces / Explicitly published interface
• Python / Python, Python

Q

• QueryStack / Understanding CQRS
• queueing / Understanding CQRS

R

• RabbitMQ / RabbitMQ
• Recommendation Service
  • data, defining / Data definition – RecommendationService
  • about / The public facing layer
• RecommendationService, communication features
  • about / Microservice communication
  • queues, applying / Applying the message broker and queues
  • message broker, applying / Applying the message broker and queues
  • pub/sub structure, preparing / Preparing the pub/sub structure
• RecommendationService domain
  • defining / Domain definition – RecommendationService
• RecommendationService microservice
  • coding / Coding the microservice
• Redis / Redis
• refactoring / Applying binary communication 
• Remote Procedure Call (RPC) / Microservice communication
• response consolidation
  • chained design pattern, used for / Data orchestration and response consolidation
  • branch design pattern, used for / Data orchestration and response consolidation
• REST (Representational State Transfer) / Understanding the pattern
• risk points, for microservice failure
  • performance / Performance
  • build / Build
  • components / Components
  • implementation gaps / Implementation gaps

S

• scalability
  • about / Scale
  • x-axis / The x-axis
  • y-axis / The y-axis
  • z-axis / The z-axis
  • replace process / Replace
• Secure Socket Layer (SSL) / Web container
• security
  • about / Security
  • JWT / Understanding JWT
  • SSO / Single Sign-On
  • of data / Security of data
  • attacks, identifying / Defense for malicious requests – Identifying attacks
  • interceptor / Explaining the interceptor
  • web container / Web container
  • API gateway / The API gateway
• Security Monkey / Chaos Monkey
• segregated database / Best practices
• semantic gap / Domain-driven design
• Sentry
  • about / Implementation gaps
  • features / Implementation gaps
• server
  • monitoring / Monitoring a single service
• service instance per host
  • about / Service instance per host
  • VM / Service instance per VM
  • container / Service instance per container
• Service Signature / Signature tests
• shared data pattern
  • about / Understanding the pattern
  • used, for data orchestration / Data orchestration
  • responses, consolidating / Consolidating responses
  • microservice communication / Microservice communication
  • storage sharing anti-pattern / Storage sharing anti-pattern
  • using, best practices / Best practices
  • testing / Testing
  • advantages / Pros and cons of the shared data pattern
  • disadvantages / Pros and cons of the shared data pattern
• signature tests / Signature tests
• single responsibility principle / Single responsibility principle
• Single Sign-On (SSO) / Explicitly published interface, Single Sign-On
• smart proxy / Smart proxy
• SQLX
  • reference link / Golang ORMs
• storage distribution
  • about / Storage distribution
  • data, depreciating / Depreciating data
  • data, regionalizing / Regionalizing data
• storage sharing anti-pattern / Storage sharing anti-pattern
• synchronization
  • automatic updating / Understanding CQRS
  • update possible state / Understanding CQRS
  • controlled update state / Understanding CQRS
  • update on demand state / Understanding CQRS

T

• testify
  • reference link / Tests
• throttling policies
  • for client / Throttling for your client
• Transport Layer Security (TLS) / Web container

U

• unit tests / Unit tests
• UsersService
  • separating / Separating UsersService
  • Dockerfile, creating / Creating Dockerfile
  • containers, using / Using the containers
  • about / The public facing layer

V

• Virtual Machine (VM) / Service instance per VM

W

• web application caches
  • strategies / Caching strategies
  • applying / Applying cache
  • caching first strategy / Caching first
  • tasks, enqueuing / Enqueuing tasks
  • asynchronism / Asynchronism and workers
  • workers / Asynchronism and workers
• web applications
  • endpoints / Endpoints for web applications
• web container / Web container
• WRK tool / WRK