Logga inBoka en genomgång

Kapitel 2.1

Arkitektur

Vad varje tjänst i Nexus-chartet äger och vilka datalager som ligger under den, följt av reglerna som håller ihop dem, från identitet mellan tjänster till vägen som varje modellanrop tar.

Denna sida har översatts av AI från det engelska originalet. Om något är oklart är den engelska sidan referensen. Läs denna sida på engelska

19 minuters läsning

När Tomás Reilly hade slutfört den första installationen vid Harrow Port Authority visade kubectl -n nexus get pods tio Deployments och sju StatefulSets, plus tre CronJobs. De migrerings-Jobs som byggde databasen var redan borta, eftersom vart och ett raderar sig självt när det lyckas. Den listan utgör hela plattformen. Lär er den, för de flesta frågor efter driftsättningen börjar med ”vilken av dessa äger det där?”

Det här kapitlet besvarar den frågan för varje del, följer ett anrop genom dem och går sedan igenom de regler som de alla lyder under. Resten av del 2 bygger vidare på denna bild.

Tjänsterna och vad var och en äger

Chartet är ett enda Helm-chart, nexus, version 1.0.0-alpha.1, för Kubernetes 1.33 eller senare. Varje workload körs under sitt eget ServiceAccount, som en icke-root-användare, med alla Linux-capabilities borttagna. Anrop till de tjänster som skyddar identitet och nycklar sker över ömsesidig TLS (Transport Layer Security), och det publika API:et (applikationsprogrammeringsgränssnittet) delar process med AI-routern (artificiell intelligens).

Komponent Deployment och Service Service-port Vad den äger
Konsol nexus-alpha 3000 Sidorna som användarna ser; levererar HTML (Hypertext Markup Language) på konsolvärden
BFF (backend för frontend) nexus-alpha-bff 8080 Konsolens egna data, menyn som varje person får, utgåveregistret
Autentisering nexus-auth 9101 (ömsesidig TLS på 8443) Personer, organisationer, sessioner, token, API-nycklar, organisationens pool av modellnycklar
Gateway nexus-gateway 9092, WebSocket 8093 AI Provider Router och den publika API-kanten för REST (representational state transfer) och MCP (Model Context Protocol)
Orkestrerare nexus-orchestrator 8080 UNO-utskick: tar emot varje jobb och lägger det i kö
Arbetsflöden nexus-workflows 8081 UNO-exekvering: den worker som kör köade jobb
GraphRAG nexus-graphrag 8090, WebSocket 8091 Minne: kunskapsgrafen och sökning i den
Probitas nexus-probitas 9151 (HTTPS) Bevis: styrningsposter och den förseglade liggaren
Färdighetsmotor nexus-skills-engine 8095 Färdighetsbiblioteket; att hitta och köra färdigheter
Nycklar nexus-keys 8080 (HTTPS, ömsesidig TLS) Organisationsspecifika nycklar i OpenBao, förvaring, installationsidentiteten
Plugin-program nexus-plugins 9111 Plugin-registret och katalogposter; avstängt som standard
Filbearbetning nexus-fileprocess 9109 Läser uppladdade dokument och bilder; avstängt som standard

De första tio är obligatoriska. De två sista är valfria och slås på med components.plugins.enabled och components.fileprocess.enabled där en Enterprise-installation eller ett domänpaket använder dem. Ytterligare en valfri tjänst, nexus-alive på port 8080, har en egen växel, components.alive.enabled, och är också avstängd som standard. Repliker och resurser för var och en ligger under components.<name>.

Konsolen består av serverrenderade sidor utan databas. Den kommunicerar med BFF och med nexus-auth inuti klustret, aldrig ut genom den publika auth-värden och tillbaka in. Den vägrar att starta utan sin utgåva, vilken chartet skickar med som NEXUS_EDITION från det enda värdet edition. Varje medlem i en organisation arbetar i den utifrån sin roll. Administrationssidorna är till för ägare och administratörer, och en medlem som öppnar en sådan sida får upp sidan ”Inte en administratör”.

