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

บทที่ 2.6

การติดตั้งรุ่น Community บน Kubernetes

การติดตั้งรุ่น Community ตามลำดับขั้นตอนด้วย Helm ตั้งแต่ cert-manager ไปจนถึงทุกเวิร์กโหลดพร้อมใช้งาน พร้อมคำอธิบายไฟล์ values ทีละคีย์ เหตุผลที่ไม่มี --wait ลำดับที่ฮุกของชาร์ตทำงาน และแนวทางการติดตั้งด้วย nexusctl เป็นทางเลือก

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

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

ตัวการติดตั้งเองนั้นเป็นเพียง helm install คำสั่งเดียว ทุกอย่างที่รายล้อมอยู่มีไว้เพื่อให้คำสั่งเดียวนั้นทำงานได้สำเร็จตั้งแต่ครั้งแรก ได้แก่ cert-manager ก่อนการติดตั้ง, ไฟล์ values ที่คุณอ่านทีละบรรทัดแล้ว และการรอคอยหลังจากนั้นซึ่งรู้ว่าต้องรออะไร ที่ Harrow Port Authority เราติดตั้งรุ่น Community ก่อนสำหรับโครงการนำร่องหกสัปดาห์ บนคลัสเตอร์ k3s แบบสามโหนดจากเวิร์กชีตการวางแผนของเรา รีลีสเริ่มทำงานได้ในเวลาประมาณยี่สิบนาที และไม่มีใครสามารถลงชื่อเข้าใช้ได้จนกว่าเราจะอ้างสิทธิ์ ซึ่งก็เป็นไปตามที่ควรจะเป็น

บทนี้ตั้งสมมติฐานว่าคุณได้ทำสามสิ่งนี้ไปแล้ว ได้แก่ ทำตามเวิร์กชีตการวางแผนจนครบ (บทที่ 2.3, การวางแผนการติดตั้ง), ดึงข้อมูลและตรวจสอบรีลีสแล้ว (บทที่ 2.4, การรับและตรวจสอบรีลีส) และรันการตรวจสอบก่อนการติดตั้ง (preflight) แล้ว (บทที่ 2.5, การตรวจสอบก่อนการติดตั้งด้วย nexusctl) หากยังมีสิ่งใดค้างอยู่ ให้ย้อนกลับไปทำก่อน การติดตั้งจะปฏิเสธข้อผิดพลาดส่วนใหญ่โดยระบุชื่อข้อผิดพลาดนั้น แต่มีบางอย่าง เช่น ผู้ดูแลกุญแจ (custodian) ที่คุณทำกุญแจของเขาหายไปแล้ว ซึ่งระบบไม่สามารถมองเห็นได้

ขั้นตอนที่ 1: ยืนยันเครื่องมือและบริบท (Context) ของคุณ

  1. ตรวจสอบว่า Helm เป็นเวอร์ชัน 4

    helm version

    การติดตั้งต้องอาศัย Helm 4 ซึ่งจะรอให้ Job ที่เป็นฮุก (hook) ของชาร์ตทำงานเสร็จโดยค่าเริ่มต้น เราใช้ v4.3.1

  2. ชี้ kubectl ไปที่คลัสเตอร์ในเวิร์กชีตของคุณ และยืนยัน

    kubectl config use-context harrow-prod
    kubectl get nodes

    ทุกโหนดควรแสดงสถานะเป็น Ready การตรวจสอบก่อนการติดตั้งได้เช็กสิ่งนี้ไปแล้ว แต่โหนดอาจหลุดออกไปในระหว่างการตรวจสอบก่อนการติดตั้งกับการติดตั้งจริง และการดูตรงนี้จะรวดเร็วกว่า

ขั้นตอนที่ 2: ติดตั้ง cert-manager ก่อน

