สถาปัตยกรรมไมโครเซอร์วิส - คู่มือฉบับย่อ

Microservice เป็นวิธีการพัฒนาแอปพลิเคชันที่ใช้บริการ ในวิธีการนี้แอปพลิเคชันขนาดใหญ่จะถูกแบ่งออกเป็นหน่วยบริการอิสระที่เล็กที่สุด Microservice เป็นกระบวนการในการนำ Service-oriented Architecture (SOA) มาใช้โดยแบ่งแอปพลิเคชันทั้งหมดเป็นชุดของบริการที่เชื่อมต่อกันโดยแต่ละบริการจะตอบสนองความต้องการทางธุรกิจเพียงหนึ่งเดียว

แนวคิดของ Going Micro

ในสถาปัตยกรรมที่มุ่งเน้นบริการแพคเกจซอฟต์แวร์ทั้งหมดจะถูกแบ่งย่อยออกเป็นหน่วยธุรกิจขนาดเล็กที่เชื่อมต่อกัน หน่วยธุรกิจขนาดเล็กแต่ละหน่วยจะสื่อสารกันโดยใช้โปรโตคอลที่แตกต่างกันเพื่อส่งมอบธุรกิจที่ประสบความสำเร็จให้กับลูกค้า คำถามคือ Microservice Architecture (MSA) แตกต่างจาก SOA อย่างไร? พูดได้คำเดียวว่า SOA เป็นรูปแบบการออกแบบและ Microservice เป็นวิธีการดำเนินการเพื่อใช้ SOA หรือเราสามารถพูดได้ว่า Microservice คือ SOA ประเภทหนึ่ง

ต่อไปนี้เป็นกฎบางประการที่เราต้องคำนึงถึงในขณะที่พัฒนาแอปพลิเคชันที่มุ่งเน้น Microservice

• Independent - ไมโครเซอร์วิสแต่ละตัวควรใช้งานได้อย่างอิสระ

• Coupling - ไมโครเซอร์วิสทั้งหมดควรอยู่คู่กันอย่างหลวม ๆ เพื่อที่การเปลี่ยนแปลงในหนึ่งจะไม่ส่งผลกระทบต่ออีก

• Business Goal - แต่ละหน่วยบริการของแอปพลิเคชันทั้งหมดควรมีขนาดเล็กที่สุดและสามารถบรรลุเป้าหมายทางธุรกิจที่เฉพาะเจาะจง

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

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

ตอนนี้เมื่อพิจารณาว่าคุณกำลังเรียกใช้พอร์ทัลการช็อปปิ้งออนไลน์กับหน่วยธุรกิจทั้งหมดที่กล่าวถึงก่อนหน้านี้คุณจำเป็นต้องมีแอปพลิเคชันระดับองค์กรที่ประกอบด้วยเลเยอร์ต่างๆเช่นส่วนหน้าส่วนหลังฐานข้อมูลเป็นต้นหากแอปพลิเคชันของคุณไม่ได้ปรับขนาด และพัฒนาอย่างสมบูรณ์ในไฟล์สงครามไฟล์เดียวจากนั้นจะถูกเรียกว่าเป็นแอปพลิเคชันเสาหินทั่วไป ตามที่ IBM ระบุว่าแอ็พพลิเคชันเสาหินทั่วไปควรมีโครงสร้างโมดูลต่อไปนี้ภายในโดยที่ปลายทางหรือแอ็พพลิเคชันเดียวเท่านั้นที่รับผิดชอบในการจัดการคำขอของผู้ใช้ทั้งหมด

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

พิจารณาสถานการณ์ต่อไปนี้ที่คุณต้องเปลี่ยนใบสมัครตามความต้องการทางธุรกิจ

หน่วยธุรกิจต้องการการเปลี่ยนแปลงบางอย่างในโมดูล "การค้นหา" จากนั้นคุณต้องเปลี่ยนกระบวนการค้นหาทั้งหมดและทำให้แอปพลิเคชันของคุณใช้งานได้อีกครั้ง ในกรณีนี้คุณกำลังปรับใช้หน่วยอื่นของคุณอีกครั้งโดยไม่มีการเปลี่ยนแปลงใด ๆ เลย

อีกครั้งหน่วยธุรกิจของคุณต้องการการเปลี่ยนแปลงบางอย่างในโมดูล "ชำระเงิน" เพื่อรวมตัวเลือก "กระเป๋าเงิน" ตอนนี้คุณต้องเปลี่ยนโมดูล“ ชำระเงิน” ของคุณและทำให้ใช้งานได้อีกครั้งในเซิร์ฟเวอร์ หมายเหตุคุณกำลังปรับใช้โมดูลต่างๆของแพ็คเกจซอฟต์แวร์ของคุณอีกครั้งในขณะที่เราไม่ได้ทำการเปลี่ยนแปลงใด ๆ ต่อไปนี้เป็นแนวคิดของสถาปัตยกรรมที่มุ่งเน้นการบริการที่เฉพาะเจาะจงมากขึ้นสำหรับสถาปัตยกรรม Microservice เราสามารถพัฒนาแอปพลิเคชันเสาหินของเราในลักษณะที่แต่ละโมดูลของซอฟต์แวร์จะทำงานเป็นหน่วยงานอิสระที่สามารถจัดการงานทางธุรกิจเดียวได้อย่างอิสระ

ลองพิจารณาตัวอย่างต่อไปนี้

ในสถาปัตยกรรมข้างต้นเราไม่ได้สร้างไฟล์หูใด ๆ ด้วยบริการ end-to-end ขนาดกะทัดรัด แต่เรากำลังแบ่งส่วนต่างๆของซอฟต์แวร์โดยเปิดเผยว่าเป็นบริการ ส่วนใดส่วนหนึ่งของซอฟต์แวร์สามารถสื่อสารกันได้อย่างง่ายดายโดยการใช้บริการที่เกี่ยวข้อง นั่นเป็นวิธีที่ microservice มีบทบาทอย่างมากในเว็บแอปพลิเคชันสมัยใหม่

ให้เราเปรียบเทียบตัวอย่างตะกร้าสินค้าของเราในสาย microservice เราสามารถแยกรายละเอียดตะกร้าสินค้าของเราในโมดูลต่างๆเช่น "ค้นหา" "ตัวกรอง" "ชำระเงิน" "รถเข็น" "คำแนะนำ" ฯลฯ หากเราต้องการสร้างพอร์ทัลตะกร้าสินค้าเราจะต้องสร้าง โมดูลดังกล่าวข้างต้นในลักษณะที่สามารถเชื่อมต่อถึงกันเพื่อมอบประสบการณ์การช็อปปิ้งที่ดีตลอด 24 ชั่วโมงทุกวัน

ข้อดีข้อเสีย

ต่อไปนี้เป็นข้อดีของการใช้ไมโครเซอร์วิสแทนการใช้แอปพลิเคชันเสาหิน

ข้อดี

• Small in size- Microservices คือการนำรูปแบบการออกแบบ SOA มาใช้ ขอแนะนำให้ใช้บริการของคุณให้มากที่สุดเท่าที่จะทำได้ โดยพื้นฐานแล้วบริการไม่ควรทำงานทางธุรกิจมากกว่าหนึ่งอย่างดังนั้นจึงเห็นได้ชัดว่ามีขนาดเล็กและดูแลรักษาง่ายกว่าแอปพลิเคชันเสาหินอื่น ๆ

