เข้าสู่ระบบนัดหมายรับฟังข้อมูลสรุป (or นัดหมายพูดคุยกับทีมงาน)

บทที่ 2.27

สถานการณ์จำลองการสร้าง

คู่มือรวบรวมการสร้าง 13 รูปแบบ ตั้งแต่ทักษะเดียวไปจนถึงการส่งมอบแบบแยกเครือข่าย (Air-gapped) แต่ละรูปแบบจะระบุเป้าหมาย ส่วนประกอบ ขั้นตอนและคำสั่ง เกณฑ์ตรวจสอบที่พิสูจน์ว่าทำงานได้จริง และสิ่งที่เปลี่ยนแปลงไปตามรุ่นและรูปแบบการส่งมอบ

หน้านี้แปลโดย AI จากต้นฉบับภาษาอังกฤษ หากมีส่วนใดไม่ชัดเจน โปรดอ้างอิงจากหน้าภาษาอังกฤษ อ่านหน้านี้เป็นภาษาอังกฤษ

ใช้เวลาอ่าน 25 นาที

นี่คือสูตรที่ผมหยิบมาใช้เมื่อมีใครสักคนที่ Corrán Orbital หรือที่ลูกค้าบอกว่า "เราต้องการให้ Nexus ทำ X" แต่ละสูตรตั้งใจให้สั้น เหตุผลเบื้องหลังขั้นตอนต่าง ๆ อยู่ในบทก่อนหน้านี้: บทที่ 2.20 Skills และ บทที่ 2.21 The Plugin SDK ซึ่งครอบคลุมชุดพัฒนาซอฟต์แวร์ ตามด้วย บทที่ 2.23 Domain packs และอีกสามบทถัดจากนั้นเกี่ยวกับการสร้าง ในบทนี้คุณจะได้เป้าหมาย องค์ประกอบพื้นฐานที่ควรใช้ ขั้นตอน คำสั่ง เกตที่บอกว่าได้ผลแล้ว และหมายเหตุเกี่ยวกับรุ่นและการส่งมอบ

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

สถานการณ์ องค์ประกอบหลัก เกตที่พิสูจน์ผล เอดิชัน
สกิลใหม่ของ Skills Engine แพ็กเกจ SKILL.md skill:validate โดยไม่มีข้อผิดพลาด Community และ Enterprise
สกิลในแมนิเฟสต์ที่มี host_callback แมนิเฟสต์ของปลั๊กอิน skills[] create-nexus-plugin validate และ nexus-gates Community และ Enterprise
การขยายแพ็กที่มีอยู่ pack.json พร้อม inherits การตรวจนโยบายเลนส์ที่เกตนำร่อง Enterprise และสิทธิ์การใช้งานแพ็ก
แพ็กใหม่ตั้งแต่ต้น เส้นทางมาตรฐานของ Domain pack เกตสเตจจิงและเกตนำร่อง Enterprise
ตัวเชื่อมต่อข้อมูล สกิล plugin_queue validate, nexus-gates, การปฏิเสธทราฟฟิกขาออก Community และ Enterprise
เครื่องมือ MCP (Model Context Protocol) แมนิเฟสต์ mcpTools[] validate (ไม่มีตัวรวมระดับบนสุด) Community และ Enterprise
หน้าร้านแบบ white-label แมนิเฟสต์ domains และ branding กฎสาธารณะของ scope-adherence Enterprise และส่วนเสริม Storefront
Mission pack สำหรับ Edge Mission pack กรณีทดสอบบนอุปกรณ์ ลายเซ็นสองในสาม Enterprise และส่วนเสริม Nexus Edge
การส่งมอบแบบ air-gapped บันเดิลแบบปิดผนึก nexus-airgap verify Enterprise
โมดูลเฉพาะ Enterprise @adverant/nexus-spi เกตเส้นแบ่งสิทธิ์การใช้งาน การบิลด์แต่ละรุ่น Enterprise
การ fork หรือขยาย open core ซอร์สของ Community การทดสอบ lint และการตรวจชนิดข้อมูล Community
แอปคลาวด์รุ่น Team คลัสเตอร์ของผู้เผยแพร่ รีลีสที่ลงนามแล้ว การรีวิว การให้สิทธิ์แก่ลูกค้า Team
การห่อหุ้มแอปภายในที่มีอยู่ /plugin-create migrate, validate, nexus-gates Community และ Enterprise
แผนผังการตัดสินใจที่อ่านจากบนลงล่าง รูปข้าวหลามตัดแรกถามว่า "ต้องมีโค้ดทำงานตลอดเวลาหรือไม่" "ไม่" นำไปสู่รูปข้าวหลามตัด "เป็นคำแนะนำสำหรับผู้ช่วยหรือไม่" ซึ่ง "ใช่" สิ้นสุดที่ "สกิลของ Skills Engine" และ "ไม่" สิ้นสุดที่ "Lens บนแพ็กที่มีอยู่" "ใช่" นำไปสู่รูปข้าวหลามตัด "เป็นมุมมองของอุตสาหกรรมหนึ่งต่อแพลตฟอร์มหรือไม่" ซึ่ง "ใช่" สิ้นสุดที่ "แพ็กโดเมน (พร้อมปลั๊กอินของแพ็ก)" และ "ไม่" นำไปสู่รูปข้าวหลามตัดสุดท้าย "ต้องเป็นแบบปิดและมีไลเซนส์หรือไม่" ซึ่งสิ้นสุดที่ "โมดูล Enterprise" สำหรับ "ใช่" และ "ปลั๊กอิน" สำหรับ "ไม่"
ควรเริ่มจากองค์ประกอบใด

