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

aggrega push

aggrega push publikuje encję katalogu w rejestrze OCI, skąd inne przestrzenie robocze mogą ją rozwiązać za pomocą aggrega pull.

Działanie

aggrega push odczytuje pojedynczy plik YAML encji, pakuje go do transportu i wypycha pod adres <registry>/<kind>/<metadata.name>:<metadata.version>, przy czym ścieżka repozytorium jest zapisywana małymi literami; encja Recipe lub FeatureRecipe dodaje swoje spec.capability, a encja Plugin swoje metadata.pluginType, jako segment między rodzajem a nazwą. Polecenie aggrega push --list-kinds wypisuje rodzaje encji, które publikuje zainstalowany plik binarny — po jednym rodzaju w wierszu, posortowane i nic poza tym, dzięki czemu skrypt może odczytać wynik bezpośrednio. Zbiór obejmuje rodzaje encji do tworzenia katalogu wraz z encją Aggregate, czyli modułem wielokrotnego użytku, oraz encją Plugin, czyli adresowanym treścią odwołaniem do artefaktu WebAssembly, który kompilator przekazuje dalej, a środowisko uruchomieniowe wykonuje. Encja Plugin jest strukturalnym artefaktem do publikacji, a nie rodzajem encji do tworzenia katalogu. Możliwość publikacji jest właściwością encji, a nie sposobu jej użycia: encję Aggregate można opublikować niezależnie od tego, czy później jest wskazywana jako spec.aggregate najwyższego poziomu encji Release, czy zagnieżdżona w bloku aggregates: innej encji Aggregate. Encje Release i Manifest są danymi wejściowymi po stronie wdrożenia, a nie artefaktami katalogu, i są odrzucane.

Pakowanie

Wypchnięcie publikuje dokument encji oraz pliki, które sama encja wskazuje obok niego — i nic więcej z jej katalogu. Pliki wskazywane przez encję to:

  • dla encji Recipe lub FeatureRecipe jej lokalne source: — katalog trafia do publikacji z każdym plikiem, który zachowują reguły ignorowania zapisane w jej entity.lock, jak opisuje Które pliki są dostarczane z encją; każdy plik importowany przez wpisy valuesMapping:, workload: i artifacts: za pomocą $import:; oraz entity.lock obok niej;
  • dla encji Component lub Feature każdy plik schematu importowany za pomocą $import: przez jej spec.schema, filar lub gniazdo usesSchema, łącznie z każdym plikiem, który z kolei importuje plik zaimportowany.

Encje Aggregate, Plugin oraz rodzaje bibliotek nie wskazują żadnych plików obok swojego dokumentu. Notatka, README, pliki innej encji lub wynik kompilacji znajdujące się w katalogu nie są publikowane, niezależnie od nazwy. Dowiązanie symboliczne wśród plików wskazywanych przez encję jest odrzucane, a nie śledzone — A symbolic link sits among the files an entity carries (Wśród plików encji znajduje się dowiązanie symboliczne) — podobnie jak ścieżka wskazywana przez encję poprzez katalog będący dowiązaniem prowadzącym poza katalog encji, zanim cokolwiek zostanie spakowane — A path names content outside the entity’s own directory (Ścieżka wskazuje treść spoza katalogu encji).

Z tego wynika kształt publikacji. Encja, która niczego nie wskazuje, jest publikowana jako jej dokument, bez zmian, z typem mediów +yaml swojego rodzaju. Encja wskazująca plik jest publikowana jako .tar.gz zawierający dokument i te pliki na ich miejscach w katalogu, z typem mediów +tar+gz swojego rodzaju. Zatem encja Recipe, której cała treść jest wbudowana, jest publikowana jako jej dokument, a encja Component, której schemat jest importowany z pliku, jest publikowana jako archiwum. Catalog and Registry §6 wymienia oba typy mediów dla każdego rodzaju.

Każdy plik w archiwum ma tryb 0644 i nie ma znacznika czasu, niezależnie od bitów uprawnień na dysku. Checkout zapisuje pliki z własnymi bitami uprawnień, a system, który nie zapisuje bitu wykonywania, pobiera jako zwykły plik to, co inny system pobiera jako wykonywalne, więc archiwum nie zawiera trybu odczytanego z dysku: dwa checkouty jednego commita publikują te same pliki niezależnie od umask i systemu, na którym powstały, a przełączenie bitu wykonywania skryptu nie zmienia niczego w publikacji.

Wypchnięcie ostrzega o każdym wpisie archiwum, którego Windows nie może przechować w zapisanej postaci — o ścieżce z częścią nazwaną jak urządzenie, np. CON, AUX lub NUL, w dowolnej wielkości liter i z dowolnym rozszerzeniem, jak aux/x.yaml, lub o części kończącej się kropką lub spacją, jak report.. W systemie Windows aggrega odmawia rozpakowania takiego wpisu, więc obszar roboczy w Windows nie może użyć tej wersji. Ostrzeżenie jest wypisywane na standardowe wyjście błędów na każdej platformie, po jednym wierszu na wpis, przed własnym raportem publikacji; nazwa pliku dokumentu encji jest oceniana razem z plikami, które wskazuje, a encja, która niczego nie wskazuje, jest publikowana jako sam dokument i nigdy nie wywołuje ostrzeżenia. Ostrzeżenie niczego nie odrzuca: wypchnięcie przebiega lub jest odrzucane dokładnie tak, jak bez niego, a --dry-run ostrzega w ten sam sposób. A published archive carries an entry Windows cannot use (Opublikowane archiwum zawiera wpis, którego Windows nie może użyć) pokazuje ten wiersz i sposób postępowania.

Lokalne source: zapisane jako szablon przenosi cały katalog. Szablon taki jak ./charts/{{ .values.flavour }} wskazuje katalog dopiero wtedy, gdy wypełni go encja Release, więc żadna publikacja nie może ustalić, który to będzie katalog. Taka encja przenosi każdy plik ze swojego katalogu, który zachowują zapisane reguły ignorowania — nigdy jej .aggregaignore, którego reguły są przenoszone w locku — a wypchnięcie informuje o tym pod pozostałymi faktami:

carries: every file in the entity's directory, because its source "./charts/{{ .values.flavour }}" is a template and the directory it names is decided by each Release that uses it

To, co nie jest wskazane, nie jest przenoszone, a dowiaduje się o tym konsument. Plik, na którym encja polega, nie wskazując go w jednym z powyższych pól, nie znajduje się w publikacji, a kompilacja u konsumenta kończy się błędem wskazującym brakującą ścieżkę w jego slocie pamięci podręcznej — a nie wypchnięcie. Należy wskazać każdy plik potrzebny encji w jednym z tych pól.

