Skip to main content

Availability and Scalability

đŸĸ 9. High Availability & Scalability​

101. What is database clustering?​

Database Clustering āĻšāϞ⧋ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāϧāĻžāϰāĻŖ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻžāĻ°ā§āĻ­āĻžāϰāϕ⧇ (Node) āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻāĻ•āĻ¤ā§āϰ⧇ āϝ⧁āĻ•ā§āϤ āĻ•āϰāĻžāϰ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋ, āϝāĻžāϤ⧇ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦāĻž āχāωāϜāĻžāϰ⧇āϰ āĻ•āĻžāϛ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ āϝ⧇ āϤāĻžāϰāĻž āĻāĻ•āϟāĻŋ āĻŽāĻžāĻ¤ā§āϰ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻžāĻĨ⧇āχ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āĻ•āϰāϛ⧇āĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻšāĻžāχāϞāĻŋ āĻāϭ⧇āχāĻ˛ā§āϝāĻžāĻŦāϞ (High Availability - HA) āĻāĻŦāĻ‚ āĻ¸ā§āϕ⧇āϞ⧇āĻŦāϞ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

āϏāĻšāϜ āĻ•āĻĨāĻžāϝāĻŧ, āĻāĻ•āϟāĻŋ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇, āĻŦ⧇āĻļ āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰāϕ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•āĻžāύ⧇āĻ•ā§āϟ āĻ•āϰ⧇ āĻāĻ•āϟāĻŋ "āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ" (Cluster) āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āϝāĻĻāĻŋ āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āĻ…āĻ¨ā§āϝ āϏāĻžāĻ°ā§āĻ­āĻžāϰāϗ⧁āϞ⧋ āϤāĻ–āύ āĻĻāĻžāϝāĻŧāĻŋāĻ¤ā§āĻŦ āύāĻŋāϤ⧇ āĻĒāĻžāϰ⧇, āĻĢāϞ⧇ āϏāĻžāĻ°ā§āĻ­āĻŋāϏ āĻ•āĻ–āύ⧋ āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ āύāĻžāĨ¤

Technical definition: Database clustering is the process of connecting two or more database servers to function as a single, coordinated logical unit. It is primarily designed to achieve high availability, fault tolerance, and load balancing by distributing database transactions and storage across multiple nodes.

Difference between active-active and active-passive clustering?​

FeatureActive-Active ClusteringActive-Passive Clustering
āĻ“āϝāĻŧāĻžāĻ°ā§āĻ•āĻŋāĻ‚ āĻŽāĻĄā§‡āϞāĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āϏāĻŦāϗ⧁āϞ⧋ āύ⧋āĻĄ āĻāĻ•āϏāĻžāĻĨ⧇ āϏāϚāϞ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āϏāĻŦāϗ⧁āϞāĻŋāϤ⧇ āϰāĻŋāĻĄ/āϰāĻžāχāϟ āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻāĻ•āϟāĻŋ āύ⧋āĻĄ (Primary) āĻĒā§āϰāϧāĻžāύ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āĻŦāĻžāĻ•āĻŋāϗ⧁āϞ⧋ āĻŦā§āϝāĻžāĻ•āφāĻĒ (Standby) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦāϏ⧇ āĻĨāĻžāϕ⧇āĨ¤
āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻŋāĻ‚āχāωāϜāĻžāϰ⧇āϰ āϰāĻŋāĻ•ā§‹ā§Ÿā§‡āĻ¸ā§āϟ āϏāĻŦ āύ⧋āĻĄā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŽāĻžāύāĻ­āĻžāĻŦ⧇ āĻ­āĻžāĻ— āĻšā§Ÿā§‡ āϝāĻžā§Ÿ, āĻĢāϞ⧇ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻ…āύ⧇āĻ• āĻŦāĻžā§œā§‡āĨ¤āϕ⧋āύ⧋ āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻŋāĻ‚ āĻšā§Ÿ āύāĻž, āĻ•āĻžāϰāĻŖ āϰāĻŋāĻ•ā§‹ā§Ÿā§‡āĻ¸ā§āϟ āĻļ⧁āϧ⧁ āĻāĻ•āϟāĻŋ āύ⧋āĻĄā§‡āχ āφāϏ⧇āĨ¤
āĻĢ⧇āχāϞāĻ“āĻ­āĻžāϰ (Failover)āĻāĻ•āϟāĻŋ āĻĄāĻžāωāύ āĻšāϞ⧇ āĻ…āĻ¨ā§āϝāϗ⧁āϞ⧋ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ•āĻ­āĻžāĻŦ⧇āχ āĻ•āĻžāϜ āϚāĻžāϞāĻŋā§Ÿā§‡ āϝāĻžā§Ÿ, āĻŦā§āϝāĻŦāĻšāĻžāϰāĻ•āĻžāϰ⧀ āĻŸā§‡āϰāχ āĻĒāĻžā§Ÿ āύāĻžāĨ¤āĻĒā§āϰāĻžāχāĻŽāĻžāϰāĻŋ āĻĄāĻžāωāύ āĻšāϞ⧇ āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻŦāĻžāχ āύ⧋āĻĄ āϚāĻžāϞ⧁ āĻšāϤ⧇ āĻāĻ•āϟ⧁ āϏāĻŽāϝāĻŧ āύ⧇āϝāĻŧ (downtime āĻšāϤ⧇ āĻĒāĻžāϰ⧇)āĨ¤
āϰāĻŋāϏ⧋āĻ°ā§āϏ āĻŦā§āϝāĻŦāĻšāĻžāϰāϏāĻŦ āϏāĻŽāϝāĻŧ āϏāĻŦ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻĒā§āϰāϏ⧇āϏāϰ āĻ“ āĻ°â€ā§āϝāĻžāĻŽ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇ āĻŦāϞ⧇ ā§§ā§Ļā§Ļ% āϰāĻŋāϏ⧋āĻ°ā§āϏ āĻāϰ āϏāĻĻā§āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤āĻŦā§āϝāĻžāĻ•āφāĻĒ āύ⧋āĻĄ āĻ…āϞāϏ āĻŦāϏ⧇ āĻĨāĻžāĻ•āĻžāϝāĻŧ āϰāĻŋāϏ⧋āĻ°ā§āϏ⧇āϰ āĻ…āĻĒāϚāϝāĻŧ āĻšāϝāĻŧāĨ¤
āĻ•āĻŽāĻĒā§āϞ⧇āĻ•ā§āϏāĻŋāϟāĻŋāĻ•āύāĻĢā§āϞāĻŋāĻ•ā§āϟ āĻŽā§āϝāĻžāύ⧇āϜāĻŽā§‡āĻ¨ā§āϟ (data conflict) āϏāĻžāĻŽāϞāĻžāύ⧋ āĻŦ⧇āĻļ āϜāϟāĻŋāϞ āĻ“ āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞāĨ¤āχāĻŽāĻĒā§āϞāĻŋāĻŽā§‡āĻ¨ā§āϟ āĻ•āϰāĻž āĻ…āύ⧇āĻ• āϏāĻšāϜ āĻāĻŦāĻ‚ āĻ•āĻŽ āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞāĨ¤

How does failover work in clusters?​

Failover āĻšāϞ⧋ āϕ⧋āύ⧋ āύ⧋āĻĄ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāϞ⧇ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧāĻ­āĻžāĻŦ⧇ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āĻ…āĻ¨ā§āϝ āϏāϚāϞ āύ⧋āĻĄā§‡ āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĢāĻžāϰ āĻ•āϰāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤

  • āĻāĻ•āϟāĻŋ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇ āύ⧋āĻĄāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϰ⧇āϗ⧁āϞāĻžāϰ "Heartbeat" āϏāĻŋāĻ—āĻ¨ā§āϝāĻžāϞ āφāĻĻāĻžāύ-āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ (āϝ⧇āĻŽāύ: "āφāĻŽāĻŋ āĻŦ⧇āρāĻšā§‡ āφāĻ›āĻŋ, āϤ⧁āĻŽāĻŋ āφāϛ⧋ āϤ⧋?")āĨ¤
  • āϝāĻĻāĻŋ āϕ⧋āύ⧋ āύ⧋āĻĄā§‡āϰ āĻšāĻžāĻ°ā§āϟāĻŦāĻŋāϟ āĻ•āϝāĻŧ⧇āĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āϜāĻ¨ā§āϝ āφāϏāĻž āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϤāĻ–āύ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ āĻŽā§āϝāĻžāύ⧇āϜāĻŽā§‡āĻ¨ā§āϟ āϏāĻĢāϟāĻ“āϝāĻŧā§āϝāĻžāϰ (āϝ⧇āĻŽāύ: Zookeeper āĻŦāĻž Pacemaker) āϧāϰ⧇ āύ⧇āϝāĻŧ āϝ⧇ āύ⧋āĻĄāϟāĻŋ āĻŽāĻžāϰāĻž āϗ⧇āϛ⧇ āĻŦāĻž āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤
  • āϤāĻ–āύ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇āχ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰāϟāĻŋ āĻ“āχ āĻŽā§ƒāϤ āύ⧋āĻĄāϟāĻŋāϕ⧇ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻĨ⧇āϕ⧇ āϏāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ āĻāĻŦāĻ‚ āϏāĻŽāĻ¸ā§āϤ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āĻ…āĻ¨ā§āϝ āϏāϚāϞ āύ⧋āĻĄāϗ⧁āϞ⧋āϤ⧇ āĻĢāϰāĻ“āϝāĻŧāĻžāĻ°ā§āĻĄ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻāϤ āĻĻā§āϰ⧁āϤ āĻšāϝāĻŧ āϝ⧇ āχāωāϜāĻžāϰāϰāĻž āϕ⧋āύ⧋ āĻŦāĻžāϧāĻžāχ āĻ…āύ⧁āĻ­āĻŦ āĻ•āϰ⧇āύ āύāĻžāĨ¤

102. What is database replication?​