1. ทักษะใหม่ของ Skills Engine

เป้าหมายคือชุดคำสั่งที่นำกลับมาใช้ซ้ำได้ ซึ่งผู้ช่วย เอเจนต์ เวิร์กโฟลว์ และเครื่องมือนักพัฒนาสามารถรันได้ทั้งหมด เช่น การตรวจสอบเอกสารยื่นศุลกากรเทียบกับกฎของเอกสารนั้น องค์ประกอบพื้นฐานของคุณคือแพ็กเกจ SKILL.md ในโฟลเดอร์ที่ตั้งชื่อตามสกิล skill.yaml ซึ่งไม่บังคับสำหรับทริกเกอร์และแท็ก และโฟลเดอร์ scripts/ ซึ่งไม่บังคับที่รวมมาด้วย

  1. สร้าง skills/<slug>/ และเขียน SKILL.md พร้อม frontmatter: name (แบบ kebab-case และตรงกับชื่อโฟลเดอร์) description (ไม่เกิน 500 อักขระ) allowed-tools และอาจเพิ่ม triggers capabilities และ version
  2. เขียนเนื้อหาสำหรับโมเดล: ควรใช้สกิลเมื่อใด ขั้นตอน ตัวอย่าง และสิ่งที่สกิลต้องไม่ทำเด็ดขาด
  3. เพิ่มกรณีทดสอบ โดยให้มีกรณีหนึ่งที่ฝังคำสั่งไว้ในอินพุตซึ่งสกิลต้องไม่ปฏิบัติตาม
  4. ตรวจสอบความถูกต้อง ดูแผนการอัปโหลด แล้วจึงอัปโหลด
  5. เผยแพร่ สกิลที่เพิ่มเครื่องมือสำหรับเขียนข้อมูลจะถูกระงับไว้จนกว่าบุคคลที่ระบุชื่อสองคนจะอนุมัติด้วยพาสคีย์ และผู้เสนอไม่สามารถอนุมัติการเปลี่ยนแปลงของตนเองได้
npm run skill:validate skills/check-a-customs-filing
npm run skill:upload skills/check-a-customs-filing --dry-run
npm run skill:upload skills/check-a-customs-filing

เกตคือ skill:validate ซึ่งต้องรายงานว่าไม่มีข้อผิดพลาดก่อนจึงจะเผยแพร่สิ่งใดได้ ข้อผิดพลาดที่ขัดขวางคือการไม่มีชื่อหรือคำอธิบาย และ slug หรือประเภทงานซ้ำกัน การอัปโหลดเนื้อหาที่เผยแพร่แล้วจะคืนเวอร์ชันที่มีอยู่ (CONTENT_HASH_ALREADY_PUBLISHED) ดังนั้นจึงอัปโหลดซ้ำได้อย่างปลอดภัย

Community ได้รับเครื่องมือสร้างครบทั้งหมด ไลบรารี เวอร์ชัน การย้อนกลับ การนำเข้า และการทดสอบ บน Enterprise การเผยแพร่จะผ่านขั้นตอน shadow และ canary ด้วย: เวอร์ชันที่อนุมัติแล้วจะรันแบบ shadow จากนั้นรันกับหนึ่งหน่วยภายใต้เกตที่ระบุชื่อ แล้วจึงรันกับทุกคน และจะหยุดตัวเองหากไม่ผ่านเกต สำหรับลูกค้าแบบ air-gapped สกิลจะถูกส่งไปแบบลงนามไว้ล่วงหน้าภายในบันเดิลแบบปิดผนึก (สถานการณ์ที่ 9)

2. ทักษะใน Manifest ที่ใช้ host_callback

