Log indBook en briefing

Kapitel 2.22

Plugin-kørselsmiljøet

De SDK-moduler (softwareudviklingssæt), som Deres plugin kører på, fra råderumsvagten og databasehegnet til UNO-afvikling, aflæsning af AI-ruten (kunstig intelligens) og licenskontroller. Derefter test mod en rigtig database, registrering af Deres færdigheder og ibrugtagning.

Denne side er oversat af AI fra den engelske original. Hvis noget er uklart, er den engelske side gældende. Læs denne side på engelsk

21 minutters læsetid

Runtime-halvdelen af SDK'et (softwareudviklingssættet) er et sæt moduler under @adverant-nexus/plugin-sdk/runtime/* samt testhjælpere under testing/*. Du importerer dem; du genimplementerer dem ikke. Det er hele idéen, og det kostede mig én afvist gennemgang at tage det alvorligt: bedømmerens bemærkning til mit første plugins håndskrevne tjek af afgrænsning (scope) var en enkelt linje: "SDK'et har allerede dette, og dit accepterer et MFA-udfordringstoken (multifaktorgodkendelse) som en session".

Dette kapitel følger en forespørgsel gennem et kørende plugin, præcis som full-service-skabelonen forbinder det: afgrænsningsvagten (scope guard), databasehegnet, den ene tilladte krydsning, afsendelse gennem UNO, læsningen af ruten til AI (kunstig intelligens) og licenstjekkene. Derefter dækker det test, registrering af dine manifestfærdigheder og onboarding-trinene.

Afgrænsning: én vagt pr. framework

Hver /api-rute bærer afgrænsningsvagten. Den verificerer ihændehavertokenet (bearer token), udleder de tre akser (lejer, ejer, enhed) derfra, afviser en body, der navngiver en lejer, anvender rutens rettighed fra manifestets register og lader først derefter handleren køre. SDK'et leverer én adapter pr. framework, alle fra @adverant-nexus/plugin-sdk/runtime/scope og alle med de samme indstillinger.

Framework Adapter
Express scopeMiddleware
Fastify requireScope, som en preHandler
Next withScope, der indkapsler handleren; en Next-handler får ikke oplyst sin rute, så withScope tager den som et tredje argument

Her er skabelonens Express-opsætning i beskåret form. Verifikatoren tilhører SDK'et, og den fastholder tokenet i identitetstjenestens sessionsformat: kun HS256; iss, exp, iat og jti er påkrævet; en levetid på højst en time; og intet MFA-udfordrings-, personificerings- eller OAuth-ressourcetoken (den åbne standard for delegeret autorisation) godkendes som en session.

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)) });
});

Rettighedsvagten anvender en rutes rettighed i fire trin. En rolle på rettighedens never-liste afviser med AUTHORITY_EXCEEDED og barred-ordene, og intet sæde (seat) ophæver dette. En rolle i roles giver adgang, men kræver derudover et aktivt sæde, når rettigheden angiver seat: true. Ellers giver et aktivt sæde, der bærer rettigheden, adgang. Ellers afvises forespørgslen med AUTHORITY_EXCEEDED, idet de personer, der kan tildele et sæde, navngives. Giv vagten et lager (rights: { manifest, store: { pool, schema } }), og den læser sæder under kalderens egen afgrænsning; en rettighed, der navngiver en licence, kræver også en licenslæser, hvilket dækkes nedenfor.

Inde i en handler er scopeOf(req) den eneste måde at læse den udledte afgrænsning på, og den kaster en fejl, hvis vagten ikke kørte. En vagt, der er registreret på et præfiks og kører, før nogen rute har matchet, svarer 500 MIDDLEWARE_ORDERING_ERROR; en rute, som din kode registrerer, men som manifestet ikke erklærer, svarer 500 UNHANDLED_ERROR. Begge fejler lukket (fail closed).

Skabelonens /internal-ruter, som platformen kalder, bruger det andet regime. Tjenestevagten tjekker X-Service-Key på konstant tid og tager lejeren fra platformens X-Organization-ID, mens den afviser MISSING_SERVICE_KEY, INVALID_SERVICE_KEY eller MISSING_ORG_ID_HEADER. Til platformens signerede token pr. kald har SDK'et requireService (Fastify) og serviceMiddleware (Express), som også tjekker, hvilken færdighed og rute tokenet blev udstedt til, og afviser et token, der bruges to gange.

Databasehegnet: tenantFence og withScopedTx