Database Replication āĻšāϞ⧋ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĨ⧇āϕ⧇ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• āĻ…āĻ¨ā§āϝ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻšā§āĻŦāĻšā§ āĻ•āĻĒāĻŋ āĻŦāĻž āĻ•ā§āϞ⧋āύ (Clone) āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āϰāĻžāĻ–āĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰāĻŋāĻ‚ āϝ⧇āĻ–āĻžāύ⧇ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻāĻŦāĻ‚ āϞ⧋āĻĄ āĻļ⧇āϝāĻŧāĻžāϰāĻŋāĻ‚āϝāĻŧ⧇āϰ āĻ“āĻĒāϰ āĻœā§‹āϰ āĻĻ⧇āϝāĻŧ, āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϏ⧇āĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϰ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻāĻŦāĻ‚ āϰāĻŋāĻĄāĻŋāĻ‚ āĻ¸ā§āĻĒāĻŋāĻĄ āĻŦāĻžāĻĄāĻŧāĻžāύ⧋āϰ āĻ“āĻĒāϰ āĻœā§‹āϰ āĻĻ⧇āϝāĻŧāĨ¤

āĻāϰ āĻŽā§‚āϞ āϏ⧁āĻŦāĻŋāϧāĻž āĻšāĻ˛ā§‹â€”āϝāĻĻāĻŋ āĻŽā§‡āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ (Master) āϕ⧋āύ⧋ āĻ•āĻžāϰāϪ⧇ āĻĄā§‡āϟāĻž āĻĄāĻŋāϞāĻŋāϟ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āĻŦāĻž āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āĻ• āĻĒ⧁āĻĄāĻŧ⧇ āϝāĻžāϝāĻŧ, āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻ•āĻĒāĻŋ (Slave) āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž āϖ⧁āĻŦ āϏāĻšāĻœā§‡āχ āωāĻĻā§āϧāĻžāϰ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤

Technical definition: Database replication is the continuous and automated copying of data changes from a primary database instance to one or more secondary database instances. It ensures data redundancy, increases query throughput (by scaling reads), and minimizes data loss.

Types of replication (synchronous vs asynchronous)?​

ā§§. Synchronous Replication (āϏāĻŋāύāĻ•ā§āϰ⧋āύāĻžāϏ):

  • āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇: āϝāĻ–āύ āχāωāϜāĻžāϰ āĻŽā§‚āϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ (Master) āϕ⧋āύ⧋ āĻĄā§‡āϟāĻž āϏ⧇āĻ­ āĻ•āϰ⧇, āϤāĻ–āύ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏ⧇āχ āĻĄā§‡āϟāĻž āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āĻ¸ā§āϞ⧇āĻ­ (Slave) āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋āϤ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤ āϝāϤāĻ•ā§āώāĻŖ āύāĻž āĻ…āĻ¨ā§āϝ āĻ¸ā§āϞ⧇āĻ­āϗ⧁āϞ⧋ āĻ•āύāĻĢāĻžāĻ°ā§āĻŽ āĻ•āϰ⧇ āϝ⧇ "āĻšā§āϝāĻžāρ, āφāĻŽāϰāĻž āφāĻĒāĻĄā§‡āϟ āĻĒ⧇āϝāĻŧ⧇āĻ›āĻŋ", āϤāϤāĻ•ā§āώāĻŖ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āχāωāϜāĻžāϰāϕ⧇ 'Success' āĻŽā§‡āϏ⧇āϜ āĻĻ⧇āϝāĻŧ āύāĻžāĨ¤
  • āϏ⧁āĻŦāĻŋāϧāĻž: āĻĄā§‡āϟāĻžāϰ ā§§ā§Ļā§Ļ% āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋ (Zero Data Loss)āĨ¤
  • āĻ…āϏ⧁āĻŦāĻŋāϧāĻž: āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻ…āύ⧇āĻ• āĻ¸ā§āϞ⧋ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āĻ•āĻžāϰāĻŖ āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āφāĻĒāĻĄā§‡āϟ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ…āĻ¨ā§āϝāϗ⧁āϞ⧋āϰ āωāĻ¤ā§āϤāϰ⧇āϰ āĻ…āĻĒ⧇āĻ•ā§āώāĻžāϝāĻŧ āĻĨāĻžāĻ•āϤ⧇ āĻšāϝāĻŧāĨ¤

⧍. Asynchronous Replication (āĻ…ā§āϝāĻžāϏāĻŋāύāĻ•ā§āϰ⧋āύāĻžāϏ):

  • āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇: āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻĄā§‡āϟāĻž āĻĸā§‹āĻ•āĻž āĻŽāĻžāĻ¤ā§āϰāχ āϏ⧇ āχāωāϜāĻžāϰāϕ⧇ 'Success' āĻŽā§‡āϏ⧇āϜ āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϰāĻĒāϰ āϏ⧇ āφāϰāĻžāĻŽāϏ⧇ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āύāĻŋāĻœā§‡āϰ āϏ⧁āĻŦāĻŋāϧāĻžāĻŽāϤ⧋ āϏāĻŽāϝāĻŧ⧇ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋ āĻ¸ā§āϞ⧇āϭ⧇āϰ āĻ•āĻžāϛ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤
  • āϏ⧁āĻŦāĻŋāϧāĻž: āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĢāĻžāĻ¸ā§āϟ āĻāĻŦāĻ‚ āĻšāĻžāχ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏāĨ¤
  • āĻ…āϏ⧁āĻŦāĻŋāϧāĻž: āϝāĻĻāĻŋ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āϏāĻŋāĻ™ā§āĻ• āĻšāĻ“āϝāĻŧāĻžāϰ āφāϗ⧇āχ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϟāĻŋ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰ⧇ āϝāĻžāϝāĻŧ, āϤāĻŦ⧇ āϏāĻ°ā§āĻŦāĻļ⧇āώ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋ āϚāĻŋāϰāϤāϰ⧇ āĻšāĻžāϰāĻŋāϝāĻŧ⧇ āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇ (Data Loss).

What is replication lag and how to minimize it?​

Replication Lag āĻšāϞ⧋ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϕ⧋āύ⧋ āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰ, āϏ⧇āϟāĻŋ āĻ¸ā§āϞ⧇āĻ­ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻĒ⧌āρāĻ›āĻžāϤ⧇ āĻāĻŦāĻ‚ āφāĻĒāĻĄā§‡āϟ āĻšāϤ⧇ āĻ āĻŋāĻ• āϝāϤāϟ⧁āϕ⧁ āϏāĻŽāϝāĻŧ āϞāĻžāϗ⧇, āϏ⧇āχ āĻĄāĻŋāϞ⧇ (Delay) āĻŦāĻž āϏāĻŽāϝāĻŧ⧇āϰ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝāϕ⧇ āĻŦā§‹āĻāĻžāϝāĻŧāĨ¤

  • āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻŽāĻžāĻŦ⧇āύ?
    1. āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻ­āĻžāϞ⧋ āĻ•āϰāĻž: āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝ⧇ āϞ⧇āĻŸā§‡āĻ¨ā§āϏāĻŋ āĻŦāĻž āĻĒāĻŋāĻ‚ āϟāĻžāχāĻŽ (Ping time) āĻ•āĻŽāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻĒā§āϰāĻžāχāϭ⧇āϟ āĻŦāĻž āĻĄā§‡āĻĄāĻŋāϕ⧇āĻŸā§‡āĻĄ āĻĢāĻžāĻ¸ā§āϟ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāĨ¤
    2. āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ (Parallel Replication): āĻ¸ā§āϞ⧇āĻ­ āύ⧋āĻĄā§‡ āϏāĻŋāĻ™ā§āϗ⧇āϞ-āĻĨā§āϰ⧇āĻĄā§‡āϰ āĻŦāĻĻāϞ⧇ āĻŽāĻžāĻ˛ā§āϟāĻŋ-āĻĨā§āϰ⧇āĻĄ āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϚāĻžāϞ⧁ āĻ•āϰāĻž, āϝāĻžāϤ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ…āύ⧇āĻ• āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ (MySQL ā§Ģ.ā§­+ āĻ āĻāχ āĻĢāĻŋāϚāĻžāϰāϟāĻŋ āĻ…āϏāĻžāϧāĻžāϰāĻŖ āĻ•āĻžāϜ āĻ•āϰ⧇)āĨ¤
    3. āĻ…āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ āĻĄā§‡āϟāĻž āĻāĻĄāĻŧāĻžāύ⧋: āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϞāϗ⧇ āĻŦāĻĄāĻŧ āĻŦāĻž āϜāϟāĻŋāϞ āϕ⧁āϝāĻŧ⧇āϰāĻŋ (āϝ⧇āĻŽāύ āĻĒ⧁āϰ⧋ āĻŸā§‡āĻŦāĻŋāϞ āĻāĻ•āϏāĻžāĻĨ⧇ āφāĻĒāĻĄā§‡āϟ) āύāĻž āϚāĻžāϞāĻžāύ⧋āĨ¤

103. What is database sharding?​

Database Sharding āĻšāϞ⧋ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŸā§‡āĻŦāĻŋāϞāϕ⧇ āϕ⧇āĻŸā§‡ āϛ⧋āϟ āϛ⧋āϟ āϟ⧁āĻ•āϰ⧋āϤ⧇ (Shard) āĻ­āĻžāĻ— āĻ•āϰ⧇ āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŽā§‡āĻļāĻŋāύ⧇āϰ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇ āĻ›āĻĄāĻŧāĻŋāϝāĻŧ⧇ āϰāĻžāĻ–āĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋāĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻ¸ā§āϕ⧇āϞ⧇āĻŦāĻŋāϞāĻŋāϟāĻŋāϰ (Scalability) āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ āĻšāĻžāϤāĻŋāϝāĻŧāĻžāϰāĨ¤

āϝāĻ–āύ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻĒāĻ•ā§āώ⧇ āϞāĻžāĻ– āϞāĻžāĻ– āχāωāϜāĻžāϰ⧇āϰ āĻĄā§‡āϟāĻž āϰāĻžāĻ–āĻž āϏāĻŽā§āĻ­āĻŦ āĻšāϝāĻŧ āύāĻž, āϤāĻ–āύ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋āϕ⧇ āĻļāĻžāĻ°ā§āĻĄāĻŋāĻ‚ āĻ•āϰ⧇ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤

Technical definition: Sharding is an architectural pattern for horizontal partitioning of databases. It divides a large unified dataset into smaller, distinct chunks (shards) across multiple autonomous servers to distribute the data storage and query processing load linearly.

