Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Zugangsdaten an Verbindungen — ein Schlüssel pro Verbindung und ein einziger Schlüssel an beiden Enden

Ein Store für semantisches Gedächtnis, der zwei Modelle erreicht und jedem einen anderen Schlüssel vorlegt, kompiliert zu Kubernetes-Manifesten. Er liest aufgenommenes Material mit einem gehosteten Modell und kodiert es mit einem Embedding-Server, der neben ihm im Cluster läuft. Der Schlüssel, den er dem gehosteten Modell vorlegt, wird aus einem Secret-Store des Clusters abgerufen. Der Embedding-Server prüft einen eigenen Schlüssel, und der Store legt genau diesen Schlüssel vor — beide Enden lesen ihn aus einem einzigen Parameter, sodass die beiden nicht unterschiedlich geschrieben werden können.

Dieser Workspace verfasst keine eigene Katalogentität. Jede Component, jedes Feature und jedes Recipe, die er nennt, wird im Katalog der Standardbibliothek mitgeliefert; die Dateien hier — drei Aggregates, ein Manifest und drei Releases — sind alles, was irgendjemand schreibt.

Was es baut

┌── extraction_model ──► llm a hosted model API
│ key on the connection, fetched from a secret store
memory ───┤
│
└── embedding_model ──► embeddings an embedding server that checks a key
key on the connection ═══ the server's own api_key
(both read one parameter)
InstanzKatalog-Componentwas es hier ist
memorycore/datastore/cogneeder Aufrufer: ein Store für semantisches Gedächtnis, dessen zwei Modell-Sockets jeweils einen Slot credential für den Schlüssel deklarieren, den er an dieser Verbindung vorlegt
llmcore/ai-model/openaiein gehostetes Modell, gekennzeichnet mit component.aggrega.ai/hosting: managed; als Referenz erreicht, daher läuft dafür nichts im Cluster
embeddingscore/ai-model/teiText Embeddings Inference im Cluster, gekennzeichnet mit self-hosted; es verlangt von jedem Aufrufer einen Schlüssel und hält ihn in seinem eigenen Slot api_key

Drei Releases teilen sich ein Manifest, manifest.yaml, und jedes hat ein eigenes Aggregate:

ReleaseAggregatewas es zeigt
release-matched.yamlaggregate-matched.yamlbeide Verbindungen vom Entwickler geschrieben, die beiden Enden der Embedding-Verbindung lesen einen einzigen Parameter
release-mismatched.yamlaggregate-mismatched.yamldasselbe, wobei die beiden Enden zwei Parameter lesen: Der Build gelingt, und die Konventionsprüfung gibt einen Hinweis aus
release-operator-wired.yamlaggregate-operator-wired.yamldie Extraktionsverbindung dem Operator überlassen: Das Release verdrahtet sie und nennt ihren Schlüssel in infra

Das Beispiel generieren

Sie können dieses Beispiel mit den folgenden Befehlen bauen oder es von Ihrem KI-Assistenten für Sie bauen lassen.

Schreiben Sie das Beispiel in einen neuen Ordner, der nach ihm benannt ist:

Terminal window
aggrega scaffold --example connection-credentials

Danach gibt er die als Nächstes auszuführenden Befehle aus. Der erste wechselt in den neuen Ordner:

Terminal window
cd connection-credentials

Build

Bauen Sie pro Lauf ein Release:

Terminal window
aggrega build --release release-matched.yaml --auto-pull # → dist/matched/
aggrega build --release release-mismatched.yaml --auto-pull # → dist/mismatched/
aggrega build --release release-operator-wired.yaml --auto-pull # → dist/operator-wired/

Jedes Release schreibt in sein eigenes Verzeichnis, sodass die drei gerenderten Bäume nebeneinander bestehen und gegeneinander gedifft werden können.

Ein Release braucht sein Lockfile, bevor es gebaut wird, und Lockfiles werden erzeugt statt mitgeliefert. Lösen Sie zuerst eines auf, oder lassen Sie es vom Build befüllen:

Terminal window
aggrega pull --release release-matched.yaml # resolve, then build normally
aggrega build --release release-matched.yaml --auto-pull # or resolve during the build

