ASP.NET Core में एक साधारण API गेटवे बनाएं

नमस्कार, हेब्र! मैं आपको " ASP.NET कोर में एक साधारण एपीआई गेटवे बनाना " लेख का अनुवाद प्रस्तुत करता हूं।

पढ़ने के लिए 10 मिनट

मेरे पिछले लेख में, .NET में माइक्रोसॉफ़्ट के लिए JWT ऑथेंटिकेशन , मैंने उपयोगकर्ता प्रमाणीकरण के लिए एक माइक्रोसैस सर्विस बनाने की प्रक्रिया को देखा। इसका उपयोग सिस्टम के अन्य घटकों में किसी भी क्रिया को करने से पहले उपयोगकर्ता की पहचान को सत्यापित करने के लिए किया जा सकता है।

उत्पाद के काम करने के लिए एक अन्य महत्वपूर्ण घटक एक एपीआई गेटवे है - एप्लिकेशन और बैकएंड के बीच की एक प्रणाली, जो, सबसे पहले, संबंधित माइक्रोसर्विस के लिए आने वाले अनुरोधों को रूट करता है, और दूसरी बात, उपयोगकर्ता को अधिकृत करता है।

ऐसे कई फ्रेमवर्क हैं जिनका उपयोग एपीआई गेटवे बनाने के लिए किया जा सकता है, उदाहरण के लिए, जावा में .NET कोर या नेटफ्लिक्स ज़ूल में ओसेलॉट। हालांकि, इस लेख में मैं .NET कोर में स्क्रैच से एक साधारण एपीआई गेटवे बनाने की प्रक्रिया का वर्णन करूंगा।

परियोजना निर्माण

सबसे पहले, प्रोजेक्ट निर्माण विंडो में ASP.NET कोर वेब एप्लिकेशन का चयन करके एक नया एप्लिकेशन बनाएं और टेम्पलेट के रूप में खाली करें ।

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

app.Run(async (context) => { await context.Response.WriteAsync("Hello, World!"); }); 

राउटर वर्तनी

चूंकि यह कॉन्फ़िगर विधि में है कि हम अनुरोधों को संसाधित करेंगे, हम आवश्यक तर्क लिखेंगे:

 Router router = new Router("routes.json"); app.Run(async (context) => { var content = await router.RouteRequest(context.Request); await context.Response.WriteAsync(await content.Content.ReadAsStringAsync()); }); 

पहले हम राउटर का एक प्रकार बनाते हैं। उनके कार्यों में मौजूदा मार्गों को संग्रहीत करना, मार्गों के अनुसार अनुरोधों को मान्य करना और भेजना शामिल है। कोड को क्लीनर बनाने के लिए, हम JSON फ़ाइल से मार्गों को लोड करेंगे।

परिणाम निम्न तर्क है: गेटवे पर अनुरोध आने के बाद, इसे राउटर पर पुनर्निर्देशित किया जाएगा, जो बदले में, इसे संबंधित माइक्रो सर्विस पर भेज देगा।

राउटर वर्ग लिखने से पहले, एक path.json फ़ाइल बनाएं। इस फ़ाइल में, हम मार्गों की एक सूची दर्शाते हैं, जिनमें से प्रत्येक में एक बाहरी पता (समापन बिंदु) और एक गंतव्य पता (गंतव्य) होगा। साथ ही, हम उपयोगकर्ता को पुनर्निर्देशित करने से पहले अधिकृत करने की आवश्यकता का संकेत देते हुए एक ध्वज जोड़ेंगे।

यहाँ फ़ाइल की तरह लग सकता है:

 { "routes": [ { "endpoint": "/movies", "destination": { "uri": "http://localhost:8090/movies/", "requiresAuthentication": "true" } }, { "endpoint": "/songs", "destination": { "uri": "http://localhost:8091/songs/", "requiresAuthentication": "false" } } ], "authenticationService": { "uri": "http://localhost:8080/api/auth/" } } 

एक गंतव्य वर्ग बनाएं

अब हम जानते हैं कि प्रत्येक रूट का endpoint और गंतव्य होना चाहिए, और प्रत्येक गंतव्य के पास uri और requiresAuthentication होनी requiresAuthentication ।

अब याद करते हैं कि डेस्टिनेशन क्लास लिखते हैं। मैं दो क्षेत्रों, दो कंस्ट्रक्टरों और एक निजी कंस्ट्रक्टर को JSON डिसेरलाइज़ेशन के मापदंडों के बिना जोड़ूंगा।

 public class Destination { public string Uri { get; set; } public bool RequiresAuthentication { get; set; } public Destination(string uri, bool requiresAuthentication) { Uri = path; RequiresAuthentication = requiresAuthentication; } public Destination(string uri) :this(uri, false) { } private Destination() { Uri = "/"; RequiresAuthentication = false; } } 

साथ ही, इस कक्षा में SendRequest विधि लिखना सही होगा। यह दिखाएगा कि अनुरोध भेजने के लिए गंतव्य वर्ग का प्रत्येक ऑब्जेक्ट जिम्मेदार होगा। यह विधि HttpRequest प्रकार का एक ऑब्जेक्ट लेगी, जो आने वाले अनुरोध का वर्णन करता है, वहां से सभी आवश्यक जानकारी निकालता है, और अनुरोध को लक्ष्य URI को भेजता है। ऐसा करने के लिए, हम एक सहायक विधि CreateDestinationUri लिखते हैं, जो क्लाइंट के पते और एड्रेस लाइन (क्वेरी स्ट्रिंग) के मापदंडों के साथ लाइनों को जोड़ देगा।

  private string CreateDestinationUri(HttpRequest request) { string requestPath = request.Path.ToString(); string queryString = request.QueryString.ToString(); string endpoint = ""; string[] endpointSplit = requestPath.Substring(1).Split('/'); if (endpointSplit.Length > 1) endpoint = endpointSplit[1]; return Uri + endpoint + queryString; } 

अब हम एक SendRequest विधि लिख सकते हैं जो एक microservice के लिए एक अनुरोध भेजेगा और एक प्रतिक्रिया वापस प्राप्त करेगा।

 public async Task<HttpResponseMessage> SendRequest(HttpRequest request) { string requestContent; using (Stream receiveStream = request.Body) { using (StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8)) { requestContent = readStream.ReadToEnd(); } } HttpClient client = new HttpClient(); HttpRequestMessage newRequest = new HttpRequestMessage(new HttpMethod(request.Method), CreateDestinationUri(request)); HttpResponseMessage response = await client.SendAsync(newRequest); return response; } 

एक JSON पार्सर बनाएं।

राउटर वर्ग लिखने से पहले, हमें मार्गों के साथ JSON फ़ाइल को डिस्क्राइब करने के लिए तर्क बनाने की आवश्यकता है। मैं इसके लिए एक सहायक वर्ग बनाऊंगा, जिसमें दो विधियाँ होंगी: एक JSON फ़ाइल से एक ऑब्जेक्ट बनाने के लिए, और दूसरा डीसर्लाइज़ेशन के लिए।

 public class JsonLoader { public static T LoadFromFile<T>(string filePath) { using (StreamReader reader = new StreamReader(filePath)) { string json = reader.ReadToEnd(); T result = JsonConvert.DeserializeObject<T>(json); return result; } } public static T Deserialize<T>(object jsonObject) { return JsonConvert.DeserializeObject<T>(Convert.ToString(jsonObject)); } } 

कक्षा राउटर।

राउटर लिखने से पहले हम जो आखिरी काम करेंगे, वह मार्ग मॉडल का वर्णन करना है:

  public class Route { public string Endpoint { get; set; } public Destination Destination { get; set; } } 

अब खेतों और एक कंस्ट्रक्टर को जोड़कर राउटर क्लास लिखें।

 public class Router { public List<Route> Routes { get; set; } public Destination AuthenticationService { get; set; } public Router(string routeConfigFilePath) { dynamic router = JsonLoader.LoadFromFile<dynamic>(routeConfigFilePath); Routes = JsonLoader.Deserialize<List<Route>>( Convert.ToString(router.routes) ); AuthenticationService = JsonLoader.Deserialize<Destination>( Convert.ToString(router.authenticationService) ); } } 

मैं JSON से पढ़ने और इसके लिए ऑब्जेक्ट गुण लिखने के लिए एक गतिशील प्रकार का उपयोग करता हूं।

अब सब कुछ एपीआई गेटवे की मुख्य कार्यक्षमता का वर्णन करने के लिए तैयार है: मार्ग और उपयोगकर्ता प्राधिकरण, जो कि RouteRequest विधि में होगा। हमें अनुरोध ऑब्जेक्ट से बाहरी पते (बेस एंडपॉइंट) के आधार भाग को अनपैक करने की आवश्यकता है। उदाहरण के लिए, पते /movies/add आधार /movies/ । उसके बाद, हमें यह जांचने की आवश्यकता है कि क्या इस मार्ग का विवरण है। यदि ऐसा है, तो उपयोगकर्ता को अधिकृत करें और अनुरोध भेजें, अन्यथा हम एक त्रुटि लौटाते हैं। मैंने सुविधा के लिए ConstructErrorMessage वर्ग भी बनाया।

प्राधिकरण के लिए, मैंने निम्न तरीके को प्राथमिकता दी: हम अनुरोध हेडर से टोकन निकालते हैं और इसे अनुरोध पैरामीटर के रूप में भेजते हैं। एक अन्य विकल्प संभव है: हेडर में एक टोकन छोड़ दें, फिर माइक्रोसेवा से अनुरोध करने का इरादा पहले से ही इसे निकालना चाहिए।

 public async Task<HttpResponseMessage> RouteRequest(HttpRequest request) { string path = request.Path.ToString(); string basePath = '/' + path.Split('/')[1]; Destination destination; try { destination = Routes.First(r => r.Endpoint.Equals(basePath)).Destination; } catch { return ConstructErrorMessage("The path could not be found."); } if (destination.RequiresAuthentication) { string token = request.Headers["token"]; request.Query.Append(new KeyValuePair<string, StringValues>("token", new StringValues(token))); HttpResponseMessage authResponse = await AuthenticationService.SendRequest(request); if (!authResponse.IsSuccessStatusCode) return ConstructErrorMessage("Authentication failed."); } return await destination.SendRequest(request); } private HttpResponseMessage ConstructErrorMessage(string error) { HttpResponseMessage errorMessage = new HttpResponseMessage { StatusCode = HttpStatusCode.NotFound, Content = new StringContent(error) }; return errorMessage; } 

निष्कर्ष

एक बुनियादी एपीआई गेटवे बनाने के लिए बहुत प्रयास की आवश्यकता नहीं होती है, लेकिन यह उचित कार्यक्षमता प्रदान नहीं करता है। यदि आपको एक लोड बैलेंसर की आवश्यकता है, तो आप मौजूदा फ्रेमवर्क या प्लेटफ़ॉर्म को देख सकते हैं जो रूटिंग अनुरोधों के लिए पुस्तकालयों की पेशकश करते हैं।

इस लेख के सभी कोड GitHub रिपॉजिटरी में उपलब्ध हैं ।