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

aggrega registry

Registries und ihre Signatur-Vertrauensrichtlinie verwalten

Übersicht

aggrega registry

Beschreibung

Manage the OCI registries Aggrega publishes to and resolves from, together with
the signature trust policy for each.
A registry entry records where to reach the registry and what to require of the
signatures on artifacts it serves — which identities are trusted, and whether a
signature is required at all. That policy is what "aggrega pull" enforces when
it verifies an artifact and what "aggrega push" honours when it decides whether
to sign.
"aggrega registry add" can fetch a registry's own advertised trust policy rather
than having you write it out. "aggrega registry update" builds the local
searchable index that "aggrega search" and "aggrega plugin add" read.
A registry entry is written to the global config shared across every workspace
on this machine, because a registry and the identities you trust on it are
usually the same wherever you work. That makes adding or removing one a
machine-wide change: every project on this machine resolves through the entry
you just wrote or dropped. Pass --workspace to write it to this project's config
file instead. Building the searchable index is the exception — that lands in
this workspace's own artifact cache and reaches no other project.

Unterbefehle

BefehlBeschreibung
aggrega registry addEine Registry und ihre Signatur-Vertrauensrichtlinie registrieren
aggrega registry listKonfigurierte Registrys und ihren Vertrauensstatus auflisten
aggrega registry removeEine Registry und ihre Vertrauensrichtlinie aus einer Konfigurationsdatei entfernen
aggrega registry updateDen lokalen durchsuchbaren Index der konfigurierten Registrys erstellen

Beschreibung von aggrega registry add

Register a registry host and its signature trust policy.
The entry is keyed under the host exactly as written, and every lookup of it is
made in one spelling: a lowercase host name containing a dot, localhost, a single
name followed by a port (registry:5000), an IPv4 address, or an IPv6 address in
brackets, each with an optional :port. A reference may be given instead — its
scheme, path and credentials are dropped and the entry is keyed under the host it
names — but a host written in capitals, with the default HTTPS port, or as a
single name with no port is refused, naming the spelling to write where there is
one.
The entry is written to the global config shared across every workspace, since a
registry and the identities you trust on it are usually the same wherever you
work. Pass --workspace to write it to this project's config file instead; the two
flags are mutually exclusive.
By default the registry's advertised trust policy is fetched once from the
registry's own origin (https://<host>/.well-known/aggrega-trust) and pinned
locally — trust-on-first-use. Verification at pull time always runs against the
pinned local policy, never a live re-fetch. Pass --fetch-trust=false to skip the
fetch and pin only what the flags supply.
A trust policy can also be set by hand: keyless (one or more --identity entries,
each an "identity=issuer" pair) or keyed (--key pointing at a pinned public-key
PEM). Manual --identity / --key flags OVERRIDE the fetched set — when either is
supplied, the fetch is skipped and the policy is built from the flags alone.
Pass --trusted-root to pin a Sigstore trust-root bundle for air-gapped keyless
verification. Adding the official hub host with no policy flags pins the built-in
official baseline.
When the registry advertises no trust policy (a 404 or an unreachable endpoint),
the add does not fail: it writes the policy from the flags (or an empty policy)
and prints a notice suggesting manual --identity / --key pinning. The official
hub writes its built-in baseline instead, and the notice says the baseline was
pinned.
When the workspace is offline the advertised policy cannot be fetched, so the
registry is never asked. Adding a registry other than the official hub is then
refused unless --identity or --key supplies the policy, rather than writing an
entry that trusts nothing: register it once while online, or pin it by hand.
Adding the official hub offline pins its built-in baseline, with a notice saying
so, and a manual policy registers offline exactly as it does online.
Existing settings in the target config file are preserved.

Flags von aggrega registry add

