BestHub
Sign in
Tagged articles

Fault Tolerance

328 articles · Page 2 of 4
Sanyou's Java Diary
Sanyou's Java Diary
Nov 20, 2023 · Operations

Mastering High Availability: 10 Essential Design Techniques for Scalable Systems

This article outlines ten practical techniques—including system splitting, decoupling, asynchronous processing, retry strategies, compensation, backup, multi‑active deployment, isolation, rate limiting, circuit breaking, and degradation—to help engineers design highly available, resilient architectures for large‑scale internet applications.

Fault ToleranceSystem Designmicroservices
0 likes · 14 min read
Mastering High Availability: 10 Essential Design Techniques for Scalable Systems
Architects' Tech Alliance
Architects' Tech Alliance
Nov 5, 2023 · Fundamentals

Understanding RAID Fault Tolerance, Consistency Checks, Hot Spare, Rebuild, and Data Protection Features

This article explains RAID fault‑tolerance mechanisms, consistency verification, hot‑spare and emergency backup, rebuild processes, virtual‑disk read/write policies, power‑loss protection, disk striping, mirroring, foreign configurations, power‑saving and pass‑through features, providing a comprehensive overview of modern storage system capabilities.

Fault ToleranceRAIDdisk striping
0 likes · 16 min read
Understanding RAID Fault Tolerance, Consistency Checks, Hot Spare, Rebuild, and Data Protection Features
Alibaba Cloud Native
Alibaba Cloud Native
Oct 13, 2023 · Cloud Native

Why Microservice Governance Matters and How OpenSergo Tackles Its Challenges

The article explains the stability challenges of modern microservice architectures, outlines the three governance domains (development/testing, change, runtime), and introduces OpenSergo’s open, cloud‑native specifications, control‑plane, and data‑plane solutions for traffic routing, gray‑release, and fault‑tolerance.

Fault ToleranceOpenSergogray release
0 likes · 18 min read
Why Microservice Governance Matters and How OpenSergo Tackles Its Challenges
dbaplus Community
dbaplus Community
Oct 7, 2023 · Operations

How to Build a Truly High‑Availability System: 6 Essential Design Layers

This article breaks down high‑availability system design into six critical layers—architecture, development standards, application services, storage, product safeguards, and operations—offering concrete practices such as capacity planning, fault‑tolerant patterns, monitoring, and incident‑response strategies to achieve four‑nine (99.99%) uptime.

Fault ToleranceOperationsSystem Design
0 likes · 26 min read
How to Build a Truly High‑Availability System: 6 Essential Design Layers
MaGe Linux Operations
MaGe Linux Operations
Aug 29, 2023 · Operations

How to Effectively Monitor and Recover a Kafka Cluster

This guide explains essential Kafka monitoring techniques, third‑party tools, custom scripts, key metrics, and practical strategies for high availability, fault detection, rapid recovery, and ongoing testing to keep Kafka clusters stable and performant.

Fault ToleranceOperationsdistributed-systems
0 likes · 7 min read
How to Effectively Monitor and Recover a Kafka Cluster
JD Retail Technology
JD Retail Technology
Aug 14, 2023 · Backend Development

Implementing a Lightweight Distributed Scheduling Solution to Replace TBSchedule

To improve stability and reduce costs during high‑traffic events, we replaced the Zookeeper‑dependent TBSchedule framework with a lightweight, Redis‑based distributed scheduler that decentralizes task execution, uses thread pools instead of timers, and supports dynamic scaling and seamless degradation for reliable order processing.

Fault ToleranceRedisdistributed scheduling
0 likes · 4 min read
Implementing a Lightweight Distributed Scheduling Solution to Replace TBSchedule
JD Cloud Developers
JD Cloud Developers
Aug 9, 2023 · Backend Development

Mastering Hystrix: Implementing Circuit Breakers in Spring Cloud Microservices

This article explains why circuit breakers are essential in microservice architectures, introduces Netflix's Hystrix library, details its design principles, shows step‑by‑step demos for Ribbon and Feign integration, and covers dashboards, Turbine, isolation strategies, request merging, caching, and related Spring Boot SPI mechanisms.

Fault ToleranceHystrixSpring Cloud
0 likes · 29 min read
Mastering Hystrix: Implementing Circuit Breakers in Spring Cloud Microservices
Architect
Architect
Aug 4, 2023 · Fundamentals

What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles

The article systematically defines software architecture, distinguishes systems, subsystems, modules, and components, compares frameworks with architectures, explores TOGAF and RUP classifications, traces the evolution from monoliths to micro‑services, and presents concrete design principles and common pitfalls for building scalable, maintainable systems.

Design PrinciplesFault ToleranceSystem Design
0 likes · 25 min read
What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles
Architects Research Society
Architects Research Society
Jul 13, 2023 · Operations

Five Patterns to Make Your Microservice Fault‑Tolerant

This article explains essential fault‑tolerance patterns for microservices—including timeouts, retries, circuit breakers, distributed deadlines, and rate limiting—detailing their basic forms, drawbacks, and practical implementation strategies to improve reliability and prevent cascading failures.

Fault Tolerancecircuit breakermicroservices
0 likes · 12 min read
Five Patterns to Make Your Microservice Fault‑Tolerant
58UXD
58UXD
Apr 27, 2023 · Product Management

Designing Fault‑Tolerant Products: Lessons from AI and Human Error

The article explores how AI's rise highlights human error, argues that fault‑tolerant design is essential for user‑centric products, outlines practical guidelines such as anticipatory guidance and constructive error recovery, and validates the approach with a VR‑tool experiment.

AI integrationFault ToleranceUX Research
0 likes · 9 min read
Designing Fault‑Tolerant Products: Lessons from AI and Human Error
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 26, 2023 · Backend Development

Design and Implementation of an Automated Payment Channel Management System

This article describes the design, technology choices, architecture, and implementation details of an automated payment channel management system that uses Redis‑based time‑series storage, custom circuit‑breaker logic, and monitoring to achieve fast fault detection, accurate alerting, and future automated failover.

