Versione 1.0.0-alpha.1ultima
Capitolo 2.22
Il runtime del plugin
I moduli dell'SDK (software development kit) su cui viene eseguito il plugin, dalla protezione dell'ambito e il perimetro del database fino all'invio tramite UNO, alla lettura dell'instradamento dell'IA (intelligenza artificiale) e ai controlli delle licenze. Infine, i test su un database reale, la registrazione delle skill e l'onboarding.
Questa pagina è stata tradotta dall'IA a partire dall'originale in inglese. In caso di dubbi, fa fede la pagina in inglese. Legga questa pagina in inglese

La parte di runtime dell'SDK (kit di sviluppo software) è un insieme di moduli sotto @adverant-nexus/plugin-sdk/runtime/*, oltre a funzioni di supporto per i test sotto testing/*. Li importa; non li reimplementa. Questa è l'idea di fondo, e mi è bastata una revisione respinta per prenderla sul serio: la nota del revisore sul controllo dell'ambito scritto a mano nel mio primo plugin era di una sola riga: "l'SDK dispone già di questa funzione e la sua accetta un token di verifica MFA (autenticazione a più fattori) come sessione".
Questo capitolo segue una richiesta attraverso un plugin in esecuzione, nel modo in cui il modello a servizio completo la collega: la guardia dell'ambito, la barriera del database, l'unico attraversamento consentito, l'invio tramite UNO, la lettura dell'instradamento dell'IA (intelligenza artificiale) e i controlli delle licenze. Tratta poi i test, la registrazione delle competenze del manifesto e le fasi di onboarding.
Ambito: una protezione per framework
Ogni rotta /api integra la guardia dell'ambito. Essa verifica il token bearer, ne risolve i tre assi (tenant, proprietario, unità), rifiuta un corpo che indica un tenant, applica il diritto della rotta dal registro del manifesto e solo allora consente l'esecuzione del gestore. L'SDK fornisce un adattatore per framework, tutti da @adverant-nexus/plugin-sdk/runtime/scope e tutti con le stesse opzioni.
| Framework | Adattatore |
|---|---|
| Express | scopeMiddleware |
| Fastify | requireScope, come preHandler |
| Next | withScope, che avvolge il gestore; a un gestore Next non viene comunicata la sua rotta, quindi withScope la riceve come terzo argomento |
Ecco il cablaggio Express del modello, in versione ridotta. Il verificatore è quello dell'SDK e vincola il token al formato di sessione del servizio di identità: solo HS256; iss, exp, iat e jti obbligatori; una durata massima di un'ora; e nessun token di verifica MFA, di impersonificazione o di risorsa OAuth (lo standard aperto per l'autorizzazione delegata) ammesso come sessione.
import { platformAccessTokenVerifier } from "@adverant-nexus/plugin-sdk/runtime/platform-token";
import { scopeMiddleware } from "@adverant-nexus/plugin-sdk/runtime/scope";
const requireScope = scopeMiddleware({
verify: platformAccessTokenVerifier(config.PLATFORM_JWT_SECRET),
rights: { manifest },
});
router.get("/api/projects", requireScope, async (req, res) => {
res.json({ projects: await db.listProjects(scopeOf(req)) });
});La guardia dei diritti applica il diritto di una rotta in quattro passaggi. Un ruolo nell'elenco never del diritto rifiuta con AUTHORITY_EXCEEDED e le parole barred, e nessuna postazione lo rimuove. Un ruolo in roles ammette, anche con una postazione attiva quando il diritto indica seat: true. Altrimenti, una postazione attiva dotata del diritto ammette. In caso contrario, la richiesta viene rifiutata con AUTHORITY_EXCEEDED, indicando le persone che potrebbero concedere una postazione. Fornisca un archivio (rights: { manifest, store: { pool, schema } }) alla guardia ed essa leggerà le postazioni nell'ambito del chiamante stesso; un diritto che indica un licence richiede anche un lettore di licenze, trattato più avanti.
All'interno di un gestore, scopeOf(req) è l'unico modo per leggere l'ambito risolto e genera un'eccezione se la guardia non è stata eseguita. Una guardia registrata su un prefisso, in esecuzione prima che qualsiasi rotta abbia trovato corrispondenza, risponde con 500 MIDDLEWARE_ORDERING_ERROR; una rotta registrata dal codice ma non dichiarata dal manifesto risponde con 500 UNHANDLED_ERROR. Entrambe falliscono in modo sicuro (fail closed).
Le rotte /internal del modello, chiamate dalla piattaforma, utilizzano l'altro regime. La guardia del servizio controlla X-Service-Key in tempo costante e preleva il tenant da X-Organization-ID della piattaforma, rifiutando MISSING_SERVICE_KEY, INVALID_SERVICE_KEY o MISSING_ORG_ID_HEADER. Per il token firmato per singola chiamata della piattaforma, l'SDK dispone di requireService (Fastify) e serviceMiddleware (Express), che controllano anche per quale competenza e rotta è stato emesso il token e rifiutano un token utilizzato due volte.
La barriera del database: tenantFence e withScopedTx
Ogni istruzione su una tabella con ambito compone la barriera e viene eseguita all'interno di una transazione con ambito:
import { withScopedTx } from "@adverant-nexus/plugin-sdk/runtime/db";
import { tenantFence } from "@adverant-nexus/plugin-sdk/runtime/fence";
async function listProjects(scope: ResolvedScope) {
// Projects are owner-private inside the organisation, so the owner axis is passed explicitly.
const f = tenantFence(scope, { alias: "p", owner: scope.owner });
const r = await withScopedTx(pool, scope, { schema: SCHEMA }, (db) =>
db.query(`SELECT p.* FROM anomaly_review.reviews p WHERE ${f.where} ORDER BY p.created_at DESC`, f.params),
);
return r.rows;
}tenantFence(scope, options) costruisce il predicato e i relativi parametri a partire da un ambito risolto. Passi owner per le tabelle personali; lo ometta per gli artefatti dell'organizzazione in cui il proprietario rappresenta la provenienza. Quando l'istruzione ha già dei parametri, startIndex indica alla barriera da dove iniziare la numerazione. Un inserimento non riceve mai gli assi come input: scrive scope.tenant, scope.owner e scope.unit prelevandoli dall'ambito.
withScopedTx associa tutti e tre gli assi per una transazione tramite l'unica funzione di associazione dello schema, quindi esegue la callback. Una seconda associazione nella stessa transazione solleva SCOPE_ALREADY_BOUND (500: il codice ha eseguito l'associazione due volte; il chiamante non ha commesso errori). Un tenant o un proprietario assente o pari a zero solleva SCOPE_PREDICATE_INVALID (403). L'impostazione è locale alla transazione, pertanto una connessione in pool non può trasferire un tenant alla richiesta successiva.
Due funzioni affini coprono i casi che non riguardano la richiesta di una persona. withTenantScopedTx associa tenant e unità senza proprietario, per le righe lette da una macchina (il registro dei dispositivi), e rifiuta un ambito che include un proprietario. maintenanceScope(reason) impone a un'operazione a livello di intera organizzazione di dichiarare esplicitamente la propria natura prima che la transazione del proprietario si apra. La barriera del codice e la sicurezza forzata a livello di riga sono due meccanismi per un'unica legge; il controllo all'avvio si rifiuta di mettersi in ascolto finché il database non dimostra che il secondo è attivo (altrimenti restituisce DB_ROLE_BYPASSES_ISOLATION).
Ogni rifiuto è una riga
Il modello installa un ulteriore componente middleware, una sola volta, tra il parser del corpo e i router: il registro dei rifiuti.
import { recordRefusals } from "@adverant-nexus/plugin-sdk/runtime/refusal-ledger";
app.use(express.json({ limit: "256kb" }));
app.use(recordRefusals({ pool, schema: SCHEMA }));Esso avvolge la risposta in modo che ogni rifiuto letto da una persona, proveniente dalla guardia dei diritti, da un gestore o da un archivio, venga scritto nella tabella refusal dello schema all'interno della transazione con ambito di quella stessa persona prima dell'invio del corpo. Un errore 401 anonimo non scrive nulla. Se la riga non può essere scritta, la risposta diventa UNHANDLED_ERROR: un "no" che il prodotto non può registrare non viene inviato come se lo fosse. L'avvio esegue assertRefusalLedger per verificare che la tabella possa accogliere la riga del registro, e un archivio può chiamare noteSubject({ recordId, isDemo }) affinché ogni rifiuto indichi il record a cui si riferiva. Quando un cliente chiede perché qualcuno è stato respinto martedì scorso, la risposta è una query, non un'ipotesi.
L'unico attraversamento: una concessione di sola lettura registrata
Quando uno dei suoi clienti svolge un lavoro per un altro e quest'ultimo può ispezionarlo, esiste un unico modo autorizzato per attraversare il confine. L'organizzazione che detiene le righe registra una concessione. L'organizzazione del lettore ammette una persona tramite una postazione dotata del diritto granted.read, che deve indicare owner e admin in never. La lettura viene eseguita come sesto ruolo del database, la postazione di lettura, che può eseguire selezioni solo sulle tabelle elencate da databases[].granted:
const r = await withSeatTx({ app: appPool, seat: seatPool }, seatsOf(req), { holder, grantId }, { schema: "anomaly_review" }, (db) => {
const f = grantFence(db.seat, { alias: "r" });
return db.query(`SELECT r.review_id FROM anomaly_review.reviews r WHERE ${f.where}`, f.params);
});
if (!r.ok) return res.status(r.status).json(r.refusal);withSeatTx scrive prima la consultazione nel tenant del lettore stesso, quindi associa la postazione di lettura alla concessione, il che scrive la consultazione nel tenant del titolare. La policy stessa del database verifica che la concessione indichi l'organizzazione del lettore, copra la tabella, sia iniziata, non sia terminata e non sia stata revocata, e che questa transazione abbia scritto la propria consultazione. Una lettura che salta la consultazione non vede nulla. All'avvio, assertSeatAtBoot(seatPool, schema) verifica che il pool aperto da seat.url sia effettivamente la postazione e nient'altro, rifiutando altrimenti con DB_SEAT_ROLE_INVALID.
Invio tramite UNO
Tutto il calcolo passa attraverso un unico client, costruito in un unico file, con un elenco di elementi consentiti (allow-list) chiuso:
import { UnoClient } from "@adverant-nexus/plugin-sdk/runtime/uno";
/** The namespaced job types this surface may dispatch. Closed; edit in code. */
export const DISPATCHABLE = Object.freeze([`${manifest.name}.sentiment_score`] as const);
export function createUno(deps: UnoDeps): UnoClient {
return new UnoClient({
baseUrl: deps.dispatchUrl,
serviceKey: deps.serviceKey,
callerService: manifest.name,
dispatchable: DISPATCHABLE,
});
}L'elenco degli elementi consentiti è intenzionalmente una costante a livello di modulo. Se un operatore potesse ampliarlo dalla configurazione, la rotta diventerebbe un proxy di invio per l'intero registro. Il test stesso del modello verifica che l'elenco indichi esattamente i tipi di job generati dalla compilazione del manifesto.
La busta
Un invio contiene sei campi nel suo nucleo obbligatorio. Il client compila il tenant e l'attore dall'ambito verificato, mai dalla richiesta:
| Campo | Contenuto |
|---|---|
jobType |
Il tipo di job con namespace, <plugin name>.<skill id> |
organizationId |
Il tenant, dall'ambito |
userId |
L'attore, dall'ambito, per l'audit e la fatturazione |
inputParams |
L'input della competenza. Non contiene mai un ID tenant; se lo contiene, viene rifiutato al momento dell'invio |
priority |
critical, high, normal o low |
pluginId |
Il name del suo manifesto. Ogni invio dichiara il proprio plugin di origine |
I campi facoltativi includono correlationId (un UUID, identificatore universalmente univoco, oppure ne viene generato uno nuovo) e callbackUrl, necessario a una competenza plugin_queue affinché il worker sappia dove pubblicare il proprio risultato.
const accepted = await uno.dispatch(scope, {
jobType: DISPATCHABLE[0],
inputParams: { text: text.body },
priority: "normal",
pluginId: manifest.name,
correlationId: crypto.randomUUID(),
});
if (!accepted.ok) return res.status(statusFor(accepted.refusal.code)).json(accepted.refusal);
res.status(202).json(accepted.value);202, quindi polling
Ogni invio viene accodato. La risposta è sempre 202 con identificatori (jobId, runId, traceId, status), mai un risultato. Il risultato proviene dal polling del job o dalla callback. uno.peek(jobId, { scope }) lo legge una volta e awaitJob esegue il polling fino a uno stato terminale; entrambi inviano il tenant dall'ambito verificato ed entrambi controllano il organization_id della riga restituita rispetto al tenant del chiamante sul suo lato della chiamata di rete, rifiutando una mancata corrispondenza con SCOPE_REFUSED.
Legga la riga di esecuzione nella sua grafia esatta. La risposta di invio indica jobId; la riga indica job_id, organization_id e plugin_id. Le colonne del risultato e dell'errore sono result, error, error_code e error_troubleshooting. completed e failed sono terminali. timed_out, cancelled e system_failure provengono dal reaper e un risultato tardivo può ancora correggerli. Un client che tratta uno qualsiasi di questi valori come non analizzabile rifiuta righe che la piattaforma scrive ogni giorno.
Il blocco per approvazione
Una competenza del manifesto che dichiara approval viene bloccata al momento dell'invio. Il 202 indica quindi status: "awaiting_approval" e contiene un waitpointId, con il motivo fornito dal manifesto. L'esecuzione rimane bloccata finché una persona designata non si pronuncia in merito. uno.approve e uno.resolveWaitpoint inviano il tenant e il chiamante come attore, e una decisione presa da qualcuno diverso dal chiamante verificato viene rifiutata. Un'approvazione rilascia il job una sola volta ed esegue nuovamente i controlli di invio; un rifiuto lo termina con failed. Una seconda decisione viene rifiutata, così come una decisione successiva alla scadenza del blocco. Se il suo prodotto richiede che l'approvatore sia una persona diversa dal proponente, imponga tale regola nella rotta che emette la decisione: la piattaforma registra entrambi.
Visualizzi un job bloccato come bloccato. Non comunichi a una persona che il suo clic lo ha rilasciato finché la riga di esecuzione non lo conferma.
IA: preferenze sulla riga della skill e una sola lettura
Il suo plugin non chiama mai un modello. Quando una competenza del manifesto ne richiede uno (llm_only o tool_using, al livello di attendibilità core o verified), lei esprime le preferenze sulla relativa riga del registro e il router decide attingendo dal pool dell'organizzazione stessa:
{
"execution_config_skill": {
"preferredProvider": "gemini",
"capabilityProfile": { "needsToolUse": true, "dataResidency": "eu_only" }
}
}preferredProvider e preferredModel sono preferenze che il router rispetta solo quando l'organizzazione ha quel fornitore abilitato e dotato di credenziali. capabilityProfile filtra e non seleziona mai; il suo dataResidency (eu_only, us_only o any) è un vincolo rigido che il router soddisfa o rifiuta. Ometterli tutti è solitamente la scelta corretta. modelOverride esiste per le rare competenze che necessitano di un modello esatto e rende inattive le preferenze adiacenti; consiglierei di evitarlo a meno che la competenza non sia priva di senso su qualsiasi altro modello.
Quando la sua interfaccia deve mostrare quale modello utilizzerebbe il router, lo legga, non cerchi di prevederlo:
import { createAIRouteClient } from "@adverant-nexus/plugin-sdk/runtime/ai-route";createAIRouteClient(...).effectiveRoute() è l'unica lettura autorizzata dell'AI Provider Router. Riceve l'indirizzo del gateway, il token bearer del chiamante stesso e lo slug della piattaforma, e non invia alcuna richiesta di IA. Restituisce il fornitore e il modello, i fornitori consentiti dalla policy e indica se l'endpoint scelto esegue local o external. Quando la rotta non è utilizzabile, restituisce il rifiuto del router a parole (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE o NO_MODEL_FOR_ROLE_AND_PROVIDER, con la relativa soluzione), mai un modello predefinito. Mostri tale rifiuto alla persona; è la configurazione della sua organizzazione che parla.
Controlli delle licenze
Tre meccanismi controllano le licenze, a tre livelli di granularità.
Un diritto che indica una licenza. Il più semplice. Nel manifesto, un diritto contiene licence: "<feature>" e la guardia chiede al servizio di identità se la licenza dell'organizzazione lo include, utilizzando il token del chiamante stesso, prima che venga letto qualsiasi ruolo. Costruisca la guardia con un lettore:
import { createLicenceReader } from "@adverant-nexus/plugin-sdk/runtime/licence";
const requireScope = scopeMiddleware({
verify,
rights: { manifest, store: { pool, schema: SCHEMA }, licence: createLicenceReader({ baseUrl: config.NEXUS_AUTH_URL }) },
});Una licenza che non include la funzionalità oppone un rifiuto a tutti con LICENCE_LOCKED, indicando cosa la include e specificando che i proprietari e gli amministratori dell'organizzazione possono attivarla. Una licenza che non può essere letta oppone un rifiuto con UNHANDLED_ERROR: una funzionalità bloccata non viene mai erogata perché la licenza non era raggiungibile. Le risposte vengono memorizzate per 30 secondi per organizzazione e funzionalità.
Il gate del prodotto. createProductGate({ baseUrl, product }) da runtime/product-gate chiede al controllo delle autorizzazioni se l'organizzazione del chiamante possiede effettivamente il prodotto, e il suo middleware() viene eseguito dopo la guardia dell'ambito. Un verdetto negativo restituisce ENTITLEMENT_DENIED; un controllo non raggiungibile restituisce ENTITLEMENT_UNREACHABLE, e il gate non tratta mai l'uno come l'altro.
Il documento di licenza stesso. Il codice che deve decidere autonomamente a partire dalla licenza firmata, come il modulo chiuso di un domain pack, utilizza verifyLicenceDocument(docText, opts) da runtime/licence-document. È una funzione pura: nessuna chiamata di rete, nessuna variabile d'ambiente, nessun file. Controlla entrambe le firme rispetto alle radici di attendibilità incluse nella build e restituisce uno stato (VALID, WARN, GRACE, RESTRICT, TERMINATE o ABSENT) con le concessioni, i componenti aggiuntivi e i domain pack. licenceAllows(verdict, featureGroup, action, tenantId?) indica quindi se è consentito eseguire use o provision sotto un gruppo. RESTRICT consente use e risponde a provision con LICENCE_LOCKED, in modo che il lavoro in esecuzione continui e non ne venga avviato alcuno nuovo.
Test
I test del modello mostrano lo schema; questi sono gli strumenti che vi stanno dietro.
Simulazioni dell'ambito. Costruisca il sostituto di test dell'ambito risolto una sola volta, in test/scope-fakes.ts, e lo inietti ovunque, inclusi i casi di assenza: nessuna unità, nessun token, un token con un'organizzazione pari a zero. I percorsi di rifiuto sono il prodotto.
Un trasporto di invio simulato. UnoClient riceve fetch, now e sleep, in modo che un unit test non tocchi mai la rete. Verifichi tramite asserzioni i campi della busta, la struttura di 202, il polling fino a una riga terminale con il relativo organization_id e che una riga per un altro tenant venga scartata.
Un vero Postgres. Una funzione di query simulata dimostra la validità di una stringa SQL. Non può dimostrare che la sicurezza forzata a livello di riga sia attiva o che i file vengano applicati in ordine come fa il migratore. testing/ephemeral-postgres avvia un server temporaneo ed esegue lo stesso nexus-migrate eseguito in produzione:
import { EPHEMERAL_REMEDY, migrated, startEphemeralPostgres } from "@adverant-nexus/plugin-sdk/testing/ephemeral-postgres";
const pg = await startEphemeralPostgres(); // null off CI: skip each case by name with EPHEMERAL_REMEDY
const db = migrated(pg!, "plugin_test", { root }); // provision as the superuser, then every file as the migrator
// connect as db.appUrl and run the boot checks the server runsFuori dalla CI (integrazione continua), una macchina priva di server Postgres salta per nome ogni caso di test del database indicandone il rimedio, senza mai dare esito positivo (verde). In CI la stessa assenza fa fallire la suite (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), perché un test di sicurezza a livello di riga saltato è un semaforo verde che non ha misurato nulla. Il server attende fino a 180 secondi per avviarsi e un watchdog lo arresta quando il processo di test termina.
L'infrastruttura di test dell'isolamento. runIsolationHarness(target) da testing/isolation-harness legge ogni rotta montata dall'app e attacca ciascuna di esse come amministratore di un'altra organizzazione e come collega. Quindi attacca nuovamente rimuovendo la barriera del codice, la barriera del database ed entrambe. Una rotta è PROVEN solo quando l'attacco fallisce con una delle due barriere attiva e raggiunge i dati della vittima quando entrambe sono rimosse, in modo da avere la certezza che il test sia effettivamente in grado di rilevare una perdita di dati. Invia la query dichiarata e il corpo di esempio di ciascuna rotta, affinché anche una rotta che rifiuta una richiesta vuota venga comunque raggiunta. Fissi ledgerOf(report) in un test e imposti il fallimento su defectsOf(report).
Registrazione: dal manifest al registro delle skill
Le competenze del suo manifesto raggiungono il registro delle competenze attraverso un unico percorso:
manifest.skills[] → compileRegistry(manifest) → POST /api/v1/plugins/sync
compileRegistry trasforma un manifesto convalidato nel corpo nexus.plugin-sync/v1. Il modello lo fa al momento dell'importazione, pertanto un manifesto non valido fa fallire la build:
import { compileRegistry, definePlugin } from "@adverant-nexus/plugin-sdk";
export const manifest = definePlugin(raw);
export const registryPayload = compileRegistry(manifest);{
"contract": "nexus.plugin-sync/v1",
"pluginId": "anomaly-review",
"version": "0.3.0",
"skills": [ { "job_type": "anomaly-review.excursion_summary", "tier": "host_callback", "classification": "tenant" } ]
}La sincronizzazione è dichiarativa: invii ogni volta l'intero set di competenze e una competenza omessa verrà disabilitata, mantenendone la cronologia. È rigorosa: un campo sconosciuto, un campo di un altro livello o un null vengono rifiutati, tutte le violazioni vengono restituite insieme in un unico 400 SYNC_CONTRACT_VIOLATION e non viene scritto nulla finché ne è presente anche solo una. Inoltre, scrive una riga di registro per competenza, indicizzata sul tipo di job con namespace, contenente ogni colonna letta dal dispatcher, in modo che la competenza sia eseguibile nel momento stesso in cui la sincronizzazione risponde con 200.
Il plugin è il chiamante autenticato, mai un campo del corpo. Chiami la sincronizzazione dal carico di lavoro stesso del plugin tramite mTLS (TLS reciproco: Transport Layer Security con un certificato su entrambe le estremità). Lo Skills Engine legge il certificato client del carico di lavoro, la cui identità SPIFFE (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) indica il namespace e il service account, e cerca il plugin e l'organizzazione proprietaria registrati per quel namespace. Il pluginId del corpo deve corrispondere; è una verifica, non un selettore. Ogni riga viene scritta con quel plugin e quell'organizzazione.
| Stato | Codice | Significato |
|---|---|---|
| 200 | {contract, pluginId, version, created, updated, unchanged, disabled, skills} |
|
| 400 | SYNC_CONTRACT_VIOLATION |
Ogni violazione elencata in violations[]; nulla viene scritto |
| 401 | UNAUTHORIZED |
Chiave di servizio errata o mancante |
| 401 | CALLER_IDENTITY_UNVERIFIED |
Nessuna identità client leggibile |
| 403 | DELIVERY_IDENTITY_MISSING |
Il namespace chiamante non appartiene ad alcun plugin |
| 403 | PLUGIN_ID_MISMATCH |
Il corpo indica un altro plugin |
| 409 | REGISTRY_CONFLICT |
Un tipo di job appartiene ad altri o è stato registrato al di fuori della sincronizzazione; nulla viene scritto |
Imposti il fallimento della fase di distribuzione per qualsiasi stato diverso da 200. Nessun altro stato significa che le competenze sono state registrate.
Onboarding
L'onboarding viene eseguito in dieci passaggi ordinati, ciascuno dei quali può essere rieseguito, annullato o sottoposto a rollback singolarmente:
- Clonare il repository e convalidarlo.
- Analizzare il manifesto.
- Scansionarlo per individuare problemi di sicurezza.
- Costruire l'immagine.
- Inviarla tramite push al registro dell'installazione.
- Configurare i relativi nomi di dominio.
- Distribuirla attraverso i canali di rilascio dell'installazione.
- Attendere il controllo di integrità (health check).
- Registrare il plugin.
- Informare lo sviluppatore.
Prima della distribuzione, vengono eseguiti cinque controlli di conformità sul manifesto e sull'immagine costruita: il manifesto viene analizzato correttamente e contiene i campi obbligatori; ogni rotta dichiarata è una rotta reale registrata; il plugin possiede il proprio schema e non scrive nulla al di fuori di esso; le richieste di risorse sono dichiarate e rientrano nei limiti; e l'immagine dispone di un gestore di integrità funzionante. Un plugin che si registra all'avvio esegue lo stesso contratto sotto la propria autorità, in modo che i controlli diventino la sua CI anziché quella della pipeline. Saltarne uno non abbrevia l'onboarding; sposta semplicemente il fallimento al runtime.
Gli elementi di branding nel manifesto vengono serviti senza autenticazione in base al dominio, poiché la pagina di accesso ne ha bisogno prima che chiunque disponga di una credenziale. Tratti tutto ciò che si trova in branding come pubblico.
GATE_CANNOT_BE_SKIPPED.Cosa non farà il runtime al posto vostro
Il runtime mantiene una linea ferma su isolamento, invio e accesso ai modelli. Non renderà corretta la logica del suo prodotto e non renderà veloce una query lenta: ogni istruzione viene eseguita all'interno di una transazione associata con i timeout dichiarati dal blocco db del manifesto, e un'istruzione che supera statementTimeoutMs viene annullata, non attesa. Dimensioni le sue query di conseguenza. Inoltre, il blocco per approvazione, la postazione di lettura e il lettore di licenze aggiungono tutti un round trip o una transazione. Nel mio plugin di revisione delle anomalie, il controllo della licenza ha aggiunto alcuni millisecondi per richiesta finché la sua memoria di 30 secondi non è entrata a regime, un prezzo equo per non erogare mai una funzionalità bloccata.

