Building Microservices with Node.js: Explore microservices applications and migrate from a monolith architecture to microservice

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Part 1: Understanding Microservices and Node.js
Chapter 1: Introducing Microservices
	Introduction to the microservices and decentralized architecture concepts
		Microservices architecture
		Decentralized architecture
	Service boundaries and loose coupling
		Service boundaries
		Loose coupling
	Independent development and deployment and polyglot architecture
		Independent development and deployment
		Polyglot architecture
	Scalability and resilience and independent data management
		Scalability and resilience
		Independent data management
	APIs and communication and CI
		APIs and communication
		CI
	Summary
	Quiz time
Chapter 2: Exploring the Core Principles of Microservices
	Overview of the core principles of microservices
	Understanding the fundamentals and identifying business capabilities
	Defining service contracts and decentralized decision making
		Service contracts in microservices
		Decentralized decision making in microservices
	Prioritizing autonomy and ownership and designing for resilience
		Prioritizing autonomy and ownership
		Designing for resilience
	Implementing communication strategies and ensuring scalability
		Implementing communication strategies
		Ensuring scalability
	Implementing observability and continuously learning and improving
		Implementing observability
		Continuous learning and improving
	Summary
	Quiz time
Chapter 3: Understanding Node.js Fundamentals: Building Blocks and Key Concepts
	Asynchronous and non-blocking communication and event-driven architecture
		Asynchronous and non-blocking communication
		Event-driven architecture
	The JavaScript ecosystem and server-side development
		The JavaScript ecosystem
		Server-side development with Node.js
	Command-line applications and scalability and performance
		Command-line applications
		Scalability and performance
	Cross-platform compatibility and community and support
		Cross-platform compatibility
		Community and support
	Microservices and serverless architectures and their integration through APIs
		What is microservices architecture?
		What is a serverless architecture?
		Integration through APIs
		Integration in microservices and serverless architectures
	Summary
	Quiz time
Chapter 4: Leveraging the JavaScript and Node.js Ecosystem for Microservices Development
	Vast package management and developer productivity
		Vast package management
		Developer productivity
	Community support and collaboration, and rapid innovation and updates
		Community support and collaboration
		Rapid innovation and updates
	Versatility and full stack development, and cross-platform compatibility
		Versatility and full stack development
		Cross-platform compatibility
	Integration and interoperability and support for modern web standards
		Integration and interoperability
		Support for modern web standards
	Enterprise adoption and industry maturity and ecosystem growth and innovation
		Enterprise adoption and industry maturity
		What is ecosystem growth and innovation?
	Summary
	Quiz time
Part 2: Building and Integrating Microservices with Node.js
Chapter 5: Knowing the Infrastructure of Microservices in Node.js
	Service discovery and API gateways
		Service discovery
		API gateways
	Load balancing and service orchestration
		Load balancing
		Service orchestration
	Containerization and orchestration and centralized logging and monitoring
		Containerization and orchestration
		Centralized logging and monitoring
	Distributed tracing and event-driven communication
		Distributed tracing
		Event-driven communication
	Database integration and continuous integration and deployment
		Database integration
		CI/CD
	Summary
	Quiz time
Chapter 6: Designing Microservices Architecture in Node.js
	Things to consider before creating your microservice
	Communication protocol and design APIs
		Communication protocol
		API design
	Decentralized data management and data consistency
	Authentication and authorization and error handling and fault tolerance
		Authentication and authorization
		Error handling and fault tolerance
	Monitoring and tracing requests and containerization technologies
		Monitoring and tracing requests
		Containerization technologies
	Summary
	Quiz time
Chapter 7: Integrating Microservices in Node.js Applications
	Synchronous HTTP/REST communication and asynchronous messaging
		Synchronous HTTP/REST communication
		Asynchronous messaging
	EDA and API gateways
		EDA
		API gateways
	Service mesh and caching
		Service mesh
		Caching
	Distributed tracing and database integration
		Distributed tracing
		Database integration
	Monitoring and observability and error handling and resilience
		Monitoring and observability
		Error handling and resilience
	Summary
	Quiz time
