Index

A

• ActiveMQ / Messaging and message bus, Message-driven
• aggregator
  • URL / Gateway aggregation and offloading
• Akka / Message-driven
• Amazon CloudWatch
  • URL / Centralizing and externalizing log storage 
• Amazon Simple Queue Service / Message-driven
• Amazon Web Services Elastic Load Balancer (ELB)
  • about / AWS Load Balancer
  • benefits / Benefits of using a load balancer
  • fault tolerance / Fault tolerance
  • high availability / High availability
  • flexibility / Flexibility
  • security / Security
  • health check parameters / Health check parameters
  • configuring / Configuring a load balancer, Autoscaling – practical hands on with AWS
  • launch configuration, creating / Creating the launch configuration
  • autoscaling group, creating / Creating an autoscaling group and configuring it with autoscaling policies
  • autoscaling group, configuring with policies / Creating an autoscaling group and configuring it with autoscaling policies
  • application, creating / Creating an application load balancer and adding a target group
  • target group, adding / Creating an application load balancer and adding a target group
  • testing / Time to test
• Ambassador
  • URL / Revisiting testing key points
• AMQP
  • URL / Asynchronous messaging microservice design pattern
• anti-corruption layer (ACL) / Anti-corruption microservice design pattern
• anti-corruption microservice design pattern / Anti-corruption microservice design pattern
• Apache Kafka / Messaging and message bus, Message-driven
• Apache Thrift
  • using, for gRPC / gRPC with Apache Thrift 
• API Composition / Database per service
• API Gateway
  • debunking / Debunking API Gateway
  • design patterns / API Gateway design patterns and aspects
  • aspects / API Gateway design patterns and aspects
  • need for / Need for gateway in our shopping cart microservices
  • design aspects / Need for gateway in our shopping cart microservices
  • versus Reverse proxy Nginx / API Gateway versus reverse proxy NGINX
  • about / API Gateway
• API Gateway, considerations
  • dependency / Design considerations
  • database logic / Design considerations
  • business logic / Design considerations
  • orchestration / Design considerations
  • multiple content types, handling / Design considerations
  • versioning / Design considerations
  • high availability / Design considerations
• API Gateway handles
  • concerns / Concerns API Gateway handles
  • security / Security
  • dumb gateways / Dumb gateways
  • orchestration / Transformation and orchestration
  • monitoring / Monitoring, alerting, and high availability
  • alerting / Monitoring, alerting, and high availability
  • high availability / Monitoring, alerting, and high availability
  • caching / Caching and error handling
  • error handling / Caching and error handling
  • service registry / Service registry and discovery
  • discovery / Service registry and discovery
  • circuit breakers / Circuit breakers
  • versioning / Versioning and dependency resolution
  • dependency resolution / Versioning and dependency resolution
• application directory, configurations
  • src/data-layer / src/data-layer 
  • src/business-layer / src/business-layer
  • src/service-layer / src/service-layer
  • src/middleware / src/middleware
• architecture design, distributed microservices
  • about / Architecture design of our system 
  • microservices / Different microservices 
  • cache microservice / Cache microservice
  • service registry / Service registry and discovery
  • discovery / Service registry and discovery
  • registrator / Registrator
  • logger / Logger 
  • gateway / Gateway
• Async/await
  • failed requests, retrying / Retrying failed requests
  • multiple requests, in parallel / Multiple requests in parallel
• Async Hooks
  • URL / Log levels and logging mechanisms 
• auditing
  • via logs / Auditing via logs 
• auditjs
  • URL / Auditjs  
• AutoRest / Service contracts and statelessness
• Ava / Ava
• AWS Elastic load balancer / Server-side discovery

B

• backend for frontend (BFFs) / Backend for frontends
• back pressure problem / Backpressure strategy
• Bacon.js
  • about / Bacon.js
  • features / Key takeaways
• bit
  • URL / The problem and solution 
  • about / Getting started with bit 
• Bottom-up Approach / Bottom-up approach
• brokers / Message queues and brokers
• brute force attacks
  • preventing / Preventing brute force attacks or flooding by adding rate limiters
• build pipeline
  • deployment / Deployment
  • reference / Deciding release plan
  • dev Stage/feature branch / Deciding release plan
  • testing Stage/QA branch / Deciding release plan
  • Release Stage/Master branch / Deciding release plan
  • Released/ Tag / Deciding release plan
  • logging / Logging 
  • monitoring / Monitoring 
• bulkhead design pattern / Bulkhead design pattern, Bulkhead and retry pattern 

