AccediPrenota un briefing

Capitolo 2.8

Installazioni su macchina singola

Installare Nexus su un singolo server Linux con nexusctl, oppure valutarlo su un laptop con k3d, e raggiungere la console tramite HTTPS affinché l'accesso e le passkey funzionino.

Questa pagina è stata tradotta dall'IA a partire dall'originale in inglese. In caso di dubbi, fa fede la pagina in inglese. Legga questa pagina in inglese

18 minuti di lettura

Prima che Harrow Port Authority mettesse Nexus sul proprio cluster di produzione, Tomás Reilly ha voluto due installazioni più piccole. Una era un progetto pilota su un server Linux di riserva nell'edificio operativo, per le dodici persone che l'avrebbero provato per prime. L'altra girava sul suo laptop personale, così da poter fare esperimenti e causare guasti senza che nessuno se ne accorgesse. Questo capitolo tratta entrambe le soluzioni. Utilizzano lo stesso chart, le stesse immagini e la stessa procedura di primo avvio di un'installazione completa su Kubernetes, perciò quanto appreso su una macchina resta valido anche sull'altra.

Il percorso su server richiede un solo comando: nexusctl install --single-node crea un cluster k3s sulla macchina, installa cert-manager e poi installa Nexus. Il percorso su laptop richiede più interventi manuali. Si crea autonomamente un cluster k3d, si installano cert-manager e il chart con Helm, e poi si esegue un passaggio aggiuntivo che trae in inganno quasi tutti: si posiziona la console dietro HTTPS sulla propria macchina, perché un semplice port-forward non consente mai a nessuno di effettuare l'accesso.

Dimensioni minime della macchina

Con i valori predefiniti del chart, Nexus richiede circa 2.05 core di CPU (unità di elaborazione centrale) e 6.7 GiB di memoria nelle richieste (requests), e i suoi volumi sommano fino a 142 GiB. Questo totale è composto da PostgreSQL 50, Valkey 5, Neo4j 20, Qdrant 10, l'object store 50, i due store OpenBao 1 e 5, e il volume delle ricevute (receipts) 1. Le richieste corrispondono a ciò che lo scheduler riserva, ma l'utilizzo reale aumenta quando gli utenti iniziano a lavorare.

Macchina CPU Memoria (RAM, memoria ad accesso casuale) Disco
Nodo singolo consigliato 8 vCPU 32 GiB 250 GB SSD (unità a stato solido)
Minimo per la valutazione 4 vCPU 16 GiB 200 GB

Un laptop che soddisfa i requisiti minimi di valutazione è in grado di eseguire Nexus, ma ciò che conta è il limite di memoria assegnato a Docker, non quello del laptop. Assegnare a Docker almeno 16 GiB prima di iniziare.

Entrambi i percorsi richiedono Kubernetes 1.33 o versioni successive. Il percorso a nodo singolo include già la propria distribuzione: k3s v1.33.6+k3s1, sulla quale viene testata ogni release.

Parte uno: un singolo server Linux con nexusctl

Il server pilota di Tomás è una macchina a 8 core con 32 GiB di memoria e un SSD da 500 GB, su cui gira una versione aggiornata di Linux priva di qualsiasi altro software. L'installazione richiede i privilegi di root, poiché installa k3s come servizio di sistema.

Ottenere nexusctl e verificarlo

  1. Scaricare nexusctl per la propria architettura da https://downloads.adverant.ai/nexus/1.0.0-alpha.1/, insieme alla chiave pubblica della release. Salvare la chiave come release.pub. Il capitolo 2.4, Ottenere e verificare una release, spiega come controllare l'impronta digitale (fingerprint) della chiave confrontandola con quella pubblicata da Adverant.
  2. Verificare il file binario e la release con la chiave:
nexusctl version --json
nexusctl verify

nexusctl verify controlla il file scaricato rispetto alla chiave di rilascio di Adverant e rifiuta qualsiasi elemento che non possa verificare. Se l'operazione fallisce, interrompere la procedura e ripetere il download. Non eseguire mai un'installazione da un file che non ha superato la verifica.

Creare la chiave del custode

Il key store dell'installazione sigilla le proprie chiavi di ripristino associandole a uno o più custodi (custodians). Un custode è una persona che conserva offline un file di identità age, e il chart rifiuta l'installazione se non ne è presente almeno uno. Sulla macchina del custode:

age-keygen -o custodian.key