เป้าหมายคือการประมวลผลแบบกำหนดผลแน่นอนในปลั๊กอินของคุณเองที่แพลตฟอร์มสามารถสั่งงานได้ เช่น การเปิดบันทึกเหตุการณ์ค่าเกินจากค่าที่อ่านได้ คุณจะใช้แถวหนึ่งใน skills[] ของแมนิเฟสต์ที่มีระดับ host_callback และเส้นทาง /internal ในแบ็กเอนด์ของคุณที่ป้องกันด้วย service guard ของ SDK

  1. ประกาศสกิล: id แบบ lower_snake, tier: "host_callback", classification ที่เท่ากับหรือต่ำกว่าเพดานความเชื่อถือของปลั๊กอินคุณ, inputSchema, outputSchema และ timeoutMs ระหว่าง 1 วินาทีถึง 6 ชั่วโมง
  2. กรอก hostCallback: ชื่อ Service ของคุณเอง พอร์ตของ Service นั้น พาธแบบสัมพัทธ์ เช่น /internal/skills/excursion_open ขีดจำกัดไบต์ทั้งสองค่า (maxRequestBytes และ maxResponseBytes) และ tenantHeader: "X-Organization-ID"
  3. ประกาศเส้นทางใน api.endpoints[] ด้วย auth: "service-key" หรือ auth: "internal" และป้องกันด้วย requireService หรือ serviceMiddleware ห้ามใช้ user scope guard เด็ดขาด
  4. ตรวจสอบความถูกต้อง รันเกต และปล่อยให้กระบวนการ onboarding ซิงก์สกิลไปยังรีจิสทรีผ่าน compileRegistry คุณไม่ต้องเขียน SQL ของรีจิสทรีด้วยตนเองเลย
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-test

validate ใช้กฎของการซิงก์รีจิสทรีเองก่อนที่จะซิงก์สิ่งใด โดยแต่ละกรณีจะถูกปฏิเสธพร้อมรหัสของฝั่งผู้รับ พาธที่มี scheme, // หรือแบ็กสแลชจะถูกปฏิเสธในฐานะข้าม origin การไม่มีขีดจำกัดไบต์คือ ENDPOINT_BYTE_CAP_REQUIRED ฟิลด์จากระดับอื่นคือ FIELD_NOT_FOR_TIER และค่า timeout ที่อยู่นอกช่วงคือ TIMEOUT_OUT_OF_BOUNDS จากนั้น nexus-gates จะตรวจสอบว่าเส้นทาง /internal มี service guard และประกาศเป็น internal หรือ service-key เกตคู่นี้คือหลักฐานพิสูจน์

การซิงก์เป็นแบบประกาศ ให้ส่งชุดสกิลทั้งหมดทุกครั้ง เพราะสกิลที่คุณไม่ได้ใส่จะถูกปิดใช้งาน และให้ขั้นตอนดีพลอยล้มเหลวเมื่อได้สถานะอื่นที่ไม่ใช่ 200 บน Enterprise การซิงก์ปลั๊กอินจะถูกตรวจทั้งชุด: หากสกิลใดสกิลหนึ่งผิดกฎ การซิงก์ครั้งนั้นจะไม่ถูกรับเลย (PLUGIN_SYNC_ALL_OR_NOTHING) และเวอร์ชันก่อนหน้าจะยังคงทำงานต่อ ปลั๊กอินระดับความเชื่อถือ community ไม่สามารถใช้ระดับที่เข้าถึงโมเดล คือ tool_using และ llm_only ได้ ระดับเหล่านั้นต้องมีความเชื่อถือ core หรือ verified

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

3. การขยายแพ็กที่มีอยู่แล้ว

เป้าหมายคืออุตสาหกรรมหรืออุตสาหกรรมย่อยใหม่ที่นำแพ็กที่มีอยู่มาใช้ซ้ำเป็นส่วนใหญ่ เช่น สินเชื่อและข้อพิพาทบัตรที่ต่อยอดจากโครงสร้างของแพ็ก Insurance องค์ประกอบพื้นฐานคือ pack.json ที่ระบุแพ็กแม่ใน inherits และเพิ่มเฉพาะกลุ่มเลนส์และคำศัพท์ของตนเอง

  1. เริ่มแพ็กด้วยเส้นทางมาตรฐานของ Domain pack จากนั้นตั้งค่า inherits เป็น id ของแพ็กแม่
  2. เพิ่มกลุ่ม lens ของคุณเอง โดยแต่ละกลุ่มมีตำแหน่ง วัตถุประสงค์ และการอ้างอิงคลังคำศัพท์
  3. เพิ่มคำศัพท์ของคุณลงในคลังคำศัพท์ พร้อมคำอธิบายแบบเข้าใจง่ายสำหรับแต่ละคำ ทำเครื่องหมาย exact ให้คำที่ต้องแสดงตามที่เขียนไว้
  4. ใช้เลนส์ที่ใช้ร่วมกันซ้ำแทนการสร้างเลนส์ของคุณเอง: ระเบียบที่หลายแพ็กต้องใช้ เช่น ทะเบียนเทคโนโลยีที่จ้างภายนอก ถือเป็นเลนส์ที่ใช้ร่วมกันหนึ่งเลนส์
  5. ตรวจสอบสายสิทธิ์การใช้งาน แพ็กของคุณจะสืบทอดข้อกำหนดส่วนเสริมของแพ็กแม่
  6. แสดงตัวอย่างเลนส์แต่ละเลนส์ในฐานะบุคคลบนสาขาข้อมูลสังเคราะห์
{ "id": "fintech", "name": "Banking and payments", "version": "0.1", "inherits": "insurance" }

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

