Canary Deployments Kotlin के साथ: बिना डर के सुरक्षित रिलीज़

सामान्य डिप्लॉय हमेशा एक लॉटरी क्यों होता है?

हर डेवलपर ने कम से कम एक बार उस पल का अनुभव किया है: जब आप "Deploy" बटन दबाते हैं, और दिल धड़कने लगता है। क्या होगा अगर नया वर्ज़न डेटाबेस को क्रैश कर दे? क्या होगा अगर यूज़र्स को होमपेज के बजाय 500 एरर दिखे?

सामान्य डिप्लॉय बिना रिज़र्व पैराशूट के कूदने जैसा है। या तो सब कुछ सही काम करता है, या फिर आप रात भर लॉग्स में खोजते रहते हैं कि क्या गलत हुआ। लेकिन इस प्रक्रिया को सुरक्षित बनाने का एक तरीका है — Canary Deployments (कैनरी डिप्लॉयमेंट).

इस लेख में, हम सीखेंगे कि Kotlin में Ktor और एक सरल लोड बैलेंसर का उपयोग करके Canary Deployment कैसे लागू करें। आप सीखेंगे कि नए कोड को पहले केवल 5% यूज़र्स तक कैसे पहुँचाएँ, और फिर धीरे-धीरे ट्रैफ़िक कैसे बढ़ाएँ। और हाँ, हम वह कोड लिखेंगे जो वास्तव में काम करता है।

Canary Deployment क्या है और आपको इसकी आवश्यकता क्यों है?

कल्पना करें कि आप एक जहाज़ के कप्तान हैं। सीधे चट्टानों के बीच से जाने के बजाय, आप पहले एक छोटी नाव (कैनरी) भेजते हैं। अगर वह सुरक्षित निकल जाती है, तो पूरा बेड़ा चलता है। अगर वह डूब जाती है, तो आप केवल एक नाव खोते हैं।

IT की दुनिया में यह इस तरह दिखता है: आप अपने सर्विस के नए वर्ज़न को पहले यूज़र्स के एक छोटे समूह के लिए डिप्लॉय करते हैं। अगर मेट्रिक्स सही हैं, तो ट्रैफ़िक बढ़ता है। अगर नहीं, तो आप सेकंडों में रोलबैक कर लेते हैं।

फ़ायदे स्पष्ट हैं:

\n
• जोखिम कम करना — बग्स केवल 1-5% ऑडियंस को प्रभावित करते हैं।
\n
• त्वरित फीडबैक — आप त्रुटियों को आपदा बनने से पहले देख लेते हैं।
\n
• A/B टेस्टिंग — पुराने और नए वर्ज़न के प्रदर्शन की तुलना कर सकते हैं।
\n
• Zero Downtime — यूज़र्स को स्विचिंग का पता नहीं चलता।
\n

लेकिन एक कमी भी है: आपको ट्रैफ़िक प्रबंधित करना, मेट्रिक्स की निगरानी करना और प्रक्रिया को स्वचालित करना आना चाहिए। Kotlin अपनी सरलता और कोरूटीन्स के साथ इस कार्य के लिए एकदम सही है।

Kotlin पर Canary Deployment की आर्किटेक्चर

चलिए एक सरल लेकिन काम करने वाली आर्किटेक्चर बनाते हैं। इसमें होगा:

\n
• लोड बैलेंसर — यह तय करता है कि कितने प्रतिशत रिक्वेस्ट पुराने वर्ज़न (stable) पर जाएँ और कितने नए (canary) पर।
\n
• सर्विस के दो इंस्टेंस — stable और canary, दोनों Kotlin और Ktor में लिखे गए।
\n
• मॉनिटरिंग — एरर काउंटर और रिस्पॉन्स टाइम।
\n

लोड बैलेंसर X-Canary हेडर या रैंडम डिस्ट्रीब्यूशन के आधार पर निर्णय लेगा। हम दूसरे तरीके का उपयोग करेंगे — यह वास्तविकता के करीब है।

कोड लिखना: Kotlin में लोड बैलेंसर

चलिए लोड बैलेंसर से शुरू करते हैं। यह रिक्वेस्ट प्राप्त करेगा और उन्हें दो सर्विसेज में से एक पर भेजेगा। सरलता के लिए, हम Ktor के बिल्ट-इन HTTP क्लाइंट का उपयोग करेंगे।

import io.ktor.client.*\nimport io.ktor.client.engine.cio.*\nimport io.ktor.client.request.*\nimport io.ktor.client.statement.*\nimport io.ktor.server.application.*\nimport io.ktor.server.engine.*\nimport io.ktor.server.netty.*\nimport io.ktor.server.response.*\nimport io.ktor.server.routing.*\nimport kotlinx.coroutines.runBlocking\nimport kotlin.random.Random\n\n// कॉन्फ़िगरेशन\nconst val STABLE_URL = "http://localhost:8081"\nconst val CANARY_URL = "http://localhost:8082"\nvar canaryPercent = 5 // 5% ट्रैफ़िक से शुरू करें\n\nfun main() {\n    val client = HttpClient(CIO)\n\n    embeddedServer(Netty, port = 8080) {\n        routing {\n            get("/api/data") {\n                val useCanary = Random.nextInt(100) < canaryPercent\n                val targetUrl = if (useCanary) CANARY_URL else STABLE_URL\n\n                val response = runBlocking {\n                    client.get("$targetUrl/api/data")\n                }\n\n                call.respondText(\n                    response.bodyAsText(),\n                    contentType = response.contentType()\n                )\n            }\n\n            // कैनरी प्रतिशत बदलने के लिए एंडपॉइंट\n            get("/canary/set/{perc