Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Informations d’identification sur les connexions — une clé par connexion, et une seule clé aux deux extrémités

Un magasin de mémoire sémantique qui atteint deux modèles et présente une clé différente à chacun, compilé en manifestes Kubernetes. Il lit les contenus ingérés avec un modèle hébergé et les encode avec un serveur d’embeddings qui s’exécute à côté de lui dans le cluster. La clé qu’il présente au modèle hébergé est récupérée depuis un magasin de secrets du cluster. Le serveur d’embeddings vérifie une clé qui lui est propre, et le magasin présente cette même clé — les deux extrémités la lisent dans un seul paramètre, si bien que les deux ne peuvent pas être écrites différemment.

Cet espace de travail n’écrit aucune entité de catalogue qui lui soit propre. Chaque Component, Feature et Recipe qu’il nomme est livré dans le catalogue de la bibliothèque standard ; les fichiers d’ici — trois Aggregates, un Manifest et trois Releases — sont tout ce que quiconque écrit.

Ce qu’il construit

┌── 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)
instanceComponent du cataloguece qu’il est ici
memorycore/datastore/cogneel’appelant : un magasin de mémoire sémantique dont les deux sockets de modèle déclarent chacun un slot credential pour la clé qu’il présente sur cette connexion
llmcore/ai-model/openaiun modèle hébergé, étiqueté component.aggrega.ai/hosting: managed ; atteint en tant que référence, si bien que rien ne s’exécute pour lui dans le cluster
embeddingscore/ai-model/teiText Embeddings Inference dans le cluster, étiqueté self-hosted ; il exige une clé de chaque appelant et la détient dans son propre slot api_key

Trois releases partagent un même Manifest, manifest.yaml, et chacune a un Aggregate qui lui est propre :

releaseAggregatece qu’elle montre
release-matched.yamlaggregate-matched.yamlles deux connexions écrites par le développeur, les deux extrémités de la connexion d’embeddings lisant un seul paramètre
release-mismatched.yamlaggregate-mismatched.yamlla même chose avec les deux extrémités lisant deux paramètres : le build réussit, et la vérification des conventions émet un avis
release-operator-wired.yamlaggregate-operator-wired.yamlla connexion d’extraction laissée à l’opérateur : la Release la câble et nomme sa clé dans infra

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example connection-credentials

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd connection-credentials

Build

Construisez une release par exécution :

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/

Chaque release écrit dans son propre répertoire, si bien que les trois arborescences rendues coexistent et peuvent être comparées entre elles par un diff.

Une release a besoin de son lockfile avant d’être construite, et les lockfiles sont générés plutôt que livrés. Résolvez-en d’abord un, ou laissez le build le remplir :

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

L’espace de travail résout ses entités depuis le registre par défaut que nomme .aggrega-config.yaml, si bien qu’aucun flag --catalog n’est nécessaire.

La commande pull affiche :

[… 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)

et le build, <workspace> désignant le dossier de cet exemple :

[… 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

Les deux autres releases affichent les mêmes lignes, chaque commande pull nommant son propre lockfile et chaque build écrivant huit fichiers. La ligne notice: concerne la Feature d’identification qu’utilise chaque rattachement ici : core/referenced-secret accepte le nom de son secret, origin, depuis les values du développeur ou depuis l’infra de l’opérateur, et l’avis signale qu’une feuille est déclarée dans les deux piliers. Il ne change aucun verdict ni aucun octet rendu ; Features d’identification explique pourquoi la feuille se trouve dans les deux.

Là où cette page affiche ce qu’un build a produit, le bloc est copié d’une exécution réelle — voir Lire la sortie sur ces pages pour la convention et la marque qu’elle utilise pour les lignes omises.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `connection-credentials`, appelez une fois l’outil `scaffold` avec `example` défini sur `connection-credentials` et sans `dir` : il écrit l’exemple dans un nouveau dossier `connection-credentials`. Appelez ensuite l’outil `build` une fois pour chaque Release, dans cet ordre — `release-matched.yaml`, `release-mismatched.yaml`, `release-operator-wired.yaml` — en définissant à chaque fois `workspace_root` sur `connection-credentials`, `release` sur ce fichier, `auto_pull` sur true et `write` sur true. Indiquez-moi les fichiers écrits par chaque build ; ils se trouvent sous `connection-credentials/dist/`.

L’arborescence rendue

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

Un fichier a été apporté par un rattachement plutôt que par la propre Recipe d’un composant : l’ExternalSecret qui récupère la clé que le magasin présente au modèle hébergé. Son nom de fichier porte le composant qui reçoit le rattachement, memory, et le nom du rattachement, llm.credential, écrit llm-zdcredential parce que le point partage une seule chaîne avec le nom propre du fichier ; voir Nommer une ressource rendue. Aucun fichier ne porte la clé d’embeddings : elle se trouve dans un Secret que le namespace détient déjà, comme le montrent les sections ci-dessous.

Quel document a écrit quoi

  • Le catalogue déclare les points de liaison. Le Component du magasin déclare un slot credential sur chacun de ses deux sockets de modèle ; le Component du serveur d’embeddings déclare api_key sur lui-même ; chaque Recipe décide de la variable sous laquelle une clé est livrée.
  • L’Aggregate — le développeur — écrit quels modèles atteint le magasin, les informations d’identification sur chaque connexion, la clé que vérifie le serveur et l’unique paramètre que lisent les deux extrémités de la connexion d’embeddings.
  • Le Manifest — le routage de l’opérateur pour cette cible — décide de ce que devient chaque information d’identification sur Kubernetes : une référence à un Secret que le namespace détient déjà pour chaque rattachement core/referenced-secret, sauf celui de la connexion au modèle hébergé, qui est récupéré depuis un magasin de secrets du cluster.
  • La Release — le document de l’opérateur pour un environnement — remplit les paramètres, place la frontière dans un namespace et, dans la release câblée par l’opérateur, câble la connexion d’extraction et nomme la clé qui y est présentée.

Une clé par connexion

Le magasin atteint deux modèles par deux sockets que déclare son entité de catalogue, extraction_model et embedding_model, et chaque socket déclare un slot credential. La clé que présente le magasin se trouve donc sur la connexion sur laquelle elle est présentée, et chaque connexion porte la sienne. Extrait de 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 }}"