Fault ToleranceMonitoringRedis
0 likes · 10 min read
Design and Implementation of an Automated Payment Channel Management System
Programmer DD
Programmer DD
Mar 16, 2023 · Operations

Why High Availability Matters: Building Fault‑Tolerant Cloud Systems

The article explains how system failures like bugs, security breaches, and cloud outages can cripple businesses, and outlines the concepts of fault tolerance and disaster recovery as essential components of high‑availability architectures to ensure continuous service and protect revenue.

Disaster RecoveryFault ToleranceHigh Availability
0 likes · 7 min read
Why High Availability Matters: Building Fault‑Tolerant Cloud Systems
Tencent Cloud Developer
Tencent Cloud Developer
Mar 13, 2023 · Cloud Computing

Design Principles for High‑Availability System Architecture

The article outlines a comprehensive high‑availability architecture framework across six layers—development standards, application services, storage, product fallback, operations deployment, and emergency response—detailing design principles such as stateless services, elastic scaling, redundant storage, robust monitoring, gray releases, and chaos engineering to ensure resilient, continuously available systems.

Fault ToleranceHigh AvailabilityMonitoring
0 likes · 25 min read
Design Principles for High‑Availability System Architecture
DaTaobao Tech
DaTaobao Tech
Mar 1, 2023 · Game Development

Design and Implementation of Taobao Dou Dizhu Endgame Mode

The article describes the design and implementation of Taobao Dou Dizhu’s new single‑player endgame mode, which generates daily unique puzzles with a guaranteed single solution, manages activity triggers, Redis caching, AI interaction, fault tolerance, consistency, and reward idempotency, boosting user retention during promotions.

AIBackend ArchitectureFault Tolerance
0 likes · 15 min read
Design and Implementation of Taobao Dou Dizhu Endgame Mode
Java High-Performance Architecture
Java High-Performance Architecture
Jan 24, 2023 · Backend Development

How to Build Highly Available Backend APIs: 10 Essential Design Principles

This article explains why high availability is crucial for backend services and outlines ten practical design principles—including dependency control, avoiding single points, load balancing, isolation, rate limiting, circuit breaking, async processing, degradation, gray release, and chaos engineering—to help developers create resilient APIs.

API designFault ToleranceHigh Availability
0 likes · 10 min read
How to Build Highly Available Backend APIs: 10 Essential Design Principles
Architecture Digest
Architecture Digest
Jan 19, 2023 · Backend Development

Designing High‑Availability Backend Interfaces

The article explains why high availability is essential for backend services, defines its core concepts, and outlines key design principles such as minimizing dependencies, avoiding single points of failure, load balancing, resource isolation, rate limiting, circuit breaking, asynchronous processing, degradation strategies, gray releases, and chaos engineering to build resilient APIs.

Fault ToleranceService designreliability
0 likes · 9 min read
Designing High‑Availability Backend Interfaces
ITPUB
ITPUB
Jan 12, 2023 · Operations

How to Build a Truly High‑Availability System: 6 Essential Design Layers

This article breaks down the essential design and operational considerations for achieving high availability across six layers—development standards, application services, storage, product strategy, operations deployment, and incident response—providing concrete practices, metrics, and safeguards to reach four‑nine (99.99%) uptime.

Disaster RecoveryFault ToleranceOperations
0 likes · 25 min read
How to Build a Truly High‑Availability System: 6 Essential Design Layers
Tencent Cloud Developer
Tencent Cloud Developer
Jan 5, 2023 · Cloud Native

QQ Music High-Availability Architecture Overview

QQ Music achieves high availability by layering redundant multi‑datacenter architecture, proactive chaos‑engineering toolchains, and comprehensive observability—including metrics, logging, tracing and profiling—while employing service grading, adaptive retry windows and EMA‑based dynamic timeouts to gracefully handle faults across its massive micro‑service ecosystem.

Chaos EngineeringFault ToleranceHigh Availability
0 likes · 24 min read
QQ Music High-Availability Architecture Overview
Architecture Digest
Architecture Digest
Dec 21, 2022 · Operations

Designing High‑Availability Systems: Principles and Practices Across Six Layers

This article systematically explores high‑availability system design from development standards, capacity planning, application services, storage, product strategies, operations deployment, to incident response, presenting key concepts, architectural patterns, and practical guidelines for building resilient services.

Fault ToleranceHigh AvailabilityMonitoring
0 likes · 27 min read
Designing High‑Availability Systems: Principles and Practices Across Six Layers
Java High-Performance Architecture
Java High-Performance Architecture
Dec 6, 2022 · Cloud Native

How to Build Resilient Microservices: Patterns for Fault Tolerance and High Availability

Learn essential techniques for designing fault‑tolerant microservices, including graceful degradation, change management, health checks, self‑healing, failover caching, retry strategies, rate limiting, circuit breakers, and testing failures, to ensure high availability and reliability in distributed cloud‑native systems.

Fault ToleranceOperationscloud-native
0 likes · 15 min read
How to Build Resilient Microservices: Patterns for Fault Tolerance and High Availability
High Availability Architecture
High Availability Architecture
Dec 2, 2022 · Operations

High‑Availability Design and Implementation of the BIGO Backbone Network

This article explains how BIGO’s backbone network achieves high availability through a three‑layer design—control‑plane HA using ETCD‑based Raft leader election, data‑plane HA with MPLS SR‑Policy and intermediate Route‑Reflection layers, and business‑level HA that combines traffic, optimization, and fault scheduling to ensure seamless service continuity.

Fault ToleranceHigh AvailabilityMPLS
0 likes · 19 min read
High‑Availability Design and Implementation of the BIGO Backbone Network
Architecture & Thinking
Architecture & Thinking
Dec 2, 2022 · Cloud Native

Mastering Hystrix: A Deep Dive into Circuit Breaker, Fallback, and Isolation Strategies

