AutentificareProgramați o prezentare

Capitolul 2.8

Instalări pe o singură mașină

Instalați Nexus pe un singur server Linux cu nexusctl sau evaluați-l pe un laptop cu k3d și accesați consola prin HTTPS, astfel încât autentificarea și cheile de acces (passkeys) să funcționeze.

Această pagină a fost tradusă cu ajutorul IA din originalul în limba engleză. Dacă există neclarități, pagina în limba engleză rămâne cea de referință. Citiți această pagină în limba engleză

18 minute de lectură

Înainte ca Harrow Port Authority să instaleze Nexus pe clusterul său de producție, Tomás Reilly a dorit două instalări mai mici. Una a fost un proiect-pilot pe un server Linux de rezervă din clădirea de operațiuni, pentru cele douăsprezece persoane care urmau să îl încerce primele. Cealaltă a rulat pe propriul său laptop, astfel încât să poată testa și strica lucruri fără ca cineva să observe. Acest capitol le acoperă pe ambele. Ele folosesc același chart, aceleași imagini și aceeași primă rulare ca o instalare Kubernetes completă, astfel încât ceea ce învățați pe o mașină rămâne valabil mai departe.

Varianta pentru server constă dintr-o singură comandă: nexusctl install --single-node construiește un cluster k3s pe mașină, instalează cert-manager și apoi instalează Nexus. Varianta pentru laptop presupune mai multă intervenție manuală. Construiți singur un cluster k3d, instalați cert-manager și chart-ul cu Helm, iar apoi faceți o operațiune suplimentară care îi ia prin surprindere aproape pe toți: puneți consola în spatele HTTPS pe propria mașină, deoarece un simplu port-forward nu poate autentifica pe nimeni.

Cât de mare trebuie să fie mașina

Nexus solicită aproximativ 2.05 nuclee CPU (unitate centrală de procesare) și 6.7 GiB de memorie în cereri cu valorile implicite ale chart-ului, iar volumele sale însumează 142 GiB. Acest total este format din PostgreSQL 50, Valkey 5, Neo4j 20, Qdrant 10, stocarea de obiecte 50, cele două stocări OpenBao 1 și 5, și volumul de chitanțe 1. Cererile reprezintă ceea ce rezervă planificatorul, iar utilizarea reală crește odată ce oamenii încep să lucreze.

Mașină CPU Memorie (RAM, memorie cu acces aleatoriu) Disc
Recomandat pentru un singur nod 8 vCPU 32 GiB 250 GB SSD (unitate solid-state)
Minim pentru evaluare 4 vCPU 16 GiB 200 GB

Un laptop care îndeplinește minimul pentru evaluare va rula Nexus, însă contează limita de memorie proprie a lui Docker, nu cea a laptopului. Alocați pentru Docker cel puțin 16 GiB înainte de a începe.

Ambele variante necesită Kubernetes 1.33 sau o versiune ulterioară. Varianta cu un singur nod vine cu propria sa versiune: k3s v1.33.6+k3s1, distribuția pe care este testată fiecare versiune lansată.

Partea întâi: un server Linux cu nexusctl

Serverul-pilot al lui Tomás este o mașină cu 8 nuclee, cu 32 GiB de memorie și un SSD de 500 GB, care rulează o versiune actuală de Linux fără nimic altceva pe ea. Instalarea necesită drepturi de root, deoarece instalează k3s ca serviciu de sistem.

Obțineți nexusctl și verificați-l

  1. Descărcați nexusctl pentru arhitectura dumneavoastră de la https://downloads.adverant.ai/nexus/1.0.0-alpha.1/, împreună cu cheia publică a versiunii. Salvați cheia ca release.pub. Capitolul 2.4, Obținerea și verificarea unei versiuni, explică modul în care puteți verifica amprenta cheii în raport cu cea publicată de Adverant.
  2. Verificați fișierul binar și versiunea cu ajutorul cheii:
nexusctl version --json
nexusctl verify

nexusctl verify verifică descărcarea în raport cu cheia de versiune Adverant și refuză tot ceea ce nu poate verifica. Dacă eșuează, opriți-vă și descărcați din nou. Nu rulați niciodată o instalare dintr-un fișier care nu a trecut verificarea.

Creați cheia de custode

Magazia de chei a instalării își sigilează cheile de recuperare către unul sau mai mulți custozi. Un custode este o persoană care deține offline un fișier de identitate age, iar chart-ul refuză instalarea fără cel puțin unul. Pe propria mașină a custodelui:

age-keygen -o custodian.key

Fișierul începe cu o linie # public key: age1.... Această jumătate publică este cea care intră în fișierul de valori. Fișierul de identitate în sine nu părăsește niciodată mașina custodelui. Pe un Mac cu Secure Enclave, age-plugin-se keygen --access-control=any-biometry -o custodian.key creează o cheie care necesită Touch ID pentru a fi utilizată, iar jumătatea sa publică începe cu age1se1.

Scrieți fișierul de valori

# harrow-pilot-values.yaml (Helm values)
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
keys:
  installationName: harrow-pilot
  custody:
    recipients:
      - "<custodian-age-recipient>"

<custodian-age-recipient> este linia age1... din custodian.key. Adăugați câte o intrare în listă pentru fiecare custode.

keys.installationName este permanent. Prima pornire a magaziei de chei creează identitatea instalării sub acel nume și nimic nu o mai poate redenumi ulterior. Trebuie să respecte ^[a-z][a-z0-9-]{0,62}$: litere mici, începând cu o literă, cel mult 63 de caractere. Nu copiați nexus-example sau destinatarul exemplu din fișierele exemplu ale chart-ului. Chart-ul le refuză pe ambele după nume, iar verificarea prealabilă (preflight) raportează mai întâi aceleași coduri.

Cele trei gazde reprezintă identitatea instalării. Fiecare serviciu refuză să pornească fără ele, iar fiecare autentificare, cookie și passkey este legat de hosts.console. Alegeți nume pe care le veți dori și peste cinci ani.

Direcționați cele trei nume către server

Utilizatorii accesează consola, API-ul (interfața de programare a aplicațiilor) și serviciul de autentificare prin controllerul de ingress încorporat în k3s, Traefik, pe porturile 80 și 443 ale serverului. Adăugați trei înregistrări DNS (Domain Name System) pentru console.harrow.example, api.harrow.example și auth.harrow.example, fiecare indicând către adresa serverului. Verificarea prealabilă controlează fiecare nume și vă indică pentru care dintre ele lipsește înregistrarea.

Politica de rețea a chart-ului permite unui singur namespace să acceseze cele trei servicii publice. Valoarea sa implicită, kube-system, este locul în care k3s rulează Traefik, astfel că pe un singur nod lăsați networkPolicy.ingressNamespace nemodificat.

Rulați verificarea prealabilă, apoi instalați

  1. Rulați verificarea prealabilă cu opțiunea pentru un singur nod. Aceasta citește mașina și fișierul dumneavoastră de valori și nu modifică nimic.
sudo nexusctl preflight --single-node --values harrow-pilot-values.yaml
  1. Citiți linia de rezumat de la sfârșit. Un avertisment nu blochează niciodată instalarea, dar o eroare o face, iar fiecare rând cu eroare conține o linie fix.
 ────────────────────────────────────────────────────────────
 9 passed · 1 warning · 0 failed   You can install. Warnings do not block; fix them when you can.
 Report saved to preflight-2026-11-12-0902.txt · nothing was changed
  1. Instalați. Opțiunea --edition trebuie să corespundă cu edition din fișierul de valori.
sudo nexusctl install --single-node --values harrow-pilot-values.yaml --edition community
  1. Urmăriți execuția. Rulează din nou verificarea prealabilă, instalează k3s v1.33.6+k3s1, instalează cert-manager v1.21.3, instalează Nexus și așteaptă ca fiecare serviciu să răspundă la verificarea stării de funcționare. Pe serverul lui Tomás a durat puțin sub zece minute.
 done   Preflight again        9 passed · 1 warning
 done   k3s v1.33.6+k3s1       node Ready
 done   cert-manager v1.21.3   ready
 done   Database and search    ready
 done   Engines                started
 done   Console                https://console.harrow.example
 Installed. 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:
 3F9A C21B 77E0 5D4C 9B12 A6F3 0E88 41D7

Păstrați acea amprentă pe ecran. O veți compara în browser atunci când revendicați instalarea cu ajutorul codului. Dacă codul expiră înainte să îl folosiți, nexusctl claim-code --administrator <email> generează unul nou. Capitolul 2.12, Prima rulare, continuă de aici.

