Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

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)
instancjaencja Component z kataloguczym jest tutaj
memorycore/datastore/cogneewywołujący: magazyn pamięci semantycznej, którego oba gniazda modeli deklarują slot credential na klucz przedstawiany w danym połączeniu
llmcore/ai-model/openaimodel hostowany, oznaczony etykietą component.aggrega.ai/hosting: managed; osiągany jako odwołanie, więc nic nie działa dla niego w klastrze
embeddingscore/ai-model/teiText 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:

wydanieAggregateco pokazuje
release-matched.yamlaggregate-matched.yamloba połączenia zapisane przez programistę, oba końce połączenia z serwerem embeddingów odczytują jeden parametr
release-mismatched.yamlaggregate-mismatched.yamlto samo, ale oba końce odczytują dwa parametry: budowanie się udaje, a sprawdzenie konwencji zgłasza poradę
release-operator-wired.yamlaggregate-operator-wired.yamlpołą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:

Terminal window
aggrega scaffold --example connection-credentials

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu:

Terminal window
cd connection-credentials

Kompilacja

W jednym uruchomieniu buduje się jedno wydanie:

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/

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:

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

Obszar 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>/dist

Pozostał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.yaml

Jeden 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 credential na każdym z dwóch gniazd modeli; encja Component serwera embeddingów deklaruje api_key na 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-mini

Dwa 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-key

Encja 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-key

a w kontenerze magazynu, z dist/matched/helm/memory-statefulset.yaml:

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

Obiekt 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: 443

Klucz, 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.0

k8s-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:

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

Zatem 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-key

Encja 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: value

Kluczem 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-key

Po 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:

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)

To samo sprawdzenie dla dopasowanego wydania nie zgłasza niczego:

Terminal window
aggrega lint --release release-matched.yaml
conventions 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:

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

Ponowne 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_key i embeddings.credential po nazwie z k8s-external-secret oraz wypełnić embedding_key_secret wpisem 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 przez unauthenticated: true w jego values.

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ń.