FlagStandardBeschreibung
--advisoryfalseVerifizierungsfehler für diese Registry zu Warnungen herabstufen, statt anzuhalten
--fetch-trusttrueDie von der Registry angebotene Vertrauensrichtlinie bei der ersten Verwendung abrufen und pinnen. Verwenden Sie —fetch-trust=false, um dies zu überspringen; auch manuelle Angaben von —identity/—key überspringen den Abruf.
--globalfalseDen Eintrag in die globale Konfiguration schreiben, die alle Workspaces gemeinsam nutzen. Eine Registry landet standardmäßig hier.
--identity[]Vertrauenswürdige schlüssellose Identität als identity=issuer, zum Beispiel dev@example.com=https://accounts.google.com (wiederholbar; ODER-Menge). Überschreibt die abgerufene Vertrauensrichtlinie.
--key—Pfad zu einem gepinnten, cosign-kompatiblen PEM mit öffentlichem Schlüssel für die Keyed-Verifizierung. Überschreibt die abgerufene Vertrauensrichtlinie.
--name—Optionaler sprechender Alias für diese Registry. Der Host bleibt die Identität; der Alias wird überall dort zu ihm aufgelöst, wo eine Registry benannt wird (z. B. —registry). Muss über alle Registrys hinweg eindeutig sein.
--require-signaturesfalseEine Signatur für jedes Artefakt verlangen, das aus dieser Registry abgerufen (und in sie gepusht) wird
--trusted-root—Pfad zu einem gepinnten Sigstore-Trust-Root-Bundle für schlüssellose Verifizierung in Air-Gap-Umgebungen
--workspacefalseSchreibt den Eintrag in die Workspace-Konfiguration dieses Projekts statt in die globale Konfiguration.

Beschreibung von aggrega registry list

List every registry configured in the effective merged config, one per line,
with its friendly alias (if any), a short trust-posture summary, and a marker on
the default registry.
This reads the resolved configuration and never contacts a registry. Registries
are listed in ascending host order.
With -o json the same set is emitted as one structured document per registry:
its host, its alias, whether it is the default, its trust posture as discrete
fields rather than the table's rendered sentence, and whether a credential for
that host is present in the shared credential store. The credential state reports
presence only — a credential is never read out, measured, or shown in any form,
and whether the registry would accept it is not asked, since that would take a
network round trip. Reading it consults the local credential store, which honors
a configured credential helper. The order is the same ascending host order the
table uses.

Flags von aggrega registry list

FlagStandardBeschreibung
--output, -otableAusgabeformat: table|json.

Beschreibung von aggrega registry remove

Remove a registry's trust-policy entry from a config file, addressed by its host
or its friendly alias.
By default the entry is removed from the global config shared across every
workspace; pass --workspace to remove it from this project's workspace config
instead. Setting both --global and --workspace is a usage error.
The default_registry pointer is left untouched — removing a registry's trust
policy reverts that host to default trust; it does not change which registry is
the default. Where default_registry names the removed entry by its alias, that
alias names nothing afterwards, and the configuration is refused until
default_registry is written as a host or as another entry's name.

Flags von aggrega registry remove

FlagStandardBeschreibung
--globalfalseDen Eintrag aus der globalen Konfiguration entfernen, die alle Workspaces gemeinsam nutzen.
--workspacefalseDen Eintrag aus der Workspace-Konfiguration dieses Projekts statt aus der globalen Konfiguration entfernen.

Beschreibung von aggrega registry update

