Skip to main content

Troubleshooting and Performance

🛑 151. Database suddenly became slow after deployment. How do you debug?​

āĻĒā§āϰ⧋āĻĄāĻžāĻ•āĻļāύ āĻĄā§‡āĻĒā§āϞāϝāĻŧāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āĻĒāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻšāĻ āĻžā§Ž āĻ¸ā§āϞ⧋ āĻšāϝāĻŧ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āϏāĻĢāϟāĻ“āϝāĻŧā§āϝāĻžāϰ āχāĻžā§āϜāĻŋāύāĻŋāϝāĻŧāĻžāϰāĻŋāĻ‚āϝāĻŧ⧇āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻŽāύ āχāĻŽāĻžāĻ°ā§āĻœā§‡āĻ¨ā§āϏāĻŋ (P0 Incident) āϗ⧁āϞ⧋āϰ āĻāĻ•āϟāĻŋāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻĄāĻŋāĻŦāĻžāĻ— āĻ•āϰāĻŦ⧇āύ? āύāϤ⧁āύ āĻĄā§‡āĻĒā§āϞāϝāĻŧāĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āĻĒāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ¸ā§āϞ⧋ āĻšāϞ⧇ āĻĒā§āϰāĻĨāĻŽā§‡āχ āϕ⧋āĻĄ āϰ⧋āϞāĻŦā§āϝāĻžāĻ• āĻ•āϰāĻžāϰ āĻ•āĻĨāĻž āϚāĻŋāĻ¨ā§āϤāĻž āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āĻāϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϞāĻŋāĻ•, āĻĻā§€āĻ°ā§āϘāϏāĻŽāϝāĻŧ āϧāϰ⧇ āϚāϞāĻž āĻ¸ā§āϞ⧋ āϕ⧁āϝāĻŧ⧇āϰāĻŋ, āĻāĻŦāĻ‚ āύāϤ⧁āύ āϰāĻŋāϞāĻŋāĻœā§‡āϰ āĻ—āĻŋāϟ āĻ•āĻŽāĻŋāĻŸā§‡ āϕ⧋āύ⧋ āφāύ-āĻ…āĻĒā§āϟāĻŋāĻŽāĻžāχāϜāĻĄ JOIN āĻŦāĻž āχāύāĻĄā§‡āĻ•ā§āϏāĻŋāĻ‚ āĻ›āĻžāĻĄāĻŧāĻž āϕ⧁āϝāĻŧ⧇āϰāĻŋ āφāϛ⧇ āĻ•āĻŋ āύāĻž āϤāĻž āφāχāĻĄā§‡āĻ¨ā§āϟāĻŋāĻĢāĻžāχ āĻ•āϰ⧇ āĻĢāĻŋāĻ•ā§āϏ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤

Technical summary: Debugging a slow database after a deployment involves immediately checking resource metrics, identifying unoptimized or new slow queries introduced in the release, analyzing active connections for potential leaks, and rolling back the deployment if the system is completely unresponsive.

🔍 What are the first things you would check?​

  1. CPU āĻ“ Memory Usage: āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āϰāĻŋāϏ⧋āĻ°ā§āϏ āĻšāĻ āĻžā§Ž āĻ•āϰ⧇ ā§§ā§Ļā§Ļ% āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇ āĻ•āĻŋ āύāĻž āϤāĻž āĻšā§‡āĻ• āĻ•āϰāĻž (āϝ⧇āĻŽāύ: htop, top, āĻŦāĻž CloudWatch āĻĻāĻŋāϝāĻŧ⧇)āĨ¤
  2. Active Connections & Locks: āύāϤ⧁āύ āϕ⧋āĻĄ āĻšāϝāĻŧāϤ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏ⧇āĻļāύ āĻŦāĻž āĻ•āĻžāύ⧇āĻ•āĻļāύ āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻ•ā§āϞ⧋āϜ āĻ•āϰāϛ⧇ āύāĻžāĨ¤ āϏāĻŦāϗ⧁āϞ⧋ āĻ•āĻžāύ⧇āĻ•āĻļāύ āĻĢ⧁āϞ āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇ āĻ•āĻŋ āύāĻž āϤāĻž āĻšā§‡āĻ• āĻ•āϰāĻž (āϝ⧇āĻŽāύ: pg_stat_activity āĻŦāĻž SHOW PROCESSLIST āĻĻāĻŋāϝāĻŧ⧇)āĨ¤
  3. Recent Commits: āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āϰāĻŋāϞāĻŋāĻœā§‡āϰ āĻ—āĻŋāϟ āĻ•āĻŽāĻŋāϟ āĻšā§‡āĻ• āĻ•āϰāĻžāĨ¤ āύāϤ⧁āύ āϕ⧋āύ⧋ āϕ⧋āϝāĻŧāĻžāϰāĻŋ, JOIN, āĻŦāĻž ORM āφāĻĒāĻĄā§‡āϟ āĻāϏ⧇āϛ⧇ āĻ•āĻŋ āύāĻž, āϝāĻž āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āĻĒā§āϰ⧇āĻļāĻžāϰ āĻĻāĻŋāĻšā§āϛ⧇āĨ¤
  4. Quick Rollback:

    💡 Important Note: āϝāĻĻāĻŋ āϏāĻžāĻ°ā§āĻ­āĻŋāϏ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ āĻāĻŦāĻ‚ āĻ•āĻžāϰāĻŖ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻĻ⧇āϰāĻŋ āĻšāϝāĻŧ, āϤāĻŦ⧇ āϰāĻŋāĻ¸ā§āĻ• āύāĻž āύāĻŋāϝāĻŧ⧇ āϏāĻ°ā§āĻŦāĻļ⧇āώ āĻ¸ā§āĻŸā§āϝāĻžāĻŦāϞ āĻŦāĻž āφāϗ⧇āϰ āĻ­āĻžāĻ°ā§āϏāύ⧇ āϕ⧋āĻĄāϟāĻŋ Rollback āĻ•āϰ⧇ āĻĢ⧇āϞāĻž āϏāĻŦāĻžāϰ āĻĒā§āϰāĻĨāĻŽ āĻĄāĻŋāϏāĻŋāĻļāύ āĻšāĻ“āϝāĻŧāĻž āωāϚāĻŋāϤāĨ¤

🧩 How do you identify if it's a query or infrastructure issue?​

  • Infrastructure Issue: āϝāĻĻāĻŋ āĻĻ⧇āϖ⧇āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āĻ•ā§āϝāĻžāĻļ āϏāĻžāĻ°ā§āĻ­āĻžāϰ, āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϏāĻžāĻ°ā§āĻ­āĻžāĻ°â€”āϏāĻŦāϗ⧁āϞ⧋āϰāχ āϞ⧋āĻĄ āĻŦ⧇āĻļāĻŋ, āϤāĻŦ⧇ āĻāϟāĻŋ āχāύāĻĢā§āϰāĻžāĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āĻŦāĻž āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āχāĻ¸ā§āϝ⧁ (āĻŦāĻž āĻšāĻ āĻžā§Ž āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āĻ¸ā§āĻĒāĻžāχāĻ•/DDoS āĻ…ā§āϝāĻžāϟāĻžāĻ•) āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ Disk I/O āĻŦāĻž I/O Wait time āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ āĻĨāĻžāĻ•āĻž āĻŽāĻžāύ⧇ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇ āϏāĻŽāĻ¸ā§āϝāĻž āĻšāĻšā§āϛ⧇āĨ¤
  • Query Issue: āϝāĻĻāĻŋ āχāύāĻĢā§āϰāĻžāĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ⧇āϰ āĻŽā§‡āĻŸā§āϰāĻŋāĻ•ā§āϏ (CPU/RAM) āύāϰāĻŽāĻžāϞ āĻĨāĻžāϕ⧇ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ¸ā§āĻĒ⧇āϏāĻŋāĻĢāĻŋāĻ• āĻĒ⧇āϜ āϞ⧋āĻĄ āĻšāϤ⧇ āĻĻ⧇āϰāĻŋ āĻšāϝāĻŧ, āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻŋāϛ⧁ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϞāϕ⧇āϜ (Deadlocks āĻŦāĻž Long waiting transactions) āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ, āϤāĻŦ⧇ āĻāϟāĻŋ āύāĻŋāĻļā§āϚāĻŋāϤāĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻžāĻĄ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻŦāĻž āϕ⧋āĻĄāĻŋāĻ‚ āχāĻ¸ā§āϝ⧁āĨ¤