Un rattachement écrit sur une connexion devient l’un des propres rattachements du magasin, nommé d’après l’alias de la connexion, un point et le slot : llm.credential et embeddings.credential. Voici les deux premières et les quatre dernières entrées de l’env du conteneur du magasin, extraites de 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

Les deux premières sont les clés, chacune issue des informations d’identification de sa propre connexion, sous la variable que la Recipe du magasin donne à ce côté — LLM_API_KEY pour l’extraction, EMBEDDING_API_KEY pour l’embedding. Les deux sont des références, et non des valeurs, et le fournisseur helm écrit les entrées qu’il lit depuis un Secret avant les entrées simples. Les quatre dernières proviennent des deux connexions : chaque modèle publie son adresse et son nom de modèle, et la Recipe du magasin les lit par socket.

Le Component du magasin déclare aussi un slot de clé sur lui-même, model_api_key. Sa Recipe ne lit ce slot que pour un socket laissé non câblé, où le magasin atteint un fournisseur à l’adresse propre de ce fournisseur et où aucune connexion ne porte de clé. Les deux sockets sont câblés ici, si bien qu’il n’est pas lu.

Une seule clé aux deux extrémités

Le serveur d’embeddings vérifie une clé. Il détient cette clé dans un slot de son propre Component, api_key, et sa Recipe livre ce qui remplit le slot sous la forme de API_KEY, la variable que Text Embeddings Inference lit au démarrage. Extrait de 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 }}"

C’est un rattachement sur le serveur. La clé que présente le magasin en est un autre, sur la connexion du magasin, montré plus haut. Remplir le slot d’une extrémité ne remplit rien sur l’autre, si bien que déclarer la clé aux deux extrémités est le minimum et non un doublon. Ce qui fait des deux une seule clé, c’est que les deux lisent un même paramètre, embedding_key_secret, que l’Aggregate déclare et que la Release remplit :

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

Le Manifest lie core/referenced-secret à k8s-existing-secret, qui lit origin comme le nom d’un Secret que le namespace détient déjà et ne rend rien. Les deux extrémités référencent donc cet unique Secret. Dans l’env du conteneur du serveur, extrait de dist/matched/helm/embeddings-statefulset.yaml :

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

et dans celui du magasin, extrait de dist/matched/helm/memory-statefulset.yaml :

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

Le Secret est créé en dehors de la Release, par la personne qui la déploie, si bien que le contenu de la clé ne passe jamais par un fichier écrit ni par un artefact rendu.

Pourquoi le serveur ne voit jamais les clés de ses appelants

Un rattachement sur une connexion arrive sur le seul appelant. Les deux informations d’identification du magasin sont des rattachements du magasin : ce qu’elles rendent se trouve à côté du magasin, et le conteneur du magasin y fait référence. Rien de ce qui les concerne n’atteint le composant vers lequel pointe une connexion, si bien qu’une cible est rendue de la même façon quoi que portent les connexions qui l’atteignent.

Le modèle hébergé le montre clairement. Il rend un seul fichier, un Service qui fait correspondre un nom interne au cluster à l’hôte du fournisseur — l’intégralité du spec de dist/matched/helm/llm-service.yaml :

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