Instalați ediția Community
Instalați ediția Community
Instalarea ediției Community pe un singur server presupune descărcarea, verificarea, verificarea prealabilă și instalarea, urmate de configurarea primului administrator. Nu există nicio etapă de licențiere.

Puneți certificatul la locul său

Cu tls.mode: existing, cele trei rute de ingress servesc certificatul din obiectul Secret numit de tls.existingSecret. Acesta trebuie să acopere toate cele trei gazde. Verificarea prealabilă citește acel Secret atunci când există și avertizează când certificatul expiră în mai puțin de 30 de zile. Când obiectul Secret nu este încă acolo, rândul vă indică să îl creați, iar acesta este un avertisment, nu o eroare.

Pe un singur nod, clusterul nu există până când instalarea nu l-a creat, așadar creați obiectul Secret imediat după instalare. Scrieți mai întâi fișierul kubeconfig al clusterului (ultima secțiune a acestui capitol explică acest lucru), apoi creați obiectul Secret cu ajutorul lui:

sudo nexusctl kubeconfig > harrow-pilot.kubeconfig
chmod 600 harrow-pilot.kubeconfig
export KUBECONFIG=$PWD/harrow-pilot.kubeconfig
kubectl -n nexus create secret tls harrow-public-tls --cert=harrow-public.crt --key=harrow-public.key

harrow-public.crt conține certificatul urmat de orice certificate intermediare, iar harrow-public.key cheia sa privată. Dacă certificatele dumneavoastră provin de la o CA (autoritate de certificare) privată, nexusctl preflight și nexusctl install primesc --ca-bundle <file> pentru a putea verifica lanțul. Celelalte modalități de gestionare a TLS (Transport Layer Security) se găsesc în capitolul 2.11, Variațiuni: stocări externe, TLS și ingress.

Dacă acest lucru eșuează

Ce vedeți Ce înseamnă Ce trebuie să faceți
PREFLIGHT_FAILED (409) Verificarea prealabilă a găsit o eroare, astfel încât instalarea nu a pornit. Nu a fost instalat nimic. Remediați fiecare rând cu eroare, folosind linia sa fix, și rulați din nou instalarea.
INSTALLATION_NAME_MISSING keys.installationName este gol. Setați numele permanent propriu al instalării.
INSTALLATION_NAME_EXAMPLE Numele este cel din valorile exemplu ale chart-ului. Alegeți propriul nume.
KEYS_CUSTODIAN_MISSING keys.custody.recipients este gol. Adăugați destinatarul public age1... al fiecărui custode.
KEYS_CUSTODIAN_EXAMPLE Un destinatar este custodele exemplu al chart-ului, a cărui identitate nu o deține nimeni. Înlocuiți-l cu destinatarii custozilor dumneavoastră.

nexusctl iese cu codul 0 când poate continua, 1 când o verificare a blocat execuția și 2 când nu a putut rula deloc (un fișier de valori ilizibil, o opțiune greșită). Un script poate ramifica execuția pe baza acestor trei valori.

Partea a doua: o evaluare pe un laptop cu k3d

k3d rulează k3s în interiorul containerelor Docker, astfel încât un întreg cluster trăiește pe un laptop și dispare cu o singură comandă. Instrumentele de lansare care testează fiecare versiune Nexus își construiesc clusterele exact în acest mod, iar copierea setărilor lor vă scutește de redescoperirea problemelor pe care acestea le-au întâmpinat deja.

Aveți nevoie de Docker, k3d 5.8.3, kubectl, Helm v4 și Chrome. Tomás a folosit Mac-ul său.

Creați clusterul

k3d cluster create harrow-eval --agents 0 --wait --timeout 300s \
  --image rancher/k3s:v1.33.6-k3s1 \
  --k3s-arg "--disable=traefik@server:0"
k3d kubeconfig get harrow-eval > harrow-eval.kubeconfig
chmod 600 harrow-eval.kubeconfig
export KUBECONFIG=$PWD/harrow-eval.kubeconfig

Fiecare opțiune are un motiv.

  • --agents 0 oferă un nod server și niciun worker. Nexus rulează fără probleme pe un singur nod, iar un al doilea nu face decât să consume memorie.
  • --image rancher/k3s:v1.33.6-k3s1 fixează versiunea k3s pe care este testată fiecare versiune lansată. Fără aceasta, obțineți versiunea implicită din k3d.
  • --disable=traefik@server:0 omite Traefik. Un laptop nu are o adresă publică pe care să o servească, iar consola este accesată în schimb prin propria interfață HTTPS (mai jos).
  • --wait --timeout 300s returnează doar atunci când clusterul răspunde sau eșuează după cinci minute.