Domain pack เป็นของ Enterprise และให้สิทธิ์การใช้งานแยกตามแพ็ก หน้าจอโทรศัพท์ของแพ็กยังต้องใช้ส่วนเสริม Mobile apps ด้วย แพ็กลูกไม่สามารถเปลี่ยนเชลล์ คอมโพเนนต์ หรือกฎการเขียนได้

4. การสร้างแพ็กใหม่ตั้งแต่ต้น

เป้าหมายคือมุมมองของ Nexus สำหรับอุตสาหกรรมหนึ่ง: โมเดลความรู้ เลนส์สำหรับแต่ละบทบาท หลักฐานที่กฎของอุตสาหกรรมนั้นกำหนด และปลั๊กอินที่ทำให้ข้อมูลเป็นปัจจุบันอยู่เสมอ บทที่ 2.24 การสร้าง vertical แบบกำหนดเองตั้งแต่ต้นจนจบ อธิบายการสร้างนี้อย่างครบถ้วน ส่วนนี้เป็นฉบับย่อ

  1. รันเส้นทางมาตรฐานของ Domain pack และอธิบายแพ็ก: วัตถุประสงค์ หน่วย โมเดลฐาน และกฎที่แพ็กแมปไว้
  2. สร้างโมเดลความรู้บนโมเดลฐาน และจัดประเภทพร็อพเพอร์ตีทุกตัวทันทีที่เพิ่ม
  3. อ่านแผน ยืนยันลายนิ้วมือของแผนด้วยพาสคีย์ของคุณ แล้วสร้าง
  4. กำหนดรูปแบบเลนส์ใน Lens builder โดยแต่ละเลนส์จำกัดขอบเขตจากเลนส์ฐาน
  5. เขียนปลั๊กอินและสกิล Skills Engine ที่แพ็กต้องการ
  6. สร้างข้อมูลสังเคราะห์แบบกำหนด seed พร้อมกรณีผิดปกติที่คุณให้ความสำคัญ และแสดงตัวอย่างเลนส์แต่ละเลนส์ในฐานะบุคคล
  7. เลื่อนระดับจากพื้นที่ dev ไปยังสเตจจิง ไปยังหน่วยนำร่อง แล้วจึงไปยังทุกหน่วย

หลักฐานพิสูจน์คือเกตการเลื่อนระดับ: การทดสอบทั้งหมดต้องผ่านบนสาขาข้อมูลสังเคราะห์ก่อนเข้าสเตจจิง จากนั้นต้องมีผู้รีวิวสองคนที่ไม่ใช่ผู้เขียน แล้วจึงนำร่อง 14 วันโดยมีข้อผิดพลาดต่ำกว่า 1 ใน 1,000 ไม่มีขั้นตอนใดข้ามได้ (GATE_CANNOT_BE_SKIPPED) แพ็กเป็นของ Enterprise บน Community จะไม่มีเส้นทางมาตรฐานของ Domain pack ให้ใช้

5. ตัวเชื่อมต่อข้อมูล

เป้าหมายคือให้ข้อมูลจากระบบภายนอกไหลเข้าสู่ตารางของปลั๊กอินคุณเองตามกำหนดเวลา เช่น เหตุการณ์ที่ประตูจากระบบปฏิบัติการท่าเทียบเรือ องค์ประกอบพื้นฐานคือสกิล plugin_queue worker ที่ดึงงานจากคิวของคุณ migration สำหรับตารางเป้าหมาย และที่อยู่ขาออกที่ประกาศไว้ในแมนิเฟสต์

  1. ประกาศสกิล plugin_queue โดยสะกด queueName เป็น <plugin name>.<name> ไม่อนุญาตให้มีเครื่องหมายทวิภาค และชื่อต้องอยู่ในแมนิเฟสต์ เพราะ orchestrator จะนำงานเข้าคิวนั้นโดยตรง
  2. เขียน worker ที่ดึงงานจากคิวและเรียกระบบภายนอก
  3. ประกาศที่อยู่ของระบบภายนอกเป็นที่อยู่ขาออก สิ่งใดที่ไม่ได้ระบุไว้จะถูกบล็อก
  4. จัดเก็บข้อมูลที่เข้ามาใน schema ของคุณเอง โดยมี organization_id owner_user_id และ business_unit_id ในทุกแถว
  5. อ่านข้อมูลรับรองของระบบภายนอกตามชื่อจากตัวแปรสภาพแวดล้อม และระบุตัวแปรนั้นใน scripts/ci/required-env
  6. สั่งการดึงข้อมูลผ่าน UNO ซึ่งเป็นเอนจินเวิร์กโฟลว์ ห้ามใช้ตัวจับเวลาที่เรียกเอนจินโดยตรงเด็ดขาด
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only no-credentials --only no-direct-compute --only migrations-are-scoped
node scripts/ci/required-env