BFF är konsolens serverdel och är byggd som ett plugin-program i plattformen, registrerat som produkten Nexus Alpha. Den håller konsolens egna tabeller i en separat databas, nexus_alpha, och avgör vilka menygrupper en person ser. När konsolen behöver få ett arbete utfört ber BFF den tjänst som äger det.

nexus-auth är skrivet i Go och är den enda tjänsten som utfärdar token. Åtkomsttoken gäller i 15 minuter och uppdateringstoken i 12 timmar som standard (auth.accessTokenTTL, auth.refreshTokenTTL). Tjänsten begränsar varje inloggad person till 5,000 anrop per minut innan den svarar med 429 (auth.rateLimitPerMinute). Den kör två lyssnare: en vanlig på containerport 8080 som den publika Ingressen når, och en med ömsesidig TLS på 8443 som varje anropare inuti klustret måste använda. Den litar på X-Forwarded-For endast från hoppen i proxy.trustedCIDRs, en lista med CIDR-intervall (Classless Inter-Domain Routing) som har standardvärdet 10.42.0.0/16, k3s-poddnätverket. Om er ingress-controller körs någon annanstans måste ni ändra detta. Annars ser varje inloggning ut att komma från controllern.

Gatewayen har två uppgifter som delar på en process. Inuti klustret är den AI Provider Router (AI-växeln i del 1 och på konsolens sidor), den enda innehavaren av en organisations modellinloggningsuppgifter (mer om det nedan). Vid kanten är den vad api.<domain> når: REST-klienter och MCP-klienter, vars token bär målgruppen https://<hosts.api>/mcp och kommer från OAuth 2.1-auktoriseringsservern på auth-värden (OAuth är den öppna standarden för delegerad auktorisering).

Orchestrator och workflows utgör tillsammans UNO, arbetsflödesmotorn. All beräkning körs genom dem. Orchestratorn tar emot ett jobb på POST /api/v1/dispatch, svarar 202 med jobId, runId och traceId, och lägger det i kö. Det finns ingen väg för direkt exekvering: en klient pollar alltid GET /api/v1/dispatch/{jobId} eller tar emot en callback. Workflows-workern hämtar jobb från kön, fyra åt gången per replik som standard (workflows.concurrency), och har exakt en HTTP-rutt, GET /health.

Probitas är bevistjänsten. Den hanterar TLS själv, med ett certifikat som chartet utfärdar, och håller sina tabeller i schemat trust med en separat roll för liggaren. Dess styrningsfunktioner växlas med probitas.flags. Flera levereras i läget shadow: utslaget beräknas och registreras, och ingenting blockeras förrän ni ändrar flaggan.

nexus-keys är plattformens nyckeltjänst, skriven i Go. Den håller en nyckel per organisation i ett OpenBao-nyckellager och roterar dem varje natt. Dess nattliga jobb förstör även nycklar vars lagringsdatum har passerat och exporterar kvitton till en egen volym. Att radera en organisations nyckel gör de data som är låsta under den oläsbara för alltid. Den utfärdar också installationsidentiteten vid den första bootstrap-körningen, under keys.installationName, och det namnet är permanent. Välj det med omsorg: chartet nekar ett tomt namn (INSTALLATION_NAME_MISSING) och nekar namnet i sina egna exempelvärden (INSTALLATION_NAME_EXAMPLE).

Denna installation (Community)
Denna installation (Community)
En Community-installations egen sida visar dess version och motorhälsa. Där står tydligt att ingen licens behövs. Enterprise-delarna av sidan visas som förhandstittar.

Tre publika värdar

Chartet publicerar exakt tre värdnamn, som tillsammans utgör installationsidentiteten. Varje tjänst vägrar att starta utan dem.

Ingress Värdvärde Backend
nexus-console hosts.console nexus-alpha, port 3000
nexus-api hosts.api nexus-gateway, port 9092
nexus-auth hosts.auth nexus-auth, port 9101

