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

บทที่ 2.1

สถาปัตยกรรม

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

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

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

เมื่อ Tomás Reilly ติดตั้งครั้งแรกที่ Harrow Port Authority เสร็จสิ้น kubectl -n nexus get pods ได้แสดงสิบ Deployment และเจ็ด StatefulSet รวมถึงสาม CronJob ส่วน Job สำหรับการย้ายข้อมูลที่สร้างฐานข้อมูลนั้นได้หายไปแล้ว เนื่องจากแต่ละ Job จะลบตัวเองเมื่อทำงานสำเร็จ รายการดังกล่าวคือแพลตฟอร์มทั้งหมด โปรดทำความเข้าใจกับรายการนี้ เพราะคำถามส่วนใหญ่ในการดูแลรักษาระบบมักเริ่มต้นด้วยคำว่า "ส่วนไหนในนี้ที่เป็นเจ้าของสิ่งนั้น?"

บทนี้จะตอบคำถามนั้นสำหรับแต่ละส่วน ติดตามหนึ่งคำขอที่วิ่งผ่านส่วนต่างๆ เหล่านั้น จากนั้นจะครอบคลุมถึงกฎที่ทุกส่วนต้องปฏิบัติตาม เนื้อหาที่เหลือของส่วนที่ 2 จะต่อยอดจากภาพรวมนี้

เซอร์วิสต่างๆ และสิ่งที่แต่ละเซอร์วิสเป็นเจ้าของ

ชาร์ตนี้เป็น Helm ชาร์ตเดียวคือ nexus เวอร์ชัน 1.0.0-alpha.1 สำหรับ Kubernetes 1.33 ขึ้นไป ทุกเวิร์กโหลดจะทำงานภายใต้ ServiceAccount ของตนเองในฐานะผู้ใช้ที่ไม่ใช่ root โดยตัดความสามารถของ Linux ออกทั้งหมด การเรียกใช้บริการที่ดูแลข้อมูลประจำตัวและคีย์จะทำงานผ่าน mutual TLS (Transport Layer Security) และ API (application programming interface) สาธารณะจะใช้โปรเซสร่วมกับเราเตอร์ AI (artificial intelligence)

คอมโพเนนต์ Deployment และ Service พอร์ตของบริการ สิ่งที่รับผิดชอบ
คอนโซล nexus-alpha 3000 หน้าเว็บที่ผู้คนมองเห็น ทำหน้าที่ให้บริการ HTML (Hypertext Markup Language) ที่โฮสต์ของคอนโซล
BFF (backend for frontend) nexus-alpha-bff 8080 ข้อมูลของคอนโซลเอง เมนูที่แต่ละคนได้รับ และทะเบียนรีลีส
Auth nexus-auth 9101 (mutual TLS บนพอร์ต 8443) บุคคล องค์กร เซสชัน โทเค็น คีย์ API และพูลคีย์โมเดลขององค์กร
เกตเวย์ nexus-gateway 9092, WebSocket 8093 เราเตอร์ผู้ให้บริการ AI และจุดเชื่อมต่อ API สาธารณะสำหรับ REST (Representational State Transfer) และ MCP (Model Context Protocol)
ออร์เคสเตรเตอร์ nexus-orchestrator 8080 การจ่ายงานของ UNO: การรับงานทุกชิ้นและการจัดเข้าคิว
เวิร์กโฟลว์ nexus-workflows 8081 การประมวลผลของ UNO: เวิร์กเกอร์ที่รันงานในคิว
GraphRAG nexus-graphrag 8090, WebSocket 8091 หน่วยความจำ: กราฟความรู้และการดึงข้อมูลผ่านกราฟนั้น
Probitas nexus-probitas 9151 (HTTPS) หลักฐาน: บันทึกการกำกับดูแลและบัญชีแยกประเภทที่ปิดผนึก
เอนจินทักษะ nexus-skills-engine 8095 ไลบรารีทักษะ การค้นหาและการรันทักษะ
Keys nexus-keys 8080 (HTTPS, mutual TLS) คีย์แยกตามองค์กรใน OpenBao การเก็บรักษา และข้อมูลประจำตัวของการติดตั้ง
ปลั๊กอิน nexus-plugins 9111 รีจิสทรีของปลั๊กอินและบันทึกแค็ตตาล็อก ปิดไว้โดยค่าเริ่มต้น
การประมวลผลไฟล์ nexus-fileprocess 9109 การอ่านเอกสารและรูปภาพที่อัปโหลด ปิดไว้โดยค่าเริ่มต้น

สิบรายการแรกเป็นสิ่งจำเป็น สองรายการสุดท้ายเป็นทางเลือก ซึ่งเปิดใช้งานได้ด้วย components.plugins.enabled และ components.fileprocess.enabled ในกรณีที่การติดตั้งแบบ Enterprise หรือแพ็กโดเมนมีการใช้งาน และมีบริการทางเลือกอีกหนึ่งรายการคือ nexus-alive บนพอร์ต 8080 ซึ่งมีสวิตช์ของตัวเองคือ components.alive.enabled และถูกปิดไว้โดยค่าเริ่มต้นเช่นกัน จำนวนเรพลิกาและทรัพยากรสำหรับแต่ละรายการจะอยู่ภายใต้ components.<name>