validate ตรวจสอบชื่อคิวและค่า timeout เทียบกับกฎของการซิงก์รีจิสทรี เกตทั้งสามพิสูจน์ว่าไม่มีข้อมูลรับรองของโมเดล ไม่มีการประมวลผลโดยตรง และตารางมีขอบเขตที่ถูกต้อง ให้รัน nexus-gates แบบเต็มก่อนพุช เนื่องจาก --only จะจำกัดขอบเขตการรันและระบุไว้ในสรุปผล ขณะรันจริง การเรียกไปยังที่อยู่ที่แมนิเฟสต์ไม่ได้ประกาศไว้จะถูกหยุดที่ edge ด้วย EGRESS_NOT_DECLARED

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

6. เครื่องมือ MCP

เป้าหมายคือเครื่องมือที่ Claude Code เอเจนต์ และไคลเอนต์ MCP (Model Context Protocol) อื่น ๆ สามารถเรียกใช้ได้ เช่น การค้นหาประวัติการตรวจสอบของเรือ องค์ประกอบพื้นฐานคือรายการใน mcpTools[] ของแมนิเฟสต์ ที่มี name description และ inputSchema

  1. ตั้งชื่อเครื่องมือและอธิบายอย่างเข้าใจง่าย คำอธิบายคือสิ่งที่โมเดลอ่านเพื่อตัดสินใจว่าจะเรียกใช้หรือไม่
  2. เขียน inputSchema เป็น object schema เดียว อย่าใส่ oneOf allOf หรือ anyOf ไว้ที่ระดับบนสุด
  3. ให้เส้นทางที่ให้บริการเครื่องมืออยู่หลัง scope guard เช่นเดียวกับเส้นทาง /api อื่น ๆ ทั้งหมด เพื่อให้การแยกผู้เช่ามาจากโทเค็นของผู้เรียก
  4. ตรวจสอบความถูกต้องของแมนิเฟสต์
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json

หลักฐานพิสูจน์คือ validate: ตัวรวมระดับบนสุดจะถูกปฏิเสธตั้งแต่ตอนเขียน เพราะขณะรันจริงจะทำให้เครื่องมือล้มเหลวสำหรับ MCP subagent ทุกตัวที่นำเข้า และเครื่องมือจะมีอยู่โดยไม่มีใครเรียกใช้ได้

บน Enterprise เครื่องมือทุกตัวที่ IDE (integrated development environment) เรียกใช้ได้จะแสดงอยู่ในแคตตาล็อกเครื่องมือของ Workbench พร้อมระดับ ระบุว่าเปลี่ยนแปลงข้อมูลหรือไม่ ลายนิ้วมือที่ปักหมุดไว้ และบทบาทที่ใช้ได้ หากคำอธิบายเครื่องมือของคุณเปลี่ยนในรีลีสใหม่ แคตตาล็อกจะระงับเครื่องมือไว้จนกว่าจะมีคนตรวจสอบการเปลี่ยนแปลง นี่เป็นการออกแบบโดยเจตนา: คำอธิบายที่เปลี่ยนไปคือช่องทางที่เครื่องมืออาจเริ่มขอสิ่งที่ไม่ควรขอจากโมเดล การเรียกสิ่งใดก็ตามที่อยู่นอกสิทธิ์ของผู้เรียกจะถูกปฏิเสธด้วย CONNECTION_SCOPE_EXCEEDED

7. หน้าร้านแบบ White-label

เป้าหมายคือแอปที่ลูกค้าของลูกค้าคุณใช้งาน บนโดเมนของลูกค้าและในแบรนด์ของลูกค้า โดยไม่มีร่องรอยของ Adverant องค์ประกอบพื้นฐานคือบล็อก domains และ branding ของแมนิเฟสต์ ตัวช่วยการลงชื่อเข้าใช้ของ SDK และส่วนเสริม Storefront / white-label ของลูกค้า

  1. ใส่โดเมนของลูกค้าใน domains[] เป็น primary พร้อม aliases ถ้ามี
  2. กรอก branding: appName tagline primaryColor accentColor passkeyRpId ที่ตรงกับโดเมน และ oauthClientRef
  3. ให้ผู้ใช้ลงชื่อเข้าใช้ผ่านตัวช่วยการลงชื่อเข้าใช้ของ SDK และประกาศเส้นทางสาธารณะสองเส้นทางของตัวช่วยนั้นให้ตรงทุกประการ ด้วย auth: "public" และ allowAnonymous: true
  4. ส่งการเรียกจากฟรอนต์เอนด์ทุกครั้งผ่านพร็อกซีรายการอนุญาตของ backend for frontend ห้ามใส่ที่อยู่ของบริการไว้ในไคลเอนต์เด็ดขาด
  5. ปล่อยเรื่องการชำระเงินให้ผู้ดูแลระบบของลูกค้า ซึ่งจะเชื่อมต่อเกตเวย์และตั้งค่าหน้าชำระเงินที่มีแบรนด์
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only scope-adherence --only api-contract

