Architectural Patterns by Raj, Pethuru -- Read -- Imperial Library of Trantor

The major issues with EDA

Service-oriented architecture (SOA)

Service-inspired integration (SOI)

Event-driven service-oriented architecture

The EDA fundamental principles The ED-SOA composite pattern benefits Microservices architecture (MSA) Event-driven microservices patterns Space-based architecture (SBA) Combining architecture patterns Special-purpose architectures Real-time context-aware prediction architecture Summary Additional reading materials

Client/Server Multi-Tier Architectural Patterns

Domain name service (DNS) server and DNS client

The workings of a DNS

Functional requirements in two-tier client-server patterns

Distribution of functional requirements in a client-server pattern

The remote data access client-server pattern The remote presentation client-server pattern The split logic data client-server architecture pattern

The three-tier pattern / multi-tier pattern client-server

The master-slave pattern

Issues in the master-slave pattern

Peer-to-peer patterns Advantages of two-tier client-server patterns Design considerations - when to use a two-tier client-server pattern? Limitations of two-tier client-server patterns

Three-tier client-server architecture

Design considerations for using three-tier architecture Design considerations for n-tier architecture

An example of n-tier architecture (shopping cart web application)

The distributed client-server architecture Motivation for development of web application patterns

Workings of the MVC pattern

The ASP.Net framework

The model view presenter (MVP) pattern The model-view-viewmodel (MVVM) pattern

Key advantages of the MVVM pattern Design considerations for using the MVVM pattern Prism

Design patterns for web application development

The front controller pattern Spring framework

Summary

Object-Oriented Software Engineering Patterns

Key elements of OOD

Additional elements of OOD

Design principles

Single responsibility principle (SRP) – SOLID Open and close principle – SOLID Liskov substitution principle (LSP) – SOLID Interface segregation principle (ISP) – SOLID Dependency inversion principle (DIP) – SOLID Other common design principles

OO design patterns

Creational design patterns

Factory method (virtual constructor) Abstract factory (kit) Builder Prototype Singleton

Structural design patterns

Adapter class (wrapper) Adapter (object) Bridge (handle/body) Composite Decorator Façade Flyweight Proxy

Behavioral patterns

Chain of responsibility Command (action/transaction) Interpreter Iterator (cursor) Mediator Memento Observer (dependents/publish/subscribe) State (objects for states) Strategy (policy) The template method Visitor

Concurrency patterns

Concurrency design pattern

Producer-consumer Active object Monitor object

Concurrency architectural pattern

Summary References

Enterprise Integration Patterns

Need for integration patterns Integration scenarios in enterprises

Information portal Data replication Shared business function Service-oriented architecture Distributed business process management The business-to-business integration

Main challenges in enterprise integration

File transfer Shared database Remote procedure invocation Messaging

Getting started with messaging patterns Pipe and filter pattern Message router pattern Message translator pattern Message endpoint pattern Point-to-point channel pattern Publish-subscribe channel pattern Datatype channel pattern Message bus patterns Command message patterns Event message patterns Request-reply pattern Content-based router pattern Message filter pattern Resequencer pattern Polling consumer pattern Channel adapter Mobile integration pattern Request-response pattern Defining a push notification pattern API management pattern Summary

Domain-Driven Design (DDD) Principles and Patterns

Principles, characteristics, and practices of DDD

Principles

Focusing on the core domain Collaborate and learn Model the domain Evolve Talk in ubiquitous language

Characteristics Best practices

DDD patterns

Strategic patterns

Ubiquitous language Domain, subdomain, and core domain Bounded contexts

Integrating bounded contexts

Autonomous bounded context The shared-nothing architecture Single responsibility codes Multiple bounded contexts (within a solution) Adoption of SOA principles

Integrating with legacy systems

The bubble context

The anti-corruption layer

Expose as a service

Distributed bounded context integration strategies

Database integration Flat file integration Event-driven architecture and messaging

Tactical patterns Patterns to model the domain

Entities Value objects Domain services Modules Aggregates Factories Repositories

Emerging patterns

Domain events Event sourcing Other patterns

Summary References and further reading materials

Enterprise Architecture Platforms and Tools

Overview of enterprise architecture frameworks Getting started with TOGAF Architecture development method (ADM) Deliverables, artifacts, and building blocks Enterprise continuum Architecture repository

Advantages of using TOGAF Limitations of TOGAF

Zachman framework for enterprise architecture

Advantages Restrictions Guidelines for choosing EAF

Enterprise architecture platforms and tools Enterprise Architect from Sparx Systems Dragon1 ABACUS from avolution software

Architecture of ABACUS

Summary References

Service-Oriented Architecture (SOA)

Web services and SOA Introduction to SOA Life cycle of SOA Primary characteristics of SOA

Service interconnectivity with well-defined interfaces Standard interfaces and Service level agreements Event-driven and messaging Flexible Evolution

Principles of SOA

Standardized service contract Service interoperability Service abstraction Service autonomy Service composability Service discoverability Service loose coupling Service reusability Service statelessness

SOA design patterns

Service messaging Message screening Agnostic services Atomic service transaction Authentication broker Message origin authentication Service façade Multiple service contract Service callback Event-driven messaging Service refactoring Metadata centralization Principles and patterns cross reference

Summary

Event-Driven Architectural Patterns

Service-oriented architecture and event-driven architecture (SOA versus EDA) Key characteristics of event-driven patterns

Components of an EDA pattern

Event flow layers

Event generators Event channel Event processing Downstream event-driven activity

Design considerations for event-driven patterns Implementation variants of EDA patterns

Simple event processing patterns Event stream processing patterns Complex event processing (CEP) patterns

Types of event-driven patterns

Event mediator topology pattern Event broker topology pattern

Hub and spoke pattern