คอนโซล คือหน้าเว็บที่เรนเดอร์จากฝั่งเซิร์ฟเวอร์โดยไม่มีฐานข้อมูล โดยจะสื่อสารกับ BFF และกับ nexus-auth ภายในคลัสเตอร์ และจะไม่ออกไปผ่านโฮสต์ auth สาธารณะแล้วค่อยกลับเข้ามาเด็ดขาด คอนโซลจะปฏิเสธการบูตหากไม่มีข้อมูลรุ่น (edition) ซึ่งชาร์ตจะส่งค่าเป็น NEXUS_EDITION จากค่า edition เพียงค่าเดียว สมาชิกทุกคนขององค์กรจะทำงานในคอนโซลตามบทบาทของตน หน้าการดูแลระบบมีไว้สำหรับเจ้าของและผู้ดูแลระบบ หากสมาชิกทั่วไปเปิดหน้าดังกล่าวจะพบกับหน้า "ไม่ใช่ผู้ดูแลระบบ"

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

nexus-auth เขียนด้วยภาษา Go และเป็นบริการเดียวที่สร้างโทเค็น โดยค่าเริ่มต้น โทเค็นการเข้าถึงจะมีอายุ 15 นาที และโทเค็นการรีเฟรชจะมีอายุ 12 ชั่วโมง (auth.accessTokenTTL, auth.refreshTokenTTL) บริการนี้จำกัดให้ผู้ที่ลงชื่อเข้าใช้แต่ละคนส่งคำขอได้ 5,000 ครั้งต่อนาทีก่อนที่จะตอบกลับด้วยรหัส 429 (auth.rateLimitPerMinute) และมีการรันตัวรับฟัง (listener) สองตัว ได้แก่ ตัวรับฟังแบบธรรมดาบนพอร์ตคอนเทนเนอร์ 8080 ที่ Ingress สาธารณะเข้าถึง และตัวรับฟังแบบ mutual TLS บนพอร์ต 8443 ที่ผู้เรียกใช้ภายในคลัสเตอร์ทุกรายต้องใช้ บริการนี้จะเชื่อถือ X-Forwarded-For เฉพาะจากฮอปใน proxy.trustedCIDRs ซึ่งเป็นรายการช่วง Classless Inter-Domain Routing (CIDR) โดยค่าเริ่มต้นคือ 10.42.0.0/16 ซึ่งเป็นเครือข่ายพ็อดของ k3s หากตัวควบคุม Ingress ของคุณทำงานอยู่ที่อื่น โปรดเปลี่ยนค่านี้ มิฉะนั้นทุกการลงชื่อเข้าใช้จะดูเหมือนว่ามาจากตัวควบคุม

เกตเวย์ มีหน้าที่สองอย่างที่ใช้โปรเซสเดียวกัน ภายในคลัสเตอร์ มันคือ AI Provider Router (แผงสวิตช์ AI ในส่วนที่ 1 และบนหน้าของคอนโซล) ซึ่งเป็นผู้ถือครองข้อมูลรับรองโมเดลขององค์กรเพียงรายเดียว (อ่านเพิ่มเติมได้ด้านล่าง) ส่วนที่ขอบเครือข่าย มันคือสิ่งที่ api.<domain> เข้าถึง ได้แก่ ไคลเอ็นต์ REST และไคลเอ็นต์ MCP ซึ่งโทเค็นจะมีค่าผู้รับ (audience) เป็น https://<hosts.api>/mcp และมาจากเซิร์ฟเวอร์การอนุญาต OAuth 2.1 ที่โฮสต์ auth (OAuth คือมาตรฐานเปิดสำหรับการอนุญาตแบบมอบหมายสิทธิ์)

ออร์เคสเตรเตอร์และเวิร์กโฟลว์ เมื่อรวมกันคือ UNO ซึ่งเป็นเอนจินเวิร์กโฟลว์ การประมวลผลทั้งหมดจะทำงานผ่านทั้งสองส่วนนี้ ออร์เคสเตรเตอร์จะรับงานที่ POST /api/v1/dispatch ตอบกลับด้วยรหัส 202 พร้อมกับ jobId, runId และ traceId จากนั้นจึงนำงานเข้าคิว ไม่มีเส้นทางการประมวลผลแบบอินไลน์ ไคลเอ็นต์จะต้องคอยตรวจสอบสถานะที่ GET /api/v1/dispatch/{jobId} หรือรับการเรียกกลับ (callback) เสมอ เวิร์กเกอร์ของเวิร์กโฟลว์จะดึงงานจากคิว ครั้งละสี่งานต่อเรพลิกาโดยค่าเริ่มต้น (workflows.concurrency) และมีเส้นทาง HTTP เพียงเส้นทางเดียวคือ GET /health

Probitas คือบริการด้านหลักฐาน ให้บริการ TLS ด้วยตัวเองจากใบรับรองที่ชาร์ตออกให้ และเก็บตารางข้อมูลไว้ในสคีมา trust โดยมีบทบาทแยกต่างหากสำหรับบัญชีแยกประเภท ฟีเจอร์การกำกับดูแลจะถูกเปิดปิดด้วย probitas.flags มีหลายฟีเจอร์ที่มาพร้อมกับโหมด shadow ซึ่งจะมีการคำนวณและบันทึกผลการตัดสินไว้ แต่จะไม่มีการบล็อกสิ่งใดจนกว่าคุณจะเปลี่ยนแฟล็ก