หลักฐานพิสูจน์คือ scope-adherence ซึ่งจะยอมรับเส้นทาง /api ที่ไม่มี guard ก็ต่อเมื่อแมนิเฟสต์ประกาศเมธอดและพาธนั้นตรงทุกประการว่าเป็นสาธารณะ และพาธนั้นเป็นหนึ่งในเส้นทางการลงชื่อเข้าใช้เท่านั้น การประกาศสาธารณะอื่นใดจะล้มเหลวและระบุพาธที่อนุญาตสองพาธ จากนั้น api-contract จะเปรียบเทียบเส้นทางที่ประกาศไว้กับเส้นทางจริงทั้งสองทิศทาง definePlugin ยังปฏิเสธ frontend.basePath ที่ไม่ใช่พาธแบบสัมพัทธ์ภายใน origin เดียวกันด้วย

White-label คือส่วนเสริม Storefront / white-label ในรุ่น Enterprise ซึ่งให้สิทธิ์การใช้งานระบบชำระเงินด้วย ข้อมูลบัตรจะไม่ผ่าน Nexus เลย ผู้ดูแลระบบของลูกค้าเป็นเจ้าของแบรนด์ และแพลตฟอร์มจะระบุแบรนด์จากองค์กร ไม่ใช่จากโค้ดของคุณ

8. แพ็กภารกิจ Edge

เป้าหมายคือภารกิจใหม่หรือภารกิจที่อัปเดตสำหรับดาวเทียมหรือโดรนที่ใช้ Nexus Edge เช่น การเพิ่มอะแดปเตอร์ค้นหาเรือให้กับภารกิจเฝ้าระวังทางทะเล องค์ประกอบหลักคือแพ็กภารกิจ ซึ่งสร้างและลงนามบนภาคพื้นดิน

  1. เริ่มจากแพ็กปัจจุบันในหน้า Build a mission pack ซึ่งจะร่างเวอร์ชันใหม่จากเวอร์ชันเดิมและทำเครื่องหมายทุกการเปลี่ยนแปลง
  2. เปลี่ยนแปลงเฉพาะสิ่งที่ภารกิจต้องการ คงส่วนที่มีขนาดใหญ่ ได้แก่ โมเดลภาษาและออนโทโลยี ให้คงที่เมื่อทำได้
  3. ตรวจสอบตารางการจัดวางในทุกขั้นที่ลดระดับการทำงาน เพื่อให้แต่ละบอร์ดยังรองรับสิ่งที่บอร์ดนั้นรันอยู่
  4. รันกรณีทดสอบบนอุปกรณ์ของแพ็กบนชุดทดสอบที่ใช้บอร์ดเดียวกัน
  5. ส่งแพ็กเพื่อลงนาม: ต้องมีลายเซ็นสองในสามลายเซ็น
  6. เผยแพร่แพ็กไปยังแพลตฟอร์มเดียว แพ็กจะถูกติดตั้งในสล็อตที่ว่างอยู่ และจะเปิดใช้งานหลังจากกรณีทดสอบผ่านบนอุปกรณ์แล้วเท่านั้น
  7. ขยายการเผยแพร่ไปยังแพลตฟอร์มถัดไปหลังจากทำงานได้โดยไม่มีปัญหาครบหนึ่งสัปดาห์
แพ็กภารกิจ
แพ็กภารกิจ
คลังแพ็กภารกิจ พร้อมสิ่งที่แต่ละแพ็กบรรจุและแพลตฟอร์มที่รันแพ็กนั้นอยู่ สังเกตเวอร์ชันเก่าที่เก็บไว้บนอุปกรณ์เพื่อย้อนกลับ และจำนวนกรณีทดสอบที่ทุกแพ็กต้องผ่านบนฮาร์ดแวร์ของตน

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

Nexus Edge เป็นส่วนเสริม ซึ่งให้สิทธิ์การใช้งานต่อแพลตฟอร์มหรือต่อฝูง แพ็กยังคงใช้ได้ขณะที่แพลตฟอร์มขาดการติดต่อ ช่องสัญญาณขาขึ้นมีแบนด์วิดท์จำกัด ดังนั้นโปรดวางแผนขนาดแพ็กให้สอดคล้อง: รุ่น 1.5 ของเรามีขนาด 412 MB เทียบกับ 9.8 GB สำหรับแพ็กที่มีโมเดลภาษาใหม่

9. การส่งมอบแบบแยกเครือข่าย (Air-gapped) ให้กับลูกค้า

เป้าหมายคือการติดตั้งปลั๊กอินหรือแพ็กของคุณที่ไซต์ของลูกค้าซึ่งไม่มีเครือข่าย องค์ประกอบหลักคือบันเดิลแบบปิดผนึกจาก @adverant/nexus-sovereign คีย์ลงนามรุ่นของคุณ และช่องทางการเผยแพร่ของลูกค้าเอง

  1. สร้างปลั๊กอินและอิมเมจของปลั๊กอินให้เหมือนกับสำหรับลูกค้าที่เชื่อมต่อเครือข่ายทุกประการ โดยผ่านทุกเกต
  2. สร้างบันเดิลแบบปิดผนึกด้วยโปรไฟล์ airgap ซึ่งบรรจุอิมเมจ ไมเกรชัน สกิลที่ลงนามไว้ล่วงหน้า และ SBOM (รายการส่วนประกอบซอฟต์แวร์) พร้อมไลเซนส์
  3. ลงนามบันเดิลด้วยคีย์รุ่น Ed25519 ของคุณ
  4. ตรวจสอบบันเดิลด้วยตนเองบนเครื่องที่สะอาด
  5. ส่งบันเดิลผ่านสื่อบันทึกข้อมูล และส่งคีย์สาธารณะของคุณกับ SHA-256 ของบันเดิลผ่านช่องทางแยกต่างหาก
  6. ผู้ปฏิบัติงานของลูกค้าตรวจสอบบันเดิลด้วยคีย์ของคุณ จากนั้นนำรุ่นดังกล่าวเข้าสู่ระบบผ่านช่องทางการเผยแพร่ของตนเอง