ชาร์ตจะสร้างหน่วยงานออกใบรับรอง (CA) ท้องถิ่นของตัวเองด้วย cert-manager และทุกเซอร์วิสจะสื่อสารกันด้วยใบรับรองที่หน่วยงานนี้ออกให้ ซึ่งได้แก่ Issuer แบบลงนามด้วยตนเอง (self-signed), ใบรับรอง CA ท้องถิ่นอายุสิบปี และใบรับรองอายุสั้นสำหรับเซอร์วิสต่างๆ ดังนั้น cert-manager จึงต้องทำงานอยู่ก่อนที่จะติดตั้ง Nexus รีลีสนี้ต้องการ v1.21.3 และไม่จำเป็นต้องใช้ trust-manager

  1. ติดตั้ง cert-manager จากชาร์ตของตัวเอง พร้อมด้วยทรัพยากรแบบกำหนดเอง (custom resources):

    helm install cert-manager <cert-manager-chart> -n cert-manager --create-namespace \
      --set crds.enabled=true --wait --timeout 10m

    <cert-manager-chart> คือชาร์ตของ cert-manager v1.21.3 จากรีลีสของโปรเจกต์ cert-manager เอง การรอคอยสามารถทำได้ในขั้นตอนนี้เลย เพราะเป็นการติดตั้งของ cert-manager เอง ซึ่งไม่มีฮุกที่ต้องพึ่งพาสิ่งอื่น

  2. รอให้เว็บฮุก (webhook) ของมันพร้อมทำงาน ซึ่งคำขอใบรับรองทุกรายการจะต้องผ่านเว็บฮุกนี้:

    kubectl -n cert-manager rollout status deploy/cert-manager-webhook --timeout=300s
    deployment "cert-manager-webhook" successfully rolled out

ขั้นตอนที่ 3: สร้างเนมสเปซและ TLS Secret

เมื่อใช้ tls.mode: existing ชาร์ตจะคาดหวังให้มีใบรับรองของคุณในรูปแบบ Kubernetes Secret อยู่ในเนมสเปซก่อนการติดตั้ง Transport Layer Security (TLS) สำหรับทั้งสามที่อยู่จะมาจาก Secret เดียวนี้ ดังนั้นใบรับรองในนั้นจึงต้องระบุชื่อโฮสต์ทั้งสามแห่ง

kubectl create namespace nexus
kubectl -n nexus create secret tls harrow-public-tls \
  --cert=harrow-public.crt --key=harrow-public.key

harrow-public.crt คือใบรับรองพร้อมห่วงโซ่ใบรับรอง (chain) และ harrow-public.key คือกุญแจส่วนตัว หากคุณเลือก tls.mode: cert-manager หรือ none ใน บทที่ 2.3, การวางแผนการติดตั้ง ให้ข้ามเรื่อง Secret นี้ไป โดยคุณยังสามารถสร้างเนมสเปซได้ในตอนนี้ หรือจะปล่อยให้ Helm สร้างให้ด้วย --create-namespace ในขั้นตอนที่ 6 ก็ได้

ขั้นตอนที่ 4: เขียนไฟล์ values

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

# harrow-values.yaml (Helm values, Community)
global:
  imageRegistry: registry.adverant.ai
  domain: harrow.example
hosts:
  console: console.harrow.example
  api: api.harrow.example
  auth: auth.harrow.example
edition: community
enterprise:
  enabled: false
tls:
  mode: existing
  existingSecret: harrow-public-tls
ingress:
  className: traefik
storage:
  className: local-path
networkPolicy:
  ingressNamespace: kube-system
  externalEgressCIDRs: ["10.20.9.25/32"]
keys:
  installationName: harrow-port-authority
  custody:
    recipients:
      - "<recipient-aoife>"
      - "<recipient-tomas>"
      - "<recipient-safe-laptop>"

แต่ละ <recipient-...> คือข้อมูลผู้รับ age สาธารณะของผู้ดูแลกุญแจหนึ่งคน ซึ่งเป็นบรรทัด age1... หรือ age1se1... ที่พวกเขาส่งให้คุณ นี่คือทุกคีย์ที่เราตั้งค่าและเหตุผล

global.imageRegistry คือเรจิสทรีที่โหนดของคุณดึงข้อมูลมา ชาร์ตไม่มีค่าเริ่มต้นสำหรับส่วนนี้ แต่จะสร้างทุกอิมเมจในรูปแบบ <this>/nexus/<service>@<digest> สำหรับการติดตั้งที่เชื่อมต่ออินเทอร์เน็ต ค่านี้คือ registry.adverant.ai หากคุณคัดลอกอิมเมจไปยังเรจิสทรีของคุณเอง ค่านี้ก็คือโฮสต์นั้น

global.domain คือโดเมนที่ทั้งสามที่อยู่นี้อยู่ภายใต้