• Focused- ดังที่กล่าวไว้ก่อนหน้านี้ไมโครเซอร์วิสแต่ละตัวได้รับการออกแบบมาเพื่อส่งมอบงานทางธุรกิจเพียงงานเดียว ในขณะที่ออกแบบไมโครเซอร์วิสสถาปนิกควรคำนึงถึงจุดโฟกัสของบริการซึ่งเป็นสิ่งที่ส่งมอบได้ ตามความหมายแล้วไมโครเซอร์วิสหนึ่งตัวควรมีลักษณะเป็นสแต็กเต็มรูปแบบและควรมุ่งมั่นที่จะส่งมอบทรัพย์สินทางธุรกิจเพียงรายการเดียว

• Autonomous- บริการไมโครแต่ละรายการควรเป็นหน่วยธุรกิจที่เป็นอิสระของแอปพลิเคชันทั้งหมด ดังนั้นแอปพลิเคชันจึงทำงานร่วมกันอย่างหลวม ๆ ซึ่งช่วยลดต้นทุนการบำรุงรักษา

• Technology heterogeneity- Microservice สนับสนุนเทคโนโลยีที่แตกต่างกันเพื่อสื่อสารกันในหน่วยธุรกิจเดียวซึ่งช่วยให้นักพัฒนาใช้เทคโนโลยีที่ถูกต้องในสถานที่ที่ถูกต้อง ด้วยการใช้ระบบที่แตกต่างกันเราจะได้รับความปลอดภัยสูงสุดความเร็วและระบบที่ปรับขนาดได้

• Resilience- ความยืดหยุ่นเป็นคุณสมบัติของการแยกหน่วยซอฟต์แวร์ Microservice เป็นไปตามความยืดหยุ่นในระดับสูงในวิธีการสร้างดังนั้นเมื่อใดก็ตามที่หน่วยงานหนึ่งล้มเหลวจะไม่ส่งผลกระทบต่อธุรกิจทั้งหมด ความยืดหยุ่นเป็นอีกคุณสมบัติหนึ่งที่ใช้ระบบคู่ที่ปรับขนาดได้สูงและน้อยลง

• Ease of deployment- เนื่องจากแอปพลิเคชันทั้งหมดถูกแบ่งย่อยออกเป็นชิ้นส่วนเล็ก ๆ ส่วนประกอบทุกชิ้นจึงควรมีลักษณะเป็นสแต็กเต็ม ทั้งหมดนี้สามารถปรับใช้ในทุกสภาพแวดล้อมได้อย่างง่ายดายโดยมีเวลาที่ซับซ้อนน้อยกว่าซึ่งแตกต่างจากแอปพลิเคชันเสาหินอื่น ๆ ในประเภทเดียวกัน

ต่อไปนี้เป็นประเด็นบางประการเกี่ยวกับข้อเสียของสถาปัตยกรรมไมโครเซอร์วิส

ข้อเสีย

• Distributed system- เนื่องจากความแตกต่างทางเทคนิคเทคโนโลยีที่แตกต่างกันจะถูกนำมาใช้เพื่อพัฒนาส่วนต่างๆของไมโครเซอร์วิส จำเป็นต้องมีผู้เชี่ยวชาญที่มีทักษะจำนวนมากเพื่อสนับสนุนซอฟต์แวร์แบบกระจายที่แตกต่างกันขนาดใหญ่นี้ ดังนั้นการกระจายและความแตกต่างจึงเป็นข้อเสียอันดับหนึ่งของการใช้ไมโครเซอร์วิส

• Cost - Microservice มีค่าใช้จ่ายสูงเนื่องจากคุณต้องรักษาพื้นที่เซิร์ฟเวอร์ที่แตกต่างกันสำหรับงานธุรกิจที่แตกต่างกัน

• Enterprise readiness- สถาปัตยกรรม Microservice ถือได้ว่าเป็นกลุ่มของเทคโนโลยีที่แตกต่างกันเนื่องจากเทคโนโลยีมีการพัฒนาขึ้นทุกวัน ดังนั้นจึงเป็นเรื่องยากที่จะสร้างองค์กรแอปพลิเคชันไมโครเซอร์วิสให้พร้อมเมื่อเทียบกับรูปแบบการพัฒนาซอฟต์แวร์ทั่วไป

Microservice ผ่าน SOA

ตารางต่อไปนี้แสดงคุณสมบัติบางอย่างของ SOA และ Microservice โดยให้ความสำคัญของการใช้ microservice ผ่าน SOA

ส่วนประกอบ	SOA	ไมโครเซอร์วิส
รูปแบบการออกแบบ	SOA เป็นกระบวนทัศน์การออกแบบสำหรับซอฟต์แวร์คอมพิวเตอร์โดยที่ส่วนประกอบของซอฟต์แวร์จะเปิดเผยต่อโลกภายนอกเพื่อใช้งานในรูปแบบของบริการ	Micro Service เป็นส่วนหนึ่งของ SOA เป็นการใช้งาน SOA โดยเฉพาะ
การพึ่งพา	หน่วยธุรกิจพึ่งพาซึ่งกันและกัน	หน่วยธุรกิจทั้งหมดเป็นอิสระจากกัน
ขนาด	ขนาดซอฟต์แวร์ใหญ่กว่าซอฟต์แวร์ทั่วไป	ขนาดซอฟต์แวร์มีขนาดเล็ก
เทคโนโลยี	กองเทคโนโลยีน้อยกว่า Microservice	Microservice มีลักษณะที่แตกต่างกันเนื่องจากเทคโนโลยีที่แน่นอนถูกนำมาใช้เพื่อทำงานเฉพาะอย่าง Microservices ถือได้ว่าเป็นกลุ่มของเทคโนโลยีมากมาย
อิสระและโฟกัส	แอปพลิเคชัน SOA สร้างขึ้นเพื่อทำงานทางธุรกิจหลายอย่าง	แอปพลิเคชัน Microservice สร้างขึ้นเพื่อทำงานทางธุรกิจเดียว
ธรรมชาติ	เสาหินในธรรมชาติ	กองเต็มในธรรมชาติ
การปรับใช้	การทำให้ใช้งานได้ใช้เวลานาน	การปรับใช้ทำได้ง่ายมาก ดังนั้นจะใช้เวลาน้อยลง
ลดค่าใช้จ่าย	คุ้มค่ากว่า	คุ้มค่าน้อยลง
ความสามารถในการปรับขนาด	น้อยกว่าเมื่อเทียบกับ Microservices	ปรับขนาดเต็มที่
ตัวอย่าง	ให้เราพิจารณาแอปพลิเคชันการจอง CAB ออนไลน์หนึ่งรายการ หากเราต้องการสร้างแอปพลิเคชันนั้นโดยใช้ SOA หน่วยซอฟต์แวร์จะเป็น - GetPayments และ DriverInformation และ MappingDataAPI AuthenticateUsersAnd DriversAPI	หากแอปพลิเคชันเดียวกันสร้างขึ้นโดยใช้สถาปัตยกรรมไมโครเซอร์วิส API จะเป็น - SubmitPaymentsService GetDriverInfoService GetMappingDataService AuthenticateUserService AuthenticateDriverService