Każdy opublikowany plik jest nazwany w manifeście artefaktu, więc ogólny klient OCI, taki jak oras, zapisuje go do pliku o tej nazwie: entity.yaml dla encji opublikowanej jako jej dokument, entity.tar.gz dla encji opublikowanej z plikami, a dla encji Plugin entity.yaml dla encji obok entity.wasm dla jej pliku wykonywalnego. Nazwa wynika z typu mediów, a nie z pliku, z którego następuje publikacja, więc ta sama treść opublikowana z pliku o zmienionej nazwie daje ten sam artefakt. Catalog and Registry §6 wymienia każdy publikowany kształt i plik, jako który trafia.

Zdalny URL source: w encji Recipe (odwołanie do chartu OCI, URL chartu lub fragmentu HTTPS, moduł Git) jest zachowywany dosłownie w opublikowanym YAML; nie jest pobierany ani dołączany do artefaktu. Konsumenci rozwiązują i przypinają zdalne źródła niezależnie, w chwili własnego pobrania. Dzięki temu dystrybucja encji katalogu i rozwiązywanie artefaktów źródłowych pozostają odrębnymi kwestiami.

Encja Aggregate jest publikowana jako jej własny pojedynczy dokument: podagregat, do którego odwołuje się w aggregates:, nie jest dołączany do artefaktu. Każdy podagregat to osobno opublikowana encja Aggregate, którą konsumenci rozwiązują i przypinają niezależnie w chwili pobrania, według tożsamości — to ta sama zasada rozdzielenia dystrybucji, która dotyczy zdalnych źródeł.

Jedna encja na katalog

Archiwum zawiera plik encji wśród plików, które ona wskazuje, więc przy rozpakowywaniu encję trzeba odnaleźć ponownie. Konsument odnajduje ją po preambule, którą zawiera: encją jest dokument na początku pakietu, którego kind: jest rodzajem encji podlegającym publikacji. Plik, w którym encja jest napisana, może mieć dowolną nazwę — recipe.yaml to konwencja katalogu, a nie wymóg — a fragment compose, szablon chartu czy manifest Kubernetes leżący obok encji nie zostanie z nią pomylony, ponieważ deklarują one coś innego albo nie deklarują żadnego rodzaju. Dokumenty encji położone niżej, wewnątrz drzewa source/, są treścią dostarczaną przez encję, a nie samą encją, i nigdy nie są brane pod uwagę.

Push odrzuca encję, która dzieli katalog z inną encją. Każdy rodzaj ma własny katalog, z wyjątkiem Aggregate, Release i Manifest, które katalog główny przestrzeni roboczej przechowuje obok siebie. Dla każdego innego rodzaju push sprawdza, zanim zrobi z encją cokolwiek innego — przed krokiem przypinania, polityką podpisywania i pakietem — czy w tym samym katalogu nie znajduje się żaden inny dokument encji, a w przeciwnym razie odmawia, wymieniając każdą przeszkadzającą encję, niezależnie od tego, czy push miał przypinać. aggrega pin odrzuca taki katalog tymi samymi słowami; zatrzymanie to An entity shares its directory with another entity (Encja dzieli katalog z inną encją). Dokument niebędący żadnym rodzajem encji obok encji — plik chartu, fragment compose, README — nie przeszkadza, podobnie jak nic w podkatalogu. Każdy dokument obok encji jest odczytywany wyłącznie z wnętrza przestrzeni roboczej, a w przypadku encji wskazanej poza nią — z wnętrza własnego katalogu encji, więc dokument będący dowiązaniem prowadzącym na zewnątrz zatrzymuje push, który wskazuje to dowiązanie bez jego odczytania, jak opisuje granica przestrzeni roboczej.

Ta zasada sprawia, że jeden entity.lock należy do jednej encji: nazwa pliku blokady jest taka sama dla każdej encji, więc dwie encje napisane w jednym katalogu dzieliłyby jedyną blokadę, na którą jest w nim miejsce. Jest ona sprawdzana tylko wtedy, gdy z katalogu coś jest wytwarzane, więc katalog zawierający kilka encji nadal się ładuje, przechodzi lint i buduje.

Nazwa katalogu nie jest oceniana. Encja sama w swoim katalogu publikuje się w wersji metadata.version niezależnie od położenia tego katalogu; <name>/<version>/, układ stosowany przez katalog biblioteki standardowej, jest konwencją. Artefakt opublikowany przez innego klienta z katalogu zawierającego dwie encje nadal jest odczytywany bezpiecznie: jego pull zatrzymuje się, wskazując oba dokumenty, zamiast zwrócić którykolwiek z nich, co skatalogowano w errors/fatal-halts.md.

Odczyt encji przed jej spakowaniem

Polecenie push odczytuje encję Component, Feature, Recipe lub FeatureRecipe w taki sam sposób, jak odczytuje ją kompilacja, i odrzuca encję, którą ten odczyt odrzuca — z tego samego powodu, pod tym samym krótkim kodem, zanim zostanie zbudowany pakiet i zanim nastąpi połączenie z docelowym rejestrem. Dlatego dokument niezgodny ze schematem swojego rodzaju, ścieżka wskazująca treść poza własnym katalogiem encji oraz schemat importowany przez encję Component lub Feature za pomocą $import:, którego brakuje lub którego nie można użyć, są odrzucane przy publikacji, zamiast zostać opublikowane. Każdy z tych przypadków to encja, którą odrzuciłaby pierwsza kompilacja u jej odbiorców; ścieżka wychodząca poza katalog wskazuje ponadto plik, który nie trafiłby do publikacji razem z encją, ponieważ każdy plik niesiony przez publikację pochodzi z własnego katalogu encji — zob. A path names content outside the entity’s own directory (Ścieżka wskazuje treść poza własnym katalogiem encji).

Encja Recipe lub FeatureRecipe jest odczytywana w ten sposób podczas porównywania jej przypięć, opisanego w następnej sekcji, więc odczyt następuje niezależnie od tego, czy push ma przypinać, i niezależnie od tego, czy encja ma cokolwiek do przypięcia. Każdy z czterech rodzajów jest też odczytywany w ten sposób bezpośrednio przed zbudowaniem jego pakietu, ponieważ to właśnie ten odczyt określa, jakie pliki encja wskazuje. Encja Aggregate i biblioteka nie wskazują żadnych plików i nie są odczytywane w ten sposób. Encja Plugin również nie wskazuje żadnego pliku i jest sprawdzana względem schematu swojego rodzaju przed odczytem jej pliku .wasm, jak opisuje sekcja Publikowanie encji Plugin.