Dacă oglindiți registrul de versiuni pe laptop, adăugați --registry-config <registries.yaml> pentru a trimite descărcările de imagini către oglindă și --k3s-arg "--disable-default-registry-endpoint@server:0" astfel încât nimic să nu revină la un registru din amonte. Instrumentele de lansare rulează în acest mod, fiecare imagine venind exclusiv prin intermediul oglinzii.

Instalați cert-manager

Chart-ul își creează propria CA locală, nexus-local-ca, ca emițător cert-manager, și fiecare serviciu își obține certificatul de la aceasta. Fără resursele cert-manager în cluster, helm install refuză chart-ul în câteva secunde. Instalați mai întâi cert-manager v1.21.3, din chart-ul publicat de proiectul cert-manager:

helm install cert-manager cert-manager-v1.21.3.tgz -n cert-manager \
  --create-namespace --set crds.enabled=true --wait --timeout 10m

Nexus nu are nevoie de nimic altceva de la cert-manager și, în special, nu are nevoie de trust-manager.

Instalați Nexus

  1. Scrieți un fișier de valori pentru laptop. TLS se termină la propria dumneavoastră interfață, așadar tls.mode este none.
# harrow-eval-values.yaml (Helm values)
global:
  imageRegistry: registry.adverant.ai
  domain: harrow.example
hosts:
  console: console.harrow.example
  api: api.harrow.example
  auth: auth.harrow.example
edition: community
tls:
  mode: none
keys:
  installationName: harrow-eval
  custody:
    recipients:
      - "<custodian-age-recipient>"
  1. Instalați chart-ul din registru și omiteți --wait (avertismentul de mai jos explică de ce).
helm install nexus oci://registry.adverant.ai/nexus/charts/nexus --version 1.0.0-alpha.1 \
  -n nexus --create-namespace -f harrow-eval-values.yaml --timeout 45m
  1. Apoi așteptați singur pornirea volumelor de lucru (workloads):
kubectl -n nexus wait --for=condition=Available deploy --all --timeout=900s
for s in $(kubectl -n nexus get sts -o name); do
  want=$(kubectl -n nexus get "$s" -o jsonpath='{.spec.replicas}')
  kubectl -n nexus wait "$s" --for=jsonpath='{.status.readyReplicas}'="$want" --timeout=900s
done

Bucla StatefulSet este acolo deoarece unele dintre ele actualizează câte un pod pe rând, la cerere, iar kubectl rollout status le refuză pe acestea. Așteptarea după readyReplicas funcționează pentru fiecare strategie de actualizare.

Când ambele comenzi se finalizează, fiecare Deployment este Available și fiecare StatefulSet are pod-urile pregătite. Nimeni nu se poate autentifica încă. Acest lucru este corect: instalarea este nerevendicată.

De ce un port-forward nu vă poate autentifica niciodată

Următorul pas evident este kubectl port-forward svc/nexus-alpha 3000:3000 și un browser deschis la http://127.0.0.1:3000. Paginile consolei se încarcă, așa că pare să funcționeze. Nu funcționează, și nicio setare nu o va face să funcționeze. Trei lucruri stau în cale, fiecare în mod intenționat.

Ce o oprește De ce
Originea Autentificarea consolei refuză o cerere a cărei origine nu este https://<hosts.console>, aici https://console.harrow.example. O pagină servită de la http://127.0.0.1:3000 are originea greșită, astfel încât autentificarea nu începe niciodată.
Cookie-ul Sesiunea este un cookie __Host- marcat Secure. Browserele stochează un astfel de cookie doar prin HTTPS, fără atribut de domeniu, exact pentru gazda care l-a setat. Prin HTTP simplu, browserul îl ignoră.
Passkey-ul Primul administrator se autentifică cu un passkey, iar un passkey necesită un context securizat cu un certificat valid. Chrome refuză să creeze un passkey în spatele unui avertisment de certificat, chiar și după ce ați ales să continuați.

Prin urmare, browserul trebuie să comunice cu https://console.harrow.example, cu un certificat în care are încredere, iar acel nume trebuie să ducă la laptopul dumneavoastră.