การปรับขนาดเป็นกระบวนการย่อยซอฟต์แวร์ในหน่วยต่างๆ การปรับขนาดยังกำหนดในแง่ของความสามารถในการปรับขนาด ความสามารถในการปรับขนาดเป็นศักยภาพในการใช้คุณสมบัติขั้นสูงของแอปพลิเคชัน ช่วยปรับปรุงความปลอดภัยความทนทานและการบำรุงรักษาของแอปพลิเคชัน เรามีขั้นตอนการปรับขนาดสามประเภทที่ปฏิบัติตามในอุตสาหกรรมต่างๆ ต่อไปนี้เป็นวิธีการปรับขนาดที่แตกต่างกันพร้อมกับตัวอย่างในชีวิตจริงที่เกี่ยวข้อง

การปรับขนาดแกน X

การปรับขนาดแกน X เรียกอีกอย่างว่ามาตราส่วนแนวนอน ในขั้นตอนนี้แอปพลิเคชันทั้งหมดจะถูกแบ่งย่อยออกเป็นส่วนต่างๆในแนวนอน โดยปกติเว็บเซิร์ฟเวอร์แอปพลิเคชันใด ๆ สามารถมีการปรับขนาดประเภทนี้ได้ พิจารณาสถาปัตยกรรม MVC ปกติที่เป็นไปตามมาตราส่วนแนวนอนดังแสดงในรูปต่อไปนี้

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

แกน Y

การปรับขนาดแกน Y เรียกอีกอย่างว่ามาตราส่วนแนวตั้งที่รวมการปรับระดับทรัพยากรใด ๆ ระบบ DBaaS หรือ Hadoop ใด ๆ ถือได้ว่าเป็นแกน Y ในการปรับขนาดประเภทนี้คำขอของผู้ใช้จะถูกเปลี่ยนเส้นทางและ จำกัด โดยใช้ตรรกะบางอย่าง

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

วิธีการแบ่งทรัพยากรออกเป็นหน่วยธุรกิจอิสระขนาดเล็กนี้เรียกว่าการปรับขนาดแกน Y

แกน Z

การปรับขนาดแกน X และ Y นั้นเข้าใจง่ายกว่ามาก อย่างไรก็ตามแอปพลิเคชันหนึ่งสามารถปรับขนาดได้ในระดับธุรกิจซึ่งเรียกว่าการปรับขนาดแกน Z ต่อไปนี้เป็นตัวอย่างของการปรับขนาดแอปพลิเคชันบริการรถแท็กซี่ในประเภทธุรกิจต่างๆ

ข้อดีของการขูดหินปูน

• Cost - การปรับขนาดซอฟต์แวร์ที่เหมาะสมจะช่วยลดต้นทุนในการบำรุงรักษา

• Performance - เนื่องจากข้อต่อหลวมประสิทธิภาพของซอฟต์แวร์ที่ปรับขนาดอย่างเหมาะสมจึงดีกว่าซอฟต์แวร์ที่ไม่ปรับขนาดเสมอ

• Load distribution - การใช้เทคโนโลยีที่แตกต่างกันทำให้เราสามารถรักษาการโหลดเซิร์ฟเวอร์ของเราได้อย่างง่ายดาย

• Reuse - ความสามารถในการปรับขนาดของซอฟต์แวร์ยังช่วยเพิ่มความสามารถในการใช้งานซอฟต์แวร์

Microservice ใช้ SOA ภายใน ในแง่ที่กว้างขึ้นเราสามารถพิจารณาว่าเป็นส่วนย่อยของแอปพลิเคชัน SOA หนึ่ง

กฎและขั้นตอนการทำงาน

ต่อไปนี้เป็นหลักการที่ต้องได้รับการดูแลในขณะที่พัฒนาไมโครเซอร์วิส

• High Cohesion- โมเดลธุรกิจทั้งหมดจะต้องแบ่งย่อยเป็นส่วนธุรกิจที่เล็กที่สุดให้มากที่สุด แต่ละบริการควรมุ่งเน้นเพื่อดำเนินงานทางธุรกิจเพียงอย่างเดียว

• Independent - บริการทั้งหมดควรเป็นแบบเต็มรูปแบบและเป็นอิสระจากกัน

• Business Domain Centric - ซอฟต์แวร์จะโมดูลาร์ตามหน่วยธุรกิจและไม่อิงตามระดับ

• Automation- การปรับใช้การทดสอบจะเป็นไปโดยอัตโนมัติ พยายามแนะนำให้มีปฏิสัมพันธ์กับมนุษย์น้อยที่สุด

• Observable - แต่ละบริการจะมีลักษณะเป็นสแต็กเต็มรูปแบบและควรใช้งานได้อย่างอิสระและสังเกตได้เช่นเดียวกับแอปพลิเคชันระดับองค์กร

การจัดการทีม

“ Two Pizza Rule” เป็นกฎประเภทหนึ่งที่ จำกัด จำนวนผู้เข้าร่วมในทีมพัฒนาไมโครเซอร์วิส ตามกฎนี้จำนวนสมาชิกในทีมของหนึ่งแอปพลิเคชันควรมีขนาดเล็กมากจนสามารถป้อนพิซซ่าได้สองชิ้น โดยทั่วไปจำนวนไม่ควรเกิน 8 เนื่องจาก microservice มีลักษณะเป็น full stack ทีมจึงเป็น full stack ตามธรรมชาติ ในการเพิ่มผลผลิตเราต้องสร้างทีมหนึ่งทีมสูงสุด 8 คนพร้อมความเชี่ยวชาญทุกประเภทที่จำเป็นสำหรับบริการนั้น

การจัดการงาน

งานเป็นบทบาทสำคัญในวงจรชีวิตการพัฒนาซอฟต์แวร์ การพัฒนาแอปพลิเคชันขนาดใหญ่สามารถแบ่งออกเป็นหน่วยงานย่อย ๆ ให้เราพิจารณาว่าเราจำเป็นต้องพัฒนาแอปพลิเคชั่นเดียวเช่น Facebook จากนั้นฟังก์ชัน "เข้าสู่ระบบ" ถือได้ว่าเป็นงานของกระบวนการสร้างทั้งหมด ความคืบหน้าของแต่ละงานเหล่านี้จำเป็นต้องได้รับการตรวจสอบอย่างเหมาะสมภายใต้ผู้เชี่ยวชาญที่มีทักษะสูง Agile เป็นโครงสร้างกระบวนการที่รู้จักกันดีตามในอุตสาหกรรมเพื่อให้ทันกับการจัดการงานที่ดี

จนถึงตอนนี้เราได้เรียนรู้แล้วว่า Microservice คืออะไรและอะไรคือความต้องการพื้นฐานเหนือสถาปัตยกรรม MVC สมัยใหม่ ในบทนี้เราจะเรียนรู้องค์ประกอบต่างๆของสถาปัตยกรรมนี้ที่มีความสำคัญเท่าเทียมกันสำหรับการบริการ

ประเภทของบริการ

ตามชื่อ Microservice เราถือว่าบริการนี้สามารถใช้งานผ่านโปรโตคอล HTTP ได้อย่างไรก็ตามเราจำเป็นต้องทราบว่าสามารถสร้างบริการประเภทใดได้โดยใช้สถาปัตยกรรมนี้ ต่อไปนี้เป็นรายการบริการที่สามารถใช้งานได้โดยใช้สถาปัตยกรรม Microservice