This article provides a comprehensive guide to Hystrix, covering its purpose in microservice fault tolerance, the problems it addresses, core concepts like command pattern and isolation, detailed workflow steps, configuration options, and practical Java code examples for circuit breaking, fallback, and thread‑pool or semaphore isolation.

Fault ToleranceHystrixThread Pool Isolation
0 likes · 21 min read
Mastering Hystrix: A Deep Dive into Circuit Breaker, Fallback, and Isolation Strategies
Code Ape Tech Column
Code Ape Tech Column
Nov 8, 2022 · Operations

Designing Resilient Microservices: Fault Tolerance, Health Checks, and Reliability Patterns

This article explains how to build highly available microservice systems by addressing the risks of distributed architectures, employing graceful degradation, change management, health checks, self‑healing, failover caching, retry and rate‑limiting strategies, bulkhead and circuit‑breaker patterns, and continuous failure testing.

Deployment StrategiesFault Tolerancehealth checks
0 likes · 18 min read
Designing Resilient Microservices: Fault Tolerance, Health Checks, and Reliability Patterns
Open Source Linux
Open Source Linux
Oct 26, 2022 · Fundamentals

Choosing the Right RAID Level: Pros, Cons, and Best Use Cases

This guide explains what RAID is, its role in server storage, compares common RAID levels (0, 1, 5, 6, 10) in terms of fault tolerance, performance, and capacity, and offers recommendations for selecting the most suitable RAID configuration based on data safety, speed, and cost considerations.

Fault ToleranceRAIDdata protection
0 likes · 8 min read
Choosing the Right RAID Level: Pros, Cons, and Best Use Cases
DeWu Technology
DeWu Technology
Oct 17, 2022 · Operations

High Availability: Principles and Practices for System Stability

High availability—measured in nines of uptime—requires partitioning systems, decoupling components, choosing robust technologies, deploying redundant instances with automatic failover, capacity planning, rapid scaling, traffic shaping, resource isolation, global protection, observability, and disciplined change management to achieve stable, resilient services.

Fault ToleranceHigh Availabilitycapacity planning
0 likes · 10 min read
High Availability: Principles and Practices for System Stability
Architecture Digest
Architecture Digest
Oct 10, 2022 · Operations

Designing Fault‑Tolerant Microservices: Patterns and Practices

This article explains how to build highly available microservice systems by applying fault‑tolerance patterns such as graceful degradation, health checks, self‑healing, failover caches, retries, rate limiting, bulkhead isolation, circuit breakers, and systematic failure testing, while also covering change‑management and deployment strategies.

Fault Tolerancecircuit breakergraceful degradation
0 likes · 14 min read
Designing Fault‑Tolerant Microservices: Patterns and Practices
ITPUB
ITPUB
Oct 4, 2022 · Operations

What Makes a System Truly High‑Availability? Lessons from B‑Station’s Outage

The article examines B‑Station’s July 2021 outage, explains the concept and quantitative metrics of high availability, and outlines practical techniques such as rate limiting, isolation, failover, timeout control, circuit breaking, degradation, and multi‑region deployment to achieve resilient systems.

Fault ToleranceMTBFMTTR
0 likes · 15 min read
What Makes a System Truly High‑Availability? Lessons from B‑Station’s Outage
Architecture Digest
Architecture Digest
Sep 25, 2022 · Cloud Native

Designing Microservices Architecture for Failure: Patterns and Practices

This article explains how to build highly available microservices by addressing the inherent risks of distributed systems and presenting fault‑tolerance patterns such as graceful degradation, change management, health checks, self‑healing, failover caching, retries, rate limiting, bulkheads, circuit breakers, and systematic failure testing.

BulkheadCloud NativeFault Tolerance
0 likes · 14 min read
Designing Microservices Architecture for Failure: Patterns and Practices
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 20, 2022 · Cloud Native

How to Build Fault‑Tolerant Microservices: Essential Patterns and Practices

This article explains why microservice architectures increase failure risk and presents proven techniques—such as graceful degradation, change management, health checks, self‑healing, failover caches, retries, rate limiting, bulkheads, and circuit breakers—to design resilient, fault‑tolerant services.

Fault Tolerancemicroservicesresilience patterns
0 likes · 15 min read
How to Build Fault‑Tolerant Microservices: Essential Patterns and Practices
Big Data Technology Architecture
Big Data Technology Architecture
Sep 18, 2022 · Backend Development

Design and Source Code Analysis of Apache DolphinScheduler

This article provides an in‑depth technical overview of Apache DolphinScheduler, covering its distributed design strategies, fault‑tolerance mechanisms, remote log access, source‑code module breakdown, API interfaces, Quartz integration, master‑worker execution flows, RPC communication, load‑balancing algorithms, logging services, and community contribution guidelines.

DolphinSchedulerFault ToleranceLoad Balancing
0 likes · 47 min read
Design and Source Code Analysis of Apache DolphinScheduler
Top Architect
Top Architect
Sep 4, 2022 · Backend Development

Designing Fault‑Tolerant Microservices Architecture

The article explains how to build highly available microservice systems by isolating failures, applying graceful degradation, change‑management, health checks, self‑healing, fallback caches, circuit breakers, retry policies, rate limiting and testing strategies, while acknowledging the cost and operational complexity involved.

Fault Tolerancechange managementcircuit breaker
0 likes · 16 min read
Designing Fault‑Tolerant Microservices Architecture
dbaplus Community
dbaplus Community
Aug 25, 2022 · Backend Development

Mastering Distributed Locks: From Basics to Redlock and Beyond

This comprehensive guide explains why distributed locks are needed, outlines their three essential properties, compares common implementations such as Redis, MySQL, ZooKeeper, and Redlock, discusses pitfalls like non‑atomic operations and lock expiration, and presents correct patterns using atomic commands, Lua scripts, watchdogs, and fencing tokens.

Fault ToleranceLuaMySQL
0 likes · 37 min read
Mastering Distributed Locks: From Basics to Redlock and Beyond
DaTaobao Tech
DaTaobao Tech
Aug 15, 2022 · Cloud Native