nexus-keys คือบริการจัดการคีย์ของแพลตฟอร์ม เขียนด้วยภาษา Go ทำหน้าที่เก็บคีย์หนึ่งชุดต่อหนึ่งองค์กรไว้ในที่เก็บคีย์ OpenBao และหมุนเวียนเปลี่ยนคีย์ทุกคืน นอกจากนี้ งานที่รันทุกคืนยังทำลายคีย์ที่ครบกำหนดระยะเวลาการถือครอง และส่งออกใบเสร็จไปยังโวลุ่มของตัวเอง การลบคีย์ขององค์กรจะทำให้ข้อมูลที่ถูกล็อกภายใต้คีย์นั้นไม่สามารถอ่านได้อีกต่อไปอย่างถาวร บริการนี้ยังสร้างข้อมูลประจำตัวของการติดตั้งในการบูตสแตรปครั้งแรกภายใต้ keys.installationName และชื่อนั้นจะเป็นชื่อถาวร โปรดเลือกอย่างระมัดระวัง เนื่องจากชาร์ตจะปฏิเสธชื่อที่ว่างเปล่า (INSTALLATION_NAME_MISSING) และปฏิเสธชื่อที่อยู่ในค่าตัวอย่างของมันเอง (INSTALLATION_NAME_EXAMPLE)

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

โฮสต์สาธารณะสามรายการ

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

Ingress ค่าโฮสต์ แบ็กเอนด์
nexus-console hosts.console nexus-alpha, พอร์ต 3000
nexus-api hosts.api nexus-gateway, พอร์ต 9092
nexus-auth hosts.auth nexus-auth, พอร์ต 9101

ตัวอย่างในหนังสือเล่มนี้ใช้ console.harrow.example, api.harrow.example และ auth.harrow.example ทั้งนี้ Ingress จะเป็นอ็อบเจกต์ networking.k8s.io/v1 ธรรมดาที่มีกฎเกณฑ์รายการละหนึ่งข้อ โดยมีพาธเป็น / ส่วน TLS ที่ขอบเครือข่ายจะเป็นไปตาม tls.mode ได้แก่ existing (Secret ที่คุณสร้างขึ้น โดยระบุชื่อใน tls.existingSecret), cert-manager (ClusterIssuer ที่คุณรัน โดยระบุชื่อใน tls.clusterIssuer) หรือ none (TLS สิ้นสุดที่ด้านหน้าคลัสเตอร์) ชาร์ตไม่ได้เพิ่มการเปลี่ยนเส้นทาง (redirect) ของตัวเอง ดังนั้นความท้าทาย HTTP ของ ACME (Automated Certificate Management Environment) จึงไปถึงตัวแก้ไขของคุณโดยไม่เปลี่ยนแปลง บทที่ 2.11 รูปแบบที่แตกต่าง: ที่เก็บข้อมูลภายนอก, TLS และ Ingress จะครอบคลุมแต่ละโหมด

ไม่มีสิ่งอื่นใดถูกเปิดเผยออกสู่ภายนอก ที่เก็บข้อมูล, OpenBao และบริการภายในทุกตัวจะรอรับการเชื่อมต่ออยู่ภายในเนมสเปซเท่านั้น

แถบแนวนอนสามแถบ แถบบนสุดคือ "Edge" มีกล่อง Ingress สามกล่องที่กำกับชื่อว่า console, api และ auth โดยแต่ละกล่องชี้ลงไปยัง Service ของตน (nexus-alpha :3000, nexus-gateway :9092, nexus-auth :9101) แถบกลางคือ "Platform services" มีกล่องสำหรับ nexus-alpha-bff ตามด้วย nexus-orchestrator ที่อยู่ข้าง nexus-workflows ซึ่งจัดกลุ่มรวมกันและกำกับชื่อว่า UNO จากนั้นคือ nexus-graphrag, nexus-probitas, nexus-skills-engine, nexus-keys และกล่องเส้นประสองกล่องสำหรับส่วนเสริมที่เลือกติดตั้งได้อย่าง nexus-plugins และ nexus-fileprocess แถบล่างสุดคือ "Data tier" มีหนึ่งกล่องต่อหนึ่งแหล่งจัดเก็บข้อมูล (PostgreSQL, Valkey, Neo4j, Qdrant, SeaweedFS) และมีกล่องที่ตีกรอบแยกต่างหากกำกับชื่อว่า "Key store" ซึ่งบรรจุ openbao และ openbao-unsealer โดยเข้าถึงได้จาก nexus-keys เท่านั้น
คอมโพเนนต์ของการติดตั้ง Nexus และที่เก็บข้อมูลที่อยู่เบื้องหลัง

หนึ่งคำขอ ตั้งแต่ต้นจนจบ

นี่คือสิ่งที่เกิดขึ้นเมื่อ Aoife Brennan หัวหน้าฝ่าย IT ของ Harrow เปิดคอนโซลและถามคำถามกับผู้ช่วยเกี่ยวกับตารางเทียบท่าของเดือนนี้

  1. เบราว์เซอร์ของเธอโหลด https://console.harrow.example จากนั้น Ingress nexus-console จะส่งต่อไปยัง nexus-alpha บนพอร์ต 3000
  2. เธอลงชื่อเข้าใช้ด้วยพาสคีย์ หน้าการลงชื่อเข้าใช้จะสื่อสารกับ nexus-auth ผ่าน auth.harrow.example และ nexus-auth จะสร้างโทเค็นการเข้าถึงให้เธอ ซึ่งระบุผู้ใช้ องค์กรของเธอ และหน่วยธุรกิจของเธอ (เมื่อเซสชันของเธอมีหน่วยธุรกิจ)
  3. เซิร์ฟเวอร์ของคอนโซลจะเรียกใช้ BFF ซึ่งจะตรวจสอบโทเค็นของเธอและถาม nexus-auth ว่าองค์กรของเธอถือครองผลิตภัณฑ์นั้นหรือไม่ และบทบาทของเธอได้รับอนุญาตหรือไม่ จากนั้นจะตอบกลับด้วยกลุ่มเมนูที่เธอสามารถมองเห็นได้
  4. คำถามของเธอจะถูกส่งจาก BFF ไปยังเส้นทางการจ่ายงานของออร์เคสเตรเตอร์ พร้อมด้วยข้อมูลองค์กรและผู้ใช้ของเธอที่ดึงมาจากโทเค็นที่ผ่านการตรวจสอบแล้ว ออร์เคสเตรเตอร์จะตอบกลับด้วยรหัส 202 และนำงานเข้าคิวใน Valkey
  5. เวิร์กเกอร์ของเวิร์กโฟลว์จะรับงานนั้นไปทำ ทักษะที่ใช้รันจะถูกค้นหาและจัดการโดยเอนจินทักษะ และการดึงข้อมูลจากเอกสารของ Harrow จะส่งต่อไปยัง GraphRAG ซึ่งจะอ่านข้อมูลจาก Neo4j, Qdrant และสคีมา PostgreSQL ของตัวเอง
  6. การเรียกใช้โมเดลจะส่งไปยัง AI Provider Router ที่ /internal/ai/chat เราเตอร์จะเลือกผู้ให้บริการและโมเดลจากพูลคีย์และนโยบายการกำหนดเส้นทางของ Harrow เอง ทำการเรียกใช้ด้วยคีย์ของ Harrow และส่งคืนผลลัพธ์ที่ได้
  7. ผลลัพธ์จะถูกบันทึกไว้ในแถวการรันของงานนั้น BFF จะอ่านข้อมูลดังกล่าวและคอนโซลจะแสดงคำตอบพร้อมกับการอ้างอิง

