Poświadczenia na połączeniach — klucz dla każdego połączenia i jeden klucz na obu końcach
Magazyn pamięci semantycznej, który łączy się z dwoma modelami i każdemu przedstawia inny klucz, skompilowany do manifestów Kubernetes. Odczytuje pobrany materiał za pomocą hostowanego modelu i koduje go za pomocą serwera embeddingów działającego obok niego w klastrze. Klucz, który przedstawia hostowanemu modelowi, jest pobierany z magazynu sekretów klastra. Serwer embeddingów sprawdza własny klucz, a magazyn przedstawia ten sam klucz — oba końce odczytują go z jednego parametru, więc tych dwóch wartości nie da się zapisać rozbieżnie.
Ten obszar roboczy nie definiuje żadnej własnej encji katalogowej. Każda encja Component, Feature i Recipe, którą wymienia, jest dostarczana w katalogu biblioteki standardowej; pliki tutaj — trzy encje Aggregates, jedna encja Manifest i trzy encje Releases — to wszystko, co ktokolwiek pisze.
Co powstaje
┌── 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)| instancja | encja Component z katalogu | czym jest tutaj |
|---|---|---|
memory | core/datastore/cognee | wywołujący: magazyn pamięci semantycznej, którego oba gniazda modeli deklarują slot credential na klucz przedstawiany w danym połączeniu |
llm | core/ai-model/openai | model hostowany, oznaczony etykietą component.aggrega.ai/hosting: managed; osiągany jako odwołanie, więc nic nie działa dla niego w klastrze |
embeddings | core/ai-model/tei | Text Embeddings Inference w klastrze, oznaczony etykietą self-hosted; wymaga klucza od każdego wywołującego i przechowuje go we własnym slocie api_key |
Trzy wydania współdzielą jedną encję Manifest, manifest.yaml, a każde ma własną encję Aggregate:
| wydanie | Aggregate | co pokazuje |
|---|---|---|
release-matched.yaml | aggregate-matched.yaml | oba połączenia zapisane przez programistę, oba końce połączenia z serwerem embeddingów odczytują jeden parametr |
release-mismatched.yaml | aggregate-mismatched.yaml | to samo, ale oba końce odczytują dwa parametry: budowanie się udaje, a sprawdzenie konwencji zgłasza poradę |
release-operator-wired.yaml | aggregate-operator-wired.yaml | połączenie ekstrakcji pozostawione operatorowi: encja Release je podłącza i nazywa jego klucz w infra |
Generowanie przykładu
Ten przykład można zbudować za pomocą poniższych poleceń albo zlecić jego zbudowanie asystentowi AI.
Należy zapisać przykład w nowym folderze nazwanym tak jak on:
aggrega scaffold --example connection-credentialsNastępnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu:
cd connection-credentialsKompilacja
W jednym uruchomieniu buduje się jedno wydanie:
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/Każde wydanie zapisuje do własnego katalogu, więc trzy wyrenderowane drzewa współistnieją i można je porównywać ze sobą.
Wydanie potrzebuje pliku blokady, zanim zostanie zbudowane, a pliki blokady są generowane, a nie dostarczane. Należy najpierw go rozwiązać albo pozwolić, by uzupełniła go kompilacja:
aggrega pull --release release-matched.yaml # resolve, then build normallyaggrega build --release release-matched.yaml --auto-pull # or resolve during the buildObszar roboczy rozwiązuje swoje encje z domyślnego rejestru wskazanego w .aggrega-config.yaml, więc flaga --catalog nie jest potrzebna.
Pobieranie wypisuje:
[… 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)a kompilacja, gdzie <workspace> oznacza folder tego przykładu:
[… 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>/distPozostałe dwa wydania wypisują te same wiersze: każde pobieranie podaje własny
plik blokady, a każda kompilacja zapisuje osiem plików. Wiersz notice:
dotyczy encji Feature poświadczeń, której używa tu każde dołączenie:
core/referenced-secret przyjmuje nazwę swojego sekretu, origin, albo z
values dewelopera, albo z infra operatora, a komunikat doradczy informuje,
że jeden liść jest zadeklarowany w obu filarach. Nie zmienia on żadnego werdyktu ani żadnego
wyrenderowanego bajtu; Credential Features
wyjaśnia, dlaczego liść znajduje się w obu.
Tam, gdzie ta strona pokazuje wynik kompilacji, blok jest skopiowany z rzeczywistego uruchomienia — zob. Czytanie wyników na tych stronach, gdzie opisano konwencję i znacznik oznaczający pominięte wiersze.
Z asystentem AI
Asystent AI skonfigurowany z narzędziami Aggrega może zrobić to samo: wystarczy wkleić mu ten prompt.
Używaj wyłącznie narzędzi Aggrega i nie twórz samodzielnie żadnego folderu. Jeśli folder obszaru roboczego nie zawiera jeszcze folderu `connection-credentials`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `connection-credentials` i bez `dir`: zapisuje ono przykład w nowym folderze `connection-credentials`. Następnie wywołaj narzędzie `build` raz dla każdej encji Release, w tej kolejności — `release-matched.yaml`, `release-mismatched.yaml`, `release-operator-wired.yaml` — za każdym razem z `workspace_root` ustawionym na `connection-credentials`, `release` ustawionym na ten plik, `auto_pull` ustawionym na true i `write` ustawionym na true. Podaj mi, które pliki zapisała każda kompilacja; znajdują się w `connection-credentials/dist/`.Wyrenderowane drzewo
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.yamlJeden plik pochodzi z załącznika, a nie z własnej encji Recipe komponentu:
ExternalSecret, który pobiera klucz przedstawiany przez magazyn hostowanemu
modelowi. Jego nazwa pliku zawiera komponent, do którego jest dołączony, memory, oraz
nazwę załącznika, llm.credential, zapisaną jako llm-zdcredential, ponieważ
kropka dzieli jeden ciąg znaków z własną nazwą pliku; zob.
Nazywanie wyrenderowanego zasobu.
Żaden plik nie zawiera klucza osadzania: znajduje się on w obiekcie Secret, który przestrzeń nazw już
posiada, co pokazują poniższe sekcje.
Który dokument co zapisał
- Katalog deklaruje punkty powiązania. Encja Component magazynu deklaruje
slot
credentialna każdym z dwóch gniazd modeli; encja Component serwera embeddingów deklarujeapi_keyna sobie samej; każdy Recipe decyduje, jako jaka zmienna dostarczany jest klucz. - Aggregate — programista — zapisuje, do których modeli sięga magazyn, poświadczenie na każdym połączeniu, klucz weryfikowany przez serwer oraz jedyny parametr odczytywany przez oba końce połączenia embeddingów.
- Manifest — routing operatora dla tego celu — decyduje, czym staje się
każde poświadczenie w Kubernetes: odwołaniem do obiektu Secret, który
przestrzeń nazw już zawiera, dla każdego załącznika
core/referenced-secret, z wyjątkiem tego na połączeniu z hostowanym modelem, który jest pobierany z klastrowego magazynu sekretów. - Release — dokument operatora dla jednego środowiska — wypełnia parametry, umieszcza granicę w przestrzeni nazw, a w wydaniu okablowanym przez operatora okablowuje połączenie ekstrakcji i wskazuje klucz na nim prezentowany.
Klucz na każde połączenie
Magazyn łączy się z dwoma modelami przez dwa gniazda, które deklaruje jego encja katalogowa,
extraction_model i embedding_model, a każde gniazdo deklaruje slot
credential. Klucz, który magazyn przedstawia, znajduje się więc na połączeniu, na którym jest
przedstawiany, i każde połączenie niesie własny. Z pliku
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 }}"Załącznik zapisany na połączeniu staje się jednym z własnych załączników magazynu,
nazwanym aliasem połączenia, kropką i nazwą slotu:
llm.credential i embeddings.credential. Oto dwa pierwsze i
cztery ostatnie wpisy env kontenera magazynu, z pliku
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-miniDwa pierwsze to klucze, każdy z poświadczenia na własnym połączeniu,
pod zmienną, którą encja Recipe magazynu nadaje danej stronie — LLM_API_KEY dla
ekstrakcji, EMBEDDING_API_KEY dla embeddingu. Oba są odwołaniami, a nie
wartościami, a dostawca helm zapisuje wpisy odczytywane z obiektu Secret przed
zwykłymi. Cztery ostatnie pochodzą z dwóch połączeń: każdy model
publikuje swój adres i nazwę modelu, a encja Recipe magazynu odczytuje je
osobno dla każdego gniazda.
Encja Component magazynu deklaruje też slot klucza na sobie samej, model_api_key. Jej
encja Recipe odczytuje ten slot tylko dla gniazda pozostawionego bez połączenia, gdy magazyn łączy się
z dostawcą pod własnym adresem dostawcy i nie ma połączenia, które mogłoby nieść
klucz. Tutaj oba gniazda są połączone, więc slot nie jest odczytywany.
Jeden klucz na obu końcach
Serwer embeddingów sprawdza klucz. Przechowuje ten klucz w slocie własnej encji
Component, api_key, a jego Recipe dostarcza to, co wypełnia ten slot, jako
API_KEY — zmienną, którą Text Embeddings Inference odczytuje przy starcie. Z pliku
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 }}"To jest jeden załącznik na serwerze. Klucz, który przedstawia magazyn, to inny załącznik,
na połączeniu magazynu, pokazany wyżej. Wypełnienie slotu na jednym końcu nie wypełnia niczego
na drugim, więc zadeklarowanie klucza na obu końcach jest minimum, a nie
duplikatem. To, że oba pozostają jednym kluczem, wynika z tego, że oba odczytują jeden parametr,
embedding_key_secret, który deklaruje encja Aggregate, a spełnia encja Release:
parameters: provider_key_entry: ai/openai-api-key embedding_key_secret: embedding-server-keyEncja Manifest wiąże core/referenced-secret z k8s-existing-secret, który
odczytuje origin jako nazwę obiektu Secret, który przestrzeń nazw już zawiera, i nie renderuje
niczego. Dzięki temu oba końce odwołują się do tego jednego obiektu Secret. W env kontenera serwera,
z pliku dist/matched/helm/embeddings-statefulset.yaml:
- name: API_KEY valueFrom: secretKeyRef: name: embedding-server-key key: api-keya w kontenerze magazynu, z dist/matched/helm/memory-statefulset.yaml:
- name: EMBEDDING_API_KEY valueFrom: secretKeyRef: name: embedding-server-key key: api-keyObiekt Secret jest tworzony poza encją Release, przez tego, kto ją wdraża, więc materiał klucza nigdy nie przechodzi przez plik autorski ani wyrenderowany artefakt.
Dlaczego serwer nigdy nie widzi kluczy swoich wywołujących
Załącznik na połączeniu trafia wyłącznie do strony wywołującej. Dwa poświadczenia magazynu są załącznikami magazynu: to, co renderują, znajduje się obok magazynu, a kontener magazynu się do tego odwołuje. Nic z nich nie dociera do komponentu, na który wskazuje połączenie, więc cel renderuje się tak samo bez względu na to, co niosą docierające do niego połączenia.
Wyraźnie widać to na hostowanym modelu. Renderuje on jeden plik, Service mapujący
nazwę wewnątrzklastrową na host dostawcy — oto cały spec z
dist/matched/helm/llm-service.yaml:
spec: type: ExternalName externalName: api.openai.com ports: - port: 443Klucz, który magazyn mu przedstawia, jest pobierany obok magazynu, co pokazuje następna
sekcja. Serwer embeddingów pokazuje to przez porównanie: niedopasowane
wydanie poniżej zmienia klucz na połączeniu magazynu z serwerem embeddingów i pozostawia
klucz serwera bez zmian, a trzy pliki serwera w dist/mismatched/ różnią się
od tych w dist/matched/ tylko etykietą aggrega.ai/aggregate-name,
która wskazuje encję Aggregate, z której każdy z nich zbudowano.
Zatem nic w konfiguracji serwera nie wskazuje klucza, który posiada wywołujący. W czasie działania żądanie niesie klucz wywołującego, a serwer porównuje go z kluczem, który sam posiada; wywołujący ze swojej strony odczytuje tylko to, co serwer publikuje: adres i nazwę modelu.
Jeden klucz na serwer
Text Embeddings Inference sprawdza jeden klucz. Każdy wywołujący przedstawia ten sam klucz,
wywołujący przedstawiający jakikolwiek inny zostaje odrzucony, a serwer nie potrafi odróżnić jednego
wywołującego od drugiego, więc odebranie dostępu jednemu wywołującemu oznacza zmianę klucza,
który przedstawia każdy wywołujący. Niezależnie od tego, ile połączeń do niego dociera, jego slot api_key
przechowuje jeden klucz. To ograniczenie jest własnym ograniczeniem serwera i dzielą je również
core/ai-model/vllm oraz core/ai-model/tgi z katalogu. Nie jest to ograniczenie
połączenia: wywołujący, który łączy się z kilkoma serwerami, przechowuje jeden klucz na połączenie,
tak jak magazyn w tym przykładzie przechowuje dwa.
Klucz jednego połączenia z magazynu sekretów
Manifest wiąże każde dołączenie core/referenced-secret według jego typu,
a jedno z nich według jego nazwy. Z pliku 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.0k8s-external-secret odczytuje origin jako wpis magazynu do pobrania.
origin tego połączenia to parametr provider_key_entry, wypełniony wartością
ai/openai-api-key, więc dołączenie renderuje zasób ExternalSecret, który
operator magazynu sekretów w klastrze uzgadnia do postaci Secret. Cała sekcja spec
pliku
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"Secret, który wypełnia, memory-llm.credential, nosi nazwę od magazynu i
połączenia i jest to nazwa, do której odwołuje się powyżej LLM_API_KEY magazynu.
Realizacja odczytuje dane z ClusterSecretStore o nazwie platform-secret-store.
To, co przenosi parametr, wynika z realizacji, która go odczytuje: wpis magazynu w przypadku klucza hostowanego modelu, nazwa Secret w przypadku klucza embeddingów. Klucz jednego połączenia otrzymuje własną realizację, podczas gdy każde inne dołączenie tego samego typu zachowuje realizację tego typu.
Gdzie oba końce rozwiązują sekret
Platforma docelowa rozwiązuje sekret przez odwołanie w obrębie zakresu sekretów: granicy, w której jeden zasób może wskazać inny po nazwie. Gdy oba końce połączenia znajdują się w jednym zakresie, oba odwołują się do jednego zasobu sekretu. Gdy znajdują się w różnych zakresach, każdy koniec ma własny zasób sekretu, zrealizowany z tego samego wpisu w magazynie. Manifest wybiera realizację dla każdego końca — według typu Feature dla każdego załącznika tego typu albo dla jednego załącznika według jego nazwy.
Każda platforma docelowa wyznacza zakres na swój sposób. W Kubernetes, dla którego budowany jest ten obszar roboczy, jest nim przestrzeń nazw: obciążenie może odwołać się do obiektu Secret tylko we własnej przestrzeni nazw. Każde wydanie umieszcza tu swoją jedyną granicę w jednej przestrzeni nazw, aggrega.ai/namespace: memory, i każdy wyrenderowany dokument ją zawiera — nagłówek obu obiektów StatefulSet:
metadata: name: memory namespace: memory
# dist/matched/helm/embeddings-statefulset.yamlmetadata: name: embeddings namespace: memoryZatem oba końce odwołują się do jednego obiektu Secret pokazanego wyżej. Gdyby serwer embeddingów znajdował się we własnej przestrzeni nazw, Manifest powiązałby poświadczenia obu końców według nazwy — api_key i embeddings.credential — z k8s-external-secret, encja Release wypełniłaby parametr wpisem z magazynu, a każdy koniec miałby ExternalSecret we własnej przestrzeni nazw, przy czym oba pobierałyby ten sam wpis. Magazyn sięga wtedy do serwera między przestrzeniami nazw, co opisuje cross-boundary-networking. Na pozostałych platformach docelowych zakresem jest projekt Compose, główna konfiguracja Terraform i stos CloudFormation; każdy z nich opisuje Model poświadczeń.
Operator łączy połączenie
aggregate-operator-wired.yaml zapisuje połączenie do serwera embeddingów i pozostawia
gniazdo extraction_model magazynu niepowiązane: deklaruje je encja katalogowa magazynu,
a deweloper pozostawia je operatorowi. Encja Release łączy je z
hostowanym modelem, który deklaruje encja Aggregate. Z pliku 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-keyEncja Release może podłączyć połączenie do gniazda, które deklaruje encja katalogowa, a
encja Aggregate pozostawia niepowiązane, z komponentem deklarowanym przez encję Aggregate. Nie dodaje
żadnego komponentu i nigdy nie przekierowuje połączenia zapisanego przez encję Aggregate. Nie zapisuje
values, więc poświadczenie na tym połączeniu wskazuje swój sekret w infra:
core/referenced-secret pobiera origin z values dewelopera albo z
infra operatora, dokładnie z jednego z nich, a kompilacja zatrzymuje się na
załączniku, który zawiera oba albo żadne.
Załącznik nosi nazwę llm.credential dokładnie tak jak w dopasowanym wydaniu, więc
poziom nazw encji Manifest wiąże go w ten sam sposób. Oprócz etykiety wskazującej
encję Aggregate dwa wiersze różnią się między dist/operator-wired/ a
dist/matched/. Pole data zasobu ExternalSecret:
data: - secretKey: value remoteRef: key: "ai/openai-api-key"oraz odwołanie magazynu do wypełnianego przez niego zasobu Secret, w pliku
dist/operator-wired/helm/memory-statefulset.yaml:
- name: LLM_API_KEY valueFrom: secretKeyRef: name: memory-llm.credential key: valueKluczem danych jest value, a nie api-key, ponieważ key jest liściem values,
który zapisuje wyłącznie encja Aggregate, więc załącznik utworzony przez samą encję Release
odczytuje wartość domyślną encji Feature. Realizacja publikuje ten klucz, a magazyn
odczytuje go z tego, co opublikowano, więc obie strony nadal są zgodne.
Hostowany model ma etykietę managed, więc połączenie, które do niego prowadzi, zawiera
poświadczenie albo deklaruje we własnych values, że model go nie wymaga:
unauthenticated: true. Obowiązuje to niezależnie od tego, który dokument zapisał połączenie.
Po usunięciu bloku features: z połączenia w encji Release kompilacja
się zatrzymuje. Zatrzymanie to E0033, nieudana asercja encji Component magazynu, a
jej komunikat kończy się zdaniem samej reguły: 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 (połączenie extraction_model llm magazynu „memory” prowadzi do „llm”, którego etykieta component.aggrega.ai/hosting ma wartość managed, bez poświadczenia: należy dołączyć je pod credential na tym połączeniu albo ustawić unauthenticated: true w jego values).
Gdy oba końce się nie zgadzają
aggregate-mismatched.yaml przypisuje kluczowi serwera i kluczowi magazynu dwa
osobne parametry:
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.api_key serwera odczytuje embedding_key_secret, a połączenie magazynu
odczytuje memory_embedding_key_secret, które encja Release wypełnia dwoma
różnymi obiektami Secret. Budowanie kończy się powodzeniem i zapisuje osiem plików: kompilator
ocenia każde przekazane mu dołączenie i niczego nie porównuje między oboma
końcami. Serwer nadal odwołuje się do embedding-server-key, a magazyn przedstawia
teraz inny, z dist/mismatched/helm/memory-statefulset.yaml:
- name: EMBEDDING_API_KEY valueFrom: secretKeyRef: name: embedding-client-key key: api-keyPo wdrożeniu serwer przyjmuje żądania magazynu tylko wtedy, gdy oba te obiekty Secret przypadkiem zawierają ten sam klucz.
Wychwytuje to sprawdzenie konwencji publikowania w encji Release:
aggrega lint --release release-mismatched.yamlrelease-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)To samo sprawdzenie dla dopasowanego wydania nie zgłasza niczego:
aggrega lint --release release-matched.yamlconventions checked: 10 entities, 0 advisory finding(s)a dla wydania z połączeniem wpiętym przez operatora również niczego.
Reguła odnajduje oba końce po nazwach nadanych im przez standardowy katalog —
api_key celu i credential połączenia — i porównuje
origin zapisany na każdym końcu, tak jak został zapisany: dwa końce odczytujące jeden parametr są
równe i nic nie jest rozwiązywane. Nigdy nie cytuje żadnego z nich, ponieważ to, co tam zapisano,
może być samym sekretem. Nie ocenia celu oznaczonego etykietą managed,
którego api_key, jeśli go deklaruje, jest kluczem przedstawianym jego dostawcy,
a nie kluczem przedstawianym przez wywołujących; dlatego połączenie z llm nie wywołuje niczego
w żadnym z trzech wydań. Wynik ma charakter porady: aggrega lint kończy się kodem 0,
a przestrzeń robocza, której oba końce celowo się różnią, rezygnuje z reguły za pomocą
allow_connection_credential_mismatches. Edytor zadający demonowi to samo
pytanie, aggrega/lint ze wskazaniem encji Release, otrzymuje ten sam wynik pod
kodem connection-credential-matches-target-key i krótkim kodem E0329.
Regułę i to, co odczytuje, opisano w sekcji
Reguły dyscypliny.
Determinizm
Wszystkie trzy wydania budują się z --verify-determinism, co renderuje każdy
węzeł dwukrotnie i porównuje wyemitowane bajty:
aggrega build --release release-matched.yaml --verify-determinismPonowne zbudowanie dowolnego z trzech wydań z czystego drzewa odtwarza jego wyrenderowane wyjście bajt po bajcie.
Dostosowywanie przykładu
- Dodanie drugiego wywołującego serwera osadzeń. Poświadczenie jego połączenia
również odczytuje
embedding_key_secret. Serwer przechowuje jeden klucz dla wszystkich wywołujących, więc drugi wywołujący przedstawia ten sam klucz. - Pobieranie z magazynu również klucza osadzeń. Należy powiązać
api_keyiembeddings.credentialpo nazwie zk8s-external-secretoraz wypełnićembedding_key_secretwpisem z magazynu zamiast nazwy obiektu Secret. Oba końce zmieniają się razem, ponieważ oba odczytują ten parametr. - Łączenie z modelem, który nie sprawdza klucza. Należy pominąć poświadczenie w
połączeniu. Jeśli cel ma etykietę
managed, należy to zaznaczyć w połączeniu przezunauthenticated: truew jegovalues.
Współdzielenie jednego klucza przez połączenia kilku wywołujących opisuje model-api-key-sharing. Router przechowujący klucze dostawców w imieniu wywołujących opisuje ai-agent-and-model-router. Model leżący u podstaw całości to model poświadczeń.