đŸ› ī¸ What tools would you use for diagnosis?​

  • APM Tools: Datadog, New Relic, āĻŦāĻž AppDynamics (āϝāĻž āĻĨ⧇āϕ⧇ āĻāĻ¨ā§āĻĄ-āϟ⧁-āĻāĻ¨ā§āĻĄ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āĻŸā§āϰ⧇āϏāĻŋāĻ‚ āĻ•āϰāĻž āϝāĻžāϝāĻŧ)āĨ¤
  • DB Metrics: Prometheus + Grafana āĻĄā§āϝāĻžāĻļāĻŦā§‹āĻ°ā§āĻĄāĨ¤
  • Native DB Commands: MySQL āĻāϰ EXPLAIN, PostgreSQL āĻāϰ pg_stat_statements āĻāĻ•ā§āϏāĻŸā§‡āύāĻļāύāĨ¤

đŸĸ 152. How do you identify and fix a slow query?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻ¸ā§āϞ⧋ āϕ⧋āϝāĻŧāĻžāϰāĻŋ (Slow Query) āĻāĻ•āϟāĻŋ āύāĻŋāϰāĻŦ āϘāĻžāϤāĻ•, āϝāĻž āĻĒ⧁āϰ⧋ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϕ⧇ āĻ…āϚāϞ āĻ•āϰ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻļāύāĻžāĻ•ā§āϤāĻ•āϰāĻŖ āĻāĻŦāĻ‚ āϏāĻŽāĻžāϧāĻžāύ: āĻ¸ā§āϞ⧋ āϕ⧁āϝāĻŧ⧇āϰāĻŋ āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ slow_query_log āĻŦāĻž āĻ•ā§āϞāĻžāωāĻĄā§‡āϰ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻŽā§‡āĻŸā§āϰāĻŋāĻ•ā§āϏ āĻšā§‡āĻ• āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻļāύāĻžāĻ•ā§āϤ āĻ•āϰāĻžāϰ āĻĒāϰ EXPLAIN āĻŦāĻž EXPLAIN ANALYZE āĻ•āĻŽāĻžāĻ¨ā§āĻĄ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻāϰ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāĻļāύ āĻĒā§āĻ˛ā§āϝāĻžāύ (Execution Plan) āĻĻ⧇āĻ–āϤ⧇ āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ āχāύāĻĄā§‡āĻ•ā§āϏ āϝ⧋āĻ— āĻ•āϰāĻž, N+1 āχāĻ¸ā§āϝ⧁ āϏāĻŽāĻžāϧāĻžāύ, āĻ…āĻĨāĻŦāĻž āϕ⧁āϝāĻŧ⧇āϰāĻŋ āϰāĻŋāϰāĻžāχāϟ āĻ•āϰāĻžāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻāϟāĻŋ āĻĢāĻŋāĻ•ā§āϏ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

Technical summary: Identifying a slow query involves monitoring the database's slow query logs. Fixing it requires running the EXPLAIN command to analyze the query execution path and applying optimizations such as creating missing indexes, refactoring the query, or resolving ORM N+1 issues.

âąī¸ What is query profiling?​

āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻĒā§āϰ⧋āĻĢāĻžāχāϞāĻŋāĻ‚ āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĒā§āϰāϏ⧇āϏ āϝāĻž āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύāϕ⧇ āύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻĻ⧇āϝāĻŧ āĻĒā§āϰāϤāĻŋāϟāĻŋ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻāĻ•ā§āϏāĻŋāĻ•āĻŋāωāϟ āĻšāϤ⧇ āĻ•āϤ āĻŽāĻŋāϞāĻŋ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āϏāĻŽāϝāĻŧ āϞāĻžāĻ—āϛ⧇ āϤāĻžāϰ āĻāĻ•āϟāĻŋ āϞāĻŋāĻ¸ā§āϟ āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇āĨ¤

📌 Note: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ slow_query_log āĻ•āύāĻĢāĻŋāĻ— āĻ•āϰāĻž āĻĨāĻžāϕ⧇ (āϝ⧇āĻŽāύ: ā§§ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āĻŦ⧇āĻļāĻŋ āϞāĻžāĻ—āϞ⧇ āϏ⧇āϟāĻŋ āϞāϗ⧇ āĻāĻ¨ā§āĻŸā§āϰāĻŋ āĻšāĻŦ⧇)āĨ¤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ…ā§āϝāĻžāĻĄāĻŽāĻŋāύāϰāĻž pt-query-digest āĻŦāĻž AWS Performance Insights āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āϏāĻŽāϝāĻŧ āύ⧇āϝāĻŧāĻž āϟāĻĒ āϕ⧋āϝāĻŧāĻžāϰāĻŋāϗ⧁āϞ⧋ āĻŦ⧇āϰ āĻ•āϰ⧇āύāĨ¤

đŸ”Ŧ How do you use EXPLAIN plan?​

āϝāĻ–āύ āφāĻĒāύāĻŋ āĻ¸ā§āϞ⧋ āϕ⧋āϝāĻŧāĻžāϰāĻŋāϟāĻŋ āφāχāĻĄā§‡āĻ¨ā§āϟāĻŋāĻĢāĻžāχ āĻ•āϰ⧇ āĻĢ⧇āϞāĻŦ⧇āύ, āϤāĻ–āύ āϤāĻžāϰ āϏāĻžāĻŽāύ⧇ EXPLAIN āĻŦāĻž EXPLAIN ANALYZE āϞāĻŋāϖ⧇ āϰāĻžāύ āĻ•āϰāĻŦ⧇āύāĨ¤

EXPLAIN ANALYZE SELECT * FROM users WHERE status='active';
  • EXPLAIN āϕ⧀ āĻ•āϰ⧇? āĻāϟāĻŋ āϕ⧋āϝāĻŧāĻžāϰāĻŋāϟāĻŋ āϰāĻžāύ āύāĻž āĻ•āϰ⧇ āĻļ⧁āϧ⧁ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύāϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āĻ°ā§‡â€”"āϤ⧁āĻŽāĻŋ āϕ⧋āύ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāϝāĻŧ āĻĄā§‡āϟāĻžāϟāĻŋ āϖ⧁āρāϜāĻŦ⧇?"
  • āĻāϟāĻŋ āϝ⧇ āφāωāϟāĻĒ⧁āϟ āĻĻ⧇āϝāĻŧ āϤāĻžāϤ⧇ āĻŦā§‹āĻāĻž āϝāĻžāϝāĻŧ āχāĻžā§āϜāĻŋāύ āĻ•āĻŋ Index Scan (āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ āχāύāĻĄā§‡āĻ•ā§āϏ āϧāϰ⧇ āĻĄā§‡āϟāĻž āϖ⧁āρāϜāϛ⧇) āύāĻžāĻ•āĻŋ Seq Scan / Full Table Scan (āχāύāĻĄā§‡āĻ•ā§āϏ āύāĻž āĻĒ⧇āϝāĻŧ⧇ āĻŸā§‡āĻŦāĻŋāϞ⧇āϰ āϞāĻžāĻ– āϞāĻžāĻ– āϰ⧋ āĻāĻ•āϟāĻŋ āĻāĻ•āϟāĻŋ āĻ•āϰ⧇ āĻšā§‡āĻ• āĻ•āϰāϛ⧇) āĻ•āϰāϛ⧇āĨ¤

âš ī¸ Common causes of slow queries?​

  1. Missing Indexes (Most Common): WHERE āĻŦāĻž JOIN āĻ•ā§āϞāĻœā§‡ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ•āϞāĻžāĻŽāϗ⧁āϞ⧋āϤ⧇ āχāύāĻĄā§‡āĻ•ā§āϏ āύāĻž āĻĨāĻžāĻ•āĻžāĨ¤
  2. N+1 Problem in ORM: āϕ⧋āĻĄā§‡āϰ āϭ⧁āϞ⧇āϰ āĻ•āĻžāϰāϪ⧇ ā§§āϟāĻŋ āĻŦāĻĄāĻŧ āϕ⧋āϝāĻŧāĻžāϰāĻŋāϰ āĻŦāĻĻāϞ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ ā§§ā§Ļā§ĻāϟāĻŋ āϛ⧋āϟ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻĒāĻžāĻ āĻžāύ⧋ (āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇ Laravel/Django-āϤ⧇)āĨ¤
  3. Full Table Scans: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŦāĻžāĻ§ā§āϝ āĻšā§Ÿā§‡ āχāύāĻĄā§‡āĻ•ā§āϏ āχāĻ—āύ⧋āϰ āĻ•āϰāĻž (āϝ⧇āĻŽāύ LIKE '%name%' āĻĢāĻžāĻ‚āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž)āĨ¤
  4. Data Volume Limit: āĻāĻ• āϕ⧋āϝāĻŧāĻžāϰāĻŋāϤ⧇ āϞāĻžāĻ– āϞāĻžāĻ– āĻĄā§‡āϟāĻž āφāύāĻž (Pagination āĻŦā§āϝāĻŦāĻšāĻžāϰ āύāĻž āĻ•āϰāĻž)āĨ¤

