ओकाम रूटिंग: सुरक्षित एंड-टू-एंड चैनल बनाना

ओकाम प्रोग्रामिंग लाइब्रेरीज़, कमांड लाइन टूल्स और प्रबंधित क्लाउड सेवाओं का एक सूट है जो एंड-टू-एंड एन्क्रिप्शन, पारस्परिक प्रमाणीकरण, कुंजी प्रबंधन, क्रेडेंशियल प्रबंधन और प्राधिकरण नीति प्रवर्तन को बड़े पैमाने पर व्यवस्थित करता है। ओकाम का अंत-से-अंत एप्लिकेशन स्तर पर गतिमान सभी डेटा की प्रामाणिकता, अखंडता और गोपनीयता की गारंटी देता है। सुरक्षित चैनल इसे संभव बनाने वाली प्रमुख विशेषताओं में से एक है . रूटिंग हमें मल्टी-हॉप, मल्टी-प्रोटोकॉल मार्गों पर सुरक्षित चैनल बनाने की अनुमति देता है जो विभिन्न नेटवर्क टोपोलॉजी (NAT फ़ायरवॉल के पीछे सर्वर, बिना बाहरी पोर्ट खुले आदि) और ट्रांसपोर्ट प्रोटोकॉल (टीसीपी, यूडीपी, वेबसॉकेट, बीएलई, आदि) तक फैल सकता है। ओकाम रूटिंग इस ब्लॉग पोस्ट में, हम एपीआई का पता लगाएंगे और देखेंगे कि ओकैम में रूटिंग कैसे काम करती है। हम रस्ट कोड के साथ काम करेंगे और कुछ कोड उदाहरण देखेंगे जो सरल केस और अधिक उन्नत उपयोग के मामलों को प्रदर्शित करते हैं। ओकैम रस्ट सामग्री अवलोकन जोखिम को कम करना हमारी यात्रा सरल उदाहरण जटिल उदाहरण आरंभकर्ता नोड मध्य नोड प्रत्युत्तरकर्ता नोड अगले कदम जोखिम को कम करना आरंभ करने से पहले, आइए सुरक्षित अनुप्रयोगों के लिए मौजूदा दृष्टिकोणों का उपयोग करने के नुकसानों पर शीघ्रता से चर्चा करें। सुरक्षा कोई ऐसी चीज़ नहीं है जिसके बारे में हममें से अधिकांश लोग तब सोचते हैं जब हम सिस्टम का निर्माण कर रहे होते हैं और काम करने और शिपिंग पर ध्यान केंद्रित करते हैं। पारंपरिक सुरक्षित संचार कार्यान्वयन आमतौर पर परिवहन प्रोटोकॉल के साथ इस तरह से कसकर जुड़े होते हैं कि उनकी सभी सुरक्षा एक अंतर्निहित परिवहन कनेक्शन की लंबाई और अवधि तक सीमित होती है। उदाहरण के लिए, अधिकांश टीएलएस कार्यान्वयन अंतर्निहित टीसीपी कनेक्शन के साथ मजबूती से जुड़े हुए हैं। यदि आपके एप्लिकेशन का डेटा और अनुरोध दो टीसीपी कनेक्शन हॉप्स (टीसीपी → टीसीपी) पर यात्रा करते हैं, तो सभी टीएलएस दोनों नेटवर्क के बीच पुल टूटने की गारंटी देते हैं। यह ब्रिज, गेटवे या लोड बैलेंसर एप्लिकेशन डेटा के लिए कमजोरी का बिंदु बन जाता है। पारंपरिक सुरक्षित संचार प्रोटोकॉल भी आपके एप्लिकेशन के डेटा की सुरक्षा करने में असमर्थ हैं यदि यह कई अलग-अलग परिवहन प्रोटोकॉल पर यात्रा करता है। यदि आपके एप्लिकेशन का संचार पथ यूडीपी → टीसीपी या बीएलई → टीसीपी है तो वे डेटा प्रामाणिकता या डेटा अखंडता की गारंटी नहीं दे सकते। दूसरे शब्दों में, पारंपरिक सुरक्षित संचार कार्यान्वयन का उपयोग करके आप उस डेटा पर विश्वास खोने के द्वार खोल रहे हैं जिस पर आपके ऐप्स काम कर रहे हैं। यहां आपके ऐप्स के कुछ पहलू दिए गए हैं जो जोखिम में हो सकते हैं: आपके ऐप को किसी अन्य इकाई से प्राप्त होने वाले डेटा पर विश्वास की कमी। इसे मेरे ऐप पर किसने भेजा? क्या यह वास्तव में वही डेटा है जो उन्होंने मेरे ऐप पर भेजा था? प्रमाणीकरण और डेटा अखंडता गुम है. आपका ऐप किसी अन्य इकाई को जो डेटा भेजता है, उस पर भरोसे की कमी। मैं डेटा किसे भेजूं? क्या वे इसे किसी और के साथ देख पाएंगे? हमारी यात्रा इस ब्लॉग पोस्ट में, हम ओकैम रूटिंग और ओकैम ट्रांसपोर्ट्स का उपयोग करके एक दूसरे के साथ संचार करने वाले ओकैम नोड्स के दो उदाहरण बनाएंगे। हम इन ओकाम नोड्स को बनाने और ओकैम रूटिंग ऑर्केस्ट्रेशन को सेट करने के लिए उपयोग करेंगे। ओकैम रूटिंग और ट्रांसपोर्ट अन्य ओकैम प्रोटोकॉल को एप्लिकेशन स्तर पर विश्वास, सुरक्षा, गोपनीयता, विश्वसनीय डिलीवरी और ऑर्डरिंग जैसी एंड-टू-एंड गारंटी प्रदान करने में सक्षम बनाते हैं। रस्ट एपीआई का : एक सरल और हल्का संदेश-आधारित प्रोटोकॉल है जो विभिन्न प्रकार की संचार टोपोलॉजी पर संदेशों का द्विदिश आदान-प्रदान करना संभव बनाता है: टीसीपी -> टीसीपी या टीसीपी -> टीसीपी -> टीसीपी या बीएलई -> यूडीपी -> टीसीपी या बीएलई -> टीसीपी -> टीसीपी या टीसीपी -> काफ्का -> टीसीपी या कोई अन्य टोपोलॉजी जिसकी आप कल्पना कर सकते हैं। ओकाम रूटिंग : विभिन्न परिवहन प्रोटोकॉल के लिए ओकाम रूटिंग को अनुकूलित करें। ओक्कम परिवहन ओकैम नोड कोई भी चालू एप्लिकेशन है जो विभिन्न ओकैम प्रोटोकॉल जैसे रूटिंग, रिले और पोर्टल्स, सिक्योर चैनल इत्यादि का उपयोग करके अन्य एप्लिकेशन के साथ संचार कर सकता है। ओकैम नोड को किसी भी स्वतंत्र प्रक्रिया के रूप में परिभाषित किया जा सकता है जो ओकैम रूटिंग प्रोटोकॉल का समर्थन करने वाला एपीआई प्रदान करता है। हम इसका उपयोग करके ओकाम नोड्स बना सकते हैं ( कमांड) या हमारे रस्ट और एलिक्सिर लाइब्रेरी जैसे विभिन्न ओकैम प्रोग्रामिंग लाइब्रेरी का उपयोग कर रहे हैं। हम इस ब्लॉग पोस्ट में रस्ट एपीआई का उपयोग करेंगे। ओकम कमांड लाइन इंटरफ़ेस (सीएलआई) ockam जब एक कार्यकर्ता को शुरू किया जाता है , इसे एक या अधिक पते दिए गए हैं। नोड प्रत्येक पते के लिए एक मेलबॉक्स रखता है और जब भी किसी विशिष्ट पते के लिए कोई संदेश आता है तो यह उस संदेश को संबंधित पंजीकृत कार्यकर्ता को भेजता है। नोड सरल उदाहरण हमारे पहले उदाहरण के लिए, हम एक सरल ओकाम नोड बनाएंगे जो एक कार्यकर्ता को (उसी नोड में) कुछ हॉप्स पर एक संदेश भेजेगा जो संदेश को वापस प्रतिध्वनित करता है। इसमें कोई टीसीपी ट्रांसपोर्ट शामिल नहीं है और सभी संदेश एक ही नोड के अंदर आगे और पीछे भेजे जा रहे हैं। इससे हमें बुनियादी स्तर पर निर्माण श्रमिकों और रूटिंग का अनुभव मिलेगा। हमें एक प्रोग्राम के साथ एक रस्ट स्रोत फ़ाइल और दो श्रमिकों के साथ दो अन्य रस्ट स्रोत फ़ाइलें बनाने की आवश्यकता होगी: और । फिर हम एक स्ट्रिंग संदेश भेज सकते हैं और देख सकते हैं कि क्या हम इसे वापस प्रतिध्वनित कर सकते हैं। main() Hopper Echoer शुरू करने से पहले आइए रूटिंग पर विचार करें। जब हम एक नोड के अंदर एक संदेश भेजते हैं तो यह अपने साथ 2 मेटाडेटा फ़ील्ड, और ले जाता है, जहां एक केवल की एक सूची है। प्रत्येक कार्यकर्ता को एक नोड में एक मिलता है। onward_route return_route route adresses address इसलिए, यदि हम बीच में 3 हॉप्स के साथ पते से पते पर एक संदेश भेजना चाहते हैं, तो हम निम्नलिखित की तरह एक रूट बना सकते हैं। app echoer ┌───────────────────────┐ │ Node 1 │ ├───────────────────────┤ │ ┌────────────────┐ │ │ │ Address: │ │ │ │ 'app' │ │ │ └─┬────────────▲─┘ │ │ ┌─▼────────────┴─┐ │ │ │ Address: │ │ │ │ 'hopper1..3' │x3 │ │ └─┬────────────▲─┘ │ │ ┌─▼────────────┴─┐ │ │ │ Address: │ │ │ │ 'echoer' │ │ │ └────────────────┘ │ └───────────────────────┘ इस मार्ग को बनाने के लिए रस्ट कोड यहां दिया गया है। /// Send a message to the echoer worker via the "hopper1", "hopper2", and "hopper3" workers. let route = route!["hopper1", "hopper2", "hopper3", "echoer"]; आइए आगे ऐसा करने के लिए कुछ स्रोत कोड जोड़ें। पहली चीज़ जो हम करेंगे वह इस खाली प्रोजेक्ट में एक और निर्भरता जोड़ देंगे। टोकरा हमें रंगीन कंसोल आउटपुट देगा जो हमारे उदाहरणों से आउटपुट को पढ़ने और समझने में बहुत आसान बना देगा। hello_ockam colored cargo add colored फिर हम एक नई फ़ाइल बनाकर और उसमें निम्नलिखित कोड को कॉपी/पेस्ट करके वर्कर को जोड़ते हैं (हमारे प्रोजेक्ट में)। /src/echoer.rs echoer hello_ockam use colored::Colorize; use ockam::{Context, Result, Routed, Worker}; pub struct Echoer; /// When a worker is started on a node, it is given one or more addresses. The node /// maintains a mailbox for each address and whenever a message arrives for a specific /// address it delivers that message to the corresponding registered worker. /// /// Workers can handle messages from other workers running on the same or a different /// node. In response to a message, an worker can: make local decisions, change its /// internal state, create more workers, or send more messages to other workers running on /// the same or a different node. #[ockam::worker] impl Worker for Echoer { type Context = Context; type Message = String; async fn handle_message(&mut self, ctx: &mut Context, msg: Routed ) -> Result { // Echo the message body back on its return_route. let addr_str = ctx.address().to_string(); let msg_str = msg.as_body().to_string(); let new_msg_str = format!("👈 echo back: {}", msg); // Formatting stdout output. let lines = [ format!("📣 'echoer' worker → Address: {}", addr_str.bright_yellow()), format!(" Received: '{}'", msg_str.green()), format!(" Sent: '{}'", new_msg_str.cyan()), ]; lines .iter() .for_each(|line| println!("{}", line.white().on_black())); ctx.send(msg.return_route(), new_msg_str).await } } इसके बाद, हम एक नई फ़ाइल बनाकर और उसमें निम्नलिखित कोड को कॉपी/पेस्ट करके वर्कर (हमारे प्रोजेक्ट में) जोड़ते हैं। /src/hopper.rs hopper hello_ockam ध्यान दें कि यह कार्यकर्ता संदेश को अगले हॉप पर भेजने के लिए और फ़ील्ड में कैसे हेरफेर करता है। जब हम जल्द ही इस कोड को चलाएंगे तो हम वास्तव में इसे कंसोल आउटपुट में देखेंगे। onward_route return_route use colored::Colorize; use ockam::{Any, Context, Result, Routed, Worker}; pub struct Hopper; #[ockam::worker] impl Worker for Hopper { type Context = Context; type Message = Any; /// This handle function takes any incoming message and forwards. it to the next hop /// in it's onward route. async fn handle_message(&mut self, ctx: &mut Context, msg: Routed ) -> Result { // Cast the msg to a Routed let msg: Routed = msg.cast()?; let msg_str = msg.to_string().white().on_bright_black(); let addr_str = ctx.address().to_string().white().on_bright_black(); // Some type conversion. let mut message = msg.into_local_message(); let transport_message = message.transport_mut(); // Remove my address from the onward_route. let removed_address = transport_message.onward_route.step()?; let removed_addr_str = removed_address .to_string() .white() .on_bright_black() .strikethrough(); // Formatting stdout output. let lines = [ format!("🐇 'hopper' worker → Addr: '{}'", addr_str), format!(" Received: '{}'", msg_str), format!(" onward_route -> remove: '{}'", removed_addr_str), format!(" return_route -> prepend: '{}'", addr_str), ]; lines .iter() .for_each(|line| println!("{}", line.black().on_yellow())); // Insert my address at the beginning return_route. transport_message .return_route .modify() .prepend(ctx.address()); // Send the message on its onward_route. ctx.forward(message).await } } और अंत में, आइए अपने प्रोजेक्ट में एक जोड़ें। यह हमारे उदाहरण के लिए प्रवेश बिंदु होगा। hello_ockam main() एक खाली फ़ाइल बनाएं (ध्यान दें कि यह फ़ोल्डर में है, न कि उपरोक्त कार्यकर्ताओं की तरह फ़ोल्डर में)। /examples/03-routing-many.hops.rs examples/ src/ use colored::Colorize; use hello_ockam::{Echoer, Hopper}; use ockam::{node, route, Context, Result}; #[rustfmt::skip] const HELP_TEXT: &str =r#" ┌───────────────────────┐ │ Node 1 │ ├───────────────────────┤ │ ┌────────────────┐ │ │ │ Address: │ │ │ │ 'app' │ │ │ └─┬────────────▲─┘ │ │ ┌─▼────────────┴─┐ │ │ │ Address: │ │ │ │ 'hopper1..3' │x3 │ │ └─┬────────────▲─┘ │ │ ┌─▼────────────┴─┐ │ │ │ Address: │ │ │ │ 'echoer' │ │ │ └────────────────┘ │ └───────────────────────┘ "#; /// This node routes a message through many hops. #[ockam::node] async fn main(ctx: Context) -> Result { println!("{}", HELP_TEXT.green()); print_title(vec![ "Run a node w/ 'app', 'echoer' and 'hopper1', 'hopper2', 'hopper3' workers", "then send a message over 3 hops", "finally stop the node", ]); // Create a node with default implementations. let mut node = node(ctx); // Start an Echoer worker at address "echoer". node.start_worker("echoer", Echoer).await?; // Start 3 hop workers at addresses "hopper1", "hopper2" and "hopper3". node.start_worker("hopper1", Hopper).await?; node.start_worker("hopper2", Hopper).await?; node.start_worker("hopper3", Hopper).await?; // Send a message to the echoer worker via the "hopper1", "hopper2", and "hopper3" workers. let route = route!["hopper1", "hopper2", "hopper3", "echoer"]; let route_msg = format!("{:?}", route); let msg = "Hello Ockam!"; node.send(route, msg.to_string()).await?; // Wait to receive a reply and print it. let reply = node.receive:: ().await?; // Formatting stdout output. let lines = [ "🏃 Node 1 →".to_string(), format!(" sending: {}", msg.green()), format!(" over route: {}", route_msg.blue()), format!(" and receiving: '{}'", reply.purple()), // Should print "👈 echo back: Hello Ockam!" format!(" then {}", "stopping".bold().red()), ]; lines .iter() .for_each(|line| println!("{}", line.black().on_white())); // Stop all workers, stop the node, cleanup and return. node.stop().await } fn print_title(title: Vec ) { let line = format!("🚀 {}", title.join("\n → ").white()); println!("{}", line.black().on_bright_black()) } अब हमारे प्रोग्राम को चलाने का समय आ गया है कि यह क्या करता है! 🎉 अपने टर्मिनल ऐप में, निम्न कमांड चलाएँ। ध्यान दें कि का उपयोग ओक्कम लाइब्रेरी से लॉगिंग आउटपुट को अक्षम करने के लिए किया जाता है। उदाहरण के आउटपुट को पढ़ने में आसान बनाने के लिए ऐसा किया जाता है। OCKAM_LOG=none OCKAM_LOG=none cargo run --example 03-routing-many-hops और आपको निम्नलिखित जैसा कुछ देखना चाहिए. हमारा उदाहरण प्रोग्राम और के बीच कई हॉप वर्कर (तीन वर्कर) बनाता है और उनके माध्यम से हमारे संदेश को रूट करता है। app echoer hopper जटिल उदाहरण इस उदाहरण में, हम परिचय देंगे हॉप्स के बीच में. एक ही नोड में श्रमिकों के बीच संदेश भेजने के बजाय, हम कई नोड्स उत्पन्न करेंगे। फिर हमारे पास कुछ टीसीपी ट्रांसपोर्ट (टीसीपी सॉकेट क्लाइंट और श्रोता कॉम्बो) होंगे जो नोड्स को कनेक्ट करेंगे। टीसीपी परिवहन करता है ओकैम ट्रांसपोर्ट ओकैम रूटिंग के लिए एक प्लगइन है। यह टीसीपी, यूडीपी, वेबसॉकेट, ब्लूटूथ इत्यादि जैसे विशिष्ट परिवहन प्रोटोकॉल का उपयोग करके ओकैम रूटिंग संदेशों को स्थानांतरित करता है। हमारे पास तीन नोड होंगे: : पहला नोड टीसीपी पर संदेश को मध्य नोड (पोर्ट ) पर भेजना शुरू करता है। node_initiator 3000 : फिर मध्य नोड बस इस संदेश को फिर से टीसीपी पर अंतिम नोड पर अग्रेषित करता है (इस बार पोर्ट )। node_middle 4000 : और अंत में, उत्तरदाता नोड संदेश प्राप्त करता है और आरंभकर्ता नोड को उत्तर भेजता है। node_responder निम्नलिखित चित्र दर्शाता है कि हम आगे क्या बनाएंगे। इस उदाहरण में, ये सभी नोड एक ही मशीन पर हैं, लेकिन वे आसानी से अलग-अलग मशीनों पर नोड हो सकते हैं। ┌──────────────────────┐ │node_initiator │ ├──────────────────────┤ │ ┌──────────────────┐ │ │ │Address: │ │ ┌───────────────────────────┐ │ │'app' │ │ │node_middle │ │ └──┬────────────▲──┘ │ ├───────────────────────────┤ │ ┌──▼────────────┴──┐ │ │ ┌──────────────────┐ │ │ │TCP transport └─┼─────┼─►TCP transport │ │ │ │connect to 3000 ◄─┼─────┼─┐listening on 3000 │ │ │ └──────────────────┘ │ │ └──┬────────────▲──┘ │ └──────────────────────┘ │ ┌──▼────────────┴───────┐ │ │ │Address: │ │ ┌──────────────────────┐ │ │'forward_to_responder' │ │ │node_responder │ │ └──┬────────────▲───────┘ │ ├──────────────────────┤ │ ┌──▼────────────┴──┐ │ │ ┌──────────────────┐ │ │ │TCP transport └──────┼───┼─►TCP transport │ │ │ │connect to 4000 ◄──────┼───┼─┐listening on 4000 │ │ │ └──────────────────┘ │ │ └──┬────────────▲──┘ │ └───────────────────────────┘ │ ┌──▼────────────┴──┐ │ │ │Address: │ │ │ │'echoer' │ │ │ └──────────────────┘ │ └──────────────────────┘ आइए एक नई फ़ाइल ( फ़ोल्डर में, न कि फ़ोल्डर में) बनाकर शुरुआत करें। फिर उस फ़ाइल में निम्नलिखित कोड को कॉपी/पेस्ट करें। /examples/04-routing-over-two-transport-hops.rs /examples/ /src/ use colored::Colorize; use hello_ockam::{Echoer, Forwarder}; use ockam::{ node, route, AsyncTryClone, Context, Result, TcpConnectionOptions, TcpListenerOptions, TcpTransportExtension, }; #[rustfmt::skip] const HELP_TEXT: &str =r#" ┌──────────────────────┐ │node_initiator │ ├──────────────────────┤ │ ┌──────────────────┐ │ │ │Address: │ │ ┌───────────────────────────┐ │ │'app' │ │ │node_middle │ │ └──┬────────────▲──┘ │ ├───────────────────────────┤ │ ┌──▼────────────┴──┐ │ │ ┌──────────────────┐ │ │ │TCP transport └─┼─────┼─►TCP transport │ │ │ │connect to 3000 ◄─┼─────┼─┐listening on 3000 │ │ │ └──────────────────┘ │ │ └──┬────────────▲──┘ │ └──────────────────────┘ │ ┌──▼────────────┴───────┐ │ │ │Address: │ │ ┌──────────────────────┐ │ │'forward_to_responder' │ │ │node_responder │ │ └──┬────────────▲───────┘ │ ├──────────────────────┤ │ ┌──▼────────────┴──┐ │ │ ┌──────────────────┐ │ │ │TCP transport └──────┼───┼─►TCP transport │ │ │ │connect to 4000 ◄──────┼───┼─┐listening on 4000 │ │ │ └──────────────────┘ │ │ └──┬────────────▲──┘ │ └───────────────────────────┘ │ ┌──▼────────────┴──┐ │ │ │Address: │ │ │ │'echoer' │ │ │ └──────────────────┘ │ └──────────────────────┘ "#; #[ockam::node] async fn main(ctx: Context) -> Result { println!("{}", HELP_TEXT.green()); let ctx_clone = ctx.async_try_clone().await?; let ctx_clone_2 = ctx.async_try_clone().await?; let mut node_responder = create_responder_node(ctx).await.unwrap(); let mut node_middle = create_middle_node(ctx_clone).await.unwrap(); create_initiator_node(ctx_clone_2).await.unwrap(); node_responder.stop().await.ok(); node_middle.stop().await.ok(); println!( "{}", "App finished, stopping node_responder & node_middle".red() ); Ok(()) } fn print_title(title: Vec ) { let line = format!("🚀 {}", title.join("\n → ").white()); println!("{}", line.black().on_bright_black()) } यह कोड वास्तव में संकलित नहीं होगा, क्योंकि इस स्रोत फ़ाइल में 3 फ़ंक्शन गायब हैं। हम बाकी कोड को चरणबद्ध करने के लिए पहले इस फ़ाइल को जोड़ रहे हैं जिसे हम आगे लिखेंगे। यह फ़ंक्शन तीन नोड्स बनाता है जैसा कि हम ऊपर चित्र में देखते हैं, और उदाहरण चलने के बाद यह उन्हें रोक भी देता है। main() आरंभकर्ता नोड तो आइए पहले उस फ़ंक्शन को लिखें जो आरंभकर्ता नोड बनाता है। निम्नलिखित को उस स्रोत फ़ाइल में कॉपी करें जिसे हमने पहले बनाया था ( ), और इसे वहां मौजूदा कोड के नीचे पेस्ट करें: /examples/04-routing-over-two-transport-hops.rs /// This node routes a message, to a worker on a different node, over two TCP transport /// hops. async fn create_initiator_node(ctx: Context) -> Result { print_title(vec![ "Create node_initiator that routes a message, over 2 TCP transport hops, to 'echoer' worker on node_responder", "stop", ]); // Create a node with default implementations. let mut node = node(ctx); // Initialize the TCP transport. let tcp_transport = node.create_tcp_transport().await?; // Create a TCP connection to the middle node. let connection_to_middle_node = tcp_transport .connect("localhost:3000", TcpConnectionOptions::new()) .await?; // Send a message to the "echoer" worker, on a different node, over two TCP hops. Wait // to receive a reply and print it. let route = route![connection_to_middle_node, "forward_to_responder", "echoer"]; let route_str = format!("{:?}", route); let msg = "Hello Ockam!"; let reply = node .send_and_receive:: (route, msg.to_string()) .await?; // Formatting stdout output. let lines = [ "🏃 node_initiator →".to_string(), format!(" sending: {}", msg.green()), format!(" over route: '{}'", route_str.blue()), format!(" and received: '{}'", reply.purple()), // Should print "👈 echo back: Hello Ockam!" format!(" then {}", "stopping".bold().red()), ]; lines .iter() .for_each(|line| println!("{}", line.black().on_white())); // Stop all workers, stop the node, cleanup and return. node.stop().await } यह (आरंभकर्ता) नोड निम्नलिखित मार्ग का उपयोग करके उत्तरदाता को एक संदेश भेजेगा। let route = route![connection_to_middle_node, "forward_to_responder", "echoer"]; मध्य नोड आइए आगे मध्य नोड बनाएं, जो इस पते पर वर्कर चलाएगा: । Forwarder forward_to_responder निम्नलिखित को हमारे द्वारा ऊपर बनाई गई स्रोत फ़ाइल ( ) में कॉपी और पेस्ट करें। /examples/04-routing-over-two-transport-hops.rs यह मध्य नोड अपने टीसीपी श्रोता ( पर) में जो कुछ भी आता है उसे पोर्ट पर भेज देता है। 3000 4000 इस नोड में पते पर एक कार्यकर्ता है, इसलिए इस प्रकार आरंभकर्ता इस उदाहरण के प्रारंभ में अपने रूट में निर्दिष्ट पते तक पहुंच सकता है। forward_to_responder Forwarder /// - Starts a TCP listener at 127.0.0.1:3000. /// - This node creates a TCP connection to a node at 127.0.0.1:4000. /// - Starts a forwarder worker to forward messages to 127.0.0.1:4000. /// - Then runs forever waiting to route messages. async fn create_middle_node(ctx: Context) -> Result { print_title(vec![ "Create node_middle that listens on 3000 and forwards to 4000", "wait for messages until stopped", ]); // Create a node with default implementations. let node = node(ctx); // Initialize the TCP transport. let tcp_transport = node.create_tcp_transport().await?; // Create a TCP connection to the responder node. let connection_to_responder = tcp_transport .connect("127.0.0.1:4000", TcpConnectionOptions::new()) .await?; // Create a Forwarder worker. node.start_worker( "forward_to_responder", Forwarder { address: connection_to_responder.into(), }, ) .await?; // Create a TCP listener and wait for incoming connections. let listener = tcp_transport .listen("127.0.0.1:3000", TcpListenerOptions::new()) .await?; // Allow access to the Forwarder via TCP connections from the TCP listener. node.flow_controls() .add_consumer("forward_to_responder", listener.flow_control_id()); // Don't call node.stop() here so this node runs forever. Ok(node) } प्रत्युत्तरकर्ता नोड अंत में, हम रिस्पॉन्डर नोड बनाएंगे। यह नोड वर्कर चलाएगा जो वास्तव में संदेश को आरंभकर्ता तक प्रतिध्वनित करता है। उपरोक्त स्रोत फ़ाइल में निम्नलिखित को कॉपी और पेस्ट करें ( )। echoer /examples/04-routing-over-two-transport-hops.rs इस नोड में पता पर एक कार्यकर्ता है, इसलिए इस प्रकार आरंभकर्ता इस उदाहरण के प्रारंभ में अपने मार्ग में निर्दिष्ट पते तक पहुंच सकता है। echoer Echoer /// This node starts a TCP listener and an echoer worker. It then runs forever waiting for /// messages. async fn create_responder_node(ctx: Context) -> Result { print_title(vec![ "Create node_responder that runs tcp listener on 4000 and 'echoer' worker", "wait for messages until stopped", ]); // Create a node with default implementations. let node = node(ctx); // Initialize the TCP transport. let tcp_transport = node.create_tcp_transport().await?; // Create an echoer worker. node.start_worker("echoer", Echoer).await?; // Create a TCP listener and wait for incoming connections. let listener = tcp_transport .listen("127.0.0.1:4000", TcpListenerOptions::new()) .await?; // Allow access to the Echoer via TCP connections from the TCP listener. node.flow_controls() .add_consumer("echoer", listener.flow_control_id()); Ok(node) } आइए यह उदाहरण चलाकर देखें कि यह क्या करता है 🎉। अपने टर्मिनल ऐप में, निम्न कमांड चलाएँ। ध्यान दें कि का उपयोग ओक्कम लाइब्रेरी से लॉगिंग आउटपुट को अक्षम करने के लिए किया जाता है। उदाहरण के आउटपुट को पढ़ने में आसान बनाने के लिए ऐसा किया जाता है। OCKAM_LOG=none cargo run --example 04-routing-over-two-transport-hops इसे निम्नलिखित के समान आउटपुट उत्पन्न करना चाहिए। हमारा उदाहरण प्रोग्राम एक रूट बनाता है जो कई नोड्स को पार करता है और टीसीपी से तक ट्रांसपोर्ट करता है और हमारे संदेश को उनके माध्यम से रूट करता है 🚀। app echoer अगले कदम ओकाम रूटिंग और ट्रांसपोर्ट बेहद शक्तिशाली और लचीले हैं। वे प्रमुख विशेषताओं में से एक हैं जो ओकैम सिक्योर चैनल्स को लागू करने में सक्षम बनाती हैं। ओकैम रूटिंग पर ओक्कम सिक्योर चैनल्स और अन्य प्रोटोकॉल को लेयर करके, हम कई नेटवर्क और क्लाउड तक फैले मनमाने ट्रांसपोर्ट टोपोलॉजी पर एंड-टू-एंड गारंटी प्रदान कर सकते हैं। भविष्य के ब्लॉग पोस्ट में, हम ओकम सिक्योर चैनलों को कवर करेंगे और उनका उपयोग मनमाने परिवहन टोपोलॉजी पर एंड-टू-एंड गारंटी प्रदान करने के लिए कैसे किया जा सकता है। तो मिले रहें! इस बीच ओकाम के बारे में अधिक जानने के लिए यहां कुछ अच्छे शुरुआती बिंदु दिए गए हैं: रेपो. में रस्ट उदाहरण चलाएँ ockam . ओकाम रूटिंग में गहराई से उतरें यहाँ भी प्रकाशित किया गया।