Publikowanie encji Plugin

Encja Plugin jest publikowana razem ze swoim plikiem .wasm, wskazanym przez --plugin, a push ocenia oba, zanim zostaną opublikowane jakiekolwiek bajty lub nastąpi kontakt z rejestrem. --dry-run ocenia je dokładnie tak samo jak publikacja.

Najpierw encja jest odczytywana względem schematu swojego rodzaju, tak jak odczytuje ją ładowanie katalogu, zanim zostanie odczytany plik .wasm. Dlatego metadata.version, które nie jest wersją semantyczną — na przykład sam commit, taki jak 415148e — jest odrzucane z powodu warunku samego schematu, ze wskazaniem pola; tak samo odrzucane jest każde inne odstępstwo od schematu, na przykład brak spec.abiVersion. O tym, co jest tu wersją semantyczną, decyduje wzorzec samego schematu dla metadata.version; push nie dodaje żadnej własnej reguły.

Następnie plik .wasm jest ładowany i porównywany z encją. To, co zgłasza jako oferowane, musi zgadzać się z tym, co deklaruje encja, zestaw poleceń i funkcje hosta zapisane w encji muszą do niego pasować, a wersja, którą zgłasza dla własnej kompilacji, musi być równa metadata.version — zob. A Plugin entity’s recorded version does not match the plugin (Wersja zapisana w encji Plugin nie zgadza się z pluginem).

Plik .wasm zbudowany z drzewa roboczego z niezatwierdzonymi zmianami jest odrzucany. Taka kompilacja ma znacznik -dirty na końcu zgłaszanej wersji — 1.0.0-dirty, 1.0.0-3-g1a2b3c4-dirty. Jest to poprawna wersja semantyczna, ale wskazuje commit, który nie zawiera tego, co zostało zbudowane, więc nikt nie mógłby odtworzyć opublikowanej zawartości na podstawie wersji, pod którą ją opublikowano. Push ją odrzuca, podając wersję i sposób naprawy: należy zbudować plugin z czystego checkoutu commitu wskazanego przez tag wydania, tak aby zgłaszał samą wersję wydania — a aby wydać zmianę, należy najpierw zatwierdzić ją z metadata.version encji ustawionym na nowe wydanie i otagować ten commit — zamiast kopiować do encji wersję zgłaszaną przez ponowną kompilację. Zarówno wersja deweloperska zbudowana z commitu, taka jak 1.0.0-3-g1a2b3c4, jak i wersja przedpremierowa, taka jak 1.0.0-rc.1, zostają opublikowane. Odmowa to A plugin was built from a working tree with uncommitted changes (Plugin został zbudowany z drzewa roboczego z niezatwierdzonymi zmianami).

Przypinanie przed publikacją

Encja Recipe lub FeatureRecipe przechowuje przypięcia wejść, które odczytuje — zdalnego source: zapisanego w pełni, pliku importowanego przez wpis artifacts, plików source: leżących obok niej — w pliku entity.lock znajdującym się obok niej, a push publikuje ten plik razem z encją. Przypinanie to krok uruchamiany przed publikacją, aggrega pin, po którym należy zatwierdzić (commit) zapisaną przez niego blokadę.

Push odrzuca encję, której blokada nie zapisuje tych przypięć. Przed zbudowaniem pakietu push ustala, co krok przypinania zapisałby dla encji, i porównuje to z plikiem entity.lock leżącym obok niej. Jeśli brakuje przypięcia lub blokada zawiera przypięcie, któremu wejście już nie odpowiada, push zatrzymuje się, zanim zostanie zbudowane jakiekolwiek archiwum lub nawiązany kontakt z jakimkolwiek rejestrem. Odmowa podaje encję i każde takie wejście — każde jako remote source, imported file lub local source file — oraz to, co należy uruchomić: aggrega pin na encji, --pin-sources w właśnie uruchomionym pushu lub pin_sources_at_push dla każdego pushu w obszarze roboczym. Jest to ta sama odmowa, którą zgłasza pull wobec tej samej blokady, An entity reads an input the lock beside it records no pin for (Encja odczytuje wejście, dla którego blokada obok niej nie zapisuje przypięcia), z własnymi środkami zaradczymi pushu. Dlatego encja Recipe lub FeatureRecipe publikowana przez push zawiera w swoim pakiecie blokadę zapisującą każde przypięcie, które krok zapisałby w chwili publikacji.

Dwa rodzaje encji nie mają nic do przypięcia i są publikowane bez zmian: encja, która nie odczytuje żadnego zdalnego źródła, nie importuje żadnego pliku i nie wskazuje żadnego lokalnego źródła, oraz encja Recipe, której współrzędne zdalnego źródła są wypełniane z szablonu. Takie źródło wskazuje artefakt dopiero wtedy, gdy encja Release wypełni szablon, więc jego przypięcie należy do pliku blokady każdej encji Release, a push nie wymaga go obok encji. Encja Component, Feature, biblioteka, encja Aggregate ani Plugin nie odczytuje niczego, co zapisuje blokada, i nigdy nie jest tu odrzucana.

Porównanie przypięcia zdalnego źródła oznacza pobranie źródła, tak jak robi to aggrega pin, ponieważ przypięcie, które już nie pasuje, jest widoczne tylko w zestawieniu z tym, co źródło udostępnia obecnie. Push encji z takim źródłem łączy się więc z hostem źródła, zanim połączy się z rejestrem. Porównanie odczytuje encję Recipe lub FeatureRecipe tak samo jak krok przypinania, przez katalog, więc encja, której katalog odmawia odczytania — na przykład dokument niezgodny ze schematem swojego rodzaju — jest tu odrzucana z powodem podanym przez katalog.

Jeśli nie znaleziono obszaru roboczego i żaden nie został wskazany, push, który pobrałby zdalne źródło do porównania, jest odrzucany przed jego pobraniem, tak jak aggrega pin. Porównanie pobiera każde zdalne źródło zapisane przez encję w pełni do pamięci podręcznej artefaktów, dokładnie tak jak krok przypinania, a pamięć podręczna zapisana w folderze, z którego nie znaleziono obszaru roboczego, uczyniłaby ten folder obszarem roboczym. Dlatego gdy nic nie wskazuje katalogu głównego i nic go nie wyznacza — z folderu, w którym uruchamiany jest push, lub, dla encji wskazanej ścieżką bezwzględną, z folderu samej encji — push encji Recipe lub FeatureRecipe z takim źródłem zatrzymuje się przed pobraniem źródła, także w trybie dry run i z --pin-sources, i podaje źródło, folder oraz dwa wyjścia: wskazać obszar roboczy za pomocą --workspace-root lub AGGREGA_WORKSPACE_ROOT albo umieścić w tym folderze plik .aggrega-config.yaml z blokiem workspace:. Dla dwóch powyższych rodzajów encji ani dla encji z lokalnym źródłem porównanie niczego nie pobiera, więc każda z nich jest porównywana ze swoją blokadą i publikowana tam tak jak wszędzie indziej; żaden inny rodzaj nie podlega blokadzie i nie jest z tego powodu odrzucany. Konfiguracja wymienia inne polecenia, których to dotyczy.