Hver sætning mod en afgrænset tabel sammensætter hegnet og kører inde i en afgrænset transaktion:

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) opbygger prædikatet og dets parametre ud fra en udledt afgrænsning. Send owner med for personlige tabeller; udelad det for organisationsartefakter, hvor ejeren angiver oprindelse. Når sætningen allerede har parametre, fortæller startIndex hegnet, hvor det skal nummerere fra. En indsættelse tager aldrig akserne som input: den skriver scope.tenant, scope.owner og scope.unit ud fra afgrænsningen.

withScopedTx binder alle tre akser for én transaktion gennem skemaets ene bind-funktion og kører derefter dit callback. En anden binding i den samme transaktion udløser SCOPE_ALREADY_BOUND (500: din kode bandt to gange; kalderen gjorde intet forkert). En manglende eller nulstillet lejer eller ejer udløser SCOPE_PREDICATE_INVALID (403). Indstillingen er transaktionslokal, så en puljet forbindelse ikke kan føre én lejer videre til den næste forespørgsel.

To søskendefunktioner dækker de tilfælde, der ikke er en persons forespørgsel. withTenantScopedTx binder lejer og enhed uden ejer for rækker, som en maskine læser (enhedsregistret), og afviser en afgrænsning, der bærer en ejer. maintenanceScope(reason) får en organisationsdækkende handling til udtrykkeligt at erklære, hvad den er, før ejerens transaktion åbnes. Kodehegnet og tvungen sikkerhed på rækkeniveau (row-level security) er to mekanismer for én lov; opstartstjekket nægter at lytte, indtil databasen beviser, at den anden holder (ellers DB_ROLE_BYPASSES_ISOLATION).

Hver afvisning er en række

Skabelonen installerer endnu et stykke middleware, én gang, mellem body-parseren og routerne: afvisningsprotokollen.

import { recordRefusals } from "@adverant-nexus/plugin-sdk/runtime/refusal-ledger";

app.use(express.json({ limit: "256kb" }));
app.use(recordRefusals({ pool, schema: SCHEMA }));

Den indkapsler svaret, så enhver afvisning, en person læser – uanset om den kommer fra rettighedsvagten, en handler eller et lager – skrives til dit skemas refusal-tabel inde i den pågældende persons egen afgrænsede transaktion, før bodyen sendes. En anonym 401 skriver intet. Hvis rækken ikke kan skrives, bliver svaret UNHANDLED_ERROR: et "nej", som produktet ikke kan registrere, sendes ikke, som om det var registreret. Opstarten kører assertRefusalLedger for at tjekke, at tabellen kan modtage protokollens række, og et lager kan kalde noteSubject({ recordId, isDemo }), så hver afvisning navngiver den post, den handlede om. Når en kunde spørger, hvorfor nogen blev afvist i tirsdags, er svaret en forespørgsel, ikke et gæt.

Den eneste krydsning: en registreret skrivebeskyttet tilladelse

Når en af dine kunder udfører arbejde for en anden, og den anden må inspicere det, er der én sanktioneret vej over grænsen. Den organisation, der har rækkerne, registrerer en tilladelse (grant). Læserens organisation giver en person adgang gennem et sæde, der bærer rettigheden granted.read, som skal navngive owner og admin i never. Læsningen kører som en sjette databaserolle, læsesædet, der kun kan vælge de tabeller, som databases[].granted angiver:

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 skriver først opslaget i læserens egen lejer og binder derefter læsesædet til tilladelsen, hvilket skriver opslaget i indehaverens lejer. Databasens egen politik tjekker, at tilladelsen navngiver læserens organisation, dækker tabellen, er startet, ikke er sluttet og ikke er blevet trukket tilbage, samt at denne transaktion skrev sit opslag. En læsning, der springer opslaget over, ser intet. Ved opstart tjekker assertSeatAtBoot(seatPool, schema), at den pulje, der er åbnet fra seat.url, virkelig er sædet og intet mere, og afviser ellers med DB_SEAT_ROLE_INVALID.

Afsendelse gennem UNO

Al beregning går gennem én klient, bygget i én fil, med en lukket positivliste:

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,
  });
}

Positivlisten er med vilje en konstant på modulniveau. Hvis en operatør kunne udvide den fra konfigurationen, ville ruten blive en afsendelsesproxy for hele registret. Skabelonens egen test bekræfter, at listen navngiver præcis de jobtyper, som manifestet kompilerer til.

Kuverten

En afsendelse bærer seks felter i sin påkrævede kerne. Klienten udfylder lejeren og aktøren ud fra den verificerede afgrænsning, aldrig fra forespørgslen:

