Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

aggrega registry

Gestisce i registry e la loro policy di fiducia delle firme

Sinossi

aggrega registry

Descrizione

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.

Sottocomandi

ComandoDescrizione
aggrega registry addRegistra un registry e la sua policy di fiducia delle firme
aggrega registry listElenca i registry configurati e la loro postura di fiducia
aggrega registry removeRimuove un registry e la sua policy di fiducia da un file di configurazione
aggrega registry updateCostruisce l’indice locale ricercabile dei registry configurati

Descrizione di 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.

Flag di aggrega registry add

FlagPredefinitoDescrizione
--advisoryfalseDeclassa i fallimenti di verifica per questo registry ad avvisi invece di arrestarsi
--fetch-trusttrueScarica e fissa la policy di fiducia pubblicizzata dal registry al primo utilizzo. Usa —fetch-trust=false per saltarlo; anche —identity/—key manuali saltano il download.
--globalfalseScrive la voce nella configurazione globale condivisa da tutti i workspace. Un registry viene scritto qui per impostazione predefinita.
--identity[]Identità keyless attendibile come identity=issuer, per esempio dev@example.com=https://accounts.google.com (ripetibile; insieme in OR). Sovrascrive la policy di fiducia scaricata.
--key—Percorso di un PEM di chiave pubblica fissata, compatibile con cosign, per la verifica keyed. Sovrascrive la policy di fiducia scaricata.
--name—Alias descrittivo facoltativo per questo registry. L’host resta l’identità; l’alias si risolve in esso ovunque venga indicato un registry (ad es. —registry). Deve essere univoco tra i registry.
--require-signaturesfalseRichiede una firma su ogni artefatto scaricato da (e inviato a) questo registry
--trusted-root—Percorso di un bundle di trust root Sigstore fissato per la verifica keyless in ambienti air-gapped
--workspacefalseScrive la voce nella configurazione del workspace di questo progetto invece che nella configurazione globale.

Descrizione di 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.

Flag di aggrega registry list

FlagPredefinitoDescrizione
--output, -otableFormato di output: table|json.

Descrizione di 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.

Flag di aggrega registry remove

FlagPredefinitoDescrizione
--globalfalseRimuove la voce dalla configurazione globale condivisa da tutti i workspace.
--workspacefalseRimuove la voce dalla configurazione del workspace di questo progetto invece che dalla configurazione globale.

Descrizione di 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.

Flag di aggrega registry update

FlagPredefinitoDescrizione
--upgradefalseLegge ogni repository per intero, senza confrontare nulla con l’indice già scritto (un aggiornamento senza questa opzione rilegge già tutto ciò che è cambiato)

Cosa riporta registry update sui marcatori di deprecazione

Mentre percorre un registry, aggrega registry update legge i marcatori di deprecazione di ogni versione pubblicata e registra nell’indice locale quelli che riesce ad autenticare. Riporta l’esito di quella scansione in ogni caso, così un registry che non ha pubblicato alcun marcatore si distingue da un’esecuzione che non ne ha cercati.

Ogni marcatore letto durante la scansione produce una riga che indica il repository, la versione e la gravità registrata dall’editore — warning, error o retracted — insieme al fatto che il marcatore sia stato registrato o no. Una versione i cui allegati non sono cambiati dall’ultimo aggiornamento viene mantenuta come registrata anziché riletta, quindi il suo marcatore non viene segnalato di nuovo; il conteggio riportato sotto la include comunque. Un marcatore viene registrato solo quando la sua firma si verifica rispetto ai firmatari riconosciuti dalla policy di fiducia del registry. Uno presente ma non decodificabile, o presente ma non riconosciuto, viene segnalato come tale e lasciato fuori dall’indice anziché registrato sulla base di prove che non è stato possibile autenticare — e lo stesso vale per uno che il registry risponde di non avere. Un marcatore la cui lettura non è riuscita è un caso diverso: vedi Una lettura che non riesce.

Ogni registry riporta poi quanti marcatori il suo indice registra ora, anche quando quel numero è zero. Dove la verifica delle firme è disattivata — globalmente o per quel singolo registry — il percorso riporta invece che i marcatori non sono stati esaminati per esso. Sono due fatti diversi: il primo dice che il registry non ha pubblicato nulla su cui questo workspace possa agire, il secondo dice che questa esecuzione non aveva alcuna base di fiducia su cui giudicare un marcatore. Un registry i cui marcatori non sono stati esaminati non contribuisce alcun ritiro alla selezione delle versioni, quindi un autore che ha allegato un marcatore e vede quella riga sa perché non ha effetto.