hosts.console, hosts.api และ hosts.auth คือข้อมูลประจำตัวของการติดตั้ง ซึ่งเป็นชื่อทั้งสามที่ผู้คนและโปรแกรมใช้ แต่ละชื่อจะต้องสามารถแปลงค่าในระบบชื่อโดเมน (DNS) ได้อยู่แล้ว ซึ่งการตรวจสอบก่อนการติดตั้งได้เช็กไปแล้ว

edition และ enterprise.enabled ต้องสอดคล้องกัน: community คู่กับ false หรือ enterprise คู่กับ true ชาร์ตจะปฏิเสธค่าอื่นนอกเหนือจากนี้ และจะปฏิเสธรุ่น (edition) ที่ไฟล์ล็อกของอิมเมจไม่ได้ถูกสร้างมาเพื่อรองรับ

tls.mode และ tls.existingSecret ใช้เลือกวิธีที่เอดจ์สาธารณะจะได้รับใบรับรอง หากใช้ cert-manager คุณจะต้องตั้งค่า tls.clusterIssuer แทน และหากใช้ none ก็ไม่ต้องตั้งค่าทั้งสองอย่าง

ingress.className ใช้ระบุชื่อคลาสของอินเกรส (ingress class) ให้เว้นว่างไว้หากต้องการใช้คลาสเริ่มต้นของคลัสเตอร์

storage.className ใช้ระบุชื่อคลาสของสตอเรจ (storage class) สำหรับทุกโวลุมข้อมูล ให้เว้นว่างไว้หากต้องการใช้ค่าเริ่มต้น

networkPolicy.ingressNamespace คือเนมสเปซที่อินเกรสคอนโทรลเลอร์ของคุณทำงานอยู่ ค่าเริ่มต้นคือ kube-system ซึ่งถูกต้องสำหรับ Traefik ของ k3s แต่เราก็ยังตั้งค่านี้ไว้เพื่อให้เห็นชัดเจนในไฟล์

networkPolicy.externalEgressCIDRs แสดงรายการช่วงที่อยู่ในรูปแบบ Classless Inter-Domain Routing (CIDR) ที่อยู่นอกเนมสเปซซึ่งเซอร์วิสต่างๆ สามารถเข้าถึงได้ นอกเหนือไปจาก DNS และเซิร์ฟเวอร์ส่วนต่อประสานการเขียนโปรแกรมแอปพลิเคชัน (API) ของ Kubernetes ของเรามีเพียงที่อยู่เดียวของเมลรีเลย์ หากรายการนี้ว่างเปล่า จะไม่สามารถเข้าถึงสิ่งใดนอกเนมสเปซได้เลย

keys.installationName คือชื่อถาวรที่ที่เก็บกุญแจ (key store) ใช้สร้างข้อมูลประจำตัวของการติดตั้งขึ้นมาภายใต้ชื่อนั้น

keys.custody.recipients แสดงรายการผู้รับ age สาธารณะของผู้ดูแลกุญแจ Job ของระบบดูแลกุญแจ (custody Job) จะเข้ารหัสส่วนแบ่งการปลดซีล (unseal share) และกุญแจกู้คืนทุกรายการให้แก่ผู้รับแต่ละคน

คีย์ที่คุณอาจต้องใช้ และคีย์ที่ไม่ต้องแตะต้อง

คีย์ เมื่อใดที่ต้องตั้งค่า
networkPolicy.apiServerCIDRs เมื่อชาร์ตไม่สามารถอ่านที่อยู่ของเซิร์ฟเวอร์ API จาก Endpoints ของ kubernetes ได้ ให้ระบุเป็นช่วง /32
proxy.trustedCIDRs เมื่อพอดของอินเกรสคอนโทรลเลอร์ของคุณไม่ได้อยู่บน 10.42.0.0/16 ของ k3s
ai.localProvider.baseUrl เมื่อองค์กรรันเซิร์ฟเวอร์โมเดลปัญญาประดิษฐ์ (AI) ที่เข้ากันได้กับ OpenAI ของตัวเอง (บทที่ 2.14, ผู้ให้บริการและโมเดล AI)
ai.installationHosts เมื่อเซิร์ฟเวอร์โมเดลนั้นอยู่บนชื่อส่วนตัวภายในระบบที่ติดตั้ง
dataTier.<store>.size เมื่อที่เก็บข้อมูลต้องการพื้นที่มากกว่าโวลุมเริ่มต้น
dataTier.<store>.mode external สำหรับที่เก็บข้อมูลที่คุณรันด้วยตัวเอง (บทที่ 2.11, รูปแบบอื่นๆ: ที่เก็บข้อมูลภายนอก, TLS และอินเกรส)
components.<service>.replicas, components.<service>.resources เมื่อคุณต้องการขยายขนาดของเซอร์วิส
auth.rateLimitPerMinute เมื่อระบบอัตโนมัติที่ทำงานหนักต้องการมากกว่า 5,000 คำขอต่อนาทีต่อคน
schemaWait.timeoutSeconds เมื่อดิสก์ที่ช้าทำให้การไมเกรตครั้งแรกใช้เวลานานกว่า 30 นาที