Il file inizia con una riga # public key: age1.... Questa metà pubblica è ciò che va inserito nel file dei valori (values). Il file di identità vero e proprio non lascia mai la macchina del custode. Su un Mac dotato di Secure Enclave, age-plugin-se keygen --access-control=any-biometry -o custodian.key genera una chiave il cui utilizzo richiede Touch ID, e la sua metà pubblica inizia con age1se1.

Scrivere il file dei 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> è la riga age1... proveniente da custodian.key. Aggiungere una voce all'elenco per ciascun custode.

keys.installationName è permanente. Al primo avvio del key store, l'identità dell'installazione viene coniata con quel nome e nulla potrà rinominarla in seguito. Deve rispettare il formato ^[a-z][a-z0-9-]{0,62}$: lettere minuscole, iniziale alfabetica, massimo 63 caratteri. Non copiare nexus-example o il destinatario di esempio dai file di esempio del chart stesso. Il chart li rifiuta entrambi per nome, e il controllo preliminare (preflight) segnala preventivamente gli stessi codici di errore.

I tre host costituiscono l'identità dell'installazione. Ogni servizio rifiuta di avviarsi senza di essi, e ogni accesso, cookie e passkey è vincolato a hosts.console. Scegliere nomi che si desidera mantenere anche tra cinque anni.

Puntare i tre nomi verso il server

Gli utenti raggiungono la console, l'API (interfaccia di programmazione delle applicazioni) e il servizio di accesso tramite l'ingress controller integrato di k3s, Traefik, sulle porte 80 e 443 del server. Aggiungere tre record DNS (Domain Name System) per console.harrow.example, api.harrow.example e auth.harrow.example, ciascuno puntato all'indirizzo del server. Il controllo preliminare (preflight) verifica ogni nome e segnala quale è privo di record.

La policy di rete del chart consente a un solo namespace di raggiungere i tre servizi pubblici. Il valore predefinito, kube-system, corrisponde a dove k3s esegue Traefik, quindi su un nodo singolo si lascia networkPolicy.ingressNamespace invariato.

Eseguire il controllo preliminare, poi installare

  1. Eseguire il controllo preliminare (preflight) con il flag per nodo singolo. Esso legge la macchina e il file dei valori senza apportare alcuna modifica.
sudo nexusctl preflight --single-node --values harrow-pilot-values.yaml
  1. Leggere la riga di riepilogo alla fine. Un avviso (warning) non blocca mai l'installazione, mentre un errore (failure) sì, e ogni riga che segnala un errore include una riga 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. Procedere con l'installazione. Il flag --edition deve coincidere con edition nel file dei valori.
sudo nexusctl install --single-node --values harrow-pilot-values.yaml --edition community
  1. Seguire l'esecuzione. Il comando esegue nuovamente il controllo preliminare, installa k3s v1.33.6+k3s1, installa cert-manager v1.21.3, installa Nexus e attende che ogni servizio risponda positivamente al proprio controllo di integrità (health check). Sul server di Tomás l'operazione ha richiesto poco meno di dieci minuti.
 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

Mantenere quell'impronta digitale (fingerprint) sullo schermo. Sarà necessario confrontarla nel browser al momento di reclamare l'installazione con il codice. Se il codice scade prima di essere utilizzato, nexusctl claim-code --administrator <email> ne genera uno nuovo. Il capitolo 2.12, Il primo avvio, prosegue da questo punto.

Installare l'edizione Community
Installare l'edizione Community
L'installazione dell'edizione Community su un singolo server prevede il download, la verifica, il controllo preliminare e l'installazione, seguiti dalla configurazione del primo amministratore. Non è previsto alcun passaggio relativo alla licenza.

Posizionare il certificato

Con tls.mode: existing, le tre rotte di ingress servono il certificato contenuto nel Secret indicato da tls.existingSecret. Esso deve coprire tutti e tre gli host. Il controllo preliminare legge tale Secret quando esiste e genera un avviso se il certificato scade entro 30 giorni. Quando il Secret non è ancora presente, la riga indica di crearlo e lo segnala come avviso, non come errore bloccante.