💾 153. Database is running out of disk space. What do you do?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻ¸ā§āĻĒ⧇āϏ ā§§ā§Ļā§Ļ% āĻĢ⧁āϞ āĻšāϝāĻŧ⧇ āϗ⧇āϞ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āĻĢā§āϰāĻŋāϜ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϕ⧋āύ⧋ Insert āĻŦāĻž Update āĻ•āĻžāϜ āĻ•āϰ⧇ āύāĻžāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ¸ā§āĻĒ⧇āϏ āϰāĻŋāĻ•āĻ­āĻžāϰ āĻ•āϰāĻŦ⧇āύ? āϤāĻžā§ŽāĻ•ā§āώāĻŖāĻŋāĻ• āϏāĻŽāĻžāϧāĻžāύ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•ā§āϞāĻžāωāĻĄā§‡āϰ āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻ¸ā§āϕ⧇āϞ-āφāĻĒ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āĻŦāĻž āĻ…āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ āĻŸā§‡āĻŽā§āĻĒā§‹āϰāĻžāϰāĻŋ āϞāĻ— āĻĄāĻŋāϞāĻŋāϟ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤ āĻĻā§€āĻ°ā§āϘāĻŽā§‡āϝāĻŧāĻžāĻĻā§€ āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āϜāĻ¨ā§āϝ āĻĒ⧁āϰāĻžāύ⧋ āĻ…āĻĄāĻŋāϟ āĻŦāĻž āĻšāĻŋāĻ¸ā§āĻŸā§‹āϰāĻŋāĻ•ā§āϝāĻžāϞ āĻĄā§‡āϟāĻžāϕ⧇ āϏāĻ¸ā§āϤāĻž āĻ…āĻŦāĻœā§‡āĻ•ā§āϟ āĻ¸ā§āĻŸā§‹āϰ⧇āĻœā§‡ (āϝ⧇āĻŽāύ: S3) āφāĻ°ā§āĻ•āĻžāχāĻ­ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŸā§‡āĻŦāĻŋāϞ āĻĒāĻžāĻ°ā§āϟāĻŋāĻļāύāĻŋāĻ‚ āĻ“ āύāĻŋāϝāĻŧāĻŽāĻŋāϤ VACUUM/OPTIMIZE āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻ•ā§āϞāĻŋāύ āϰāĻžāĻ–āϤ⧇ āĻšāϝāĻŧāĨ¤

Technical summary: Handling low database disk space involves immediate mitigation by scaling up the volume storage or deleting safe temporary logs. Long-term strategies include data archiving to cheaper storage, setting up table partitioning, and performing routine database maintenance like VACUUM to reclaim space from dead rows.

âŗ Short-term vs long-term solutions?​

Short-Term (āϤāĻžāĻ¤ā§āĻ•ā§āώāĻŖāĻŋāĻ• āϏāĻŽāĻžāϧāĻžāύ):

  • āĻ•ā§āϞāĻžāωāĻĄ āĻĒāϰāĻŋāĻŦ⧇āĻļ⧇ (AWS/GCP) āϤāĻžā§ŽāĻ•ā§āώāĻŖāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇āϰ (EBS Volume) āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ (Scale up storage) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāϚāϞ āĻ•āϰāĻžāĨ¤
  • āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻĒ⧁āϰ⧋āύ⧋ āφāύāχāωāϜāĻĄ āϞāĻ— āĻĢāĻžāχāϞ (WAL logs āĻŦāĻž Error logs), Temporary Tables āĻŦāĻž āĻĢ⧇āχāϞ āĻšāĻ“āϝāĻŧāĻž āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ⧇āϰ āĻŸā§‡āĻŽā§āĻĒā§‹āϰāĻžāϰāĻŋ āĻĄā§‡āϟāĻž (VACUUM āĻ•āϰ⧇) āĻĄāĻŋāϞāĻŋāϟ āĻ•āϰ⧇ āχāĻŽāĻžāĻ°ā§āĻœā§‡āĻ¨ā§āϏāĻŋ āĻ¸ā§āĻĒ⧇āϏ āĻŦ⧇āϰ āĻ•āϰāĻžāĨ¤

Long-Term (āĻĻā§€āĻ°ā§āϘāĻŽā§‡āϝāĻŧāĻžāĻĻā§€ āϏāĻŽāĻžāϧāĻžāύ):

  • Data Archiving: ā§Ģ āĻŦāĻž ā§Š āĻŦāĻ›āϰ⧇āϰ āĻĒ⧁āϰ⧋āύ⧋ āϞ⧇āύāĻĻ⧇āύ (Historical Data / Audit Logs) āĻŽā§‡āχāύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āϏāϰāĻŋāϝāĻŧ⧇ āϏāĻ¸ā§āϤāĻž āĻ¸ā§āĻŸā§‹āϰ⧇āϜ (āϝ⧇āĻŽāύ: Amazon S3 āĻŦāĻž Glacier) āĻ āφāĻ°ā§āĻ•āĻžāχāĻ­ āĻ•āϰāĻžāĨ¤
  • Table Partitioning: āĻŦāĻŋāĻļāĻžāϞ āĻŸā§‡āĻŦāĻŋāϞāϗ⧁āϞ⧋āϕ⧇ āĻŽāĻžāϏ āĻŦāĻž āĻŦāĻ›āϰ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻĒāĻžāĻ°ā§āϟāĻŋāĻļāύ āĻ•āϰāĻž, āϝāĻžāϤ⧇ āĻĒ⧁āϰ⧋āύ⧋ āĻĄā§‡āϟāĻž āĻŽā§āϛ⧇ āĻĢ⧇āϞāĻž āĻŦāĻž āφāĻ°ā§āĻ•āĻžāχāĻ­ āĻ•āϰāĻž āϏāĻšāϜ āĻšāϝāĻŧāĨ¤

🔍 How do you identify what's consuming space?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻŽā§‡āϟāĻžāĻĄā§‡āϟāĻž āĻŸā§‡āĻŦāĻŋāϞāϗ⧁āϞ⧋āϤ⧇ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤

-- PostgreSQL Example
SELECT pg_total_relation_size('table_name');

💡 Tip: āĻāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻŸā§‡āĻŦāĻŋāϞ⧇āϰ āφāϏāϞ āϏāĻžāχāϜ, āχāύāĻĄā§‡āĻ•ā§āϏ⧇āϰ āϏāĻžāχāϜ, āĻāĻŦāĻ‚ "Bloat" (āĻŽā§ƒāϤ āĻĄā§‡āϟāĻžāϰ āϏāĻžāχāϜ) āĻĻ⧇āĻ–āĻž āĻšāϝāĻŧāĨ¤ āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻ…āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ āĻĒā§āϰāϚ⧁āϰ āχāύāĻĄā§‡āĻ•ā§āϏ āĻĨāĻžāϕ⧇, āϝāĻž āφāϏāϞ āĻĄā§‡āϟāĻžāϰ āĻšā§‡āϝāĻŧ⧇āĻ“ āĻŦ⧇āĻļāĻŋ āĻ¸ā§āĻĒ⧇āϏ āĻ–āĻžāϝāĻŧāĨ¤

🧹 Database maintenance tasks to free up space?​

  • VACUUM / OPTIMIZE TABLE: āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āϕ⧋āύ⧋ Row āĻĄāĻŋāϞāĻŋāϟ āĻ•āϰāϞ⧇ āϤāĻž āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āĻ• āĻĨ⧇āϕ⧇ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇ āĻŽā§āϛ⧇ āϝāĻžāϝāĻŧ āϏāĻžāϏāĻĒ⧇āĻ¨ā§āĻĄ āĻšāϝāĻŧ āύāĻž (Soft dead rows)āĨ¤ VACUUM (Postgres) āĻŦāĻž OPTIMIZE TABLE (MySQL) āĻ•āĻŽāĻžāĻŖā§āĻĄ āϚāĻžāϞāĻžāϞ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŽā§‡āĻŽāϰāĻŋ āϰāĻŋ-āĻ…āĻ°ā§āĻ—āĻžāύāĻžāχāϜ āĻ•āϰ⧇ āĻĄāĻŋāĻ¸ā§āĻ• āĻ¸ā§āĻĒ⧇āϏ āĻĢā§āϰāĻŋ āĻ•āϰ⧇āĨ¤

🔌 154. Too many database connections error. How to resolve?​