C

• cache
  • about / Cache
  • advantages / Blessing and curse of caching
  • disadvantages / Blessing and curse of caching
  • Redis / Introduction to Redis
• caching
  • at API Gateway level / Caching and error handling
  • at service level / Caching and error handling
• Cassandra / Netflix
• Chai / Chai
• circuit breaker pattern
  • about / Circuit breaker, Circuit breakers and its role, Circuit breaker pattern 
  • role / Circuit breakers and its role
• clair scanner
  • URL / Securing container builds and standardizing deployments
• class-validator
  • URL / src/business-layer
• client-side discovery pattern / Client-side discovery pattern
• client-side load balancing / Client-side load balancing or queue-based load leveling pattern 
• client resiliency patterns
  • about / Client resiliency patterns, Client-side load balancing or queue-based load leveling pattern 
  • bulkhead pattern / Bulkhead and retry pattern 
  • retry pattern / Bulkhead and retry pattern 
  • Client-side load balancing / Client-side load balancing or queue-based load leveling pattern 
  • client resiliency patterns / Client-side load balancing or queue-based load leveling pattern 
  • circuit breaker pattern / Circuit breaker pattern 
  • fallback transaction pattern / The fallback and compensating transaction pattern
  • compensating transaction pattern / The fallback and compensating transaction pattern
• cloud-native approach / Security best practices for containers
• cold observable / Observable streams
• Command Query Responsibility Segregation (CQRS)
  • about / Database per service, Benefits
  • URL / Writing your first Hello World microservice
• commands / Commands
• communication styles
  • about / Communication styles
  • NextGen communication styles / NextGen communication styles 
• compilerOptions
  • URL / compilerOptions
  • about / compilerOptions
• Config
  • URL / Configuring application properties 
• Consul
  • about / Consul
  • server, setting up / Setting up the Consul server
  • URL / Setting up the Consul server
  • server, interacting / Talking with Consul server
  • service instance, registering / Registering a service instance
  • heartbeats, sending / Sending heartbeats and doing a health check
  • health check, performing / Sending heartbeats and doing a health check
  • application, deregistering / Deregistering an application
  • updates, subscribing / Subscribing to updates
  • features / Key points for Consul
  • benefits / If you select Consul
• consumer-driven contracts (CDCs)
  • about / Specifying and testing the microservices contract 
  • testing / What is consumer-driven contract testing?
• containers
  • about / Docker
  • security best practices / Security best practices for containers
• continuous delivery / Deciding release plan
• continuous integration (CI) / Developing some microservices for a shopping cart , Deciding release plan
• core functionalities
  • technical capabilities / Core functionalities 
  • HTTP listeners / Core functionalities 
  • message listeners / Core functionalities 
  • API Gateway / Core functionalities 
  • data storage / Core functionalities 
  • document storage / Core functionalities 
• core microservices implementation, components
  • load balancer / Supporting efficiencies
  • service registry / Supporting efficiencies
  • central logs / Supporting efficiencies
  • security / Supporting efficiencies
  • testing / Supporting efficiencies
• CreditKarma
  • URL / gRPC with Apache Thrift 
• cross-site request forgeries
  • blocking / Blocking cross-site request forgeries
• csurf module
  • URL / Blocking cross-site request forgeries
• currying / Currying functions
• custom header / Versioning 101 

D

• data
  • segregating, between microservices / How to segregate data between microservices
  • segregation rules / Postulate 1 – data ownership should be regulated via business capabilities , Postulate 2 – replicate the database for speed and robustness 
• database selection / Schema design and database selection 
• data formats
  • text-based message formats / Text-based message formats
  • binary message formats / Binary message formats
• data store
  • selecting / How to choose a data store for your microservice
  • categories / How to choose a data store for your microservice
• debugging
  • about / Debugging
  • proxy, building / Building a proxy in between to debug our microservices
  • process, profiling / Profiling process
  • heap, dumping / Dumping heap
  • CPU profiling / CPU profiling
  • Remote Debugging / Live Debugging/Remote Debugging
  • Live Debugging / Live Debugging/Remote Debugging
  • features / Key points for debugging
• DefinitelyTyped
  • URL / Understanding types
  • types, installing / Installing types from DefinitelyTyped
• dependencies / Dependencies
• dependencies, sharing
  • about / Sharing dependencies
  • problem and solution / The problem and solution 
  • bit / Getting started with bit 
  • shared data, issues / The problem of shared data
• deployment, build pipeline
  • release plan, deciding / Deciding release plan
  • options / Deployment options
  • DevOps 101 / DevOps 101
  • Docker / Docker and the world of containers 
  • containers / Docker and the world of containers 
  • WebHooks / WebHooks in our build pipeline
  • serverless architecture / Serverless architecture 
• design aspects
  • about / Microservice design aspects, Design aspects involved
  • communication between / Communication between microservices
  • Remote Procedure Invocation (RPI) / Remote Procedure Invocation (RPI)
  • messaging / Messaging and message bus
  • message bus / Messaging and message bus
  • protobuf / Protobufs
  • service discovery / Service discovery
  • service registry, for service-service communication / Service registry for service-service communication
  • service-side discovery / Server-side discovery
  • client side discovery / Client-side discovery
  • self-registration / Registration patterns – self-registration
  • data management / Data management
  • database per service / Database per service
  • sharing concerns / Sharing concerns
  • externalized configuration / Externalized configuration
  • observability / Observability
  • log aggregation / Log aggregation
  • distributed tracing / Distributed tracing
  • microservices efficiency model / Microservice efficiency model 
  • shopping cart microservices, implementation / Implementation plan for shopping cart microservices 
• design aspects, API Gateway
  • performance, handling / Handle performance and scalability
  • scalability / Handle performance and scalability
  • reactive programming / Reactive programming to up the odds
  • services, invoking / Invoking services
  • services, discovering / Discovering services
  • partial service failure, handling / Handling partial service failures
  • considerations / Design considerations
• design first approach / Top-down or design-first Approach
• design patterns
  • about / Microservice design patterns
  • asynchronous messaging / Asynchronous messaging microservice design pattern
  • backend for frontends / Backend for frontends
  • gateway aggregation / Gateway aggregation and offloading
  • offloading / Gateway aggregation and offloading
  • proxy routing / Proxy routing and throttling
  • throttling / Proxy routing and throttling
  • ambassador pattern / Ambassador and sidecar pattern
  • sidecar pattern / Ambassador and sidecar pattern
  • anti-corruption / Anti-corruption microservice design pattern
  • bulkhead design pattern / Bulkhead design pattern
  • circuit breaker / Circuit breaker
  • strangler pattern / Strangler pattern
• DevOps 101
  • about / DevOps 101
  • containers / Containers
  • containers, versus virtual machine (VM) / Containers versus Virtual Machine (VMs)
• distributed microservices
  • architecture design / Architecture design of our system 
• distributed tracing
  • in Node.js / Distributed tracing in Node.js
• Docker
  • about / Supports polyglot architecture and DevOps, Docker, Docker , Docker and the world of containers 
  • URL / Docker
  • client / Docker components
  • host / Docker components
  • registry / Docker components
  • image / Docker concepts
  • containers / Docker concepts
  • Registry / Docker concepts
  • Dockerfile / Docker concepts
  • Compose / Docker concepts
  • command reference / Docker command reference
  • setting up, with NGINX / Setting up Docker with NGINX, Node.js, and MongoDB
  • setting up, with Node.js / Setting up Docker with NGINX, Node.js, and MongoDB
  • setting up, with MongoDB / Setting up Docker with NGINX, Node.js, and MongoDB
• documenting
  • about / Documenting
  • need for / Need of Documentation
  • Swagger 101 / Swagger 101
• Don't Repeat Yourself (DRY) / The problem and solution 

E

• Elastic Load Balancer (ELB) / Server-side discovery pattern
• Elasticsearch
  • about / Supports polyglot architecture and DevOps, Tracing requests
  • URL / Setting up our environment 
• elastic stack (ELK)
  • about / Twelve-factor application of microservices
  • URL / Centralizing and externalizing log storage 
• environment
  • setting up / Setting up primary environment
  • VS Code / Visual Studio Code (VS Code)
  • PM2 / PM2
  • NGINX / NGINX
  • Docker / Docker
• Eureka
  • about / Zuul and Eureka, Eureka
  • server, setting up /  Setting up the Eureka server
  • server, registering / Registering with Eureka server
  • server, discovering / Discovering with Eureka server
  • features / Key points for Eureka
  • benefits / If you select Eureka
• Event Loop / Event Loop, Understanding Event Loop
• events / Events 
• evil regular expressions
  • protecting against / Protecting against evil regular expressions
• express-ping
  • URL / Custom health module 
• Express gateway / HTTP proxy and Express Gateway

F