การส่งต่อระหว่างบริการถึงบริการจะใช้โทเค็นบริการแบบคาดการณ์ (projected service tokens) ส่วนการเชื่อมต่อที่ไปยัง nexus-auth, nexus-keys และ Probitas จะทำงานผ่าน TLS จากหน่วยงานออกใบรับรอง (CA) ของการติดตั้งเอง และการเข้าถึงข้อมูลทุกครั้งในขั้นตอนที่ 4 ถึง 6 จะถูกจำกัดขอบเขตไว้เฉพาะองค์กรของ Harrow ภายในตัวฐานข้อมูลเอง หัวข้อด้านล่างจะอธิบายทั้งสองเรื่องนี้

ลำดับการทำงานจากซ้ายไปขวา กล่องเบราว์เซอร์ส่ง "1 page" ไปยัง Ingress console จากนั้นส่งต่อไปยัง nexus-alpha ลูกศรด้านข้าง "2 sign-in" ชี้จากเบราว์เซอร์ผ่าน Ingress auth ไปยัง nexus-auth จากนั้น nexus-alpha ส่ง "3 menu" ไปยัง nexus-alpha-bff ซึ่งจะตรวจสอบกับ nexus-auth ต่อมา nexus-alpha-bff ส่ง "4 dispatch, 202" ไปยัง nexus-orchestrator ซึ่งจะเขียนข้อมูลลงในไอคอนคิวของ Valkey จากนั้น nexus-workflows จะดึง "5 job" จากคิวและเรียกใช้ nexus-skills-engine กับ nexus-graphrag (โดยมีแหล่งจัดเก็บข้อมูลสามแห่งวาดอยู่ใต้ GraphRAG) ต่อมา nexus-workflows ส่ง "6 chat" ไปยัง nexus-gateway ที่กำกับชื่อว่า "AI Provider Router: organisation key pool" ซึ่งจะส่งลูกศรเดี่ยวออกนอกขอบเขตคลัสเตอร์ไปยัง "model provider" และมีลูกศรเส้นประย้อนกลับ "7 result on run row" ชี้กลับไปยัง nexus-alpha-bff
หนึ่งคำถามถึงผู้ช่วย จากเบราว์เซอร์ไปยังผู้ให้บริการโมเดลและส่งกลับมา

ระดับชั้นข้อมูล (Data Tier)

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

ที่เก็บข้อมูล รุ่น ใบอนุญาต เหตุผลที่มีอยู่ พอร์ต โวลุ่มเริ่มต้น
PostgreSQL พร้อมด้วย PostGIS และ pgvector PostgreSQL 16, PostGIS 3, pgvector 0.8 ใบอนุญาต PostgreSQL; PostGIS ใช้ GPL-2.0-or-later ระบบบันทึกข้อมูลหลักสำหรับทุกบริการ; PostGIS สำหรับข้อมูลแผนที่; pgvector สำหรับเวกเตอร์ที่เก็บไว้คู่กับแถวข้อมูล 5432 50 GiB
Valkey 8.1 BSD-3-Clause คิวงานของ UNO และแคชอายุสั้น เช่น แคชคีย์ API ของ nexus-auth 6379 5 GiB
Neo4j Community Edition 5.26 GPL-3.0 กราฟความรู้ที่ GraphRAG สร้างและใช้สำรวจข้อมูล 7687 (Bolt) 20 GiB
Qdrant 1.15 Apache-2.0 การค้นหาเวกเตอร์สำหรับ GraphRAG และเอนจินทักษะ 6333 (HTTP), 6334 (การเรียกใช้โปรซีเยอร์ระยะไกลแบบ gRPC) 10 GiB
SeaweedFS 4.48 Apache-2.0 พื้นที่จัดเก็บอ็อบเจกต์สำหรับไฟล์ ซึ่งเข้ากันได้กับ Amazon Simple Storage Service (S3) 8333 50 GiB
OpenBao 2.6 MPL-2.0 ที่เก็บคีย์และตัวเปิดผนึก สำหรับ nexus-keys 8200 5 GiB และ 1 GiB