Reflections on CAP Theory, ACID, BASE, and Cloud‑Native Fault Tolerance

Reflecting on reading, the author reviews CAP theory’s consistency‑availability‑partition trade‑offs, extends ACID and BASE concepts, proposes modernizing CAP objects to consistency, fault and disaster tolerance, and examines how cloud‑native architectures, micro‑services, and SLA‑driven designs reshape fault tolerance and future self‑healing systems.

ACIDBASECAP theorem
0 likes · 21 min read
Reflections on CAP Theory, ACID, BASE, and Cloud‑Native Fault Tolerance
IT Architects Alliance
IT Architects Alliance
Aug 11, 2022 · Fundamentals

Key Distributed System Concepts: Bloom Filter, Consistent Hashing, Quorum, Leader/Follower, and More

This article introduces essential distributed‑system mechanisms—including Bloom filters, consistent hashing, quorum, leader/follower roles, heartbeats, fencing, write‑ahead logs, segment logs, high‑water marks, leases, gossip protocols, failure detection, CAP/PACELC theorems, hinted handoff, read‑repair, and Merkle trees—to help engineers design scalable and fault‑tolerant services.

CAP theoremData StructuresFault Tolerance
0 likes · 12 min read
Key Distributed System Concepts: Bloom Filter, Consistent Hashing, Quorum, Leader/Follower, and More
NetEase LeiHuo UX Big Data Technology
NetEase LeiHuo UX Big Data Technology
Aug 3, 2022 · Big Data

Understanding Spark Streaming Checkpoint Mechanism for Real‑Time Feature Computation

The article explains how Spark Streaming's checkpoint mechanism works, detailing the four-step process—from setting the checkpoint directory to writing RDD data and finalizing the checkpoint—highlighting its role in ensuring fault‑tolerant, fast recovery for real‑time recommendation feature pipelines.

Big DataCheckpointFault Tolerance
0 likes · 7 min read
Understanding Spark Streaming Checkpoint Mechanism for Real‑Time Feature Computation
IT Architects Alliance
IT Architects Alliance
Jun 20, 2022 · Cloud Native

Building Resilient Microservices: Fault Tolerance, Graceful Degradation, and Reliability Patterns

This article explains how microservice architectures can achieve high availability by using fault‑tolerant designs such as graceful degradation, health checks, failover caching, circuit breakers, bulkheads, rate limiting, and systematic change‑management practices to mitigate network, hardware, and application errors.

Fault Tolerancecircuit breakermicroservices
0 likes · 13 min read
Building Resilient Microservices: Fault Tolerance, Graceful Degradation, and Reliability Patterns
MaGe Linux Operations
MaGe Linux Operations
Jun 10, 2022 · Fundamentals

Demystifying Paxos: How Distributed Systems Achieve Consensus

This article explains the Paxos consensus algorithm—its origins, core concepts, roles of proposers, acceptors and learners, safety and liveness constraints, the two-phase protocol, proposal generation, and practical variations—showing why Paxos remains a foundational solution for fault‑tolerant distributed systems.

Consensus AlgorithmFault TolerancePaxos
0 likes · 16 min read
Demystifying Paxos: How Distributed Systems Achieve Consensus
Ctrip Technology
Ctrip Technology
Jun 9, 2022 · Databases

Ctrip Order Database Architecture Optimization and Sharding Case Study

This article details Ctrip's comprehensive redesign of its airline ticket order database, covering the background performance bottlenecks, vertical and hot‑cold data splitting, sharding key selection, multi‑level caching, cross‑shard query optimization, dual‑write mechanisms, fault‑tolerance strategies, project planning, and the resulting improvements in scalability and cost.

Fault Tolerancedatabase shardingdual write
0 likes · 37 min read
Ctrip Order Database Architecture Optimization and Sharding Case Study
Architects Research Society
Architects Research Society
May 22, 2022 · Operations

Designing Resilient Microservices: Fault‑Tolerance Patterns and Practices

This article explains how to build highly available microservice systems by defining clear service boundaries, employing graceful degradation, change‑management strategies, health checks, self‑healing, cache failover, retry logic, rate limiting, bulkheads, circuit breakers, and testing techniques to mitigate failures in distributed environments.

Cloud NativeFault Tolerancechange management
0 likes · 15 min read
Designing Resilient Microservices: Fault‑Tolerance Patterns and Practices
macrozheng
macrozheng
Apr 14, 2022 · Operations

Mastering High Availability: 4 Essential Design Techniques for Scalable Systems

This article outlines the core high‑availability techniques—system splitting, decoupling, asynchronous processing, retry, compensation, backup, multi‑active strategies, isolation, rate limiting, circuit breaking, and degradation—providing practical guidance for designing resilient, scalable backend architectures in large‑scale internet applications.

Fault ToleranceHigh AvailabilitySystem Design
0 likes · 13 min read
Mastering High Availability: 4 Essential Design Techniques for Scalable Systems
Architect
Architect
Mar 11, 2022 · Operations

Rate Limiting, Circuit Breaking, and Service Degradation: Key Fault‑Tolerance Patterns for Distributed Systems

The article explains why distributed systems need fault‑tolerance mechanisms such as rate limiting, circuit breaking, and service degradation, describes common metrics (TPS, HPS, QPS), outlines several limiting algorithms (counter, sliding window, leaky bucket, token bucket, distributed and Hystrix‑based), and discusses circuit‑breaker states, considerations, and practical Hystrix usage.

Fault ToleranceHystrixcircuit breaker
0 likes · 17 min read
Rate Limiting, Circuit Breaking, and Service Degradation: Key Fault‑Tolerance Patterns for Distributed Systems
IT Architects Alliance
IT Architects Alliance
Mar 10, 2022 · Backend Development

Building Resilient Microservices: Patterns and Practices for High Availability

This article explains the risks of microservice architectures and presents a collection of reliability patterns—including graceful degradation, change management, health checks, self‑healing, failover caching, retries, rate limiting, bulkheads, and circuit breakers—to help engineers design and operate highly available backend services.