Su un nodo singolo il cluster non esiste finché l'installazione non lo ha creato, pertanto occorre creare il Secret subito dopo l'installazione. Esportare innanzitutto il file kubeconfig del cluster (l'ultima sezione di questo capitolo spiega come fare), quindi utilizzarlo per creare il Secret:

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 contiene il certificato seguito da eventuali certificati intermedi, mentre harrow-public.key contiene la relativa chiave privata. Se i certificati provengono da una CA (autorità di certificazione) privata, nexusctl preflight e nexusctl install accettano --ca-bundle <file> in modo da poter verificare la catena. Gli altri metodi per gestire TLS (Transport Layer Security) sono descritti nel capitolo 2.11, Varianti: store esterni, TLS e ingress.

Se l'operazione fallisce

Cosa si vede Cosa significa Cosa fare
PREFLIGHT_FAILED (409) Il controllo preliminare ha rilevato un errore, pertanto l'installazione non è stata avviata. Non è stato installato nulla. Correggere ciascuna riga con esito negativo utilizzando la relativa indicazione fix, quindi eseguire nuovamente l'installazione.
INSTALLATION_NAME_MISSING keys.installationName è vuoto. Impostare il nome permanente proprio dell'installazione.
INSTALLATION_NAME_EXAMPLE Il nome è quello presente nei valori di esempio del chart. Scegliere un nome proprio.
KEYS_CUSTODIAN_MISSING keys.custody.recipients è vuoto. Aggiungere il destinatario pubblico age1... di ciascun custode.
KEYS_CUSTODIAN_EXAMPLE Uno dei destinatari è il custode di esempio del chart, la cui identità non è detenuta da nessuno. Sostituirlo con i destinatari dei propri custodi.

nexusctl termina con codice di uscita 0 quando può procedere, 1 quando un controllo lo ha bloccato e 2 quando non è stato possibile eseguirlo affatto (file dei valori illeggibile, flag errato). Uno script può diramare il flusso in base a questi tre valori.

Parte due: una valutazione su un laptop con k3d

k3d esegue k3s all'interno di container Docker, cosicché un intero cluster risiede su un laptop e scompare con un solo comando. Gli strumenti di rilascio che testano ogni release di Nexus creano i propri cluster esattamente in questo modo, e copiare le loro impostazioni evita di dover riscoprire i problemi che hanno già affrontato.

Sono necessari Docker, k3d 5.8.3, kubectl, Helm v4 e Chrome. Tomás ha utilizzato il suo Mac.

Creare il cluster

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

Ogni flag ha una ragione precisa.

  • --agents 0 fornisce un nodo server e nessun nodo worker. Nexus funziona perfettamente su un solo nodo e un secondo nodo consumerebbe solo memoria.
  • --image rancher/k3s:v1.33.6-k3s1 fissa la versione di k3s sulla quale viene testata ogni release. Senza di esso si ottiene qualsiasi versione sia predefinita in k3d.
  • --disable=traefik@server:0 esclude Traefik. Un laptop non ha un indirizzo pubblico da servire e la console viene invece raggiunta tramite il proprio front-end HTTPS locale (vedere più avanti).
  • --wait --timeout 300s restituisce il controllo solo quando il cluster risponde, oppure fallisce dopo cinque minuti.

Se si effettua il mirroring del registro delle release sul proprio laptop, aggiungere --registry-config <registries.yaml> per indirizzare il pull delle immagini verso il mirror, e --k3s-arg "--disable-default-registry-endpoint@server:0" affinché nulla ripieghi su un registro upstream. Gli strumenti di rilascio funzionano in questo modo, facendo provenire ogni immagine esclusivamente dal mirror.

Installare cert-manager

Il chart crea la propria CA locale, nexus-local-ca, come issuer di cert-manager, e ogni servizio ottiene il proprio certificato da essa. Senza le risorse di cert-manager nel cluster, helm install rifiuta il chart in pochi secondi. Installare prima cert-manager v1.21.3, utilizzando il chart pubblicato dal progetto 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 non richiede nient'altro da cert-manager e, in particolare, non richiede trust-manager.

Installare Nexus

  1. Scrivere un file dei valori per il laptop. TLS termina sul proprio front-end locale, quindi tls.mode è impostato su 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. Installare il chart dal registro e omettere --wait (l'avviso seguente ne spiega il motivo).
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. Attendere quindi manualmente l'avvio dei carichi di lavoro:
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

Il ciclo sugli StatefulSet è necessario perché alcuni di essi aggiornano un pod alla volta su richiesta, e kubectl rollout status li rifiuta. L'attesa basata su readyReplicas funziona per qualsiasi strategia di aggiornamento.

Quando entrambi i comandi terminano, ogni Deployment è nello stato Available e ogni StatefulSet ha i propri pod pronti. Nessuno può ancora effettuare l'accesso. Questo è corretto: l'installazione non è ancora stata reclamata.

Perché un port-forward non consente mai di effettuare l'accesso

La mossa successiva più ovvia sarebbe eseguire kubectl port-forward svc/nexus-alpha 3000:3000 e aprire un browser su http://127.0.0.1:3000. Le pagine della console si caricano, dando l'impressione che tutto funzioni. In realtà non è così, e nessuna impostazione potrà farlo funzionare. Tre elementi lo impediscono, ciascuno intenzionalmente.

Cosa lo impedisce Perché
L'origine (origin) La procedura di accesso della console rifiuta qualsiasi richiesta la cui origine non sia https://<hosts.console>, in questo caso https://console.harrow.example. Una pagina servita da http://127.0.0.1:3000 ha un'origine errata, pertanto l'accesso non si avvia mai.
Il cookie La sessione è costituita da un cookie __Host- contrassegnato come Secure. I browser memorizzano un cookie di questo tipo solo tramite HTTPS, senza attributo di dominio, esclusivamente per l'host esatto che lo ha impostato. Su semplice HTTP il browser lo scarta.
La passkey Il primo amministratore accede tramite una passkey, e una passkey richiede un contesto sicuro con un certificato valido. Chrome rifiuta di creare una passkey dietro un avviso di certificato non valido, anche se l'utente ha scelto di ignorarlo e proseguire.

Pertanto il browser deve comunicare con https://console.harrow.example, utilizzando un certificato considerato attendibile, e quel nome deve puntare al laptop.

Raggiungere la console tramite HTTPS sul proprio laptop

Il metodo descritto di seguito utilizza la CA stessa del chart per emettere il certificato, un port-forward per raggiungere la console e un profilo Chrome separato che considera attendibile solo quella specifica CA e mappa il nome della console sul laptop. Il trust store di sistema e il file /etc/hosts rimangono invariati.

Il diagramma mostra Chrome sulla sinistra, con l'etichetta "profilo separato: considera attendibile solo nexus-local-ca; console.harrow.example:443 mappato su 127.0.0.1:28443". Una freccia con l'etichetta "HTTPS" va verso un riquadro "front-end HTTPS su 127.0.0.1:28443 (certificato da nexus-local-ca)". Una freccia con l'etichetta "HTTP, Host mantenuto, X-Forwarded-Proto https" va verso "kubectl port-forward 127.0.0.1:3000", e un'ultima freccia entra nel riquadro del cluster k3d verso "Service nexus-alpha, porta http (3000)". Una linea tratteggiata da cert-manager all'interno del cluster verso il riquadro del front-end riporta l'etichetta "emette il certificato".
Come un browser sul laptop raggiunge la console nel cluster k3d tramite HTTPS.

Emettere un certificato per il nome della console

  1. Richiedere a cert-manager un certificato per l'host della console, firmato dall'issuer del chart:
# 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 lo firma all'interno del cluster. L'utente non legge mai la chiave privata della CA.

  1. Copiare il certificato, la relativa chiave e il certificato della CA estraendoli dal 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. Calcolare il pin della CA. Chrome identifica una chiave attendibile tramite l'hash SHA-256 in base64 della sua chiave pubblica:
openssl x509 -in ca.crt -pubkey -noout | openssl pkey -pubin -outform der | openssl dgst -sha256 -binary | base64

Effettuare il pinning della chiave della CA, non di quella del certificato. Il certificato dura un giorno e riceve una nuova chiave ogni volta che cert-manager lo rinnova, mentre la CA rimane la stessa.

Posizionare un front-end HTTPS davanti a un port-forward

  1. Inoltrare il Service della console. La sua porta è quella denominata http, che in questa release corrisponde alla 3000:
kubectl -n nexus port-forward svc/nexus-alpha 3000:3000
  1. Eseguire un listener HTTPS su 127.0.0.1:28443 che inoltri il traffico a 127.0.0.1:3000. Qualsiasi reverse proxy di propria fiducia andrà bene, purché esegua quattro operazioni:
    • serva tls.crt seguito da ca.crt come catena, utilizzando tls.key;
    • mantenga l'header Host impostato su console.harrow.example;
    • imposti X-Forwarded-Proto: https;
    • lasci passare gli upgrade WebSocket, poiché la console li utilizza.

Un port-forward verso un Service si vincola al singolo pod selezionato al momento dell'avvio. Dopo che un aggiornamento o un riavvio sostituisce il pod della console, l'inoltro rimane attivo ma non punta più a nulla, e il browser mostra un errore di bad gateway. Riavviare il port-forward ogni volta che il pod della console cambia.

Aprire Chrome con il pin e la mappatura del nome

Su 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> è l'output della riga openssl. Su Linux, avviare Chrome con gli stessi tre flag.

I tre flag lavorano insieme. --host-resolver-rules invia le richieste per console.harrow.example sulla porta 443 al proprio front-end locale, esclusivamente all'interno di questo profilo. --ignore-certificate-errors-spki-list considera attendibili i certificati emessi da quell'unica chiave CA, e Chrome rispetta tale impostazione solo in presenza di --user-data-dir. Il profilo separato mantiene l'eccezione isolata dalla navigazione quotidiana. Non si tratta di un interruttore generico per "ignorare gli errori dei certificati": qualsiasi elemento non firmato dalla CA del cluster continuerà a essere rifiutato.

Con quel profilo aperto, https://console.harrow.example/install conduce alla pagina di rivendicazione ed è possibile creare una passkey. Il capitolo 2.12, Il primo avvio, riprende da questo punto.

Quando il laptop si riavvia

Il key store è composto da due parti: il key store vero e proprio e un piccolo componente di sblocco (unsealer) che detiene la chiave di sblocco. Dopo qualsiasi riavvio del nodo (un riavvio di Docker, un riavvio del laptop, k3d cluster stop e start), l'unsealer si avvia sigillato (sealed). Il key store si sblocca tramite esso, quindi finché un custode non sblocca l'unsealer con la propria identità age, nulla che richieda una chiave può funzionare. Questa è una caratteristica architetturale voluta ed è identica su un cluster di produzione. Il capitolo 2.15, Giorno due: gestione operativa di Nexus, illustra la procedura di sblocco.

Al termine della valutazione:

k3d cluster delete harrow-eval

L'eliminazione del cluster elimina l'installazione e tutto ciò che contiene.

nexusctl kubeconfig

Un cluster creato da nexusctl install --single-node appartiene a nexusctl. Per raggiungerlo con kubectl, helm o qualsiasi altro strumento, richiedere il relativo file kubeconfig:

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

Il file concede pieno accesso amministrativo al cluster. Conservarlo con permessi in modalità 600, sulle macchine delle persone che gestiscono l'installazione, e in nessun altro luogo. Ogni comando successivo nella Parte 2 che accetta --context o legge KUBECONFIG opera su un nodo singolo tramite questo file. Lo stesso vale per un aggiornamento: nexusctl upgrade plan --bundle <file> e nexusctl upgrade apply --bundle <file> su un nodo singolo aggiornano anche il cluster k3s gestito da nexusctl.

Il diagramma rappresenta una pila di quattro livelli su un riquadro con l'etichetta "un server Linux". Dal basso: "k3s v1.33.6+k3s1 (Traefik in kube-system, porte 80 e 443)", poi "cert-manager v1.21.3 e la CA locale del chart nexus-local-ca", poi "Livello dati di Nexus: PostgreSQL, Valkey, Neo4j, Qdrant, SeaweedFS, OpenBao", infine "Servizi di Nexus: console, accesso, gateway e il resto". Sulla destra, tre frecce provenienti dal livello superiore escono dal riquadro con le etichette console.harrow.example, api.harrow.example e auth.harrow.example. Sulla sinistra, l'icona di un terminale con l'etichetta "nexusctl kubeconfig" punta verso il livello k3s.
Cosa installa nexusctl install --single-node su un singolo server Linux.

Cosa si trasferisce a un cluster

Tutto ciò che è stato eseguito su una singola macchina ha un equivalente su un cluster. Il file dei valori è lo stesso file con un registro, una modalità TLS o una classe di storage differenti, come illustrato nel capitolo 2.11, Varianti: store esterni, TLS e ingress. Il primo avvio è identico. Ciò che non può essere trasferito è l'installazione stessa: il nome dell'installazione è fissato in modo permanente e un'installazione non può essere spostata da un laptop a un server. Quando Tomás è passato dal proprio laptop al server pilota, ha ricominciato da capo con un nuovo nome, harrow-pilot, mantenendo harrow-eval per gli esperimenti.