Horizontal vs vertical partitioning?​

FeatureVertical PartitioningHorizontal Partitioning (Sharding)
āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ­āĻžāĻ— āĻ•āϰ⧇?āĻŸā§‡āĻŦāĻŋāϞāϕ⧇ āĻ•āϞāĻžāĻŽ (Column) āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻ­āĻžāĻ— āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤āĻŸā§‡āĻŦāĻŋāϞāϕ⧇ āϰ⧋ (Row) āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻ­āĻžāĻ— āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
āωāĻĻāĻžāĻšāϰāĻŖāĻāĻ•āϟāĻŋ āχāωāϜāĻžāϰ āĻŸā§‡āĻŦāĻŋāϞ⧇ ⧍ā§Ļā§Ļ āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϞ⧇, "Login Info" ā°’ā°• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻāĻŦāĻ‚ "Profile Info" āφāϰ⧇āĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āϰāĻžāĻ–āĻžāĨ¤āχāωāϜāĻžāϰ⧇āϰ āϞ⧋āϕ⧇āĻļāύ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€â€”āĻŦāĻžāĻ‚āϞāĻžāĻĻ⧇āĻļ⧇āϰ āχāωāϜāĻžāϰ āϏāĻžāĻ°ā§āĻ­āĻžāϰ ā§§ āĻ āĻāĻŦāĻ‚ āχāĻ¨ā§āĻĄāĻŋāϝāĻŧāĻžāϰ āχāωāϜāĻžāϰ āϏāĻžāĻ°ā§āĻ­āĻžāϰ ⧍ āĻ āϰāĻžāĻ–āĻžāĨ¤
āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āĻ•āĻžāϰāĻŖāϏāĻŋāĻ•āĻŋāωāϰāĻŋāϟāĻŋ (āϝ⧇āĻŽāύ āĻĒāĻžāϏāĻ“āϝāĻŧāĻžāĻ°ā§āĻĄ āφāϞāĻžāĻĻāĻž āϰāĻžāĻ–āĻž) āĻŦāĻž āϝ⧇āϏāĻŦ āĻ•āϞāĻžāĻŽ āĻŽāĻžāύ⧁āώ āϖ⧁āĻŦ āĻ•āĻŽ āĻĒāĻĄāĻŧ⧇ āϏ⧇āϗ⧁āϞ⧋ āϏāϰāĻŋāϝāĻŧ⧇ āύ⧇āϝāĻŧāĻžāĨ¤āĻŦāĻŋāĻļāĻžāϞ āĻĄā§‡āϟāĻžāϏ⧇āϟ āĻāĻŦāĻ‚ āĻšāĻžāχ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āϞ⧋āĻĄ āĻŽā§āϝāĻžāύ⧇āϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝāĨ¤
āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚āϏ⧀āĻŽāĻŋāϤāĨ¤ āĻāĻ•āϏāĻŽāϝāĻŧ āĻ•āϞāĻžāĻŽ āφāϰ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžāϝāĻŧ āύāĻžāĨ¤āφāύāϞāĻŋāĻŽāĻŋāĻŸā§‡āĻĄāĨ¤ āύāϤ⧁āύ āύāϤ⧁āύ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϝ⧋āĻ— āĻ•āϰāĻž āϏāĻšāϜāĨ¤

How do you handle cross-shard queries?​

Cross-shard Query āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āϝāĻž āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŦāĻž Shard āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž āφāύāϤ⧇ āĻšāϝāĻŧāĨ¤ (āϝ⧇āĻŽāύ: "āĻŦāĻŋāĻļā§āĻŦ⧇āϰ āϏāĻŦ āĻĻ⧇āĻļ⧇āϰ āχāωāϜāĻžāϰāĻĻ⧇āϰ āĻ—āĻĄāĻŧ āĻŦāϝāĻŧāϏ āĻ•āϤ?")āĨ¤ āĻāϗ⧁āϞ⧋ āϏāĻžāϧāĻžāϰāĻŖāϤ āϖ⧁āĻŦ āĻ¸ā§āϞ⧋ āĻāĻŦāĻ‚ āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞ āĻšāϝāĻŧāĨ¤

  • āĻāϟāĻŋ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāĻŦ⧇āύ?
    1. Query Router: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϰāĻžāωāϟāĻžāϰ (āϝ⧇āĻŽāύ: Mongos) āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞāĻ­āĻžāĻŦ⧇ āϏāĻŽāĻ¸ā§āϤ Shard āĻ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻĒāĻžāĻ āĻžāϝāĻŧ, āĻāϰāĻĒāϰ āϏāĻŦāĻžāϰ āĻĨ⧇āϕ⧇ āϰ⧇āϜāĻžāĻ˛ā§āϟ āύāĻŋāϝāĻŧ⧇ āύāĻŋāĻœā§‡āϰ āĻŽā§‡āĻŽāϰāĻŋāϤ⧇ āϜāĻŽāĻž āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻāĻ•āĻ¤ā§āϰāĻŋāϤ (Merge/Aggregate) āĻ•āϰ⧇ āĻ•ā§āϞāĻžāϝāĻŧ⧇āĻ¨ā§āϟāϕ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤
    2. MapReduce/Aggregation: āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āχāύāĻ­āĻžāϝāĻŧāϰāύāĻŽā§‡āĻ¨ā§āĻŸā§‡ MapReduce āĻŦāĻž Aggregate āĻĢā§āϰ⧇āĻŽāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž, āϝāĻžāϤ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻŽāĻžāϰāĻŋ āĻ•āϰ⧇ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤
    3. Data Localization (Best Practice): āĻļāĻžāĻ°ā§āĻĄ āĻŽā§‚āϞ āϚāĻžāĻŦāĻŋāĻ•āĻžāĻ āĻŋ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āϏāĻŋāϞ⧇āĻ•ā§āϟ āĻ•āϰāĻž (āϝ⧇āĻŽāύ user_id āĻŦāĻž country), āϝāĻžāϤ⧇ āĻ…āϧāĻŋāĻ•āĻžāĻ‚āĻļ āϕ⧁āϝāĻŧ⧇āϰāĻŋ āϏāĻŋāĻ™ā§āϗ⧇āϞ āĻļāĻžāĻ°ā§āĻĄā§‡āχ āϏāĻŽāĻžāϧāĻžāύ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

104. What is read replica?​

Read Replica āĻšāϞ⧋ āĻŽā§‚āϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ (Master) āĻāĻ•āϟāĻŋ āĻ•āĻĒāĻŋ āĻŦāĻž āĻ•ā§āϞ⧋āύ, āϝāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϰāĻŋāĻĄ āĻ…āĻĒāĻžāϰ⧇āĻļāύ (SELECT queries) āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻž āĻļ⧁āϧ⧁ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĨ⧇āϕ⧇ āφāϏ⧇; āϕ⧇āω āĻāχ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻžāϤ⧇ āύāϤ⧁āύ āĻĄā§‡āϟāĻž Insert āĻŦāĻž Update āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āĻ—āĻ āύāĻŽā§‚āϞāĻ• āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

Technical definition: A read replica is a secondary instance of a database that is maintained as an exact, read-only copy of the primary database through asynchronous replication. It is used to offload read-heavy traffic from the master database.

How does it improve read performance?​

āϏāĻžāϧāĻžāϰāĻŖāϤ āĻ“āϝāĻŧ⧇āĻŦ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύāϗ⧁āϞ⧋āϤ⧇ āϞ⧇āĻ–āĻžāϰ āĻšā§‡āϝāĻŧ⧇ āĻĒāĻĄāĻŧāĻžāϰ (Read) āĻĒāϰāĻŋāĻŽāĻžāĻŖ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ āĻĨāĻžāϕ⧇ (āϝ⧇āĻŽāύ: āύāĻŋāωāϜ āĻ“āϝāĻŧ⧇āĻŦāϏāĻžāχāϟ āĻŦāĻž āχ-āĻ•āĻŽāĻžāĻ°ā§āϏ⧇ ā§§ āϜāύ āĻĒā§‹āĻ¸ā§āϟ āĻ•āϰ⧇ āφāϰ ā§§ā§Ļ āĻšāĻžāϜāĻžāϰ āϜāύ āϤāĻž āĻĒāĻĄāĻŧ⧇)āĨ¤

  • āϝāĻĻāĻŋ āĻŽā§‚āϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻāϏāĻŦ āĻĒāĻĄāĻŧāĻžāϰ āϚāĻžāĻĒ āĻĒāĻĄāĻŧ⧇, āϤāĻŦ⧇ āĻāϟāĻŋ āĻ¸ā§āϞ⧋ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āύāϤ⧁āύ āϰāĻžāχāϟ āĻ…āĻĒāĻžāϰ⧇āĻļāύāĻ“ āĻŦāĻžāϧāĻžāĻ—ā§āϰāĻ¸ā§āϤ āĻšāĻŦ⧇āĨ¤
  • Read replica āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϞ⧇ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϤāĻžāϰ āϏāĻŽāĻ¸ā§āϤ SELECT āϕ⧋āϝāĻŧāĻžāϰāĻŋ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻžāϝāĻŧ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤
  • āĻāϰ āĻĢāϞ⧇ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āύ⧋āĻĄāϟāĻŋ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻĄā§‡āϟāĻž āϏ⧇āĻ­ (Write) āĻ•āϰāĻžāϰ āĻ•āĻžāĻœā§‡ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻĢā§‹āĻ•āĻžāϏ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž āϰāĻžāχāϟ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻŦāĻžāĻĄāĻŧāĻžāϝāĻŧāĨ¤ āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž āĻĨāĻžāĻ•āĻžāϰ āĻ•āĻžāϰāϪ⧇ āĻšāĻžāϜāĻžāϰ āĻšāĻžāϜāĻžāϰ āχāωāϜāĻžāϰ āĻĢā§āĻ°ā§āϝāĻžāĻ•āĻļāύ-āĻ…āĻĢ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āĻĄā§‡āϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

What about eventual consistency issues?​