La data di pubblicazione registrata da ogni versione

L’ora di creazione di un manifest pubblicato è fissata, quindi il suo digest dipende solo da ciò che viene pubblicato e mai da quando. La data in cui una versione è stata pubblicata viene quindi letta accanto al manifest, e aggrega registry update la registra per ogni versione con la fonte da cui proviene:

  • transparency-log — dove la firma della versione è keyless e si verifica rispetto alla policy di fiducia del registry, l’ora in cui il log di trasparenza ha registrato quella firma, attestata dalla promessa firmata del log. Dove si verificano più firme della versione, è la prima delle loro ore, e il firmatario registrato per la versione è quello della stessa firma — in qualunque ordine il registry elenchi le firme — così una versione firmata di nuovo mantiene la sua data e il suo firmatario. Per una versione firmata al momento della pubblicazione, questa è la sua pubblicazione; per una firmata per la prima volta in seguito con aggrega sign, è il momento in cui è stata firmata. Questa fonte prevale ovunque esista.
  • publisher — altrimenti, l’ora che la pubblicazione ha dichiarato accanto a ciò che ha pubblicato: un piccolo allegato published-at che aggrega push e aggrega push-artifact scrivono riportando l’orologio della macchina che pubblica, che nulla attesta. Viene letto da qualsiasi registry, qualunque sia la sua policy di fiducia, perché è la dichiarazione dell’editore anziché una decisione di fiducia. Dove ne sono allegati diversi, viene preso il primo.

Una versione priva di entrambe non registra alcuna data. Si tratta di una pubblicazione che non ne ha dichiarata alcuna, dove la sua firma non è una firma keyless che questa policy verifica — per esempio una pubblicazione keyless letta sotto una policy che non considera attendibile alcuna identità keyless, poiché una pubblicazione keyless non dichiara alcuna data propria. aggrega search -o json riporta la data sotto ogni versione in published.

Che cosa rilegge un aggiornamento

Un aggiornamento confronta ciò che il registry serve ora con ciò che l’indice ha registrato, e rilegge tutto ciò che è cambiato — la stessa risposta che dà una rilettura completa. Per ogni repository:

  • riconvalida l’elenco dei tag, così una versione pubblicata o eliminata nel frattempo viene rilevata;
  • risolve il tag di ogni versione nel manifest che nomina, così una versione precedente ripubblicata con il suo tag esistente viene riletta;
  • riconvalida gli allegati di ogni versione — le sue firme, le sue dichiarazioni di data di pubblicazione e i suoi marcatori di deprecazione — così una firma, una data o un marcatore allegati a una versione nel frattempo vengono letti e verificati, e fa lo stesso per le firme di un marcatore di deprecazione che ha già valutato in precedenza;
  • confronta la policy di fiducia del registry con quella con cui è stato costruito l’indice, così una modifica alla policy fa rileggere ogni versione con quella nuova.

Un marcatore di deprecazione, una firma e una data di pubblicazione sono ciascuno allegati a una versione pubblicata come oggetto separato che punta a essa — ed è questo che permette a un editore di deprecare o firmare una versione senza ripubblicarla — quindi nessuno di essi aggiunge un tag o modifica il manifest della versione stessa. Modificano gli allegati della versione, ed è questo che il terzo controllo riconvalida. L’esclusione delle versioni e aggrega inspect leggono entrambi questo indice, quindi una versione ritirata dopo l’ultimo aggiornamento viene esclusa dalla selezione, e mostrata, una volta eseguito l’aggiornamento successivo.

Ogni controllo è una piccola richiesta — la risoluzione del digest di un manifest, o una richiesta condizionale a cui il registry risponde come invariata senza inviare nulla — quindi l’aggiornamento di un registry invariato non scarica nulla. Una versione che porta un marcatore di deprecazione non riconosciuto, o i cui allegati questa esecuzione non ha avuto modo di riconvalidare, viene riletta all’aggiornamento successivo. Un registry che non sa dire se gli allegati di una versione sono cambiati fa rileggere ogni versione a ogni aggiornamento: la risposta è la stessa, e lo è anche il costo di una rilettura completa.