Walk each configured registry's repositories, read the latest published version
of each, and write a deterministic local searchable index to the artifact cache.
With no argument, every configured registry is indexed. With a single registry
argument (a host or a friendly alias), only that registry is indexed.
This is the one registry command that reaches the network. The index it writes
lands in this workspace's own artifact cache, so refreshing it changes nothing
another project on this machine resolves through. Credentials are read from a
supplied or ambient source and never asked for: a registry that needs one you do
not have fails with a message naming what it wanted.
For each repository the highest strict-SemVer version is selected (pre-release
versions are skipped) and its catalog facets — kind, description, category,
labels, and, for plugins, socket type and capabilities — are recorded from the
published manifest. A repository with no conforming version is skipped; a
repository that cannot be read is skipped with a note, so one unreadable
repository does not abandon the whole index.
A registry that asks the walk to slow down — a 429 answer, or a 503 that says
how long to wait (Retry-After) — is left alone for as long as it asks, or ten
seconds where it does not say, and the walk reads fewer of its repositories at
once until it answers again, then returns to its usual pace; on a terminal the
wait is shown beside that registry's row. A registry that answers nothing but
"slow down" for five minutes is not indexed: it keeps the index it had before
the run, and the command names it, its last answer and how long it waited.
A read the registry fails or drops in passing — a 5xx answer, a connection
reset or timed out, an answer cut short — is asked again a few times, with a
growing wait between attempts. A repository with a read still
failing after that is not recorded from this run: it keeps the record the index
already holds for it, where that record was judged under the trust policy now in
force, and is otherwise left out of the index; either way it is named as a
repository that could not be read, as the walk goes and again in the closing
summary under its registry's row, with the kind of the read's last failure — the
status the registry answered, a timeout, a reset, an answer cut short — and the
read that failed. So a version is never recorded unsigned,
undated or without its deprecation marker because a read failed, with or without
--upgrade. Each registry's row in the closing summary also says how many reads
were asked again, whether or not they then succeeded — a read sent again after
the registry asked the walk to slow down among them — and says zero when none
was.
Every signature a registry's walk verifies against the public Sigstore trust root
is verified against the same copy of that root, fetched once for the walk rather
than once per signature; a registry whose trust policy pins a trust root of its
own is verified against that file.
A registry whose repository listing repeats itself — naming a repository it has
already named, or answering two pages in a row with no repository while still
pointing to a next page — is not followed round again. That registry is reported
as not indexed, with a message naming it and saying its repository listing
repeated itself; the other registries are still indexed, and the command exits
non-zero.
A registry that is not indexed keeps the index it had before the run, unchanged:
nothing is written for a registry whose walk failed, whose listing repeated
itself, or that was being walked when the command was interrupted. Registries
indexed earlier in the same run keep what this run wrote for them. A registry's
new index is written aside and put in place whole, so a command stopped while
writing one leaves that registry with a complete index — the one it had before
the run, or the new one — or with none, never with a partial one.
Every strict-SemVer version a recorded repository publishes is listed too, each
with the manifest digest its tag resolves to — the address of the exact bytes
published under that version. Where the registry's trust policy pins a public key
or trusted identities, and verification is not switched off, each version's own
signatures are verified against that policy and the signer is recorded when one
verifies; a version with no signature, or none that verifies, is recorded with no
signer. Where several verify, the signer recorded is the one the transparency log
recorded earliest, whatever order the registry lists them in, so signing a version
again never changes its recorded signer.
Each version's publication date is recorded too, with its source. Where one of the
version's keyless signatures verified, the date is the time the transparency log
recorded that earliest signature, as the verified log entry attests it (source
'transparency-log') — so signing a version again never moves its date. Otherwise
it is the date the publication itself stated beside what it published (source
'publisher'), the earliest where several are stated: the publishing machine's own
clock, which nothing attests, read from any registry whatever its trust policy.
A version with neither — published without stating a date, and not signed
keyless in a way this policy verifies — is recorded with no date.
Only manifests, signature attachments and publication-date attachments are read:
no entity's content is fetched. 'aggrega search -o json' reports these under each
record's 'published' field.
The per-repository records are byte-identical across two runs against the same
registry state; the freshness timestamp is written to a sibling file so it never
disturbs the records.
A refresh reads again only what changed, and finds every change a full re-read
would. For each repository it revalidates the tag listing with a conditional
request, resolves every version's tag to its manifest digest, and revalidates every
version's attachments — its signatures, publication-date statements and deprecation
markers — with one conditional request, plus one for the signatures of a
deprecation marker it judged before. A version whose digest or attachments changed
is read again in full, and its signatures and markers are verified again exactly as
a full re-read verifies them; everything else is kept as recorded. A change to this
registry's trust policy reads every version again under the policy now in force, and
so does a repository whose entry in the index records none of these checks. An
unchanged registry therefore costs one conditional request per repository and two
small requests per version (three where a deprecation marker was judged), with
nothing downloaded. A version is read again on the next refresh where it carries a
deprecation marker that was not honored, or where this run got no way to
revalidate its attachments — which, on a registry that offers none, is every
version.
Several repositories are read at a time. Everything the command records and prints
comes out in repository order, so the index and the output are the same as reading
one repository at a time would produce.
While it walks, a terminal shows the walk's progress on standard error, the way
build and pull show theirs: a row naming each registry, a spinner while that
registry's repository listing is read, then how many of its repositories the walk
has finished out of how many it lists, counted in repository order, and a bar for
the whole walk below the rows. On a terminal that cannot redraw in place, or with
--plain, each registry gets one plain line instead, written when its walk ends,
with the count it ended on and the time it took. When standard error is not a
terminal, no progress is shown. The progress changes nothing the command prints on
standard output.
Use --upgrade to read every repository in full, comparing nothing with the index
already written — to rebuild an index from the registry alone. It finds no change a
refresh without it would miss.
Each published version's deprecation markers are read as the walk goes, and the ones
whose own signature verifies are recorded into the index. Every marker read is
reported, whether or not it was recorded — a version kept as recorded is not read, so
its marker is not reported again — and each registry reports how many markers its
index now records, including when that number is zero. Where signature
verification is disabled for a registry, the walk reports that its markers were not
examined rather than a count, so a registry that published nothing is never confused
with one this run had no basis to judge.