āϝ⧇āĻšā§‡āϤ⧁ Read Replica āϏāĻžāϧāĻžāϰāĻŖāϤ Asynchronous Replication āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϤāĻžāχ āĻāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āϏāĻŽāĻ¸ā§āϝāĻž āĻšāϞ⧋ Eventual Consistency āĻŦāĻž āĻĄā§‡āϟāĻž āĻĻ⧇āϰāĻŋāϤ⧇ āϏāĻŋāĻ™ā§āĻ• āĻšāĻ“āϝāĻŧāĻž (Replication Lag)āĨ¤

  • āϏāĻŽāĻ¸ā§āϝāĻž: āĻāĻ•āϜāύ āχāωāϜāĻžāϰ āϤāĻžāϰ āĻĒā§āϰ⧋āĻĢāĻžāχāϞ āφāĻĒāĻĄā§‡āϟ āĻ•āϰ⧇ (āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āύ⧋āĻĄā§‡) āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āϰāĻŋāĻĢā§āϰ⧇āĻļ āĻĻāĻŋāϞāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϰāĻŋāĻĢā§āϰ⧇āĻļ⧇āϰ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āϗ⧇āϞ Read Replica āϤ⧇, āϝ⧇āĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϟāĻŋ āĻāĻ–āύ⧋ āϏāĻŋāĻ™ā§āĻ• āĻšāϝāĻŧ⧇ āφāϏ⧇āύāĻŋāĨ¤ āĻĢāϞ⧇ āχāωāϜāĻžāϰ āϤāĻžāϰ āĻĒ⧁āϰ⧋āύ⧋ āĻĒā§āϰ⧋āĻĢāĻžāχāϞ āĻ›āĻŦāĻŋāχ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāĻŦ⧇āĨ¤
  • āϏāĻŽāĻžāϧāĻžāύ:
    1. Critical Reads: āĻāĻ•āĻžāωāĻ¨ā§āϟ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏ āĻšā§‡āĻ• āĻŦāĻž āχāωāϜāĻžāϰ āφāĻĒāĻĄā§‡āĻŸā§‡āϰ āϜāĻžāĻ¸ā§āϟ āĻĒāϰ⧇āϰ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟāϗ⧁āϞ⧋āϕ⧇ āĻœā§‹āϰāĻĒā§‚āĻ°ā§āĻŦāĻ• (Force) āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āύ⧋āĻĄ āĻĨ⧇āϕ⧇ āĻĒāĻĄāĻŧāϤ⧇ āĻŦāϞāĻž (Read-after-write consistency)āĨ¤
    2. āĻ•ā§āϝāĻžāĻļāĻŋāĻ‚ (Caching): āχāωāϜāĻžāϰ⧇āϰ āϏ⧇āĻļāύ āĻŦāĻž Redis āĻ āĻĄā§‡āϟāĻž āĻ•ā§āϝāĻžāĻļ āĻ•āϰ⧇ āϰāĻžāĻ–āĻž, āϝāĻžāϤ⧇ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž āφāĻĒāĻĄā§‡āϟ āĻšāĻ“āϝāĻŧāĻžāϰ āφāĻ— āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ•ā§āϝāĻžāĻļ āĻĨ⧇āϕ⧇ āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤

105. What is load balancing for databases?​

Load Balancing āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻž, āϝāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āφāĻ—āϤ āĻŸā§āϰāĻžāĻĢāĻŋāĻ•āϕ⧇ (āϕ⧁āϝāĻŧ⧇āϰāĻŋ āĻŦāĻž āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ) āĻāĻ•āĻžāϧāĻŋāĻ• āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϏ⧁āώāĻŽāĻ­āĻžāĻŦ⧇ āĻŦāĻ¨ā§āϟāύ (Distribute) āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻāϰ āĻĢāϞ⧇ āϕ⧋āύ⧋ āĻāĻ•āĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻ“āĻĒāϰ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āϚāĻžāĻĒ āĻĒāĻĄāĻŧ⧇ āύāĻž āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāĻžāϰ āϏāĻŽā§āĻ­āĻžāĻŦāύāĻž āĻ…āύ⧇āĻ• āĻ•āĻŽā§‡ āϝāĻžāϝāĻŧāĨ¤

Technical definition: Database load balancing is the seamless distribution of incoming client connections and query requests across a cluster of database instances to maximize throughput, minimize latency, and ensure high availability.

How do you distribute read and write operations?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰāϗ⧁āϞ⧋ (āϝ⧇āĻŽāύ: ProxySQL, PgBouncer, HAProxy) āĻŸā§āϰāĻžāĻĢāĻŋāĻ• ëļ„ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ āĻ¸ā§āĻŽāĻžāĻ°ā§āϟ āĻŽā§‡āĻ•āĻžāύāĻŋāϜāĻŽ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϝāĻžāϕ⧇ Read/Write Splitting āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤

  • āϰāĻžāχāϟ āĻ¸ā§āĻĒā§āϞāĻŋāϟāĻŋāĻ‚ (Write Routing): āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰ āĻāϏāĻ•āĻŋāωāĻāϞ (SQL) āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻĒāĻĄāĻŧ⧇ āĻŦ⧁āĻāϤ⧇ āĻĒāĻžāϰ⧇ āĻāϟāĻŋ INSERT, UPDATE āĻŦāĻž DELETE āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻ•āĻŋ āύāĻžāĨ¤ āϝāĻĻāĻŋ āĻšāϝāĻŧ, āϤāĻŦ⧇ āϏ⧇ āĻāϟāĻŋāϕ⧇ āϏāϰāĻžāϏāϰāĻŋ āĻļ⧁āϧ⧁ Master āĻŦāĻž Primary Node āĻ āĻĒāĻžāĻ āĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤
  • āϰāĻŋāĻĄ āĻ¸ā§āĻĒā§āϞāĻŋāϟāĻŋāĻ‚ (Read Routing): āϝāĻĻāĻŋ āĻāϟāĻŋ SELECT āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻšāϝāĻŧ, āϤāĻŦ⧇ āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰ Round-Robin āĻŦāĻž Least-Connections āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽā§‡āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāϟāĻŋāϕ⧇ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ Read Replicas āĻŦāĻž Secondary Nodes āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ­āĻžāĻ— āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĨ¤

What is connection pooling at load balancer level?​

āĻāĻ•āϟāĻŋ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϤ⧈āϰāĻŋ āĻ•āϰāĻž (Authentication āĻāĻŦāĻ‚ Memory allocation) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϜāĻ¨ā§āϝ āĻ…āύ⧇āĻ• āĻ–āϰ⧁āĻšā§‡ (Expensive) āĻ•āĻžāϜāĨ¤

  • Connection Pooling: āϝāĻ–āύ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϛ⧇āĻĄāĻŧ⧇ āĻĻ⧇āϝāĻŧ, āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰ āϏ⧇āχ āĻ•āĻžāύ⧇āĻ•āĻļāύāϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻŦāĻ¨ā§āϧ āύāĻž āĻ•āϰ⧇ "āĻĒ⧁āϞ" (Pool) āĻŦāĻž āϰāĻŋāϜāĻžāĻ°ā§āϭ⧇ āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧāĨ¤
  • āĻāϰāĻĒāϰ āύāϤ⧁āύ āϕ⧇āω āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āĻ•āϰāϞ⧇ āϤāĻžāϕ⧇ āφāϗ⧇āϰ āϏ⧇āχ āϰ⧇āĻĄāĻŋāĻŽā§‡āĻĄ āĻ•āĻžāύ⧇āĻ•āĻļāύāϟāĻŋ āϧāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϤ⧇ āĻŦāĻžāϰāĻŦāĻžāϰ āĻ•āĻžāύ⧇āĻ•āĻļāύ āĻ–ā§‹āϞāĻž āĻāĻŦāĻ‚ āĻŦāĻ¨ā§āϧ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧāϟ⧁āϕ⧁ āĻŦ⧇āρāĻšā§‡ āϝāĻžāϝāĻŧ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻšāĻžāϜāĻžāϰ āĻšāĻžāϜāĻžāϰ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āύāĻŋāĻŽāĻŋāώ⧇āχ āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

106. What is failover and failback?​

Failover āĻāĻŦāĻ‚ Failback āĻšāϞ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āχāĻŽāĻžāĻ°ā§āĻœā§‡āĻ¨ā§āϏāĻŋ āϰ⧇āϏāĻ•āĻŋāω āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāĨ¤

Failover: āĻāϟāĻŋ āĻšāϞ⧋ āĻŽā§‚āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ (Primary) āϕ⧋āύ⧋ āĻ•āĻžāϰāϪ⧇ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāϞ⧇ āĻŦāĻž āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϗ⧇āϞ⧇, āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧāĻ­āĻžāĻŦ⧇ āĻŦāĻž āĻŽā§āϝāĻžāύ⧁āϝāĻŧāĻžāϞāĻŋ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āϏāĻŽāĻ¸ā§āϤ āĻĻāĻžāϝāĻŧāĻŋāĻ¤ā§āĻŦ āĻāĻŦāĻ‚ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄāĻžāϰāĻŋ āĻŦāĻž āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻŦāĻžāχ (Standby) āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻļāĻŋāĻĢāϟ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: āĻœā§‡āύāĻžāϰ⧇āϟāϰ āϚāĻžāϞ⧁ āĻšāĻ“āϝāĻŧāĻžāϰ āĻŽāϤ⧋āĨ¤ āĻŦāĻŋāĻĻā§āĻ¯ā§ā§Ž (Primary) āϚāϞ⧇ āϗ⧇āϞ⧇ āĻœā§‡āύāĻžāϰ⧇āϟāϰ (Secondary) āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧāĻ­āĻžāĻŦ⧇ āϚāĻžāϞ⧁ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