ตัวเลือกบางอย่างได้เข้ามาแทนที่สิ่งที่คุ้นเคยมากกว่า Valkey เข้ามาแทนที่ Redis 7.4 ซึ่งรีลีสนี้ปฏิเสธใบอนุญาตปัจจุบันของมัน MinIO ใช้ AGPL-3.0 ดังนั้นที่เก็บอ็อบเจกต์จึงเป็น SeaweedFS ส่วน GraphRAG จะเข้าถึง Neo4j Community Edition ผ่าน Bolt ซึ่งเป็นโปรโตคอลเครือข่าย และบริการต่างๆ จะเข้าถึง PostGIS ผ่านโปรโตคอล PostgreSQL ดังนั้นใบอนุญาต GPL จึงยังคงอยู่กับแต่ละตัวเหล่านั้นเท่านั้น OpenBao คือฟอร์กของ Vault โดย Linux Foundation จากช่วงก่อนที่ Vault จะเปลี่ยนใบอนุญาต

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

ที่เก็บข้อมูลแต่ละตัวในห้าตัวภายใต้ dataTier จะทำงานภายในคลัสเตอร์ (mode: in-cluster ซึ่งเป็นค่าเริ่มต้น) หรือเป็นตัวที่คุณดูแลใช้งานอยู่แล้ว (mode: external โดยใช้ external.host และ Secret ที่ระบุชื่อโดย external.existingSecret) สำหรับ PostgreSQL ภายนอก ให้ตั้งค่า sslmode เป็น verify-full หรือ verify-ca และใส่ใบรับรองของหน่วยงานออกใบรับรอง (CA) ของเซิร์ฟเวอร์ไว้ใน Secret นั้น ดูรายละเอียดได้ใน บทที่ 2.11 รูปแบบที่แตกต่าง: ที่เก็บข้อมูลภายนอก, TLS และ Ingress

# harrow-values.yaml (Helm values): Harrow's own PostgreSQL, every other store in the cluster
dataTier:
  postgres:
    mode: external
    sslmode: verify-full
    external:
      host: pg.harrow.example
      existingSecret: harrow-postgres

คู่ของ OpenBao เป็นข้อยกเว้น โดยจะทำงานภายในระบบที่ติดตั้งเสมอ เนื่องจาก Job การเก็บรักษา (custody Job) จะทำการเริ่มต้นระบบของมันที่นั่น

การยืนยันตัวตนระหว่างเซอร์วิส

Nexus ทำงานโดยไม่มีเซอร์วิสเมช (service mesh) ส่วน mutual TLS จะมาจากหน่วยงานออกใบรับรอง (CA) ภายในที่ชาร์ตสร้างขึ้นผ่าน cert-manager ซึ่งจะต้องติดตั้งไว้ก่อน (ผ่านการทดสอบกับ v1.21.3 แล้ว)

Issuer ที่ลงนามด้วยตนเองจะสร้างใบรับรอง CA หนึ่งใบคือ nexus-local-ca แบบ ECDSA (Elliptic Curve Digital Signature Algorithm) P-256 ซึ่งมีอายุใช้งานสิบปี ส่วน Issuer ตัวที่สองจะลงนามด้วย CA นั้น ทุกเวิร์กโหลดที่เรียกใช้เซิร์ฟเวอร์ TLS ภายในระบบที่ติดตั้งจะได้รับใบรับรองไคลเอ็นต์ของตัวเองที่ชื่อ <service-account>-client-tls ซึ่งมีอายุ 90 วันและจะต่ออายุ 15 วันก่อนหมดอายุ ชื่อเดียวของมันคือตัวระบุทรัพยากรแบบสากล (URI) ในรูปแบบข้อมูลประจำตัว SPIFFE:

spiffe://cluster.local/ns/<namespace>/sa/<service-account>

แต่ละเวิร์กโหลดจะพบใบรับรองสาธารณะของ CA ในชื่อ ca.crt ภายใน Secret ใบรับรองของตัวเอง ไม่มีพ็อดใดที่เมานต์คีย์ของ CA และคุณไม่จำเป็นต้องใช้ trust-manager

มีสามบริการที่ตรวจสอบผู้เรียกใช้ด้วยใบรับรอง nexus-auth จะทำบนตัวรับฟังตัวที่สองที่พอร์ต 8443 และผู้เรียกใช้ภายในคลัสเตอร์ทุกรายจะติดต่อไปยังพอร์ตนั้น nexus-keys จะทำบนตัวรับฟังเพียงตัวเดียวของมัน ส่วน Probitas จะให้บริการ TLS จากใบรับรองของตัวเองคือ nexus-probitas-tls ซึ่งมันจะอ่านใหม่เมื่อ cert-manager ต่ออายุให้ ไม่มีบริการใดที่เชื่อถือเฮดเดอร์ X-Forwarded-Client-Cert

นอกจากนี้ แต่ละเวิร์กโหลดจะได้รับโทเค็น Kubernetes ที่มีอายุหนึ่งชั่วโมงที่ /var/run/secrets/nexus จำนวนหนึ่งโทเค็นต่อหนึ่งบริการที่เรียกใช้ โดยมีบริการนั้นเป็นผู้รับ (audience) ทั้งนี้ ConfigMap nexus-service-identities จะจับคู่แต่ละ <namespace>/<service-account> เข้ากับชื่อบริการหรือชื่อปลั๊กอิน และเวิร์กโหลดที่ไม่มีอยู่ในนั้นจะไม่มีข้อมูลประจำตัวและจะถูกปฏิเสธ ออร์เคสเตรเตอร์และ Probitas จะตรวจสอบโทเค็นเหล่านี้กับ Kubernetes API จากบริการทั้งหมดที่กำลังทำงานอยู่ มีเพียงสองบริการนี้เท่านั้นที่ถือครอง system:auth-delegator หรือมีโทเค็น API เมานต์ไว้ ส่วนเวิร์กโหลดอีกตัวเดียวที่มีโทเค็นคือ Job การเก็บรักษา (custody Job) ที่ทำงานตอนติดตั้ง