ปล่อย istio.enabled ไว้ที่ false เพราะ Nexus ไม่จำเป็นต้องใช้เซอร์วิสเมช (service mesh) ปล่อย telemetry.enabled ไว้ที่ false เพราะสคีมาไม่ยอมรับค่าอื่น ปล่อย orchestrator.platformServiceUserId และ probitas.flags ไว้ตามที่ชาร์ตตั้งค่ามา

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

ขั้นตอนที่ 5: รันการตรวจสอบความพร้อม (Preflight) กับไฟล์ขั้นสุดท้าย

nexusctl preflight --context harrow-prod --values harrow-values.yaml

การรันจะต้องจบลงด้วย 0 failed บทที่ 2.5, การตรวจสอบก่อนการติดตั้งด้วย nexusctl มีคำอธิบายของทุกแถว หากคุณเปลี่ยนแปลงสิ่งใดก็ตามนับตั้งแต่การรันครั้งล่าสุด แม้จะเป็นเพียงขนาด ก็ให้รันใหม่อีกครั้ง

ขั้นตอนที่ 6: ติดตั้ง โดยไม่ใช้ --wait

helm install nexus oci://registry.adverant.ai/nexus/charts/nexus --version 1.0.0-alpha.1 \
  --namespace nexus -f harrow-values.yaml --timeout 45m

หากคุณไม่ได้สร้างเนมสเปซในขั้นตอนที่ 3 ให้เพิ่ม --create-namespace หากคุณกำลังติดตั้งจากไฟล์ชาร์ตที่คุณดาวน์โหลดและตรวจสอบแล้ว ให้ใส่พาธของไฟล์นั้นแทนที่การอ้างอิง oci://

อย่าเพิ่ม --wait การบูตสแตรปฐานข้อมูลของชาร์ตจะทำงานเป็นฮุกหลังการติดตั้ง (post-install hook) หลังจากที่ทรัพยากรของรีลีสเองถูกสร้างขึ้นแล้ว และฮุกนั้นเองที่เป็นตัวกำหนดบทบาทและรหัสผ่านฐานข้อมูลให้แก่แต่ละเซอร์วิส การใช้ --wait จะชะลอการติดตั้งไว้จนกว่าทุก Deployment จะมีสถานะเป็น Available และไม่มี Deployment ใดที่จะเปลี่ยนเป็นสถานะ Available ได้ก่อนที่ฮุกที่มันกำลังรออยู่จะทำงานเสร็จ เซอร์วิสต่างๆ จะค้างอยู่และถูกปฏิเสธการเข้าสู่ระบบฐานข้อมูล และ Helm ก็จะรอเซอร์วิสเหล่านั้นจนกว่าจะหมดเวลา หากไม่ใช้ --wait Helm 4 ก็ยังคงรอทุก Job ที่เป็นฮุกตามลำดับอยู่ดี และนั่นคือการรอที่คุณต้องการ

เมื่อฮุกสุดท้ายทำงานเสร็จสิ้น Helm จะพิมพ์ข้อมูลสรุปออกมา:

NAME: nexus
NAMESPACE: nexus
STATUS: deployed
REVISION: 1

STATUS: deployed หมายความว่าทุกฮุกทำงานสำเร็จแล้ว แต่ยังไม่ได้หมายความว่าทุกเซอร์วิสพร้อมให้บริการ ซึ่งในขั้นตอนที่ 7 จะเป็นการรอสิ่งนั้น

อะไรทำงานบ้าง และทำงานตามลำดับอย่างไร