aggrega push --pin-sources najpierw sam uruchamia ten sam krok. Krok jest wykonywany przed zbudowaniem pakietu, więc zapisana przez niego blokada znajduje się w opublikowanym artefakcie i jest objęta opublikowanym skrótem; wykonywany jest też przed każdą inną odmową oceniającą encję, więc oceniana jest encja w postaci przypiętej. Pierwszeństwo ma tylko powyższa reguła dotycząca katalogu, ponieważ krok zapisuje jedyną blokadę, którą zawiera katalog. Zapisuje te same bajty co aggrega pin, więc w tym uruchomieniu powyższa odmowa nigdy nie występuje: blokada właśnie zapisana przez krok zawiera dokładnie to, z czym odmowa by porównywała. Klucz obszaru roboczego pin_sources_at_push czyni to domyślnym zachowaniem każdego pushu, a --pin-sources=false pomija krok w jednym uruchomieniu, co przywraca odmowę. Krok zapisuje obok encji, co wymaga zapisywalnej lokalizacji — a push zawsze ją ma, ponieważ publikuje wskazany dokument.

--dry-run odpowiada tak, jak odpowiedziałaby publikacja. Bez --pin-sources odrzuca nieprzypiętą encję dokładnie tak jak publikacja, więc dry run, który raportuje pakiet, dotyczy pakietu, który ta odmowa by przepuściła. Z --pin-sources krok przypina w trybie dry run: wypisuje blokadę, którą by zapisał, i niczego nie zapisuje, a następujące po tym dane pakietu opisują katalog w obecnym stanie, bez tej blokady — więc skrót odpowiada publikacji bez niej, a jeśli blokada byłaby nowa, to samo dotyczy rozmiaru oraz, dla encji niewskazującej niczego innego, typu mediów. Odmowa nie występuje, ponieważ publikacja najpierw by przypięła.

Dobra praktyka: zmiana wersji już opublikowanej trafia do nowej wersji, a potem następuje przypięcie. Należy skopiować encję do katalogu nowej wersji, wprowadzić tam zmianę, przypiąć ją i opublikować. Połowę tego, którą wymusza produkt, opisuje następna sekcja: publikacja innej treści w wersji już opublikowanej jest odrzucana. Drugiej połowy — nieprzypinania ponownie już opublikowanej wersji po jej edycji we własnym obszarze roboczym — należy przestrzegać samodzielnie; lokalnie nic tego nie odrzuca, ponieważ ponowne przypięcie jest uprawnione dla encji, która nie została opublikowana.

Rejestr, tag i adresowanie treścią

Rejestrem docelowym jest --registry <ref>, jeśli podano, a w przeciwnym razie default_registry obszaru roboczego (domyślnie hub.aggrega.ai). Tagiem jest metadata.version encji, a ścieżka repozytorium wynika z jej rodzaju i nazwy, więc miejsce, w którym trafia opublikowana wersja, nie zależy od katalogu, z którego ją opublikowano.

default_registry może zawierać ścieżkę repozytorium, a publikacja przez niego trafia pod tę ścieżkę. Przy default_registry: ghcr.io/acme encja Component core/api-server w wersji 1.0.0 jest publikowana pod ghcr.io/acme/component/core/api-server:1.0.0 — w miejscu, z którego pobiera ją pull przez ten sam rejestr domyślny, więc dołączony tu podpis jest tym, który ten pull znajdzie. --registry wskazuje hosta, a publikacja przez niego skierowana trafia do tego hosta bez ścieżki. Niezależnie od sposobu wskazania miejsca docelowego obowiązują wymóg podpisywania i konfiguracja podpisywania przechowywane dla jego hosta: ścieżka nigdy nie wybiera innej polityki. Zapis ścieżki opisano w sekcji jak zapisuje się host rejestru.

Manifest wskazuje skrót opublikowanych bajtów, a plik blokady zapisuje skrót tego, co one zawierają. Manifest OCI zapisywany przez push wskazuje skrót opublikowanego dokumentu lub archiwum, a aggrega pull odrzuca pobranie, które do niego nie pasuje, więc bajty zmienione między publikacją a pobraniem zostają wykryte. Plik blokady zapisywany przez pull rejestruje encję innym skrótem: skrótem jej treści — ścieżki i bajtów każdego pliku, bez informacji o sposobie kompresji archiwum ani o bitach uprawnień jego plików. Ten sam skrót zapisuje pull w obszarze roboczym autora dla tej samej encji w jej katalogu w katalogu encji, więc autor i każdy odbiorca jednej publikacji zapisują tę samą wartość, a kompilacja po każdej ze stron odrzuca treść, która już do niej nie pasuje. Oba skróty odpowiadają na różne pytania: skrót manifestu sprawdza pobranie, a skrót pliku blokady jest tożsamością encji.

Publikowanie na istniejącej wersji

Zanim jakiekolwiek bajty zostaną przesłane, aggrega push ustala, co docelowy rejestr już przechowuje pod referencją, którą zamierza zapisać, i porównuje to z treścią, którą ma przed sobą. Możliwe są trzy wyniki:

  • Nic nie zostało tam jeszcze opublikowane — push przebiega i publikuje normalnie.
  • Ta sama treść — nic nie jest przesyłane, a polecenie zgłasza wersję jako już opublikowaną, więc powtórzony lub ponowiony push nie jest błędem. To, czego wcześniejszy push nie dołączył — podpis lub datę publikacji — zostaje dołączone teraz, jak opisuje sekcja Dokończenie publikacji, którą wcześniejszy push pozostawił niepełną.
  • Inna treść — push zostaje zatrzymany i podaje digest już opublikowany oraz ten, który zostałby zapisany. Żadna flaga nie wymusza jego wykonania.

Wersja, która została już opublikowana, nadal oznacza więc bajty pod nią opublikowane. Zmienioną treść publikuje się pod nowym metadata.version; aggrega lint --pre-publish odpowiada na kolejne pytanie — jak daleko ta wersja musi się przesunąć — klasyfikując zmianę względem poprzednio opublikowanej wersji.