âš ī¸ Error: FATAL: sorry, too many clients already āĻāχ āĻāϰāϰāϟāĻŋāϰ āĻŽāĻžāύ⧇ āĻšāϞ⧋ āφāĻĒāύāĻžāϰ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϞāĻŋāĻŽāĻŋāϟ āĻĒāĻžāϰ āĻ•āϰ⧇ āĻāϤ āĻŦ⧇āĻļāĻŋ āĻ•āĻžāύ⧇āĻ•āĻļāύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϖ⧁āϞ⧇āϛ⧇ āϝ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύāϤ⧁āύ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āϰāĻŋāĻœā§‡āĻ•ā§āϟ āĻ•āϰ⧇ āĻĻāĻŋāĻšā§āϛ⧇āĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻŦ⧇āύ? āĻāχ āĻāϰāϰ āĻĨ⧇āϕ⧇ āĻŦāĻžāρāϚāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ•āĻžāĻ°ā§āϝāĻ•āϰ⧀ āωāĻĒāĻžāϝāĻŧ āĻšāϞ⧋ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŽāĻžāĻā§‡ Connection Pool (āϝ⧇āĻŽāύ: PgBouncer āĻŦāĻž HikariCP) āϝ⧁āĻ•ā§āϤ āĻ•āϰāĻžāĨ¤ āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϏāĻ‚āĻ–ā§āϝāĻ• āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϰāĻŋ-āχāωāϜ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŽā§āϝāĻžāĻ•ā§āϏāĻŋāĻŽāĻžāĻŽ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϞāĻŋāĻŽāĻŋāϟ (max_connections) āĻšā§āϟ āĻ•āϰ⧇ āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻĻāĻŋāϞ⧇ RAM āĻĢ⧁āϞ āĻšāϝāĻŧ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Technical summary: Resolving the "too many connections" error requires implementing connection pooling at the application or middleware layer to reuse a limited number of active connections. Blindly increasing the database max_connections parameter is discouraged as it often leads to Out of Memory (OOM) crashes.

đŸ•ĩī¸ How do you identify connection leaks?​

Connection Leak āĻšāϝāĻŧ āϝāĻ–āύ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻāĻ•āϟāĻŋ āϏ⧇āĻļāύ āĻ–ā§‹āϞ⧇ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĄā§‡āϟāĻž āϰāĻŋāĻĄ āĻ•āϰāĻžāϰ āĻĒāϰ āϕ⧋āĻĄā§‡ āϏ⧇āχ āĻ•āĻžāύ⧇āĻ•āĻļāύāϟāĻŋ close() āĻ•āϰāϤ⧇ āϭ⧁āϞ⧇ āϝāĻžāϝāĻŧ āĻŦāĻž āĻāϰāϰ āĻšāϝāĻŧ⧇ āφāϟāϕ⧇ āĻĨāĻžāϕ⧇āĨ¤

  • āϏāύāĻžāĻ•ā§āϤ āĻ•āϰāϤ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻ…ā§āϝāĻžāĻ•ā§āϟāĻŋāĻ­ āϏ⧇āĻļāύāϗ⧁āϞ⧋āϤ⧇ (āϝ⧇āĻŽāύ pg_stat_activity) āφāχāĻĄāϞ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ (Idle transactions) āϖ⧁āρāϜāϤ⧇ āĻšāϝāĻŧ āϝāĻž āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āϧāϰ⧇ āĻļ⧁āϧ⧁ āĻ“āĻĒ⧇āύ āĻšāϝāĻŧ⧇ āĻŦāϏ⧇ āφāϛ⧇ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϕ⧋āύ⧋ āϕ⧋āϝāĻŧāĻžāϰāĻŋ āϰāĻžāύ āĻ•āϰāϛ⧇ āύāĻžāĨ¤

đŸŠâ€â™‚ī¸ What is connection pooling and how does it help?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāύ⧇āĻ•āĻļāύ āĻ“āĻĒ⧇āύ āĻ•āϰāĻž (TCP Handshake, Authentication) āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϏāĻŽāϝāĻŧāϏāĻžāĻĒ⧇āĻ•ā§āώ āĻāĻŦāĻ‚ āĻ–āϰ⧁āĻšā§‡āĨ¤

  • Connection Pooling: (āϝ⧇āĻŽāύ: PgBouncer, HikariCP) āĻšāϞ⧋ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŽāĻžāĻāĻ–āĻžāύ⧇ āĻĨāĻžāĻ•āĻž āĻāĻ•āϟāĻŋ āϞ⧇āϝāĻŧāĻžāϰāĨ¤ āĻāϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻžāĻĨ⧇ āĻ…āĻ˛ā§āĻĒ āĻ•āĻŋāϛ⧁ (āϧāϰāĻŋ ā§Ģā§ĻāϟāĻŋ) āĻĒāĻžāĻ°ā§āĻŽāĻžāύ⧇āĻ¨ā§āϟ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϖ⧁āϞ⧇ āϰāĻžāϖ⧇ (Pool)āĨ¤
  • āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻĨ⧇āϕ⧇ ā§Ģ āĻšāĻžāϜāĻžāϰ āχāωāϜāĻžāϰ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āφāϏāϞ⧇āĻ“, āĻĒā§‹āϞāĻŋāĻ‚ āĻ“āχ ā§Ģā§ĻāϟāĻŋ āĻ•āĻžāύ⧇āĻ•āĻļāύ⧇āϰ āĻŽāĻ§ā§āϝ⧇āχ āϏāĻŦāĻžāχāϕ⧇ āϰāĻžāωāĻ¨ā§āĻĄ-āϰāĻŦāĻŋāύ āĻ•āϰ⧇ āϏāĻžāĻ°ā§āĻ­ āĻ•āϰ⧇āĨ¤ āϕ⧇āω āĻ•āĻžāϜ āĻļ⧇āώ āĻ•āϰāϞ⧇ āĻ“āχ āϰ⧇āĻĄāĻŋāĻŽā§‡āĻĄ āĻ•āĻžāύ⧇āĻ•āĻļāύāϟāĻŋ āĻ…āĻ¨ā§āϝ āĻāĻ•āϜāύāϕ⧇ āϧāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϤ⧇ Too many connections āĻāϰāϰ āĻ•āĻ–āύ⧋āχ āφāϏ⧇ āύāĻžāĨ¤

âš™ī¸ How do you tune max_connections parameter?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ max_connections āĻ­ā§āϝāĻžāϞ⧁āϟāĻŋ āĻšā§āϟ āĻ•āϰ⧇ āĻ…āύ⧇āĻ• āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĻž āĻāĻ•āϟāĻŋ āĻŽāĻžāϰāĻžāĻ¤ā§āĻŽāĻ• āϭ⧁āϞāĨ¤

🚨 Warning: āĻĒā§āϰāϤāĻŋ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϏāĻžāϧāĻžāϰāĻŖāϤ ⧍-ā§§ā§Ļ āĻŽā§‡āĻ—āĻžāĻŦāĻžāχāϟ āĻŽā§‡āĻŽāϰāĻŋ āĻ–āĻžāϝāĻŧāĨ¤ āĻ•āĻžāύ⧇āĻ•āĻļāύ āϞāĻŋāĻŽāĻŋāϟ āĻŦ⧇āĻļāĻŋ āĻŦāĻžāĻĄāĻŧāĻžāϞ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ RAM āĻĢ⧁āϞ (Out of Memory - OOM) āĻšāϝāĻŧ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāĻŦ⧇āĨ¤

  • Calculation Formula: Number of CPU Cores × 2 + Effective Spindle Count (Disk I/O āĻ•ā§āώāĻŽāϤāĻž)āĨ¤
  • āϤāĻžāχ āϞāĻŋāĻŽāĻŋāϟ āĻŦāĻžāĻĄāĻŧāĻžāύ⧋āϰ āĻŦāĻĻāϞ⧇ āϏāĻŦāϏāĻŽāϝāĻŧ Connection Pool āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤

âąī¸ 155. Replication lag is very high. What would you do?​