นโยบายเครือข่ายจะปิดกั้นสิ่งที่ข้อมูลประจำตัวไม่ได้ปิดกั้น ชาร์ตเริ่มต้นด้วยการปฏิเสธทั้งหมดเป็นค่าเริ่มต้น (default deny) จากนั้นจึงอนุญาตทราฟฟิกระหว่างพ็อดของการติดตั้งเอง, DNS (Domain Name System), เนมสเปซของตัวควบคุม Ingress (networkPolicy.ingressNamespace โดยมีค่าเริ่มต้นเป็น kube-system) ที่ไปยัง Service สาธารณะทั้งสามตัว และเซิร์ฟเวอร์ API สำหรับผู้ตรวจสอบโทเค็นทั้งสองราย พ็อดของ OpenBao จะมีเลเบลที่แตกต่างจากส่วนที่เหลือของแพลตฟอร์ม ดังนั้นกฎการเปิดรับภายในเนมสเปซจึงไปไม่ถึงพ็อดเหล่านั้น มีเพียง nexus-keys, Job ของมัน และ Job การเก็บรักษาเท่านั้นที่ผ่านเข้าไปได้บนพอร์ต 8200 สิ่งอื่นใดที่เวิร์กโหลดต้องเข้าถึงนอกเนมสเปซ เช่น เมลรีเลย์ของคุณ จะต้องใส่ไว้ใน networkPolicy.externalEgressCIDRs ซึ่งว่างเปล่าโดยค่าเริ่มต้น

การไมเกรตและบัญชีแยกประเภทสคีมา (Schema Ledger)

การย้ายข้อมูล (migration) จะทำงานเป็นฮุกของ Helm บน post-install และ pre-upgrade ฮุกหลังการติดตั้ง (post-install hook) จะทำงานหลังจากที่สร้าง Deployment ของรีลีสแล้ว ดังนั้นในการติดตั้งครั้งแรก บริการต่างๆ จะเริ่มทำงานในขณะที่สคีมาของตนยังไม่มีอยู่ และจะเกิดอาการแครชวนลูป (crash-loop) กับฐานข้อมูลที่ไม่มีบทบาท ไม่มีรหัสผ่าน และไม่มีตาราง Nexus หลีกเลี่ยงปัญหานั้นด้วยการใช้บัญชีแยกประเภท (ledger)

ฮุกจะทำงานตามลำดับน้ำหนัก (weight) และ Helm จะรอให้แต่ละ Job เสร็จสิ้นก่อนที่น้ำหนักลำดับถัดไปจะเริ่มทำงาน:

น้ำหนัก ฮุก สิ่งที่ทำ
-30 nexus-migrations-env และสิ่งที่ต้องมีก่อน สร้าง Secret สำหรับใช้กับฮุกเท่านั้นพร้อมข้อมูลรับรองของตัวจัดการการย้ายข้อมูล และทุกสิ่งที่ Job การเก็บรักษาต้องอ่าน
-20 nexus-db-bootstrap สร้างฐานข้อมูล nexus และ nexus_alpha, บทบาทของตัวจัดการการย้ายข้อมูล, บทบาทรันไทม์ของทุกบริการ, ส่วนขยายต่างๆ และบัญชีแยกประเภท
-15 nexus-openbao-custody-init เริ่มต้นระบบที่เก็บคีย์และตัวเปิดผนึก และสร้างข้อมูลประจำตัวของการติดตั้ง
-12 nexus-graphrag-migrations สคีมาของ GraphRAG ซึ่งเป็นเจ้าของอ็อบเจกต์ที่เบสไลน์ของ nexus-auth อ้างอิงถึง
-10 nexus-auth-migrations สคีมาข้อมูลประจำตัว
-5 การย้ายข้อมูลของออร์เคสเตรเตอร์, เกตเวย์ และ Probitas สคีมาของบริการเหล่านั้น โดย Probitas จะตรวจสอบว่ามีตาราง auth อยู่ก่อนแล้ว
0 nexus-alpha-bff-migrations ฐานข้อมูลของคอนโซลเอง

แต่ละ Job การย้ายข้อมูลจะมี backoffLimit: 0 ดังนั้นหากการย้ายข้อมูลล้มเหลว การติดตั้งก็จะล้มเหลวด้วย

บัญชีแยกประเภทคือตารางหนึ่งตารางที่ชื่อ nexus_release.schema_applied โดยมีหนึ่งแถวต่อหนึ่งเชนและไดเจสต์ของอิมเมจ แต่ละฮุกจะเขียนแถวของตนหลังจากที่ตัวรันการย้ายข้อมูลทำงานเสร็จและส่งค่ากลับมาแล้วเท่านั้น ทุก Deployment ที่ใช้ PostgreSQL จะมีคอนเทนเนอร์เริ่มต้น (init container) คือ wait-for-schema ซึ่งจะอ่านตารางนั้นในฐานะบทบาทที่ได้รับอนุญาตให้อ่านเฉพาะตารางนี้เท่านั้น (nexus_ledger_reader) และรอจนกว่าทุกเชนที่ต้องพึ่งพาจะแสดงแถวข้อมูลสำหรับอิมเมจของรีลีสนี้ จากนั้นบริการจึงจะเริ่มทำงาน เวิร์กเกอร์ของเวิร์กโฟลว์จะรอเชนของออร์เคสเตรเตอร์เนื่องจากใช้ฐานข้อมูลนั้นร่วมกัน และเอนจินทักษะจะรอเฉพาะการบูตสแตรปเท่านั้น