Flags von aggrega registry update

FlagStandardBeschreibung
--upgradefalseLiest jedes Repository vollständig und vergleicht nichts mit dem bereits geschriebenen Index (eine Aktualisierung ohne diese Option liest bereits alles erneut, was sich geändert hat)

Was registry update über Deprecation-Markierungen meldet

Während aggrega registry update eine Registry durchläuft, liest es die Deprecation-Markierungen jeder veröffentlichten Version und zeichnet diejenigen, die es authentifizieren kann, im lokalen Index auf. Es meldet das Ergebnis dieser Prüfung auf jedem Weg, sodass eine Registry, die keine Markierung veröffentlicht hat, von einem Lauf unterscheidbar ist, der nicht nach einer gesucht hat.

Jede Markierung, die der Durchlauf liest, erzeugt eine Zeile, die das Repository, die Version und den vom Herausgeber festgehaltenen Schweregrad nennt – warning, error oder retracted –, zusammen mit der Angabe, ob die Markierung festgehalten wurde. Eine Version, deren Anhänge seit der letzten Aktualisierung unverändert sind, wird wie festgehalten beibehalten, statt gelesen zu werden, sodass ihre Markierung nicht erneut gemeldet wird; die Anzahl unten schließt sie dennoch ein. Eine Markierung wird nur festgehalten, wenn sich ihre eigene Signatur gegen die Signierer verifizieren lässt, die die Vertrauensrichtlinie der Registry anerkennt. Eine, die vorhanden ist, sich aber nicht dekodieren lässt, oder vorhanden, aber nicht anerkannt ist, wird als solche gemeldet und aus dem Index herausgelassen, statt auf Grundlage von Belegen festgehalten zu werden, die nicht authentifiziert werden konnten – ebenso eine, von der die Registry antwortet, dass sie sie nicht hat. Eine Markierung, deren Lesen fehlgeschlagen ist, ist ein anderer Fall: siehe Ein Lesevorgang, der fehlschlägt.

Jede Registry meldet anschließend, wie viele Markierungen ihr Index jetzt aufzeichnet, auch wenn diese Zahl null ist. Wo die Signaturverifizierung ausgeschaltet ist — global oder für diese eine Registry —, meldet der Durchlauf stattdessen, dass Markierungen für sie nicht geprüft wurden. Das sind zwei verschiedene Tatsachen: Die erste besagt, dass die Registry nichts veröffentlicht hat, worauf dieser Workspace reagieren kann, die zweite, dass dieser Lauf überhaupt keine Vertrauensgrundlage hatte, um eine Markierung zu beurteilen. Eine Registry, deren Markierungen nicht geprüft wurden, trägt keinen Rückzug zur Versionsauswahl bei, sodass ein Autor, der eine Markierung angehängt hat und diese Zeile sieht, weiß, warum sie keine Wirkung hat.

