MySQL master‑slave replication separates writes to the master and reads to one or more replicas, using binary logs to record changes; the article explains its core concepts, typical scenarios like read‑write splitting and high‑availability, and provides a step‑by‑step configuration guide covering server IDs, binlog settings, replication accounts, data initialization, GTID options, and status verification.
This article explains MySQL master‑slave replication in detail, covering its role in high‑availability and read/write separation, the core binlog mechanism, typical one‑master‑multiple‑slaves architecture, and the step‑by‑step data flow from write operations on the master to replay on the replicas.
This tutorial walks you through why JMeter distributed testing is needed, the essential pre‑checks, detailed configuration of slave and master nodes, how to launch a test across multiple machines, and common pitfalls with practical fixes, enabling you to scale load tests beyond a single host.
This article explains how MySQL master‑slave replication works, covering its role in high‑availability and read/write separation, the responsibilities of the master and slave servers, the IO and SQL threads, common replication topologies, and the step‑by‑step data flow from binlog to relay log.
This article explains how to build a highly available Nginx deployment using a master‑slave architecture combined with Keepalived, detailing the role of virtual IPs, the failover mechanism, and the step‑by‑step process that ensures 99.99% uptime.
This article walks through installing BIND, configuring the named.conf file, setting up master and slave zones, creating forward and reverse zone files, starting the named service, and verifying the setup with nslookup, including a fail‑over test to demonstrate slave activation.
This article explains MySQL master‑slave replication, covering its purpose, common topology patterns, the data flow from binlog to relay log, and a detailed step‑by‑step process for configuring asynchronous replication in production environments.
When a core order table with tens of millions of rows needs a new business field, executing a plain ALTER TABLE can lock the table and disrupt services, so the article explores master‑slave switching, online schema‑change tools, extension tables, JSON fields, and a clever reuse of an existing redundant column to achieve the change with minimal risk.
This article explains Redis master‑slave replication, covering its purpose for data redundancy, read/write separation, and high availability, and details the full‑synchronization and incremental‑synchronization processes with step‑by‑step diagrams.
This guide walks you through installing BIND on Linux, configuring forward and reverse zones, setting up master‑slave synchronization, and verifying DNS resolution on both Windows and Linux clients with detailed commands and examples.
This article explains Redis master‑slave replication, detailing the full synchronization process that creates an RDB snapshot and streams buffered writes, as well as the incremental synchronization that resumes after a disconnection using PSYNC and the replication backlog.
This article explains the Nginx master‑slave architecture, how a virtual IP is shared between a primary and backup server using Keepalived and VRRP, and why this simple failover design provides high availability for web services with minimal resources.
This guide walks you through preparing the environment, choosing a data‑sync method, configuring both master and slave servers, verifying replication, troubleshooting common issues, and applying advanced settings to achieve a reliable, monitorable MySQL 5.7 master‑slave setup.
This article explains Redis master‑slave replication, covering its purpose for backup, read/write separation, and high availability, and details the seven‑step full‑copy process and the six‑step incremental sync process with illustrative diagrams.
This article explains how the REPLACE INTO statement can cause mismatched AUTO_INCREMENT values between MySQL master and replica after a failover, leading to primary‑key conflicts, and provides reproduction steps, underlying mechanics, and practical mitigation strategies.
This guide walks you through installing BIND on Linux, configuring forward and reverse DNS, setting ports, logging, access controls, forwarders, zone files, master‑slave replication, AppArmor adjustments, and testing the DNS service with tools like dig, host, and nslookup.
This article explains how Nginx's master‑slave (primary‑backup) setup, combined with Keepalived and a virtual IP, provides high‑availability for web and API services by automatically detecting failures, shifting the VIP, and allowing the backup server to take over without service interruption.
Redis cluster relies on two ports per node, a hash‑slot based sharding scheme, a master‑slave replication model, and provides eventual consistency, making these four fundamentals essential knowledge for developers and operators to.
This tutorial walks through preparing the Linux environment, installing MySQL 5.7, configuring master and slave servers, creating replication users, verifying synchronization, troubleshooting common issues, and applying advanced options such as GTID and semi‑synchronous replication, all with complete command examples.
This article explains how RocketMQ achieves high availability and data reliability through its master‑slave broker design, covering synchronous and asynchronous replication, flush strategies, transaction messaging, automatic failover with Dledger, and read‑write separation for load balancing in distributed systems.
This tutorial explains how to use SpringBoot, AOP, and a custom @DataSource annotation to dynamically switch between MySQL master and slave databases—covering configuration, code implementation, multiple slave handling, and an Oracle example—to ensure high availability and flexible data source management.
This guide walks you through preparing multiple virtual machines, configuring MySQL server IDs, setting up both classic and GTID‑based master‑slave replication, and managing the replication with essential commands, complete with code examples and architecture diagrams.
Learn how to implement dynamic MySQL master‑slave switching in a SpringBoot project using AOP and custom annotations, ensuring automatic failover to the master when a slave fails, with detailed configuration, code examples, and guidance for multiple data sources and Oracle integration.
This guide explains how to install BIND, configure forward and reverse DNS zones, set up logging, access control, master‑slave replication, and troubleshoot common issues on Ubuntu and CentOS, including AppArmor adjustments for custom directories.
This article explains why MySQL master‑slave replication can become delayed in high‑traffic order systems, describes the underlying binlog synchronization mechanism, and provides practical steps—including network upgrades, server tuning, transaction reduction, version updates, and slave count limits—to eliminate the lag.
This article explains Redis split‑brain behavior, describing its definition, causes such as network failures and Sentinel elections, the resulting data loss during master‑slave switches, and practical prevention measures including quorum configuration, timeout tuning, network monitoring, proxy layers, and the min‑slaves‑to‑write and min‑slaves‑max‑lag settings.
This tutorial walks you through installing BIND on Linux, configuring forward and reverse DNS zones, customizing ports, logging, access control, master‑slave replication, testing with dig/host, and handling AppArmor restrictions, providing complete commands and configuration examples.
This article explains Redis master‑slave replication, synchronization steps, handling of network partitions, and how Sentinel provides automatic failover through monitoring, leader election, and notification, offering strategies to reduce master load and ensure high availability.
This guide walks you through preparing multiple virtual machines, configuring MySQL 8.0 server IDs, setting up both classic and GTID‑based master‑slave replication, and managing replication commands, providing clear code snippets and commands for a reliable MySQL clustering environment.
This article provides a comprehensive, hands‑on tutorial for planning, installing, configuring, and verifying a PostgreSQL master‑slave (streaming replication) setup on two Linux nodes, including user creation, remote connection settings, data export/import, and troubleshooting tips.
Learn how to set up a Jenkins continuous‑integration environment on Windows by installing the master server, configuring security, adding a slave node, installing JRE, and turning the slave agent into a Windows service, complete with screenshots and detailed step‑by‑step instructions.
The article examines why distributed systems inevitably face data‑consistency challenges and breaks down three common service‑architecture patterns—master‑slave, master‑master, and leaderless—detailing their replication mechanisms, advantages, drawbacks, and practical solutions such as synchronous, semi‑synchronous, asynchronous replication, quorum handling, node‑failure recovery, and conflict resolution strategies.
The article compares master‑slave, master‑master, and leaderless distributed architectures, explaining how synchronous, semi‑synchronous, and asynchronous replication affect consistency, latency and scalability, and showing that each pattern trades write throughput, conflict‑resolution complexity, and availability against strong data correctness.
This guide explains DNS fundamentals, domain name structure, resolution workflow, and provides step‑by‑step instructions for installing BIND, configuring master and slave servers, setting up zone files, and deploying a caching DNS with dnsmasq, complete with command examples and record type references.
This article explains Redis high‑availability through master‑slave replication, covering the architecture, read‑write separation benefits, the three‑stage initial sync process, incremental synchronization, and practical considerations for scaling and fault tolerance in production environments.
This article explains why read‑write separation is essential for high‑concurrency systems and details three MySQL master‑slave synchronization methods—half‑synchronous replication, database‑middleware synchronization, and cache‑key write tracking—along with their advantages, drawbacks, and consistency considerations.
This guide explains Redis's three clustering modes—master‑slave, Sentinel, and Cluster—detailing their architectures, failover mechanisms, PSYNC replication, configuration files, Spring Boot integration, and step‑by‑step testing to achieve high availability and scalability.
This article explains the concept of read‑write separation, why it improves performance, when it should be applied, the underlying principles of master‑slave replication, and provides a detailed MySQL example with diagrams to illustrate the architecture and data synchronization process.
This article explains MySQL's binary log (binlog), a binary format file that records SQL statements for database updates, its role in master-slave replication, crash recovery, and detailed implementation mechanisms including cache management and event writing processes.
This article explains why MySQL master‑slave replication can become delayed, outlines the differences between DDL and DML, shows how to diagnose lag with show slave status, and provides architectural, hardware, and configuration solutions—including semi‑synchronous replication and tuning parameters—to reduce latency.
The article explains what MySQL master‑slave replication lag is, analyzes why it occurs—especially during relay‑log replay and large DDL/DML operations—and provides concrete configuration, hardware, and architectural solutions to reduce or eliminate the delay.
This article explains the reasons for read/write splitting, compares direct‑client and proxy‑based master‑slave setups, and presents five practical strategies—including forcing reads to the master, sleep delays, lag checks, master‑position waiting, and GTID waiting—to mitigate stale reads caused by MySQL replication lag.
This article explains why a single MySQL instance is insufficient for production, introduces binlog concepts and formats, details the master‑slave replication threads and workflow, explores parallel replication mechanisms, analyzes causes of replication lag, and provides practical strategies to minimize that delay.
This article explains MySQL master‑slave architecture, why it’s used, the replication process, consistency challenges, causes of replication lag, and practical strategies—including binlog formats, mixed mode, monitoring, caching, and failover setups—to optimize performance and ensure high availability.
This guide walks through preparing two servers, installing Jenkins on a master node, configuring security and communication, adding a slave node with detailed parameters, deploying the slave agent as a Windows service, creating a slave-bound project, and troubleshooting common issues such as permission errors and network mismatches.
This article examines the evolution of database high‑availability architectures in large‑scale internet environments, covering basic direct‑connect setups, scale‑up/scale‑out sharding, master‑slave/master‑master with Keepalived, and advanced solutions such as MHA, Percona XtraDB Cluster, and MySQL Group Replication, plus smooth scaling steps.
This article explains MySQL master‑slave replication, covering its basic concepts, the advantages of read‑write separation, data backup and high availability, the underlying binlog‑based mechanism, the four replication modes (full, asynchronous, semi‑synchronous, enhanced semi‑synchronous), common consistency challenges, and practical ways to mitigate them.
This article explains why modern internet products need caching to handle massive real‑time data, introduces Redis as an in‑memory database with persistence, master‑slave replication, and clustering, and demonstrates how these techniques dramatically improve performance, scalability, and reliability of web services.
This article explains the principles, benefits, and challenges of master‑slave, multi‑master, and leaderless database replication, discusses replication lag, quorum consistency, conflict resolution, and presents various data partitioning techniques with practical examples and diagrams.
The article demonstrates via example how REPLACE INTO can cause data inconsistency and auto‑increment anomalies in master‑slave MySQL setups, explains the underlying binlog behavior, highlights risk points, and advises against using REPLACE when business logic depends on auto‑increment IDs.
The article explains why a recent write may be invisible when reading from a MySQL replica, analyzes the replication threads and latency causes, and presents practical solutions such as forcing master reads, lag detection, semi‑sync mode, and GTID‑based waiting, with examples from Sharding‑JDBC, MyCat and MaxScale.
The e‑commerce platform’s order‑query alerts were caused by MySQL master‑slave replication lag—specifically, delayed redo‑log flushing let the slave receive binlog events before the master committed—so queries returned empty, a condition mitigated by retry logic, delayed MQ delivery, or emitting post‑commit business events.
This article walks through installing BIND, configuring the named.conf file, creating forward and reverse zone files, setting up a master DNS server and a slave server, starting the services, and verifying the setup with nslookup, including a fail‑over test.
This article explains the CAP theorem, details how Redis implements master‑slave replication—including its asynchronous nature, configuration methods, three‑phase workflow, heartbeat mechanism, and common operational issues—providing practical guidance for building highly available Redis deployments.
This article explains the fundamentals of Redis master‑slave replication, covering CAP theory, the replication workflow, configuration methods, heartbeat mechanisms, and typical problems with practical solutions to ensure high availability and data consistency.
This article explains the concept of database read‑write splitting, discusses its limitations, and provides a step‑by‑step guide with Spring Boot code to configure master‑slave data sources, implement dynamic routing, context handling, custom annotations, and AOP for seamless switching.
After a month of testing a MySQL dual‑master high‑availability setup, the author details the numerous pitfalls encountered—including primary key collisions, sync failures, and data inconsistencies—and explains why they switched to a simpler master‑slave configuration, providing step‑by‑step instructions for the conversion.
After a month of operating a MySQL dual‑master high‑availability cluster, the author details the numerous pitfalls encountered and explains a step‑by‑step manual process for converting the setup to a simpler master‑slave architecture, including configuration changes and Keepalived adjustments.
The article explains how Redis Sentinel provides high availability by monitoring master‑slave instances, detecting failures through periodic pings, distinguishing subjective and objective down states, performing quorum arbitration, and automatically promoting a slave to master to ensure continuous service.
This article explains why data loss can occur in Redis master‑slave clusters due to split‑brain scenarios, outlines step‑by‑step troubleshooting methods—including checking replication lag, analyzing client logs, and monitoring resource usage—and recommends configuration settings such as min‑slaves‑to‑write and min‑slaves‑max‑lag to prevent the issue.
This article explains MySQL master‑slave read/write separation, the binlog and relay log mechanisms, master‑slave delay, and how different transaction isolation levels affect whether the master or slave may return stale data, illustrated with practical examples and SQL snippets.
This article explains why a single‑instance Redis can cause outages, introduces the master‑slave architecture, details the full and incremental synchronization processes, shows how to configure replication, addresses multi‑slave scaling, network interruptions, and automatic failover with Sentinel.
The article explains how MHA handles a crashed MySQL master by preserving binary logs, selecting the most up‑to‑date slave, applying relay logs, promoting a slave to master, and provides detailed commands for creating replication users and configuring master‑slave replication.
This article compares common distributed transaction approaches—including Master‑Slave, Master‑Master, two‑phase and three‑phase commit, and Paxos—explains their mechanisms, trade‑offs, and real‑world implementations such as Alibaba’s TCC, GTS, LCN, and TXC, helping architects select the most suitable solution for high‑availability data consistency.
This article explains why Redis is widely used, defines high availability for Redis services, enumerates common failure scenarios, evaluates four architectural solutions—including single‑instance, master‑slave with one, two, and three Sentinel instances—and finally presents a production‑grade HA design using three Sentinels and a virtual IP.
This article explains the main Redis scaling approaches—including simple partitioning, master‑slave replication, Sentinel high‑availability, and native Cluster—detailing their concepts, usage methods, advantages, drawbacks, and providing practical configuration commands and code examples.
This article introduces the main Redis scaling solutions—including simple partitioning, master‑slave replication, Sentinel high‑availability, and Redis Cluster—explaining their concepts, usage patterns, advantages, and drawbacks to help developers choose the appropriate architecture for high‑traffic environments.
This article explains why MySQL master‑slave replication is used, how the binary‑log based mechanism works, compares statement‑based and row‑based modes, provides key configuration parameters, and offers practical solutions for reducing replication lag.
Redis, the high‑performance open‑source key‑value store, uses a master‑slave replication mechanism that ensures data redundancy, read/write separation, fault recovery, and high‑availability; this article explains its handshake process, synchronization phases, replication states, and key source‑code functions in detail.
This article explains why a single MySQL instance becomes insufficient as data volume and concurrency grow, and walks through master‑slave replication, asynchronous and semi‑synchronous modes, group replication, and various high‑availability solutions such as MHA, MySQL InnoDB Cluster, and Orchestrator, while also covering read/write splitting techniques and practical implementation tips.
This article explains the recent updates to the DCS_FunTester distributed performance‑testing framework, including Groovy script execution, a new master‑slave registration mechanism, service‑layer extraction, and synchronization logic, while providing concrete Java code examples for each enhancement.
This article explains the basic principles of MySQL master‑slave architecture, the role of read‑only replicas, loop‑replication problems, master‑slave delay measurement, various failover strategies, parallel replication mechanisms across MySQL versions and MariaDB, GTID usage, and read‑write splitting techniques, providing practical commands and diagrams for each concept.
This article walks through the design and implementation of a Docker‑based distributed performance testing framework using FunTester, detailing the master‑scheduler, slave agents, test case packaging, code examples, and sample results for load‑testing a target service.
This article explains common database high‑availability designs—including master‑slave, master‑master, and automatic failover architectures—their topologies, advantages, disadvantages, and practical considerations such as replication lag, manual intervention, and data consistency challenges.
This article explains MySQL master‑slave replication, covering replication modes, use cases, required configurations, underlying mechanisms, common issues, and solutions such as semi‑synchronous and parallel replication, along with practical configuration examples and monitoring commands.
This article explains how to build a highly available Redis service by analyzing common failure scenarios, evaluating single‑instance, master‑slave with one or multiple Sentinel processes, and ultimately recommending a three‑Sentinel architecture combined with a virtual IP for seamless client usage.
This article explains how Redis master‑slave replication operates, covering the underlying mechanisms such as update propagation, partial and full resynchronization, the characteristics and limitations of replication, common single‑node issues, and step‑by‑step instructions for configuring and executing replication commands.
The article experimentally evaluates three ways of creating replication users—only on the master, separately on master and slave with CREATE statements, and separately with GRANT statements—to show how each method affects MySQL 5.7 master‑slave replication, error handling, and compatibility with GTID and MySQL 8.0.
This article provides a comprehensive guide to Redis high‑availability through master‑slave replication, covering the underlying architecture, step‑by‑step setup, full and partial synchronization processes, buffer management, practical pitfalls, and how the mechanism fits into broader Redis HA solutions.
This article explains why, in MySQL row‑based replication, a master table having an extra column does not disrupt replication to a slave table lacking that column, provided column order, placement, and default values meet specific conditions, and demonstrates the behavior with a MySQL 5.7.25 test.
This article explains the root causes of MySQL master‑slave replication lag—including random replay, high master concurrency, and lock waits—and presents practical solutions such as parallel replication, reducing master load, and reading from the master to ensure data consistency.
The article outlines typical problems caused by inconsistent Redis master‑slave settings—such as mismatched maxmemory, differing hash‑ziplist parameters, replication performance bottlenecks, and single‑point failures—and provides practical recommendations to improve reliability and data safety.
This article outlines core database architecture principles—high availability, performance, consistency, and scalability—and evaluates four common schemes (primary‑backup, dual‑master, master‑slave with read/write separation, and hybrid), followed by detailed consistency‑resolution strategies and personal insights.
This article explains MySQL's built‑in replication mechanism, covering its purpose, supported replication formats, step‑by‑step master‑slave configuration, common topologies, troubleshooting techniques, and practical SQL commands for setting up and maintaining reliable data distribution and high availability.
This article provides a step‑by‑step tutorial on configuring MySQL master‑slave replication, covering the underlying principles, master and slave configuration files, user creation, data backup, log synchronization, and verification with example commands and code snippets.
This tutorial walks through installing MySQL 8.0 on two servers, enabling binary logging, creating a replication user, configuring master and slave settings, handling common errors, and verifying that master‑slave synchronization works correctly.
This article explains a real‑world case where a newly added mapping rule didn't appear immediately due to master‑slave replication lag, walks through the evolution of database architectures from single‑node to read‑write separation, and presents several practical strategies to mitigate consistency issues caused by replication delay.
This guide outlines a step‑by‑step process for designing JMeter scripts, performing local and BlazeMeter sandbox tests, configuring consoles and engines, scaling to clusters, and using Master/Slave mode to achieve a smooth load test of 50 000 concurrent users, including monitoring and resource considerations.
This article explains the concept of read‑write splitting for databases, compares client‑side and proxy implementations, discusses data lag and forced routing techniques, and provides code examples and custom load‑balancing algorithms using Sharding‑JDBC and Spring.
This article explains MySQL master‑slave replication by covering SBR, RBR, and MBR concepts, step‑by‑step configuration of master and slave servers, binlog format settings, the underlying replication protocol, key SQL commands, and troubleshooting tips, all illustrated with real code snippets and diagrams.
This article explains what MySQL master‑slave replication is, outlines its benefits, details the underlying mechanisms and event types, and provides a comprehensive, command‑line tutorial for configuring both master and slave servers, complete with code snippets and illustrative diagrams.
Database read/write separation, alongside sharding and master‑slave architectures, mitigates high‑concurrency bottlenecks by distributing reads to replicas and writes to a primary, offering scalability and performance benefits while introducing challenges such as replication lag, routing complexity, and resource utilization trade‑offs.
This article explains Redis's asynchronous master‑slave replication, covering the three core mechanisms, partial and full resynchronization processes, configuration methods, diskless sync, key expiration handling, replication IDs and offsets, and safety considerations when disabling persistence.
This guide walks you through creating JMeter scripts, performing local and sandbox tests, configuring consoles and engines, scaling to clusters, and leveraging master‑slave mode to reliably run load tests with over fifty thousand simultaneous users.
This guide details the end‑to‑end process for performing a 50,000‑user concurrent load test with JMeter and BlazeMeter, including script creation, local validation, sandbox execution, engine scaling, cluster testing, and Master/Slave configuration to achieve the required concurrency.
Learn step‑by‑step how to set up a binlog‑based MySQL master‑slave replication using Docker‑Compose and Dockerfiles, covering directory structure, configuration files, container creation, verification, and troubleshooting, so you can quickly deploy a reliable MySQL replication environment.
This article explains why Redis needs high availability, defines common failure scenarios, compares several HA solutions, and walks through four deployment patterns—culminating in a three‑Sentinel architecture with a virtual IP to provide seamless, fault‑tolerant Redis access.
This step‑by‑step guide shows how to use Docker on CentOS 7 to pull MySQL 5.7 images, configure master and slave my.cnf files, run containers, set up replication, and verify that a test database created on the master is automatically synchronized to the slave.