Replication Lag āĻŦāĻž āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻĄāĻŋāϞ⧇ āϤāĻ–āύ āĻšāϝāĻŧ, āϝāĻ–āύ Primary (Master) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž Secondary (Slave) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āφāϏāϤ⧇ āĻāĻŦāĻ‚ āφāĻĒāĻĄā§‡āϟ āĻšāϤ⧇ āĻ…āύ⧇āĻ• āĻŦ⧇āĻļāĻŋ āϏāĻŽāϝāĻŧ āύāĻŋāĻšā§āϛ⧇āĨ¤ āĻĢāϞ⧇ āχāωāϜāĻžāϰ Secondary āĻĨ⧇āϕ⧇ āĻĄā§‡āϟāĻž āĻĒāĻĄāĻŧāϞ⧇ āĻĒ⧁āϰ⧋āύ⧋ āϭ⧁āϞ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϝāĻŧāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āϰāĻŋāĻ•āĻ­āĻžāϰ āĻ•āϰāĻŦ⧇āύ? āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻ˛ā§āϝāĻžāĻ— āĻ•āĻŽāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ Slave āύ⧋āĻĄā§‡ āĻŽāĻžāĻ˛ā§āϟāĻŋ-āĻĨā§āϰ⧇āĻĄā§‡āĻĄ (Parallel) āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϚāĻžāϞ⧁ āĻ•āϰāĻž āĻšāϝāĻŧ, āϝ⧇āύ āĻāϟāĻŋ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āĻŽāϤāχ āĻĻā§āϰ⧁āϤ āĻ¸ā§āĻĒāĻŋāĻĄā§‡ āĻĄā§‡āϟāĻž āϰāĻžāχāϟ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāĻ›āĻžāĻĄāĻŧāĻžāĻ“ āϝāĻĻāĻŋ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ⧇ āĻŦāĻŋāĻļāĻžāϞ āϕ⧋āύ⧋ āĻŦā§āϝāĻžāϚ āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ (Bulk Update) āϚāϞ⧇, āϤāĻŦ⧇ āϤāĻž āϛ⧋āϟ āϛ⧋āϟ āĻŦā§āϝāĻžāĻšā§‡ āĻ­āĻžāĻ— āĻ•āϰ⧇ āϰāĻžāύ āĻ•āϰāϞ⧇ āĻ˛ā§āϝāĻžāĻ— āϤ⧈āϰāĻŋ āĻšāϝāĻŧ āύāĻžāĨ¤

Technical summary: High replication lag is fixed by enabling multi-threaded parallel replication on the secondary nodes, upgrading the read-replica's I/O throughput to match the primary, and avoiding massive bulk writes on the primary database by breaking them down into smaller periodic batches.

📏 How do you measure replication lag?​

  • MySQL:
SHOW SLAVE STATUS\G;
-- Check the 'Seconds_Behind_Master' field. (0 = no lag).
  • PostgreSQL: pg_stat_replication āĻ­āĻŋāω āĻĨ⧇āϕ⧇ āĻ˛ā§āϝāĻžāĻ— āĻŽāĻžāĻĒāĻž āϝāĻžāϝāĻŧāĨ¤

🚧 Common causes of high replication lag?​

  1. Network Latency: āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻāĻŦāĻ‚ āĻ¸ā§āϞ⧇āϭ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āχāĻ¨ā§āϟāĻžāϰāύ⧇āϟ āĻ¸ā§āĻĒāĻŋāĻĄ āĻŦāĻž āĻŦā§āϝāĻžāĻ¨ā§āĻĄāωāχāĻĨ āĻ¸ā§āϞ⧋ āĻšāĻ“āϝāĻŧāĻžāĨ¤
  2. Heavy DDL Operations: āĻĒā§āϰāĻžāχāĻŽāĻžāϰāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻŦāĻĄāĻŧ āĻŸā§‡āĻŦāĻŋāϞ⧇āϰ āχāύāĻĄā§‡āĻ•ā§āϏ āϤ⧈āϰāĻŋ (CREATE INDEX) āĻ•āϰāĻž āĻŦāĻž āĻ¸ā§āĻ•āĻŋāĻŽāĻž āĻšā§‡āĻžā§āϜ (ALTER TABLE) āĻ•āϰāĻžāĨ¤ āĻāϟāĻŋ āĻ¸ā§āϞ⧇āĻ­ āύ⧋āĻĄā§‡ āĻ—āĻŋāϝāĻŧ⧇ āĻĒ⧁āϰ⧋āĻĒ⧁āϰāĻŋ āφāĻĒāĻĄā§‡āϟ āύāĻž āĻšāĻ“āϝāĻŧāĻž āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦā§āϞāĻ• āĻ•āϰ⧇ āϰāĻžāϖ⧇āĨ¤
  3. Massive Batch Writes: āĻāĻ•āϏāĻžāĻĨ⧇ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ ā§§ā§Ļ āϞāĻžāĻ– āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻ•āϰāϞ⧇ āϤāĻž āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϞāϗ⧇ āĻ“āĻ­āĻžāϰāϞ⧋āĻĄ āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤
  4. Single-threaded Slave: āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŽāĻžāĻ˛ā§āϟāĻŋ-āϕ⧋āϰ āϏāĻŋāĻĒāĻŋāχāω āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞ āϰāĻžāχāϟ āĻ•āϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĒ⧁āϰ⧋āύ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ⧇ Slave āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻŋāĻ™ā§āĻ—āϞ-āĻĨā§āϰ⧇āĻĄā§‡ āĻāĻ•āϟāĻŋ āϕ⧋āϝāĻŧāĻžāϰāĻŋāϰ āĻĒāϰ āĻ…āĻĒāϰāϟāĻŋ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰ⧇āĨ¤

⚡ How do you reduce it?​

  • Parallel Replication: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•āύāĻĢāĻŋāĻ—āĻžāϰ⧇āĻļāύ⧇ (MySQL 5.7+ āĻŦāĻž Postgres) Multi-threaded replication āϚāĻžāϞ⧁ āĻ•āϰāĻž, āϝāĻžāϤ⧇ āĻ¸ā§āϞ⧇āĻ­ āύ⧋āĻĄāϗ⧁āϞ⧋āĻ“ āĻāĻ•āĻžāϧāĻŋāĻ• āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻāĻ•āϏāĻžāĻĨ⧇ āϰāĻžāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
  • Batch Splitting: āĻāĻ•āĻŦāĻžāϰ⧇ ā§§ā§Ļ āϞāĻžāĻ– āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āύāĻž āĻ•āϰ⧇, āĻ•ā§āϰāύ āϜāĻŦ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ ā§Ģ āĻšāĻžāϜāĻžāϰ āĻ•āϰ⧇ āĻŦā§āϝāĻžāϚ āĻšāĻŋāϏ⧇āĻŦ⧇ āφāĻĒāĻĄā§‡āϟ āĻ•āϰāĻžāĨ¤
  • Hardware Upgrade: āϰāĻŋāĻĄ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻžāϰ āĻĄāĻŋāĻ¸ā§āϕ⧇āϰ āĻ¸ā§āĻĒāĻŋāĻĄ (IOPS) āĻāĻŦāĻ‚ āχāĻžā§āϜāĻŋāύ āĻ•ā§āϝāĻžāĻĒāĻžāϏāĻŋāϟāĻŋ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āϏāĻŽāĻžāύ āĻŦāĻž āϤāĻžāϰ āĻšā§‡āϝāĻŧ⧇ āĻ­āĻžāϞ⧋ āϰāĻžāĻ–āĻžāĨ¤

đŸ’Ĩ 156. Database crashed and won't start. Troubleshooting steps?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰ⧇ āĻ¸ā§āϟāĻžāĻ°ā§āϟ āύāĻž āĻšāĻ“āϝāĻŧāĻž āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻāĻĄāĻŽāĻŋāύāĻĻ⧇āϰ āϜāĻ¨ā§āϝ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ­ā§€āϤāĻŋāĻ•āϰ āύāĻžāχāϟāĻŽā§‡āϝāĻŧāĻžāϰāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻŸā§āϰāĻžāĻŦāϞāĻļ⧁āϟ āĻ•āϰāĻŦ⧇āύ? āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āφāϗ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻāϰāϰ āϞāĻ— (Error log) āĻšā§‡āĻ• āĻ•āϰ⧇ āĻ•ā§āĻ°ā§āϝāĻžāĻļ⧇āϰ āĻŽā§‚āϞ āĻ•āĻžāϰāĻŖ (āϝ⧇āĻŽāύ: OOM Killer, Disk I/O Failure, āĻŦāĻž Corrupted Data) āĻŦ⧇āϰ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤ āϝāĻĻāĻŋ āĻāϰāϰ āϏāĻžāϧāĻžāϰāĻŖ āĻ•āĻŋāϛ⧁ āĻšāϝāĻŧ āϤāĻŦ⧇ āϏ⧇āϟāĻŋ āĻĢāĻŋāĻ•ā§āϏ āĻ•āϰ⧇ āϰāĻŋāĻ¸ā§āϟāĻžāĻ°ā§āϏ āĻĻāĻŋāϞ⧇āχ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻ…āĻŸā§‹āĻŽā§‡āϟāĻŋāĻ• āϰāĻŋāĻ•āĻ­āĻžāϰāĻŋ āĻŽā§‡āĻ•āĻžāύāĻŋāϜāĻŽ (WAL/Redo log) āĻĄā§‡āϟāĻž āϏ⧇āĻĢ āĻ•āϰ⧇ āĻĒ⧁āύāϰāĻžāϝāĻŧ āϚāĻžāϞ⧁ āĻšāĻŦ⧇āĨ¤ āĻŽāĻžāϰāĻžāĻ¤ā§āĻŽāĻ• āĻ•āϰāĻžāĻĒāĻļāύ āĻšāϞ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻĨ⧇āϕ⧇ Point-In-Time Recovery (PITR) āĻ•āϰ⧇ āĻĄā§‡āϟāĻž āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇āĨ¤

Technical summary: Troubleshooting a crashed database starts with analyzing the system and database error logs to identify the root cause (OOM, hardware failure, data corruption). Depending on the severity, the database might auto-recover using Write-Ahead Logs (WAL) upon restart, or it may require point-in-time recovery from the latest backup.

📜 How do you check database logs?​

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĒā§āϰāĻĨāĻŽ āĻ•āĻžāϜ āĻšāϞ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϕ⧇āύ āĻŽāĻžāϰāĻž āϗ⧇āϞ āϤāĻž āϜāĻžāύāĻžāĨ¤

# Check MySQL error log
tail -n 100 /var/log/mysql/error.log

# Or use journalctl for PostgreSQL
journalctl -u postgresql

💡 Tip: āϞāĻ— āĻĨ⧇āϕ⧇āχ āϜāĻžāύāĻž āϝāĻžāĻŦ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•āĻŋ OOM (Out Of Memory) Killer āĻāϰ āĻšāĻžāϤ⧇ āĻŽāĻžāϰāĻž āϗ⧇āϛ⧇ (āĻ•āĻžāϰāĻŖ RAM āĻļ⧇āώ), āύāĻžāĻ•āĻŋ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āĻ• āύāĻˇā§āϟ (Disk I/O Error), āύāĻžāĻ•āĻŋ āĻ•āύāĻĢāĻŋāĻ—āĻžāϰ⧇āĻļāύ⧇ āϏāĻŋāύāĻŸā§āϝāĻžāĻ•ā§āϏ āϭ⧁āϞ āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

🔄 What is database recovery process?​

āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āĻŽāĻĄāĻžāĻ°ā§āύ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ (MySQL InnoDB āĻŦāĻž Postgres) āĻ…āĻŸā§‹āĻŽā§‡āϟāĻŋāĻ• āĻ•ā§āĻ°ā§āϝāĻžāĻļ āϰāĻŋāĻ•āĻ­āĻžāϰāĻŋ āĻŽā§‡āĻ•āĻžāύāĻŋāϜāĻŽ āĻĨāĻžāϕ⧇āĨ¤

  • āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϰāĻŋāĻ¸ā§āϟāĻžāĻ°ā§āϟ āύ⧇āϝāĻŧāĻžāϰ āϏāĻŽāϝāĻŧ āϏ⧇ āĻĒā§āϰāĻĨāĻŽā§‡āχ WAL (Write-Ahead Log) āĻŦāĻž Redo Logs āĻĒāĻĄāĻŧ⧇āĨ¤
  • āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāĻžāϰ āĻ āĻŋāĻ• āĻŽāĻŋāϞāĻŋ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āφāĻ— āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϝ⧇āϏāĻŦ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ⧇āϰ āĻ•āĻŽāĻŋāϟ āϏāĻžāχāύ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇ āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰ⧇āύāĻŋ, āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϞāĻ— āĻĨ⧇āϕ⧇ āϏ⧇āϗ⧁āϞ⧋ āĻĒ⧁āύāϰāĻžāϝāĻŧ (Replay) āϰāĻžāύ āĻ•āϰ⧇ āĻĄā§‡āϟāĻž āϰāĻŋāĻ•āĻ­āĻžāϰ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻ•āϰāĻžāĻĒā§āϟ āĻšāĻ“āϝāĻŧāĻž āĻĄā§‡āϟāĻž āϰ⧋āϞāĻŦā§āϝāĻžāĻ• āĻ•āϰ⧇ āϏāĻžāĻ°ā§āĻ­āĻŋāϏ āϞāĻžāχāĻ­ āĻ•āϰ⧇āĨ¤

đŸ› ī¸ When would you restore from backup vs repair?​

  • Repairing Database: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻāϰāϰ āϞāϗ⧇ āϝāĻĻāĻŋ āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ āϝ⧇ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻāĻ•āϟāĻŋ āχāύāĻĄā§‡āĻ•ā§āϏ āĻĢāĻžāχāϞ āĻŦāĻž āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŸā§‡āĻŦāĻŋāϞ āĻĒ⧇āϜ āĻ•āϰāĻžāĻĒā§āϟ (Data corruption) āĻšāϝāĻŧ⧇āϛ⧇, āϤāĻ–āύ āχāύāĻĄā§‡āĻ•ā§āϏ āϰāĻŋāĻŦāĻŋāĻ˛ā§āĻĄ āĻŦāĻž āχāĻžā§āϜāĻŋāύ āϰāĻŋāĻĒ⧇āϝāĻŧāĻžāϰ āϟ⧁āϞāϏ āĻĻāĻŋāϝāĻŧ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ āĻŋāĻ• āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤
  • Restore from Backup: āϝāĻĻāĻŋ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āĻ• āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞāĻŋ āĻĒ⧁āĻĄāĻŧ⧇ āϝāĻžāϝāĻŧ, Ransomware āĻ…ā§āϝāĻžāϟāĻžāĻ• āĻšāϝāĻŧ āĻŦāĻž āϭ⧁āϞ⧇ āϕ⧇āω āĻĒ⧁āϰ⧋ āĻĒā§āϰ⧋āĻĄāĻžāĻ•āĻļāύ āĻŸā§‡āĻŦāĻŋāϞ DROP āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ—āϤāĻ–āύ āϰāĻŋāĻĒ⧇āϝāĻŧāĻžāϰ⧇āϰ āĻĒā§āϰāĻļā§āύāχ āφāϏ⧇āϞāĻ—ā§āύ āύāĻžāĨ¤ āϤāĻ–āύ āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ āĻ•āϰ⧇ āϏāĻ°ā§āĻŦāĻļ⧇āώ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻĢāĻžāχāϞ (Full Dump + WAL logs) āĻĨ⧇āϕ⧇ Point-In-Time Recovery (PITR) āĻ•āϰ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻœā§€āĻŦāĻŋāϤ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤

🔄 157. Deadlocks are occurring frequently. How do you resolve?​

āĻĄā§‡āĻĄāϞāĻ• (Deadlock) āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻ…āĻŦāĻ¸ā§āĻĨāĻž āϝ⧇āĻ–āĻžāύ⧇ āĻĻ⧁āϟāĻŋ āφāϞāĻžāĻĻāĻž āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āϞāϕ⧇āϰ (Lock) āĻ•āĻžāϜ āĻļ⧇āώ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ…āύāĻ¨ā§āϤāĻ•āĻžāϞ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϜāĻ¨ā§āϝ āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

📌 Example: āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ A āĻŸā§‡āĻŦāĻŋāϞ-ā§§ āϞāĻ• āĻ•āϰ⧇āϛ⧇ āĻāĻŦāĻ‚ āĻŸā§‡āĻŦāĻŋāϞ-⧍ āϖ⧁āρāϜāϛ⧇āĨ¤ āĻāĻĻāĻŋāϕ⧇ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ B āĻŸā§‡āĻŦāĻŋāϞ-⧍ āϞāĻ• āĻ•āϰ⧇āϛ⧇ āĻāĻŦāĻ‚ āĻŸā§‡āĻŦāĻŋāϞ-ā§§ āϖ⧁āρāϜāϛ⧇āĨ¤ āϕ⧇āωāχ āϞāĻ• āĻ›āĻžāĻĄāĻŧāĻŦ⧇ āύāĻž, āϤāĻžāχ āϏ⧃āĻˇā§āϟāĻŋ āĻšāϝāĻŧ āĻĄā§‡āĻĄāϞāĻ•āĨ¤ āĻļ⧇āώāĻŽā§‡āĻļ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ āĻāĻ• āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύāϕ⧇ āĻĢ⧇āχāϞ (Kill) āĻ•āϰ⧇ āĻĻāĻŋāϝāĻŧ⧇ āĻĄā§‡āĻĄāϞāĻ• āĻ­āĻžāĻ™āϤ⧇ āĻŦāĻžāĻ§ā§āϝ āĻšāϝāĻŧāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āϏāĻŽāĻžāϧāĻžāύ āĻ•āϰāĻŦ⧇āύ? āĻĄā§‡āĻĄāϞāĻ• āĻ•āĻŽāĻžāύ⧋āϰ āĻĒā§āϰāϧāĻžāύ āωāĻĒāĻžāϝāĻŧ āĻšāϞ⧋ āĻŦā§āϝāĻžāĻ•āĻāĻ¨ā§āĻĄ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇āϰ āϕ⧋āĻĄ āϰāĻŋāĻĢā§āϝāĻžāĻ•ā§āϟāϰ āĻ•āϰāĻžāĨ¤ āϕ⧋āĻĄā§‡ āĻ…āĻŦāĻļā§āϝāχ āϖ⧇āϝāĻŧāĻžāϞ āϰāĻžāĻ–āϤ⧇ āĻšāĻŦ⧇ āϝ⧇ āĻ­āĻŋāĻ¨ā§āύ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύāϗ⧁āϞ⧋ āϝ⧇āύ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•āχ āϏāĻŋāĻ•ā§‹ā§Ÿā§‡āĻ¨ā§āϏ⧇ (Sequentially) āĻŸā§‡āĻŦāĻŋāϞāϗ⧁āϞ⧋ āĻāĻ•ā§āϏ⧇āϏ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύāϗ⧁āϞ⧋ āϝāϤāϟāĻž āϏāĻŽā§āĻ­āĻŦ āϛ⧋āϟ āĻ“ āĻĻā§āϰ⧁āϤ āĻšāϝāĻŧāĨ¤