--upgrade legge ogni repository per intero, senza confrontare nulla con l’indice già scritto. Usalo per ricostruire un indice a partire dal solo registry; non rileva nulla che un aggiornamento non rilevi.

Un registry che chiede di rallentare

L’hub ufficiale, hub.aggrega.ai, limita quante richieste possono provenire da un singolo indirizzo in un breve intervallo, quindi le macchine che condividono un indirizzo condividono quella quota, e qualsiasi registry può limitare i propri client allo stesso modo. Un registry oltre il proprio limite risponde 429 Too Many Requests, oppure 503 Service Unavailable con un header Retry-After che indica quanto attendere. Ogni richiesta che la riga di comando rivolge a un registry, qualunque sia il comando, reagisce a quella risposta allo stesso modo: attende quanto il registry ha chiesto, o dieci secondi dove la risposta non lo dice, più fino a un secondo in più scelto a caso, e poi chiede di nuovo, senza un numero fisso di tentativi. Ogni richiesta rivolta a quel registry attende con essa, non solo quella rifiutata, e gliene vengono inviate meno contemporaneamente — la metà ogni volta che lo chiede, fino a una — risalendo di una dopo ogni serie di richieste che serve senza errori, fino al numero abituale del comando. L’attesa viene mostrata alle stesse condizioni del resto dell’avanzamento del comando, come una riga quale hub.aggrega.ai asked to slow down; waiting 11 s: aggrega build, aggrega pull e aggrega registry update la mostrano accanto al passaggio in corso, gli altri comandi che mostrano ciò che attendono la mostrano come un passaggio a sé — tranne aggrega sign --jobs che firma più riferimenti contemporaneamente, che mostra le attese come un unico passaggio — e non viene mostrato nulla dove lo standard error non è un terminale, a meno che il --progress del comando non lo richieda. Un registry che per cinque minuti non risponde altro che «rallenta» viene rifiutato con E0378, indicando il registry, la sua ultima risposta e da quanto tempo non rispondeva altro; i cinque minuti sono fissi e nessuna impostazione li modifica. aggrega registry update indica quindi quel registry sotto Not indexed: nel riepilogo finale, e il registry mantiene l’indice che aveva prima dell’esecuzione.

Una lettura che non riesce

Una scansione legge molti piccoli oggetti da un registry, e alcune letture falliscono occasionalmente: il registry risponde di aver avuto un errore o di non essere disponibile (uno stato 5xx, diverso da un 503 che indica quanto attendere) o che la richiesta è andata in timeout (un 408), la connessione viene reimpostata o va in timeout, oppure una risposta si interrompe prima di essere completa. Ciascuna di queste letture viene ritentata alcune volte, con un’attesa crescente tra un tentativo e l’altro. Un registry che chiede alla scansione di rallentare non sta facendo fallire una lettura: la lettura attende e viene ritentata come descrive Un registry che chiede di rallentare, e un registry che continua a chiederlo per cinque minuti termina la scansione di quel registry anziché quella di un singolo repository.

Una lettura che fallisce ancora non viene mai presa come risposta. Una firma che non è stato possibile leggere non è una versione senza firma, e un marcatore di deprecazione che non è stato possibile leggere non è una versione mai ritirata, quindi la scansione non registra nulla su quel repository da questa esecuzione. Il repository mantiene il record che l’indice ha già per esso, dove quel record è stato valutato secondo la policy di fiducia del registry ora in vigore, e altrimenti viene lasciato fuori dall’indice. In entrambi i casi la scansione nomina il repository nel suo resoconto in corso, dicendo quale delle due cose è accaduta e quale lettura è fallita, e lo nomina di nuovo nel riepilogo finale, su una riga a sé sotto la riga del suo registry, tra i repository che non è stato possibile leggere:

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

La riga del registry indica anche quante letture sono state ritentate, ciascuna contata una volta sola indipendentemente da quanti tentativi abbia richiesto e dal fatto che sia poi riuscita o no, e indica 0 reads retried quando non ne è stata ritentata nessuna. Una scansione le cui letture sono alla fine tutte riuscite non mostra alcun repository sulla sua riga, quindi è questo conteggio a dire quanto è andata vicina a escluderne uno.