Felt Hvad den indeholder
jobType Den navnerumsopdelte jobtype, <plugin name>.<skill id>
organizationId Lejeren, fra afgrænsningen
userId Aktøren, fra afgrænsningen, til revision og fakturering
inputParams Færdighedens input. Det bærer aldrig et lejer-id; et input, der gør, afvises ved afsendelse
priority critical, high, normal eller low
pluginId Dit manifests name. Hver afsendelse erklærer sit oprindelige plugin

Valgfrie felter omfatter correlationId (en UUID (universelt unik identifikator), eller der udstedes en ny) og callbackUrl, som en plugin_queue-færdighed har brug for, så workeren ved, hvor den skal sende sit resultat hen.

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, derefter polling

Hver afsendelse sættes i kø. Svaret er altid 202 med identifikatorer (jobId, runId, traceId, status), aldrig et resultat. Resultatet kommer fra polling af jobbet eller fra dit callback. uno.peek(jobId, { scope }) læser det én gang, og awaitJob poller indtil en afsluttende status; begge sender lejeren fra den verificerede afgrænsning, og begge tjekker den returnerede rækkes organization_id op imod kalderens lejer på din side af netværkskaldet og afviser en uoverensstemmelse med SCOPE_REFUSED.

Læs kørselsrækken med dens egen stavemåde. Afsendelsessvaret siger jobId; rækken siger job_id, organization_id og plugin_id. Resultat- og fejlkolonnerne er result, error, error_code og error_troubleshooting. completed og failed er afsluttende. timed_out, cancelled og system_failure kommer fra oprydderen (reaper), og et forsinket resultat kan stadig nå at rette dem. En klient, der behandler nogen af disse som ufortolkelige, afviser rækker, som platformen skriver hver dag.

Godkendelsestilbageholdelsen

En manifestfærdighed, der erklærer approval, tilbageholdes ved afsendelse. 202 siger da status: "awaiting_approval" og bærer et waitpointId med den årsag, manifestet angav. Kørslen forbliver tilbageholdt, indtil en navngiven person træffer afgørelse om den. uno.approve og uno.resolveWaitpoint sender lejeren og kalderen som aktør, og en afgørelse truffet af en anden end den verificerede kalder afvises. En godkendelse frigiver jobbet én gang og kører afsendelsestjekkene igen; en afvisning afslutter det med failed. En anden afgørelse afvises, og det samme gælder en afgørelse, efter at tilbageholdelsen er udløbet. Hvis dit produkt kræver, at godkenderen er en anden person end forslagsstilleren, skal du håndhæve dette i den rute, der træffer afgørelsen: platformen registrerer begge.

Vis et tilbageholdt job som tilbageholdt. Fortæl ikke en person, at deres klik frigav det, før kørselsrækken siger det.

AI: ønsker på færdighedsrækken og én aflæsning

Dit plugin kalder aldrig en model. Når en manifestfærdighed har brug for en (llm_only eller tool_using, ved tillidsniveau core eller verified), udtrykker du præferencer på dens registerrække, og routeren beslutter ud fra organisationens egen pulje:

{
  "execution_config_skill": {
    "preferredProvider": "gemini",
    "capabilityProfile": { "needsToolUse": true, "dataResidency": "eu_only" }
  }
}

preferredProvider og preferredModel er ønsker, som routeren kun opfylder, når organisationen har den pågældende udbyder aktiveret og forsynet med legitimationsoplysninger. capabilityProfile filtrerer og vælger aldrig; dens dataResidency (eu_only, us_only eller any) er en ufravigelig begrænsning, som routeren enten opfylder eller afviser. At udelade dem alle er normalt det rette. modelOverride findes til den sjældne færdighed, der kræver én bestemt model, og den gør ønskerne ved siden af uvirksomme; jeg ville undgå den, medmindre færdigheden er meningsløs på enhver anden model.

Når din brugerflade skal vise, hvilken model routeren ville bruge, skal du læse den, ikke forudsige den:

import { createAIRouteClient } from "@adverant-nexus/plugin-sdk/runtime/ai-route";

createAIRouteClient(...).effectiveRoute() er den eneste sanktionerede læsning af AI Provider Router. Den tager gatewayens adresse, kalderens eget ihændehavertoken og din platforms slug, og den sender ingen AI-forespørgsel. Den svarer med udbyderen og modellen, de udbydere politikken tillader, og hvorvidt det valgte slutpunkt kører local eller external. Når ruten ikke kan bruges, svarer den med routerens afvisning i tekst (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE eller NO_MODEL_FOR_ROLE_AND_PROVIDER, med afhjælpningen), aldrig en standardmodel. Vis den afvisning til personen; det er vedkommendes organisations konfiguration, der taler.

Licenskontroller

Tre mekanismer tjekker licensering på tre detaljeniveauer.