Accesarea consolei prin HTTPS pe laptopul dvs.

Metoda de mai jos folosește propria CA a chart-ului pentru a emite certificatul, un port-forward pentru a ajunge la consolă și un profil Chrome separat care are încredere în acea unică CA și asociază numele consolei cu laptopul dumneavoastră. Magazia de încredere a sistemului și /etc/hosts rămân neschimbate.

Diagrama prezintă Chrome în stânga, etichetat „profil separat: are încredere doar în nexus-local-ca; console.harrow.example:443 asociat cu 127.0.0.1:28443”. O săgeată etichetată „HTTPS” duce la o casetă „interfață HTTPS pe 127.0.0.1:28443 (certificat de la nexus-local-ca)”. O săgeată etichetată „HTTP, Host păstrat, X-Forwarded-Proto https” duce la „kubectl port-forward 127.0.0.1:3000”, iar o ultimă săgeată intră în caseta clusterului k3d către „Service nexus-alpha, port http (3000)”. O linie punctată de la cert-manager din interiorul clusterului către caseta interfeței este etichetată „emite certificatul”.
Cum ajunge un browser de pe laptop la consola din clusterul k3d prin HTTPS.

Emiteți un certificat pentru numele consolei

  1. Solicitați de la cert-manager un certificat pentru gazda consolei, semnat de emițătorul chart-ului:
# console-front-certificate.yaml (a cert-manager Certificate)
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: nexus-console-front
  namespace: nexus
spec:
  secretName: nexus-console-front-tls
  dnsNames: [console.harrow.example]
  duration: 24h
  usages: [server auth, digital signature, key encipherment]
  privateKey: { algorithm: ECDSA, size: 256, rotationPolicy: Always }
  issuerRef: { name: nexus-local-ca, kind: Issuer, group: cert-manager.io }
kubectl apply -f console-front-certificate.yaml
kubectl -n nexus wait --for=condition=Ready certificate/nexus-console-front --timeout=120s

cert-manager îl semnează în interiorul clusterului. Nu citiți niciodată cheia privată a CA.

  1. Copiați certificatul, cheia sa și certificatul CA din obiectul Secret:
kubectl -n nexus get secret nexus-console-front-tls -o jsonpath='{.data.tls\.crt}' | base64 -d > tls.crt
kubectl -n nexus get secret nexus-console-front-tls -o jsonpath='{.data.tls\.key}' | base64 -d > tls.key
kubectl -n nexus get secret nexus-console-front-tls -o jsonpath='{.data.ca\.crt}' | base64 -d > ca.crt
chmod 600 tls.key
  1. Calculați amprenta (pin) CA. Chrome identifică o cheie de încredere prin valoarea SHA-256 în base64 a cheii sale publice:
openssl x509 -in ca.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64

Fixați (pin) cheia CA, nu pe cea a certificatului. Certificatul este valabil o zi și primește o cheie nouă de fiecare dată când cert-manager îl reînnoiește, în timp ce CA rămâne aceeași.

Puneți o interfață HTTPS în fața unui port-forward

  1. Redirecționați serviciul (Service) consolei. Portul său este cel numit http, care este 3000 în această versiune:
kubectl -n nexus port-forward svc/nexus-alpha 3000:3000
  1. Rulați un ascultător HTTPS pe 127.0.0.1:28443 care redirecționează către 127.0.0.1:3000. Orice proxy invers în care aveți deja încredere este potrivit, atâta timp cât face patru lucruri:
    • servește tls.crt urmat de ca.crt ca lanț, cu tls.key;
    • păstrează antetul Host ca console.harrow.example;
    • setează X-Forwarded-Proto: https;
    • permite trecerea upgrade-urilor WebSocket, deoarece consola le folosește.

Un port-forward către un Service se leagă de singurul pod pe care l-a ales la pornire. După ce un upgrade sau o repornire înlocuiește pod-ul consolei, redirecționarea rămâne activă, dar nu mai trimite către nimic, iar browserul afișează o eroare bad gateway. Reporniți conexiunea port-forward ori de câte ori se schimbă pod-ul consolei.

Deschideți Chrome cu amprenta (pin) și asocierea numelui

Pe un Mac:

open -na "Google Chrome" --args --user-data-dir="$HOME/.nexus-eval-chrome" \
  "--host-resolver-rules=MAP console.harrow.example:443 127.0.0.1:28443" \
  "--ignore-certificate-errors-spki-list=<ca-pin>" \
  https://console.harrow.example/install