--dry-run wypisuje digest, który zapisałby push, obok referencji, pod którą by go zapisał:

aggrega push (dry-run): <reference>:<tag> (<digest>)

Jest to digest, który sam push porównuje z tym, co już opublikowano, obliczany w ten sam sposób wyłącznie z treści, a jego wypisanie nie łączy się z żadnym rejestrem. Można więc zestawić posiadaną treść z digestem, pod którym opublikowano wersję, zanim cokolwiek zostanie wypchnięte: jeśli różnią się w przypadku opublikowanej wersji, push zostałby odrzucony. Z --pin-sources jest to digest katalogu w jego bieżącym stanie, jak opisuje sekcja Przypinanie przed publikacją.

Dokończenie publikacji, którą wcześniejszy push pozostawił niepełną

Push najpierw zapisuje treść, a podpis i datę publikacji dołącza potem, więc push, który zawiedzie przy jednym z tych dołączeń — po ponownych próbach — pozostawia treść opublikowaną bez niego i kończy się kodem niezerowym, podając, czego nie udało się dołączyć. Ponowne uruchomienie tego samego pusha dokańcza tę publikację. Znajduje on treść już opublikowaną, wypisuje wiersz Already published:, niczego nie przesyła i dołącza to, czego wersji nadal brakuje, każdy element w wierszu, który wypisuje dla niego pierwsza publikacja:

  • Podpis, jeśli ten push podpisuje. Zostaje dołączony, gdy wersja nie ma podpisu, który liczy się jako podpis tej publikacji. Jeśli konfiguracja przypina politykę zaufania dla hosta miejsca docelowego — public_key lub trusted_identities, albo w przypadku hub.aggrega.ai wbudowaną bazę — podpis się liczy, gdy weryfikuje się zgodnie z tą polityką, więc podpis, którego polityka nie dopuszcza, nigdy nie jest uznawany za własny podpis publikacji. Jeśli polityka nie przypina żadnego z nich, żaden podpis nie może się względem niej zweryfikować, więc liczy się każdy podpis, który ma wersja, a push podpisuje tylko wersję, która nie ma żadnego; ocenianie na podstawie weryfikacji dołączałoby w takim przypadku kolejny podpis przy każdym uruchomieniu.
  • Data publikacji, jeśli reguła dotycząca dat jej wymaga — odczytana z właśnie dołączonego podpisu lub z podpisu już uznanego — a wersja nie ma w ogóle referrera published-at. Push, który nie podpisuje, jest winien datę tak jak publikacja niepodpisana, bez względu na to, jakie podpisy dołączono później do wersji. Podawana data pochodzi z zegara tego pusha: jest to czas dokończenia publikacji, późniejszy niż moment, w którym treść po raz pierwszy trafiła do rejestru, ponieważ nic, co udostępnia rejestr, nie rejestruje tego momentu.

Do publikacji, która jest już kompletna, nic nie jest dołączane, niezależnie od tego, ile razy push zostanie powtórzony. Zanim cokolwiek dołączy, push odczytuje, jakie podpisy i daty ma wersja, i tworzy każdy podpis, który jest winien. Pytanie, na które nie potrafi odpowiedzieć — lista lub podpis, których nie może odczytać, albo podpis, którego nie może ocenić, bo nie da się uzyskać korzenia zaufania — oraz podpis, którego nie może utworzyć, kończą się kodem niezerowym bez dołączenia czegokolwiek, zamiast być uznane za oznakę, że wersja nie ma żadnego.

Gdy rejestr odrzuci zapis

Wypychanie zapisuje dane do rejestru etapami: najpierw treść — w przypadku encji Plugin samą encję i jej plik .wasm — potem manifest, który ją wskazuje, następnie tag wersji, a na końcu podpis i datę publikacji obok niej. Każdy etap zapisu jest ponawiany, gdy kończy się niepowodzeniem, po którym kolejna próba może się powieść: rejestr odpowiada błędem serwera (dowolny status 5xx poza 503 zawierającym Retry-After) lub 408 Request Timeout albo połączenie przekracza limit czasu, zostaje zresetowane lub urywa się w trakcie odpowiedzi. Każdy etap jest próbowany najwyżej trzy razy: przed drugą próbą następuje oczekiwanie przez pół sekundy, a przed trzecią przez sekundę.

Na rejestr, który prosi o zwolnienie, czeka się, a oczekiwanie nie zużywa żadnej z tych prób. Po odpowiedzi 429 Too Many Requests lub 503 zawierającej Retry-After każde żądanie do tego rejestru — zarówno odczyt, jak i zapis — czeka tak długo, jak rejestr prosił, a potem jest wysyłane ponownie; etap, którego treść została odrzucona, zaczyna się od nowa jako nowe przesyłanie, bez stałej liczby prób, dopóki rejestr przez pięć minut nie odpowiada niczym innym niż „zwolnij”. Rejestr, który prosi o zwolnienie opisuje oczekiwanie i odmowę, która je kończy.

Każda próba to nowe przesłanie tych samych bajtów, nigdy ponowne wysłanie żądania, które się nie powiodło. Rejestr, który przyjął już treść przesyłanych danych, może odrzucić to samo żądanie wysłane po raz drugi, a przyjmuje nowe przesłanie. Treść, którą rejestr już przechowuje, liczy się jako przesłana, a ponowiony etap zapisuje to samo, co zapisałaby pierwsza próba, więc próba, która dotarła do rejestru, ale której odpowiedź została utracona, niczego nie zapisuje dwukrotnie: manifest zachowuje swój digest, a wersja ma jeden podpis i jedną datę publikacji.

Każde inne niepowodzenie natychmiast kończy etap: odrzucone poświadczenie (401, 403 lub brak zapisanego poświadczenia dla rejestru), każda inna odpowiedź rejestru, rejestr całkowicie nieosiągalny albo przerwanie wypychania przez użytkownika. Etap, który nadal kończy się niepowodzeniem po ostatniej próbie, powoduje niepowodzenie polecenia, a błąd wskazuje ten etap — treść, manifest, tag, podpis lub datę publikacji. To, co opublikowały wcześniejsze etapy, pozostaje opublikowane; sekcje Podpisywanie i Data publikacji opisują, co to oznacza dla wersji.

Przy tych błędach ponawiane są wyłącznie zapisy. Odczyt tego, co rejestr już przechowuje dla danej wersji, wykonywany przed przesłaniem czegokolwiek, nie jest ponawiany, choć — jak każde żądanie — odczekuje tyle, ile każe rejestr, który prosi o zwolnienie.