nexus-airgap bundle
nexus-airgap verify --bundle cold-chain-0.4.0.tar.gz --trusted-key corran-release.pub.pem --profile airgap

nexus-airgap bundle สร้างบันเดิลจากการกำหนดค่าบันเดิลของคุณ หลักฐานคือ nexus-airgap verify ที่ฝั่งลูกค้า ซึ่งจะคำนวณแฮชของทุกไฟล์ใหม่ ปฏิเสธไฟล์ใดก็ตามที่ไม่อยู่ในรายการของแมนิเฟสต์ กำหนดให้ต้องมีผู้ลงนามที่เชื่อถือได้ และปฏิเสธบันเดิลที่รายการอนุญาตเครือข่ายไม่ว่างเปล่า ไฟล์ที่ถูกเปลี่ยนแปลงจะล้มเหลวด้วย BUNDLE_INTEGRITY_VIOLATION ไม่ควรมีผู้ใดปิดการตรวจสอบแบบเข้มงวดเพื่อข้ามขั้นตอนนี้

การติดตั้งแบบ Air-gapped เป็นรุ่น Enterprise ไม่มีสิ่งใดในบันเดิลที่ได้รับอนุญาตให้ดึงข้อมูลใดๆ ระหว่างการติดตั้ง และโมเดลที่ปลั๊กอินต้องการจะมาจากเซิร์ฟเวอร์โมเดลของลูกค้าเองผ่าน AI (ปัญญาประดิษฐ์) Provider Router

10. โมดูลเฉพาะรุ่น Enterprise

เป้าหมายคือความสามารถแบบปิดที่มีไลเซนส์ซึ่งเชื่อมต่อกับแกนหลักแบบเปิด เช่น บันทึกการตรวจสอบที่เก็บรักษาระยะยาวซึ่งจำหน่ายให้เฉพาะลูกค้า Enterprise เท่านั้น องค์ประกอบหลักคือแพ็กเกจอินเทอร์เฟซ @adverant/nexus-spi และไม่มีสิ่งอื่นใดจาก Community

  1. เก็บสำเนาของแพ็กเกจอินเทอร์เฟซที่สร้างแล้วซึ่งตรึงระดับไบต์ไว้ในรีโพสิทอรีของคุณเป็นแพ็กเกจ file: ภายในเครื่อง พร้อมการตรึง SHA256SUMS
  2. เขียน RouteModule (หรือ ScreenModule สำหรับหน้าจอคอนโซล) โดยอิงกับแพ็กเกจดังกล่าว พร้อมระบุกลุ่มฟีเจอร์ที่รองรับ
  3. รันทุกเส้นทางภายใต้ ctx.requireScope และตรวจสอบสิทธิ์ของโมดูลเองก่อนตอบกลับ
  4. ปฏิเสธด้วย LICENCE_LOCKED เมื่อองค์กรไม่มีสิทธิ์ และแสดงตัวอย่างแนะนำของฟีเจอร์ ไม่ใช่ข้อมูลของฟีเจอร์
  5. ควบคุมรีโพสิทอรีให้อยู่ภายในเส้นแบ่งไลเซนส์ จากนั้นสร้างโครงสร้างประกอบของแต่ละรุ่น
npm ci
npm test
npm run build

หลักฐานคือกฎเส้นแบ่งไลเซนส์: ห้ามนำเข้าจากขอบเขต Community ยกเว้นแพ็กเกจอินเทอร์เฟซ ห้ามนำเข้าแบบสัมพัทธ์ออกนอกรีโพสิทอรี และห้ามมีการพึ่งพา file:, link: หรือ workspace: ภายนอกรีโพสิทอรี จากนั้นคำสั่งทั้งสามข้างต้นต้องผ่านในโครงสร้างประกอบของแต่ละรุ่น ไม่ใช่เพียงในโครงสร้างงานของคุณ บทที่ 2.25 Building for each edition มีโครงร่างของโมดูล

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

11. การแยกสาขา (Fork) หรือการขยาย Open core