Platform as a Service [PaaS]- ในสถาปัตยกรรมที่มุ่งเน้นบริการนี้แพลตฟอร์มจะถูกกำหนดให้เป็นเครื่องมือที่สามารถปรับแต่งได้ตามความต้องการทางธุรกิจ PaaS มีบทบาทสำคัญในการพัฒนาแอปพลิเคชันบนมือถือ ตัวอย่างที่ดีที่สุดของ PaaS คือเครื่องมือ Google App ซึ่ง Google มีแพลตฟอร์มที่มีประโยชน์ต่างๆเพื่อสร้างแอปพลิเคชันของคุณ เดิมที PaaS พัฒนาขึ้นเพื่อมอบสถาปัตยกรรมหรือโครงสร้างพื้นฐานในตัวให้กับนักพัฒนา ช่วยลดความซับซ้อนในการเขียนโปรแกรมระดับสูงในเวลาที่ลดลงอย่างมาก ต่อไปนี้เป็นภาพรวมของ PaaS ที่ Google ให้มา

Software as a Service [SaaS]- Software as a Service เป็นธุรกิจลิขสิทธิ์ซอฟต์แวร์ซึ่งซอฟต์แวร์จะโฮสต์จากส่วนกลางและได้รับอนุญาตจากการสมัครสมาชิก SaaS สามารถเข้าถึงได้ผ่านเบราว์เซอร์เป็นหลักและเป็นรูปแบบสถาปัตยกรรมที่ใช้กันทั่วไปในธุรกิจหลายประเภทเช่นการจัดการทรัพยากรมนุษย์ (HRM) การวางแผนทรัพยากรองค์กร (ERP) การจัดการลูกค้าสัมพันธ์ (CRM) เป็นต้นภาพหน้าจอต่อไปนี้จะแสดงตัวอย่างของ SaaS ที่แตกต่างจาก Oracle

Infrastructure as a Service [IaaS]- โครงสร้างพื้นฐานมีบทบาทที่ดีในอุตสาหกรรมไอที การใช้ระบบคลาวด์คอมพิวติ้งบางองค์กรมีโครงสร้างพื้นฐานเสมือนเป็นบริการของตน IaaS มีประโยชน์มากในการนำความคล่องตัวความคุ้มค่าความปลอดภัยประสิทธิภาพการทำงานและอื่น ๆ มาใช้ในการพัฒนาซอฟต์แวร์ Amazon EC2 และ Microsoft Azure เป็นตัวอย่างที่ใหญ่ที่สุดของ IaaS ภาพต่อไปนี้แสดงตัวอย่างของ AWS ซึ่งมีการจัดเตรียมศูนย์ข้อมูลเป็น IaaS

Data as a Service [DaaS]- เทคโนโลยีสารสนเทศเกี่ยวข้องกับข้อมูลและผู้นำในอุตสาหกรรมชั้นนำบางคนเชื่อว่าข้อมูลจะเป็นปัจจัยยังชีพใหม่ของสังคม DaaS เป็นบริการประเภทหนึ่งที่มีการแบ่งปันข้อมูลกับกลุ่มธุรกิจเพื่อการวิจัยและวิเคราะห์ DaaS นำมาซึ่งความเรียบง่ายคล่องตัวและความปลอดภัยในชั้นการเข้าถึงข้อมูล ต่อไปนี้เป็นตัวอย่างของ Oracle Data cloud ซึ่งสามารถเข้าถึงหรือได้รับอนุญาตสำหรับความต้องการทางธุรกิจของคุณเอง

Back End as a Service [BaaS]- BaaS เป็นที่รู้จักกันในชื่อ MBaaS ซึ่งหมายถึงบริการแบ็คเอนด์มือถือ ในบริการประเภทนี้แบ็กเอนด์ของแอปพลิเคชันจะถูกจัดเตรียมไว้ให้กับหน่วยธุรกิจเพื่อการลงทุนทางธุรกิจของตนเอง การแจ้งเตือนแบบพุชบริการเครือข่ายสังคมทั้งหมดอยู่ภายใต้บริการประเภทนี้ Facebook และ Twitter เป็นตัวอย่างของผู้ให้บริการ BaaS ที่มีชื่อเสียง

ความปลอดภัย

เมื่อต้องจัดการกับข้อมูลลูกค้าจำนวนมากการรักษาความปลอดภัยจึงมีบทบาทสำคัญ ปัญหาด้านความปลอดภัยเกี่ยวข้องกับบริการทุกประเภทที่มีอยู่ในตลาด ไม่ว่าคุณจะใช้ระบบคลาวด์แบบใด - ส่วนตัวสาธารณะไฮบริด ฯลฯ ควรรักษาความปลอดภัยในทุกระดับ ปัญหาด้านความปลอดภัยทั้งหมดสามารถแบ่งออกเป็นส่วนย่อย ๆ ได้อย่างกว้าง ๆ -

• Security issue faced by service providers - ปัญหาด้านความปลอดภัยประเภทนี้ต้องเผชิญกับผู้ให้บริการเช่น Google, Amazon เป็นต้นเพื่อให้แน่ใจว่ามีการป้องกันความปลอดภัยการตรวจสอบประวัติของไคลเอ็นต์เป็นสิ่งที่จำเป็นโดยเฉพาะอย่างยิ่งผู้ที่สามารถเข้าถึงส่วนหลักของคลาวด์ได้โดยตรง

• Security issue faced by consumers- Cloud มีค่าใช้จ่ายที่เป็นมิตรดังนั้นจึงมีการใช้กันอย่างแพร่หลายในอุตสาหกรรมต่างๆ บางองค์กรจัดเก็บรายละเอียดผู้ใช้ในศูนย์ข้อมูลของบุคคลที่สามและดึงข้อมูลเมื่อจำเป็น ดังนั้นจึงจำเป็นต้องรักษาระดับความปลอดภัยเพื่อไม่ให้ผู้ใช้รายอื่นเห็นข้อมูลส่วนตัวของลูกค้ารายใดรายหนึ่ง

เพื่อป้องกันปัญหาด้านความปลอดภัยดังกล่าวข้างต้นกลไกการป้องกันบางส่วนที่องค์กรใช้มีดังต่อไปนี้

• Deterrent Control - รู้ว่าคุณอาจเป็นภัยคุกคามเพื่อลดการโจมตีทางไซเบอร์

• Preventive Control - รักษานโยบายการตรวจสอบสิทธิ์ระดับสูงเพื่อเข้าถึงระบบคลาวด์ของคุณ

• Detective Control - ตรวจสอบผู้ใช้ของคุณและตรวจจับความเสี่ยงที่อาจเกิดขึ้น

• Corrective Control - ทำงานอย่างใกล้ชิดกับทีมต่างๆและแก้ไขปัญหาที่เกิดขึ้นระหว่างขั้นตอนการควบคุมนักสืบ

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

การสลายตัวตามหน้าที่มีบทบาทสำคัญในการสร้างไมโครเซอร์วิสของคุณ มอบความคล่องตัวความยืดหยุ่นและความสามารถในการปรับขนาดให้กับแอปพลิเคชันของคุณ