Failback: āĻāϟāĻŋ āĻšāϞ⧋ āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻŽā§‚āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰāϟāĻŋ āφāĻŦāĻžāϰ āĻŽā§‡āϰāĻžāĻŽāϤ āĻŦāĻž āϰāĻŋāĻ•āĻ­āĻžāϰ āĻ•āϰāĻžāϰ āĻĒāϰ, āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĨ⧇āϕ⧇ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āĻāĻŦāĻ‚ āĻĻāĻžāϝāĻŧāĻŋāĻ¤ā§āĻŦāϗ⧁āϞ⧋ āĻĒā§‚āĻ°ā§āĻŦ⧇āϰ āĻŽā§‚āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āφāĻŦāĻžāϰ āĻĢāĻŋāϰāĻŋāϝāĻŧ⧇ āφāύāĻžāϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: āĻŦāĻŋāĻĻā§āĻ¯ā§ā§Ž āĻĢāĻŋāϰ⧇ āφāϏāĻžāϰ āĻĒāϰ āĻœā§‡āύāĻžāϰ⧇āϟāϰ āĻŦāĻ¨ā§āϧ āĻšāϝāĻŧ⧇ āφāĻŦāĻžāϰ āĻŦāĻŋāĻĻā§āϝ⧁āϤ⧇ āϞāĻžāχāύ āϚāϞ⧇ āϝāĻžāĻ“āϝāĻŧāĻžāĨ¤

How does automatic failover work?​

  • āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇ āĻĨāĻžāĻ•āĻž āύ⧋āĻĄāϗ⧁āϞ⧋ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϏāĻžāĻĨ⧇ Heartbeat Monitoring āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āύāϜāϰāĻĻāĻžāϰāĻŋ āϰāĻžāϖ⧇āĨ¤
  • āĻāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻāĻ•āϟāĻŋ āĻĨāĻžāĻ°ā§āĻĄ-āĻĒāĻžāĻ°ā§āϟāĻŋ āϟ⧁āϞ (āϝ⧇āĻŽāύ: MHA For MySQL, Patroni for PostgreSQL) āĻĨāĻžāϕ⧇ āϝāĻžāϕ⧇ "Witness" āĻŦāĻž āĻĒāĻ°ā§āϝāĻŦ⧇āĻ•ā§āώāĻ• āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤
  • āϝāĻ–āύ Primary āύ⧋āĻĄāϟāĻŋ āĻĄāĻžāωāύ āĻšāϝāĻŧ, āωāχāϟāύ⧇āϏ āύ⧋āĻĄ āϤāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇āĨ¤ āĻāϰāĻĒāϰ āϏ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āφāĻĒ-āϟ⧁-āĻĄā§‡āϟ Secondary āύ⧋āĻĄāϟāĻŋāϕ⧇ āĻĒā§āϰāĻŽā§‹āĻļāύ āĻĻāĻŋāϝāĻŧ⧇ (Promote) āύāϤ⧁āύ Primary āĻŦāĻžāύāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ āĻāĻŦāĻ‚ āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇āϰ āϏāĻŽāĻ¸ā§āϤ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āύāϤ⧁āύ Primary āϤ⧇ āϘ⧁āϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤

What is split-brain problem?​

Split-brain āĻšāϞ⧋ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āĻāĻ•āϟāĻŋ āϚāϰāĻŽ āĻŦāĻŋāĻ­ā§€āώāĻŋāĻ•āĻžāĻŽā§Ÿ āĻĒāϰāĻŋāĻ¸ā§āĻĨāĻŋāϤāĻŋ (Disastrous state)āĨ¤

  • āϕ⧀āĻ­āĻžāĻŦ⧇ āĻšāϝāĻŧ? āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āĻĻ⧁āϟāĻŋ āύ⧋āĻĄ (Master āĻāĻŦāĻ‚ Standby) āĻŦ⧇āρāĻšā§‡ āĻĨāĻžāϕ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϤāĻžāĻĻ⧇āϰ āĻŽāĻ§ā§āϝāĻ•āĻžāϰ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϕ⧇āĻŦāϞāϟāĻŋ āĻ›āĻŋāρāĻĄāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āϤāĻ–āύ Standby āύ⧋āĻĄ āĻ­āĻžāĻŦ⧇ āϝ⧇ Master āĻŽāĻžāϰāĻž āϗ⧇āϛ⧇, āĻāĻŦāĻ‚ āϏ⧇ āύāĻŋāĻœā§‡āϕ⧇ āύāϤ⧁āύ Master āĻ˜ā§‹āώāĻŖāĻž āĻ•āϰ⧇ āĻ•āĻžāϜ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āφāϏāϞ Master āϤ⧋ āϤāĻ–āύ⧋ āĻœā§āϝāĻžāĻ¨ā§āϤ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āϏ⧇āĻ“ āχāωāϜāĻžāϰ⧇āϰ āϰāĻžāχāϟ āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻāĻ•ā§āϏ⧇āĻĒā§āϟ āĻ•āϰāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤
  • āϏāĻŽāĻ¸ā§āϝāĻž: āϤāĻ–āύ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āĻāĻ•āχāϏāĻžāĻĨ⧇ āĻĻ⧁āϟāĻŋ Master āϤ⧈āϰāĻŋ āĻšāϝāĻŧ⧇ āĻ¸ā§āĻŦāĻžāϧ⧀āύāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇, āϝāĻž āĻĄā§‡āϟāĻžāϕ⧇ āϚāϰāĻŽāĻ­āĻžāĻŦ⧇ āĻ•āϰāĻžāĻĒā§āϟ āĻŦāĻž āĻ•āύāĻĢā§āϞāĻŋāĻ•ā§āϟ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ (āĻ•āĻžāϰ āĻĄā§‡āϟāĻž āϏāĻ āĻŋāĻ•, āϤāĻž āφāϰ āĻŽā§‡āϞāĻžāύ⧋ āϝāĻžāϝāĻŧ āύāĻž)āĨ¤
  • āϏāĻŽāĻžāϧāĻžāύ: āĻāϟāĻŋ āĻāĻĄāĻŧāĻžāϤ⧇ "Quorum" āĻŦāĻž āĻŦāĻŋāĻœā§‹āĻĄāĻŧ āϏāĻ‚āĻ–ā§āϝāĻ• (ā§Š āĻŦāĻž ā§Ģ āϟāĻŋ) āύ⧋āĻĄ āϰāĻžāĻ–āĻž āĻšāϝāĻŧāĨ¤ āϝ⧇āĻĻāĻŋāϕ⧇ āĻŦ⧇āĻļāĻŋ āύ⧋āĻĄ āĻĨāĻžāϕ⧇, āĻļ⧁āϧ⧁ āϤāĻžāϰāĻžāχ Master āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻŦāĻžāĻ•āĻŋāĻĻ⧇āϰ "Fencing" āĻŦāĻž āϗ⧁āϞāĻŋ āĻ•āϰ⧇ āĻŽāĻžāϰāĻž (STONITH - Shoot The Other Node In The Head) āĻšāϝāĻŧ, āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻĒāĻžāĻ“āϝāĻŧāĻžāϰ āĻ…āĻĢ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤

107. What is disaster recovery (DR)?​

Disaster Recovery (DR) āĻšāϞ⧋ āĻāĻ•āϟāĻŋ āĻĒā§‚āĻ°ā§āĻŦ-āĻĒāϰāĻŋāĻ•āĻ˛ā§āĻĒāĻŋāϤ āĻ¸ā§āĻŸā§āĻ°ā§āϝāĻžāĻŸā§‡āϜāĻŋāĨ¤ āĻāϟāĻŋ āĻĒā§āϰāĻžāĻ•ā§ƒāϤāĻŋāĻ• āĻĻ⧁āĻ°ā§āϝ⧋āĻ— (āĻ­ā§‚āĻŽāĻŋāĻ•āĻŽā§āĻĒ, āφāϗ⧁āύ), āϏāĻžāχāĻŦāĻžāϰ āĻ…ā§āϝāĻžāϟāĻžāĻ• (Ransomware), āĻŦāĻž āĻŦāĻĄāĻŧ āϕ⧋āύ⧋ āĻŸā§‡āĻ•āύāĻŋāĻ•ā§āϝāĻžāϞ āϏāĻŽāĻ¸ā§āϝāĻžāϰ āĻ•āĻžāϰāϪ⧇ āĻĒ⧁āϰ⧋ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ āĻ§ā§āĻŦāĻ‚āϏ āĻŦāĻž āĻ…āĻĢāϞāĻžāχāύ āĻšāϝāĻŧ⧇ āϗ⧇āϞ⧇, āϕ⧀āĻ­āĻžāĻŦ⧇ āĻŽā§‚āϞ āĻŦā§āϝāĻŦāϏāĻžāϝāĻŧāĻŋāĻ• āĻ•āĻžāĻ°ā§āϝāĻ•ā§āϰāĻŽ (IT infrastructure) āĻĻā§āϰ⧁āϤ āϰāĻŋāĻ•āĻ­āĻžāϰ āĻŦāĻž āĻĒ⧁āύāϰ⧁āĻĻā§āϧāĻžāϰ āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϤāĻžāϰ āϰ⧋āĻĄāĻŽā§āϝāĻžāĻĒāĨ¤

High Availability (HA) āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĄāĻžāωāύ āĻšāϞ⧇ āĻŦāĻžāρāϚāĻžāϝāĻŧ, DR āϏ⧇āĻ–āĻžāύ⧇ āĻĒ⧁āϰ⧋ āĻĄā§‡āϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ āĻĄāĻžāωāύ āĻšāϞ⧇ āĻŦāĻžāρāϚāĻžāϰ āĻĒāĻĨ āĻĻ⧇āĻ–āĻžāϝāĻŧāĨ¤

Technical definition: Disaster recovery involves a set of policies, tools, and procedures to enable the recovery or continuation of vital technology infrastructure and systems following a natural or human-induced disaster.

Difference between RPO and RTO?​

āĻĄāĻŋāϜāĻžāĻ¸ā§āϟāĻžāϰ āϰāĻŋāĻ•āĻ­āĻžāϰāĻŋāϰ āĻĻ⧁āϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻĒā§āϝāĻžāϰāĻžāĻŽāĻŋāϟāĻžāϰ āĻšāϞ⧋ RPO āĻāĻŦāĻ‚ RTO:

MetricRecovery Point Objective (RPO)Recovery Time Objective (RTO)
āϏāϰāϞ āĻ…āĻ°ā§āĻĨāφāĻĒāύāĻŋ āĻ•āϤāϟ⧁āϕ⧁ āĻĄā§‡āϟāĻž āĻšāĻžāϰāĻžāύ⧋ āĻŽā§‡āύ⧇ āύāĻŋāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āύ?āϏāĻžāĻ°ā§āĻ­āĻŋāϏ āĻĄāĻžāωāύ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰ āĻ•āϤ āϏāĻŽāϝāĻŧ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āφāĻĒāύāĻžāϕ⧇ āφāĻŦāĻžāϰ āĻ…āύāϞāĻžāχāύ⧇ āĻĢāĻŋāϰ⧇ āφāϏāϤ⧇ āĻšāĻŦ⧇?
āĻĢā§‹āĻ•āĻžāϏData-loss āĻŦāĻž āĻĄā§‡āϟāĻžāϰ āĻŦā§āϝāĻžāĻ•āφāĻĒ. (āϝ⧇āĻŽāύ: ā§§ āϘāĻŖā§āϟāĻž āφāϗ⧇āϰ āĻĄā§‡āϟāĻž āĻšāϞ⧇āχ āĻšāĻŦ⧇)āĨ¤Downtime āĻŦāĻž āϏāĻŽāϝāĻŧ⧇āϰ āĻšāĻŋāϏāĻžāĻŦ. (āϝ⧇āĻŽāύ: ā§§ā§Ļ āĻŽāĻŋāύāĻŋāĻŸā§‡āϰ āĻŽāĻ§ā§āϝ⧇āχ āĻ“āϝāĻŧ⧇āĻŦāϏāĻžāχāϟ āϞāĻžāχāĻ­ āĻšāϤ⧇ āĻšāĻŦ⧇)āĨ¤
āĻĒāϰāĻŋāĻŽāĻžāĻĒāĻāϟāĻŋ āĻŽāĻžāĻĒāĻž āĻšāϝāĻŧ āĻ…āϤ⧀āϤ āĻŦāĻž āĻĒāĻžāĻ¸ā§āϟ āϟāĻžāχāĻŽ āĻĻāĻŋāϝāĻŧ⧇ (Past)āĨ¤āĻāϟāĻŋ āĻŽāĻžāĻĒāĻž āĻšāϝāĻŧ āĻ­āĻŦāĻŋāĻˇā§āĻ¯ā§Ž āĻŦāĻž āĻĢāĻŋāωāϚāĻžāϰ āϟāĻžāχāĻŽ āĻĻāĻŋāϝāĻŧ⧇ (Future)āĨ¤
āωāĻĻāĻžāĻšāϰāĻŖāϰāĻžāϤ ⧧⧍ āϟāĻžāϝāĻŧ āĻŦā§āϝāĻžāĻ•āφāĻĒ āύ⧇āϝāĻŧāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āϏāĻ•āĻžāϞ ā§§ā§Ļ āϟāĻžāϝāĻŧ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāϞ⧋āĨ¤ āφāĻĒāύāĻžāϰ ā§§ā§Ļ āϘāĻŖā§āϟāĻžāϰ āĻĄā§‡āϟāĻž āĻšāĻžāϰāĻŋāϝāĻŧ⧇ āϗ⧇āϞ (RPO= 10 hrs)āĨ¤āϏāĻ•āĻžāϞ ā§§ā§Ļ āϟāĻžāϝāĻŧ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāĻžāϰ āĻĒāϰ āĻĻ⧁āĻĒ⧁āϰ ⧧⧍ āϟāĻžāϝāĻŧ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āϞāĻžāχāĻ­ āĻšāϞ⧋ (RTO= 2 hrs)āĨ¤

What is cold, warm, and hot DR site?​

āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ āϰāĻŋāĻ•āĻ­āĻžāϰāĻŋāϰ āϜāĻ¨ā§āϝ āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋāϗ⧁āϞ⧋ āϏāĻžāϧāĻžāϰāĻŖāϤ ā§Š āϧāϰāύ⧇āϰ āĻŦāĻŋāĻ•āĻ˛ā§āĻĒ āϏāĻžāχāϟ āĻŦāĻž āĻŦā§āϝāĻžāĻ•āφāĻĒ āϏ⧇āĻ¨ā§āϟāĻžāϰ āĻ­āĻžāĻĄāĻŧāĻž āύ⧇āϝāĻŧ:

ā§§. Cold Site: āĻāϟāĻŋ āĻļ⧁āϧ⧁ āĻāĻ•āϟāĻŋ āĻĢāĻžāρāĻ•āĻž āϜāĻžāϝāĻŧāĻ—āĻž āĻŦāĻž āĻŦāĻŋāĻ˛ā§āĻĄāĻŋāĻ‚, āϝ⧇āĻ–āĻžāύ⧇ āχāĻ¨ā§āϟāĻžāϰāύ⧇āϟ āĻāĻŦāĻ‚ āĻŦāĻŋāĻĻā§āϝ⧁āϤ⧇āϰ āϞāĻžāχāύ āϟāĻžāύāĻž āĻĨāĻžāϕ⧇āĨ¤ āĻĻ⧁āĻ°ā§āϝ⧋āĻ— āĻšāϞ⧇ āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋāϕ⧇ āύāϤ⧁āύ āĻ•āϰ⧇ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻ•āĻŋāύ⧇, āϏ⧇āϟāφāĻĒ āĻ•āϰ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤

  • āĻ–āϰāϚ: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϏāĻ¸ā§āϤāĻžāĨ¤
  • RTO: āĻ•āϝāĻŧ⧇āĻ• āĻĻāĻŋāύ āĻĨ⧇āϕ⧇ āĻ•āϝāĻŧ⧇āĻ• āϏāĻĒā§āϤāĻžāĻš āϞāĻžāĻ—āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

⧍. Warm Site: āĻāĻ–āĻžāύ⧇ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻāĻŦāĻ‚ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϰ⧇āĻĄāĻŋ āĻ•āϰāĻž āĻĨāĻžāϕ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϗ⧁āϞ⧋ āϞāĻžāχāĻ­ āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻĨ⧇ āϏāĻŋāĻ™ā§āĻ• āĻ•āϰāĻž āĻĨāĻžāϕ⧇ āύāĻžāĨ¤ āĻĻ⧁āĻ°ā§āϝ⧋āĻ— āĻšāϞ⧇ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻĢāĻžāχāϞāϟāĻŋ āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāϞ⧇āχ āĻ•āĻžāϜ āĻļ⧁āϰ⧁ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤

  • āĻ–āϰāϚ: āĻŽāĻžāĻāĻžāϰāĻŋāĨ¤
  • RTO: āĻ•āϝāĻŧ⧇āĻ• āϘāĻŖā§āϟāĻž āĻĨ⧇āϕ⧇ ā§§/⧍ āĻĻāĻŋāύāĨ¤

ā§Š. Hot Site: āĻāϟāĻŋ āĻŽā§‚āϞ āĻĄāĻžāϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ⧇āϰ āĻāĻ•āĻĻāĻŽ āĻšā§āĻŦāĻšā§ āϞāĻžāχāĻ­ āĻŽāĻŋāϰāϰ (Mirror)āĨ¤ āĻāĻ–āĻžāύ⧇ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϰ⧇āĻĄāĻŋ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻŽā§‚āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻĨ⧇ āϰāĻŋāϝāĻŧ⧇āϞ-āϟāĻžāχāĻŽ āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϚāϞāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

  • āĻ–āϰāϚ: āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞāĨ¤
  • RTO: āĻĢā§āĻ°ā§āϝāĻžāĻ•āĻļāύ-āĻ…āĻĢ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āĻĨ⧇āϕ⧇ āĻ•āϝāĻŧ⧇āĻ• āĻŽāĻŋāύāĻŋāϟ (āĻĒā§āϰāĻžāϝāĻŧ āϜāĻŋāϰ⧋ āĻĄāĻžāωāύāϟāĻžāχāĻŽ)āĨ¤

108. What is database federation?​

Database Federation (āĻŦāĻž Federated Database System) āĻšāϞ⧋ āĻāĻ•āĻžāϧāĻŋāĻ• āφāϞāĻžāĻĻāĻž āĻ“ āĻ¸ā§āĻŦāĻžāϧ⧀āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻāĻ•āĻ¤ā§āϰ⧇ āϝ⧁āĻ•ā§āϤ āĻ•āϰ⧇ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻ­āĻžāĻ°ā§āϚ⧁āϝāĻŧāĻžāϞ āϞ⧇āϝāĻŧāĻžāϰ āϤ⧈āϰāĻŋ āĻ•āϰāĻž, āϝ⧇āύ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦāĻž āχāωāϜāĻžāϰ⧇āϰ āĻ•āĻžāϛ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ āϤāĻžāϰāĻž āĻāĻ•āϟāĻŋāĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻļāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž āύāĻŋāĻšā§āϛ⧇āĨ¤

āĻāĻ–āĻžāύ⧇ āφāϏāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋ (āϝ⧇āϗ⧁āϞ⧋ āĻ­āĻŋāĻ¨ā§āύ āϭ⧇āĻ¨ā§āĻĄāϰ āϝ⧇āĻŽāύ: āĻāĻ•āϟāĻŋ Oracle, āφāϰ⧇āĻ•āϟāĻŋ PostgreSQL āĻšāϤ⧇ āĻĒāĻžāϰ⧇) āϤāĻžāĻĻ⧇āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻ¸ā§āĻŦāĻžāϝāĻŧāĻ¤ā§āϤāĻļāĻžāϏāύ (Autonomy) āĻŦāϜāĻžāϝāĻŧ āϰāĻžāϖ⧇, āĻ…āĻ°ā§āĻĨāĻžā§Ž āϤāĻžāϰāĻž āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāϤ⧋ āĻ¸ā§āĻŦāĻžāϧ⧀āύāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Technical definition: A federated database system is a type of meta-database management system (DBMS), which transparently maps multiple autonomous database systems into a single federated database keeping the local autonomy intact.

When would you use federated databases?​