• failure handling / Versioning microservices and failure handling, When a developer's nightmare comes true 
• functional reactive programming
  • characteristics / Introduction to reactive programming

G

• gateway aggregation / Gateway aggregation and offloading
• GCP's (Google Cloud Platform's) / Kubernetes concepts
• Grafana / Prometheus and Grafana
• gRPC
  • with Apache Thrift / gRPC with Apache Thrift 

H

• HashiCorp Consul
  • URL / Consul
• health check parameters, AWS Load Balancer
  • about / Health check parameters
  • unhealthy threshold / Unhealthy threshold
  • healthy threshold / Healthy threshold
  • timeout / Timeout
  • health check protocol / Health check protocol
  • health check port / Health check port
  • interval / Interval
• Hello World microservice
  • writing / Writing your first Hello World microservice
• helmet module
  • URL / Adding helmet to configure security headers
• HighLand.js
  • about / HighLand.js
  • features / Key takeaways
• hiredis
  • URL / Introduction to Redis
• hot observable / Observable streams
• Hoverfly
  • URL / Revisiting testing key points
• HTTP / Microservice state 
• http-proxy
  • URL / Building a proxy in between to debug our microservices
• HTTP code
  • about / HTTP code 
  • URL / HTTP code 
  • 1xx (informational) / 1xx – informational 
  • 2xx (success) / 2xx – success 
  • 3xx (redirections) / 3xx – redirections 
  • 4xx (client errors) / 4xx – client errors 
  • 5xx (server errors) / 5xx – server errors 
  • benefits / Why HTTP code is vital in microservices?
• HTTP parameter pollution
  • URL / Avoiding parameter pollution
• HTTP Proxy / HTTP proxy and Express Gateway
• HystrixJS
  • URL / Circuit breakers and its role

I

• individual services
  • security best practices / Security best practices for individual services/applications
• infrastructure role, for efficient microservice implementation
  • server layer / Infrastructure role
  • container / Infrastructure role
  • CI/CD / Infrastructure role
  • clustering / Infrastructure role
• interservice communication
  • about / Interservice communication
  • commands / Commands
  • queries / Queries 
  • events / Events 
  • data formats, exchanging / Exchanging data formats 
• inversify
  • URL / Dependency injection and inversion of control 
• Inversion of control (IOC) / Inversify 
• ioredis
  • URL / Introduction to Redis

J

• JSON Web Token (JWT) / Security

K

• Kestrel / Messaging and message bus
• Kibana
  • about / Tracing requests
  • URL / Setting up our environment 
• Kubernetes
  • about / Self-curing
  • scaling / Scaling with Kubernetes
  • used, for solving problem / What problem does Kubernetes solve?
  • concepts / Kubernetes concepts

L

• Let's Encrypt
  • URL / Securing transmission
• Lines of Code (LOC) / Primer to Node.js
• load test module
  • URL / Time to test
• Log Dashboard / Searchable logs 
• logging, build pipeline
  • best practices / Logging best practices 
  • log storage, centralizing / Centralizing and externalizing log storage 
  • log storage, externalizing / Centralizing and externalizing log storage 
  • structured data / Structured data in logs 
  • identifiers, via correlational IDs / Identifiers via correlational IDs 
  • log levels / Log levels and logging mechanisms 
  • mechanisms / Log levels and logging mechanisms 
  • searchable logs / Searchable logs 
  • centralized custom logging solution implementation / Centralized custom logging solution implementation 
  • environment, setting up / Setting up our environment 
  • distributed tracing, in Node.js / Distributed tracing in Node.js
• logs
  • fatal/emergency (0) / Auditing via logs 
  • alert (1) / Auditing via logs 
  • critical(2) / Auditing via logs 
  • error(3) / Auditing via logs 
  • warning(4) / Auditing via logs 
  • notice(5) / Auditing via logs 
  • info(6) / Auditing via logs 
  • debug(7) / Auditing via logs 
• log shipper / Searchable logs 
• Logstash
  • about / Tracing requests
  • URL / Setting up our environment 
• Log Store / Searchable logs 
• Log stream processor / Searchable logs 
• lusca
  • URL / Adding helmet to configure security headers

M