รูปแบบผู้รวบรวม

รูปแบบ Aggregator เป็นรูปแบบเว็บที่ง่ายที่สุดที่สามารถใช้งานได้ในขณะที่พัฒนาไมโครเซอร์วิส ในรูปแบบการจัดองค์ประกอบนี้โมดูลเว็บอย่างง่ายจะทำหน้าที่เป็นตัวจัดสรรภาระงานซึ่งหมายความว่าจะเรียกใช้บริการที่แตกต่างกันตามข้อกำหนด ต่อไปนี้เป็นแผนภาพที่แสดงถึงเว็บแอปไมโครเซอร์วิสที่เรียบง่ายพร้อมการออกแบบตัวรวบรวม ดังที่เห็นในภาพต่อไปนี้ "Aggregator" มีหน้าที่เรียกใช้บริการต่างๆทีละรายการ หากเราต้องการใช้ตรรกะทางธุรกิจใด ๆ กับผลลัพธ์ของบริการ A, B และ C เราก็สามารถใช้ตรรกะทางธุรกิจในตัวรวบรวมได้

ผู้รวบรวมสามารถเปิดเผยได้อีกครั้งในฐานะบริการอื่นสู่โลกภายนอกซึ่งผู้อื่นสามารถใช้งานได้ทุกเมื่อที่ต้องการ ในขณะที่พัฒนาบริการเว็บรูปแบบตัวรวบรวมข้อมูลเราจำเป็นต้องจำไว้ว่าบริการ A, B และ C แต่ละรายการของเราควรมีชั้นแคชของตัวเองและควรเป็นแบบเต็มสแต็ก

รูปแบบพร็อกซี

Proxy microservice pattern เป็นรูปแบบของ aggregator model ในรุ่นนี้เราจะใช้โมดูลพร็อกซีแทนโมดูลการรวม บริการพร็อกซีอาจเรียกใช้บริการที่แตกต่างกันเป็นรายบุคคล

ในรูปแบบพร็อกซีเราสามารถสร้างความปลอดภัยพิเศษได้อีกหนึ่งระดับโดยจัดเตรียมเลเยอร์พร็อกซีการถ่ายโอนข้อมูล เลเยอร์นี้ทำหน้าที่คล้ายกับอินเทอร์เฟซ

รูปแบบที่ถูกล่ามโซ่

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

ข้อเสียเปรียบที่สำคัญอย่างหนึ่งของสถาปัตยกรรมนี้คือไคลเอนต์จะถูกบล็อกจนกว่ากระบวนการทั้งหมดจะเสร็จสมบูรณ์ ดังนั้นจึงขอแนะนำอย่างยิ่งให้รักษาความยาวของโซ่ให้สั้นที่สุด

รูปแบบบริการไมโครสาขา

Branch microservice เป็นเวอร์ชันขยายของรูปแบบตัวรวบรวมและรูปแบบโซ่ ในรูปแบบการออกแบบนี้ลูกค้าสามารถสื่อสารกับบริการได้โดยตรง นอกจากนี้บริการหนึ่งรายการสามารถสื่อสารกับบริการได้มากกว่าหนึ่งบริการในแต่ละครั้ง ต่อไปนี้คือการแสดงแผนผังของ Branch Microservice

รูปแบบไมโครเซอร์วิสสาขาช่วยให้นักพัฒนาสามารถกำหนดค่าการเรียกใช้บริการแบบไดนามิก การเรียกใช้บริการทั้งหมดจะเกิดขึ้นพร้อมกันซึ่งหมายความว่าบริการ A สามารถเรียกใช้บริการ B และ C ได้พร้อมกัน

รูปแบบทรัพยากรที่ใช้ร่วมกัน

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

ในบทนี้เราจะพัฒนาแอปพลิเคชันที่ใช้ CRUD ด้วยสถาปัตยกรรม SOA ต่อไปในบทต่อ ๆ ไปเราจะแยกบริการนี้ออกเป็นไมโครเซอร์วิสและเราจะเรียนรู้ความแตกต่างพื้นฐานระหว่างสถาปัตยกรรม SOA และไมโครเซอร์วิส

การกำหนดค่าระบบและการตั้งค่า

ในส่วนนี้เราจะสร้างแอปพลิเคชัน CRUD ตัวอย่างซึ่งจะส่งคืนออบเจ็กต์ JSON เป็นการตอบสนองทุกครั้งที่เราเรียกใช้บริการของเรา เราจะใช้เจอร์ซีกรอบในการพัฒนาเดียวกัน ต่อไปนี้เป็นขั้นตอนในการตั้งค่าสภาพแวดล้อมระบบโลคัลของคุณ

การพัฒนาแอปพลิเคชัน CRUD

Step 1- เราจะใช้ NetBeans เป็น IDE ในการพัฒนา โปรดดาวน์โหลดและติดตั้งเวอร์ชันล่าสุดบนเว็บไซต์ทางการของ NetBeanshttps://netbeans.org/downloads/.

Step 2- เปิด NetBeans IDE ของคุณ ไปที่“ ไฟล์ -> โครงการใหม่” ภาพหน้าจอต่อไปนี้จะปรากฏขึ้น เลือก“ Maven” เป็นหมวดหมู่และเลือก“ Project from ArchType” เป็นโปรเจ็กต์แล้วกด Next

สิ่งนี้จะดาวน์โหลดไฟล์ jar ที่จำเป็นทั้งหมดเพื่อสร้างโปรเจ็กต์ Maven และ RESTful Web Service ครั้งแรกของคุณ

Step 3- ในการกดปุ่ม Next ในขั้นตอนก่อนหน้านี้ภาพหน้าจอต่อไปนี้จะปรากฏขึ้น ที่นี่คุณจะต้องระบุ Maven Archetype

ในช่องค้นหาให้ค้นหา“ Jersey-archType-Webapp (2.16)” แล้วเลือกช่องทำเครื่องหมาย“ Show Older”

Step 4- เมื่อคุณเลือกแบบเดียวกันคุณจะถูกนำไปยังหน้าจอต่อไปนี้ เลือกโถที่ต้องการจากรายการและกด Next เพื่อดำเนินการต่อ

Step 5- ในขั้นตอนนี้คุณต้องระบุชื่อโครงการของคุณและรหัสกลุ่มของคุณรวมทั้งรายละเอียดแพ็คเกจ หลังจากให้ข้อมูลทั้งหมดแล้วให้กด Finish เพื่อดำเนินการต่อ

Step 6- คุณตั้งค่าพื้นที่ทำงานเสร็จแล้ว ไดเรกทอรีโครงการจะมีลักษณะดังต่อไปนี้

ตรวจสอบโฟลเดอร์ "Dependencies" ของคุณและคุณจะพบว่า Maven ได้ดาวน์โหลดไฟล์ jar ที่จำเป็นทั้งหมดสำหรับโครงการนี้โดยอัตโนมัติ

Step 7- พื้นที่ทำงานของคุณได้รับการตั้งค่าและคุณสามารถเริ่มต้นด้วยการเขียนโค้ดได้ สร้างคลาสและแพ็กเกจสี่คลาสตามที่ระบุไว้ในภาพหน้าจอต่อไปนี้ คุณจะพบว่า MyResource.java สร้างขึ้นโดย Maven แล้วเนื่องจาก Maven ฉลาดพอที่จะตรวจพบว่าคุณกำลังจะสร้างบริการเว็บของคุณเอง

