Version 1.0.0-alpha.1senaste
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

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).
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.
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.
- Hennes webbläsare läser in
https://console.harrow.example. Ingressennexus-consoleskickar anropet tillnexus-alphapå port 3000. - Hon loggar in med sin passkey. Inloggningssidorna kommunicerar med
nexus-authgenomauth.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. - 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.
- 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.
- 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.
- 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. - 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.
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-postgresOpenBao-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-schemaDet ä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.