• media type versioning / Versioning 101 
• Memcache / Cache for failover
• message queues / Message queues and brokers
• microservices
  • debunking / Debunking microservices
  • causes / Rise of microservices
  • languages, selection as per demand / Wide selection of languages as per demand
  • ownership, handling /
  • deployments / Frequent deployments
  • self-sustaining development units / Self-sustaining development units
  • about / What are microservices?
  • principles / Principles and characteristics
  • characteristics / Principles and characteristics, What and how to test
  • monolithic modules, avoiding / No monolithic modules
  • dumb communication pipes /
  • self-governance, decentralization / Decentralization or self-governance
  • service contracts / Service contracts and statelessness
  • statelessness / Service contracts and statelessness
  • lightweight / Lightweight
  • polyglot / Polyglot
  • advantages / Good parts of microservices
  • disadvantages / Bad and challenging parts of microservices
  • example / Microservice example
  • considerations / Key considerations while adopting microservices
  • applications / Microservices in the current world
  • versioning / Versioning microservices and failure handling
• microservices, advantages
  • self-dependent teams / Self-dependent teams
  • services, degradation / Graceful degradation of services
  • polyglot architecture support / Supports polyglot architecture and DevOps
  • DevOps support / Supports polyglot architecture and DevOps
  • event-driven architecture / Event-driven architecture
• microservices, considerations
  • service degradation / Service degradation
  • change governance / Proper change governance
  • heath checks / Health checks, load balancing, and efficient gateway routing
  • load balancing / Health checks, load balancing, and efficient gateway routing
  • gateway routing / Health checks, load balancing, and efficient gateway routing
  • self-curing / Self-curing
  • failover caching / Cache for failover
  • retry / Retry until
• microservices, disadvantages
  • organization / Organization and orchestration
  • platform / Platform
  • testing / Testing
  • service discovery / Service discovery
• Microservices 101 / Dependencies
• microservices description / Versioning and dependency resolution
• microservices design, best practices
  • about / Microservice design best practices
  • microservices scope, setting up / Setting up proper microservice scope 
  • self-governing function / Self-governing functions 
  • polyglot architecture / Polyglot architecture 
  • size of independent deployable component / Size of independent deployable component 
  • services, distributing / Distributing and scaling services whenever required
  • services, scaling / Distributing and scaling services whenever required
  • Agile methodology / Being Agile 
  • single business capability handler / Single business capability handler
  • shifting needs, adapting / Adapting to shifting needs
  • dependencies, handling / Handling dependencies and coupling
  • couplings, handling / Handling dependencies and coupling
  • endpoint count, determining / Deciding the number of endpoints in a microservice
  • communication styles / Communication styles between microservices
  • contract, specifying / Specifying and testing the microservices contract 
  • contract, testing / Specifying and testing the microservices contract 
  • containerizing / Number of microservices in a container 
  • data sources / Data sources and rule engine among microservices 
  • rule engine / Data sources and rule engine among microservices 
• microservices discovery / Versioning and dependency resolution
• microservices efficiency model
  • about / Microservice efficiency model 
  • core functionalities / Core functionalities 
  • efficiency, supporting / Supporting efficiencies
  • infrastructure role / Infrastructure role
  • governance / Governance
• microservices gateway
  • designing, for shopping cart microservices / Designing our gateway for shopping cart microservices
  • requisites / What are we going to use?
• microservices state / Microservice state 
• middleware / Middleware
• Mocha / Mocha
• MongoDB / Supports polyglot architecture and DevOps
• monitoring, build pipeline
  • monitoring 101 / Monitoring 101
  • challenges / Monitoring challenges
  • alerting / When to alert and when not to alert?
  • tools / Monitoring tools 
  • PM2 / PM2 and keymetrics 
  • keymetrics / PM2 and keymetrics 
  • keymetrics, monitor application exceptions / Keymetrics to monitor application exceptions and runtime problems 
  • runtime issues / Keymetrics to monitor application exceptions and runtime problems 
  • custom metrics, adding / Adding custom metrics
  • simple metrics / Simple metrics
  • counter metric h4 / Counter metric 
  • meter / Meter
  • Prometheus / Prometheus and Grafana
  • Grafana / Prometheus and Grafana

N

• Netflix
  • about / Netflix
  • Zuul / Netflix
  • Ribbon / Netflix
  • Hystrix / Netflix
  • Eureka / Netflix
  • Turbine / Netflix
• NetFlix Stack
  • about / Case Study – The NetFlix Stack
  • Zuul environment / Part A – Zuul and Polyglot Environment
  • Polyglot environment / Part A – Zuul and Polyglot Environment
  • Zuul load balancing / Part B – Zuul, Load balancing and failure resiliency
  • Zuul failure resilience / Part B – Zuul, Load balancing and failure resiliency
• NextGen communication styles
  • about / NextGen communication styles 
  • HTTP/2 / HTTP/2 
  • gRPC, with Apache Thrift / gRPC with Apache Thrift 