Fault Tolerancebackendcircuit breaker
0 likes · 17 min read
Building Resilient Microservices: Patterns and Practices for High Availability
IT Services Circle
IT Services Circle
Feb 12, 2022 · Cloud Computing

Azure Leap‑Year Outage and Leap‑Second Impacts on Cloud Systems

The article analyzes the 2012 Azure outage caused by a leap‑year date bug, explains Azure's cluster and Fabric Controller architecture, discusses common leap‑year and leap‑second pitfalls, and shows how time anomalies can cascade through DNS and other cloud services, illustrated with real code examples.

AzureCloud ComputingDNS
0 likes · 12 min read
Azure Leap‑Year Outage and Leap‑Second Impacts on Cloud Systems
IT Architects Alliance
IT Architects Alliance
Feb 3, 2022 · Cloud Native

Building a Docker‑Powered Microservice PaaS with Spring Cloud Netflix

This article explains how to design and implement a microservice‑based PaaS platform using Docker containers, Spring Cloud Netflix components such as Zuul, Eureka, and Hystrix, covering service gateway routing, registration and discovery, deployment, fault tolerance, and dynamic configuration.

DockerDynamic ConfigurationFault Tolerance
0 likes · 14 min read
Building a Docker‑Powered Microservice PaaS with Spring Cloud Netflix
IT Architects Alliance
IT Architects Alliance
Jan 23, 2022 · Operations

Microservice Monitoring, Fault Tolerance, Access Security, and Container Technology Overview

This article provides a comprehensive guide to microservice monitoring—including log, tracing, and metrics approaches—fault‑tolerance isolation techniques, access‑security mechanisms such as API‑gateway and OAuth2.0, and the role of container technologies like Docker in cloud‑native deployments.

Cloud NativeFault ToleranceMonitoring
0 likes · 30 min read
Microservice Monitoring, Fault Tolerance, Access Security, and Container Technology Overview
Code DAO
Code DAO
Dec 17, 2021 · Artificial Intelligence

How to Scale XGBoost with Ray for Distributed Multi‑GPU Training

XGBoost‑Ray provides a fault‑tolerant, multi‑node, multi‑GPU backend for XGBoost that integrates seamlessly with Ray Tune, supports distributed data loading, and can be enabled with only three code changes, enabling scalable training and inference on large clusters.

Distributed TrainingFault ToleranceGPU
0 likes · 8 min read
How to Scale XGBoost with Ray for Distributed Multi‑GPU Training
Architects Research Society
Architects Research Society
Dec 9, 2021 · Fundamentals

Key Challenges in Designing Distributed Systems

Designing a distributed system involves overcoming major challenges such as heterogeneity, transparency, openness, concurrency, security, scalability, and fault tolerance, each of which must be addressed to build a reliable, extensible, and performant system.

Fault Toleranceconcurrencydistributed systems
0 likes · 7 min read
Key Challenges in Designing Distributed Systems
MaGe Linux Operations
MaGe Linux Operations
Nov 24, 2021 · Backend Development

Mastering Go Circuit Breakers: Boost System Resilience with gobreaker

This article explains how to use the Go gobreaker library to implement circuit‑breaker patterns, describing its three states, state transitions, configurable parameters, and providing full source‑code examples to help developers improve fault tolerance in micro‑service architectures.

Fault ToleranceGobackend
0 likes · 9 min read
Mastering Go Circuit Breakers: Boost System Resilience with gobreaker
Java Architect Essentials
Java Architect Essentials
Nov 19, 2021 · Fundamentals

A Comprehensive Guide to Learning Distributed Systems

This article provides a thorough overview of distributed systems, explaining their definition, core concepts such as partition and replication, key challenges, essential characteristics, typical components and protocols, a practical request flow example, and a curated list of real‑world implementations to help readers build a solid learning roadmap.

Fault Toleranceconsistencydistributed systems
0 likes · 17 min read
A Comprehensive Guide to Learning Distributed Systems
Beike Product & Technology
Beike Product & Technology
Nov 19, 2021 · Backend Development

Implementing a Hystrix‑Style Circuit Breaker in the PHP Ecosystem: Principles, Design, and Practice

This article explains the problem of service avalanche in distributed systems, introduces the Hystrix circuit‑breaker concept and its four command modes, evaluates existing PHP implementations, and details the design and implementation of a custom hystrix‑ex Composer package that integrates with Guzzle middleware for high‑concurrency fault tolerance.

Fault Tolerancebackendcircuit-breaker
0 likes · 14 min read
Implementing a Hystrix‑Style Circuit Breaker in the PHP Ecosystem: Principles, Design, and Practice
DataFunTalk
DataFunTalk
Nov 13, 2021 · Cloud Native

Designing Cloud‑Native Distributed Database Architecture: Lessons from TiDB

This article explores how to design a cloud‑native distributed database architecture by examining TiDB’s current structure, proposing a storage‑compute separation that leverages cloud services like S3 and EBS, and discussing implications for cost, scalability, fault‑tolerance, and multi‑tenant deployment.

Fault ToleranceTiDBarchitecture
0 likes · 14 min read
Designing Cloud‑Native Distributed Database Architecture: Lessons from TiDB
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 23, 2021 · Backend Development

Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices

This article thoroughly examines how Redis distributed locks work, the safety challenges they face—including deadlocks, lock expiration, and node failures—explores the Redlock algorithm and its controversies, compares Redis with Zookeeper implementations, and offers practical guidelines and best‑practice solutions for reliable distributed locking.

Fault ToleranceRedisRedlock
0 likes · 32 min read
Redis Distributed Locks: Safety Issues, Redlock Debate, and Best Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 13, 2021 · Big Data

Why “Exactly‑Once” Doesn’t Guarantee Consistency in Stream Processing

This article examines the true meaning of consistency in stream computing, clarifies common misconceptions about exactly‑once semantics, formalizes consistency challenges, and reviews how major stream engines such as Google MillWheel, Apache Flink, Kafka Streams, and Spark Streaming implement end‑to‑end consistency.

