How does MySQL master–replica replication work, and how does it help read scaling?

Question

IT Interview Practice · Accepted Answer

Replication మార్పులను ఒక **source (master)** నుండి ఒకటి లేదా అంతకంటే ఎక్కువ **replicas** కు stream చేస్తుంది. source ప్రతి committed మార్పును దాని **binary log (binlog)** లో record చేస్తుంది; ప్రతి replica యొక్క I/O thread ఆ log ను copy చేస్తుంది మరియు ఒక SQL/applier thread దాన్ని replay చేస్తుంది, కాబట్టి replicas అదే డేటాకు converge అవుతాయి. ## ప్రవాహం ``` writes app ---------> [ SOURCE ] --- binlog ---> [ replica 1 ] <-- reads | [ replica 2 ] <-- reads +---------- binlog ---> [ replica 3 ] <-- reads ``` - **Formats** — `ROW` (logs actual row images, safe default), `STATEMENT`, లేదా `MIXED`. - **Async (default)** — source replicas కోసం వేచి ఉండకుండా commit చేస్తుంది: వేగంగా, కానీ ఒక replica lag అవ్వచ్చు. - **Semi-sync** — source కనీసం ఒక replica acknowledge చేసే వరకు వేచి ఉంటుంది, durability కోసం కొంత latency ను వదులుకుంటుంది. ## Read scaling writes ను source వద్దకు మళ్లించండి మరియు `SELECT`లను replicas అంతటా విస్తరించండి. Read-heavy apps (చాలా web apps) replicas ను జోడించడం ద్వారా reads ను దాదాపు linearly గా scale చేస్తాయి, అయితే ఒకే source ఇప్పటికీ అన్ని writes ను నిర్వహిస్తుంది. ```sql -- On a replica, watch how far behind it is: SHOW REPLICA STATUS\G -- Seconds_Behind_Source: 2 <- replication lag -- Replica_IO_Running: Yes -- Replica_SQL_Running: Yes ``` ## చిక్కు: replication lag async replicas source వెనుక ఉంటాయి కాబట్టి, write చేసి వెంటనే ఒక replica నుండి read చేసే user తన స్వంత మార్పును చూడకపోవచ్చు ("read-your-writes" ఉల్లంఘన). latency-sensitive లేదా అప్పుడే-write చేసిన reads ను source కు route చేయండి, లేదా semi-sync ను ఉపయోగించండి. ## ఇది ఎందుకు ముఖ్యం reads ను scale చేయడానికి మరియు failover/backups కోసం warm standby ను పొందడానికి Replication ప్రామాణిక మొదటి అడుగు. దాని నిర్వచించే పరిమితి — lag, మరియు ఒకే write bottleneck — వాస్తవ designs ను రూపొందిస్తుంది: మీరు కొన్నిసార్లు stale డేటాను ఎందుకు చదువుతారో మరియు write scaling కి చివరికి కేవలం ఎక్కువ replicas కాదు, sharding ఎందుకు అవసరమో ఇది వివరిస్తుంది.

ప్రవాహం

Read scaling

చిక్కు: replication lag

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు