คำถามติดแท็ก message-queue

ใครสามารถอธิบายฉันในกรณีการใช้งานที่ฉันควรพิจารณาใช้ AMQP เช่น RabbitMQ ข้อดีและข้อเสียคืออะไร?

45 design  message-queue 

ฉันเพิ่งอ่านบทความนี้และฉันสับสน ลองจินตนาการ 1 webapp และ 1 แอพลิเคชันที่แตกต่างกันทำหน้าที่เป็น "คนงาน" ทั้งสองร่วมกันฐานข้อมูลเดียวกัน โอ้ฉันพูดว่า "การแบ่งปัน" .. แต่บทความจะเตือนอะไร : ประการที่สี่การแบ่งปันฐานข้อมูลระหว่างแอปพลิเคชัน (หรือบริการ) เป็นสิ่งที่ไม่ดี มันเป็นการล่อลวงเกินไปที่จะทำให้รัฐร่วมอสัณฐานอยู่ในนั้นและก่อนที่คุณจะรู้ว่าคุณจะมีสัตว์ประหลาดคู่ขนานอย่างมหาศาล => ไม่เห็นด้วย มีบางกรณีที่แอปพลิเคชันที่แตกต่างยังคงเป็นส่วนหนึ่งของหน่วยเดียวกันดังนั้นแนวคิดของ "ปัญหาการมีเพศสัมพันธ์" จึงไม่มีเหตุผลในกรณีนี้ มาดำเนินการต่อ: เว็บแอปจัดการคำขอ HTTP ของไคลเอ็นต์และอาจอัปเดตเมื่อใดก็ได้ที่มีการรวม (คำศัพท์ DDD) เพื่อสร้างกิจกรรมโดเมนที่สอดคล้องกัน เป้าหมายของผู้ปฏิบัติงานคือการจัดการกิจกรรมโดเมนเหล่านั้นโดยการประมวลผลงานที่ต้องการ ประเด็นก็คือ: ข้อมูลเหตุการณ์ควรส่งผ่านไปยังผู้ปฏิบัติงานอย่างไร วิธีแรกในการส่งเสริมการอ่านบทความคือการใช้ RabbitMQ เป็นมิดเดิลแวร์ที่มุ่งเน้นข้อความ เวิร์กโฟลว์จะง่าย: เมื่อใดก็ตามที่เว็บไดโนสร้างเหตุการณ์มันจะเผยแพร่ผ่าน RabbitMQ ซึ่งฟีดคนงาน ข้อเสียเปรียบก็คือไม่มีสิ่งใดรับประกันความสอดคล้องทันทีระหว่างการคอมมิชชันของการอัพเดตแบบรวมและการเผยแพร่เหตุการณ์โดยไม่ต้องจัดการกับความล้มเหลวในการส่งที่เป็นไปได้ ... หรือปัญหาฮาร์ดแวร์; นั่นเป็นอีกประเด็นหลัก ตัวอย่าง: เป็นไปได้ว่าเหตุการณ์ถูกเผยแพร่โดยไม่ประสบความสำเร็จในการอัปเดตรวม ... ส่งผลให้เกิดเหตุการณ์ที่แสดงถึงการแสดงโมเดลโดเมนที่ผิดพลาด คุณสามารถยืนยันได้ว่า XA …

33 architecture  domain-driven-design  message-queue  middleware 

ทำไม Redis ถึงเข้าคิว? ฉันอยู่ภายใต้ความประทับใจที่ Redis สามารถสร้างผู้สมัครที่ดีสำหรับการนำระบบคิวเข้ามาใช้ จนถึงตอนนี้เราได้ใช้ฐานข้อมูล MySQL กับโพลหรือ RabbitMQ ด้วย RabbitMQ เรามีปัญหามากมาย - ห้องสมุดลูกค้านั้นแย่มากและบั๊กกี้และเราไม่ต้องการลงทุนชั่วโมงนักพัฒนามากเกินไปในการแก้ไขปัญหาเหล่านี้ปัญหาบางอย่างเกี่ยวกับคอนโซลการจัดการเซิร์ฟเวอร์ ฯลฯ และในเวลานั้น อย่างน้อยเราก็ไม่ได้จับเป็นมิลลิวินาทีหรือผลักดันประสิทธิภาพอย่างจริงจังดังนั้นตราบใดที่ระบบมีสถาปัตยกรรมที่รองรับคิวอย่างชาญฉลาดเราอาจมีรูปร่างที่ดี ตกลงนั่นคือพื้นหลัง โดยพื้นฐานแล้วฉันมีโมเดลคิวที่เรียบง่ายคลาสสิกผู้ผลิตหลายรายผลิตงานและบริโภคผู้บริโภคจำนวนมากและทั้งผู้ผลิตและผู้บริโภคต้องสามารถปรับขนาดได้อย่างชาญฉลาด ปรากฎว่าไร้เดียงสาPUBSUBไม่ทำงานเนื่องจากฉันไม่ต้องการให้สมาชิกทั้งหมดใช้งานฉันแค่ต้องการสมาชิกหนึ่งคนเพื่อรับงาน ที่ผ่านครั้งแรกมันดูเหมือนฉันชอบBRPOPLPUSHคือการออกแบบที่ชาญฉลาด เราสามารถใช้ BRPOPLPUSH ได้หรือไม่? การออกแบบพื้นฐานด้วยBRPOPLPUSHคือคุณมีคิวงานหนึ่งคิวและคิวความคืบหน้า เมื่อผู้บริโภคได้รับการทำงานมันอะตอมผลักดันรายการลงในคิวความคืบหน้าและเมื่อเสร็จสิ้นการทำงานมันLREMเป็นมัน สิ่งนี้จะช่วยป้องกันไม่ให้เกิดการปิดกั้นการทำงานหากลูกค้าตายและทำการตรวจสอบได้อย่างง่ายดาย - ตัวอย่างเช่นเราสามารถบอกได้ว่ามีปัญหาที่ทำให้ผู้บริโภคต้องใช้เวลานานในการปฏิบัติงานนอกเหนือจากการบอกว่ามีงานจำนวนมากหรือไม่ มันทำให้มั่นใจ ส่งมอบงานให้กับผู้บริโภคเพียงรายเดียว ทำงานช้าลงในคิวที่กำลังดำเนินการอยู่ดังนั้นจึงไม่สามารถปิดกั้นผู้บริโภคได้ ข้อเสียเปรียบ มันค่อนข้างแปลกสำหรับฉันที่การออกแบบที่ดีที่สุดที่ฉันพบไม่ได้ใช้จริงPUBSUBเนื่องจากนี่เป็นสิ่งที่บล็อกโพสต์ส่วนใหญ่เกี่ยวกับการรอคิว Redis ดังนั้นฉันรู้สึกว่าฉันขาดอะไรบางอย่างที่ชัดเจน วิธีเดียวที่ฉันเห็นการใช้งานPUBSUBโดยไม่ต้องเสียงานสองครั้งคือเพียงแค่ส่งการแจ้งเตือนว่างานมาถึงแล้วซึ่งผู้บริโภคสามารถไม่ปิดกั้นRPOPLPUSHได้ เป็นไปไม่ได้ที่จะขอมากกว่าหนึ่งรายการงานในแต่ละครั้งซึ่งดูเหมือนว่าจะเป็นปัญหาด้านประสิทธิภาพ ไม่ใช่เรื่องใหญ่สำหรับสถานการณ์ของเรา แต่เห็นได้ชัดว่าการดำเนินการนี้ไม่ได้ถูกออกแบบมาสำหรับปริมาณงานสูงหรือสถานการณ์นี้ ในระยะสั้น: ฉันไม่มีอะไรที่โง่หรือเปล่า? เพิ่มแท็ก node.js ด้วยเพราะนั่นคือภาษาที่ฉันใช้เป็นหลัก โหนดอาจเสนอการทำให้เรียบง่ายบางอย่างในการดำเนินการเนื่องจากลักษณะแบบเธรดเดียวและไม่มีการปิดกั้น แต่ยิ่งไปกว่านั้นฉันใช้ไลบรารี่ node-redis และวิธีแก้ปัญหาควรหรืออาจอ่อนไหวต่อจุดแข็งและจุดอ่อนของมัน

29 node.js  message-queue  redis  pubsub  producer-consumer 

ฉันพยายามเรียนรู้เพิ่มเติมเกี่ยวกับวิธีการต่าง ๆ ที่ปัญหาของคิวการแจกจ่ายอาจได้รับการแก้ไข ดังนั้นฉันอยากจะรู้ว่าผลิตภัณฑ์บริการการใช้งานและงานวิจัยที่มีอยู่แล้ว การดำเนินการจะเผชิญกับความท้าทายมากมายและจะถูกบังคับให้ทำการแลกเปลี่ยน: มันมีการสั่งซื้อที่แข็งแกร่งหรือหลวม? มันใส่ idempotent หรือไม่? เราสามารถมีคิวมากกว่าสิ่งที่สามารถใส่ลงในเครื่องเดียวได้หรือไม่? เราสามารถมีข้อมูลเพิ่มเติมในคิวได้มากกว่าที่สามารถบรรจุลงในเครื่องเดียวได้หรือไม่? มีกี่เครื่องที่สามารถพังก่อนที่เราจะสูญเสียข้อมูลได้? มันทนต่อการแยกเน็ตได้หรือไม่? มันสามารถกระทบยอดข้อมูลโดยอัตโนมัติเมื่อมีการแก้ไขการแบ่งสุทธิหรือไม่? มันสามารถรับประกันการส่งมอบเมื่อลูกค้าสามารถผิดพลาด? สามารถรับประกันได้หรือไม่ว่าข้อความเดียวกันไม่ได้ส่งมากกว่าหนึ่งครั้ง? โหนดเกิดความผิดพลาดได้ทุกจุดกลับมาและไม่ส่งขยะหรือไม่ คุณสามารถเพิ่มโหนดไปยังหรือลบโหนดออกจากคลัสเตอร์ที่รันอยู่โดยไม่ต้องหยุดทำงานได้หรือไม่? คุณสามารถอัพเกรดโหนดในคลัสเตอร์ที่รันอยู่โดยไม่ต้องหยุดทำงานได้หรือไม่? มันสามารถทำงานได้โดยไม่มีปัญหากับเซิร์ฟเวอร์ต่างกันหรือไม่? คุณสามารถ“ แปะ” คิวกับกลุ่มของเซิร์ฟเวอร์ได้หรือไม่? (ตัวอย่าง:“ คิวเหล่านี้ได้รับอนุญาตเฉพาะในศูนย์ข้อมูลยุโรป”) มันสามารถตรวจสอบให้แน่ใจว่าได้วางแบบจำลองข้อมูลไว้ในดาต้าเซ็นเตอร์อย่างน้อยสองศูนย์หรือไม่ถ้ามี ฉันไม่มีภาพลวงตาว่าการดำเนินการใด ๆ จะสามารถพูดว่า "ใช่" กับทุกสิ่ง ฉันแค่สนใจฟังการใช้งานที่หลากหลาย พวกเขาทำงานอย่างไรสิ่งแลกเปลี่ยนที่พวกเขาทำและบางทีพวกเขาตัดสินใจเลือกชุดการแลกเปลี่ยนที่เฉพาะเจาะจงของพวกเขา นอกจากนี้หากมีความท้าทายใด ๆ ที่ฉันอาจพลาดในรายการด้านบน

23 distributed-computing  message-queue 

ฉันเพิ่งเริ่มเรียนรู้ความแตกต่างของสถาปัตยกรรมคอมพิวเตอร์ที่ปรับขนาดได้และองค์กรและหนึ่งในองค์ประกอบกลางคือคิวการส่งข้อความ เพื่อเรียนรู้มากที่สุดที่ฉันสามารถทำได้จากกระบวนทัศน์การเขียนโปรแกรมใด ๆ ฉันกำลังพยายามใช้บริการคิวการส่งข้อความในเวอร์ชันของฉันเอง จนถึงตอนนี้การออกแบบเริ่มต้นของฉันทำงานบนฟังก์ชั่นซ็อกเก็ตแบบเธรด แต่เพื่อป้องกันไม่ให้มีการดาวน์โหลดข้อความเดียวกันสองครั้งโดยสองโหนดการประมวลผลที่แยกต่างหากการลงทะเบียนดัชนีคิวข้อความจะถูกล็อคเมื่อเริ่มอ่านแล้ว อัปเดต ด้วยเหตุนี้จึงเป็นการลดความต้องการในการทำเธรดและหมายความว่ามีขนาดเพดานของระบบที่ปรับขนาดได้ตามความเร็วการประมวลผลของเซิร์ฟเวอร์ที่บริการคิวการส่งข้อความกำลังทำงานอยู่ วิธีที่จะหลีกเลี่ยงปัญหานี้คือการเรียกใช้บริการคิวข้อความบนเซิร์ฟเวอร์หลายเครื่อง แต่สิ่งนี้จะเพิ่มโอกาสในการดาวน์โหลดข้อความเดิมสองครั้ง วิธีเดียวที่จะป้องกันปัญหาดังกล่าวที่เกิดขึ้นคือการรวมการโทรกลับการเพิกถอนที่ (หลังจากเซิร์ฟเวอร์หรือแม้กระทั่งเธรดบนเซิร์ฟเวอร์เดียวได้ซิงโครไนซ์ข้อมูลและตรวจพบการออกใหม่) จะสั่งโหนดการประมวลผลเพื่อหยุด งานปัจจุบันและสอบถามคิวข้อความใหม่สำหรับข้อความถัดไป แต่อีกครั้งจะมีเพดานที่การรับส่งข้อมูลส่วนใหญ่จะเป็นการซิงโครไนซ์และการเพิกถอนการเรียกกลับทำให้เกิดปัญหาคอขวดและทำให้การประมวลผลข้อมูลช้าลง โหนดการประมวลผลจำนวนมากจะทำการดำเนินการเป็นโมฆะและเสียเวลา วิธีสุดท้ายที่ฉันคิดว่าจะแก้ไขปัญหานี้คือการมีเซิร์ฟเวอร์คิวข้อความ (และแต่ละเธรดในแต่ละเซิร์ฟเวอร์) จะมีออฟเซ็ตเฉพาะว่าอยู่ที่ไหนในคิวที่กำลังมองหา แต่ที่อาจมีปัญหาตาม ชนิดของแอปพลิเคชันโดยเฉพาะอย่างยิ่งหากจำเป็นต้องดำเนินการตามลำดับเฉพาะ ดังนั้นทั้งหมดที่กล่าวมามีการออกแบบสถาปัตยกรรมคิวข้อความที่สามารถแสดงให้ฉันเห็นว่าบริการคิวข้อความระดับองค์กรที่มีอยู่จะหลีกเลี่ยงปัญหาเหล่านี้ได้อย่างไร

22 design  scalability  message-queue 

ฉันมีแอปพลิเคชั่นที่สร้างการสนทนาที่ค่อนข้างร้อนแรงระหว่างนักพัฒนาสองคน โดยทั่วไปจะแบ่งเป็นเลเยอร์เว็บและเลเยอร์แบ็กเอนด์ เลเยอร์เว็บรวบรวมข้อมูลโดยแบบฟอร์มเว็บอย่างง่ายหยุดข้อมูลนี้เป็นเอกสาร JSON (แท้จริงไฟล์. json) ลงในโฟลเดอร์เฝ้าดูที่ใช้โดยส่วนหลัง ส่วนหลังทำการสำรวจโฟลเดอร์นี้ทุกสองสามวินาทีหยิบไฟล์ขึ้นมาและทำหน้าที่ของมัน ตัวไฟล์เองนั้นง่ายมาก (เช่นข้อมูลสตริงทั้งหมด, ไม่มีการซ้อน), และประมาณ 1-2k ที่ใหญ่ที่สุด, โดยระบบใช้เวลาส่วนใหญ่ในการใช้งาน (แต่การกระจายข้อความสูงสุด 100 ข้อความในเวลาใดก็ตาม) ขั้นตอนการประมวลผลส่วนหลังใช้เวลาประมาณ 10 นาทีต่อข้อความ ข้อโต้แย้งเกิดขึ้นเมื่อผู้พัฒนารายหนึ่งแนะนำว่าการใช้ระบบไฟล์เป็นเลเยอร์การส่งข้อความเป็นวิธีแก้ปัญหาที่ไม่ดีเมื่อบางสิ่งเช่นฐานข้อมูลเชิงสัมพันธ์ (MySQL), ฐานข้อมูล noSQL (Redis) หรือแม้แต่การเรียก REST API ธรรมดาควรใช้แทน ควรสังเกตว่า Redis ถูกใช้ที่อื่นในองค์กรสำหรับการจัดการข้อความที่อยู่ในคิว ข้อโต้แย้งที่ฉันได้ยินแตกออกเป็นดังนี้ ในความโปรดปรานของไฟล์แบน: ไฟล์แบบเรียบมีความน่าเชื่อถือมากกว่าโซลูชันอื่น ๆ เนื่องจากไฟล์จะถูกย้ายจากโฟลเดอร์ "เฝ้าดู" ไปยังโฟลเดอร์ "กำลังดำเนินการ" หลังจากที่รับแล้วและท้ายที่สุดไปยังโฟลเดอร์ "เสร็จสิ้น" เมื่อเสร็จสิ้น ไม่มีความเสี่ยงของข้อความที่จะหายไปยกเว้นข้อผิดพลาดในระดับต่ำมากซึ่งจะทำลายสิ่งอื่น ๆ อย่างไรก็ตาม ไฟล์แบบแฟลตต้องการความซับซ้อนทางเทคนิคที่น้อยกว่าในการทำความเข้าใจ - เพียงแค่catมัน …