En rettighed, der navngiver en licens. Den enkleste. I manifestet bærer en rettighed licence: "<feature>", og vagten spørger identitetstjenesten, om organisationens licens bærer den, med kalderens eget token, før nogen rolle læses. Byg vagten med en læser:

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 }) },
});

En licens, der ikke bærer funktionen, afviser alle med LICENCE_LOCKED, idet den navngiver, hvad der bærer den, og oplyser, at organisationens ejere og administratorer kan slå den til. En licens, der ikke kan læses, afviser med UNHANDLED_ERROR: en låst funktion leveres aldrig, blot fordi licensen var uden for rækkevidde. Svar huskes i 30 sekunder pr. organisation og funktion.

Produktporten. createProductGate({ baseUrl, product }) fra runtime/product-gate spørger rettighedstjekket (entitlement check), om kalderens organisation overhovedet har dit produkt, og dens middleware() kører efter afgrænsningsvagten. En negativ afgørelse er ENTITLEMENT_DENIED; et tjek, der ikke kan nås, er ENTITLEMENT_UNREACHABLE, og porten behandler aldrig det ene som det andet.

Selve licensdokumentet. Kode, der selv skal træffe afgørelse ud fra den signerede licens, såsom det lukkede modul i en domænepakke, bruger verifyLicenceDocument(docText, opts) fra runtime/licence-document. Det er en ren funktion: intet netværkskald, ingen miljøvariabel, ingen fil. Den tjekker begge signaturer op imod de tillidsrødder, som dit build bærer, og svarer med en tilstand (VALID, WARN, GRACE, RESTRICT, TERMINATE eller ABSENT) sammen med tilladelserne, tilføjelserne og domænepakkerne. licenceAllows(verdict, featureGroup, action, tenantId?) angiver derefter, om du må use eller provision under en gruppe. RESTRICT tillader use og svarer provision med LICENCE_LOCKED, så igangværende arbejde fortsætter, og intet nyt starter.

Test

Skabelonens test viser mønstret; her er værktøjerne bag det.

Afgrænsningsattrapper (scope fakes). Byg attrappen for den udledte afgrænsning én gang i test/scope-fakes.ts, og injicer den overalt, inklusive de manglende tilfælde: ingen enhed, intet token, et token med en nulstillet organisation. Afvisningsstierne er selve produktet.

En attrap til afsendelsestransport. UnoClient tager fetch, now og sleep, så en enhedstest aldrig rører netværket. Bekræft kuvertens felter, 202-formen, polling til en afsluttende række med dens organization_id, og at en række for en anden lejer droppes.

En rigtig Postgres. En falsk forespørgselsfunktion beviser en SQL-streng. Den kan ikke bevise, at tvungen sikkerhed på rækkeniveau holder, eller at filerne anvendes i rækkefølge som migreringsværktøjet. testing/ephemeral-postgres starter en midlertidig server og kører den samme nexus-migrate, som produktionen kører:

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 runs

Uden for CI (kontinuerlig integration) springer en maskine uden en Postgres-server hvert databasetilfælde over ved navn med angivelse af afhjælpningen, aldrig med grønt lys. I CI får det samme fravær testsuiten til at fejle (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), fordi en oversprunget test af sikkerhed på rækkeniveau er en grøn port, der intet har målt. Serveren venter op til 180 sekunder på at starte, og en overvågningsproces (watchdog) stopper den, når testprocessen forsvinder.

Isolationsrammen. runIsolationHarness(target) fra testing/isolation-harness læser hver rute, din app monterer, og angriber hver enkelt som en anden organisations administrator og som en kollega. Derefter angriber den igen med kodehegnet fjernet, databasehegnet fjernet og begge fjernet. En rute er først PROVEN, når angrebet fejler med et af hegnene på plads og når frem til offerets data, når begge er fjernet, så du ved, at testen overhovedet kan se en lækage. Den sender hver rutes erklærede forespørgsel og eksempel-body, så en rute, der afviser en tom forespørgsel, stadig nås. Fastlås ledgerOf(report) i en test, og fejl ved defectsOf(report).

Registrering: fra manifest til færdighedsregister

Dine manifestfærdigheder når færdighedsregistret ad én vej:

manifest.skills[]  →  compileRegistry(manifest)  →  POST /api/v1/plugins/sync

compileRegistry omdanner et valideret manifest til nexus.plugin-sync/v1-bodyen. Skabelonen gør dette ved import, så et ugyldigt manifest får dit build til at fejle:

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" } ]
}