Ogni riga di questo tipo si apre con il tipo dell’ultimo errore della lettura — lo stato con cui ha risposto il registry, una lettura andata in timeout, una connessione reimpostata o una risposta troncata — seguito dall’errore stesso, che dice di quale lettura si trattava. Un errore che non è di nessuno di questi tipi, come una radice di fiducia che non è stato possibile ottenere per verificarvi una firma, viene riportato come solo errore. Il metodo aggrega/registryUpdate di aggrega serve risponde con gli stessi repository sotto skipped di ciascun host, ognuno con lo stesso reason, e con il conteggio delle letture ritentate come readsRetried. Lo stesso vale per un aggiornamento e per --upgrade, e la scansione successiva parte da ciò che l’indice contiene in quel momento, come per qualsiasi repository.

La chiave pubblica fissata da una policy keyed

Una policy di fiducia keyed fissa inline la chiave pubblica del registry, come public_key della voce: aggrega registry add --key <file> vi copia il contenuto del file, e lo stesso fa il pinning di una policy che il registry pubblicizza con una chiave al suo interno. Il valore è un blocco PEM di chiave pubblica — il testo da una riga -----BEGIN PUBLIC KEY-----, o -----BEGIN RSA PUBLIC KEY-----, fino alla riga -----END corrispondente — e qualsiasi testo sopra il blocco viene ignorato.

Un valore privo di una riga -----BEGIN … PUBLIC KEY----- viene rifiutato al caricamento del file di configurazione, nominando il file e la voce. registry add esegue lo stesso controllo prima di scrivere, quindi un file --key che contiene qualsiasi altra cosa — una chiave privata, un certificato o una chiave in un’altra codifica — viene rifiutato e il file di configurazione resta com’era. Viene controllata solo quella riga: se il blocco si decodifica in una chiave utilizzabile si scopre quando una firma del registry viene verificata rispetto a esso.

Offline

aggrega registry update è l’unico comando di questo gruppo il cui intero lavoro è un percorso dei registry, e in modalità offline — la chiave di primo livello offline in un file di configurazione, AGGREGA_OFFLINE o --offline — rifiuta prima di percorrere qualsiasi cosa. Il rifiuto indica quale dei tre ha impostato la modalità.

Non esiste alcuna forma parziale su cui ripiegare, perché l’indice registra ciò che ogni registry serve attualmente e questo non si può sapere senza chiederlo a un registry. Ciò che un workspace offline può fare è leggere l’indice che ha già: aggrega search e l’avviso di deprecazione di aggrega inspect leggono entrambi lo snapshot locale e non richiedono alcuna rete, quindi un aggiornamento è l’unica cosa che la modalità toglie. Per aggiornare per un’esecuzione da un workspace offline, passa --offline=false.

aggrega registry add raggiunge la rete una sola volta, per la policy di fiducia che il registry pubblicizza, a meno che --fetch-trust=false, --identity o --key non indichi di non scaricarla. In modalità offline quel download viene rifiutato prima di qualsiasi connessione, quindi al registry non viene mai chiesto nulla. Aggiungere un registry diverso dall’hub ufficiale viene allora rifiutato — aggiungere un registry è l’unico momento in cui la sua fiducia viene fissata, e una voce scritta senza la policy non considererebbe attendibile nulla mentre ogni pull successivo vincolerebbe il registry a essa. Il rifiuto porta il codice breve E0310 e nomina entrambe le strade possibili: registralo una volta mentre sei online, cosa che --offline=false consente per una singola esecuzione, oppure fissa la policy a mano con --identity o --key, che registra esattamente ciò che fornisci e non esegue alcun download. L’hub ufficiale viene aggiunto con la sua baseline integrata, con un avviso che dice che all’hub non è stata chiesta la sua policy di fiducia perché il workspace è offline e al suo posto viene usata la baseline, e --fetch-trust=false registra la voce dai suoi flag esattamente come fa online. La stessa registrazione effettuata tramite aggrega serve o aggrega mcp si comporta allo stesso modo: lo stesso rifiuto con le stesse parole, e altrimenti la stessa voce. A registry is added offline with no trust policy to pin (Un registry viene aggiunto offline senza alcuna policy di fiducia da fissare) riporta il rifiuto.

list e remove modificano o leggono la configurazione locale e non ne sono interessati.