Big DataFault ToleranceStream Processing
0 likes · 29 min read
Why “Exactly‑Once” Doesn’t Guarantee Consistency in Stream Processing
dbaplus Community
dbaplus Community
Sep 23, 2021 · Cloud Native

Master Distributed System Design: Patterns, Performance & Fault Tolerance

This article provides a comprehensive overview of distributed system architecture, covering design patterns such as gateways, sidecars and service meshes, performance techniques like caching and sharding, fault‑tolerance mechanisms including rate limiting and circuit breakers, and DevOps practices for deployment and monitoring, all aimed at building resilient cloud‑native applications.

DevOpsFault Tolerancemicroservices
0 likes · 15 min read
Master Distributed System Design: Patterns, Performance & Fault Tolerance
Architecture Digest
Architecture Digest
Sep 23, 2021 · Operations

High Availability Practices: From Taobao to Cloud

This talk shares practical high‑availability strategies learned from years of building Taobao’s massive e‑commerce platform and migrating to Alibaba Cloud, covering traditional IDC stability mechanisms, cache and disaster‑recovery designs, cloud‑native fault‑tolerance, capacity planning, rate‑limiting, graceful degradation, and multi‑region resilience.

Cloud ComputingFault Tolerancecaching
0 likes · 20 min read
High Availability Practices: From Taobao to Cloud
NiuNiu MaTe
NiuNiu MaTe
Sep 8, 2021 · Backend Development

Mastering Distributed Locks with Redis: From Basics to RedLock

This article explains what distributed locks are, outlines their essential properties, walks through step‑by‑step Redis implementations—from simple SETNX to Lua‑based atomic operations—and discusses reliability strategies such as master‑slave failover and RedLock while highlighting the inherent limits of any distributed lock.

Fault ToleranceLua ScriptingRedis
0 likes · 11 min read
Mastering Distributed Locks with Redis: From Basics to RedLock
Architecture Digest
Architecture Digest
Aug 22, 2021 · Operations

High Availability Practices: From Taobao to Cloud Migration

This talk shares practical high‑availability design experiences from Alibaba’s e‑commerce platform to its cloud services, covering traditional IDC stability mechanisms, cache and disaster‑recovery strategies, cloud‑native fault handling, capacity planning, traffic shaping, and lessons learned from real incidents.

AlibabaFault Tolerancecloud architecture
0 likes · 19 min read
High Availability Practices: From Taobao to Cloud Migration
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 20, 2021 · Operations

From Taobao to the Cloud: Secrets of Building Ultra‑High‑Availability Systems

This talk shares practical high‑availability strategies learned from Alibaba’s Taobao platform and Alibaba Cloud, covering traditional IDC stability, cache and disaster‑recovery designs, cloud‑native fault‑tolerance, performance‑capacity trade‑offs, traffic shaping, multi‑region replication, and lessons from real‑world incidents like GitLab failures.

AlibabaFault ToleranceHigh Availability
0 likes · 21 min read
From Taobao to the Cloud: Secrets of Building Ultra‑High‑Availability Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 17, 2021 · Backend Development

How Meituan Scaled Instant Logistics with Distributed Systems and AI

This article details Meituan's five‑year journey building a high‑availability, low‑latency instant logistics platform, describing the distributed architecture evolution, AI‑driven optimizations, fault‑tolerance techniques, and future challenges in scaling micro‑services for massive order and rider volumes.

AI logisticsAIOpsFault Tolerance
0 likes · 12 min read
How Meituan Scaled Instant Logistics with Distributed Systems and AI
Baidu Intelligent Testing
Baidu Intelligent Testing
Jul 29, 2021 · Backend Development

Building High‑Availability Architecture for Baidu Feed Online Recommendation System

This article describes how Baidu engineered a flexible, multi‑level fault‑tolerant architecture—including dynamic retry scheduling, multi‑recall coordination, ranking layer degradation, and cross‑IDC multi‑master storage—to achieve five‑nine availability for its massive feed recommendation service.

Cloud NativeFault ToleranceHigh Availability
0 likes · 16 min read
Building High‑Availability Architecture for Baidu Feed Online Recommendation System
21CTO
21CTO
Jul 16, 2021 · Operations

What Bilibili’s Outage Teaches About Achieving True High Availability

The article analyzes Bilibili’s recent service outage, explains why high availability matters, introduces key metrics like MTBF and MTTR, and outlines practical strategies such as redundancy, rate limiting, isolation, failover, timeout control, circuit breaking, degradation, and multi‑region deployment to build resilient systems.

Fault ToleranceHigh AvailabilityMTBF
0 likes · 18 min read
What Bilibili’s Outage Teaches About Achieving True High Availability
vivo Internet Technology
vivo Internet Technology
Jul 14, 2021 · Backend Development

Hystrix Source Code Analysis: Circuit Breaker, Isolation, and Fallback Mechanisms

Analyzing Hystrix’s source code reveals how its circuit‑breaker, bulkhead isolation (semaphore or thread‑pool), timeout detection, fallback logic, and sliding‑window health metrics work together to prevent cascading failures in distributed systems, as illustrated by an e‑commerce order service calling multiple downstream services.

Fault ToleranceHystrixNetflix OSS
0 likes · 20 min read
Hystrix Source Code Analysis: Circuit Breaker, Isolation, and Fallback Mechanisms
ITPUB
ITPUB
Jun 29, 2021 · Backend Development

Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives

This article thoroughly examines the safety of Redis‑based distributed locks, explains basic SETNX locking, explores deadlock and lock‑release problems, presents robust solutions such as atomic SET with expiration, Lua scripts, and unique tokens, and critically compares Redlock with Zookeeper while summarizing expert debates and best‑practice recommendations.

Fault ToleranceLuaRedis
0 likes · 34 min read
Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives
Architects Research Society
Architects Research Society
Jun 16, 2021 · Backend Development

Common Pitfalls in Microservice Integration and How to Mitigate Them

