Versie 1.0.0-alpha.1nieuwste
Hoofdstuk 2.22
De plug-in-runtime
De SDK-modules (software development kit) waarop uw plug-in draait, van de scopebewaker en de database-omheining tot UNO-verzending, het uitlezen van de AI-route (kunstmatige intelligentie) en licentiecontroles. Vervolgens testen tegen een echte database, het registreren van uw vaardigheden en onboarding.
Deze pagina is door AI vertaald vanuit het Engelse origineel. Als er iets onduidelijk is, geldt de Engelse pagina als referentie. Lees deze pagina in het Engels

De runtime-helft van de SDK (software development kit) bestaat uit een reeks modules onder @adverant-nexus/plugin-sdk/runtime/*, plus testhulpmiddelen onder testing/*. U importeert ze; u implementeert ze niet opnieuw. Dat is het hele idee, en het kostte me één afgekeurde review om dat serieus te nemen: de opmerking van de reviewer bij de handgeschreven scopecontrole van mijn eerste plug-in bestond uit één regel: "de SDK heeft dit al, en die van u accepteert een MFA-challengetoken (multi-factor authentication) als sessie".
Dit hoofdstuk volgt een aanvraag door een draaiende plug-in, precies zoals de full-service template deze koppelt: de scopebewaker, de database-afscherming, de enige toegestane grensoverschrijding, verzending via UNO, het uitlezen van de AI-route (artificial intelligence) en de licentiecontroles. Vervolgens worden testen, het registreren van uw manifest-skills en de onboarding-stappen behandeld.
Scope: één bewaker per framework
Elke /api-route is voorzien van de scopebewaker. Deze verifieert het bearer-token, leidt daar de drie assen (tenant, eigenaar, eenheid) uit af, weigert een body waarin een tenant wordt genoemd, past het recht van de route uit het manifestregister toe en laat pas daarna de handler draaien. De SDK levert één adapter per framework, allemaal vanuit @adverant-nexus/plugin-sdk/runtime/scope en allemaal met dezelfde opties.
| Framework | Adapter |
|---|---|
| Express | scopeMiddleware |
| Fastify | requireScope, als een preHandler |
| Volgende | withScope, als schil rond de handler; een Next-handler krijgt zijn route niet doorgegeven, dus withScope neemt deze als derde argument aan |
Hier is de ingekorte Express-koppeling van de template. De verifier is afkomstig uit de SDK en houdt het token aan het sessieformaat van de identiteitsservice: uitsluitend HS256; iss, exp, iat en jti zijn vereist; een levensduur van hoogstens een uur; en er wordt geen MFA-challenge-, impersonatie- of OAuth-resourcetoken (de open standaard voor gedelegeerde autorisatie) als sessie toegelaten.
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)) });
});De rechtenbewaker past het recht van een route in vier stappen toe. Een rol in de lijst never van het recht weigert met AUTHORITY_EXCEEDED en de tekst barred, en geen enkele zetel heft dit op. Een rol in roles verleent toegang, eveneens met een actieve zetel wanneer het recht seat: true vermeldt. Anders verleent een actieve zetel met dat recht toegang. Zo niet, dan wordt de aanvraag geweigerd met AUTHORITY_EXCEEDED, waarbij de personen worden genoemd die een zetel kunnen toekennen. Geef de bewaker een opslagplaats (rights: { manifest, store: { pool, schema } }) en hij leest zetels uit binnen de eigen scope van de aanroeper; voor een recht dat een licence noemt is ook een licentielezer nodig, die hieronder wordt besproken.
Binnen een handler is scopeOf(req) de enige manier om de vastgestelde scope uit te lezen, en deze geeft een foutmelding als de bewaker niet heeft gedraaid. Een bewaker die op een prefix is geregistreerd en draait voordat er een route is gematcht, antwoordt met 500 MIDDLEWARE_ORDERING_ERROR; een route die door uw code wordt geregistreerd maar niet in het manifest is gedeclareerd, antwoordt met 500 UNHANDLED_ERROR. Beide zijn fail-closed.
De /internal-routes van de template, die door het platform worden aangeroepen, gebruiken het andere regime. De servicebewaker controleert X-Service-Key in constante tijd en haalt de tenant uit X-Organization-ID van het platform, en weigert MISSING_SERVICE_KEY, INVALID_SERVICE_KEY of MISSING_ORG_ID_HEADER. Voor het door het platform ondertekende token per aanroep biedt de SDK requireService (Fastify) en serviceMiddleware (Express), die ook controleren voor welke skill en route het token is aangemaakt en een token weigeren dat twee keer wordt gebruikt.
De database-afscherming: tenantFence en withScopedTx
Elk statement op een tabel met scopebeperking bouwt de afscherming op en draait binnen een transactie met scopebeperking:
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) bouwt het predicaat en de bijbehorende parameters op vanuit een vastgestelde scope. Geef owner mee voor persoonlijke tabellen; laat dit weg voor organisatie-artefacten waarbij de eigenaar voor de herkomst staat. Wanneer het statement al parameters heeft, geeft startIndex aan de afscherming door vanaf waar er genummerd moet worden. Een insert neemt de assen nooit als invoer aan: deze schrijft scope.tenant, scope.owner en scope.unit vanuit de scope.
withScopedTx bindt alle drie de assen voor één transactie via de enige bind-functie van het schema, en voert daarna uw callback uit. Een tweede binding in dezelfde transactie leidt tot SCOPE_ALREADY_BOUND (500: uw code heeft twee keer gebonden; de aanroeper heeft niets verkeerd gedaan). Een ontbrekende of op nul staande tenant of eigenaar leidt tot SCOPE_PREDICATE_INVALID (403). De instelling geldt lokaal voor de transactie, zodat een verbinding uit een pool geen tenant kan meenemen naar de volgende aanvraag.
Twee verwante functies dekken de gevallen af die geen aanvraag van een persoon zijn. withTenantScopedTx bindt tenant en eenheid zonder eigenaar, voor rijen die door een machine worden gelezen (het apparaatregister), en weigert een scope die een eigenaar bevat. maintenanceScope(reason) dwingt een organisatiebrede bewerking om expliciet aan te geven wat ze is voordat de transactie van de eigenaar wordt geopend. De code-afscherming en afgedwongen beveiliging op rijniveau (row-level security) zijn twee mechanismen voor één wet; de opstartcontrole weigert te luisteren totdat de database bewijst dat het tweede mechanisme standhoudt (anders volgt DB_ROLE_BYPASSES_ISOLATION).
Elke weigering is een rij
De template installeert eenmalig nog één stuk middleware tussen de body-parser en de routers: het weigeringslogboek.
import { recordRefusals } from "@adverant-nexus/plugin-sdk/runtime/refusal-ledger";
app.use(express.json({ limit: "256kb" }));
app.use(recordRefusals({ pool, schema: SCHEMA }));Het omhult de respons zodat elke weigering die een persoon te zien krijgt – of deze nu afkomstig is van de rechtenbewaker, een handler of een opslagplaats – binnen de eigen transactie met scopebeperking van die persoon naar de tabel refusal van uw schema wordt geschreven voordat de body wordt verzonden. Een anonieme 401 schrijft niets. Als de rij niet kan worden geschreven, wordt het antwoord UNHANDLED_ERROR: een "nee" die het product niet kan vastleggen, wordt niet verzonden alsof dat wel zo is. Bij het opstarten draait assertRefusalLedger om te controleren of de tabel de rij van het logboek kan opnemen, en een opslagplaats kan noteSubject({ recordId, isDemo }) aanroepen zodat elke weigering het record noemt waar het over ging. Wanneer een klant vraagt waarom iemand afgelopen dinsdag is geweigerd, is het antwoord een query, geen gok.
De enige kruising: een vastgelegde alleen-lezen-toekenning
Wanneer een van uw klanten werk verricht voor een andere klant en die andere klant dat mag inspecteren, is er één goedgekeurde manier om de grens over te steken. De organisatie die de rijen beheert, legt een toekenning vast. De organisatie van de lezer laat een persoon toe via een zetel met het recht granted.read, waarin owner en admin in never moeten worden genoemd. De leesbewerking draait als een zesde databaserol, de leeszetel, die alleen een select kan uitvoeren op de tabellen die in databases[].granted worden vermeld:
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 schrijft de inzage eerst weg in de eigen tenant van de lezer en bindt vervolgens de leeszetel aan de toekenning, wat de inzage wegschrijft in de tenant van de beheerder. Het eigen beleid van de database controleert of de toekenning de organisatie van de lezer noemt, de tabel dekt, is ingegaan, nog niet is geëindigd en niet is ingetrokken, en of deze transactie de bijbehorende inzage heeft weggeschreven. Een leesbewerking die het vastleggen van de inzage overslaat, ziet niets. Bij het opstarten controleert assertSeatAtBoot(seatPool, schema) of de vanuit seat.url geopende pool daadwerkelijk de zetel is en niets meer, en weigert anders met DB_SEAT_ROLE_INVALID.
Verzending via UNO
Alle rekenkracht loopt via één client, opgebouwd in één bestand, met een gesloten allow-list:
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,
});
}De allow-list is bewust een constante op moduleniveau. Als een operator deze vanuit de configuratie zou kunnen uitbreiden, zou de route een verzendproxy voor het hele register worden. De eigen test van de template controleert of de lijst exact de taaktypen noemt waarnaar het manifest compileert.
De envelop
Een verzending bevat in de verplichte kern zes velden. De client vult de tenant en de actor in vanuit de geverifieerde scope, nooit vanuit de aanvraag:
| Veld | Wat het bevat |
|---|---|
jobType |
Het taaktype met namespace, <plugin name>.<skill id> |
organizationId |
De tenant, vanuit de scope |
userId |
De actor, vanuit de scope, voor auditing en facturering |
inputParams |
De invoer van de skill. Deze bevat nooit een tenant-ID; een invoer die dat wel doet, wordt bij verzending geweigerd |
priority |
critical, high, normal of low |
pluginId |
Uw manifest-name. Elke verzending declareert de oorspronkelijke plug-in |
Optionele velden zijn onder meer correlationId (een UUID (universally unique identifier), anders wordt er een nieuwe aangemaakt) en callbackUrl, wat een plugin_queue-skill nodig heeft zodat de worker weet waar hij zijn resultaat moet plaatsen.
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, daarna pollen
Elke verzending wordt in een wachtrij geplaatst. Het antwoord is altijd 202 met identificatiegegevens (jobId, runId, traceId, status), nooit een resultaat. Het resultaat komt uit het pollen van de taak of uit uw callback. uno.peek(jobId, { scope }) leest het eenmalig uit en awaitJob pollt tot een eindstatus is bereikt; beide sturen de tenant mee vanuit de geverifieerde scope, en beide controleren aan uw kant van de netwerkaanroep de organization_id van de geretourneerde rij tegen de tenant van de aanroeper, waarbij een afwijking wordt geweigerd met SCOPE_REFUSED.
Lees de uitvoeringsrij in haar eigen schrijfwijze. De verzendrespons zegt jobId; de rij zegt job_id, organization_id en plugin_id. De kolommen voor resultaten en fouten zijn result, error, error_code en error_troubleshooting. completed en failed zijn eindstatussen. timed_out, cancelled en system_failure zijn afkomstig van de reaper en kunnen nog door een vertraagd resultaat worden gecorrigeerd. Een client die een van deze waarden als onverwerkbaar beschouwt, weigert rijen die het platform dagelijks schrijft.
De goedkeuringsblokkade
Een manifest-skill die approval declareert, wordt bij verzending in de wacht gezet. De 202 vermeldt dan status: "awaiting_approval" en bevat een waitpointId, met de reden die het manifest heeft opgegeven. De uitvoering blijft geblokkeerd totdat een aangewezen persoon er een besluit over neemt. uno.approve en uno.resolveWaitpoint sturen de tenant en de aanroeper mee als de actor, en een besluit door iemand anders dan de geverifieerde aanroeper wordt geweigerd. Een goedkeuring geeft de taak eenmalig vrij en voert de verzendcontroles opnieuw uit; een afwijzing beëindigt de taak met failed. Een tweede besluit wordt geweigerd, evenals een besluit nadat de blokkade is verlopen. Als uw product vereist dat de goedkeurder een andere persoon is dan de aanvrager, dwing dat dan af in de route die het besluit neemt: het platform legt beiden vast.
Geef een geblokkeerde taak weer als geblokkeerd. Vertel een persoon niet dat zijn klik de taak heeft vrijgegeven totdat de uitvoeringsrij dat aangeeft.
AI: wensen op de vaardigheidsrij en één leesactie
Uw plug-in roept nooit zelf een model aan. Wanneer een manifest-skill er een nodig heeft (llm_only of tool_using, op vertrouwensniveau core of verified), geeft u voorkeuren op in de bijbehorende registerrij en beslist de router vanuit de eigen pool van de organisatie:
{
"execution_config_skill": {
"preferredProvider": "gemini",
"capabilityProfile": { "needsToolUse": true, "dataResidency": "eu_only" }
}
}preferredProvider en preferredModel zijn wensen die de router alleen honoreert wanneer de organisatie die provider heeft ingeschakeld en van inloggegevens heeft voorzien. capabilityProfile filtert en selecteert nooit; de bijbehorende dataResidency (eu_only, us_only of any) is een harde voorwaarde waaraan de router voldoet of die hij weigert. Ze allemaal weglaten is doorgaans de juiste keuze. modelOverride bestaat voor de zeldzame skill die één exact model nodig heeft, en maakt de wensen ernaast onwerkzaam; ik zou dit vermijden tenzij de skill op elk ander model zinloos is.
Wanneer uw interface moet tonen welk model de router zou gebruiken, lees dat dan uit en voorspel het niet:
import { createAIRouteClient } from "@adverant-nexus/plugin-sdk/runtime/ai-route";createAIRouteClient(...).effectiveRoute() is de enige goedgekeurde leesbewerking van de AI Provider Router. Deze neemt het adres van de gateway, de eigen bearer van de aanroeper en de slug van uw platform aan, en verstuurt geen AI-aanvraag. Hij geeft als antwoord de provider en het model, de providers die het beleid toestaat, en of het gekozen eindpunt local of external draait. Wanneer de route niet bruikbaar is, antwoordt hij met de weigering van de router in tekst (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE of NO_MODEL_FOR_ROLE_AND_PROVIDER, inclusief de oplossing), nooit met een standaardmodel. Toon die weigering aan de persoon; het is de configuratie van zijn eigen organisatie die spreekt.
Licentiecontroles
Drie mechanismen controleren de licenties, op drie detailniveaus.
Een recht dat een licentie noemt. De eenvoudigste vorm. In het manifest bevat een recht licence: "<feature>", en de bewaker vraagt met het eigen token van de aanroeper aan de identiteitsservice of de licentie van de organisatie dit recht bevat, voordat er een rol wordt uitgelezen. Bouw de bewaker met een lezer:
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 }) },
});Een licentie die de functie niet bevat, weigert iedereen met LICENCE_LOCKED, noemt waar de functie wel in zit en geeft aan dat de eigenaren en beheerders van de organisatie deze kunnen inschakelen. Een licentie die niet kan worden uitgelezen, weigert met UNHANDLED_ERROR: een vergrendelde functie wordt nooit aangeboden omdat de licentie onbereikbaar was. Antwoorden worden gedurende 30 seconden per organisatie en functie onthouden.
De productpoort. createProductGate({ baseUrl, product }) uit runtime/product-gate vraagt aan de rechtencontrole of de organisatie van de aanroeper uw product überhaupt bezit, en de bijbehorende middleware() draait na de scopebewaker. Een negatief oordeel is ENTITLEMENT_DENIED; een controle die niet kan worden bereikt is ENTITLEMENT_UNREACHABLE, en de poort behandelt het een nooit als het ander.
Het licentiedocument zelf. Code die zelfstandig moet beslissen op basis van de ondertekende licentie, zoals de gesloten module van een domeinpakket, gebruikt verifyLicenceDocument(docText, opts) uit runtime/licence-document. Het is een zuivere functie: geen netwerkaanroep, geen omgevingsvariabele, geen bestand. Ze controleert beide handtekeningen tegen de vertrouwensankers die de build bevat en geeft als antwoord een status (VALID, WARN, GRACE, RESTRICT, TERMINATE of ABSENT) met de toekenningen, add-ons en domeinpakketten. licenceAllows(verdict, featureGroup, action, tenantId?) geeft vervolgens aan of u use of provision mag uitvoeren onder een groep. RESTRICT staat use toe en beantwoordt provision met LICENCE_LOCKED, zodat lopend werk doorgaat en er niets nieuws wordt gestart.
Testen
De tests van de template tonen het patroon; dit zijn de onderliggende hulpmiddelen.
Scope-fakes. Bouw de testdouble voor de vastgestelde scope één keer, in test/scope-fakes.ts, en injecteer deze overal, inclusief de ontbrekende gevallen: geen eenheid, geen token, een token met een organisatie op nul. De weigeringspaden vormen het product.
Een fake verzendtransport. UnoClient neemt fetch, now en sleep aan, zodat een unittest nooit het netwerk raakt. Controleer de velden van de envelop, de vorm van 202, het pollen tot een eindrij met haar organization_id, en dat een rij voor een andere tenant wordt genegeerd.
Een echte Postgres. Een fake queryfunctie bewijst een SQL-tekenreeks. Ze kan niet bewijzen dat afgedwongen beveiliging op rijniveau standhoudt of dat de bestanden in de juiste volgorde worden toegepast door de migrator. testing/ephemeral-postgres start een wegwerpserver en voert dezelfde nexus-migrate uit die in productie draait:
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 runsBuiten CI (continuous integration) slaat een machine zonder Postgres-server elke databasecase op naam over met vermelding van de oplossing, zonder ooit groen te geven. In CI zorgt hetzelfde ontbreken ervoor dat de suite faalt (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), omdat een overgeslagen test voor beveiliging op rijniveau een groene poort is die niets heeft gemeten. De server wacht maximaal 180 seconden met opstarten en een watchdog stopt hem zodra het testproces verdwijnt.
Het isolatieharnas. runIsolationHarness(target) uit testing/isolation-harness leest elke route die uw app koppelt en valt elk daarvan aan als beheerder van een andere organisatie en als collega. Vervolgens valt het opnieuw aan zonder de code-afscherming, zonder de database-afscherming, en zonder beide. Een route is pas PROVEN wanneer de aanval mislukt zolang een van beide afschermingen actief is en de gegevens van het slachtoffer bereikt wanneer beide zijn verwijderd; zo weet u zeker dat de test überhaupt een lek kan waarnemen. Het verstuurt de gedeclareerde query en voorbeeldbody van elke route, zodat een route die een lege aanvraag weigert toch wordt bereikt. Zet ledgerOf(report) vast in een test en laat deze falen op defectsOf(report).
Registratie: van manifest tot vaardigheidsregister
Uw manifest-skills bereiken het skillregister via één pad:
manifest.skills[] → compileRegistry(manifest) → POST /api/v1/plugins/sync
compileRegistry zet een gevalideerd manifest om in de body van nexus.plugin-sync/v1. De template doet dit bij het importeren, zodat een ongeldig manifest de build laat falen:
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" } ]
}De synchronisatie is declaratief: stuur telkens de volledige set skills mee; een weggelaten skill wordt uitgeschakeld met behoud van de historie. Ze is strikt: een onbekend veld, een veld van een ander niveau of een null wordt geweigerd, alle overtredingen komen samen terug in één 400 SYNC_CONTRACT_VIOLATION en er wordt niets geschreven zolang er ook maar één overtreding is. Bovendien schrijft ze één registerrij per skill, geïndexeerd op het taaktype met namespace en voorzien van elke kolom die de dispatcher uitleest, zodat de skill uitvoerbaar is zodra de synchronisatie antwoordt met 200.
De plug-in is de geauthenticeerde aanroeper, nooit een veld in de body. Roep de synchronisatie aan vanuit de eigen workload van uw plug-in via mTLS (mutual TLS: Transport Layer Security met een certificaat aan beide kanten). De Skills Engine leest het clientcertificaat van uw workload, waarvan de SPIFFE-identiteit (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) de namespace en het serviceaccount noemt, en zoekt de plug-in en de eigenaarsorganisatie op die voor die namespace zijn vastgelegd. De pluginId in de body moet overeenkomen; het is een controle, geen keuzemiddel. Elke rij wordt weggeschreven met die plug-in en organisatie.
| Status | Code | Betekenis |
|---|---|---|
| 200 | {contract, pluginId, version, created, updated, unchanged, disabled, skills} |
|
| 400 | SYNC_CONTRACT_VIOLATION |
Elke overtreding vermeld in violations[]; niets geschreven |
| 401 | UNAUTHORIZED |
Onjuiste of ontbrekende servicesleutel |
| 401 | CALLER_IDENTITY_UNVERIFIED |
Geen leesbare client-identiteit |
| 403 | DELIVERY_IDENTITY_MISSING |
De aanroepende namespace behoort tot geen enkele plug-in |
| 403 | PLUGIN_ID_MISMATCH |
De body noemt een andere plug-in |
| 409 | REGISTRY_CONFLICT |
Een taaktype is elders in eigendom of is buiten de synchronisatie om geregistreerd; niets geschreven |
Laat uw implementatiestap falen bij elke andere status dan 200. Geen enkele andere status betekent dat uw skills zijn geregistreerd.
Onboarding
Onboarding verloopt in tien opeenvolgende stappen, die elk afzonderlijk opnieuw kunnen worden uitgevoerd, geannuleerd of teruggedraaid:
- Kloon de repository en valideer deze.
- Parseer het manifest.
- Scan het op beveiligingsproblemen.
- Bouw het image.
- Push het naar het register van de installatie.
- Stel de bijbehorende domeinnamen in.
- Implementeer het via de releasekanalen van de installatie.
- Wacht op de statuscontrole (health check).
- Registreer de plug-in.
- Stel de ontwikkelaar op de hoogte.
Vóór de implementatie worden er vijf conformiteitscontroles uitgevoerd op het manifest en het gebouwde image: het manifest kan worden geparseerd en bevat de verplichte velden; elke gedeclareerde route is een daadwerkelijk geregistreerde route; de plug-in is eigenaar van zijn eigen schema en schrijft niets daarbuiten; de resource-aanvragen zijn gedeclareerd en vallen binnen de grenzen; en het image heeft een werkende health-handler. Een plug-in die zichzelf bij het opstarten registreert, voert hetzelfde contract uit onder zijn eigen autoriteit, waardoor de controles onderdeel worden van zijn eigen CI in plaats van die van de pijplijn. Het overslaan van een controle verkort de onboarding niet; het verplaatst de fout naar de runtime.
De huisstijl (branding) in uw manifest wordt zonder authenticatie per domein aangeboden, omdat de aanmeldpagina deze nodig heeft voordat iemand over inloggegevens beschikt. Behandel alles in branding als openbaar.
GATE_CANNOT_BE_SKIPPED.Wat de runtime niet voor u doet
De runtime bewaakt de grens op het gebied van isolatie, verzending en modeltoegang. Hij maakt uw productlogica niet kloppend en maakt een trage query niet snel: elk statement draait binnen een gebonden transactie met de time-outs die het blok db van uw manifest declareert, en een statement dat statementTimeoutMs overschrijdt, wordt geannuleerd in plaats van afgewacht. Stem de omvang van uw query's daarop af. Bovendien voegen de goedkeuringsblokkade, de leeszetel en de licentielezer allemaal een netwerkrondgang (round trip) of een transactie toe. Bij mijn plug-in voor anomaliebeoordeling voegde de licentiecontrole een paar milliseconden per aanvraag toe totdat het geheugen van 30 seconden was opgewarmd, wat een redelijke prijs was om nooit een vergrendelde functie aan te bieden.