• NGINX
  • about / NGINX
  • URL / NGINX
• Node.js
  • about / Primer to Node.js
  • event loop / Event Loop
  • clusters / Node.js clusters and multithreading
  • multithreading / Node.js clusters and multithreading
  • async/await / Async/await
  • streams / Streams
  • reactive programming, implementing / Being reactive in Node.js
  • Rx.js / Rx.js
  • Bacon.js / Bacon.js
  • HighLand.js / HighLand.js
• npm module
  • URL / Dumping heap

O

• OAuth / Security
• observables streams
  • about / Observable streams
  • hot observables / Observable streams
  • cold observables / Observable streams
  • subjects / Observable streams
• offloading / Gateway aggregation and offloading
• OpenID / Security
• operator / Operator
• orchestration
  • about / When to react and when not to react (orchestrate), Orchestration
  • advantages / Benefits
  • disadvantages / Disadvantages
  • reactive approach / Reactive approach
  • hybrid pattern / React outside, orchestrate inside
  • reactive orchestrator / Reactive coordinator to drive the flow
  • synopsis / Synopsis, When react outside, orchestrate inside is a perfect fit, When introducing a reactive coordinator is the perfect fit

P

• package.json / package.json 
• platform as a service (PaaS) / Introduction to the service registry
• PM2
  • about / PM2, PM2 process manager
  • URL / PM2, Node.js clusters and multithreading
• postgres
  • URL / Preventing command injection/SQL injection
• Prana
  • URL / Ambassador and sidecar pattern
• predevelopment aspects
  • about / Microservice predevelopment aspects
  • HTTP code / HTTP code 
  • auditing, via logs / Auditing via logs 
  • PM2 process manager / PM2 process manager
  • tracing requests / Tracing requests
• process manager / The problem of shared data
• production-ready microservice
  • criteria / Production-ready microservice criteria
• products microservices
  • design / Design of product microservices
• Prometheus / Prometheus and Grafana
• protocol buffers (protobufs) / Protobufs
• proxy routing / Proxy routing and throttling
• pub/sub pattern / Introduction to pub/sub pattern
• Pull Request (PR) / Deciding release plan

Q

• queries / Queries 

R

• RabbitMQ / Messaging and message bus, Message-driven, RabbitMQ
• rate limiters
  • using / Preventing brute force attacks or flooding by adding rate limiters
• reactive / Introduction to reactive programming
• reactive approach
  • about / Reactive approach
  • advantages / Benefits
  • disadvantages / Disadvantages
• Reactive Manifesto
  • about / Reactive Manifesto
  • responsive systems / Responsive systems
  • resilient, to errors / Resilient to errors
  • elastic scalable / Elastic scalable
  • message-driven / Message-driven
• reactive programming
  • about / Introduction to reactive programming
  • benefits / Why should I consider adopting reactive programming?
  • building blocks / Major building blocks and concerns
  • observable streams / Observable streams
  • subscription / Subscription
  • emit / emit and map
  • map / emit and map
  • operator / Operator
  • backpressure strategy / Backpressure strategy
  • currying functions / Currying functions
  • implementing, in Node.js / Being reactive in Node.js
• Redis
  • about / Netflix, Introduction to Redis
  • URL / Introduction to Redis
  • used, for setting up distributed cache / Setting up our distributed caching using redis
• Registrator
  • URL / Registrator
  • about / Registrator
  • features / Key points for Registrator
• Remote Procedure Invocation (RPI) / Remote Procedure Invocation (RPI)
• responsive systems / Responsive systems
• retire.js
  • URL / Snyk.io 
• retry pattern / Bulkhead and retry pattern 
• Routing Controllers
  • URL / Writing your first Hello World microservice
• routing slip / The problem of shared data
• Rx.js
  • about / Rx.js
  • features / Key takeaways
• Rx.Net / Rx.js
• RxClojure / Rx.js
• RxJava / Rx.js
• RxJS / Rx.js
• RxScala / Rx.js

S

• safe-regex tool
  • URL / Protecting against evil regular expressions
• Sagas / Database per service
• SAML / Security
• scalability
  • about / Scalability
  • AWS Load Balancer / AWS Load Balancer
  • with kubernetes / Scaling with Kubernetes
• security, applying
  • considerations / Questions you should be asking while applying security, Team and operational activities