Der Workspace löst seine Entitäten aus der Standard-Registry auf, die .aggrega-config.yaml nennt, daher ist kein Flag --catalog nötig.

Der Pull-Befehl gibt aus:

[… omitted: a warning that the declared-sensitive origin of llm.credential reaches the target with no per-key sensitivity marking, because its realization maps it through a valuesMapping]
Pull complete: release-matched.lock (entities=15, source_artifacts=0, external_inputs=0)

und der Build, wobei <workspace> für den Ordner dieses Beispiels steht:

[… omitted: the same warning about llm.credential the pull printed]
notice: LINT: Feature "core/referenced-secret" at core/referenced-secret:1.0.0 declares property "origin" in both values: and infra: pillars (path: origin)
[… omitted: a total build time, which differs per run]
Build completed: 8 files written to <workspace>/dist

Die beiden anderen Releases geben dieselben Zeilen aus, wobei jeder Pull-Befehl sein eigenes Lockfile nennt und jeder Build acht Dateien schreibt. Die Zeile notice: betrifft das Zugangsdaten-Feature, das jede Anbindung hier verwendet: core/referenced-secret nimmt den Namen seines Geheimnisses, origin, entweder aus den values des Entwicklers oder aus der infra des Operators an, und der Hinweis meldet, dass ein Blatt in beiden Säulen deklariert ist. Er ändert kein Urteil und kein gerendertes Byte; Zugangsdaten-Features erklärt, warum das Blatt in beiden steht.

Wo diese Seite ausgibt, was ein Build erzeugt hat, ist der Block aus einem echten Lauf kopiert — siehe Die Ausgabe auf diesen Seiten lesen für die Konvention und die Markierung, die sie für ausgelassene Zeilen verwendet.

Mit einem KI-Assistenten

Ein KI-Assistent, der mit den Tools von Aggrega eingerichtet ist, kann dasselbe tun: Fügen Sie ihm diesen Prompt ein.

Verwenden Sie ausschließlich die Aggrega-Tools und legen Sie selbst keinen Ordner an. Wenn der Arbeitsbereichsordner noch keinen Ordner `connection-credentials` enthält, rufen Sie das Tool `scaffold` einmal mit `example` auf `connection-credentials` gesetzt und ohne `dir` auf: Es schreibt das Beispiel in einen neuen Ordner `connection-credentials`. Rufen Sie dann das Tool `build` einmal für jedes Release auf, in dieser Reihenfolge — `release-matched.yaml`, `release-mismatched.yaml`, `release-operator-wired.yaml` — jedes Mal mit `workspace_root` auf `connection-credentials`, `release` auf diese Datei, `auto_pull` auf true und `write` auf true gesetzt. Nennen Sie mir die Dateien, die jeder Build geschrieben hat; sie liegen unter `connection-credentials/dist/`.

Der gerenderte Baum

dist/matched/helm/
├── embeddings-default-service.yaml
├── embeddings-headless-service.yaml
├── embeddings-statefulset.yaml
├── llm-service.yaml
├── memory--llm-zdcredential--memory-externalsecret-memory-memory-llm-credential.yaml
├── memory-default-service.yaml
├── memory-headless-service.yaml
└── memory-statefulset.yaml

Eine Datei wurde von einer Anbindung mitgebracht statt vom eigenen Recipe einer Komponente: das ExternalSecret, das den Schlüssel abruft, den der Store dem gehosteten Modell vorlegt. Ihr Dateiname trägt die Komponente, an die die Anbindung angebunden ist, memory, und den Namen der Anbindung, llm.credential, geschrieben als llm-zdcredential, weil der Punkt sich einen String mit dem eigenen Namen der Datei teilt; siehe Eine gerenderte Ressource benennen. Keine Datei trägt den Embedding-Schlüssel: Er liegt in einem Secret, das der Namespace bereits hält, wie die folgenden Abschnitte zeigen.