The article explains three frequent pitfalls when adopting microservices—complex remote communication, asynchronous processing challenges, and distributed transaction difficulties—and shows how fast‑fail, retries, timeouts, compensation, lightweight workflow engines, and idempotency can reduce complexity and improve resilience.

Fault ToleranceIdempotencyWorkflow
0 likes · 13 min read
Common Pitfalls in Microservice Integration and How to Mitigate Them
21CTO
21CTO
Jun 9, 2021 · Cloud Native

Baidu’s Low‑Intrusion, High‑Performance Service Mesh: Architecture & Lessons

This article details Baidu’s internal service‑mesh deployment, explaining why traditional RPC‑based governance fell short, how a sidecar‑based mesh decouples governance from frameworks, and the technical challenges and solutions for low‑intrusion, high‑performance, fault‑tolerant traffic management across tens of thousands of microservices.

Cloud NativeFault ToleranceTraffic Management
0 likes · 18 min read
Baidu’s Low‑Intrusion, High‑Performance Service Mesh: Architecture & Lessons
Baidu Geek Talk
Baidu Geek Talk
Jun 9, 2021 · Cloud Native

Baidu's Internal Service Mesh Practice: Architecture, Challenges, and Performance Optimizations

Baidu created an internally‑built, Istio‑based service mesh that decouples governance from language‑specific RPCs, offering low‑intrusion integration, ultra‑low latency via a brpc coroutine data plane, advanced fault‑tolerance and fine‑grained traffic scheduling, and now powers over 80 % of its core microservices handling more than a trillion daily requests.

EnvoyFault ToleranceIstio
0 likes · 17 min read
Baidu's Internal Service Mesh Practice: Architecture, Challenges, and Performance Optimizations
Programmer DD
Programmer DD
Jun 4, 2021 · Operations

Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems

This article explores essential patterns and techniques—such as graceful degradation, change management, health checks, failover caching, retry logic, rate limiting, circuit breakers, and chaos testing—to build highly available microservice architectures that can withstand network, hardware, and application failures.

Cloud NativeFault Tolerancecircuit breaker
0 likes · 15 min read
Mastering Fault‑Tolerant Microservices: Patterns for Reliable Distributed Systems
Amap Tech
Amap Tech
May 28, 2021 · Operations

System Observability Practices in Gaode Ride-Hailing: From Unified Logging to Fault Defense

Gaode Ride‑Hailing created a comprehensive 360° observability platform—standardized logging, distributed tracing, multi‑domain metrics, visual dashboards, and an incident workflow—that transforms raw data into actionable insights, accelerates root‑cause analysis, and enables automated fault defense for its large‑scale cloud‑native microservice system.

Fault ToleranceMonitoringdistributed systems
0 likes · 22 min read
System Observability Practices in Gaode Ride-Hailing: From Unified Logging to Fault Defense
Architects' Tech Alliance
Architects' Tech Alliance
May 19, 2021 · Operations

Designing Microservices Architecture for Failure: Patterns and Practices

Microservice architectures must handle inevitable network, hardware, and application errors by employing fault‑tolerant patterns such as graceful degradation, change management, health checks, fail‑over caches, retry logic, rate limiting, circuit breakers, and testing strategies to maintain service reliability and user experience.

Fault ToleranceOperationsmicroservices
0 likes · 15 min read
Designing Microservices Architecture for Failure: Patterns and Practices
JD Tech Talk
JD Tech Talk
May 17, 2021 · Databases

Design and Optimization of Multi‑Data‑Center Redis Synchronization

This article describes the challenges of native Redis in multi‑data‑center deployments and presents the design, implementation, and performance evaluation of a custom Redis extension that adds bidirectional synchronization, rlog logging, protocol enhancements, and conflict‑resolution mechanisms to achieve reliable cross‑region active‑active operation.

Data synchronizationFault ToleranceMulti-Data Center
0 likes · 16 min read
Design and Optimization of Multi‑Data‑Center Redis Synchronization
Tencent Cloud Middleware
Tencent Cloud Middleware
May 11, 2021 · Operations

Mastering High Availability: Core Concepts, Metrics, and Design Strategies

This article explains high availability fundamentals, defines availability, outlines design targets, presents common metrics such as MTBF, MTTR, MTTF, SA, RPO, RTO, discusses CAP theory, essential design elements, and answers practical Q&A on cost, architecture, fault tolerance, testing, and implementation guidance.

CAP theoremFailoverFault Tolerance
0 likes · 15 min read
Mastering High Availability: Core Concepts, Metrics, and Design Strategies
Top Architect
Top Architect
Apr 21, 2021 · Backend Development

Microservice Architecture Evolution: From Monolith to Service Mesh

This article chronicles the evolution of an online supermarket from a simple monolithic website to a fully split microservice architecture, discussing the motivations, challenges, design patterns, monitoring, fault tolerance, testing, service discovery, and the eventual adoption of service mesh.

Fault Tolerancearchitecturebackend
0 likes · 23 min read
Microservice Architecture Evolution: From Monolith to Service Mesh
vivo Internet Technology
vivo Internet Technology
Apr 14, 2021 · Fundamentals

An Overview of the Raft Distributed Consensus Algorithm

Raft is a fault‑tolerant distributed consensus protocol that simplifies Paxos by electing a single leader each term to coordinate client requests, replicate logs to a majority of servers, ensure safety through up‑to‑date voting, handle failures with randomized timeouts, resolve log conflicts, and compress logs via snapshots.

Fault ToleranceLeader ElectionLog Replication
0 likes · 19 min read
An Overview of the Raft Distributed Consensus Algorithm
Kuaishou Tech
Kuaishou Tech
Apr 9, 2021 · Backend Development

Design and Implementation of Red Packet Calculation and Distribution System for Spring Festival Activity

This article details the design of a red packet calculation and distribution system for a Spring Festival promotion, addressing mixed-type packet computation, seamless transition to awarding, distributed task processing, stability guarantees, and successful implementation results.