• security best practices, containers
  • container builds, securing / Securing container builds and standardizing deployments
  • deployments, standardizing / Securing container builds and standardizing deployments
  • containers, securing at runtime / Securing containers at runtime
• security best practices, individual services
  • known security vulnerabilities, checking / Checking for known security vulnerabilities
  • brute force attacks, preventing / Preventing brute force attacks or flooding by adding rate limiters
  • rate limiters addition, flooding / Preventing brute force attacks or flooding by adding rate limiters
  • evil regular expressions, protecting against / Protecting against evil regular expressions
  • cross-site request forgeries, blocking / Blocking cross-site request forgeries
  • session cookies, altering / Tightening session cookies and effective session management
  • session management / Tightening session cookies and effective session management
  • helmet, adding for security headers configuration / Adding helmet to configure security headers
  • parameter pollution, avoiding / Avoiding parameter pollution
  • transmission, securing / Securing transmission
  • command injection, preventing / Preventing command injection/SQL injection
  • SQL injection, preventing / Preventing command injection/SQL injection
  • TSLint / TSLint/static code analyzers
  • static code analyzers / TSLint/static code analyzers
• security checklist
  • about / Security checklist
  • services necessities / Service necessities
  • service interactions / Service interactions
  • development phase / Development phase
  • deployment / Deployment
  • operations / Operations
• self-curing / Self-curing
• self-registration pattern / Self-registration pattern
• separation of concerns (SoC) / Application directory configurations 
• server-side discovery pattern / Server-side discovery pattern
• serverless architecture / Serverless architecture 
• service contract / Service contracts and statelessness
• service degradation / Service degradation
• service discovery patterns
  • about / Service discovery patterns
  • client-side discovery pattern / Client-side discovery pattern
  • advantages / Client-side discovery pattern
  • disadvantages / Client-side discovery pattern
  • server-side discovery pattern / Server-side discovery pattern
• service level agreements (SLAs) / Monitoring 101
• Service Oriented Architecture (SOA) / Orchestration
• service registry / Introduction to the service registry
• service registry and discovery
  • about / What, why, and how of service registry and discovery, The what of service registry and discovery
  • need for / The why of service registry and discovery
  • approaches / How service registry and discovery?
  • service registration / Service registration
  • service resolution / Service resolution
  • maintaining / Maintaining service registry
  • timely health checks / Timely health checks
  • options / Service registry and discovery options
  • Eureka / Eureka
  • consul / Consul
  • registrator / Registrator
  • selection, determining / How to choose service registry and discovery
  • Consul, benefits / If you select Consul
  • Eureka, benefits / If you select Eureka
• service registry patterns
  • about / Service registry patterns
  • self-registration pattern / Self-registration pattern
  • third-party registration pattern / Third-party registration pattern
• shopping cart microservices
  • overview / Overview of shopping cart microservices 
  • business process overview / Business process overview 
  • functional view / Functional view 
  • deployment view / Deployment view 
  • implementation / Implementation plan for shopping cart microservices 
  • scenarios / What to do when the scope is not clear
  • developing / Developing some microservices for a shopping cart 
  • itinerary / Itinerary 
  • development setting up / Development setup and prerequisite modules
  • prerequisite modules / Development setup and prerequisite modules
  • repository pattern / Repository pattern
  • application properties, configuring / Configuring application properties 
  • custom health module / Custom health module 
  • dependency injection / Dependency injection and inversion of control 
  • inversion of control / Dependency injection and inversion of control 
  • inversify / Inversify 
  • typedi / Typedi 
  • TypeORM / TypeORM 
  • application directory configurations / Application directory configurations 
  • configuration files / Configuration files
  • data, processing / Processing data
  • package.json / Ready to serve (package.json and Docker) 
  • docker / Docker 
  • synopsis / Synopsis
  • API Gateway, need for / Need for gateway in our shopping cart microservices
  • microservices gateway, designing / Designing our gateway for shopping cart microservices
• signing images
  • URL / Securing container builds and standardizing deployments
• Sinon / Sinon
• snyk.io
  • URL / Snyk.io 
• Software as a service (SaaS) / Twelve-factor application of microservices
• sourcemaps / Debugging
• Spotify / Spotify
• Spring boot project
  • URL / Zuul and Eureka
• SSL / Microservice state 
• state store / The problem of shared data
• strangler pattern / Strangler pattern
• streams
  • about / Streams
  • readable stream / Streams
  • writable stream / Streams
  • duplex stream / Streams
  • transform stream / Streams