Helm จะรันฮุกตามค่าน้ำหนัก (weight) โดยเริ่มจากค่าน้อยที่สุดก่อน และรอให้แต่ละฮุกเสร็จสิ้นก่อนที่จะเริ่มฮุกถัดไป ทุก Job ของการไมเกรตจะมี backoffLimit: 0: การไมเกรตที่ล้มเหลวจะทำให้การติดตั้งล้มเหลวและจะไม่มีการลองใหม่โดยที่คุณไม่รู้ตัว Job ที่สำเร็จจะถูกลบออก ส่วน Job ที่ล้มเหลวจะยังคงอยู่พร้อมกับล็อกของมันเพื่อให้คุณอ่าน

น้ำหนัก ฮุก สิ่งที่ทำ
-30 สิ่งที่ต้องมีก่อน บัญชีของฮุก nexus-migrations, Secret สำหรับฮุกเท่านั้น nexus-migrations-env ที่มีข้อมูลรับรองฐานข้อมูลที่ถูกสร้างขึ้น และบัญชี, บทบาท, การกำหนดค่า และใบรับรองของ Job ระบบดูแลกุญแจ
-20 nexus-db-bootstrap สร้างฐานข้อมูลและบทบาทต่างๆ โดยไม่มีบทบาทใดเป็น superuser และไม่มีบทบาทใดที่สามารถข้ามการรักษาความปลอดภัยระดับแถว (RLS) ได้, เพิ่มส่วนขยายต่างๆ ซึ่งรวมถึง PostGIS และ pgvector, และสร้างบัญชีแยกประเภทของรีลีส (release ledger)
-15 nexus-openbao-custody-init เริ่มต้นการทำงานของที่เก็บกุญแจและตัวปลดซีล, เข้ารหัสส่วนแบ่งและกุญแจกู้คืนให้แก่ผู้ดูแลกุญแจของคุณ, เพิกถอนรูทโทเค็นทั้งสองรายการ และสร้างข้อมูลประจำตัวของการติดตั้งภายใต้ keys.installationName
-12 nexus-graphrag-migrations วางสคีมาของเซอร์วิสกราฟเป็นอันดับแรก เนื่องจากสคีมาของเซอร์วิสการลงชื่อเข้าใช้มีการอ้างอิงถึงออบเจกต์ที่เซอร์วิสกราฟเป็นเจ้าของ
-10 nexus-auth-migrations วางสคีมาของเซอร์วิสการลงชื่อเข้าใช้และบทบาทรันไทม์ทั้งสองของมัน
-5 nexus-orchestrator-migrations, nexus-gateway-migrations, nexus-probitas-migrations สคีมาของแต่ละเซอร์วิสเอง โดย probitas จะทำงานหลังจาก auth เนื่องจากจะต้องตรวจสอบตารางของ auth ก่อน
0 nexus-alpha-bff-migrations จัดเตรียมฐานข้อมูลของแบ็กเอนด์สำหรับฟรอนต์เอนด์ (BFF) และบทบาทต่างๆ จากนั้นจึงทำการไมเกรต

ฮุกการไมเกรตแต่ละตัวจะจบการทำงานด้วยการเขียนข้อมูลหนึ่งแถวลงในบัญชีแยกประเภทของรีลีส nexus_release.schema_applied: ชื่อของห่วงโซ่ (chain) และค่าไดเจสต์ของอิมเมจที่รันฮุกนั้น ฮุกจะเขียนแถวดังกล่าวก็ต่อเมื่อตัวรันการไมเกรตทำงานเสร็จสิ้นโดยไม่มีข้อผิดพลาดเท่านั้น Job ของการบูตสแตรปจะพิมพ์ db-bootstrap: done ส่วนฮุกการไมเกรต SQL จะพิมพ์ schema-ledger: recorded <chain> for this release's image เป็นบรรทัดสุดท้าย ฮุกการไมเกรตของคอนโซลเอง ซึ่งก็คือ nexus-alpha-bff-migrations จะบันทึกแถวของตัวเองด้วยวิธีเดียวกัน แล้วจึงพิมพ์ bff-migrate: done