Exemplen i den här boken använder console.harrow.example, api.harrow.example och auth.harrow.example. Ingresserna är vanliga networking.k8s.io/v1-objekt med en regel vardera, sökväg /. TLS vid kanten följer tls.mode: existing (en Secret ni har skapat, namngiven i tls.existingSecret), cert-manager (en ClusterIssuer ni kör, namngiven i tls.clusterIssuer) eller none (TLS avslutas framför klustret). Chartet lägger inte till någon egen omdirigering, så en ACME-utmaning (Automated Certificate Management Environment) över HTTP når er lösare oförändrad. Kapitel 2.11, Variationer: externa datalager, TLS och ingress, går igenom varje läge.

Ingenting annat exponeras. Datalagren, OpenBao och varje intern tjänst lyssnar endast inuti namnrymden.

Tre horisontella band. Det översta bandet är "Edge" med tre Ingress-rutor märkta console, api och auth, som var och en pekar nedåt mot sin Service (nexus-alpha :3000, nexus-gateway :9092, nexus-auth :9101). Det mittersta bandet är "Platform services": en ruta för nexus-alpha-bff; nexus-orchestrator bredvid nexus-workflows, grupperade och märkta UNO; därefter nexus-graphrag, nexus-probitas, nexus-skills-engine, nexus-keys; samt två streckade rutor för de valfria nexus-plugins och nexus-fileprocess. Det nedersta bandet är "Data tier" med en ruta per datalager (PostgreSQL, Valkey, Neo4j, Qdrant, SeaweedFS), och en separat inhägnad ruta märkt "Key store" som innehåller openbao och openbao-unsealer, vilken endast kan nås av nexus-keys.
Komponenterna i en Nexus-installation och datalagren under dem.

En förfrågan, från början till slut

Så här går det till när Aoife Brennan, IT-chef på Harrow, öppnar konsolen och ställer en fråga till assistenten om månadens kajschema.

  1. Hennes webbläsare läser in https://console.harrow.example. Ingressen nexus-console skickar anropet till nexus-alpha på port 3000.
  2. Hon loggar in med sin passkey. Inloggningssidorna kommunicerar med nexus-auth genom auth.harrow.example, och nexus-auth utfärdar en åtkomsttoken åt henne som bär hennes användare, hennes organisation och, när hennes session har en sådan, hennes affärsenhet.
  3. Konsolens server anropar BFF, som kontrollerar hennes token och frågar nexus-auth om hennes organisation innehar produkten och om hennes roll har behörighet. Tjänsten svarar med de menygrupper hon får se.
  4. Hennes fråga går från BFF till orchestratorns utskicksrutt, med hennes organisation och användare hämtade från den verifierade token. Orchestratorn svarar 202 och lägger jobbet i en kö i Valkey.
  5. En workflows-worker tar hand om jobbet. Den färdighet som körs slås upp av färdighetsmotorn, och sökningen i Harrows dokument går till GraphRAG, som läser Neo4j, Qdrant och sitt PostgreSQL-schema.
  6. Modellanropet går till AI Provider Router på /internal/ai/chat. Routern väljer leverantör och modell från Harrows egen nyckelpool och routningspolicy, gör anropet med Harrows nyckel och returnerar svaret.
  7. Resultatet hamnar på jobbets körrad. BFF läser det och konsolen ritar upp svaret med källhänvisningar.

Hoppen mellan tjänster bär projicerade tjänstetoken, anropen till nexus-auth, nexus-keys och Probitas körs över TLS från installationens egen certifikatutfärdare, och varje dataåtkomst i steg 4 till 6 är avgränsad till Harrows organisation i själva databasen. Avsnitten nedan förklarar bådadera.