• subscription / Subscription
• Swagger
  • about / Service contracts and statelessness, Swagger 101
  • Swagger Descriptor / Swagger Editor and Descriptor
  • features / Key points for Swagger  and Descriptor
  • Swagger Editor / Swagger Editor
  • Swagger Codegen / Swagger Codegen
  • Swagger UI / Swagger UI
  • Swagger Inspector / Swagger Inspector
  • using / Possible strategies to use Swagger
  • design first approach / Top-down or design-first Approach
  • bottom-up Approach / Bottom-up approach
  • project, generating / Generating a project from a Swagger definition
• swagger-ui-express
  • URL / Bottom-up approach
• Swagger Codegen
  • URL / Swagger 101, Swagger Codegen
  • about / Swagger Codegen
  • advantages / Swagger Codegen
  • disadvantages / Swagger Codegen

T

• TCP / Microservice state 
• Telepresence
  • URL / Revisiting testing key points
• testing
  • about / Testing
  • users / What and how to test
  • functionality check / What and how to test
  • undesired changes, preventing / What and how to test
  • runtime behavior, protection against / What and how to test
  • testing pyramid / The testing pyramid – what to test?
  • application / Hands-on testing
  • libraries / Our libraries and test tool types
  • test tool types / Our libraries and test tool types
  • Chai / Chai
  • Mocha / Mocha
  • Ava / Ava
  • Sinon / Sinon
  • Istanbul / Istanbul
  • contract tests / Contract tests using Pact.js
  • consumer-driven contract testing / What is consumer-driven contract testing?
  • pact module, utilizing / Introduction to Pact.js
  • features / Revisiting testing key points
• testing pyramid
  • system tests (top level) / The testing pyramid – what to test?, System tests
  • service tests (middle level) / The testing pyramid – what to test?, Service tests
  • contract tests (lower level) / The testing pyramid – what to test?, Contract tests
  • unit tests (bottom level) / The testing pyramid – what to test?, Unit tests
• third-party registration pattern
  • about / Third-party registration pattern
  • Netflix Prana / Third-party registration pattern
  • built-in components / Third-party registration pattern
  • advantages / Third-party registration pattern
  • disadvantages / Third-party registration pattern
• throttling / Proxy routing and throttling
• time to the first byte (TTFB) / Zalando
• tracing requests / Tracing requests
• tsconfig.json
  • about / Understanding tsconfig.json
  • compilerOptions / compilerOptions
  • include / include and exclude
  • exclude / include and exclude
  • extends / extends
  • URL / extends
• TSOA
  • URL / Top-down or design-first Approach
• twelve-factor application
  • about / Twelve-factor application of microservices
  • codebase / Twelve-factor application of microservices
  • dependencies / Twelve-factor application of microservices
  • configs / Twelve-factor application of microservices
  • services, backing / Twelve-factor application of microservices
  • build, release, and run / Twelve-factor application of microservices
  • processes / Twelve-factor application of microservices
  • port binding / Twelve-factor application of microservices
  • concurrency / Twelve-factor application of microservices
  • disposability / Twelve-factor application of microservices
  • dev/prod parity / Twelve-factor application of microservices
  • logs / Twelve-factor application of microservices
  • admin processes / Twelve-factor application of microservices
• Typedi
  • URL / Dependency injection and inversion of control 
  • about / Typedi 
• TypeORM
  • URL / TypeORM 
• types
  • about / Understanding types
  • installing, from DefinitelyTyped / Installing types from DefinitelyTyped
  • writing / Writing your own types
  • dts-gen tool, using / Using the dts-gen tool
  • custom d.ts file, writing / Writing your own *.d.ts file
• TypeScript
  • about / Primer to TypeScript
  • tsconfig.json / Understanding tsconfig.json
  • types / Understanding types
  • debugging / Debugging

U

• URI versioning / Versioning 101 
• UUID
  • URL / Identifiers via correlational IDs 

V

• versioning / Versioning 101 
• Visual Studio Code (VS Code)
  • about / Visual Studio Code (VS Code)
  • URL / Visual Studio Code (VS Code)

W

• Walmart / Walmart
• WebHooks
  • using, in build pipeline / WebHooks in our build pipeline
• winston
  • URL / Writing your first Hello World microservice, src/middleware, Log levels and logging mechanisms 

Z

• Zalando
  • about / Microservices in the current world, Zalando
  • tailor / Zalando
  • skipper / Zalando
  • shaker / Zalando
  • quilt / Zalando
  • innkeeper / Zalando
  • tesselate / Zalando
• Zuul / Zuul and Eureka