Technical summary: Resolving frequent deadlocks primarily requires an application-level refactoring to ensure that all concurrent transactions access database tables or rows in exactly the same deterministic order. Additionally, minimizing transaction duration and employing optimistic locking can significantly reduce deadlock occurrences.

🔍 How do you identify which queries are causing deadlocks?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϞāϗ⧇ āĻĄā§‡āĻĄāϞāĻ• āĻĄāĻŋāĻŸā§‡āĻ•ā§āϟ āĻšāϞ⧇ āϤāĻž āĻĒā§āϰāĻŋāĻ¨ā§āϟ āĻšāϝāĻŧāĨ¤

-- For MySQL
SHOW ENGINE INNODB STATUS;

āφāωāϟāĻĒ⧁āϟ āĻĨ⧇āϕ⧇ āϏāĻ°ā§āĻŦāĻļ⧇āώ āĻĄā§‡āĻĄāϞāĻ• āϘāϟāĻž āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻāĻŦāĻ‚ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύāϗ⧁āϞ⧋āϰ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧāĨ¤

âš™ī¸ Application-level vs database-level solutions?​

  • Database-level: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϞ⧇āϭ⧇āϞ⧇ āĻ•āĻŋāϛ⧁āχ āĻ•āϰāĻžāϰ āύ⧇āχ; āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύāĻŋāĻœā§‡ āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻŋ āĻļāĻŋāĻ•āĻžāϰ (Victim) āĻŦ⧇āϛ⧇ āύāĻŋāϝāĻŧ⧇ āϤāĻžāϕ⧇ āϰ⧋āϞāĻŦā§āϝāĻžāĻ• āĻŦāĻž āĻ•āĻŋāϞ āĻ•āϰ⧇ āĻĄā§‡āĻĄāϞāĻ• āĻ­āĻžāϙ⧇āĨ¤
  • Application-level: āφāϏāϞ āϏāĻŽāĻžāϧāĻžāύ āĻāĻ–āĻžāύ⧇āχāĨ¤ āĻĄā§‡āϭ⧇āϞāĻĒāĻžāϰāĻĻ⧇āϰ āϕ⧋āĻĄ āϰāĻŋāĻĢā§āϝāĻžāĻ•ā§āϟāϰ āĻ•āϰ⧇ āĻŸā§‡āĻŦāĻŋāϞ āφāĻĒāĻĄā§‡āĻŸā§‡āϰ āϏāĻŋāϕ⧋āϝāĻŧ⧇āĻ¨ā§āϏ (Sequence) āĻ āĻŋāĻ• āĻ•āϰāϤ⧇ āĻšāϝāĻŧ, āϝāĻžāϤ⧇ āĻĻ⧁āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āĻĒā§āϰāϏ⧇āϏ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•āχ āϏāĻŋāϰāĻŋāϝāĻŧāĻžāϞ⧇ āĻŸā§‡āĻŦāĻŋāϞāϗ⧁āϞ⧋ āĻāĻ•ā§āϏ⧇āϏ āĻ•āϰ⧇āĨ¤

đŸ›Ąī¸ How do you prevent deadlocks in code?​

  1. āĻ…āĻ°ā§āĻĄāĻžāϰ āĻ āĻŋāĻ• āĻ•āϰāĻž (Sorting): āϝāĻĻāĻŋ āĻāĻ•āĻžāϧāĻŋāĻ• āϰ⧋ āĻŦāĻž āĻŸā§‡āĻŦāĻŋāϞ āφāĻĒāĻĄā§‡āϟ āĻ•āϰāĻžāϰ āĻĨāĻžāϕ⧇, āϤāĻŦ⧇ āϕ⧋āĻĄā§‡ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻĒā§āϰāĻžāχāĻŽāĻžāϰāĻŋ-āĻ•āĻŋ (Primary Key) āĻŦāĻž āύāĻžāĻŽ āĻ…āύ⧁āϏāĻžāϰ⧇ āϏāĻ°ā§āϟ (Sort) āĻ•āϰ⧇ āφāĻĒāĻĄā§‡āϟ āϞ⧁āĻĒ āϚāĻžāϞāĻžāύ⧋ āωāϚāĻŋāϤāĨ¤
  2. āϛ⧋āϟ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ: āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āĻŦā§āϞāĻ• āϝāϤ āĻŦāĻĄāĻŧ āĻšāĻŦ⧇, āĻĄā§‡āĻĄāϞāĻ• āĻšāĻ“āϝāĻŧāĻžāϰ āϏāĻŽā§āĻ­āĻžāĻŦāύāĻž āϤāϤ āĻŦāĻžāĻĄāĻŧāĻŦ⧇āĨ¤ āϤāĻžāχ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āϝāϤāϟāĻž āϏāĻŽā§āĻ­āĻŦ āϛ⧋āϟ āϰāĻžāĻ–āĻžāĨ¤
  3. Optimistic Locking: āĻŸā§‡āĻŦāĻŋāϞ āĻŦāĻž āϰ⧋-āϕ⧇ āĻļāĻ•ā§āϤāĻ­āĻžāĻŦ⧇ āϞāĻ• (FOR UPDATE) āύāĻž āĻ•āϰ⧇, āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻĨ⧇ āĻāĻ•āϟāĻŋ version_number āϰāĻžāĻ–āĻž, āϝāĻžāϤ⧇ āϞāĻ• āĻ›āĻžāĻĄāĻŧāĻžāχ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻ­āĻžāĻ°ā§āϏāύ āĻŽāĻŋāϞāϞ⧇āχ āφāĻĒāĻĄā§‡āϟ āĻšāϝāĻŧāĨ¤

đŸ“Ļ 158. Database backup is taking too long. How to optimize?​

āĻŸā§‡āϰāĻžāĻŦāĻžāχāϟ āĻ¸ā§āϕ⧇āϞ⧇āϰ āĻĄā§‡āϟāĻžāĻŦ⧇āϏ āĻŦā§āϝāĻžāĻ•āφāĻĒ āύāĻŋāϤ⧇ āĻ•āϝāĻŧ⧇āĻ• āϘāĻŖā§āϟāĻž āĻĨ⧇āϕ⧇ āĻĻāĻŋāύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻŽāϝāĻŧ āϞāĻžāĻ—āϤ⧇ āĻĒāĻžāϰ⧇, āϝāĻž āĻĒā§āϰ⧋āĻĄāĻžāĻ•āĻļāύ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āĻŽāĻžāϰāĻžāĻ¤ā§āĻŽāĻ• āĻĄā§āϰāĻĒ āĻŦāĻž āĻ¸ā§āϞ⧋-āύ⧇āϏ⧇āϰ āϏ⧃āĻˇā§āϟāĻŋ āĻ•āϰ⧇āĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ…āĻĒāϟāĻŋāĻŽāĻžāχāϜ āĻ•āϰāĻŦ⧇āύ? āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻĒā§āϰāϏ⧇āϏāϕ⧇ āĻĢāĻžāĻ¸ā§āϟ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĒā§āϝāĻžāϰāĻžāϞāĻžāϞ āĻŦāĻž āĻŽāĻžāĻ˛ā§āϟāĻŋ-āĻĨā§āϰ⧇āĻĄā§‡āĻĄ āĻŦā§āϝāĻžāĻ•āφāĻĒ (Parallel Backups) āϟ⧁āϞāϏ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§ŸāĨ¤ āĻāĻ›āĻžāĻĄāĻŧāĻž āĻĒā§āϰ⧋āĻĄāĻžāĻ•āĻļāύ⧇āϰ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ⧇ āĻĒā§āϰāĻ­āĻžāĻŦ āύāĻž āĻĢ⧇āϞāϤ⧇ āĻĒā§āϰāĻžāχāĻŽāĻžāϰāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŦāĻĻāϞ⧇ āϰāĻŋāĻĄ-āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž āĻŦāĻž āĻ¸ā§āϞ⧇āĻ­ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āϰāĻžāύ āĻ•āϰāĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞ āĻ¸ā§āĻ¨ā§āϝāĻžāĻĒāĻļāϟ (EBS Snapshot) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻĄā§‡āϟāĻž āĻŦā§āϝāĻžāĻ•āφāĻĒ āύāĻž āύāĻŋāϝāĻŧ⧇, āχāύāĻ•ā§āϰāĻŋāĻŽā§‡āĻ¨ā§āϟāĻžāϞ āĻŦāĻž āĻĄā§‡āĻ˛ā§āϟāĻž āĻŦā§āϝāĻžāĻ•āφāĻĒ āύ⧇āϝāĻŧāĻž āĻāĻ•āϟāĻŋ āĻŦ⧇āĻ¸ā§āϟ āĻĒā§āĻ°ā§āϝāĻžāĻ•āϟāĻŋāϏāĨ¤