En sekvens från vänster till höger. En webbläsarruta skickar "1 page" till Ingress console, och därefter till nexus-alpha. En sidopil "2 sign-in" går från webbläsaren genom Ingress auth till nexus-auth. nexus-alpha skickar "3 menu" till nexus-alpha-bff, som gör en kontroll mot nexus-auth. nexus-alpha-bff skickar "4 dispatch, 202" till nexus-orchestrator, som skriver till en Valkey-köikon. nexus-workflows hämtar "5 job" från kön och anropar nexus-skills-engine och nexus-graphrag (dess tre datalager är ritade under GraphRAG). nexus-workflows skickar "6 chat" till nexus-gateway, märkt "AI Provider Router: organisation key pool", som skickar en enkel pil ut ur klustergränsen till "model provider". En prickad returpil "7 result on run row" går tillbaka till nexus-alpha-bff.
En fråga till assistenten, från webbläsaren till modelleverantören och tillbaka.

Datalagret

Nexus levererar en egen signerad kopia av varje datalager, med källkodserbjudandet för vart och ett i paketet. Varje lager valdes lika mycket för sin licens som för sin funktion.

Datalager Version Licens Varför det finns där Hamn Standardvolym
PostgreSQL med PostGIS och pgvector PostgreSQL 16, PostGIS 3, pgvector 0.8 PostgreSQL Licence; PostGIS GPL-2.0-or-later System of record för varje tjänst; PostGIS för kartdata; pgvector för vektorer som lagras bredvid rader 5432 50 GiB
Valkey 8.1 BSD-3-Clause UNO-jobbköerna och kortlivade cachar, såsom API-nyckelcachen i nexus-auth 6379 5 GiB
Neo4j Community Edition 5.26 GPL-3.0 Kunskapsgrafen som GraphRAG bygger och traverserar 7687 (Bolt) 20 GiB
Qdrant 1.15 Apache-2.0 Vektorsökning för GraphRAG och färdighetsmotorn 6333 (HTTP), 6334 (gRPC-fjärranrop) 10 GiB
SeaweedFS 4.48 Apache-2.0 Objektlagring för filer, kompatibel med Amazon Simple Storage Service (S3) 8333 50 GiB
OpenBao 2.6 MPL-2.0 Nyckellagret och dess upplåsare, för nexus-keys 8200 5 GiB och 1 GiB

Vissa val ersatte mer välbekanta alternativ. Valkey ersätter Redis 7.4, vars nuvarande licenser utgåvan inte tillåter. MinIO har AGPL-3.0, så objektlagret är SeaweedFS. GraphRAG når Neo4j Community Edition över Bolt, ett nätverksprotokoll, och tjänsterna når PostGIS över PostgreSQL-protokollet, så GPL-licensen stannar hos var och en av dem. OpenBao är Linux Foundations förgrening av Vault från tiden före Vaults licensändring.

Varje datalager körs med autentisering påslagen och genererade inloggningsuppgifter: ett lösenord för Valkey, en API-nyckel för Qdrant, åtkomstnycklar för SeaweedFS.

Vart och ett av de fem datalagren under dataTier körs i klustret (mode: in-cluster, standardvalet) eller är ett som ni redan driver (mode: external, med external.host och en Secret namngiven av external.existingSecret). För en extern PostgreSQL anger ni sslmode till verify-full eller verify-ca, och lägger serverns CA-certifikat (certifikatutfärdare) i den Secreten; kapitel 2.11, Variationer: externa datalager, TLS och ingress, innehåller detaljerna.

# 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-paret är undantaget: det körs alltid inuti installationen, eftersom förvarings-Jobet initierar det där.

Identitet mellan tjänster

Nexus körs utan en service mesh. Ömsesidig TLS kommer från en lokal certifikatutfärdare (CA) som chartet skapar genom cert-manager, vilken måste installeras först (v1.21.3 är testad).

En självsignerad Issuer skapar ett CA-certifikat, nexus-local-ca, ECDSA (Elliptic Curve Digital Signature Algorithm) P-256, giltigt i tio år. En andra Issuer signerar med den CA:n. Varje workload som anropar en TLS-server inuti installationen får sitt eget klientcertifikat, namngivet <service-account>-client-tls, giltigt i 90 dagar och förnyat 15 dagar före utgångsdatum. Dess enda namn är en URI (uniform resource identifier) i SPIFFE-identitetsformat:

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