Das Veröffentlichungsdatum, das jede Version aufzeichnet

Der Erstellungszeitpunkt eines veröffentlichten Manifests ist fixiert, sodass sein Digest nur davon abhängt, was veröffentlicht wird, und nie davon, wann. Das Datum, an dem eine Version veröffentlicht wurde, wird daher neben dem Manifest gelesen, und aggrega registry update zeichnet es für jede Version zusammen mit seiner Quelle auf:

  • transparency-log — wo die Signatur der Version schlüssellos ist und gegen die Vertrauensrichtlinie der Registry verifiziert wird, der Zeitpunkt, zu dem das Transparenzlog diese Signatur aufgezeichnet hat, den das signierte Versprechen des Logs bestätigt. Wo mehrere Signaturen der Version verifiziert werden, ist es der früheste ihrer Zeitpunkte, und der für die Version aufgezeichnete Signierer ist der derselben Signatur — in welcher Reihenfolge die Registry die Signaturen auch auflistet —, sodass eine erneut signierte Version ihr Datum und ihren Signierer behält. Für eine Version, die beim Veröffentlichen signiert wurde, ist das ihre Veröffentlichung; für eine, die erst später mit aggrega sign signiert wurde, ist es der Zeitpunkt der Signierung. Diese Quelle hat überall Vorrang, wo sie existiert.
  • publisher — andernfalls der Zeitpunkt, den die Veröffentlichung neben dem Veröffentlichten angegeben hat: ein kleiner Published-at-Anhang, den aggrega push und aggrega push-artifact mit der eigenen Uhr des veröffentlichenden Rechners schreiben und den nichts bestätigt. Er wird aus jeder Registry gelesen, unabhängig von ihrer Vertrauensrichtlinie, weil er die Aussage des Herausgebers ist und keine Vertrauensentscheidung. Wo mehrere angehängt sind, wird der früheste genommen.

Eine Version ohne beides zeichnet kein Datum auf. Das ist eine Veröffentlichung, die keines angegeben hat und deren Signatur keine schlüssellose ist, die diese Richtlinie verifiziert — zum Beispiel eine schlüssellose Veröffentlichung, die unter einer Richtlinie gelesen wird, die keiner schlüssellosen Identität vertraut, da eine schlüssellose Veröffentlichung kein eigenes Datum angibt. aggrega search -o json meldet das Datum unter jeder Version in published.

Was eine Aktualisierung erneut liest

Eine Aktualisierung vergleicht, was die Registry jetzt ausliefert, mit dem, was der Index festgehalten hat, und liest alles erneut, was sich geändert hat – dieselbe Antwort, die ein vollständiges erneutes Lesen liefert. Für jedes Repository:

  • validiert sie die Tag-Auflistung erneut, sodass eine seitdem veröffentlichte oder gelöschte Version erfasst wird;
  • löst sie den Tag jeder Version zu dem Manifest auf, das er nennt, sodass eine ältere Version, die unter ihrem bestehenden Tag erneut veröffentlicht wurde, erneut gelesen wird;
  • validiert sie die Anhänge jeder Version erneut – ihre Signaturen, ihre Angaben zum Veröffentlichungsdatum und ihre Deprecation-Markierungen –, sodass eine seitdem an eine Version angehängte Signatur, ein Datum oder eine Markierung gelesen und verifiziert wird, und tut dasselbe für die Signaturen einer Deprecation-Markierung, die sie zuvor beurteilt hat;
  • vergleicht sie die Vertrauensrichtlinie der Registry mit derjenigen, unter der der Index erstellt wurde, sodass eine Änderung der Richtlinie jede Version unter der neuen erneut lesen lässt.