Step 8 - เมื่อทำตามขั้นตอนข้างต้นเสร็จแล้วเราจะสร้างคลาส POJO ของเราที่เป็น UserProfile.java ดังต่อไปนี้

package com.tutorialspoint.userprofile.Model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class UserProfile {
   private long ProId;
   private String FName;
   private String LName;
   private String Add;
   public UserProfile(){}
   
   public UserProfile(long Proid, String Fname, String Lname,String Add) {
      this.ProId = Proid;
      this.FName = Fname;
      this.LName = Lname;
      this.Add = Add;
   }
   public long getProId() {
      return ProId;
   }
   public void setProId(long ProId) {
      this.ProId = ProId;
   }
   public String getFName() {
      return FName;
   }
   public void setFName(String FName) {
      this.FName = FName;
   }
   public String getLName() {
      return LName;
   }
   public void setLName(String LName) {
      this.LName = LName;
   }
   public String getAdd() {
      return Add;
   }
   public void setAdd(String Add) {
      this.Add = Add;
   }
}

Step 9- ตอนนี้เราจะสร้างคลาสฐานข้อมูลของเรา เนื่องจากนี่เป็นส่วนหนึ่งของสื่อการเรียนรู้เราจะไม่ใช้ฐานข้อมูลใด ๆ เป็นฐานข้อมูลของเรา เราจะใช้หน่วยความจำ Java ในตัวเพื่อทำงานเป็นหน่วยความจำชั่วคราวของเรา ดังที่คุณเห็นในชุดรหัสต่อไปนี้เราจะใช้ MAP เป็นฐานข้อมูลของเรา การดำเนินการบริการเว็บทั้งหมดที่เราดำเนินการเราจะทำงานบน MAP นี้ที่กำหนดไว้ในคลาส

package com.tutorialspoint.userprofile.DAO;

import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.HashMap;
import java.util.Map;

public class DatabaseClass {
   private static Map<Long,UserProfile> messages = new HashMap<Long,UserProfile>();
   public static Map<Long,UserProfile> getUsers() {
      return messages; 
      // Each time this method will return entire map as an instance of database
   }
}

Step 10- ตอนนี้ให้เราสร้างคลาสบริการของเรา คัดลอกและวางชุดรหัสต่อไปนี้ในคลาส“ ProfileService.java” นี่คือคลาสที่เราจะประกาศวิธีการบริการเว็บทั้งหมดของเราที่จะเปิดเผยต่อโลกภายนอก เราจำเป็นต้องสร้างการอ้างอิงของ DatabaseClass ของเราเพื่อให้สามารถเข้าถึงฐานข้อมูลชั่วคราวของเราได้ในคลาสนี้

package com.tutorialspoint.userprofile.service;

import com.tutorialspoint.userprofile.DAO.DatabaseClass;
import com.tutorialspoint.userprofile.Model.UserProfile;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class ProfileService {
   private Map<Long,UserProfile> Userprofiles = DatabaseClass.getUsers();
   
   // Creating some predefine profile and populating the same in the map
   public ProfileService() {
      UserProfile m1 = new UserProfile(1L,"Tutorials1","Point1","TutorialsPoint.com");
      UserProfile m2 = new UserProfile(2L,"Tutorials2","Point2","TutorialsPoint.com2");
      UserProfile m3 = new UserProfile(3L,"Tutorials3","Point3","TutorialsPoint.com3");
      UserProfile m4 = new UserProfile(4L,"Tutorials4","Point4","TutorialsPoint.com4");
      
      Userprofiles.put(1L, m1);
      Userprofiles.put(2L, m2);
      Userprofiles.put(1L, m3);
      Userprofiles.put(2L, m4);
   }
   
   //Method to fetch all profile
   public List<UserProfile> getAllProfile() {
      List<UserProfile> list = new ArrayList<UserProfile>(Userprofiles.values());
      return list;
   }  // Method to fetch only one profile depending on the ID provided
   
   public UserProfile getProfile(long id) {
      return Userprofiles.get(id);
   }  //Method to add profile
   
   public UserProfile addProfile(UserProfile UserProfile) {
      UserProfile.setProId(Userprofiles.size()+1);
      Userprofiles.put(UserProfile.getProId(), UserProfile);
      return UserProfile;
   }  //method to update Profile

   public UserProfile UpdateProfile(UserProfile UserProfile) {
      if(UserProfile.getProId()<=0) { 
         return null;
      } else { 
         Userprofiles.put(UserProfile.getProId(), UserProfile);
         return UserProfile;
      }
   } //method to delete profile
   
   public void RemoveProfile(long Id) {
      Userprofiles.remove(Id);
   }
}

Step 11 - ในขั้นตอนนี้เราจะสร้างคลาส Resource ของเราที่จะเชื่อมโยงกับ URL และจะเรียกใช้บริการที่เกี่ยวข้อง

package com.tutorialspoint.userprofile.Resource;

import com.tutorialspoint.userprofile.Model.UserProfile;
import com.tutorialspoint.userprofile.service.ProfileService;

import java.util.List;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/Profile")
@Consumes(MediaType.APPLICATION_XML)
@Produces(MediaType.APPLICATION_XML)

public class ProfileResource {
   ProfileService messageService = new ProfileService();
   
   @GET
   public List<UserProfile> getProfile() {
      return messageService.getAllProfile();
   }

   @GET
   @Path("/{ProID}")
   public UserProfile getProfile(@PathParam("ProID")long Id) {
      return messageService.getProfile(Id);
   }

   @POST
   public UserProfile addProfile(UserProfile profile) {
      return messageService.addProfile(profile);
   }

   @PUT
   @Path("/{proID}")
   public UserProfile UpdateProfile(@PathParam("proID")long Id,UserProfile UserProfile) {
      UserProfile.setProId(Id);
      return messageService.UpdateProfile(UserProfile);
   }
   
   @DELETE
   @Path("/{ProID}")
   public void deleteProfile(@PathParam("ProID")long Id) {
      messageService.RemoveProfile(Id);
   }
}

Step 12- ทำความสะอาดสร้างโครงการและเรียกใช้ หากทุกอย่างเป็นไปด้วยดีคุณควรได้รับผลลัพธ์ต่อไปนี้ในเบราว์เซอร์ขณะเข้าถึงhttp://localhost:8080/UserProfile/webapi/Profile” URL

คุณสามารถดูรายการต่างๆที่สร้างขึ้นโดยใช้การแสดง XML

วิธีการต่างๆสามารถทดสอบได้โดยใช้บุรุษไปรษณีย์โดยใช้ URL วิธีการที่เหมาะสม

@GET method - ภาพหน้าจอต่อไปนี้แสดงให้เห็นว่าเราจะได้ผลลัพธ์ที่ต้องการสำหรับคำขอได้อย่างไรซึ่งจะแสดงรายละเอียดผู้ใช้ทั้งหมด

@POST- สามารถใช้คำขอต่อไปนี้เพื่อทดสอบวิธีการโพสต์ของเรา สังเกตว่า proId ถูกสร้างขึ้นโดยอัตโนมัติอย่างไร