Podpisywanie

aggrega push może podpisać artefakt podczas publikacji i dołączyć podpis jako referrer OCI — pakiet Sigstore (zgodny z cosign) powiązany z niezmiennym digestem manifestu artefaktu. Podpis jest manifestem równorzędnym, więc podpisywanie nigdy nie wypycha ponownie ani nie modyfikuje opublikowanych bajtów. Referrer nadaje swojemu pakietowi nazwę signature.json, więc ogólny klient OCI pobierający referrer po digeście zapisuje pakiet do tego pliku.

Podpisywanie działa w trybie podpisz przed wypchnięciem: digest manifestu jest znany przed publikacją, więc aggrega push tworzy podpisującego i podpisuje digest zanim jakiekolwiek bajty trafią do rejestru. Jeśli nie można utworzyć podpisującego lub podpisywanie się nie powiedzie, push zostaje odrzucony, zanim cokolwiek zostanie przesłane — nic nie zostaje opublikowane, więc nieudane podpisywanie nigdy nie pozostawia w rejestrze niepodpisanej treści. Przed odrzuceniem wywołanie podpisujące, które nie powiodło się przejściowo — z powodu dowolnego błędu, przy którym ponawiany jest zapis do rejestru, lub gdy urząd certyfikacji trybu bezkluczowego zgłosi, że nie mógł przetworzyć tokenu tożsamości — jest ponawiane, maksymalnie do trzech prób z tymi samymi odstępami. W ramach wywołania podpisywania bezkluczowego żądanie, na które urząd certyfikacji, dziennik przejrzystości lub urząd znaczników czasu odpowie 429 Too Many Requests lub błędem serwera, jest najpierw wysyłane do tej usługi ponownie, jak opisuje aggrega sign.

Podpis jest dołączany po zapisaniu treści, więc nieudane dołączenie pozostawia treść opublikowaną bez podpisu. Dołączenie jest zapisem, ponawianym zgodnie z opisem w sekcji Gdy rejestr odrzuci zapis. Jeśli nadal się nie powiedzie, polecenie kończy się kodem niezerowym, wskazując podpis, którego nie udało się dołączyć, a odbiorca, którego rejestr wymaga podpisów, odrzuca wersję, dopóki podpis nie zostanie dołączony. Ponowne uruchomienie tego samego push dołącza go, jak opisano w sekcji Dokończenie publikacji, którą wcześniejszy push pozostawił niepełną; aggrega sign dołącza podpis do opublikowanej wersji przez referencję.

Publikacja wymaga podpisu, gdy własny blok signing rejestru docelowego ustawia required: true lub gdy robi to blok signing najwyższego poziomu dla każdego rejestru — każdy z nich ograniczony do rodzajów wymienionych w jego kinds, jeśli jakieś wymienia. Taka publikacja jest domyślnie podpisywana, a --sign jawnie żąda podpisania. Nie ma flagi pozwalającej wypchnąć niepodpisaną treść tam, gdzie wymagany jest podpis — taki push zawsze zostaje zatrzymany.