ā§§. āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋ āĻ•āĻŋāύ⧇ āύāĻŋāϞ⧇ (Mergers & Acquisitions): āϧāϰāĻž āϝāĻžāĻ• āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋ A (āϝāĻžāϰāĻž MySQL āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇), āϤāĻžāϰāĻž āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋ B (āϝāĻžāϰāĻž Oracle āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇) āϕ⧇ āĻ•āĻŋāύ⧇ āύāĻŋāϞāĨ¤ āĻāĻ–āύ āĻĻ⧁āχ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŽāĻŋāĻļāĻŋāϝāĻŧ⧇ āĻĢ⧇āϞāϤ⧇ āĻ•āϝāĻŧ⧇āĻ• āĻŦāĻ›āϰ āϞāĻžāĻ—āĻŦ⧇āĨ¤ āϤāĻžāϰ āĻŦāĻĻāϞ⧇ āĻĢ⧇āĻĄāĻžāϰ⧇āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĻ⧁āϟāĻŋāϰ āĻ“āĻĒāϰ āĻāĻ•āϟāĻŋ āĻ•āĻŽāύ āϞ⧇āϝāĻŧāĻžāϰ āĻŦāϏāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āϚāĻžāϞāĻžāύ⧋ āϏāĻšāϜāĨ¤

⧍. āĻĄāĻžāϟāĻž āĻļ⧇āϝāĻŧāĻžāϰāĻŋāĻ‚ āĻ“ āĻāύāĻžāϞāĻžāχāϟāĻŋāĻ•ā§āϏ (Cross-organization sharing): āĻāĻ•āϟāĻŋ āĻšāĻžāϏāĻĒāĻžāϤāĻžāϞ⧇āϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ, āĻĒ⧁āϞāĻŋāĻļ⧇āϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻāĻŦāĻ‚ āχāύāĻ¸ā§āϝ⧁āϰ⧇āĻ¨ā§āϏ āϕ⧋āĻŽā§āĻĒāĻžāύāĻŋāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻ¸ā§āĻŦāĻžāϧ⧀āύ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĢ⧇āĻĄāĻžāϰ⧇āĻļāύ āϞ⧇āϝāĻŧāĻžāϰ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāϰāĻ•āĻžāϰ āĻāĻ• āϜāĻžāϝāĻŧāĻ—āĻž āĻĨ⧇āϕ⧇ āĻāχ āϤāĻŋāύāϟāĻžāϰ āϰāĻŋāĻĒā§‹āĻ°ā§āϟ āĻœā§‡āύāĻžāϰ⧇āϟ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

ā§Š. āϞāĻŋāĻ—ā§āϝāĻžāϏāĻŋ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻāĻ•ā§āϏ⧇āϏ (Legacy Systems): āĻĒ⧁āϰ⧋āύ⧋ āĻĻāĻŋāύ⧇āϰ āĻŽā§‡āχāύāĻĢā§āϰ⧇āĻŽ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻžāĻĨ⧇ āύāϤ⧁āύ 클ëŧėš°ā˛Ąāŗ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻ•āĻžāύ⧇āĻ•ā§āϟ āĻ•āϰāϤ⧇āĨ¤

Challenges with federated queries?​

  • āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āχāĻ¸ā§āϝ⧁: āĻāĻ•āϟāĻŋ āĻĢ⧇āĻĄāĻžāϰ⧇āĻŸā§‡āĻĄ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϕ⧇āω āĻšāϝāĻŧāϤ⧋ āϖ⧁āĻŦ āĻ¸ā§āϞ⧋, āĻ…āĻĨāĻŦāĻž āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϞ⧇āĻŸā§‡āĻ¨ā§āϏāĻŋ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋāĨ¤ āĻĢāϞ⧇ āĻāĻ•āϟāĻŋ āϰ⧇āϜāĻžāĻ˛ā§āϟ āφāϏāϤ⧇ āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āϞāĻžāϗ⧇āĨ¤
  • āϜāϟāĻŋāϞ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻ…āĻĒā§āϟāĻŋāĻŽāĻžāχāĻœā§‡āĻļāύ: āĻĻ⧁āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āχāĻžā§āϜāĻŋāύ (āϝ⧇āĻŽāύ MySQL āĻāĻŦāĻ‚ SQL Server) āĻāϰ āĻŽāĻ§ā§āϝ⧇ JOIN āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻ•āϰāĻž āϖ⧁āĻŦāχ āϜāϟāĻŋāϞ āĻāĻŦāĻ‚ āĻŦā§āϝāϝāĻŧāĻŦāĻšā§āϞ (Expensive)āĨ¤
  • āϏāĻŋāĻ•āĻŋāωāϰāĻŋāϟāĻŋ āĻāĻŦāĻ‚ āĻĒāĻžāϰāĻŽāĻŋāĻļāύ: āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻŋāĻ•āĻŋāωāϰāĻŋāϟāĻŋ āϞ⧇āϭ⧇āϞ āφāϞāĻžāĻĻāĻžāĨ¤ āϏ⧇āϗ⧁āϞ⧋ āĻāĻ•āϟāĻŋ āĻ•āĻŽāύ āϞ⧇āϝāĻŧāĻžāϰ āĻĻāĻŋāϝāĻŧ⧇ āĻŽā§āϝāĻžāύ⧇āϜ āĻ•āϰāĻž āĻ•āĻ āĻŋāύāĨ¤

109. What is multi-master replication?​

Multi-Master Replication (āϝāĻžāϕ⧇ Active-Active Replication āĻ“ āĻŦāϞāĻž āĻšāϝāĻŧ) āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ, āϝ⧇āĻ–āĻžāύ⧇ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āĻļ⧁āϧ⧁ āĻāĻ•āϟāĻŋ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āύāϝāĻŧ, āĻŦāϰāĻ‚ āĻāĻ•āĻžāϧāĻŋāĻ• (āĻŦāĻž āĻĒā§āϰāϤāĻŋāϟāĻŋ) āύ⧋āĻĄāχ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āφāϚāϰāĻŖ āĻ•āϰ⧇āĨ¤

āĻāϰ āĻŽāĻžāύ⧇ āĻšāϞ⧋, āφāĻĒāύāĻžāϰ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇āϰ āϏāĻŦ āχāωāϜāĻžāϰ āϝ⧇āϕ⧋āύ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύ⧋āĻĄā§‡ āĻĄā§‡āϟāĻž Read āĻāĻŦāĻ‚ Write (Insert/Update) āωāĻ­āϝāĻŧ āĻ•āĻžāϜāχ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤ āĻāϰāĻĒāϰ āĻŽāĻžāĻ¸ā§āϟāĻžāϰāϗ⧁āϞ⧋ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻĄā§‡āϟāĻž āφāĻĻāĻžāύ-āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇ āϏāĻŋāĻ™ā§āĻ• āĻ•āϰ⧇ āύ⧇āϝāĻŧāĨ¤

Technical definition: Multi-master replication is a method of database replication which allows data to be stored by a group of computers, and updated by any member of the group. All members are responsive to client data queries and updates, effectively operating as masters.

How do you handle write conflicts?​

āĻŽāĻžāĻ˛ā§āϟāĻŋ-āĻŽāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āĻŦāĻŋāĻ­ā§€āώāĻŋāĻ•āĻž āĻšāϞ⧋ Write ConflictāĨ¤ āϝ⧇āĻšā§‡āϤ⧁ āĻāĻ•āĻžāϧāĻŋāĻ• āύ⧋āĻĄā§‡ āϰāĻžāχāϟ āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϤāĻžāχ āĻāĻŽāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻ—ā§āϞ⧋āĻŦāĻžāϞ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āχāωāϜāĻžāϰ A āφāĻŽā§‡āϰāĻŋāĻ•āĻžāϰ āύ⧋āĻĄā§‡ "row_5" āφāĻĒāĻĄā§‡āϟ āĻ•āϰāϞ⧋, āĻāĻŦāĻ‚ āĻāĻ•āχ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āχāωāϜāĻžāϰ B āϏāĻŋāĻ™ā§āĻ—āĻžāĻĒ⧁āϰ⧇āϰ āύ⧋āĻĄā§‡ "row_5" āφāĻĒāĻĄā§‡āϟ āĻ•āϰāϞ⧋āĨ¤ āĻāĻ–āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•āĻžāϰ āφāĻĒāĻĄā§‡āϟāϟāĻž āĻ—ā§āϰāĻšāĻŖ āĻ•āϰāĻŦ⧇?

āĻāϗ⧁āϞ⧋ āϏāĻžāĻŽāϞāĻžāϤ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻŋāĻšā§‡āϰ āĻĒāĻĻā§āϧāϤāĻŋāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ:

  1. Last-Writer-Wins (LWW): āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻĨ⧇ Timestamp āĻŦāĻž āϘāĻĄāĻŧāĻŋāϰ āϏāĻŽāϝāĻŧ āϏ⧇āĻ­ āĻ•āϰāĻž āĻĨāĻžāϕ⧇āĨ¤ āϝāĻžāϰ āφāĻĒāĻĄā§‡āϟāϟāĻŋ (āĻŽāĻŋāϞāĻŋ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡) āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒāĻĄāĻŧ⧇ āĻŦāĻž āϞ⧇āĻŸā§‡ āĻšāϝāĻŧ⧇āϛ⧇, āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻļ⧁āϧ⧁ āϤāĻžāϰāϟāĻžāχ āϰāĻžāϖ⧇ āĻāĻŦāĻ‚ āφāϗ⧇āϰāϟāĻž āĻŽā§āϛ⧇ āĻĻ⧇āϝāĻŧāĨ¤ (Cassandra āĻāϟāĻŋ āĻŦā§āϝāĻžāĻĒāĻ•āĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇)āĨ¤
  2. Conflict-Free Replicated Data Types (CRDT): āĻāϟāĻŋ āĻāĻ• āĻĒā§āϰāĻ•āĻžāϰ āĻŽā§āϝāĻžāĻĨāĻŽā§‡āϟāĻŋāĻ•āĻžāϞ āĻ…ā§āϝāĻžāϞāĻ—āϰāĻŋāĻĻāĻŽ, āϝāĻž āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇ āϝ⧇ āϏāĻŋāϰāĻŋāϝāĻŧāĻžāϞ āĻŽā§‡āχāύāĻŸā§‡āχāύ āύāĻž āĻ•āϰ⧇ āĻĄā§‡āϟāĻž āϏāĻŋāĻ™ā§āĻ• āĻ•āϰāϞ⧇āĻ“, āϏāĻŦ āύ⧋āĻĄā§‡āϰ āĻ•ā§āϝāĻžāϞāϕ⧁āϞ⧇āĻļāύ āĻļ⧇āώ⧇ āϰ⧇āϜāĻžāĻ˛ā§āϟ āϏāĻŽāĻžāύ āĻšāĻŦ⧇āĨ¤ (āϝ⧇āĻŽāύ: āĻļāĻĒāĻŋāĻ‚ āĻ•āĻžāĻ°ā§āϟ āφāχāĻŸā§‡āĻŽ āĻ•āĻžāωāĻ¨ā§āϟāĻžāϰ)āĨ¤
  3. Application Level Resolution: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύāĻŋāĻœā§‡ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύāĻž āύāĻŋāϝāĻŧ⧇, āĻĻ⧁āϟāĻŋ āĻ­āĻžāĻ°ā§āϏāύāχ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇ āĻĒāĻžāĻ āĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ āĻāĻŦāĻ‚ āĻĄā§‡āϭ⧇āϞāĻĒāĻžāϰ āϕ⧋āĻĄā§‡āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āϝāĻŧ āϕ⧋āύāϟāĻŋ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