20 database  programming-practices  file-handling  message-queue 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันใช้เวลาหนึ่งสัปดาห์ในการดำน้ำลึกเข้าไปในเอกสาร Akkaและในที่สุดก็เข้าใจว่าระบบของนักแสดงคืออะไรและปัญหาที่พวกเขาแก้ไข ความเข้าใจของฉัน(และประสบการณ์กับ) โบรกเกอร์ข้อความ JMS / AMQP ดั้งเดิมคือพวกเขามีตัวตนเพื่อให้สิ่งต่อไปนี้: การประมวลผลแบบอะซิงโครนัสระหว่างผู้ผลิตและผู้บริโภค และ การรับประกันการส่งข้อความรวมถึงการคงอยู่การลองใหม่และการย้อนกลับ แต่ Akka ไม่ได้ให้สิ่งนี้โดยไม่มีโครงสร้างพื้นฐานที่จำเป็นและค่าใช้จ่ายในการดำเนินงานทั้งหมดหรือไม่ ใน Akka การสื่อสารของนักแสดงทั้งหมดไม่ตรงกันและไม่ปิดกั้น และ ใน Akka SupervisorStrategiesมีอยู่เพื่อบรรลุการลองใหม่อีกครั้งทางเลือกและการเพิ่มระดับ นักแสดงสามารถกำหนดค่าให้คงอยู่กับร้านค้าแทบทุกประเภทหากเป็นข้อกำหนดเช่นกัน นี่ทำให้ฉันสงสัยว่า: หากแอปของฉันใช้ Akka ฉันจำเป็นต้องนำโบรกเกอร์ JMS / AMQP (เช่น ActiveMQ, RabbitMQ, Kafka) เข้ามาในรูปภาพหรือไม่? กล่าวอีกนัยหนึ่งเคยมีกรณีการใช้งานที่แอพที่ใช้ Akka ใหม่จะรับประกันการเปิดตัวของกลุ่มโบรกเกอร์ JMS / AMQP ใหม่หรือไม่ ทำไมหรือทำไมไม่? อาร์กิวเมนต์เดียวอาจเป็นได้ว่าแอป …

19 asynchronous-programming  message-queue  messaging  akka 