Eine Deprecation-Markierung, eine Signatur und ein Veröffentlichungsdatum werden jeweils als separates Objekt an eine veröffentlichte Version angehängt und verweisen auf sie zurück – das ermöglicht es einem Herausgeber, eine Version als veraltet zu markieren oder zu signieren, ohne sie erneut zu veröffentlichen –, sodass keines davon einen Tag hinzufügt oder das eigene Manifest der Version verändert. Sie verändern die Anhänge der Version, und genau das validiert die dritte Prüfung erneut. Der Versionsausschluss und aggrega inspect lesen beide diesen Index, sodass eine seit der letzten Aktualisierung zurückgezogene Version von der Auswahl ausgeschlossen und als solche angezeigt wird, sobald die nächste Aktualisierung gelaufen ist.

Jede Prüfung ist eine kleine Anfrage – das Auflösen eines Manifest-Digests oder eine bedingte Anfrage, die die Registry als unverändert beantwortet, ohne etwas zu senden –, sodass eine Aktualisierung einer unveränderten Registry nichts herunterlädt. Eine Version, die eine nicht anerkannte Deprecation-Markierung trägt oder deren Anhänge dieser Lauf auf keinem Weg erneut validieren konnte, wird bei der nächsten Aktualisierung erneut gelesen. Bei einer Registry, die nicht sagen kann, ob sich die Anhänge einer Version geändert haben, wird bei jeder Aktualisierung jede Version erneut gelesen: Die Antwort ist dieselbe, und ebenso die Kosten eines vollständigen erneuten Lesens.

--upgrade liest jedes Repository vollständig und vergleicht nichts mit dem bereits geschriebenen Index. Verwenden Sie es, um einen Index allein aus der Registry neu aufzubauen; es erfasst nichts, was eine Aktualisierung übersieht.

Eine Registry, die um Verlangsamung bittet

Der offizielle Hub, hub.aggrega.ai, begrenzt, wie viele Anfragen in kurzer Zeit von einer Adresse kommen dürfen, sodass Rechner, die sich eine Adresse teilen, sich dieses Kontingent teilen, und jede Registry kann ihre Clients auf dieselbe Weise begrenzen. Eine Registry, die ihr Limit überschritten hat, antwortet mit 429 Too Many Requests oder mit 503 Service Unavailable und einem Retry-After-Header, der angibt, wie lange zu warten ist. Jede Anfrage, die die Kommandozeile an eine Registry stellt, gleich mit welchem Befehl, begegnet dieser Antwort auf dieselbe Weise: Sie wartet so lange, wie die Registry verlangt hat, oder zehn Sekunden, wo die Antwort es nicht angibt, zuzüglich bis zu einer weiteren, zufällig gewählten Sekunde, und fragt dann erneut, ohne feste Anzahl von Versuchen. Jede Anfrage an diese Registry wartet mit, nicht nur die abgewiesene, und es werden ihr weniger Anfragen gleichzeitig gesendet — jedes Mal, wenn sie darum bittet, halb so viele, bis hinunter auf eine —, wobei die Zahl nach jeder Folge von Anfragen, die sie ohne Fehler bedient, wieder um eins steigt, zurück bis zur üblichen Zahl des Befehls. Die Wartezeit wird zu denselben Bedingungen angezeigt wie der übrige Fortschritt des Befehls, als Zeile wie hub.aggrega.ai asked to slow down; waiting 11 s: aggrega build, aggrega pull und aggrega registry update zeigen sie neben dem laufenden Schritt, die anderen Befehle, die anzeigen, worauf sie warten, zeigen sie als eigenen Schritt — außer aggrega sign --jobs beim gleichzeitigen Signieren mehrerer Referenzen, das die Wartezeiten als einen einzigen Schritt zeigt —, und wo die Standardfehlerausgabe kein Terminal ist, wird nichts angezeigt, es sei denn, --progress des Befehls verlangt es. Eine Registry, die fünf Minuten lang nichts anderes als „langsamer“ antwortet, wird unter E0378 abgewiesen, wobei die Registry, ihre letzte Antwort und die Dauer, während der sie nichts anderes geantwortet hatte, genannt werden; die fünf Minuten sind fest, und keine Einstellung ändert sie. aggrega registry update nennt diese Registry dann in seiner abschließenden Zusammenfassung unter Not indexed:, und die Registry behält den Index, den sie vor dem Lauf hatte.