Broadcast pattern Polling pattern

EDA pattern implementation in systems/processes

Event log Event collectors Reply queue

Improving the performance of EDA-based processes/systems IBM WebSphere MQ Emerging trends in EDA

Event-driven microservices Complex event processing Internet of Things (IoT) and EDA

References Summary

Microservices Architecture Patterns

Microservices patterns

Decomposition patterns

Decomposition by use case pattern Decomposition by resources pattern Decomposition by business capability pattern Decomposition by subdomain pattern

Microservices deployment pattern

Multiple service instances per host pattern Single service instance per host pattern Service instance per VM pattern Service instance per container pattern Serverless deployment pattern Service deployment platform pattern

Microservices design patterns

Aggregator microservice design pattern Proxy microservice design pattern Chained microservice design pattern Microservice chassis pattern Externalized configuration pattern

Microservices database patterns

Database per service pattern Shared data design pattern Shared database pattern Command-query responsibility segregation (CQRS) pattern

Microservices integration patterns

Remote procedure invocation (RPI) pattern Messaging design pattern

Asynchronous messaging design pattern

Domain-specific protocol pattern API gateway pattern

Backend for frontend pattern Microservices registration, discovery, and usage patterns

Service discovery pattern Service registry pattern Service registration pattern Event-driven architecture (EDA) patterns Event sourcing pattern Transaction log tailing pattern Publishing events using the database trigger pattern Application publishes events pattern Testing and troubleshooting patterns Access token pattern Service component test pattern Log aggregation pattern Application metrics pattern

Audit logging pattern

Distributed tracing pattern

Exception tracking pattern

Health check API pattern

Microservices composition patterns

Server-side page fragment composition pattern Client-side UI composition pattern Messaging-based microservices composition pattern

Resilient and reliable microservices patterns

Circuit breaker pattern

Shared caching layer pattern High availability microservices pattern Concurrent requests for data pattern Event store pattern

Event streams and the unified event log pattern

Asynchronous command calls pattern

Summary

Patterns for Containerized and Reliable Applications

Introduction

The key drivers for containerization Design patterns for Docker containers Container building patterns

Docker image building patterns Multi-stage image building pattern The pattern for file sharing between containers

Using bind-mount volumes

Pipes and filters pattern Containerized applications - Autopilot pattern Containers - persistent storage patterns

The context for persistent storages The persistent storage options Volumes Bind mounts The tmpfs mounts

Docker compose configuration pattern Docker container anti-patterns

Installing an OS inside a Docker container Go for optimized Docker images Storing container images only inside a container registry Hosting only one service inside a container Latest doesn't mean best Docker containers with SSH IP addresses of a container Root user Dependency between containers

Patterns for highly reliable applications Resiliency implementation strategies

The testing approaches for resiliency The resilient deployment approaches The deployment patterns Monitoring and diagnostics Resiliency realization patterns

Circuit breaker pattern Bulkhead pattern Compensating transaction pattern Health endpoint monitoring pattern Leader election pattern Queue-based load leveling pattern Retry pattern

Summary

Software-Defined Clouds - the Architecture and Design Patterns

Reflecting the cloud journey Traditional application architecture versus cloud application architecture

The traditional application architecture The cloud architecture The cloud application architecture

Cloud integration patterns

Tier/Layer-based decomposition Process-based decomposition Pipes-and-filters-based decomposition Service messaging pattern Messaging metadata pattern Service agent pattern Intermediate routing pattern State messaging pattern Service callback pattern Service instance routing Asynchronous queuing pattern Reliable messaging pattern

Cloud design patterns

Cache-aside pattern Circuit breaker pattern Compensating transaction pattern Competing consumers pattern Compute resource consolidation pattern Command and query responsibility segregation (CQRS) pattern Event sourcing pattern External configuration store pattern Federated identity pattern Gatekeeper pattern Application health monitoring pattern Leader election pattern Materialized views pattern Pipes and filters pattern Priority queue pattern Queue-based load leveling pattern Retry pattern Runtime reconfiguration pattern Scheduler agent supervisor pattern Sharding pattern Throttling pattern Workload distribution pattern Cloud workload scheduler pattern

Cloud reliability and resilience patterns

Resource pooling pattern Resource reservation pattern Hypervisor clustering pattern Redundant storage pattern Dynamic failure detection and recovery pattern Redundant physical connection for virtual servers pattern

Cloud security patterns

Cryptographic key management system pattern Virtual private network (VPN) pattern Cloud authentication gateway pattern In-transit cloud data encryption pattern Cloud storage device masking pattern Cloud storage data at rest encryption pattern Endpoint threat detection and response pattern Threat intelligence processing pattern Cloud denial of service (DoS) protection pattern

Summary Bibliography

Big Data Architecture and Design Patterns

The four V's of big data Big data analysis and technology concepts

Data analysis life cycle

Big data analysis and data science

Data analysis Data science

Big data platform

Big data engineering Big data governance

Big data architecture landscape and layers Big data architecture patterns

MapReduce pattern Lambda architecture pattern Data lake architecture pattern

Big data design patterns

Data sources and ingestion layer

Multisource extractor Multidestination pattern Protocol converter Just-In-Time (JIT) transformation pattern Real-time streaming pattern

Big data workload patterns Data storage layer

ACID versus BASE versus CAP Façade pattern NoSQL pattern Polyglot pattern

Data access layer

Connector pattern Lightweight stateless pattern Service locator pattern Near real-time pattern Stage transform pattern Rapid data analysis pattern Data discovery and analysis layer Data queuing pattern Index-based insight pattern Machine learning pattern Converge(r) pattern Data visualization layer First glimpse pattern Portal pattern Mashup view pattern Compression pattern Exploder pattern

Summary References

← Prev
Back
Next →

← Prev
Back
Next →