ฉันหลังจากคำแนะนำเกี่ยวกับการจัดคิวข้อความ เรามีข้อกำหนดสำหรับ "งาน" ที่จะโพสต์ในคิวข้อความ ข้อเสนอแนะดั้งเดิมคือเพียงใช้อินสแตนซ์ SQL Server และประมวลผลข้อความจากนั้น ทุกสิ่งที่ฉันได้อ่านบนอินเทอร์เน็ตแสดงให้เห็นว่าการใช้ฐานข้อมูลสำหรับ Message Queue ไม่ใช่วิธีที่ปรับขนาดได้ ด้วยเหตุนี้จึงแนะนำให้ใช้ความคิด RabbitMQ หรือบุคคลที่สามอื่น ๆ MQ อีกสิ่งที่ควรคำนึงถึงก็คือข้อกำหนดสำหรับ "การประมวลผลงาน" จะไม่ต่ำกว่า 30 วินาทีดังนั้นกระบวนการที่ทำหน้าที่จะสำรวจฐานข้อมูลทุก ๆ 30 วินาที สำหรับฉันแล้วมันไม่ได้เลวร้ายนักและอาจใช้ได้ดีโดยไม่ต้องเพิ่มการโหลดจำนวนมากในฐานข้อมูล เรามีฐานข้อมูลอยู่แล้วในลูกค้าของเราที่เราสามารถใช้สิ่งนี้ได้ดังนั้นมันจะไม่เพิ่มการสนับสนุนพิเศษที่จำเป็นสำหรับลูกค้าของเราในขณะที่ถ้าเราเพิ่ม MQ บุคคลที่สามจะมีการสนับสนุนพิเศษสำหรับการกำหนดค่าเครือข่าย ฯลฯ ซึ่งจะเป็น เป็นจำนวนมากเนื่องจากมีผู้ใช้จำนวนมาก ตัวเลือกอื่นที่ฉันกำลังพิจารณาคือให้ผู้ใช้เลือกระหว่างกัน หากพวกเขาเป็นผู้ใช้รายเล็กโซลูชันของ SQL Server จะใช้ได้ แต่ถ้าพวกเขาเป็นผู้ใช้ที่มีขนาดใหญ่ขึ้นเราอนุญาตให้พวกเขากำหนดค่าโซลูชัน MQ ของบุคคลที่สาม ฉันไม่ได้ขายในการแก้ปัญหาใด ๆ ฉันสงสัยว่าใครมีอะไรที่ฉันควรพิจารณาหรือคำแนะนำ

17 database  message-queue 

ตามไซต์ Kafka : " Kakfa ใช้สำหรับสร้างท่อข้อมูลและแอพสตรีมมิ่งแบบเรียลไทม์ " การค้นหาอินเทอร์เน็ตอย่างกว้างขวางฉันได้พบคำจำกัดความที่เป็นที่ยอมรับโดยทั่วไปของคำว่า " ข้อมูลสตรีม " คืออะไร: ข้อมูลสตรีมเป็นข้อมูลที่ไหลอย่างต่อเนื่องจากต้นทางไปยังปลายทางผ่านเครือข่าย และ ข้อมูลสตรีมไม่ได้เป็นแบบอะตอมมิคหมายถึงส่วนใด ๆ ของสตรีมข้อมูลที่มีความหมายและสามารถประมวลผลได้ซึ่งตรงข้ามกับไฟล์ที่มีไบต์ไม่ได้มีความหมายอะไรนอกจากคุณจะมีทั้งหมด และ ข้อมูลสตรีมสามารถเริ่ม / หยุดได้ตลอดเวลา และ ผู้บริโภคสามารถแนบและแยกออกจากกระแสข้อมูลตามความประสงค์และประมวลผลเฉพาะส่วนที่ต้องการ ตอนนี้ถ้ามีสิ่งใดที่ฉันกล่าวข้างต้นไม่ถูกต้องไม่สมบูรณ์หรือผิดทั้งหมดโปรดเริ่มต้นด้วยการแก้ไขฉัน! สมมติว่าฉันติดตามมากกว่าหรือน้อยกว่านั้น ... ตอนนี้ฉันเข้าใจแล้วว่า "การสตรีมข้อมูล" คืออะไรจากนั้นฉันก็เข้าใจว่าคาฟคาและไคเนซิสหมายถึงอะไรเมื่อพวกเขาเรียกเก็บเงินด้วยตนเองว่าเป็นตัวกลางในการประมวลผล / การเป็นนายหน้าตัวกลางสำหรับแอปพลิเคชัน แต่มันทำให้ฉันสนใจ: สามารถ / ควร "สตรีมมิดเดิลแวร์" เช่น Kafka หรือ Kinesis ใช้สำหรับข้อมูลที่ไม่ได้สตรีมมิงเช่นโบรกเกอร์ข้อความแบบดั้งเดิมหรือไม่ และในทางกลับกัน: สามารถ / ควรใช้ MQ แบบดั้งเดิมเช่น RabbitMQ, ActiveMQ, Apollo …

14 message-queue  stream-processing  apache-kafka 