Examples of databases supporting multi-master?​

  • NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋ āĻāϤ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒāĻžāϰāĻĻāĻ°ā§āĻļā§€: Apache Cassandra, Amazon DynamoDB, CouchDB, Riak.
  • SQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋āϤ⧇āĻ“ āĻāϟāĻŋ āϏāĻŽā§āĻ­āĻŦ: MySQL Group Replication (Galera Cluster), PostgreSQL (BDR - Bi-Directional Replication).

110. What is distributed database?​

Distributed Database āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϝāĻž āϕ⧋āύ⧋ āϏāĻŋāĻ™ā§āϗ⧇āϞ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ āĻŦāĻž āĻŽā§‡āĻļāĻŋāύ⧇ āφāĻŦāĻĻā§āϧ āĻĨāĻžāϕ⧇ āύāĻž, āĻŦāϰāĻ‚ āĻāϟāĻŋ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āϕ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻ‚āϝ⧁āĻ•ā§āϤ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ (āĻŦāĻž āϭ⧌āĻ—ā§‹āϞāĻŋāĻ• āĻ¸ā§āĻĨāĻžāύ⧇) āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞāĻŋ āĻ›āĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻŦāĻž āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāϟ āĻ•āϰāĻž āĻĨāĻžāϕ⧇āĨ¤

āϝāĻĻāĻŋāĻ“ āĻāϗ⧁āϞ⧋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻ¸ā§āĻĨāĻžāύ⧇ āĻ›āĻĄāĻŧāĻžāύ⧋ āĻĨāĻžāϕ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āχāωāϜāĻžāϰ āĻŦāĻž āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇āϰ āĻ•āĻžāϛ⧇ āĻāϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āϟāĻŋāĻŽāĻžāĻ¤ā§āϰ āĻŦāĻŋāĻļāĻžāϞ āĻāĻŦāĻ‚ āύāĻŋāϰāĻŦāĻšā§āĻ›āĻŋāĻ¨ā§āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻšāĻŋāϏ⧇āĻŦ⧇āχ āĻŽāύ⧇ āĻšāϝāĻŧāĨ¤

Technical definition: A distributed database system (DDBS) is a centralized application that manages a distributed database, acting as if the data were stored on the same, single computer locally. It transparently distributes data computing and storage across multiple network interconnected nodes.

CAP theorem implications?​

āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻĄāĻŧ āύāĻŋāϝāĻŧāĻžāĻŽāĻ• āĻšāϞ⧋ CAP Theorem (Consistency, Availability, Partition Tolerance)āĨ¤

āϝ⧇āĻšā§‡āϤ⧁ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϟāĻŋ āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞāĻŋ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻ›āĻĄāĻŧāĻžāύ⧋ (Distributed), āϤāĻžāχ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĨ⧇āϕ⧇ āĻ…āĻ¨ā§āϝ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŽāĻ§ā§āϝāĻ•āĻžāϰ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϤāĻžāϰ āĻ›āĻŋāρāĻĄāĻŧ⧇ āϝāĻžāĻ“āϝāĻŧāĻž (Partition) āϖ⧁āĻŦāχ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ•āĨ¤ āϤāĻžāχ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻ…āĻŦāĻļā§āϝāχ "P" āĻŦāĻž Partition Tolerance āĻŽā§‡āύ⧇ āϚāϞāϤ⧇ āĻšāϝāĻŧāĨ¤

āĻāϰ āχāĻŽāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦāĻž āĻĒā§āϰāĻ­āĻžāĻŦ āĻšāĻ˛ā§‹â€”āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĄāĻŋāϜāĻžāχāύāĻžāϰāϕ⧇ āĻ…āĻŦāĻļā§āϝāχ āĻ āĻŋāĻ• āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āϤāĻžāϰāĻž āĻ•āĻŋ āĻĒāĻžāϰāĻĢ⧇āĻ•ā§āϟ "Consistency (C)" āϚāĻžāϝāĻŧ, āύāĻžāĻ•āĻŋ āϝ⧇āϕ⧋āύ⧋ āĻŽā§‚āĻ˛ā§āϝ⧇ "Availability (A)" āϚāĻžāϝāĻŧāĨ¤ āĻĻ⧁āĻŸā§‹ āĻāĻ•āϏāĻžāĻĨ⧇ āĻĒāĻžāĻ“āϝāĻŧāĻž āĻ…āϏāĻŽā§āĻ­āĻŦāĨ¤

What is distributed transaction (2PC)?​

āĻāĻ•āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ⧇ āϝāĻĻāĻŋ āϟāĻžāĻ•āĻž āĻŸā§āϰāĻžāĻ¨ā§āϏāĻĢāĻžāϰ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ, āϤāĻŦ⧇ āϤāĻž āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āχ āĻšāϝāĻŧāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ⧇ āĻāĻŽāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āϝ⧇, āφāĻĒāύāĻžāϰ āĻŦā§āϝāĻžāĻ‚āĻ• āĻāĻ•āĻžāωāĻ¨ā§āϟ āφāϛ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ A āϤ⧇ (āφāĻŽā§‡āϰāĻŋāĻ•āĻž) āĻāĻŦāĻ‚ āφāĻĒāύāĻŋ āϝāĻžāϕ⧇ āϟāĻžāĻ•āĻž āĻĒāĻžāĻ āĻžāĻšā§āϛ⧇āύ āϤāĻžāϰ āĻŦā§āϝāĻžāĻ‚āĻ• āĻāĻ•āĻžāωāĻ¨ā§āϟ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ B āϤ⧇ (āϞāĻ¨ā§āĻĄāύ⧇)āĨ¤

āĻāĻ–āύ āϝāĻĻāĻŋ āφāĻŽā§‡āϰāĻŋāĻ•āĻž āĻĨ⧇āϕ⧇ āϟāĻžāĻ•āĻž āϕ⧇āĻŸā§‡ āύ⧇āϝāĻŧāĻžāϰ āĻĒāϰ āϞāĻ¨ā§āĻĄāύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϟāĻŋ āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϤāĻŦ⧇ āĻĄā§‡āϟāĻž āĻ•āϰāĻžāĻĒā§āϟ āĻšāĻŦ⧇āĨ¤ āĻāϟāĻŋ āϏāĻžāĻŽāϞāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Two-Phase Commit (2PC) āĻĒā§āϰ⧋āĻŸā§‹āĻ•āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ:

ā§§. Prepare Phase (āĻĒā§āϰāĻ¸ā§āϤ⧁āϤāĻŋ āĻĒāĻ°ā§āĻŦ): āĻāĻ•āϟāĻŋ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āĻŽā§āϝāĻžāύ⧇āϜāĻžāϰ (āϕ⧋āĻ…āĻ°ā§āĻĄāĻŋāύ⧇āϟāϰ) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ A āĻāĻŦāĻ‚ B āĻĻ⧁āϜāύāϕ⧇āχ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇, "āϤ⧋āĻŽāϰāĻž āĻ•āĻŋ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āϏ⧇āĻ­ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āϰ⧇āĻĄāĻŋ?" āϤāĻžāϰāĻž āϝāĻĻāĻŋ āĻšā§āϝāĻžāρ āĻŦāϞ⧇, āϤāĻŦ⧇ āϤāĻžāϰāĻž āĻ“āχ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋ āϞāĻ• āĻ•āϰ⧇ āϰāĻžāϖ⧇āĨ¤

⧍. Commit Phase (āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ āĻĒāĻ°ā§āĻŦ): āϝāĻĻāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ A āĻāĻŦāĻ‚ B āĻĻ⧁āϜāύ⧇āχ "āĻšā§āϝāĻžāρ" āĻŦāϞ⧇, āϤāĻŦ⧇ āϕ⧋āĻ…āĻ°ā§āĻĄāĻŋāύ⧇āϟāϰ āϤāĻžāĻĻ⧇āϰ āĻĢāĻžāχāύāĻžāϞ "Commit" āĻŦāĻž āϏ⧇āĻ­ āĻ•āϰāϤ⧇ āĻŦāϞ⧇āĨ¤ āϝāĻĻāĻŋ āĻāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϜāύāĻ“ "āύāĻž" āĻŦāϞ⧇ āĻŦāĻž āϰ⧇āϏāĻĒāĻ¨ā§āϏ āύāĻž āĻĻ⧇āϝāĻŧ, āϤāĻŦ⧇ āϕ⧋āĻ…āĻ°ā§āĻĄāĻŋāύ⧇āϟāϰ āĻĻ⧁āϜāύāϕ⧇āχ "Rollback" āĻŦāĻž āĻŦāĻžāϤāĻŋāϞ āĻ•āϰāϤ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻ⧇āϝāĻŧāĨ¤

āĻĢāϞāĻžāĻĢāϞ: āĻšāϝāĻŧ āĻĻ⧁āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āχ āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻšāĻŦ⧇, āĻ…āĻĨāĻŦāĻž āϕ⧋āύ⧋āϟāĻŋāϤ⧇āχ āĻšāĻŦ⧇ āύāĻžāĨ¤ āĻāϤ⧇ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āĻ“ āĻĄā§‡āϟāĻžāϰ āχāĻ¨ā§āϟāĻŋāĻ—ā§āϰāĻŋāϟāĻŋ (āĻāĻ•āĻžāĻ—ā§āϰāϤāĻž) āĻŦāϜāĻžāϝāĻŧ āĻĨāĻžāϕ⧇āĨ¤