Technical summary: Optimizing slow database backups involves switching to parallel or multi-threaded backup tools and running the process on a read-replica node to offload the primary database. Using incremental backups instead of daily full backups, or utilizing fast physical storage snapshots (like AWS EBS snapshots), can significantly reduce backup duration.

🚀 Parallel backup strategies?​

  • āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āύ⧇āϟāĻŋāĻ­ āĻĄāĻžāĻŽā§āĻĒ āϟ⧁āϞ (āϝ⧇āĻŽāύ MySQL āĻāϰ mysqldump āĻŦāĻž Postgres āĻāϰ pg_dump) āϏāĻžāϧāĻžāϰāĻŖāϤ āϏāĻŋāĻ™ā§āĻ—āϞ-āĻĨā§āϰ⧇āĻĄā§‡ āϏāĻŋāϕ⧁āϝāĻŧ⧇āĻ¨ā§āϏāĻŋāϝāĻŧāĻžāϞāĻŋ āĻĄā§‡āϟāĻž āϰāĻŋāĻĄ āĻ•āϰ⧇, āϤāĻžāχ āĻ…āύ⧇āĻ• āĻ¸ā§āϞ⧋āĨ¤
  • āĻāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤ⧇ Parallel Backups āĻŦāĻž āĻŽāĻžāĻ˛ā§āϟāĻŋ-āĻĨā§āϰ⧇āĻĄāĻŋāĻ‚ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ (āϝ⧇āĻŽāύ: pg_dump -j 4 āĻŦāĻž Percona XtraBackup)āĨ¤ āĻāϤ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻĒā§āϰāϏ⧇āϏ āĻāĻ• āϏāĻžāĻĨ⧇ āĻāĻ•āĻžāϧāĻŋāĻ• āĻŸā§‡āĻŦāĻŋāϞ āĻĄāĻžāĻŽā§āĻĒ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āĻāĻŦāĻ‚ āĻŦā§āϝāĻžāĻ•āφāĻĒ⧇āϰ āϏāĻŽāϝāĻŧ āĻ•āϝāĻŧ⧇āĻ• āϗ⧁āĻŖ āĻ•āĻŽā§‡ āφāϏ⧇āĨ¤

âš–ī¸ Incremental vs full backup trade-offs?​

  • Full Backup: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻŽāĻ¸ā§āϤ āĻĄā§‡āϟāĻžāϰ āφāĻ¸ā§āϤ āĻ•āĻĒāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ āĻ…āύ⧇āĻ• āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻ–āĻžāϝāĻŧ āĻāĻŦāĻ‚ āĻ…āύ⧇āĻ• āĻ¸ā§āϞ⧋āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•ā§āϰāĻžāχāϏāĻŋāϏ⧇āϰ āϏāĻŽāϝāĻŧ āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāϤ⧇ āĻāϟāĻŋ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĢāĻžāĻ¸ā§āϟāĨ¤
  • Incremental Backup: āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āĻĢ⧁āϞ āĻŦā§āϝāĻžāĻ•āφāĻĒ āύāĻž āύāĻŋāϝāĻŧ⧇, āĻ—āϤ āĻĒāϰāĻļ⧁ āĻĨ⧇āϕ⧇ āφāϜ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻļ⧁āϧ⧁ āϝ⧇āϟ⧁āϕ⧁ āĻĄā§‡āϟāĻž āĻšā§‡āĻžā§āϜ āĻšāϝāĻŧ⧇āϛ⧇ (Write-Ahead Logs/BinLogs), āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϏ⧇āχ āϞāĻ—āϗ⧁āϞ⧋ āĻ•āĻĒāĻŋ āĻ•āϰāĻžāĨ¤ āĻāϟāĻŋ āϏāĻžāχāĻœā§‡ āϛ⧋āϟ āĻāĻŦāĻ‚ āĻ•āϝāĻŧ⧇āĻ• āĻŽāĻŋāύāĻŋāĻŸā§‡āχ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āϤāĻŦ⧇ āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āĻĢ⧁āϞ āĻŦā§āϝāĻžāĻ•āφāĻĒ⧇āϰ āϏāĻžāĻĨ⧇ āϏāĻŦ āχāύāĻ•ā§āϰāĻŋāĻŽā§‡āĻ¨ā§āϟāĻžāϞ āĻĢāĻžāχāϞ āĻœā§‹āĻĄāĻŧāĻž āϞāĻžāĻ—āĻŋāϝāĻŧ⧇ āϰāĻžāύ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ, āϝāĻž āϰāĻŋāĻ¸ā§āĻŸā§‹āϰ⧇āĻļāύāϕ⧇ āĻ¸ā§āϞ⧋ āĻ•āϰ⧇āĨ¤

    💡 Best Practice: āϏāĻĒā§āϤāĻžāĻšā§‡ āĻāĻ•āĻĻāĻŋāύ āĻĢ⧁āϞ āĻŦā§āϝāĻžāĻ•āφāĻĒ āĻāĻŦāĻ‚ āĻŦāĻžāĻ•āĻŋ ā§Ŧ āĻĻāĻŋāύ āχāύāĻ•ā§āϰāĻŋāĻŽā§‡āĻ¨ā§āϟāĻžāϞ āĻŦā§āϝāĻžāĻ•āφāĻĒ āύ⧇āϝāĻŧāĻžāĨ¤

đŸ›Ąī¸ How to backup without affecting production?​

āĻŦā§āϝāĻžāĻ•āφāĻĒ āύ⧇āϝāĻŧāĻžāϰ āϏāĻŽāϝāĻŧ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ āĻĄāĻŋāĻ¸ā§āĻ• āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ⧇ (I/O) āĻĒā§āϰ⧇āĻļāĻžāϰ āĻĻ⧇āϝāĻŧ āĻāĻŦāĻ‚ āĻŸā§‡āĻŦāĻŋāϞāĻ“ āϞāĻ• (Table Locking) āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • Solution 1 (Physical Snapshot): AWS (EBS Snapshot) āĻŦāĻž LVM (Logical Volume Manager) āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇āϰ āĻ¸ā§āĻ¨ā§āϝāĻžāĻĒāĻļāϟ āύ⧇āĻ“āϝāĻŧāĻž, āϝāĻž āĻĢā§āĻ°ā§āϝāĻžāĻ•āĻļāύ āĻ…āĻĢ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āϕ⧋āύ⧋ āχāĻĢ⧇āĻ•ā§āϟāχ āĻ…āύ⧁āĻ­āĻŦ āĻ•āϰ⧇ āύāĻžāĨ¤
  • Solution 2 (Slave Backup): āĻ•āĻ–āύ⧋āχ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ (Primary) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āύāĻž āύ⧇āĻ“āϝāĻŧāĻžāĨ¤ āĻāĻ•āϟāĻŋ āϰāĻŋāĻĄ-āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž āĻŦāĻž āĻ¸ā§āϞ⧇āĻ­ (Secondary) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĨ⧇āϕ⧇ āĻŦā§āϝāĻžāĻ•āφāĻĒ āϰāĻžāύ āĻ•āϰāĻž, āϝāĻžāϤ⧇ āĻĒā§āϰ⧋āĻĄāĻžāĻ•āĻļāύ⧇āϰ āϰāĻžāχāĻĄ/āϰāĻŋāĻĄ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ⧇ āĻŦāĻŋāĻ¨ā§āĻĻ⧁āĻŽāĻžāĻ¤ā§āϰ āϕ⧋āύ⧋ āχāĻŽāĻĒā§āϝāĻžāĻ•ā§āϟ āύāĻž āĻĒāĻĄāĻŧ⧇āĨ¤ īŋŊīŋŊāĻŧ Connection Pool āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āωāϚāĻŋāϤāĨ¤