ไทม์ไลน์แนวนอนที่ไล่จากซ้ายไปขวา มีป้ายกำกับว่า "helm install" ในแถบด้านบนมีกล่องฮุกเจ็ดกล่องเรียงตามลำดับ ได้แก่ "-30 prerequisites", "-20 db-bootstrap", "-15 custody init", "-12 graphrag migrations", "-10 auth migrations", "-5 orchestrator, gateway, probitas migrations", "0 BFF migrations" กล่องการไมเกรตแต่ละกล่องมีลูกศรเล็กๆ ชี้ลงไปยังรูปทรงกระบอกในแถบตรงกลางที่มีป้ายกำกับว่า "release ledger: nexus_release.schema_applied" ในแถบด้านล่างมีแถบยาวที่เริ่มต้นจากทางซ้าย มีป้ายกำกับว่า "Deployments start, wait-for-schema holds each pod" โดยมีลูกศรแนวตั้งสั้นๆ ชี้ขึ้นจากแถบนี้ไปยังบัญชีแยกประเภท และแถบของแต่ละ Deployment จะเปลี่ยนเป็นสีทึบเมื่อแถวข้อมูลของตัวเองในบัญชีแยกประเภทปรากฏขึ้น
ลำดับของการติดตั้งใหม่ทั้งหมด โดยแสดงฮุกและเวิร์กโหลดเคียงคู่กัน

วิธีที่เซอร์วิสต่างๆ รอสคีมาของตนเอง

Deployment ต่างๆ จะเริ่มทำงานทันทีที่ Helm สร้างขึ้นมา ในขณะที่ฮุกยังคงทำงานอยู่ เซอร์วิสที่เริ่มทำงานกับฐานข้อมูลที่ยังไม่มีบทบาท ไม่มีรหัสผ่าน หรือไม่มีสคีมา จะเกิดอาการแครชและรีสตาร์ทไปเรื่อยๆ จนกว่าฮุกจะทำงานเสร็จ ดังนั้น ทุก Deployment ที่ใช้ฐานข้อมูลจึงมีคอนเทนเนอร์เริ่มต้น (init container) ชื่อ wait-for-schema ที่คอยชะลอพอดไว้แทน

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

Deployment รอ
nexus-auth nexus-auth-migrations
nexus-orchestrator, nexus-workflows nexus-orchestrator-migrations
nexus-gateway nexus-gateway-migrations
nexus-graphrag nexus-graphrag-migrations
nexus-probitas nexus-probitas-migrations
nexus-skills-engine nexus-db-bootstrap
nexus-alpha-bff nexus-alpha-bff-migrations

หากต้องการดูการรอของเซอร์วิสใดเซอร์วิสหนึ่งในขณะที่กำลังเกิดขึ้น ให้อ่านล็อกของคอนเทนเนอร์เริ่มต้นของเซอร์วิสนั้น:

kubectl -n nexus logs deploy/nexus-auth -c wait-for-schema
wait-for-schema: nexus-auth waits for nexus_release.schema_applied (read as nexus_ledger_reader) to show: nexus-auth-migrations; gives up after 1800s
wait-for-schema: ready after 212s: the release ledger shows nexus-auth-migrations

เนื่องจากการรอจะยึดตามค่าไดเจสต์ของอิมเมจ ไม่ใช่จำนวนไฟล์ พอดของการอัปเกรดในภายหลังจึงจะรอแถวของรีลีสใหม่ และพอดที่รีสตาร์ทหลังจากการเปลี่ยนแปลงเฉพาะค่าในไฟล์ values จะพบแถวของตัวเองในทันที

ขั้นตอนที่ 7: รอให้ทุกเวิร์กโหลดพร้อมใช้งาน

รอให้ Deployment ต่างๆ พร้อมทำงาน โดยมีการกำหนดเวลาสูงสุด:

kubectl -n nexus wait --for=condition=Available deploy --all --timeout=900s
deployment.apps/nexus-alpha condition met
deployment.apps/nexus-alpha-bff condition met
deployment.apps/nexus-auth condition met
deployment.apps/nexus-gateway condition met
deployment.apps/nexus-graphrag condition met
deployment.apps/nexus-keys condition met
deployment.apps/nexus-orchestrator condition met
deployment.apps/nexus-probitas condition met
deployment.apps/nexus-skills-engine condition met
deployment.apps/nexus-workflows condition met

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

for s in $(kubectl -n nexus get statefulset -o name); do
  kubectl -n nexus wait "$s" --for=jsonpath='{.status.readyReplicas}'=1 --timeout=900s
done

แต่ละรายการจะพิมพ์ condition met ในคลัสเตอร์ของเรา การรอทั้งสองส่วนรวมกันใช้เวลาน้อยกว่าห้านาทีหลังจากที่ Helm คืนค่ากลับมา

ลักษณะของระบบเมื่อพร้อมใช้งาน