Batch ProcessingDistributed ComputingFault Tolerance
0 likes · 12 min read
Design and Implementation of Red Packet Calculation and Distribution System for Spring Festival Activity
IT Architects Alliance
IT Architects Alliance
Apr 5, 2021 · Operations

Design and Implementation of a Handcrafted Distributed Cluster (MyCluster)

This article describes how to design and build a native distributed cluster called MyCluster without using any existing frameworks, covering master‑slave architecture, leader election, split‑brain handling, centralized configuration management, custom communication protocols, state transitions, and client interfaces.

Cluster ArchitectureFault ToleranceLeader Election
0 likes · 13 min read
Design and Implementation of a Handcrafted Distributed Cluster (MyCluster)
DataFunTalk
DataFunTalk
Mar 28, 2021 · Big Data

Flink Stream‑Batch Integration: Layered Architecture, Unified SDK, DAG Scheduler, Shuffle, and Fault‑Tolerance

This article explains how Apache Flink has evolved into a unified stream‑batch engine by introducing a three‑layer architecture, a unified DataStream SDK, a pipeline‑region‑based DAG scheduler, a common shuffle framework, and enhanced fault‑tolerance mechanisms to address efficiency, consistency, and resource‑utilisation challenges in real‑time big‑data processing.

Apache FlinkBatch ProcessingDAG scheduler
0 likes · 25 min read
Flink Stream‑Batch Integration: Layered Architecture, Unified SDK, DAG Scheduler, Shuffle, and Fault‑Tolerance
Baidu Geek Talk
Baidu Geek Talk
Mar 22, 2021 · Operations

How Baidu Achieved 99.999% Uptime for Its Massive Feed Recommendation System

This article details Baidu's Feed recommendation system architecture, explaining how a combination of dynamic retry scheduling, real‑time stop‑loss mechanisms, multi‑recall frameworks, ranking layer fallbacks, and IDC‑level multi‑master designs collectively ensure five‑nine availability across billions of daily requests.

Fault ToleranceHigh AvailabilityOperations
0 likes · 18 min read
How Baidu Achieved 99.999% Uptime for Its Massive Feed Recommendation System
Wukong Talks Architecture
Wukong Talks Architecture
Mar 18, 2021 · Fundamentals

Understanding Distributed Theory and Algorithms: Importance, Core Concepts, and Learning Path

This article explains why distributed theory and algorithms are crucial for architects, outlines the four foundational theories and eight key protocols, discusses their four evaluation dimensions, and provides a step‑by‑step learning roadmap illustrated with stories and practical examples.

CAP theoremFault Toleranceconsensus algorithms
0 likes · 10 min read
Understanding Distributed Theory and Algorithms: Importance, Core Concepts, and Learning Path
IT Architects Alliance
IT Architects Alliance
Mar 15, 2021 · Backend Development

Evolution of Meituan Instant Logistics Distributed System Architecture and Practices

The article details Meituan's five‑year journey in instant logistics, describing how distributed, high‑concurrency backend architectures were progressively upgraded to microservices, how AI is integrated for pricing, ETA and dispatch, and the operational techniques used to ensure scalability, fault tolerance, and high availability.

AIFault ToleranceMeituan
0 likes · 8 min read
Evolution of Meituan Instant Logistics Distributed System Architecture and Practices
Xianyu Technology
Xianyu Technology
Feb 8, 2021 · Backend Development

Design and Implementation of a Cluster‑Aware Guava Cache Component for High Reliability

The paper presents a cluster‑aware Guava cache component for Alibaba’s Xianyu platform that mitigates downstream service failures by adding asynchronous reload, cluster‑wide key invalidation, and size reporting, enabling automatic fallback to refreshed local data and improving latency, with future plans for a management console, tiered storage, and disk‑backed caching.

Fault ToleranceGuavacaching
0 likes · 8 min read
Design and Implementation of a Cluster‑Aware Guava Cache Component for High Reliability
Sohu Tech Products
Sohu Tech Products
Jan 20, 2021 · Backend Development

Understanding Dubbo’s Core Architecture: Service Registration, Invocation, Routing, and Thread Dispatch Mechanisms

This article explains Dubbo’s internal architecture, covering service registration and discovery with Zookeeper, RPC invocation details including load balancing, routing, and fault‑tolerance strategies, as well as its network protocol and thread‑dispatch mechanisms, providing practical insights for backend developers.

DubboFault ToleranceLoad Balancing
0 likes · 13 min read
Understanding Dubbo’s Core Architecture: Service Registration, Invocation, Routing, and Thread Dispatch Mechanisms
Top Architect
Top Architect
Jan 6, 2021 · Cloud Native

Implementing a Microservice Architecture with Spring Cloud, Docker, and PaaS

This article explains how to build a microservice‑based PaaS platform using Spring Cloud Netflix components, Docker containers, Eureka for service registration, Zuul as a gateway, Hystrix for fault tolerance, and a dynamic configuration center to achieve agile development and continuous integration.

DockerDynamic ConfigurationFault Tolerance
0 likes · 13 min read
Implementing a Microservice Architecture with Spring Cloud, Docker, and PaaS
Architects Research Society
Architects Research Society
Dec 30, 2020 · Fundamentals

Key Challenges in Designing Distributed Systems

Designing a distributed system involves overcoming major challenges such as heterogeneity, transparency, openness, concurrency, security, scalability, and fault tolerance, each requiring careful consideration of hardware, software, network, and management aspects to build robust, scalable, and secure architectures.

Fault ToleranceSystem Designdistributed systems
0 likes · 9 min read
Key Challenges in Designing Distributed Systems
FunTester
FunTester
Dec 12, 2020 · Operations

Why Redundancy Is the Key to Effective Disaster Recovery in IT Systems

The article explains that disaster recovery for information systems relies on redundancy across hardware, energy, and data, classifies natural, human, and technical disasters, defines critical metrics such as RTO and RPO, and outlines the technologies, architectures, and maturity levels needed to ensure business continuity.

Disaster RecoveryFault ToleranceRPO
0 likes · 29 min read
Why Redundancy Is the Key to Effective Disaster Recovery in IT Systems