@PUT- วิธีนี้จะอัปเดตรายการ ภาพหน้าจอต่อไปนี้แสดงให้เห็นว่า Jersey ใช้ proId จาก URL คำขอและอัปเดตการตอบกลับโปรไฟล์ผู้ใช้เดียวกันได้อย่างไร

ในทำนองเดียวกันคุณสามารถตรวจสอบวิธีการอื่น ๆ ที่มีอยู่ในบริการบนเว็บของคุณ

ในส่วนก่อนหน้านี้เราได้พัฒนาบริการหนึ่งซึ่งจะแสดงฟังก์ชัน CRUD เมื่อใดก็ตามที่เราพยายามใช้บริการนี้ในแอปพลิเคชันของเราเราจำเป็นต้องสร้างไคลเอนต์ของแอปพลิเคชันนี้และแนบไปกับแอปพลิเคชันของเรา ในบทนี้เราจะเรียนรู้วิธีการสร้างฟังก์ชันนี้โดยใช้แนวคิดของ Microservice ต่อไปนี้คือการแสดงแผนผังของแอปพลิเคชันของเราที่สร้างขึ้นโดยใช้ขั้นตอนข้างต้น

นักแสดงควรเป็นจุดเริ่มต้นของบริการของเรา ในกรณีนี้“ ProfileResource.java” จะเป็นหน้าที่ของนักแสดง คลาสนี้จะเรียกวิธีการที่แตกต่างกันเพื่อดำเนินการที่แตกต่างกันเช่นเพิ่มอัปเดตและลบ

การสลายตัวของแอปพลิเคชัน CRUD

ตามหลักการสำคัญของ microservice เราจำเป็นต้องมีงานทางธุรกิจเพียงอย่างเดียวสำหรับแต่ละโมดูลดังนั้นนักแสดงคนหนึ่งจึงไม่ควรรับผิดชอบฟังก์ชัน CRUD ทั้งสี่อย่าง ลองพิจารณาตัวอย่างต่อไปนี้ที่เราได้แนะนำบทบาทใหม่บางอย่างเพื่อให้คุณเข้าใจได้อย่างชัดเจนว่า Microservice เป็นตัวแทนทางสถาปัตยกรรมของ SOA

“ ผู้ใช้หลัก” คือผู้ใช้ที่สื่อสารกับ“ Application Controller” เพื่อตอบสนองความต้องการ “ ตัวควบคุมแอปพลิเคชัน” คือผู้ที่เรียกว่า“ ผู้จัดการทรัพยากร” ที่แตกต่างกันโดยขึ้นอยู่กับคำขอจากผู้ใช้ปลายทาง “ ผู้จัดการทรัพยากร” ทำงานที่จำเป็นต้องทำ มาดูบทบาทต่างๆของหน่วยต่างๆของแอปพลิเคชันกันอย่างรวดเร็ว

• End User/Main Users - ขอทรัพยากรบางอย่างไปยัง Application Controller

• Application - รับคำขอและส่งต่อสิ่งเดียวกันกับผู้จัดการทรัพยากรเฉพาะ

• Resource Manager - งานอัปเดตลบและเพิ่มผู้ใช้จริงหรือไม่

ดูว่าความรับผิดชอบทั้งหมดของชั้นเรียนหนึ่งถูกกระจายไปยังชั้นเรียนอื่น ๆ อย่างไร

ในบทนี้เราจะสร้างแอพพลิเคชั่นไมโครเซอร์วิสหนึ่งตัวที่จะใช้บริการต่างๆที่มีอยู่ เราทุกคนรู้ดีว่า microservice ไม่ใช่วิธีที่คุ้มค่าในการสร้างแอปพลิเคชันเนื่องจากแต่ละบริการที่เราสร้างขึ้นจะเป็นแบบเต็มรูปแบบ การสร้างไมโครเซอร์วิสในสภาพแวดล้อมโลคัลจะต้องมีการกำหนดค่าระบบระดับไฮเอนด์เนื่องจากคุณต้องมีเซิร์ฟเวอร์สี่อินสแตนซ์เพื่อให้ทำงานต่อไปได้เพื่อให้สามารถใช้งานได้ ณ เวลา ในการสร้างไมโครเซอร์วิสครั้งแรกของเราเราจะใช้จุดสิ้นสุด SOA ที่มีอยู่บางส่วนและเราจะใช้สิ่งเดียวกันนี้ในแอปพลิเคชันของเรา

การกำหนดค่าระบบและการตั้งค่า

ก่อนที่จะไปต่อในขั้นตอนการสร้างให้เตรียมระบบของคุณให้สอดคล้อง คุณจะต้องมีบริการเว็บสาธารณะ คุณสามารถ google ได้อย่างง่ายดายสำหรับสิ่งนี้ หากคุณต้องการใช้บริการเว็บ SOAP คุณจะได้รับไฟล์ WSDL หนึ่งไฟล์จากนั้นคุณจะต้องใช้บริการเว็บเฉพาะ สำหรับบริการ REST คุณจะต้องใช้ลิงค์เดียวเพื่อใช้งานเดียวกัน ในตัวอย่างนี้คุณจะติดขัดบริการเว็บที่แตกต่างกันสามอย่าง "SOAP", "REST" และ "กำหนดเอง" ในแอปพลิเคชันเดียว

สถาปัตยกรรมแอปพลิเคชัน

คุณจะสร้างแอปพลิเคชัน Java โดยใช้แผนการใช้งานไมโครเซอร์วิส คุณจะสร้างบริการที่กำหนดเองและผลลัพธ์ของบริการนี้จะทำงานเป็นอินพุตสำหรับบริการอื่น ๆ

ต่อไปนี้เป็นขั้นตอนในการพัฒนาแอปพลิเคชันไมโครเซอร์วิส

Step 1: Client creation for SOAP service- มีเว็บ API ฟรีมากมายสำหรับเรียนรู้บริการบนเว็บ สำหรับจุดประสงค์ของบทช่วยสอนนี้ให้ใช้บริการ GeoIP ของ“http://www.webservicex.net/.”ไฟล์ WSDL อยู่ในลิงค์ต่อไปนี้บนเว็บไซต์“ webservicex.net ในการสร้างไคลเอนต์จากไฟล์ WSDL นี้สิ่งที่คุณต้องทำคือรันคำสั่งต่อไปนี้ในเทอร์มินัลของคุณ

wsimport http://www.webservicex.net/geoipservice.asmx?WSDL

คำสั่งนี้จะสร้างไฟล์ไคลเอนต์ที่จำเป็นทั้งหมดภายใต้โฟลเดอร์เดียวชื่อ“ SEI” ซึ่งตั้งชื่อตามอินเทอร์เฟซจุดสิ้นสุดของบริการ

Step 2: Create your custom web service- ทำตามกระบวนการเดียวกันที่กล่าวถึงในขั้นตอนก่อนหน้าในบทช่วยสอนนี้และสร้าง REST api ที่ใช้ Maven ชื่อ“ CustomRest” เมื่อเสร็จแล้วคุณจะพบคลาสชื่อ“ MyResource.java” อัปเดตชั้นเรียนนี้โดยใช้รหัสต่อไปนี้

package com.tutorialspoint.customrest;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("myresource")
public class MyResource {
   @GET
   @Produces(MediaType.TEXT_PLAIN)
   