Ein Lesevorgang, der fehlschlägt

Ein Durchlauf liest viele kleine Objekte aus einer Registry, und manche Lesevorgänge schlagen zwischendurch fehl: Die Registry antwortet, dass ein Fehler auftrat oder sie nicht verfügbar ist (ein Status 5xx, außer einem 503, der angibt, wie lange zu warten ist), oder dass die Anfrage in eine Zeitüberschreitung lief (ein 408), die Verbindung wird zurückgesetzt oder läuft in eine Zeitüberschreitung, oder eine Antwort bricht ab, bevor sie vollständig ist. Jeder solche Lesevorgang wird einige Male erneut angefragt, mit einer wachsenden Wartezeit zwischen den Versuchen. Eine Registry, die den Durchlauf um Verlangsamung bittet, lässt keinen Lesevorgang fehlschlagen: Der Lesevorgang wartet und wird erneut angefragt, wie Eine Registry, die um Verlangsamung bittet beschreibt, und eine Registry, die fünf Minuten lang weiter darum bittet, beendet den Durchlauf dieser Registry statt den eines einzelnen Repositorys.

Ein Lesevorgang, der weiterhin fehlschlägt, wird nie als Antwort genommen. Eine Signatur, die nicht gelesen werden konnte, ist keine Version ohne Signatur, und eine Deprecation-Markierung, die nicht gelesen werden konnte, ist keine Version, die nie zurückgezogen wurde, sodass der Durchlauf aus diesem Lauf nichts über dieses Repository festhält. Das Repository behält den Datensatz, den der Index bereits dafür hat, sofern dieser Datensatz unter der jetzt geltenden Vertrauensrichtlinie der Registry beurteilt wurde, und wird andernfalls aus dem Index herausgelassen. In beiden Fällen nennt der Durchlauf das Repository in seinen laufenden Meldungen, sagt, welcher der beiden Fälle eingetreten ist und welcher Lesevorgang fehlgeschlagen ist, und nennt es erneut in seiner abschließenden Zusammenfassung, in einer eigenen Zeile unter der Zeile seiner Registry, unter den Repositorys, die nicht gelesen werden konnten:

Indexed 1 registry.
registry.example.com: 41 entities, 1 repository could not be read, 4 reads retried
component/core/web: the registry answered 503 Service Unavailable: …

Die Zeile der Registry sagt außerdem, wie viele Lesevorgänge erneut angefragt wurden, wobei jeder Lesevorgang einmal gezählt wird, gleich wie viele Versuche er brauchte und ob er danach gelang oder nicht, und sagt 0 reads retried, wenn keiner erneut angefragt wurde. Ein Durchlauf, dessen Lesevorgänge am Ende alle gelangen, zeigt in seiner Zeile kein Repository, also sagt diese Anzahl, wie knapp er daran war, eines auszulassen.

Jede solche Zeile beginnt mit der Art des letzten Fehlschlags des Lesevorgangs – dem Status, mit dem die Registry geantwortet hat, einem Lesevorgang mit Zeitüberschreitung, einer zurückgesetzten Verbindung oder einer abgeschnittenen Antwort –, gefolgt vom Fehlschlag selbst, der sagt, um welchen Lesevorgang es sich handelte. Ein Fehlschlag, der keiner dieser Arten angehört, etwa eine Vertrauenswurzel, die nicht beschafft werden konnte, um eine Signatur dagegen zu verifizieren, wird allein als Fehlschlag angegeben. Die Methode aggrega/registryUpdate von aggrega serve antwortet mit denselben Repositorys unter skipped jedes Hosts, jeweils mit demselben reason, und mit der Anzahl der erneut angefragten Lesevorgänge als readsRetried. Dasselbe gilt für eine Aktualisierung und für --upgrade, und der nächste Durchlauf beginnt mit dem, was der Index dann enthält, wie bei jedem Repository.

Der öffentliche Schlüssel, den eine Keyed-Richtlinie pinnt