Chapter 8: Debugging Microservices in Node.js
	Logging and debugging tools
		Logging in microservices
		Debugging tools
	Debugging in containers and error handling
		Debugging in containers
		Error handling
	Unit testing and remote debugging
		Unit testing
		Remote debugging
	Instrumentation and tracing and environment and configuration
		Instrumentation and tracing
		Environment and configuration
	Reproducing and isolating issues and debugging tools and libraries
		Reproduce and isolate issues
		Debugging tools and libraries
	Summary
	Quiz time
Part 3: Data Management in Microservices Using Node.js
Chapter 9: Database Manipulation in Microservices with Node.js
	Choosing the right database and database connections
		Choosing the right database
		Database connections in microservices
	Data models and schemas and CRUD operations
		Data models and schemas
		CRUD operations
	Transactions and data validation
		Transactions in microservices
		Data validation and sanitization
	Error handling and optimizations
		Error handling in microservices
		Optimizations in microservices
	Testing
	Summary
	Quiz time
Chapter 10: API Communication and Data Contracts in Microservices
	Defining API contracts and RESTful API design
		Defining API contracts
		RESTful API design
	REST API libraries and API versioning
		REST API libraries
		API versioning
	Authentication and authorization and data validation
		Authentication and authorization
		Data validation
	Error handling and API documentation
		Error handling
		API documentation
	API testing and API gateway
		API testing
		API gateway
	Summary
	Quiz time
Chapter 11: Caching and Asynchronous Messaging in Microservices
	Client-side caching and edge caching
		Client-side caching
		Edge caching
	Microservice-level caching and database query caching
		Microservice-level caching
		Database query caching
	Message queues and publish-subscribe
		Message queues
		Publish-subscribe (Pub/Sub)
	Event-driven architecture
	Summary
	Quiz time
Chapter 12: Ensuring Data Security with the Saga Pattern, Encryption, and Security Measures
	Compensating actions and Saga orchestration
		Compensating actions
		Saga orchestration
	Event-driven communication and Sagas with state
		Event-driven communication
		Sagas with state
	Transport layer security (TLS) and data encryption at rest
		TLS
		Data encryption at rest
	Encryption algorithms and key management
		Encryption algorithms
		Key management
	Authentication, authorization, input validation, secure coding practices, and API rate limiting
		Authentication
		Authorization
		Input validation
		Secure coding practices
		API rate limiting
	Summary
	Quiz time
Part 4: Monitoring and Logging in Microservices with Node.js
Chapter 13: Monitoring Microservices in Node.js
	Structured logging and log levels
	Contextual information and centralized log management
		Contextual information in logs
		Centralized log management
	Application-level metrics, distributed tracing, and health checks
		Application-level metrics
		Distributed tracing
		Health checks
	Threshold-based alerts and anomaly detection
		Threshold-based alerts
		Anomaly detection
	Request tracing, request context propagation, and logging frameworks
		Request tracing
		Request context propagation
		Logging frameworks
	Summary
	Quiz time
Chapter 14: Logging in Microservices with Node.js
	Choosing a logging framework and defining log levels
		Choosing a logging library
		Log levels
	Structured logging, log transport, and storage
		Structured logging
		Log transport and storage
	Log filtering, sampling, error handling, and exception logging
	Context propagation, monitoring, and analyzing logs
		Context propagation
		Monitoring
		Log analysis
	Summary
	Quiz time
Chapter 15: Interpreting Monitoring Data in Microservices
	Metrics analysis
	Log analysis
	Alerting and thresholds
	Visualization and dashboards
	Correlation and context
	Summary
	Quiz time
Chapter 16: Analyzing Log Data in Microservices with Node.js
	Log levels and severities
	Request tracing, contextual information, and event sequencing and order
		Request tracing
		Contextual information
		Event sequencing and order
		Advantages and considerations of request tracing, contextual information, and event sequencing and order
	Log format, structured logging, and log filtering and search
		Log format
		Structured logging
		Log filtering and search
		Advantages and considerations of log format, structured logging, and log filtering and search
	Log aggregation, centralized log management, visualization, and log analysis tools
		Log aggregation
		Centralized log management
		Visualization
		Log analysis tools
		Advantages and considerations of log aggregation, centralized log management, visualization, and log analysis tools
	Correlation of log data with metrics and monitoring data
	Summary
	Quiz time
	Final words
Index
About Packt
Other Books You May Enjoy