เป้าหมายคือการเปลี่ยนแปลงตัว Community เอง โดยเก็บไว้ในฟอร์กของคุณหรือส่งกลับไปยังโครงการ องค์ประกอบหลักคือซอร์สโค้ด Community ภายใต้ Apache License, Version 2.0

  1. ฟอร์กรีโพสิทอรีและแตกแบรนช์จาก main
  2. ควรเลือกใช้ปลั๊กอินหรือสกิลหากสิ่งที่คุณต้องการสามารถทำเป็นเช่นนั้นได้ การเปลี่ยนแปลงแกนหลักเป็นสิ่งที่คุณต้องดูแลเองในทุกรุ่น
  3. ทำการเปลี่ยนแปลงพร้อมการทดสอบที่จะล้มเหลวหากไม่มีการเปลี่ยนแปลงนั้น
  4. รันการตรวจสอบที่โครงการใช้ก่อนเสนอสิ่งใด
  5. เก็บไฟล์ NOTICE ไว้ และอย่าใช้ชื่อหรือเครื่องหมายการค้าของ Adverant เกินกว่าการระบุที่มาของงาน
git checkout -b feature/your-change
npm test
npm run lint
npm run typecheck

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

สิ่งนี้ใช้กับ Community เท่านั้น สิ่งใดก็ตามที่ต้องเป็นแบบปิดควรอยู่ในโมดูล Enterprise (สถานการณ์ที่ 10) แทน เพื่อให้เส้นแบ่งไลเซนส์อยู่ในตำแหน่งที่ทุกคนชี้ได้

12. แอปคลาวด์สำหรับรุ่น Team

เป้าหมายคือแอปที่ลูกค้า Team สามารถติดตั้งได้ Team ทำงานบน Adverant cloud เท่านั้น ดังนั้นแอปจะเข้าถึงลูกค้าได้ผ่านแคตตาล็อกเท่านั้น องค์ประกอบหลักคือปลั๊กอินและคลัสเตอร์ผู้เผยแพร่ ซึ่งเป็นคลัสเตอร์เสมือนของคุณเองบน Adverant cloud พร้อมข้อมูลตัวอย่าง

  1. สร้างและทดสอบบนคลัสเตอร์ผู้เผยแพร่ โดยใช้ข้อมูลตัวอย่างเท่านั้น
  2. ประกาศทุกสิ่งที่แอปต้องการในแมนิเฟสต์ และไม่มีสิ่งใดเกินกว่านั้น
  3. เผยแพร่แอปแบบลงนามแล้ว เพื่อให้ Adverant ตรวจสอบและลงรายการในแคตตาล็อก
  4. ลูกค้าแต่ละรายติดตั้งแอป โดยให้สิทธิ์แต่ละขอบเขตที่ประกาศไว้ทีละหน่วยงาน

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

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

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

13. การห่อหุ้มแอปภายในที่มีอยู่ให้เป็นปลั๊กอิน

เป้าหมายคือแอปที่บริษัทของคุณใช้งานอยู่แล้ว ซึ่งนำเข้าสู่ Nexus เพื่อรับความสามารถด้านการลงชื่อเข้าใช้ การแยกส่วน และการกำกับดูแล องค์ประกอบหลักคือสกิล /plugin-create สำหรับร่างแรก และเครื่องมือแมนิเฟสต์กับเกตของ SDK เพื่อทำให้เสร็จสมบูรณ์

  1. รัน /plugin-create กับรีโพสิทอรี สกิลจะวิเคราะห์โค้ดและเลือกกลยุทธ์การห่อหุ้ม จากนั้นสร้างแบ็กเอนด์ ไมเกรชัน ส่วนติดต่อผู้ใช้ (UI) แมนิเฟสต์ และการทดสอบ
  2. ยกระดับแมนิเฟสต์เป็นสัญญา v2 migrate จะเพิ่มประโยคกฎสามประโยค และย้าย domain ไปยัง domains[] และจะปฏิเสธการสร้างจุดเริ่มต้นขึ้นเอง
  3. แทนที่ค่าผู้เช่าใดๆ ที่ตัวห่อหุ้มอ่านจากเฮดเดอร์ด้วยตัวป้องกันขอบเขตของ SDK
  4. เพิ่ม organization_id, owner_user_id และ business_unit_id ในทุกตาราง โดยใช้คีย์หลักที่ขึ้นต้นด้วยผู้เช่า
  5. ประกาศทุกเส้นทางพร้อมสิทธิ์ของเส้นทางนั้น และติดตั้งบัญชีบันทึกการปฏิเสธ
  6. รันเกตจนกว่าจะผ่านทั้งหมด
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin migrate nexus.manifest.json --write
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-test

หลักฐานคือ nexus-gates จบการทำงานด้วยค่า 0 โดย scope-adherence, one-fence, migrations-are-scoped, crud-adherence และ api-contract ผ่านทั้งหมด คาดว่าการรันครั้งแรกจะล้มเหลวในเกือบทุกรายการ ของเรารายงานว่าทุกเส้นทางไม่มีการกำหนดขอบเขต เนื่องจากร่างเชื่อถือเฮดเดอร์ที่เบราว์เซอร์สามารถกำหนดได้ เกตไม่มีสวิตช์แก้ไขอัตโนมัติ โดยเจตนา

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