Synkroniseringen er deklarativ: send hele færdighedssættet hver gang, og en udeladt færdighed deaktiveres, mens dens historik bevares. Den er streng: et ukendt felt, et felt fra et andet niveau (tier) eller en null afvises, alle overtrædelser returneres samlet i én 400 SYNC_CONTRACT_VIOLATION, og intet skrives, så længe der er en overtrædelse. Og den skriver én registerrække pr. færdighed, nøglebaseret på den navnerumsopdelte jobtype, med hver kolonne, som afsenderen læser, så færdigheden kan køres i det øjeblik, synkroniseringen svarer 200.

Pluginet er den godkendte kalder, aldrig et body-felt. Kald synkroniseringen fra dit plugins egen workload over mTLS (gensidig TLS: Transport Layer Security med et certifikat i begge ender). Skills Engine læser din workloads klientcertifikat, hvis SPIFFE-identitet (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) navngiver navnerummet og tjenestekontoen, og slår det plugin og den ejerorganisation op, der er registreret for det pågældende navnerum. Bodyens pluginId skal matche; det er et tjek, ikke en vælger. Hver række skrives med det pågældende plugin og den pågældende organisation.

Status Kode Betydning
200 {contract, pluginId, version, created, updated, unchanged, disabled, skills}
400 SYNC_CONTRACT_VIOLATION Hver overtrædelse opført i violations[]; intet skrevet
401 UNAUTHORIZED Forkert eller manglende tjenestenøgle
401 CALLER_IDENTITY_UNVERIFIED Ingen læsbar klientidentitet
403 DELIVERY_IDENTITY_MISSING Det kaldende navnerum tilhører intet plugin
403 PLUGIN_ID_MISMATCH Bodyen navngiver et andet plugin
409 REGISTRY_CONFLICT En jobtype ejes et andet sted eller blev registreret uden for synkroniseringen; intet skrevet

Lad dit udrulningstrin fejle ved enhver anden status end 200. Ingen anden status betyder, at dine færdigheder er registreret.

Ibrugtagning

Onboarding kører som ti ordnede trin, der hver især kan genkøres, annulleres eller rulles tilbage separat:

  1. Klon repositoriet, og valider det.
  2. Fortolk manifestet.
  3. Scan det for sikkerhedsproblemer.
  4. Byg imaget.
  5. Skub det til installationens register.
  6. Opsæt dets domænenavne.
  7. Rul det ud gennem installationens udgivelseskanaler.
  8. Vent på sundhedstjekket.
  9. Registrer pluginet.
  10. Giv udvikleren besked.

Før udrulning kører fem overensstemmelsestjek mod manifestet og det byggede image: manifestet kan fortolkes og bærer sine påkrævede felter; hver erklæret rute er en reel registreret rute; pluginet ejer sit skema og skriver intet uden for det; ressourceforespørgsler er erklæret og inden for grænserne; og imaget har en fungerende sundhedshandler. Et plugin, der registrerer sig selv ved opstart, kører den samme kontrakt under sin egen autoritet, så tjekkene bliver dets CI i stedet for pipelinens. At springe et tjek over forkorter ikke onboarding; det flytter fejlen til runtime.

Brandingen i dit manifest leveres uden godkendelse pr. domæne, fordi loginsiden har brug for den, før nogen har legitimationsoplysninger. Behandl alt i branding som offentligt.

Miljøer og promovering
Miljøer og promovering
Miljøer og promovering flytter hver udgivelse fra udviklingsområdet gennem staging til en pilotenhed og derefter til alle enheder, med hver port og dens tilstand på én side. En promovering, der springer en port over, afvises med GATE_CANNOT_BE_SKIPPED.
Kanaler og installationer
Kanaler og installationer
Kanaler og installationer viser, hvilken enhed der kører hvilken version, med fejlrater som antal og aldrig indhold. At rulle én enhed tilbage er en gennemgået ændring, der kun berører den pågældende enhed.

Hvad kørselsmiljøet ikke gør for Dem

Runtimen holder linjen, hvad angår isolation, afsendelse og modeladgang. Den gør ikke din produktlogik rigtig, og den gør ikke en langsom forespørgsel hurtig: hver sætning kører inde i en bundet transaktion med de timeouts, som dit manifests db-blok erklærer, og en sætning, der overskrider statementTimeoutMs, annulleres i stedet for at blive ventet på. Dimensioner dine forespørgsler efter det. Og godkendelsestilbageholdelsen, læsesædet og licenslæseren tilføjer alle en rundtur eller en transaktion. På mit plugin til anomaligennemgang tilføjede licenstjekket et par millisekunder pr. forespørgsel, indtil dets 30-sekunders hukommelse var varmet op, hvilket var en rimelig pris for aldrig at levere en låst funktion.