Eine Keyed-Vertrauensrichtlinie pinnt den öffentlichen Schlüssel der Registry inline als public_key des Eintrags: aggrega registry add --key <file> kopiert den Inhalt der Datei dorthin, und ebenso das Pinnen einer von der Registry angebotenen Richtlinie, die einen Schlüssel enthält. Der Wert ist ein PEM-Block mit öffentlichem Schlüssel — der Text von einer Zeile -----BEGIN PUBLIC KEY----- oder -----BEGIN RSA PUBLIC KEY----- bis zur passenden Zeile -----END —, und jeglicher Text oberhalb des Blocks wird ignoriert.

Ein Wert ohne eine Zeile -----BEGIN … PUBLIC KEY----- wird beim Laden der Konfigurationsdatei abgelehnt, wobei die Datei und der Eintrag genannt werden. registry add führt dieselbe Prüfung vor dem Schreiben durch, sodass eine --key-Datei mit etwas anderem — einem privaten Schlüssel, einem Zertifikat oder einem Schlüssel in einer anderen Kodierung — abgelehnt wird und die Konfigurationsdatei unverändert bleibt. Nur diese Zeile wird geprüft: Ob sich der Block zu einem verwendbaren Schlüssel dekodieren lässt, zeigt sich, wenn eine Signatur der Registry dagegen verifiziert wird.

Offline

aggrega registry update ist der einzige Befehl dieser Gruppe, dessen gesamte Arbeit ein Durchlauf der Registrys ist, und im Offline-Modus — dem Top-Level-Schlüssel offline in einer Konfigurationsdatei, AGGREGA_OFFLINE oder --offline — lehnt er ab, bevor er etwas durchläuft. Die Ablehnung nennt, welche der drei Quellen den Modus gesetzt hat.

Es gibt keine Teilform als Rückfall, weil der Index aufzeichnet, was jede Registry aktuell ausliefert, und das lässt sich nicht erfahren, ohne eine zu fragen. Was ein Offline-Workspace tun kann, ist den Index zu lesen, den er bereits hat: aggrega search und der Deprecation-Hinweis bei aggrega inspect lesen beide den lokalen Snapshot und benötigen überhaupt kein Netzwerk, sodass eine Aktualisierung das Einzige ist, was der Modus wegnimmt. Um für einen Lauf aus einem Offline-Workspace zu aktualisieren, übergeben Sie --offline=false.

aggrega registry add greift einmal auf das Netzwerk zu, für die Vertrauensrichtlinie, die die Registry anbietet, es sei denn, --fetch-trust=false, --identity oder --key geben an, nicht abzurufen. Im Offline-Modus wird dieser Abruf abgelehnt, bevor eine Verbindung aufgebaut wird, sodass die Registry nie gefragt wird. Das Hinzufügen einer anderen Registry als des offiziellen Hubs wird dann abgelehnt — das Hinzufügen einer Registry ist der einzige Moment, in dem ihr Vertrauen gepinnt wird, und ein ohne die Richtlinie geschriebener Eintrag würde nichts vertrauen, während jeder spätere Pull die Registry daran bindet. Die Ablehnung trägt den Kurzcode E0310 und nennt beide Wege nach vorn: Registrieren Sie sie einmal online, was --offline=false für einen Lauf erlaubt, oder pinnen Sie die Richtlinie von Hand mit --identity oder --key, was genau das registriert, was Sie angeben, und gar keinen Abruf durchführt. Der offizielle Hub wird mit seiner eingebauten Baseline hinzugefügt, mit einem Hinweis, dass der Hub nicht nach seiner Vertrauensrichtlinie gefragt wurde, weil der Workspace offline ist, und stattdessen die Baseline verwendet wird, und --fetch-trust=false registriert den Eintrag aus seinen Flags genau wie online. Dieselbe Registrierung über aggrega serve oder aggrega mcp verhält sich genauso: dieselbe Ablehnung mit denselben Worten, und ansonsten derselbe Eintrag. A registry is added offline with no trust policy to pin (Eine Registry wird offline ohne zu pinnende Vertrauensrichtlinie hinzugefügt) zitiert die Ablehnung.

list und remove ändern oder lesen die lokale Konfiguration und sind nicht betroffen.