Varje workload hittar CA:ns publika certifikat som ca.crt i sin egen certifikat-Secret. Ingen podd monterar CA:ns nyckel, och ni behöver inte trust-manager.

Tre tjänster verifierar anropare med certifikat. nexus-auth gör det på sin andra lyssnare, port 8443, och varje anropare inuti klustret ansluter till den. nexus-keys gör det på sin enda lyssnare. Probitas levererar TLS från sitt eget certifikat, nexus-probitas-tls, som tjänsten läser in på nytt när cert-manager förnyar det. Ingen av dem litar på en X-Forwarded-Client-Cert-header.

Varje workload får också entimmes Kubernetes-token vid /var/run/secrets/nexus, en per tjänst den anropar, med den tjänsten som målgrupp. ConfigMap-objektet nexus-service-identities mappar varje <namespace>/<service-account> till ett tjänste- eller plugin-namn, och en workload som saknas där har ingen identitet och nekas. Orchestratorn och Probitas kontrollerar dessa token med Kubernetes API. Av de körande tjänsterna är det endast dessa två som innehar system:auth-delegator eller har en API-token monterad; den enda övriga workloaden med en token är det förvarings-Job som körs vid installationen.

Nätverkspolicyer stänger det som identiteten inte stänger. Chartet utgår från standardnekande (default deny) och släpper sedan igenom trafik mellan installationens egna poddar, DNS (Domain Name System), ingress-controllerns namnrymd (networkPolicy.ingressNamespace, kube-system som standard) till de tre publika Services, samt API-servern för de två tokengranskarna. OpenBao-poddarna bär en annan etikett än resten av plattformen, så den öppna regeln inuti namnrymden når dem inte: endast nexus-keys, dess Jobs och förvarings-Jobet släpps igenom, på port 8200. Allt annat som en workload måste nå utanför namnrymden, såsom er e-postreläserver, anges i networkPolicy.externalEgressCIDRs, som är tom som standard.

Migreringar och schemaliggaren

Migreringar körs som Helm-hookar, på post-install och pre-upgrade. En post-install-hook körs efter att utgåvans Deployments har skapats. Vid en nyinstallation startar därför tjänsterna medan deras scheman ännu inte finns, och de skulle hamna i en kraschloop mot en databas utan roll, utan lösenord och utan tabeller. Nexus undviker det med en liggare.

Hookarna körs i viktordning, och Helm väntar på varje Job innan nästa vikt startar:

Vikt Hook Vad den gör
-30 nexus-migrations-env och förutsättningar Skapar den Secret som endast används av hookar med migratorns inloggningsuppgifter, samt allt som förvarings-Jobet läser
-20 nexus-db-bootstrap Skapar databaserna nexus och nexus_alpha, migratorrollen, varje tjänsts körningsroll, tilläggen och liggaren
-15 nexus-openbao-custody-init Initierar nyckellagret och upplåsaren samt utfärdar installationsidentiteten
-12 nexus-graphrag-migrations GraphRAGs schema, som äger objekt som baslinjen i nexus-auth hänvisar till
-10 nexus-auth-migrations Identitetsschemat
-5 Migreringar för orchestrator, gateway och Probitas Deras scheman; Probitas kontrollerar först att auth-tabellerna finns
0 nexus-alpha-bff-migrations Konsolens egen databas

Varje migrerings-Job har backoffLimit: 0, så en misslyckad migrering gör att installationen misslyckas.

Liggaren är en enda tabell, nexus_release.schema_applied, med en rad per kedja och avbildnings-digest. Varje hook skriver sin rad först efter att dess migreringskörare har returnerat. Varje Deployment som använder PostgreSQL bär en init-container, wait-for-schema, som läser den tabellen som en roll med behörighet att inte läsa någonting annat (nexus_ledger_reader) och väntar tills varje kedja den är beroende av visar en rad för den här utgåvans avbildning. Därefter startar tjänsten. Workflows-workern väntar på orchestratorns kedja, eftersom den delar den databasen, och färdighetsmotorn väntar endast på bootstrap-steget.