La clé que lui présente le magasin est récupérée à côté du magasin, comme le montre la section suivante. Le serveur d’embeddings le montre par comparaison : la release discordante ci-dessous change la clé sur la connexion d’embeddings du magasin et laisse celle du serveur intacte, et les trois fichiers du serveur dans dist/mismatched/ ne diffèrent de ceux de dist/matched/ que par le label aggrega.ai/aggregate-name, qui nomme l’Aggregate à partir duquel chacun a été construit.

Rien dans la configuration du serveur ne nomme donc une clé que détient un appelant. À l’exécution, une requête porte la clé de l’appelant et le serveur la compare à celle qu’il détient ; l’appelant, de son côté, ne lit que ce que publie le serveur : une adresse et un nom de modèle.

Une clé par serveur

Text Embeddings Inference vérifie une seule clé. Chaque appelant présente la même clé, un appelant qui en présente une autre est refusé, et le serveur ne peut pas distinguer un appelant d’un autre, si bien que retirer l’accès à un appelant implique de changer la clé que présente chaque appelant. Quel que soit le nombre de connexions qui l’atteignent, son slot api_key contient une seule clé. Cette limite est propre au serveur, et les core/ai-model/vllm et core/ai-model/tgi du catalogue la partagent. Ce n’est pas une limite de la connexion : un appelant qui atteint plusieurs serveurs détient une clé par connexion, comme le magasin ici en détient deux.

La clé d’une connexion depuis un magasin de secrets

Le Manifest lie chaque rattachement core/referenced-secret par son type, et l’un d’eux par son nom. Extrait de 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 lit origin comme l’entrée du magasin de secrets à récupérer. L’origin de la connexion est le paramètre provider_key_entry, rempli sous la forme ai/openai-api-key, si bien que le rattachement rend un ExternalSecret qu’un opérateur de magasin de secrets du cluster réconcilie en un Secret. L’intégralité du spec de 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"

Le Secret qu’il remplit, memory-llm.credential, est nommé d’après le magasin et la connexion, et c’est le nom que référence plus haut le LLM_API_KEY du magasin. La réalisation lit depuis un ClusterSecretStore nommé platform-secret-store.

Ce que porte un paramètre découle de la réalisation qui le lit : une entrée du magasin de secrets pour la clé du modèle hébergé, le nom d’un Secret pour la clé d’embeddings. La clé d’une connexion reçoit une réalisation qui lui est propre, tandis que chaque autre rattachement du même type conserve celle du type.

Où les deux extrémités résolvent un secret

Une plateforme cible résout un secret par référence à l’intérieur d’une portée de secret : la frontière à l’intérieur de laquelle une ressource peut en nommer une autre. Lorsque les deux extrémités d’une connexion se trouvent dans une même portée, elles référencent toutes deux une même ressource de secret. Lorsqu’elles se trouvent dans des portées différentes, chaque extrémité détient sa propre ressource de secret, réalisée à partir de la même entrée du magasin de secrets. Le Manifest choisit la réalisation de chaque extrémité — par type de Feature pour chaque rattachement de ce type, ou pour un seul rattachement par son nom.

Chaque cible trace la portée dans ses propres termes. Sur Kubernetes, que cible cet espace de travail, c’est le namespace : une charge de travail ne référence un Secret que dans le sien. Chaque release place ici son unique frontière dans un seul namespace, aggrega.ai/namespace: memory, et chaque document rendu le porte — l’en-tête des deux StatefulSets :

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

Les deux extrémités référencent donc l’unique Secret ci-dessus. Avec le serveur d’embeddings dans son propre namespace, le Manifest lie les informations d’identification des deux extrémités par leur nom — api_key et embeddings.credential — à k8s-external-secret, la Release remplit le paramètre avec l’entrée du magasin de secrets, et chaque extrémité détient un ExternalSecret dans son propre namespace, tous deux récupérant cette même entrée. Le magasin atteint alors le serveur d’un namespace à l’autre, ce que couvre cross-boundary-networking. Sur les autres cibles, la portée est un projet Compose, une configuration racine Terraform et une stack CloudFormation ; le Modèle des informations d’identification décrit chacune.

L’opérateur câble une connexion

aggregate-operator-wired.yaml écrit la connexion d’embeddings et laisse non lié le socket extraction_model du magasin : l’entité de catalogue du magasin le déclare, et le développeur le laisse à l’opérateur. La Release le câble au modèle hébergé que déclare l’Aggregate. Extrait de 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

Une Release peut câbler une connexion dans un socket que l’entité de catalogue déclare et que l’Aggregate laisse non lié, vers un composant que l’Aggregate déclare. Elle n’ajoute aucun composant, et ne change jamais la cible d’une connexion écrite par l’Aggregate. Elle n’écrit aucun values, si bien que les informations d’identification de cette connexion nomment leur secret dans infra : core/referenced-secret prend origin dans les values du développeur ou dans l’infra de l’opérateur, exactement l’un des deux, et le build s’arrête sur un rattachement qui porte les deux ou aucun.