มันจะคอยตรวจสอบทุกๆ 3 วินาที (schemaWait.intervalSeconds) และจะยกเลิกหลังจากผ่านไป 1,800 วินาที (schemaWait.timeoutSeconds) พร้อมกับข้อความหนึ่งบรรทัดที่ระบุชื่อเชนที่ยังขาดหายไป คอนเทนเนอร์ของบริการเองจะไม่มีวันเริ่มทำงานกับสคีมาที่ไม่ถูกต้องเด็ดขาด

kubectl -n nexus logs deploy/nexus-gateway -c wait-for-schema

นี่คือเหตุผลที่คุณต้องไม่รัน helm install --wait เด็ดขาด หากใช้ --wait ทาง Helm จะรอให้ Deployment พร้อมก่อนจึงจะรันฮุกหลังการติดตั้ง และ Deployment ก็จะรอฮุกเช่นกัน ทำให้ไม่มีฝั่งใดขยับเดินหน้าได้ โปรดติดตั้งโดยไม่ใช้แฟล็กดังกล่าวและค่อยรอหลังจากนั้น ดูคำสั่งที่ถูกต้องได้ใน บทที่ 2.6 การติดตั้ง Community บน Kubernetes

การแยกส่วนข้อมูลในสามแกน

ทุกการอ่าน การเขียน การเรียกใช้เครื่องมือ และการจ่ายงานทักษะใน Nexus จะถูกจำกัดขอบเขตตามแกนสามแกน

แกน ฟิลด์ สิ่งที่แยกออกจากกัน
ผู้เช่า (Tenant) organization_id แยกองค์กรหนึ่งออกจากอีกองค์กรหนึ่ง เป็นขอบเขตที่ชัดเจนและเด็ดขาด
เจ้าของ (Owner) owner_user_id แยกสิ่งของของบุคคลหนึ่งออกจากของคนอื่นๆ ทุกคน แม้ว่าจะอยู่ภายในองค์กรเดียวกันก็ตาม
หน่วย (Unit) business_unit_id หน่วยงานย่อยขององค์กร เป็นทางเลือก

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

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

หลักการดังกล่าวมีผลบังคับใช้ในสองที่พร้อมกัน

ในฐานข้อมูล ทุกบริการจะเชื่อมต่อในฐานะบทบาทรันไทม์ของตัวเอง ได้แก่ nexus_auth, auth_app และ auth_platform สำหรับบริการข้อมูลประจำตัว, nexus_probitas และ nexus_probitas_ledger สำหรับ Probitas และ nexus_gateway, nexus_graphrag, nexus_skills, orchestrator_app, workflows_app รวมถึงตัวที่เหลือสำหรับบริการอื่นๆ ไม่มีบทบาทใดที่เป็น superuser หรือมีสิทธิ์ BYPASSRLS และไม่มีบทบาทใดที่เป็นเจ้าของตารางที่ตัวเองใช้งานด้วย ดังนั้นนโยบายการรักษาความปลอดภัยระดับแถว (RLS) ทุกข้อจึงมีผลบังคับใช้กับบทบาทเหล่านั้น บทบาทเหล่านี้จะใช้กลุ่มร่วมกันคือ nexus_runtime ซึ่งให้สิทธิ์ในการเชื่อมต่อและการใช้สคีมา แต่ไม่ให้สิทธิ์ใดๆ กับตารางเลย แต่ละบริการจะได้รับสิทธิ์ในตารางของตัวเองจากการย้ายข้อมูลของตัวเอง การตั้งค่าผู้เช่าที่นโยบาย RLS อ่านนั้นสามารถตั้งค่าได้ผ่านฟังก์ชัน bind_scope ของแต่ละบริการเท่านั้น ซึ่งจะทำงานในฐานะเจ้าของฟังก์ชัน การบูตสแตรปจะเพิกถอนสิทธิ์ set_config จากคนอื่นๆ ทั้งหมด และออร์เคสเตรเตอร์กับ Probitas จะปฏิเสธการเริ่มทำงานหากบทบาทรันไทม์ของตนสามารถเรียกใช้ฟังก์ชันดังกล่าวได้โดยตรง (Probitas เรียกสิ่งนั้นว่า DB_ROLE_SETS_SCOPE_DIRECTLY) การเชื่อมต่อแบบ superuser เพียงอย่างเดียวในการติดตั้งทั้งหมดเป็นของ Job การบูตสแตรปและขั้นตอนการจัดเตรียมระบบของ BFF เท่านั้น

ในพริมิทีฟการคิวรีแบบจำกัดขอบเขตที่ใช้ร่วมกัน ดาต้ารีพอซิทอรีทุกตัวในแพลตฟอร์มและปลั๊กอินทุกตัวที่สร้างบน SDK (software development kit) จะสืบทอดการจำกัดขอบเขตหนึ่งเดียวที่สร้างเงื่อนไข SQL จากขอบเขตที่ระบุแล้ว ฟังก์ชันขอบเขตของมันจะรับข้อมูลประจำตัวที่ผ่านการตรวจสอบแล้วและไม่มีพารามิเตอร์ขององค์กร ดังนั้นผู้เรียกใช้จึงไม่สามารถส่งค่านั้นเข้ามาได้ และไม่มีเส้นทางใดที่สามารถเลือกไม่ใช้งานได้

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

เส้นทางของ AI

ผู้เรียกใช้สามารถแสดงความต้องการได้ แต่ AI Provider Router เป็นเจ้าของข้อมูลรับรองและเป็นผู้ตัดสินใจขั้นสุดท้าย