Den pollar var 3:e sekund (schemaWait.intervalSeconds) och ger upp efter 1 800 (schemaWait.timeoutSeconds) med en rad som anger vilka kedjor som fortfarande saknas. Tjänstens egen container startar aldrig mot fel schema.

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

Det är därför ni aldrig får köra helm install --wait. Med --wait väntar Helm på att Deployments ska bli klara innan det kör post-install-hookarna, och Deployments väntar på hookarna. Ingendera kommer vidare. Installera utan flaggan och vänta efteråt; kapitel 2.6, Installera Community på Kubernetes, anger det exakta kommandot.

Isolering längs tre axlar

Varje läsning, skrivning, verktygsanrop och färdighetsutskick i Nexus avgränsas längs tre axlar.

Axel Fält Vad den skiljer åt
Klientorganisation (Tenant) organization_id En organisation från en annan, en hård gräns
Ägare owner_user_id En persons resurser från alla andras, även inom samma organisation
Enhet business_unit_id En underavdelning av en organisation, valfri

Ägaraxeln överraskar många. En postlåda eller en personlig anteckningsbok är privat för sin ägare, även gentemot kollegor i samma enhet med samma roll. En administratör anger policyer och läser inte innehåll.

Axlarna kommer från det autentiserade anropet och ingen annanstans ifrån. Ingen miljövariabel, header, frågeparameter eller sökvägsdel kan ange dem. En anropskropp som namnger en organisation nekas med TENANT_NOT_A_PARAMETER. En yta som inte kan ange vilken klientorganisation, ägare och enhet en rad tillhör nekar med 403 SCOPE_PREDICATE_MISSING, och kroppen listar vilka axlar som kunde slås upp och vilka som inte kunde det. Den faller aldrig tillbaka på en bredare läsning.

Detta gäller på två ställen samtidigt.

I databasen. Varje tjänst ansluter som sina egna körningsroller: nexus_auth, auth_app och auth_platform för identitetstjänsten, nexus_probitas och nexus_probitas_ledger för Probitas, samt nexus_gateway, nexus_graphrag, nexus_skills, orchestrator_app, workflows_app och resten för de övriga. Ingen är superanvändare eller har BYPASSRLS. Ingen äger heller de tabeller den använder, så varje RLS-policy (row-level security) gäller för den. Rollerna delar en grupp, nexus_runtime, som ger rätt till anslutning och schemaanvändning men inga tabellrättigheter alls; varje tjänst tilldelas sina egna tabeller genom sina egna migreringar. De inställningar för klientorganisation som RLS-policyerna läser kan endast anges genom varje tjänsts bind_scope-funktion, vilken körs som sin ägare. Bootstrap-steget återkallar set_config från alla andra, och orchestratorn och Probitas vägrar att starta om deras körningsroll skulle kunna anropa den direkt (Probitas kallar detta DB_ROLE_SETS_SCOPE_DIRECTLY). De enda superanvändaranslutningarna i hela installationen tillhör bootstrap-Jobet och BFF:s provisioneringssteg.

I den delade primitiven för avgränsade frågor. Varje lagringslager i plattformen och varje plugin-program som är byggt på SDK:t (software development kit) ärver ett staket som bygger SQL-predikatet utifrån en fastställd avgränsning. Dess avgränsningsfunktion tar den verifierade identiteten och har ingen organisationsparameter, så en anropare kan inte skicka med en sådan, och ingen rutt kan välja bort detta.

Det finns exakt en passage över gränsen mellan klientorganisationer, och den är smal: ett registrerat tillstånd. Två personer i den organisation som håller raderna registrerar vilken organisation som får läsa vilka tabeller, och hur länge. Varje läsning körs i en skrivskyddad transaktion och loggas i båda klientorganisationerna. Ägare och administratörer läser aldrig över gränsen, och läsaren kan inte utvidga ett tillstånd.