   public String getIt() {
      return "IND|INDIA|27.7.65.215";
   }
}

เมื่อทุกอย่างเสร็จสมบูรณ์ให้ดำเนินการต่อและเรียกใช้แอปพลิเคชันนี้บนเซิร์ฟเวอร์ คุณควรได้รับผลลัพธ์ต่อไปนี้ในเบราว์เซอร์

นี่คือเว็บเซิร์ฟเวอร์ซึ่งจะส่งคืนอ็อบเจ็กต์สตริงหนึ่งตัวเมื่อถูกเรียกใช้ นี่คือบริการอินพุตที่ให้อินพุตที่แอปพลิเคชันอื่นสามารถใช้เพื่อสร้างเรกคอร์ดได้

Step 3: Configure another Rest API- ในขั้นตอนนี้ให้ใช้บริการเว็บอื่นที่services.groupkt.com สิ่งนี้จะส่งคืนออบเจ็กต์ JSON เมื่อเรียกใช้

Step 4: Create JAVA application - สร้างแอปพลิเคชัน Java ปกติโดยเลือก“ New Project” ->“ JAVA project” แล้วกด Finish ตามที่แสดงในภาพหน้าจอต่อไปนี้

Step 5: Add the SOAP client- ในขั้นตอนที่ 1 คุณได้สร้างไฟล์ไคลเอนต์สำหรับบริการเว็บ SOAP ดำเนินการต่อและเพิ่มไฟล์ไคลเอนต์เหล่านี้ในโครงการปัจจุบันของคุณ หลังจากเพิ่มไฟล์ไคลเอนต์สำเร็จแล้วไดเรกทอรีแอปพลิเคชันของคุณจะมีลักษณะดังต่อไปนี้

Step 6: Create your main app- สร้างชั้นเรียนหลักของคุณที่คุณจะใช้บริการเว็บทั้งสามนี้ คลิกขวาที่โครงการต้นทางและสร้างคลาสใหม่ชื่อ“ MicroServiceInAction.java” ภารกิจต่อไปคือการเรียกใช้บริการเว็บต่างๆจากสิ่งนี้

Step 7: Call your custom web service - สำหรับสิ่งนี้ให้ดำเนินการต่อและเพิ่มชุดรหัสต่อไปนี้เพื่อใช้การเรียกใช้บริการของคุณเอง

try {
   url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
   conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      inputToOtherService = output;
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 8: Consume SOAP Services- คุณได้สร้างไฟล์ไคลเอนต์ของคุณแล้ว แต่คุณไม่รู้ว่าควรเรียกใช้วิธีใดในแพ็คเกจทั้งหมดนั้น? สำหรับสิ่งนี้คุณต้องอ้างถึง WSDL อีกครั้งซึ่งคุณใช้ในการสร้างไฟล์ไคลเอนต์ของคุณ ไฟล์ WSDL ทุกไฟล์ควรมีแท็ก“ wsdl: service” หนึ่งแท็กค้นหาแท็กนี้ ควรเป็นจุดเริ่มต้นของบริการเว็บนั้น ต่อไปนี้เป็นจุดสิ้นสุดบริการของแอปพลิเคชันนี้

ตอนนี้คุณต้องใช้บริการนี้ในแอปพลิเคชันของคุณ ต่อไปนี้เป็นชุดโค้ด Java ที่คุณต้องใช้ในการติดตั้งบริการเว็บ SOAP ของคุณ

GeoIPService newGeoIPService = new GeoIPService();
GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);  
// Ipaddress is output of our own web service.

System.out.println("Country Name from SOAP Webserivce ---"+newGeoIP.getCountryName());

Step 9: Consume REST web service- บริการสองรายการถูกใช้ไปจนถึงปัจจุบัน ในขั้นตอนนี้บริการเว็บ REST อื่นที่มี URL ที่กำหนดเองจะถูกใช้ด้วยความช่วยเหลือของบริการเว็บที่คุณกำหนดเอง ใช้ชุดรหัสต่อไปนี้เพื่อดำเนินการดังกล่าว

String url1="http://services.groupkt.com/country/get/iso3code/";//customizing the Url
url1 = url1.concat(countryCode);

try {
   URL url = new URL(url1);
   HttpURLConnection conn = (HttpURLConnection) url.openConnection();
   conn.setRequestMethod("GET");
   conn.setRequestProperty("Accept", "application/json");
   
   if (conn.getResponseCode() != 200) {
      throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
   }
   
   BufferedReader br = new BufferedReader(new InputStreamReader(
      (conn.getInputStream())));
   while ((output = br.readLine()) != null) {
      System.out.println(output);
   }
   conn.disconnect();

} catch (MalformedURLException e) {
   e.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

Step 10: Consume all services - พิจารณาว่าบริการเว็บ“ CustomRest” ของคุณกำลังทำงานอยู่และคุณเชื่อมต่อกับอินเทอร์เน็ตหากทุกอย่างเสร็จสมบูรณ์สิ่งต่อไปนี้ควรเป็นคลาสหลักที่รวมไว้ของคุณ

package microserviceinaction;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.StringTokenizer;

import net.webservicex.GeoIP;
import net.webservicex.GeoIPService;
import net.webservicex.GeoIPServiceSoap;

public class MicroServiceInAction {
   static URL url;
   static HttpURLConnection conn;
   static String output;
   static String inputToOtherService;
   static String countryCode;
   static String ipAddress;
   static String CountryName;
   public static void main(String[] args) {
      //consuming of your own web service
      try {
         url = new URL("http://localhost:8080/CustomRest/webapi/myresource");
         conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
         
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
         
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            inputToOtherService = output;
         }
         conn.disconnect();
      
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
      
      //Fetching IP address from the String and other information
      StringTokenizer st = new StringTokenizer(inputToOtherService);
      countryCode = st.nextToken("|");
      CountryName = st.nextToken("|");
      ipAddress = st.nextToken("|");
      
      // Call to SOAP web service with output of your web service--- 
      // getting the location of our given IP address
      String Ipaddress = ipAddress;
      GeoIPService newGeoIPService = new GeoIPService();
      GeoIPServiceSoap newGeoIPServiceSoap = newGeoIPService.getGeoIPServiceSoap();
      GeoIP newGeoIP = newGeoIPServiceSoap.getGeoIP(Ipaddress);
      System.out.println("Country Name from SOAP Webservice ---"+newGeoIP.getCountryName());
      
      // Call to REST API --to get all the details of our country
      String url1 = "http://services.groupkt.com/country/get/iso3code/"; //customizing the Url
      url1 = url1.concat(countryCode);
      
      try {
         URL url = new URL(url1);
         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("GET");
         conn.setRequestProperty("Accept", "application/json");
			
         if (conn.getResponseCode() != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + conn.getResponseCode());
         }
      
         BufferedReader br = new BufferedReader(new InputStreamReader(
            (conn.getInputStream())));
         while ((output = br.readLine()) != null) {
            System.out.println(output);
         }
      
         conn.disconnect();
      } catch (MalformedURLException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

เมื่อคุณเรียกใช้ไฟล์นี้คุณจะเห็นผลลัพธ์ต่อไปนี้ในคอนโซล คุณได้พัฒนาแอปพลิเคชันไมโครเซอร์วิสแรกของคุณสำเร็จแล้ว