Le rattachement est nommé llm.credential exactement comme dans la release concordante, si bien que le niveau des noms du Manifest le lie de la même façon. Outre le label qui nomme l’Aggregate, deux lignes diffèrent entre dist/operator-wired/ et dist/matched/. Le data de l’ExternalSecret :

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

et la référence du magasin au Secret qu’il remplit, dans dist/operator-wired/helm/memory-statefulset.yaml :

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

La clé de données est value plutôt que api-key parce que key est une feuille des values, que seul l’Aggregate écrit, si bien qu’un rattachement que fait la Release seule lit la valeur par défaut de la Feature. La réalisation publie cette clé et le magasin la lit dans ce qui a été publié, si bien que les deux concordent malgré tout.

Le modèle hébergé est étiqueté managed, si bien qu’une connexion qui l’atteint porte des informations d’identification ou indique dans ses propres values que le modèle n’en demande aucune, unauthenticated: true. Cela vaut quel que soit le document qui a écrit la connexion. Retirez le bloc features: de la connexion de la Release et le build s’arrête. L’arrêt est E0033, une assertion en échec du Component du magasin, et son message se termine par la phrase propre à la règle : 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 (la connexion extraction_model llm de « memory » atteint « llm », dont le label component.aggrega.ai/hosting vaut managed, sans informations d’identification : rattachez-en sous credential sur cette connexion, ou définissez unauthenticated: true dans ses values).

Quand les deux extrémités divergent

aggregate-mismatched.yaml donne à la clé du serveur et à la clé du magasin deux paramètres :

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.

L’api_key du serveur lit embedding_key_secret et la connexion du magasin lit memory_embedding_key_secret, que la Release remplit avec deux Secrets différents. Le build réussit et écrit huit fichiers : le compilateur évalue chaque rattachement qu’il reçoit et ne compare rien entre les deux extrémités. Le serveur référence toujours embedding-server-key, et le magasin en présente désormais un autre, extrait de dist/mismatched/helm/memory-statefulset.yaml :

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

Une fois déployé, le serveur n’accepte les requêtes du magasin que si ces deux Secrets contiennent par hasard la même clé.

C’est la vérification des conventions de publication d’une Release qui le détecte :

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)

La même vérification sur la release concordante ne signale rien :

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

et sur la release câblée par l’opérateur, rien non plus.

La règle trouve les deux extrémités par les noms que leur donne le catalogue standard — l’api_key de la cible et la credential de la connexion — et compare l’origin qu’écrit chaque extrémité, tel qu’il est écrit : deux extrémités qui lisent un même paramètre sont égales, et rien n’est résolu. Elle ne cite jamais ni l’un ni l’autre, puisque ce qui y est écrit peut être le secret lui-même. Elle ne juge pas une cible étiquetée managed, dont l’api_key, là où elle en déclare une, est la clé présentée à son fournisseur plutôt qu’une clé que présentent ses appelants ; la connexion vers llm ne donne donc lieu à rien dans aucune des trois releases. Le constat est une recommandation : aggrega lint se termine avec 0, et un espace de travail dont les deux extrémités diffèrent délibérément s’en exclut avec allow_connection_credential_mismatches. Un éditeur qui pose la même question au daemon, aggrega/lint en nommant la Release, reçoit le même constat sous le code connection-credential-matches-target-key et le code court E0329. La règle et ce qu’elle lit sont décrits sous Les règles de discipline.

Déterminisme

Les trois releases se construisent sous --verify-determinism, qui rend chaque nœud deux fois et compare les octets émis :

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

Reconstruire n’importe laquelle des trois à partir d’une arborescence propre reproduit sa sortie rendue octet pour octet.

L’adapter

  • Ajoutez un second appelant du serveur d’embeddings. Les informations d’identification de sa connexion lisent aussi embedding_key_secret. Le serveur détient une seule clé pour tous les appelants, si bien que le second appelant présente la même clé.
  • Récupérez aussi la clé d’embeddings depuis le magasin de secrets. Liez api_key et embeddings.credential par leur nom à k8s-external-secret et remplissez embedding_key_secret avec une entrée du magasin de secrets plutôt qu’avec le nom d’un Secret. Les deux extrémités changent ensemble parce que les deux lisent le paramètre.
  • Atteignez un modèle qui ne vérifie aucune clé. Laissez les informations d’identification hors de la connexion. Lorsque la cible est étiquetée managed, indiquez-le sur la connexion avec unauthenticated: true dans ses values.

Pour partager une clé entre les connexions de plusieurs appelants, voir model-api-key-sharing. Pour un routeur qui détient les clés des fournisseurs pour le compte de ses appelants, voir ai-agent-and-model-router. Le modèle qui sous-tend tout cela est le Modèle des informations d’identification.