Un server di modelli che solo il suo gateway può chiamare
Un server di modelli in esecuzione in un cluster risponde a chiunque raggiunga il suo indirizzo. Su una rete di pod senza alcuna policy di rete, che è l’impostazione predefinita di Kubernetes, si tratta di ogni carico di lavoro nel cluster: il gateway posto davanti al modello è il modo in cui il traffico dovrebbe arrivare, non l’unico modo in cui può arrivare.
L’Aggregate dice già quali componenti chiamano quali: la connessione upstream del gateway nomina il server di modelli. core/caller-allowlist, che l’operatore associa al server di modelli nella Release, trasforma quella connessione dichiarata nella regola della rete del cluster. Questo workspace compila questa disposizione in manifest Kubernetes: un gateway NGINX nel namespace edge, un server di modelli Ollama nel namespace models, e la policy di rete che l’associazione scrive accanto al server di modelli.
Questo workspace non scrive alcuna entità di catalogo propria. I tre file di entità qui presenti — un Aggregate, un Manifest e una Release — sono tutto ciò che chiunque scrive.
Chi scrive cosa
| file | autore | cosa dice qui |
|---|---|---|
aggregate.yaml | lo sviluppatore | il gateway, il server di modelli, e la connessione upstream del gateway verso di esso |
release.yaml | l’operatore | i due namespace, e sulla voce del server di modelli l’associazione allowlist con il suo infra |
manifest.yaml | l’operatore | quale Recipe realizza ciascun componente e la Feature su Kubernetes |
L’Aggregate non contiene nulla sulla policy di rete. Lo sviluppatore dichiara la connessione che il gateway stabilisce; se il cluster rifiuta ogni altra è una decisione dell’operatore per questo ambiente, presa nella Release sotto components.model.features. Ogni input che la Feature accetta è infra, il pilastro dell’operatore. Ciò che lo sviluppatore dovrebbe sapere è la conseguenza: ovunque una Release associ questa Feature a un componente, una chiamata che l’Aggregate non dichiara come arco uses verso quel componente viene rifiutata dal cluster, dove il suo plugin di rete applica la policy di rete.
Che cosa costruisce
| istanza | Component del catalogo | namespace | che cosa è qui |
|---|---|---|---|
gateway | core/gateway/nginx | edge | il gateway che i client chiamano; inoltra al server di modelli |
model | core/ai-model/ollama | models | il server di modelli, che serve llama3.1 |
Un arco uses: il socket upstream del gateway verso il server di modelli. Un’associazione di Feature, nella Release: allowlist, core/caller-allowlist, sul server di modelli. La Release afferma che il cluster applica la policy di rete e nomina una sorgente esterna all’Aggregate, un agente di monitoraggio.
Generare l’esempio
Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.
Scrivi l’esempio in una nuova cartella che porta il suo nome:
aggrega scaffold --example model-server-caller-allowlistPoi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:
cd model-server-caller-allowlistBuild
aggrega build --release release.yaml --auto-pullUna release ha bisogno di un lockfile prima di eseguire il build, e i lockfile sono generati anziché distribuiti, quindi un clone appena creato non ne ha nessuno. Risolvine prima uno, oppure lascia che sia il build a crearlo:
aggrega pull --release release.yaml # resolve once, then build with no flagaggrega build --release release.yaml --auto-pull # or resolve during the buildQuesto workspace risolve le entità di catalogo dal registry predefinito che .aggrega-config.yaml nomina; nulla viene scaricato da un repository di chart.
Il build stampa, con <workspace> al posto della cartella di questo esempio:
warning: node "model" (provider "helm"): target "helm" does not support annotation aggrega.ai/namespace on artifacts-only input and ignored it[… omitted: the resolution's summary and a total build time, which differ per run]Build completed: 6 files written to <workspace>/distL’avviso riguarda la policy. La destinazione non colloca i manifest propri di una Feature in un namespace, quindi il template dell’associazione scrive nella policy il namespace in cui viene emesso lo StatefulSet del server di modelli — namespace: "models" qui sotto.
Con un assistente AI
Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.
Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella del workspace non contiene ancora una cartella `model-server-caller-allowlist`, chiama una volta lo strumento `scaffold` con `example` impostato su `model-server-caller-allowlist` e senza `dir`: scrive l’esempio in una nuova cartella `model-server-caller-allowlist`. Poi chiama lo strumento `build` con `workspace_root` impostato su `model-server-caller-allowlist`, `release` impostato su `release.yaml`, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto la build; si trovano in `model-server-caller-allowlist/dist/`.L’albero renderizzato
dist/├── edge/helm/│ ├── gateway-default-service.yaml│ └── gateway-deployment.yaml└── models/helm/ ├── model--allowlist--networkpolicy.yaml ├── model-default-service.yaml ├── model-headless-service.yaml └── model-statefulset.yamlL’associazione aggiunge un file, la policy. Ogni altro file è byte per byte ciò che la stessa Release renderizza senza di essa.
Che cosa può raggiungere il server di modelli
dist/models/helm/model--allowlist--networkpolicy.yaml, dal suo spec in poi:
spec: podSelector: matchLabels: "app": "model" policyTypes: - Ingress ingress: - from: - namespaceSelector: matchLabels: "kubernetes.io/metadata.name": "models" podSelector: matchLabels: "app": "model" - namespaceSelector: matchLabels: "kubernetes.io/metadata.name": "edge" podSelector: matchLabels: "app": "gateway" - namespaceSelector: matchLabels: "kubernetes.io/metadata.name": "monitoring" podSelector: matchLabels: "app.kubernetes.io/name": "prometheus" ports: - port: 11434 protocol: "TCP"La policy si trova in models, il namespace in cui viene emesso lo StatefulSet del server di modelli, seleziona i pod del server di modelli, e ammette connessioni verso di essi da tre sorgenti, sull’unica porta che il container del server di modelli dichiara:
- I pod propri del server di modelli, in
models, così che le repliche di uno stesso server possano raggiungersi a vicenda. - I pod del gateway, nel namespace
edge. Il selettore di namespace e il selettore di pod si trovano in un’unica voce, quindi un pod deve corrispondere a entrambi. Un carico di lavoro in un altro namespace con le stesse etichette — lo stesso Aggregate distribuito di nuovo altrove, per esempio — non è il gateway e non viene ammesso. - L’agente di monitoraggio che la Release nomina: i pod etichettati
app.kubernetes.io/name: prometheusnel namespacemonitoring.
I pod di ciascun componente sono selezionati dal selettore che scrive il suo controller — app: model per lo StatefulSet del server di modelli, app: gateway per il Deployment del gateway — e ciascun namespace è quello in cui viene emesso il suo carico di lavoro, entrambi letti da ciò che i rendering hanno emesso anziché ridichiarati a mano. Nessuno dei due selettori porta una versione, quindi quando viene distribuito un nuovo build, i pod del precedente sono ancora selezionati e ancora ammessi finché non vengono sostituiti.
Che cosa non può raggiungerlo
- Qualsiasi altro carico di lavoro, in
models, inedgeo in qualsiasi altro namespace — compreso un altro agente inmonitoring. - Un ingress controller, o qualsiasi client esterno al cluster. Nulla al di fuori dell’Aggregate viene ammesso a meno che la Release non lo nomini, e questa Release nomina solo l’agente di monitoraggio. I client raggiungono il server di modelli attraverso il gateway, che è la connessione che l’Aggregate dichiara.
- Qualsiasi porta diversa da 11434.
La policy limita chi può connettersi, non ciò che una connessione trasporta: una richiesta che il gateway inoltra raggiunge il modello così come il gateway l’ha inviata.
Che cosa il build non può sapere
Se la regola viene applicata. Una policy di rete viene applicata dal plugin di rete del cluster, e solo dove quel plugin implementa la policy di rete; un cluster il cui plugin non lo fa accetta la policy e non applica nulla. Il build scrive la policy e non può vedere il cluster, ed è per questo che la Release porta control_plane_present: true sull’associazione: è la dichiarazione dell’operatore che il cluster di destinazione la applica, e il build si arresta finché non viene fatta.
Altri tre limiti derivano dal funzionamento della policy di rete piuttosto che da questa Feature:
- Le policy si sommano. Dove un’altra policy nel cluster seleziona gli stessi pod, una connessione che l’una o l’altra ammette viene ammessa.
- Il gateway non è limitato da questa associazione. Essa protegge il server di modelli; associa la Feature anche alla voce del gateway nella Release per limitare chi raggiunge il gateway, e nomina lì i client che serve.
- Il traffico in uscita non viene toccato. Il server di modelli raggiunge ancora il registry da cui scarica i pesi, e risolve i nomi come prima.
Che cosa arresta il build
Ognuno di questi casi è una frase che il build stampa, e che nomina che cosa cambiare:
-
Il prerequisito non è affermato. Rimuovi
control_plane_present: truedalla Release:[… omitted: what resolving the lockfile prints, the same halt among it, and the halt's heading, the template position and the assertion's own source]error calling fail: assertion failed: core/caller-allowlist attachment "allowlist" on "model" writes a network policy, which restricts connections only where the cluster's network plugin enforces network policy; once the target cluster's plugin does, affirm it by setting infra.control_plane_present to true on this attachment in the Release -
Un chiamante il cui carico di lavoro non viene emesso in alcun namespace. Rimuovi l’annotazione
aggrega.ai/namespacedal confineedge, e il Deployment del gateway viene emesso senza alcun namespace:[… omitted: what resolving the lockfile prints, the same halt among it, and the halt's heading, the artifact being rendered, the template position and the template's own source]error calling fail: core/caller-allowlist attachment "allowlist" on "model": "gateway" connects to "model" through its "upstream" socket, but the Deployment "gateway" it renders is emitted into no namespace, so the policy cannot name where its pods run; set aggrega.ai/namespace on the boundary holding "gateway", or on its own entry, in the Release, or have the manifest that carries it write one -
Il carico di lavoro del server di modelli non emesso in alcun namespace, per la stessa ragione: una policy seleziona i pod solo nel proprio namespace.
-
Un carico di lavoro dell’uno o dell’altro che non scrive alcun selettore del controller e non porta nessuna delle etichette di identità che il build applica ai suoi pod — un Job di un chart che si affida al selettore generato dal cluster, per esempio. Selezionarlo in base a ogni etichetta che porta smetterebbe di corrispondere ai suoi pod la prima volta che cambia un’etichetta di versione, quindi il build si ferma invece.
-
Un chiamante, o il server di modelli, il cui rendering non emette alcun pod — uno realizzato da una risorsa personalizzata il cui controller crea i pod in seguito, o raggiunto a un indirizzo esterno al cluster. Un tale componente non può essere nominato in una policy, quindi il build si ferma anziché scrivere una policy che lo rifiuterebbe o non selezionerebbe nulla.
-
Una sorgente in
admitted_sourcesche nomina sia un intervallo di indirizzi sia dei pod, o nessuno dei due.
Dove il compilatore non interpreta
Il compilatore incanala nella policy, come stringhe, i selettori, le etichette e i namespace riportati da ciascun rendering. Non contatta il cluster, non sa quale plugin di rete vi è in esecuzione, e non sa quali carichi di lavoro sono già in esecuzione in un namespace. Ciascun arresto descritto sopra è dichiarato dalle entità proprie del catalogo, nella realizzazione della Feature, e nessuno di essi si basa su alcuna conoscenza del cluster.
Adattarlo
- Ammetti un ingress controller. Aggiungi una voce a
admitted_sourcescon il suo namespace e le etichette dei suoi pod — entrambi in un’unica voce, così vengono ammessi solo quei pod in quel namespace. - Ammetti un intervallo di indirizzi. Aggiungi una voce con
cidr, per esempio10.20.0.0/16. - Un secondo chiamante. Aggiungi un arco
usesda esso al server di modelli nell’Aggregate e collocalo in un namespace che la Release dichiara; il build successivo lo ammette senza alcuna modifica all’associazione. - Compose. La Feature non vi è realizzata: uno stack Compose mette ogni servizio di un gruppo su un’unica rete, e la configurazione di un servizio non può spostarne un altro fuori da essa, quindi una Release che lega questa Feature su Compose si arresta per mancanza di una realizzazione.