kubectl -n nexus get deploy,statefulset
NAME                                  READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nexus-alpha           1/1     1            1           14m
deployment.apps/nexus-alpha-bff       1/1     1            1           14m
deployment.apps/nexus-auth            1/1     1            1           14m
deployment.apps/nexus-gateway         1/1     1            1           14m
deployment.apps/nexus-graphrag        1/1     1            1           14m
deployment.apps/nexus-keys            1/1     1            1           14m
deployment.apps/nexus-orchestrator    1/1     1            1           14m
deployment.apps/nexus-probitas        1/1     1            1           14m
deployment.apps/nexus-skills-engine   1/1     1            1           14m
deployment.apps/nexus-workflows       1/1     1            1           14m

NAME                                READY   AGE
statefulset.apps/nexus-neo4j        1/1     14m
statefulset.apps/nexus-postgres     1/1     14m
statefulset.apps/nexus-qdrant       1/1     14m
statefulset.apps/nexus-seaweedfs    1/1     14m
statefulset.apps/nexus-valkey       1/1     14m
statefulset.apps/openbao            1/1     14m
statefulset.apps/openbao-unsealer   1/1     14m

สิบ Deployment และเจ็ด StatefulSet พร้อมใช้งานครบทุกรายการ เคียงข้างสิ่งเหล่านั้น คุณจะพบสาม CronJob ได้แก่ nexus-keys-rotate-epoch, nexus-keys-run-schedule และ nexus-keys-export-receipts ซึ่งเป็นการบำรุงรักษาประจำคืนของเซอร์วิสกุญแจ คำสั่ง kubectl -n nexus get jobs ไม่ควรแสดงรายการ Job ที่เป็นฮุกเลย เนื่องจากรายการที่สำเร็จได้ถูกลบออกไปแล้ว

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

พร้อมใช้งาน หมายความว่าแพลตฟอร์มกำลังทำงานอยู่และยังไม่มีการอ้างสิทธิ์ เมื่อเปิด https://console.harrow.example คุณจะพบกับตัวติดตั้ง ไม่ใช่หน้าลงชื่อเข้าใช้ เพราะจะไม่มีใครสามารถลงชื่อเข้าใช้ได้จนกว่าจะมีคนอ้างสิทธิ์ในการติดตั้งนั้น นั่นคือการรันครั้งแรก ซึ่งอยู่ใน บทที่ 2.12, การรันครั้งแรก

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

หากขั้นตอนนี้ล้มเหลว

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

สิ่งที่คุณเห็น สาเหตุ สิ่งที่ต้องทำ
INSTALLATION_NAME_MISSING หรือ INSTALLATION_NAME_EXAMPLE keys.installationName ว่างเปล่าหรือเป็นค่าตัวอย่าง ตั้งชื่อถาวรของคุณเอง
KEYS_CUSTODIAN_MISSING หรือ KEYS_CUSTODIAN_EXAMPLE ไม่มีผู้ดูแลกุญแจ หรือเป็นค่าตัวอย่าง ตั้งค่าผู้รับที่เป็นของผู้ดูแลกุญแจของคุณเอง
keys.installationName ... does not match ^[a-z][a-z0-9-]{0,62}$ มีตัวพิมพ์ใหญ่ จุด หรือขึ้นต้นด้วยตัวเลข ใช้ตัวพิมพ์เล็ก ตัวเลข และเครื่องหมายยัติภังค์ โดยขึ้นต้นด้วยตัวอักษร
keys.custody.recipients: ... และเหตุผล พิมพ์ข้อมูลผู้รับผิด เป็นกุญแจส่วนตัว หรืออยู่ในรูปแบบที่ Job ของระบบดูแลกุญแจไม่สามารถเข้ารหัสให้ได้ ขอข้อมูลผู้รับจากผู้ดูแลกุญแจอีกครั้ง
hosts.console is required (the installation identity) ไม่ได้ตั้งค่าโฮสต์ ตั้งค่าโฮสต์ทั้งสามแห่ง
tls.existingSecret is required when tls.mode is existing ไม่ได้ระบุชื่อ Secret ตั้งค่า Secret หรือเปลี่ยน tls.mode
networkPolicy.apiServerCIDRs is empty and the kubernetes Endpoints could not be read บัญชีของคุณไม่สามารถอ่านที่อยู่ของเซิร์ฟเวอร์ API ได้ ระบุเป็นช่วง /32
global.imageRegistry is required ไม่ได้ตั้งค่าเรจิสทรี ตั้งค่าเรจิสทรี
Helm ค้างอยู่จนกระทั่งหมดเวลา และ nexus-auth บันทึกล็อกเป็น password authentication failed มีการระบุ --wait ถอนการติดตั้งแล้วติดตั้งใหม่อีกครั้งโดยไม่ใช้ --wait
Error: ... job failed ที่ระบุชื่อฮุก การไมเกรตล้มเหลว รัน kubectl -n nexus logs job/<hook-name> และอ่านบรรทัดสุดท้ายของล็อก
พอดค้างอยู่ในสถานะ Init wait-for-schema ของพอดนั้นยังคงรออยู่ อ่านล็อกของคอนเทนเนอร์นั้น ซึ่งจะระบุชื่อห่วงโซ่ที่ยังขาดอยู่
wait-for-schema: FAILED ฮุกของห่วงโซ่นั้นไม่ได้เขียนแถวข้อมูลลงไป ค้นหาความล้มเหลวของฮุกนั้นก่อน
ImagePullBackOff โหนดไม่สามารถดึงข้อมูลจาก global.imageRegistry ได้ ตรวจสอบว่าโหนดสามารถเข้าถึงเรจิสทรีได้ และสำหรับรุ่น Enterprise ให้ตรวจสอบว่ามีโทเค็นสำหรับการดึงข้อมูลแล้ว