ฉันกำลังทำโครงการวิจัยที่ฉันค้นคว้าตัวเลือกเพื่อจัดการการเปลี่ยนแปลงในสถาปัตยกรรมไมโครบริการที่ขับเคลื่อนด้วยเหตุการณ์ สมมุติว่าเรามีแอปพลิเคชั่นที่ให้บริการต่าง ๆ สี่อย่าง แต่ละบริการเหล่านี้มีฐานข้อมูลของตัวเองเพื่อเก็บข้อมูลในเครื่อง ในการตั้งค่านี้บริการสี่รายการสื่อสารกันโดยใช้ Event Bus ดังนั้นเมื่อมีสิ่งใดเกิดขึ้นในบริการมันจะเผยแพร่กิจกรรม บริการอื่น ๆ ทั้งหมดที่มีความสนใจในเหตุการณ์นั้นจะดำเนินการด้วยวิธีของตนเอง ในกรณีนี้บริการต่าง ๆ ในสถาปัตยกรรมจำเป็นต้องมี "สัญญา" เกี่ยวกับเนื้อหาของเหตุการณ์เหล่านี้ (แอตทริบิวต์ ฯลฯ ) ดังนั้นบริการจึงมี "การพึ่งพาคู่กันอย่างหลวม ๆ " ต่อเหตุการณ์เหล่านี้ คำถามของฉันคือ: เราจะจัดการการเปลี่ยนแปลงในเหตุการณ์เหล่านี้ได้อย่างไร ดังนั้นบริการสมมติว่าลงทะเบียนผู้ใช้ใหม่ในแอปพลิเคชัน ดังนั้นจึงส่งกิจกรรม "" UserRegistered "Service B เลือกกิจกรรมนั้นและประมวลผล แต่นักพัฒนาบางคนในทีมบริการ C ตัดสินใจว่าพวกเขาต้องการเพศของผู้ใช้ที่ลงทะเบียนด้วยดังนั้นเหตุการณ์จึงเปลี่ยนไปและแอตทริบิวต์เพศ ถูกเพิ่มไปยังเหตุการณ์ "UserRegistered" เราจะมั่นใจได้อย่างไรว่า Service B ยังสามารถรับเหตุการณ์เดียวกันด้วยคุณสมบัติพิเศษนั้นโดยไม่ต้องปรับใช้ซ้ำ และมีวิธีอื่นในการแก้ไขปัญหานี้แล้วกำหนดเหตุการณ์เหล่านี้หรือไม่

9 communication  versioning  microservices  message-queue  code-contracts 

ฉันออกแบบ API REST สำหรับระบบสามชั้นเช่น: Client application-> ->Front-end API cloud serveruser's home API server (Home) Homeเป็นอุปกรณ์บ้านและควรจะรักษาเชื่อมต่อFront-endผ่าน WebSocket หรือโพลล์ยาว(นี้เป็นสถานที่แรกที่เรากำลังละเมิด REST. จะได้รับก็แย่ภายหลัง) Front-endช่องสัญญาณส่วนใหญ่Clientร้องขอการHomeเชื่อมต่อและจัดการการโทรบางตัว บางครั้งส่งการแจ้งเตือนไปยังHomeClient Front-endและHomeมี API เดียวกันโดยทั่วไป Clientอาจเชื่อมต่อHomeโดยตรงผ่าน LAN ในกรณีนี้Homeจำเป็นต้องลงทะเบียนClientการกระทำบางอย่างกับFront-endตัวเอง ข้อดีสำหรับ REST ในระบบนี้คือ: REST สามารถอ่านได้โดยมนุษย์ ส่วนที่เหลือมีการทำแผนที่กริยาที่กำหนดไว้อย่างดี (เช่น CRUD) คำนามและรหัสการตอบสนองกับวัตถุโปรโตคอล; มันทำงานผ่าน HTTP และส่งผ่านผู้รับมอบฉันทะที่เป็นไปได้ทั้งหมด; ส่วนที่เหลือ REST คือ: เราไม่เพียง แต่ต้องการสไตล์การสื่อสารที่ตอบสนองการร้องขอเท่านั้น รหัสข้อผิดพลาด HTTP อาจไม่เพียงพอสำหรับจัดการข้อผิดพลาดการสื่อสารสามระดับ Front-endอาจจะกลับ202 Acceptedไปโทร async …

9 architecture  web-services  rest  message-queue  websockets