Table of Contents for
Scaling Your Node.js Apps: Progress Your Personal Projects to Production-Ready

Version ebook / Retour

Cover image for bash Cookbook, 2nd Edition Scaling Your Node.js Apps: Progress Your Personal Projects to Production-Ready by Fernando Doglio Published by Apress, 2018
  1. Navigation
  2. Cover
  3. Front Matter
  4. 1. The Need to Scale
  5. 2. Architectural Patterns
  6. 3. Ways to Scale
  7. 4. Challenges when Scaling
  8. 5. When to Scale?
  9. 6. Testing Your Application
  10. 7. Success Cases
  11. Back Matter

Index

A

Adaro
Alerting
maintenance window
periodicity
strategy
symptoms
triggering condition
Architecture
broker pattern
client-server
event-driven
lambda
layers
data flows
storage engines
master-slave
microservices
MVC
patterns
Atomic
AWS Console
AWS ElastiCache

B

Bottom-up integration testing
Broker pattern
Byzantine fault-tolerance
architecture
CRC algorithm
monitoring modules
status checkers

C

Client-server architecture
business-related computation
communication protocol/technology
Clustering
color-coded process
forking process
generic API
install PM2
IPC
PM2 logs command
PM2 start command
process ID, printing
single-threaded environment
Code Division Multiple Access (CDMA)
Consistent
Custom alerting strategy

D

Data-processing service
Docker approach
Documented control flow

E

Elastic, Logstash, and Kibana (ELK) cluster
Event-driven architectures
components
limitations
Exception handling

F

Falcon9 rocket
Fault tolerance
Byzantine
checkpointing
DMTCP
mementos
redundancy ( see Redundancy)
Filebeat
FlexRay
Forward Error Correction (FEC)
encoding algorithms
Reed-Solomon
Viterbi algorithm
Fragmented session problem
external memory access
sticky session
Apache configuration
load balancers

G

Global System for Mobiles (GSM)

H

Hadoop Distributed File System (HDFS)
High availability
data-replication process
HDFS setup
master-slave model
replica sets
SLA
three-node service

I, J

Integration testing
big bang approach
gradual approach
Internal factors
fault tolerance
high availability
Inter Process Communication (IPC)

K

Kappa

L

Lambda architectures
batch processing
nutshell processing
real time querying
stream processing
use case
LinkedIn
architecture
mobile API
monitoring
pacemaker implementation
profiling
RoR plus Mongrel
three-tier model
transformation
Load balancer
Logging
centralized architecture
elastic scaling architecture
index data
module
single file
history
logrotate, configuration and execution
size
stdout and stderr
filebeat, execution
logstash, configuration
winston-based custom logger
logrotate command
Lusca

M

Makara
Master-slave architecture
controlled communication
JobTracker
use cases
Memcached
Metrics
alert creation
autoscaling actions
EC2 instances
process
Microservices
architectures
authentication strategy
behavior
issues
monolithic approach
UserMgnmt service
horizontal scaling
vs. monolithic application
Mobile API architecture
Model-View-Controller (MVC)
architecture, nodes/objects
data binding
definition
domain knowledge
Model, View, Presenter (MVP) pattern
Model, View, ViewModel (MVVM) pattern
Monitoring
alerting
app-specific indicators
AWS metrics
infrastructure
LinkedIn
metrics ( see Metrics)
networking devices
types
Monolithic initial Uber architecture
Multi-server scenarios
fragmented session problem
user session, partial fragment

N, O

Netflix
API.NEXT, architecture
Docker approach
high-level architecture
I/O operations
monolithic applications
Node.js
non-blocking I/O
REST API
Node.js applications
ad-hoc metrics
API endpoint
architecture
attributes, JSON
average delay
AWS CloudWatch
custom metrics
metrics module
metrics parameter
modified API’s code
refactoring process
scaling rules
SDK module
wrapper module

P, Q

PayPal
enterprise solutions
Express.js
front-end/back-end type
Kraken.js
Node.js and java, comparison
open source module
performance apps
web applications
Period column
Profiling, LinkedIn
Proof of Concept (PoC)
putMetricData method

R

Redis
Redis cluster
Redundancy
fault tolerance
FEC
TMR
Replica sets
Resource utilization technique
crashed service
service degradation

S

Scaling techniques
advantages
automatic elastic behavior
AWS
cost management
GCP
multi-zone deployment
multi-zone replica schema
horizontal
elasticity
service oriented architectures
tier seperation
vertical
Service degradation
Service level agreement (SLA)
Sharing memory
benefits
migration
multi-server scenarios
Single points of failure (SPOFs)
error budget
Redis
SLA
SLI
SLO
SinonJS
Statistic column
System-level indicators (SLIs)
System level objectives (SLOs)

T

Testing
AssertionError exception
assertions
asynchronous code
BookSales controller
callback pattern
error
Mocha
MVC pattern
output, execution
save method
unit tests
writeHAL method
deepStrictEqual
Mocha
module
parameter
strictEqual method
structure test cases
theoretical test case
thrown exception
unit
Tools
assertions
dummies
fixtures
frameworks
generic save function
mocks
spies
stubs
test cases
test suites
Top-down testing
Traffic increase
direct effects
non-blocking I/O approach
overloading servers’ capacity
indirect effects
microservices-based architecture
overloading internal processes
resource-bound log server
scaling capabilities
Triple modular redundancy (TMR)

U, V

Uber
consistent hashing mechanism
gossip-based cluster
monolithic-based architecture
Node.js project
Unit testing

W, X, Y, Z

Web-server log files
writeHAL method