AI-vägen

Anropare uttrycker önskemål. AI Provider Router äger inloggningsuppgifterna och fattar det slutgiltiga beslutet.

Varje modellanrop i Nexus går genom routerns /internal/ai/*-rutter, och routern släpper endast in namngivna anropare. Chartet anger tre listor på gatewayen:

Rutter Vem som får anropa
Chatt och chattströmning nexus-orchestrator, nexus-workflows, nexus-skills-engine
Inbäddningar och omrangering nexus-graphrag, nexus-skills-engine, nexus-workflows
Allt annat, inklusive verktygsexekvering nexus-orchestrator, nexus-workflows

Ett anrop utan anroparidentitet nekas med 403 MISSING_CALLER_IDENTITY, och en anropare som inte står på listan med 403 UNAUTHORIZED_CALLER. Plugin-program står inte på någon lista, och det är avsiktligt: ett plugin-programs modellanrop sker för dess räkning, genom UNO-utskick.

Det en anropare får skicka är ett önskemål: en föredragen leverantör och modell, plus en kapabilitetsprofil såsom en minsta kontextlängd eller verktygsanvändning. Routern tillgodoser ett önskemål endast när organisationen har den leverantören aktiverad och försedd med inloggningsuppgifter; annars byter den ut valet, först inom samma leverantör och sedan över organisationens övriga leverantörer. En kapabilitetsprofil filtrerar endast, och ett krav på datalagringsplats i den är hårt. När ingenting passar finns det ingen reservmodell: anroparen får 422 MODEL_CAPABILITY_UNAVAILABLE eller 422 NO_PROVIDER_FOR_ROLE, med en åtgärdssträng som konsolen visar för en administratör.

Nycklarna tillhör organisationen. Varje organisations administratörer lägger in sina egna leverantörsnycklar i dess pool från konsolen, och routern slår upp dem vid anropstillfället. Ingen modellnyckel är ett chart-värde och ingen levereras med Nexus. En organisation utan nyckel får inga AI-svar, och konsolen anger detta tydligt; ingenting fyller tomrummet någon annanstans ifrån.

Två chart-värden styr routern. ai.localProvider.baseUrl namnger en OpenAI-kompatibel modellserver som du kör, vilken dirigeras som vilken annan leverantör som helst. ai.installationHosts listar dina modellservrar på privata namn, vilka routern räknar som en del av installationen. Även GraphRAG skapar inbäddningar via routern, i egenskap av den organisation vars innehåll det gäller. Standardmodellen för inbäddning körs i klustret utan grafikkort; externt hostade inbäddningar är varje organisations eget val.

Ingen telemetri

Ingenting lämnar en installation om du inte själv skickar det. Chartens värde för telemetry.enabled kan endast vara false; schemat nekar allt annat. Datalagrets egen rapportering är också avstängd: Neo4j:s användningsrapport och Qdrants telemetri är inaktiverade i charten.

När networkPolicy.enabled är aktiverat, vilket är standard, kan ingen pod nå internet om du inte anger destinationen i networkPolicy.externalEgressCIDRs. En externt hostad modelleverantör är en sådan destination, liksom ditt e-postrelä.

Samma regel ändrade en standardinställning som du kommer att märka av. CAPTCHA-funktionen i nexus-auth för registreringar kräver en internettjänst, så i en installation är den avstängd, och en okänd användares registrering inväntar godkännande från en administratör (403 SIGNUP_REQUIRES_APPROVAL). Spärren som blockerar registreringar från webbhotellsnätverk är också avstängd, eftersom den kräver licensierade databaser som Nexus inte levererar. Du förlorar den gallringen.

Installationens status
Installationens status
I Enterprise visar hälsosidan klustret under Nexus: hur belastad varje del är och hur mycket kapacitet som återstår, med varje varning placerad bredvid instruktioner för vad som bör göras åt den.