ทุกฮุกที่รอ PostgreSQL จะรอในเวลาที่จำกัดและจะแจ้งข้อความว่า waiting for postgres (12/60) ดังนั้นฐานข้อมูลที่ค้างจะแสดงขึ้นมาในล็อกของฮุกภายในเวลาหนึ่งนาที

เส้นทางการติดตั้งด้วย nexusctl

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

nexusctl install --context harrow-prod --values harrow-values.yaml

คำสั่งนี้จะรันการตรวจสอบก่อนการติดตั้งอีกครั้งและจะหยุดทำงานหากมีการตรวจสอบใดเริ่มล้มเหลว มันจะตรวจสอบลายเซ็นของชุดชาร์ตเทียบกับกุญแจของรีลีส จากนั้นจึงทำการติดตั้ง รอให้ฮุกและเวิร์กโหลดทำงานจนเสร็จ และพิมพ์แต่ละขั้นตอนพร้อมเวลาที่ใช้ --edition community ใช้ระบุรุ่น (edition) ในบรรทัดคำสั่งนอกเหนือไปจากในไฟล์ --ca-bundle <file> ใช้เพิ่มใบรับรอง CA ของคุณเอง เช่นเดียวกับในการตรวจสอบก่อนการติดตั้ง หากต้องการดูการดำเนินการของ helm และ kubectl ที่คำสั่งนี้จะรันโดยไม่รันจริง ให้เพิ่ม --explain:

nexusctl install --context harrow-prod --values harrow-values.yaml --explain

เมื่อทำงานเสร็จสิ้น คำสั่งจะพิมพ์ที่อยู่สำหรับการอ้างสิทธิ์, รหัสอ้างสิทธิ์แบบใช้ครั้งเดียว และลายนิ้วมือ (fingerprint) ของการติดตั้ง:

Installed in <time>. Nobody can sign in yet.

  Open   https://console.harrow.example/claim
  Code   <code>          works once, for 30 minutes
  Fingerprint of this installation, to compare in the browser:
         <eight groups of four>

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

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

การส่งต่อไปยังการเรียกใช้งานครั้งแรก

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

nexusctl claim-code --administrator aoife.brennan@harrow.example

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

ต่อจากนี้ไปจะเป็นการทำงานผ่านเบราว์เซอร์ ได้แก่ การอ้างสิทธิ์ในการติดตั้ง, การสร้างผู้ดูแลระบบคนแรกด้วยพาสคีย์ (passkey) และการทำหกขั้นตอนให้เสร็จสิ้นก่อนที่ใครจะลงชื่อเข้าใช้ นั่นคือเนื้อหาใน บทที่ 2.12, การรันครั้งแรก หากคุณต้องการใส่ไลเซนส์สำหรับรุ่น Enterprise ทันที ให้อ่าน บทที่ 2.7, การติดตั้งรุ่น Enterprise และการเปิดใช้ไลเซนส์ ก่อน เนื่องจากไลเซนส์เป็นหนึ่งในหกขั้นตอนนั้น