Dwa tryby podpisywania:

  • Bezkluczowy (domyślny) — efemeryczny klucz powiązany z tożsamością OIDC krótkotrwałym certyfikatem Fulcio, zarejestrowany w dzienniku przejrzystości Rekor. Fulcio i Rekor domyślnie wskazują publiczne instancje Sigstore (https://fulcio.sigstore.dev, https://rekor.sigstore.dev). Zaufany znacznik czasu w trybie bezkluczowym pochodzi z włączenia wpisu do dziennika przejrzystości Rekor; osobny urząd znaczników czasu RFC3161 jest opcjonalny — aby go włączyć, należy podać --timestamp-url z pełnym adresem endpointu. W terminalu interaktywnym podpisywanie bezkluczowe nie wymaga żadnych flag: CLI otwiera przeglądarkę, aby uzyskać krótkotrwały token tożsamości OIDC. W GitHub Actions również nie wymaga żadnych: CLI automatycznie generuje token OIDC przepływu pracy z endpointu dostępnego w środowisku runnera. W innych zastosowaniach nieinteraktywnych / CI należy wyeksportować AGGREGA_IDENTITY_TOKEN (lub SIGSTORE_ID_TOKEN) albo przekazać --identity-token; bez podanego tokenu, bez endpointu środowiskowego i bez terminala push zostaje odrzucony. Model tokenów w CI opisano w environment-variables.md.
  • Kluczowy (--key) — klucz ECDSA P-256 przechowywany offline (PEM zgodny z cosign), furtka dla środowisk bez dostawcy tożsamości OIDC. Nie jest nawiązywane połączenie z żadnym dostawcą tożsamości, urzędem certyfikacji ani dziennikiem przejrzystości.

Adresy URL usług trybu bezkluczowego i ścieżkę klucza trybu kluczowego można też ustawić w .aggrega-config.yaml w bloku signing: (globalnym i dla danego rejestru); flaga nadpisuje konfigurację, a konfiguracja nadpisuje publiczną wartość domyślną. Token tożsamości OIDC nigdy nie jest polem konfiguracji (jest krótkotrwałym sekretem), a klucz prywatny nigdy nie jest wpisywany bezpośrednio w konfiguracji — tylko ścieżka do niego.

Data publikacji

Czas utworzenia manifestu jest przypięty, więc skrót manifestu zależy wyłącznie od tego, co zostało opublikowane, a nigdy od tego, kiedy. Data publikacji wersji jest więc przechowywana obok niej, a jej źródło zależy od podpisu:

  • Podpis bezkluczowy już ją zawiera. Jego wpis w dzienniku przejrzystości rejestruje, kiedy dziennik włączył podpis, a podpisana obietnica dziennika poświadcza ten czas. aggrega push nie zapisuje nic więcej.
  • Podpis kluczem lub brak podpisu nie niesie żadnego czasu. Dlatego po umieszczeniu encji i ewentualnego podpisu aggrega push dołącza do manifestu mały referrer published-at — o nazwie published-at.json dla ogólnego klienta OCI — zawierający jeden znacznik czasu RFC 3339 w UTC z dokładnością do sekundy, odczytany z zegara maszyny publikującej. Nie jest on podpisany: jest to oświadczenie publikującego i czytelnik rejestruje go jako takie. Zgłasza go wiersz Publication date attached:.

Podobnie jak podpis, referrer published-at jest manifestem równorzędnym wskazującym na opublikowany manifest, więc nie zmienia żadnego skrótu ani tagu, a sprawdzenie przy publikowaniu na istniejącej wersji nie jest przez niego zmieniane. Ponowne wypchnięcie tej samej treści dołącza datę tylko do wersji, która jej nie ma, podając czas z własnego zegara — zob. Dokończenie publikacji pozostawionej częściowo przez wcześniejsze wypchnięcie. Data jest odczytywana z zegara raz, przed pierwszą próbą dołączenia, więc ponowiona próba dołączenia — zob. Gdy rejestr nie wykona zapisu — podaje tę samą datę. Wypchnięcie, które opublikowało treść, ale po tych próbach nie zdołało dołączyć daty, kończy się kodem niezerowym i wskazuje, czego nie dołączono. aggrega registry update rejestruje datę każdej wersji wraz z informacją, z którego z dwóch źródeł pochodzi.

Tryb offline

Publikowanie wymaga komunikacji sieciowej w obie strony i nie ma formy, która by jej nie wymagała, dlatego w trybie offline — ustawianym kluczem najwyższego poziomu offline w pliku konfiguracyjnym, zmienną AGGREGA_OFFLINE lub flagą --offline — aggrega push odmawia działania, zanim odczyta encję. Komunikat odmowy wskazuje, które z tych trzech ustawień włączyło tryb offline, czego czytelnik potrzebuje, gdy włączyła go zatwierdzona w repozytorium konfiguracja projektu, a nie cokolwiek, co sam wpisał.

--dry-run stanowi wyjątek, i to wyjątek wynikający z tego, co robi: oblicza pakiet, wypisuje referencję, którą by opublikował, oraz skrót, który dałaby ta publikacja, i nigdy nie łączy się z rejestrem. Dzięki temu jest bezpieczną w trybie offline formą publikowania, a nie czymś sprzecznym z tym trybem, i działa nadal w trybie offline — z jednym zastrzeżeniem. Dla encji Recipe lub FeatureRecipe, której zdalne source: jest zapisane w pełnej postaci, to źródło jest pobierane w celu porównania przypięcia, a w trybie offline to pobranie zostaje odrzucone z własnym komunikatem, więc przebieg próbny dla takiej encji zatrzymuje się w tym miejscu, zamiast zgłaszać pakiet, za który nie może ręczyć.

Aby opublikować w pojedynczym uruchomieniu z obszaru roboczego, którego konfiguracja włącza tryb offline, należy przekazać --offline=false.

Zmienne środowiskowe

Dane wejściowe podpisywania oraz rejestr docelowy można podać przez środowisko; nadpisują one wtedy .aggrega-config.yaml, a flaga nadal ma pierwszeństwo:

  • AGGREGA_IDENTITY_TOKEN — bezkluczowy token tożsamości OIDC (odpowiednik --identity-token w zmiennych środowiskowych). SIGSTORE_ID_TOKEN jest uwzględniany jako alias zapewniający interoperacyjność z ekosystemem sigstore, o priorytecie niższym niż AGGREGA_IDENTITY_TOKEN i punkt końcowy dostępny w środowisku GitHub Actions. Token nigdy nie jest polem konfiguracji.
  • AGGREGA_SIGNING_FULCIO_URL, AGGREGA_SIGNING_REKOR_URL, AGGREGA_SIGNING_TIMESTAMP_URL — adresy URL usług podpisywania bezkluczowego.
  • AGGREGA_SIGNING_KEY_PATH — ścieżka wskazująca plik PEM z kluczem do podpisywania kluczem (nigdy sam materiał klucza).
  • AGGREGA_DEFAULT_REGISTRY — rejestr docelowy, gdy pominięto --registry.

Kolejność pierwszeństwa: flaga > środowisko > konfiguracja > wartość domyślna. Pełną listę i model pierwszeństwa opisano w environment-variables.md.

Uwierzytelnianie

aggrega push odczytuje poświadczenia rejestru tak samo jak aggrega pull — z konfiguracji poświadczeń Dockera i wskazanych w niej pomocników poświadczeń. Przed wypchnięciem do prywatnego rejestru należy uruchomić aggrega login <registry>, które nie wymaga żadnego innego narzędzia, lub docker login <registry>. Miejsce odczytu tej konfiguracji opisano w aggrega-pull.md.

Zobacz także

  • ./aggrega-sign.md — podpisanie już opublikowanego artefaktu po fakcie (odpowiednik --sign stosowany po publikacji).
  • ./aggrega-lint.md — bramka publikacji (--pre-publish), która powinna poprzedzać wypchnięcie.
  • ./aggrega-pull.md — strona konsumująca, która rozwiązuje i przypina to, co publikuje push.
  • ./aggrega-serve.md — demon udostępnia tę samą publikację pod aggrega/publishEntity, dzięki czemu edytor może ją uruchomić bez opuszczania sesji; działa ona tylko wtedy, gdy żądanie ją wskazuje, a w odpowiedzi zwraca referencję, opublikowany digest — przy próbnym uruchomieniu digest wypisywany przez --dry-run — informację, jak daleko dotarło wywołanie, oraz wpisy, przed którymi ostrzega to polecenie, jako windowsUnusableEntries.
  • ./aggrega-mcp.md — ta sama funkcja jako narzędzie publish-entity, które może wywołać asystent, zwracające te wpisy jako windows_unusable_entries. Przed zezwoleniem na nie należy przeczytać, co ta strona mówi o takim zezwoleniu.
  • ../../architecture/13-catalog-and-registry.md — model katalogu, rejestru i typów mediów OCI.

Składnia

aggrega push <entity-path> [flags]

Opis

Publish a single catalog entity to an OCI registry, where other workspaces
resolve it with "aggrega pull".
The entity is read from the path given, bundled for transport, and pushed to
<registry>/<kind>/<metadata.name>:<metadata.version>, the repository path
lowercased; a Recipe or FeatureRecipe carries its spec.capability, and a Plugin
its metadata.pluginType, as a segment between <kind> and <metadata.name>. The
tag is the entity's own metadata.version. Run "aggrega push --list-kinds" for
the kinds this binary publishes, one per line and nothing else, so a script can
read it directly. Release and Manifest are deployment-side inputs rather than
catalog artifacts and are refused.
Every kind has a directory of its own except Aggregate, Release and Manifest: an
entity of any other kind is refused when another entity sits in its directory,
before anything is pinned or bundled, and the refusal names the entity in the way.
The directory's name is not judged.
A Component, Feature, Recipe or FeatureRecipe is read the way a build reads it
before it is bundled, and one that read refuses is refused here for the same
reason: a document that fails its kind's schema, a path naming content outside
the entity's own directory, which would not travel with the entity, or a schema
a Component or Feature imports that cannot be read or used.
A Plugin is read against its kind's schema too, before its .wasm is read, so a
metadata.version that is not a semantic version is refused. Its .wasm must then
agree with the entity on what the plugin offers and on its version, and a .wasm
whose version says it was built from a working tree with uncommitted changes —
the -dirty mark a build adds — is refused. A version disagreement and a build
from uncommitted changes are both cleared by building the plugin from a clean
checkout of the commit its release tag names, never by copying the version it
reports into the entity. A development version such as 1.0.0-3-g1a2b3c4, built
from a commit, and a prerelease such as 1.0.0-rc.1 publish.
What is published is the entity document and the files the entity itself names
beside it — a Recipe's or FeatureRecipe's local source, each file an $import:
names, the entity.lock beside it, and each schema file a Component or Feature
imports — and nothing else in its directory. An entity that names nothing
publishes as its document, unchanged; one that names a file publishes as a
gzipped archive of the document and those files. A directory it names travels
with every file under it that the ignore rules recorded in its entity.lock keep:
the rules the plugin serving its capability declared, and the author's own
.aggregaignore beside it, composed when the entity was pinned. A symbolic link
among those files is refused rather than followed. A local source written as a
template names no one directory until a Release fills it in, so an entity with
one carries every such file in its own directory, and push says so.
Push warns about each file an archive carries whose path holds a part Windows
cannot hold as written: a name Windows reserves for a device — CON, PRN, AUX,
NUL, COM1 or LPT1, say, in any letter case and whatever extension follows — or a
part ending in a full stop or a space. On Windows, aggrega refuses to unpack
such a file, so a Windows workspace cannot use the version. The warning is
written to standard error on every platform, one line per file, the entity
document's own file name judged with the rest, and it refuses nothing: the push,
or its dry run, goes ahead or stops exactly as it would without it. An entity
that names nothing publishes as its document alone and is never warned about.
Each file travels with mode 0644, whatever its permission bits — the execute
bit included — in the checkout it is published from. The OCI manifest names the
digest of the published bytes, so "aggrega pull" refuses a download that does
not match it. The lockfile a pull writes records the entity by the digest of its
content — each file's path and its bytes — which is the digest a pull in the
author's own workspace records for the same entity in its catalog directory, so
a build on either side refuses content that no longer matches.
Push signs before it publishes: where signing applies, the signature is made
over the manifest digest before any bytes reach the registry, so a failed
signing refuses the push rather than leaving unsigned content published.
The manifest's creation time is pinned, so the digest depends only on what is
published and never on when. Push states when it published beside the manifest
instead, as a small published-at attachment carrying this machine's clock, in
UTC to the second — unless the signature it attached already carries a time a
transparency log attests, as a keyless signature does. So a keyed or unsigned
publication writes one, and a keyless one does not. The attachment moves no
digest and changes no tag. "aggrega registry update" records the date, with
which of the two it came from.
Push refuses to replace content already published at the same version:
publish changed content under a new version instead.
A Recipe or FeatureRecipe carries the pins for its own inputs in the entity.lock
beside it, and pinning them is a step you run before publishing: aggrega pin.
A push that does not run that step refuses an entity whose entity.lock is
missing a pin, or holds one an input no longer matches, and names the step.
Pass --pin-sources, or set pin_sources_at_push in the workspace configuration, to
have push run that same step first, so the lock it writes is part of what is
published; --pin-sources=false skips it for one run.

Flagi

FlagaDomyślnieOpis
--dry-runfalseOblicza pakiet i wypisuje proponowane : wraz z digestem, który dałaby publikacja, bez kontaktowania się z rejestrem. Encja, którą publikacja odrzuciłaby z powodu brakującego przypięcia, jest odrzucana również tutaj
--entity—Ścieżka do pliku YAML encji do opublikowania (alternatywnie można ją przekazać jako argument pozycyjny)
--fulcio-url—Adres URL urzędu certyfikacji Fulcio do podpisywania bezkluczowego. Jeśli zostanie pominięty, używana jest publiczna instancja Fulcio.
--identity-token—Token tożsamości OIDC do podpisywania bezkluczowego. Opcjonalny w interaktywnym terminalu (token uzyskuje się w przeglądarce) oraz w GitHub Actions (token OIDC przepływu pracy jest generowany automatycznie); wymagany w pozostałych zastosowaniach nieinteraktywnych/CI, gdzie można go zamiast tego wyeksportować jako AGGREGA_IDENTITY_TOKEN lub SIGSTORE_ID_TOKEN.
--key—Ścieżka do posiadanego klucza prywatnego ECDSA P-256 w formacie PEM do podpisywania kluczem w trybie offline. Jeśli zostanie pominięta, używane jest podpisywanie bezkluczowe.
--list-kindsfalseWypisuje każdy rodzaj encji, który można opublikować, a następnie kończy działanie bez publikowania czegokolwiek. Wynik jest czytelny maszynowo, a jego kształt jest stabilny: jeden rodzaj w wierszu, w kolejności posortowanej, bez niczego więcej.
--pin-sourcesfalseUruchamia na encji krok przypinania autora encji przed jej spakowaniem, tak aby plik entity.lock zapisywany przez ten krok obok encji stał się częścią publikacji, zamiast odrzucać encję, której blokada nie zapisuje jej przypięć. Jest to ten sam krok co aggrega pin, zapisujący te same bajty. Zapisuje obok encji, więc działa tylko tam, gdzie encja ma miejsce z prawem zapisu: dokument w katalogu, z którego go odczytano — co przy wypchnięciu jest zawsze spełnione, ponieważ publikuje ono wskazany dokument encji. Nadpisuje ustawienie pin_sources_at_push obszaru roboczego w obu kierunkach: —pin-sources przypina w tym uruchomieniu, a —pin-sources=false nie przypina, niezależnie od ustawienia
--plugin—Ścieżka do lokalnego artefaktu .wasm dla encji Plugin. Wymagana przy publikowaniu encji Plugin: publikacja wypycha artefakt .wasm, oblicza jego digest treści i wypycha encję.
--registry—Host rejestru docelowego (zastępuje default_registry obszaru roboczego)
--rekor-url—Adres URL dziennika przejrzystości Rekor do podpisywania bezkluczowego. Jeśli zostanie pominięty, używana jest publiczna instancja Rekor.
--signfalsePodpisuje opublikowany artefakt i dołącza podpis jako referrer OCI. Jeśli flaga zostanie pominięta, podpisywanie odbywa się zgodnie z zasadami rejestru docelowego.
--timestamp-url—Opcjonalny adres URL urzędu znaczników czasu RFC3161 do podpisywania bezkluczowego.