Welches Dokument was geschrieben hat

  • Der Katalog deklariert die Bindungspunkte. Die Component des Stores deklariert an jedem ihrer zwei Modell-Sockets einen Slot credential; die Component des Embedding-Servers deklariert api_key an sich selbst; jedes Recipe entscheidet, als welche Variable ein Schlüssel zugestellt wird.
  • Das Aggregate — der Entwickler — schreibt, welche Modelle der Store erreicht, die Zugangsdaten an jeder Verbindung, den Schlüssel, den der Server prüft, und den einen Parameter, den beide Enden der Embedding-Verbindung lesen.
  • Das Manifest — das Routing des Operators für dieses Ziel — entscheidet, was aus den Zugangsdaten jeweils auf Kubernetes wird: eine Referenz auf ein Secret, das der Namespace bereits hält, für jede Anbindung core/referenced-secret, außer der an der Verbindung zum gehosteten Modell, die aus einem Secret-Store des Clusters abgerufen wird.
  • Das Release — das Dokument des Operators für eine Umgebung — erfüllt die Parameter, platziert die Boundary in einem Namespace und verdrahtet im vom Operator verdrahteten Release die Extraktionsverbindung und nennt den Schlüssel, der an ihr vorgelegt wird.

Ein Schlüssel pro Verbindung

Der Store erreicht zwei Modelle über zwei Sockets, die seine Katalogentität deklariert, extraction_model und embedding_model, und jeder Socket deklariert einen Slot credential. Der Schlüssel, den der Store vorlegt, sitzt also an der Verbindung, an der er vorgelegt wird, und jede Verbindung trägt ihren eigenen. Aus aggregate-matched.yaml:

memory:
type: core/datastore/cognee
values:
# The width of the vectors the embedding model above returns.
embedding_dimensions: 384
uses:
extraction_model:
llm:
target: llm
features:
credential: # the key presented to the hosted model
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.provider_key_entry }}"
embedding_model:
embeddings:
target: embeddings
features:
credential: # the key presented to the embedding server
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.embedding_key_secret }}"

Eine an einer Verbindung geschriebene Anbindung wird zu einer der eigenen Anbindungen des Stores, benannt nach dem Alias der Verbindung, einem Punkt und dem Slot: llm.credential und embeddings.credential. Hier sind die ersten zwei und die letzten vier Einträge der env des Containers des Stores, aus dist/matched/helm/memory-statefulset.yaml:

- name: LLM_API_KEY
valueFrom:
secretKeyRef:
name: memory-llm.credential
key: api-key
- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key
[… omitted: the store's own settings, HTTP_PORT to EMBEDDING_DIMENSIONS]
- name: EMBEDDING_ENDPOINT
value: http://embeddings-default:8080/v1
- name: EMBEDDING_MODEL
value: BAAI/bge-small-en-v1.5
- name: LLM_ENDPOINT
value: https://api.openai.com/v1
- name: LLM_MODEL
value: gpt-4o-mini

Die ersten beiden sind die Schlüssel, jeder aus den Zugangsdaten an seiner eigenen Verbindung, unter der Variable, die das Recipe des Stores dieser Seite gibt — LLM_API_KEY für die Extraktion, EMBEDDING_API_KEY für das Embedding. Beide sind Referenzen, keine Werte, und der Provider helm schreibt die Einträge, die er aus einem Secret liest, vor die einfachen. Die letzten vier stammen von den beiden Verbindungen: Jedes Modell veröffentlicht seine Adresse und seinen Modellnamen, und das Recipe des Stores liest sie pro Socket.

Die Component des Stores deklariert außerdem einen Schlüssel-Slot an sich selbst, model_api_key. Ihr Recipe liest diesen Slot nur für einen unverdrahtet gelassenen Socket, bei dem der Store einen Provider unter dessen eigener Adresse erreicht und es keine Verbindung gibt, die einen Schlüssel tragen könnte. Hier sind beide Sockets verdrahtet, daher wird er nicht gelesen.

Ein einziger Schlüssel an beiden Enden

Der Embedding-Server prüft einen Schlüssel. Er hält diesen Schlüssel in einem Slot seiner eigenen Component, api_key, und sein Recipe stellt alles, was den Slot füllt, als API_KEY zu, die Variable, die Text Embeddings Inference beim Start liest. Aus aggregate-matched.yaml:

embeddings:
type: core/ai-model/tei
values:
model: BAAI/bge-small-en-v1.5
features:
api_key: # the key the server verifies
type: core/referenced-secret
values:
key: api-key
origin: "{{ .parameters.embedding_key_secret }}"

Das ist eine Anbindung am Server. Der Schlüssel, den der Store vorlegt, ist eine weitere Anbindung, an der Verbindung des Stores, oben gezeigt. Den Slot des einen Endes zu füllen, füllt am anderen nichts, daher ist es das Minimum und keine Verdopplung, den Schlüssel an beiden Enden zu deklarieren. Was die beiden zu einem einzigen Schlüssel macht, ist, dass beide einen Parameter lesen, embedding_key_secret, den das Aggregate deklariert und das Release erfüllt:

parameters:
provider_key_entry: ai/openai-api-key
embedding_key_secret: embedding-server-key

Das Manifest bindet core/referenced-secret an k8s-existing-secret, das origin als Namen eines Secrets liest, das der Namespace bereits hält, und nichts rendert. Beide Enden referenzieren also dieses eine Secret. In der env des Containers des Servers, aus dist/matched/helm/embeddings-statefulset.yaml:

- name: API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key

und in der des Stores, aus dist/matched/helm/memory-statefulset.yaml:

- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-server-key
key: api-key

Das Secret wird außerhalb des Release erstellt, von demjenigen, der es bereitstellt, sodass das Material des Schlüssels nie eine verfasste Datei oder ein gerendertes Artefakt durchläuft.

Warum der Server die Schlüssel seiner Aufrufer nie sieht

Eine Anbindung an einer Verbindung landet allein beim Aufrufer. Die beiden Sätze Zugangsdaten des Stores sind Anbindungen des Stores: Was sie rendern, liegt neben dem Store, und der Container des Stores referenziert es. Nichts davon erreicht die Komponente, auf die eine Verbindung zeigt, sodass ein Ziel gleich gerendert wird, was auch immer die Verbindungen tragen, die es erreichen.

Das gehostete Modell zeigt es deutlich. Es rendert eine Datei, einen Service, der einen clusterinternen Namen auf den Host des Providers abbildet — die gesamte spec von dist/matched/helm/llm-service.yaml:

spec:
type: ExternalName
externalName: api.openai.com
ports:
- port: 443

Der Schlüssel, den der Store ihm vorlegt, wird neben dem Store abgerufen, wie der nächste Abschnitt zeigt. Der Embedding-Server zeigt es im Vergleich: Das nicht übereinstimmende Release unten ändert den Schlüssel an der Embedding-Verbindung des Stores und lässt den des Servers unverändert, und die drei Dateien des Servers in dist/mismatched/ unterscheiden sich von denen in dist/matched/ nur im Label aggrega.ai/aggregate-name, das das Aggregate nennt, aus dem jede gebaut wurde.

Nichts in der Konfiguration des Servers nennt also einen Schlüssel, den ein Aufrufer hält. Zur Laufzeit trägt eine Anfrage den Schlüssel des Aufrufers, und der Server vergleicht ihn mit dem, den er hält; der Aufrufer seinerseits liest nur, was der Server veröffentlicht: eine Adresse und einen Modellnamen.

Ein Schlüssel pro Server

Text Embeddings Inference prüft einen einzigen Schlüssel. Jeder Aufrufer legt denselben Schlüssel vor, ein Aufrufer, der einen anderen vorlegt, wird abgewiesen, und der Server kann einen Aufrufer nicht vom anderen unterscheiden, daher bedeutet der Entzug des Zugriffs eines Aufrufers, den Schlüssel zu ändern, den jeder Aufrufer vorlegt. Wie viele Verbindungen ihn auch erreichen, sein Slot api_key hält einen einzigen Schlüssel. Diese Grenze ist die des Servers selbst, und core/ai-model/vllm und core/ai-model/tgi des Katalogs teilen sie. Sie ist keine Grenze der Verbindung: Ein Aufrufer, der mehrere Server erreicht, hält einen Schlüssel pro Verbindung, so wie der Store hier zwei hält.

Der Schlüssel einer Verbindung aus einem Secret-Store

Das Manifest bindet jede Anbindung core/referenced-secret über ihren Typ und eine davon über ihren Namen. Aus manifest.yaml:

features:
# One realization for every core/referenced-secret attachment: the Secret
# already exists in the namespace, and origin is its name.
type:
core/referenced-secret:1.0.0: helm/k8s-existing-secret:1.0.0
# One attachment bound differently, by its name. An attachment written on
# a connection is named for the connection's alias, a dot and the slot,
# so the memory store's credential on its llm connection is
# llm.credential. That key is fetched from the store, and origin is the
# store entry to fetch.
name:
llm.credential: helm/k8s-external-secret:1.0.0

k8s-external-secret liest origin als den abzurufenden Eintrag im Secret-Store. Das origin der Verbindung ist der Parameter provider_key_entry, erfüllt als ai/openai-api-key, daher rendert die Anbindung ein ExternalSecret, das ein Secret-Store-Operator im Cluster zu einem Secret abgleicht. Die gesamte spec von dist/matched/helm/memory--llm-zdcredential--memory-externalsecret-memory-memory-llm-credential.yaml:

spec:
refreshInterval: "1h"
secretStoreRef:
name: platform-secret-store
kind: ClusterSecretStore
target:
name: memory-llm.credential
creationPolicy: Owner
data:
- secretKey: api-key
remoteRef:
key: "ai/openai-api-key"

Das Secret, das es befüllt, memory-llm.credential, ist nach dem Store und der Verbindung benannt, und es ist der Name, den LLM_API_KEY des Stores oben referenziert. Die Realisierung liest aus einem ClusterSecretStore namens platform-secret-store.

Was ein Parameter trägt, folgt aus der Realisierung, die ihn liest: ein Eintrag im Secret-Store für den Schlüssel des gehosteten Modells, der Name eines Secrets für den Embedding-Schlüssel. Der Schlüssel einer Verbindung erhält eine eigene Realisierung, während jede andere Anbindung desselben Typs die des Typs behält.

Wo die beiden Enden ein Geheimnis auflösen

Eine Zielplattform löst ein Geheimnis per Referenz innerhalb eines Secret-Bereichs auf: der Grenze, innerhalb derer eine Ressource eine andere benennen kann. Wo beide Enden einer Verbindung in einem Bereich liegen, referenzieren beide eine einzige Secret-Ressource. Wo sie in verschiedenen Bereichen liegen, hält jedes Ende eine eigene Secret-Ressource, realisiert aus demselben Eintrag im Secret-Store. Das Manifest wählt die Realisierung jedes Endes — nach Feature-Typ für jede Anbindung dieses Typs oder für eine einzelne Anbindung über ihren Namen.

Jedes Ziel zieht den Bereich nach seinen eigenen Begriffen. Auf Kubernetes, für das dieser Workspace baut, ist es der Namespace: Eine Arbeitslast referenziert ein Secret nur in ihrem eigenen. Jedes Release hier platziert seine eine Boundary in einem Namespace, aggrega.ai/namespace: memory, und jedes gerenderte Dokument trägt ihn — der Kopf beider StatefulSets:

dist/matched/helm/memory-statefulset.yaml
metadata:
name: memory
namespace: memory
# dist/matched/helm/embeddings-statefulset.yaml
metadata:
name: embeddings
namespace: memory

Beide Enden referenzieren also das eine Secret oben. Mit dem Embedding-Server in einem eigenen Namespace bindet das Manifest die Zugangsdaten beider Enden über ihren Namen — api_key und embeddings.credential — an k8s-external-secret, das Release erfüllt den Parameter mit dem Eintrag im Secret-Store, und jedes Ende hält ein ExternalSecret in seinem eigenen Namespace, die beide diesen einen Eintrag abrufen. Der Store erreicht den Server dann über Namespaces hinweg, was cross-boundary-networking behandelt. Auf den anderen Zielen ist der Bereich ein Compose-Projekt, eine Terraform-Root-Konfiguration und ein CloudFormation-Stack; das Zugangsdatenmodell beschreibt jeden davon.

Der Operator verdrahtet eine Verbindung

aggregate-operator-wired.yaml schreibt die Embedding-Verbindung und lässt den Socket extraction_model des Stores ungebunden: Die Katalogentität des Stores deklariert ihn, und der Entwickler überlässt ihn dem Operator. Das Release verdrahtet ihn mit dem gehosteten Modell, das das Aggregate deklariert. Aus release-operator-wired.yaml:

memory:
uses:
# A connection the Aggregate does not write, into a socket the
# store's catalog entity declares, to a component the Aggregate
# declares. A Release writes no values, so the credential on it
# names its secret in infra.
extraction_model:
llm:
target: llm
features:
credential:
type: core/referenced-secret
infra:
origin: ai/openai-api-key

Ein Release darf eine Verbindung in einen Socket verdrahten, den die Katalogentität deklariert und das Aggregate ungebunden lässt, zu einer Komponente, die das Aggregate deklariert. Es fügt keine Komponente hinzu und ändert nie das Ziel einer Verbindung, die das Aggregate geschrieben hat. Es schreibt keine values, daher nennen die Zugangsdaten an dieser Verbindung ihr Geheimnis in infra: core/referenced-secret nimmt origin aus den values des Entwicklers oder aus der infra des Operators, genau aus einem der beiden, und der Build bricht bei einer Anbindung ab, die beides oder keines von beiden trägt.

Die Anbindung heißt llm.credential, genau wie im übereinstimmenden Release, sodass die Namensstufe des Manifests sie auf dieselbe Weise bindet. Neben dem Label, das das Aggregate nennt, unterscheiden sich zwei Zeilen zwischen dist/operator-wired/ und dist/matched/. Die data des ExternalSecret:

data:
- secretKey: value
remoteRef:
key: "ai/openai-api-key"

und die Referenz des Stores auf das Secret, das es befüllt, in dist/operator-wired/helm/memory-statefulset.yaml:

- name: LLM_API_KEY
valueFrom:
secretKeyRef:
name: memory-llm.credential
key: value

Der Datenschlüssel ist value statt api-key, weil key ein Blatt der values ist, die nur das Aggregate schreibt, sodass eine Anbindung, die das Release allein vornimmt, den Standardwert des Features liest. Die Realisierung veröffentlicht diesen Schlüssel, und der Store liest ihn aus dem Veröffentlichten, sodass die beiden dennoch übereinstimmen.

Das gehostete Modell ist mit managed gekennzeichnet, daher trägt eine Verbindung, die es erreicht, Zugangsdaten oder gibt in ihren eigenen values an, dass das Modell keine benötigt, unauthenticated: true. Das gilt unabhängig davon, welches Dokument die Verbindung geschrieben hat. Entfernen Sie den Block features: aus der Verbindung des Release, und der Build bricht ab. Der Abbruch ist E0033, eine fehlgeschlagene Assertion der Component des Stores, und seine Meldung endet mit dem eigenen Satz der Regel: the extraction_model connection llm of “memory” reaches “llm”, whose component.aggrega.ai/hosting label is managed, with no credential: attach one under credential on that connection, or set unauthenticated: true in its values (die extraction_model-Verbindung llm von „memory“ erreicht „llm“, dessen Label component.aggrega.ai/hosting managed ist, ohne Zugangsdaten: Binden Sie welche unter credential an dieser Verbindung an, oder setzen Sie unauthenticated: true in ihren values).

Wenn die beiden Enden nicht übereinstimmen

aggregate-mismatched.yaml gibt dem Schlüssel des Servers und dem Schlüssel des Stores zwei Parameter:

parameters:
provider_key_entry:
type: string
description: >
The store entry holding the key the memory store presents to the hosted
model provider.
embedding_key_secret:
type: string
description: The Secret holding the key the embedding server verifies.
# The fault: a second parameter for what is meant to be the same key.
memory_embedding_key_secret:
type: string
description: The Secret holding the key the memory store presents to the embedding server.

Der api_key des Servers liest embedding_key_secret, und die Verbindung des Stores liest memory_embedding_key_secret, die das Release mit zwei verschiedenen Secrets erfüllt. Der Build gelingt und schreibt acht Dateien: Der Compiler wertet jede Anbindung aus, die er erhält, und vergleicht nichts zwischen den beiden Enden. Der Server referenziert weiterhin embedding-server-key, und der Store legt nun einen anderen vor, aus dist/mismatched/helm/memory-statefulset.yaml:

- name: EMBEDDING_API_KEY
valueFrom:
secretKeyRef:
name: embedding-client-key
key: api-key

Nach der Bereitstellung nimmt der Server die Anfragen des Stores nur an, wenn diese beiden Secrets zufällig denselben Schlüssel enthalten.

Die Prüfung der Veröffentlichungskonventionen eines Release ist die Stelle, an der dies erkannt wird:

Terminal window
aggrega lint --release release-mismatched.yaml
release-mismatched.yaml:
warn: E0329 connection-credential-matches-target-key: connection "embeddings" on socket "embedding_model" of component "memory" carries a credential in its credential slot and its target "embeddings" holds a key in its api_key slot, but the two ends write their secret's locator differently, so they may name different secrets and the target would refuse the key this caller presents. The locators are compared as written, and neither is shown here. Reading one parameter at both ends keeps them one key; that agreement is the standard-catalog convention, and the build does not check it.
conventions checked: 10 entities, 1 advisory finding(s)

Dieselbe Prüfung über das übereinstimmende Release meldet nichts:

Terminal window
aggrega lint --release release-matched.yaml
conventions checked: 10 entities, 0 advisory finding(s)

und über das vom Operator verdrahtete Release ebenfalls nichts.

Die Regel findet die beiden Enden über die Namen, die ihnen der Standardkatalog gibt — den api_key des Ziels und die credential der Verbindung — und vergleicht das origin, das jedes Ende schreibt, so wie es geschrieben ist: Zwei Enden, die einen Parameter lesen, gelten als gleich, und nichts wird aufgelöst. Sie zitiert keines von beiden, da das dort Geschriebene das Geheimnis selbst sein kann. Sie beurteilt kein mit managed gekennzeichnetes Ziel, dessen api_key, wo es einen deklariert, der Schlüssel ist, der seinem Anbieter vorgelegt wird, und nicht einer, den seine Aufrufer vorlegen; daher löst die Verbindung zu llm in keinem der drei Releases etwas aus. Der Befund ist eine Empfehlung: aggrega lint endet mit 0, und ein Workspace, dessen zwei Enden absichtlich voneinander abweichen, schließt sich mit allow_connection_credential_mismatches aus. Ein Editor, der dem Daemon dieselbe Frage stellt, aggrega/lint mit dem Namen des Release, erhält denselben Befund unter dem Code connection-credential-matches-target-key und dem Kurzcode E0329. Die Regel und was sie liest, werden unter Die Disziplinregeln beschrieben.

Determinismus

Alle drei Releases werden mit --verify-determinism gebaut, das jeden Knoten zweimal rendert und die ausgegebenen Bytes vergleicht:

Terminal window
aggrega build --release release-matched.yaml --verify-determinism

Ein Neubau eines der drei aus einem sauberen Baum reproduziert seine gerenderte Ausgabe Byte für Byte.

Anpassen

  • Fügen Sie einen zweiten Aufrufer des Embedding-Servers hinzu. Die Zugangsdaten seiner Verbindung lesen ebenfalls embedding_key_secret. Der Server hält einen einzigen Schlüssel für alle Aufrufer, daher legt der zweite Aufrufer denselben Schlüssel vor.
  • Rufen Sie auch den Embedding-Schlüssel aus dem Secret-Store ab. Binden Sie api_key und embeddings.credential über ihren Namen an k8s-external-secret und erfüllen Sie embedding_key_secret mit einem Eintrag im Secret-Store statt mit dem Namen eines Secrets. Beide Enden ändern sich gemeinsam, weil beide den Parameter lesen.
  • Erreichen Sie ein Modell, das keinen Schlüssel prüft. Lassen Sie die Zugangsdaten an der Verbindung weg. Wo das Ziel mit managed gekennzeichnet ist, geben Sie das an der Verbindung mit unauthenticated: true in ihren values an.

Zum Teilen eines Schlüssels über die Verbindungen mehrerer Aufrufer siehe model-api-key-sharing. Für einen Router, der die Provider-Schlüssel im Namen seiner Aufrufer hält, siehe ai-agent-and-model-router. Das Modell hinter alldem ist das Zugangsdatenmodell.