การเรียกใช้โมเดลทุกครั้งใน Nexus จะผ่านเส้นทาง /internal/ai/* ของเราเตอร์ และเราเตอร์จะอนุญาตเฉพาะผู้เรียกใช้ที่ระบุชื่อไว้เท่านั้น ชาร์ตจะตั้งค่ารายการสามรายการบนเกตเวย์:

เส้นทาง ผู้ที่สามารถเรียกใช้ได้
การแชทและการสตรีมแชท nexus-orchestrator, nexus-workflows, nexus-skills-engine
การทำ Embedding และการจัดอันดับใหม่ (rerank) nexus-graphrag, nexus-skills-engine, nexus-workflows
อย่างอื่นทั้งหมด รวมถึงการประมวลผลเครื่องมือ nexus-orchestrator, nexus-workflows

การเรียกใช้ที่ไม่มีข้อมูลประจำตัวของผู้เรียกใช้จะถูกปฏิเสธด้วยรหัส 403 MISSING_CALLER_IDENTITY และผู้เรียกใช้ที่ไม่อยู่ในรายการจะถูกปฏิเสธด้วยรหัส 403 UNAUTHORIZED_CALLER ปลั๊กอินจะไม่อยู่ในรายการใดเลย และนั่นเป็นความตั้งใจ เนื่องจากปลั๊กอินจะเรียกใช้โมเดลในนามของตัวเองผ่านการจ่ายงานของ UNO

สิ่งที่ผู้เรียกใช้สามารถส่งมาได้คือความต้องการ ได้แก่ ผู้ให้บริการและโมเดลที่ต้องการ รวมถึงโปรไฟล์ความสามารถ เช่น ความยาวบริบทขั้นต่ำหรือการใช้เครื่องมือ เราเตอร์จะทำตามความต้องการก็ต่อเมื่อองค์กรได้เปิดใช้งานและใส่ข้อมูลรับรองของผู้ให้บริการรายนั้นไว้แล้ว มิฉะนั้นเราเตอร์จะทำการทดแทน โดยเริ่มจากภายในผู้ให้บริการรายเดียวกันก่อน จากนั้นจึงข้ามไปยังผู้ให้บริการรายอื่นขององค์กร โปรไฟล์ความสามารถจะทำหน้าที่คัดกรองเท่านั้น และข้อกำหนดเรื่องถิ่นที่อยู่ของข้อมูล (data-residency) ในโปรไฟล์นั้นถือเป็นข้อบังคับที่เข้มงวด เมื่อไม่มีสิ่งใดตรงตามเกณฑ์ จะไม่มีการใช้โมเดลสำรอง ผู้เรียกใช้จะได้รับรหัส 422 MODEL_CAPABILITY_UNAVAILABLE หรือ 422 NO_PROVIDER_FOR_ROLE พร้อมด้วยข้อความแนะนำการแก้ไขที่คอนโซลจะแสดงให้ผู้ดูแลระบบเห็น

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

ค่าใน chart สองตัวเป็นตัวกำหนดรูปแบบของเราเตอร์ โดย ai.localProvider.baseUrl จะระบุชื่อเซิร์ฟเวอร์โมเดลที่รองรับ OpenAI ซึ่งคุณรันอยู่ และจะถูกส่งต่อเหมือนกับผู้ให้บริการรายอื่น ส่วน ai.installationHosts จะแสดงรายการเซิร์ฟเวอร์โมเดลของคุณที่ใช้ชื่อส่วนตัว ซึ่งเราเตอร์จะนับว่าอยู่ภายในระบบที่ติดตั้ง ทั้งนี้ GraphRAG ก็สร้าง embedding ผ่านเราเตอร์นี้เช่นกัน ในนามขององค์กรที่เป็นเจ้าของเนื้อหานั้น โมเดลสร้าง embedding เริ่มต้นจะทำงานในคลัสเตอร์โดยไม่ใช้การ์ดจอ ส่วนการใช้บริการ embedding แบบโฮสต์นั้นเป็นทางเลือกของแต่ละองค์กร

ไม่มีการส่งข้อมูลการใช้งานกลับ (No Telemetry)

ไม่มีข้อมูลใดถูกส่งออกจากระบบที่ติดตั้งเว้นแต่คุณจะเป็นผู้ส่งเอง ค่า telemetry.enabled ของ chart สามารถเป็น false ได้เท่านั้น โดยสคีมาจะปฏิเสธค่าอื่นทั้งหมด การรายงานของระดับข้อมูลเองก็ถูกปิดไว้เช่นกัน ทั้งรายงานการใช้งานของ Neo4j และระบบส่งข้อมูลการใช้งานของ Qdrant ต่างก็ถูกปิดไว้ใน chart

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

กฎเดียวกันนี้ได้เปลี่ยนค่าเริ่มต้นอย่างหนึ่งที่คุณจะสังเกตเห็นได้ ระบบ CAPTCHA สำหรับการสมัครใช้งานของ nexus-auth ต้องใช้บริการอินเทอร์เน็ต ดังนั้นในระบบที่ติดตั้งจึงถูกปิดไว้ และการสมัครใช้งานจากบุคคลภายนอกจะต้องรอการอนุมัติจากผู้ดูแลระบบ (403 SIGNUP_REQUIRES_APPROVAL) ระบบคัดกรองที่บล็อกการสมัครใช้งานจากเครือข่ายโฮสติ้งก็ถูกปิดไว้เช่นกัน เนื่องจากต้องใช้ฐานข้อมูลที่มีใบอนุญาตซึ่ง Nexus ไม่ได้จัดส่งมาพร้อมกัน คุณจึงสูญเสียการคัดกรองส่วนนั้นไป

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