<ca-pin> este rezultatul liniei openssl. Pe Linux, porniți Chrome cu aceleași trei opțiuni.

Cele trei opțiuni funcționează împreună. --host-resolver-rules trimite console.harrow.example pe portul 443 către interfața dumneavoastră, doar în interiorul acestui profil. --ignore-certificate-errors-spki-list are încredere în certificatele emise de acea unică cheie CA, iar Chrome o respectă doar împreună cu --user-data-dir. Profilul separat ține excepția departe de navigarea dumneavoastră zilnică. Nu este un comutator general de tip „ignoră erorile de certificat”: orice nu este semnat de CA-ul clusterului eșuează în continuare.

Cu acel profil deschis, https://console.harrow.example/install duce la pagina de revendicare și poate fi creat un passkey. Capitolul 2.12, Prima rulare, continuă de aici.

Când laptopul repornește

Magazia de chei are două părți: magazia de chei în sine și un mic serviciu de desigilare (unsealer) care deține cheia sa de deblocare. După orice repornire a nodului (o repornire Docker, o repornire a laptopului, k3d cluster stop și start), serviciul de desigilare pornește sigilat. Magazia de chei se desigilează prin intermediul acestuia, astfel încât, până când un custode nu desigilează serviciul de desigilare cu propria sa identitate age, nimic din ceea ce necesită o cheie nu funcționează. Aceasta este o caracteristică de proiectare și funcționează la fel și pe un cluster de producție. Capitolul 2.15, Ziua a doua: operarea Nexus, prezintă procesul de desigilare.

Când ați terminat evaluarea:

k3d cluster delete harrow-eval

Ștergerea clusterului șterge instalarea și tot ce se află în ea.

nexusctl kubeconfig

Un cluster construit de nexusctl install --single-node aparține lui nexusctl. Pentru a-l accesa cu kubectl, helm sau orice alt instrument, solicitați fișierul său kubeconfig:

sudo nexusctl kubeconfig > harrow-pilot.kubeconfig
chmod 600 harrow-pilot.kubeconfig
export KUBECONFIG=$PWD/harrow-pilot.kubeconfig
kubectl -n nexus get deploy,statefulset

Fișierul acordă acces administrativ complet la cluster. Păstrați-l cu modul de permisiuni 600, pe mașinile persoanelor care gestionează instalarea și nicăieri altundeva. Fiecare comandă ulterioară din Partea 2 care primește --context sau citește KUBECONFIG funcționează pe un singur nod prin intermediul acestui fișier. Același lucru este valabil și pentru un upgrade: nexusctl upgrade plan --bundle <file> și nexusctl upgrade apply --bundle <file> pe un singur nod actualizează, de asemenea, clusterul k3s pe care îl deține nexusctl.

Diagrama reprezintă o stivă de patru niveluri pe o casetă etichetată „un server Linux”. De jos în sus: „k3s v1.33.6+k3s1 (Traefik în kube-system, porturile 80 și 443)”, apoi „cert-manager v1.21.3 și CA-ul local al chart-ului nexus-local-ca”, apoi „Nivelul de date Nexus: PostgreSQL, Valkey, Neo4j, Qdrant, SeaweedFS, OpenBao”, apoi „Serviciile Nexus: consolă, autentificare, gateway și restul”. În dreapta, trei săgeți de la nivelul superior părăsesc caseta, fiind etichetate console.harrow.example, api.harrow.example și auth.harrow.example. În stânga, o pictogramă de terminal etichetată „nexusctl kubeconfig” indică spre nivelul k3s.
Ce instalează nexusctl install --single-node pe un singur server Linux.

Ce se păstrează la trecerea pe un cluster

Tot ceea ce ați făcut pe o singură mașină are un echivalent pe un cluster. Fișierul de valori este același fișier, dar cu un alt registru, mod TLS sau clasă de stocare, după cum arată capitolul 2.11, Variațiuni: stocări externe, TLS și ingress. Prima rulare este identică. Ceea ce nu se transferă este instalarea în sine: numele instalării este fixat definitiv, iar o instalare nu poate fi mutată de pe un laptop pe un server. Când Tomás a trecut de pe laptopul său pe serverul-pilot, a luat-o de la capăt cu un nume nou, harrow-pilot, și a păstrat harrow-eval pentru experimente.