40 इंटरैक्टिव पाठों में सिस्टम डिज़ाइन सीखें। लोड बैलेंसिंग, कैश और डेटाबेस समझें और URL शॉर्टनर, न्यूज़ फ़ीड और चैट सिस्टम डिज़ाइन करें।
TCP और TLS से पहली बार जुड़ते समय ब्राउज़र डोमेन का पता खोजता है, सुरक्षित कनेक्शन बनाता है और HTTP अनुरोध भेजता है। फिर वह सर्वर की प्रतिक्रिया दिखाता है।
नेटवर्क नाम से नहीं, संख्या वाले IP पते से रूट करते हैं। इसलिए ब्राउज़र पहले एक DNS रिज़ॉल्वर से पूछता है: shop.example कहाँ है?
जवाब (203.0.113.7) लगभग 20 ms में लौट आता है।
अब ब्राउज़र 203.0.113.7 से कनेक्शन खोलता है। TCP हैंडशेक बातचीत तय करता है; TLS हैंडशेक एन्क्रिप्शन सेट करता है। हर एक को एक राउंड ट्रिप चाहिए: जाना और लौटना।
यहाँ एक राउंड ट्रिप 30 ms लेता है, इसलिए पेज का एक भी बाइट माँगने से पहले कनेक्ट करने में 60 ms लग जाते हैं।
खुले कनेक्शन पर ब्राउज़र GET /products भेजता है। सर्वर उसे पार्स करता है, सेशन जाँचता है और आपका कोड चलाता है।
इसमें एक और राउंड ट्रिप और ~10 ms सर्वर का काम लगता है।
प्रोडक्ट वेब सर्वर में नहीं, एक डेटाबेस में रहते हैं। सर्वर क्वेरी भेजता है और पंक्तियों के लौटने का इंतज़ार करता है।
देखिए कैसे एक अनुरोध पूरे रास्ते अंदर जाता है और जवाब पूरे रास्ते बाहर आता है।
सर्वर पंक्तियों को HTML में बदलकर वापस भेजता है; डाउनलोड में 20 ms और लगते हैं। Enter दबाने के 155 ms बाद ब्राउज़र पेज दिखा देता है।
फिर वह पेज में इमेज और स्टाइलशीट देखता है और और अनुरोध भेजता है। खुला कनेक्शन दोबारा इस्तेमाल करने से उनका हैंडशेक बच जाता है।
एक पेज लोड को हॉप-दर-हॉप फ़ॉलो करें, और जानें कि समय असल में कहाँ जाता है।
रफ़्तार के बारे में दो सवाल, और व्यस्त सर्वर भरने से पहले ही धीमे क्यों हो जाते हैं।
ऐसे हिसाब से जो एक नैपकिन पर आ जाए, किसी प्रोडक्ट आइडिया को सर्वर और टेराबाइट में बदलिए।
आपका इकलौता सर्वर पिघल रहा है। बड़ा सर्वर खरीदें, या ज़्यादा सर्वर?
कई सर्वरों के लिए एक मुख्य दरवाज़ा, और यह तय करने के नियम कि कौन-सा अनुरोध किसे मिले।
अगला अनुरोध किसी भी सर्वर पर क्यों चलना चाहिए, और स्टेट उसकी जगह कहाँ जाता है।
लोग जो जवाब सबसे ज़्यादा माँगते हैं, उन्हें डेटाबेस से कहीं तेज़ जगह पर रखिए।
जो सब डाउनलोड करते हैं, उसे उपयोगकर्ताओं के पास के सर्वरों पर कॉपी कीजिए, और प्रकाश की गति से लड़ना बंद कीजिए।
टेबल, डॉक्यूमेंट या सादी कुंजियाँ: हर तरह का डेटाबेस किसमें अच्छा है, और क्या छोड़ देता है।
एक ही क्वेरी दो सेकंड या दो मिलीसेकंड क्यों ले सकती है।
डेटाबेस आपके write के साथ असल में क्या करता है — और क्यों कुछ इंजन reads के लिए बने हैं और कुछ writes के लिए।
डेटाबेस की कॉपियाँ कई मशीनों पर रखिए — ज़्यादा reads के लिए और बचे रहने के लिए।
जब डेटा या writes एक मशीन से बड़े हो जाएँ, तो उन्हें कई मशीनों में बाँट दीजिए।
सर्वर जोड़िए या हटाइए, और डेटा का बस एक पतला-सा हिस्सा खिसकाइए।
हर row को ऐसा नाम देना जो कोई और कभी इस्तेमाल न करे — बिना एक ऐसे counter के जिसके लिए सबको कतार लगानी पड़े।
जब network टूटता है, तो आपके डेटा की कॉपियों को सही होने और पहुँच में रहने के बीच चुनना पड़ता है।
सर्वरों का एक समूह एक leader और एक इतिहास पर कैसे सहमत होता है — तब भी जब कुछ तक पहुँचा न जा सके।
दो लोग, एक सीट, एक ही millisecond। डेटाबेस एक साथ होने वाले बदलावों को सही कैसे रखते हैं।
फ़ोटो और वीडियो आपके डेटाबेस में नहीं रखे जाते: वे इसके बजाय कहाँ जाते हैं, और वहाँ तक कैसे पहुँचते और लौटते हैं।
प्रोग्राम एक-दूसरे से चीज़ें माँगने के तीन तरीके, और हर तरीका 4G पर चल रहे फ़ोन को कितना महँगा पड़ता है।
तुरंत जवाब दीजिए, धीमा काम बाद में कीजिए, और रास्ते में कभी कोई जॉब मत खोइए।
बताइए कि कुछ हुआ है, और जिसे परवाह हो उसे प्रतिक्रिया देने दीजिए, बिना किसी के इंतज़ार किए।
सर्वर आपको कैसे बताता है कि कुछ हुआ: चैट, लाइव स्कोर, नोटिफ़िकेशन।
आख़िरकार सब कुछ फ़ेल होता है। ऐसे डिज़ाइन कीजिए कि कोई एक अकेली ख़राबी आपको गिरा न दे।
हर क्लाइंट को एक उचित बजट दीजिए, ताकि बेक़ाबू हुई कोई एक स्क्रिप्ट सबको न गिरा दे।
मुश्किल में फँसी सर्विस को सुरक्षित ढंग से कॉल करना: समय पर हार मानिए, सावधानी से दोबारा कोशिश कीजिए, और जानिए कब रुकना है।
मेट्रिक्स, लॉग और ट्रेस: जल्दी पता करना कि क्या गड़बड़ है, कहाँ और क्यों।
एक कोडबेस या कई सर्विसें? हर एक से क्या मिलता है, क्या कीमत चुकानी पड़ती है, और एक से दूसरे पर कैसे जाएँ।
जब इंस्टेंस आते-जाते रहते हैं, तब सर्विसें एक-दूसरे को कैसे ढूँढती हैं, और बाहर वालों के लिए एक ही मुख्य दरवाज़ा।
एक काम, कई सर्विसें, कई डेटाबेस: एक बड़े ट्रांज़ैक्शन के बिना सब-या-कुछ-नहीं कैसे बनाए रखें।
अरबों इवेंट प्रोसेस करना: रात में बड़े बैच में, या आते-आते लगातार।
यह साबित करना कि कोई कौन है, बिना उसके पासवर्ड के लीक होने की वजह बने।
यह जानना कि कोई कौन है, यह नहीं बताता कि वह क्या देख या कर सकता है। हर जगह इसकी जाँच।
नेटवर्क पर और डिस्क पर डेटा की सुरक्षा, और उन चाबियों और पासवर्ड की भी जो आपकी सर्विस इस्तेमाल करती हैं।
यूज़र के पता लगाने से पहले जानना कि बदलाव सुरक्षित है: लॉजिक के लिए तेज़ टेस्ट, बाकी सब के लिए कुछ धीमे।
हर बदलाव को जल्दी और सुरक्षित रूप से प्रोडक्शन तक पहुँचाना, और उतनी ही जल्दी वापस लेना।
एक ही सिस्टम, दो ज़ूम लेवल पर: सर्विसों का नक्शा, और उनमें से एक का अंदरूनी हिस्सा।
पहला शुरू से आख़िर तक का डिज़ाइन: एक लाइन के ब्रीफ़ से अरबों रीडायरेक्ट संभालने वाले सिस्टम तक।
जिन्हें आप फ़ॉलो करते हैं, उन सबकी पोस्ट 200 ms में, और यह सवाल कि काम कब किया जाए।
दो करोड़ खुले कनेक्शन और एक वादा: हर मैसेज पहुँचेगा, क्रम से, ठीक एक बार।