ConnexionPlanifier un briefing

Chapitre 2.22

L'environnement d'exécution de plugin

Les modules du SDK (kit de développement logiciel) sur lesquels repose votre plugin, du garde de portée et de la barrière de base de données à la répartition UNO, en passant par la lecture de route d'IA (intelligence artificielle) et les vérifications de licence. Puis les tests sur une base de données réelle, l'enregistrement de vos compétences et l'intégration.

Cette page a été traduite par l'IA à partir de l'original en anglais. En cas de doute, la page en anglais fait foi. Lire cette page en anglais

21 minutes de lecture

La partie exécution du SDK (kit de développement logiciel) est un ensemble de modules sous @adverant-nexus/plugin-sdk/runtime/*, ainsi que des utilitaires de test sous testing/*. Vous les importez ; vous ne les réimplémentez pas. C'est là toute l'idée, et il m'a fallu une revue rejetée pour la prendre au sérieux : la note du réviseur sur la vérification de portée écrite à la main de mon premier plugin tenait en une seule ligne : « le SDK intègre déjà cela, et la vôtre accepte un jeton de défi MFA (authentification multifacteur) comme session ».

Ce chapitre suit une requête à travers un plugin en cours d'exécution, telle que le modèle de service complet la câble : le garde de portée, la clôture de base de données, l'unique franchissement autorisé, la répartition via UNO, la lecture de route d'IA (intelligence artificielle) et les vérifications de licence. Il aborde ensuite les tests, l'enregistrement des compétences de votre manifeste et les étapes d'intégration.

Portée : un garde par framework

Chaque route /api comporte le garde de portée. Il vérifie le jeton porteur, en résout les trois axes (locataire, propriétaire, unité), refuse un corps qui nomme un locataire, applique le droit de la route à partir du registre du manifeste, et laisse seulement alors le gestionnaire s'exécuter. Le SDK fournit un adaptateur par framework, tous issus de @adverant-nexus/plugin-sdk/runtime/scope et acceptant tous les mêmes options.

Framework Adaptateur
Express scopeMiddleware
Fastify requireScope, en tant que preHandler
Next withScope, enveloppant le gestionnaire ; un gestionnaire Next n'étant pas informé de sa route, withScope la prend comme troisième argument

Voici le câblage Express du modèle, en version abrégée. Le vérificateur est celui du SDK, et il soumet le jeton au format de session du service d'identité : HS256 uniquement ; iss, exp, iat et jti requis ; une durée de vie d'une heure au maximum ; et aucun jeton de défi MFA, d'emprunt d'identité ou de ressource OAuth (la norme ouverte d'autorisation déléguée) n'est admis comme 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)) });
});

Le garde des droits applique le droit d'une route en quatre étapes. Un rôle figurant dans la liste never du droit oppose un refus avec AUTHORITY_EXCEEDED et les termes barred, et aucun siège ne lève ce refus. Un rôle dans roles autorise l'accès, accompagné d'un siège actif lorsque le droit indique seat: true. Sinon, un siège actif portant le droit autorise l'accès. À défaut, la requête est refusée avec AUTHORITY_EXCEEDED, en nommant les personnes habilitées à accorder un siège. Fournissez un magasin (rights: { manifest, store: { pool, schema } }) au garde et il lira les sièges sous la propre portée de l'appelant ; un droit qui nomme un licence nécessite également un lecteur de licence, présenté ci-dessous.

À l'intérieur d'un gestionnaire, scopeOf(req) est le seul moyen de lire la portée résolue, et il lève une exception si le garde ne s'est pas exécuté. Un garde enregistré sur un préfixe, s'exécutant avant toute correspondance de route, répond 500 MIDDLEWARE_ORDERING_ERROR ; une route enregistrée par votre code mais que le manifeste ne déclare pas répond 500 UNHANDLED_ERROR. Tous deux échouent en mode fermé.

Les routes /internal du modèle, que la plateforme appelle, utilisent l'autre régime. Le garde de service vérifie X-Service-Key en temps constant et récupère le locataire depuis l'en-tête X-Organization-ID de la plateforme, en refusant MISSING_SERVICE_KEY, INVALID_SERVICE_KEY ou MISSING_ORG_ID_HEADER. Pour le jeton signé par appel de la plateforme, le SDK dispose de requireService (Fastify) et serviceMiddleware (Express), qui vérifient également pour quelle compétence et quelle route le jeton a été émis et refusent un jeton utilisé deux fois.

La clôture de base de données : tenantFence et withScopedTx

Chaque instruction portant sur une table soumise à une portée compose la clôture et s'exécute à l'intérieur d'une transaction délimitée par une portée :

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) construit le prédicat et ses paramètres à partir d'une portée résolue. Passez owner pour les tables personnelles ; omettez-le pour les artefacts d'organisation où le propriétaire indique la provenance. Lorsque l'instruction possède déjà des paramètres, startIndex indique à la clôture à partir d'où numéroter. Une insertion ne prend jamais les axes en entrée : elle écrit scope.tenant, scope.owner et scope.unit à partir de la portée.

withScopedTx lie les trois axes pour une transaction via l'unique fonction de liaison du schéma, puis exécute votre fonction de rappel. Une seconde liaison dans la même transaction lève SCOPE_ALREADY_BOUND (500 : votre code a effectué deux liaisons ; l'appelant n'a commis aucune erreur). Un locataire ou un propriétaire absent ou nul lève SCOPE_PREDICATE_INVALID (403). Le paramètre étant local à la transaction, une connexion issue d'un pool ne peut pas transporter un locataire vers la requête suivante.

Deux fonctions sœurs couvrent les cas qui ne correspondent pas à la requête d'une personne. withTenantScopedTx lie le locataire et l'unité sans propriétaire, pour les lignes lues par une machine (le registre des appareils), et refuse une portée qui comporte un propriétaire. maintenanceScope(reason) oblige une opération à l'échelle de l'organisation à déclarer explicitement sa nature avant que la transaction du propriétaire ne s'ouvre. La clôture de code et la sécurité au niveau des lignes forcée sont deux mécanismes au service d'une même règle ; la vérification au démarrage refuse d'écouter tant que la base de données ne prouve pas que le second est bien appliqué (DB_ROLE_BYPASSES_ISOLATION dans le cas contraire).

Chaque refus correspond à une ligne

Le modèle installe un dernier middleware, une seule fois, entre l'analyseur de corps de requête et les routeurs : le registre des refus.

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

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

Il enveloppe la réponse de sorte que chaque refus reçu par une personne, qu'il provienne du garde des droits, d'un gestionnaire ou d'un magasin, soit écrit dans la table refusal de votre schéma au sein de la propre transaction délimitée de cette personne avant l'envoi du corps. Une erreur 401 anonyme n'écrit rien. Si la ligne ne peut pas être écrite, la réponse devient UNHANDLED_ERROR : un « non » que le produit ne peut pas enregistrer n'est pas envoyé comme s'il l'avait été. Le démarrage exécute assertRefusalLedger pour vérifier que la table peut recevoir la ligne du registre, et un magasin peut appeler noteSubject({ recordId, isDemo }) afin que chaque refus nomme l'enregistrement concerné. Lorsqu'un client demande pourquoi quelqu'un s'est vu refuser l'accès mardi dernier, la réponse est une requête, et non une supposition.

L'unique franchissement : une autorisation enregistrée en lecture seule

Lorsqu'un de vos clients effectue un travail pour un autre et que ce dernier est autorisé à l'inspecter, il existe un unique moyen approuvé de franchir la frontière. L'organisation qui détient les lignes enregistre une autorisation. L'organisation du lecteur admet une personne via un siège portant le droit granted.read, qui doit nommer owner et admin dans never. La lecture s'exécute sous un sixième rôle de base de données, le siège de lecture, qui peut uniquement sélectionner les tables listées par 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 écrit d'abord la consultation dans le propre locataire du lecteur, puis lie le siège de lecture à l'autorisation, ce qui écrit la consultation dans le locataire du détenteur. La propre politique de la base de données vérifie que l'autorisation nomme l'organisation du lecteur, couvre la table, a commencé, n'a pas pris fin et n'a pas été retirée, et que cette transaction a bien écrit sa consultation. Une lecture qui omet la consultation ne voit rien. Au démarrage, assertSeatAtBoot(seatPool, schema) vérifie que le pool ouvert à partir de seat.url correspond véritablement au siège et à rien d'autre, et oppose un refus avec DB_SEAT_ROLE_INVALID dans le cas contraire.

Répartition via UNO

Tout le calcul passe par un seul client, construit dans un seul fichier, avec une liste d'autorisation fermée :

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

La liste d'autorisation est délibérément une constante au niveau du module. Si un opérateur pouvait l'élargir depuis la configuration, la route deviendrait un proxy de répartition pour l'ensemble du registre. Le propre test du modèle vérifie que la liste nomme exactement les types de tâches issus de la compilation du manifeste.

L'enveloppe

Une répartition comporte six champs dans son noyau obligatoire. Le client renseigne le locataire et l'acteur à partir de la portée vérifiée, jamais à partir de la requête :

Champ Contenu
jobType Le type de tâche avec espace de noms, <plugin name>.<skill id>
organizationId Le locataire, issu de la portée
userId L'acteur, issu de la portée, pour l'audit et la facturation
inputParams L'entrée de la compétence. Elle ne comporte jamais d'identifiant de locataire ; une entrée qui en contient un est refusée lors de la répartition
priority critical, high, normal ou low
pluginId Le name de votre manifeste. Chaque répartition déclare son plugin d'origine

Les champs facultatifs incluent correlationId (un UUID (identifiant unique universel), sinon un nouveau est émis) et callbackUrl, dont une compétence plugin_queue a besoin pour que le nœud de travail sache où publier son résultat.

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, puis interrogation périodique

Chaque répartition est mise en file d'attente. La réponse est toujours 202 avec des identifiants (jobId, runId, traceId, status), jamais un résultat. Le résultat provient de l'interrogation périodique de la tâche ou de votre fonction de rappel. uno.peek(jobId, { scope }) le lit une fois et awaitJob l'interroge périodiquement jusqu'à un statut final ; tous deux envoient le locataire issu de la portée vérifiée, et tous deux vérifient le organization_id de la ligne renvoyée par rapport au locataire de l'appelant de votre côté de l'appel réseau, en refusant toute non-concordance avec SCOPE_REFUSED.

Lisez la ligne d'exécution selon sa propre nomenclature. La réponse de répartition indique jobId ; la ligne indique job_id, organization_id et plugin_id. Les colonnes de résultat et d'échec sont result, error, error_code et error_troubleshooting. completed et failed sont des statuts finaux. timed_out, cancelled et system_failure proviennent du processus de nettoyage et un résultat tardif peut encore les corriger. Un client qui traite l'un d'entre eux comme non analysable refuse des lignes que la plateforme écrit quotidiennement.

La mise en attente d'approbation

Une compétence du manifeste qui déclare approval est mise en attente lors de la répartition. Le 202 indique alors status: "awaiting_approval" et comporte un waitpointId, avec le motif fourni par le manifeste. L'exécution reste en attente jusqu'à ce qu'une personne désignée statue à son sujet. uno.approve et uno.resolveWaitpoint envoient le locataire et l'appelant en tant qu'acteur, et une décision prise par une autre personne que l'appelant vérifié est refusée. Une approbation libère la tâche une seule fois et exécute à nouveau les vérifications de répartition ; un rejet y met fin avec failed. Une seconde décision est refusée, tout comme une décision intervenant après l'expiration de la mise en attente. Si votre produit exige que l'approbateur soit une personne différente du demandeur, appliquez cette règle dans la route qui statue : la plateforme enregistre les deux.

Affichez une tâche en attente comme étant en attente. N'indiquez pas à une personne que son clic l'a libérée tant que la ligne d'exécution ne le confirme pas.

IA : souhaits sur la ligne de la compétence et lecture unique

Votre plugin n'appelle jamais un modèle. Lorsqu'une compétence du manifeste en nécessite un (llm_only ou tool_using, au niveau de confiance core ou verified), vous exprimez des préférences sur sa ligne de registre, et le routeur décide à partir du propre pool de l'organisation :

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

preferredProvider et preferredModel sont des souhaits que le routeur n'honore que lorsque l'organisation a activé ce fournisseur et configuré ses identifiants. capabilityProfile filtre et ne sélectionne jamais ; son dataResidency (eu_only, us_only ou any) est une contrainte stricte que le routeur satisfait ou refuse. Il est généralement préférable de tous les omettre. modelOverride existe pour les rares compétences qui nécessitent un modèle exact, et il rend les souhaits adjacents inopérants ; je conseille de l'éviter, à moins que la compétence n'ait aucun sens sur un autre modèle.

Lorsque votre interface doit afficher le modèle que le routeur utiliserait, lisez-le, ne le prédisez pas :

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

createAIRouteClient(...).effectiveRoute() est l'unique lecture autorisée du routeur de fournisseurs d'IA. Elle prend l'adresse de la passerelle, le jeton porteur de l'appelant et le slug de votre plateforme, et n'envoie aucune requête d'IA. Elle renvoie le fournisseur et le modèle, les fournisseurs autorisés par la politique, et indique si le point de terminaison choisi exécute local ou external. Lorsque la route n'est pas utilisable, elle renvoie le refus du routeur de manière explicite (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE ou NO_MODEL_FOR_ROLE_AND_PROVIDER, avec la procédure de remédiation), jamais un modèle par défaut. Affichez ce refus à l'utilisateur ; il reflète la configuration de son organisation.

Vérifications de licence

Trois mécanismes vérifient les licences, à trois niveaux de granularité.

Un droit qui nomme une licence. Le plus simple. Dans le manifeste, un droit porte licence: "<feature>", et le garde demande au service d'identité si la licence de l'organisation l'inclut, avec le propre jeton de l'appelant, avant même la lecture d'un rôle. Construisez le garde avec un lecteur :

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

Une licence qui n'inclut pas la fonctionnalité refuse tout le monde avec LICENCE_LOCKED, en nommant ce qui la porte et en indiquant que les propriétaires et administrateurs de l'organisation peuvent l'activer. Une licence qui ne peut pas être lue renvoie un refus UNHANDLED_ERROR : une fonctionnalité verrouillée n'est jamais servie sous prétexte que la licence était inaccessible. Les réponses sont mémorisées pendant 30 secondes par organisation et par fonctionnalité.

La porte de produit. createProductGate({ baseUrl, product }) de runtime/product-gate demande à la vérification des droits si l'organisation de l'appelant détient votre produit, et son middleware() s'exécute après le garde de portée. Un verdict négatif renvoie ENTITLEMENT_DENIED ; une vérification injoignable renvoie ENTITLEMENT_UNREACHABLE, et la porte ne confond jamais l'un avec l'autre.

Le document de licence lui-même. Le code qui doit décider par lui-même à partir de la licence signée, tel que le module fermé d'un pack de domaine, utilise verifyLicenceDocument(docText, opts) de runtime/licence-document. C'est une fonction pure : aucun appel réseau, aucune variable d'environnement, aucun fichier. Elle vérifie les deux signatures par rapport aux racines de confiance intégrées au build et renvoie un état (VALID, WARN, GRACE, RESTRICT, TERMINATE ou ABSENT) avec les droits accordés, les modules complémentaires et les packs de domaine. licenceAllows(verdict, featureGroup, action, tenantId?) indique ensuite si vous pouvez exécuter use ou provision sous un groupe. RESTRICT autorise use et répond provision avec LICENCE_LOCKED, de sorte que les tâches en cours se poursuivent et qu'aucune nouvelle tâche ne démarre.

Tests

Les tests du modèle illustrent cette approche ; voici les outils qui la sous-tendent.

Simulations de portée. Construisez la doublure de portée résolue une seule fois, dans test/scope-fakes.ts, et injectez-la partout, y compris pour les cas d'absence : aucune unité, aucun jeton, un jeton avec une organisation nulle. Les chemins de refus constituent le produit.

Un transport de répartition simulé. UnoClient prend fetch, now et sleep, de sorte qu'un test unitaire ne touche jamais le réseau. Vérifiez les champs de l'enveloppe, la forme de 202, l'interrogation jusqu'à une ligne terminale avec son organization_id, et assurez-vous qu'une ligne destinée à un autre locataire est rejetée.

Un vrai Postgres. Une fonction de requête simulée valide une chaîne SQL. Elle ne peut pas prouver que la sécurité au niveau des lignes (RLS) forcée tient bon ou que les fichiers s'appliquent dans l'ordre comme le fait l'outil de migration. testing/ephemeral-postgres démarre un serveur éphémère et exécute le même nexus-migrate qu'en production :

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

Hors CI (intégration continue), une machine sans serveur Postgres ignore chaque cas de test de base de données en le nommant avec sa solution, sans jamais l'afficher en vert. En CI, cette même absence fait échouer la suite de tests (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), car un test de sécurité au niveau des lignes ignoré est un feu vert qui n'a rien mesuré. Le serveur attend jusqu'à 180 secondes pour démarrer, et un chien de garde l'arrête lorsque le processus de test se termine.

Le harnais d'isolation. runIsolationHarness(target) de testing/isolation-harness lit chaque route montée par votre application et attaque chacune d'elles en tant qu'administrateur d'une autre organisation et en tant que collègue. Ensuite, il attaque à nouveau en retirant la barrière du code, la barrière de la base de données, puis les deux. Une route n'est PROVEN que lorsque l'attaque échoue avec l'une ou l'autre des barrières en place et atteint les données de la victime lorsque les deux sont retirées, ce qui garantit que le test est réellement capable de détecter une fuite. Il envoie la requête déclarée et le corps d'exemple de chaque route, de sorte qu'une route qui refuse une requête vide est tout de même atteinte. Épinglez ledgerOf(report) dans un test et faites-le échouer sur defectsOf(report).

Enregistrement : du manifeste au registre des compétences

Les compétences de votre manifeste atteignent le registre des compétences par une seule voie :

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

compileRegistry transforme un manifeste validé en corps nexus.plugin-sync/v1. Le modèle le fait à l'importation, de sorte qu'un manifeste invalide fait échouer le 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 synchronisation est déclarative : envoyez l'ensemble des compétences à chaque fois, et toute compétence omise est désactivée, tout en conservant son historique. Elle est stricte : un champ inconnu, un champ d'un autre niveau ou un null est refusé, toutes les violations sont renvoyées ensemble dans un seul 400 SYNC_CONTRACT_VIOLATION, et rien n'est écrit tant qu'il en subsiste une. Enfin, elle écrit une ligne de registre par compétence, indexée sur le type de tâche avec espace de noms, portant chaque colonne lue par le répartiteur, de sorte que la compétence est exécutable dès l'instant où la synchronisation répond 200.

Le plugin est l'appelant authentifié, jamais un champ du corps de la requête. Appelez la synchronisation depuis la propre charge de travail de votre plugin via mTLS (TLS mutuel : Transport Layer Security avec un certificat aux deux extrémités). Le Skills Engine lit le certificat client de votre charge de travail, dont l'identité SPIFFE (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) nomme l'espace de noms et le compte de service, et recherche le plugin ainsi que l'organisation propriétaire enregistrés pour cet espace de noms. Le champ pluginId du corps doit correspondre ; il s'agit d'une vérification et non d'un sélecteur. Chaque ligne est écrite avec ce plugin et cette organisation.

Statut Code Signification
200 {contract, pluginId, version, created, updated, unchanged, disabled, skills}
400 SYNC_CONTRACT_VIOLATION Chaque violation est listée dans violations[] ; aucune écriture effectuée
401 UNAUTHORIZED Clé de service incorrecte ou manquante
401 CALLER_IDENTITY_UNVERIFIED Aucune identité client lisible
403 DELIVERY_IDENTITY_MISSING L'espace de noms appelant n'appartient à aucun plugin
403 PLUGIN_ID_MISMATCH Le corps nomme un autre plugin
409 REGISTRY_CONFLICT Un type de tâche appartient à une autre entité ou a été enregistré en dehors de la synchronisation ; aucune écriture effectuée

Faites échouer votre étape de déploiement pour tout statut autre que 200. Aucun autre statut ne signifie que vos compétences sont enregistrées.

Intégration

L'intégration s'exécute en dix étapes ordonnées, chacune pouvant être relancée, annulée ou annulée par retour arrière indépendamment :

  1. Cloner le dépôt et le valider.
  2. Analyser le manifeste.
  3. L'analyser pour détecter d'éventuels problèmes de sécurité.
  4. Construire l'image.
  5. La pousser vers le registre de l'installation.
  6. Configurer ses noms de domaine.
  7. La déployer, via les canaux de publication de l'installation.
  8. Attendre la vérification de l'état de santé.
  9. Enregistrer le plugin.
  10. Informer le développeur.

Avant le déploiement, cinq vérifications de conformité s'exécutent sur le manifeste et l'image construite : le manifeste est analysable et contient ses champs obligatoires ; chaque route déclarée est une route réellement enregistrée ; le plugin possède son schéma et n'écrit rien en dehors de celui-ci ; les demandes de ressources sont déclarées et dans les limites autorisées ; et l'image dispose d'un gestionnaire d'état de santé fonctionnel. Un plugin qui s'enregistre lui-même au démarrage exécute le même contrat sous sa propre autorité, de sorte que ces vérifications deviennent sa propre CI au lieu de celle du pipeline. En ignorer une ne raccourcit pas l'intégration ; cela déplace simplement la défaillance vers l'exécution.

Les éléments de marque de votre manifeste sont servis sans authentification par domaine, car la page de connexion en a besoin avant même qu'un utilisateur ne dispose d'identifiants. Considérez tout ce qui se trouve dans branding comme public.

Environnements et promotion
Environnements et promotion
La vue Environnements et promotion fait passer chaque version de l'espace de développement à une unité pilote via la préproduction, puis à toutes les unités, en affichant chaque porte de validation et son état sur une seule page. Une promotion qui tente de contourner une porte est refusée avec GATE_CANNOT_BE_SKIPPED.
Canaux et installations
Canaux et installations
La vue Canaux et installations indique quelle unité exécute quelle version, en présentant les taux d'erreur sous forme de compteurs et jamais de contenu. La restauration d'une unité à une version antérieure est une modification soumise à révision qui n'affecte que cette unité.

Ce que l'environnement d'exécution ne fera pas pour vous

L'environnement d'exécution assure une maîtrise stricte de l'isolation, de la répartition et de l'accès aux modèles. Il ne corrigera pas la logique de votre produit à votre place, et il ne rendra pas rapide une requête lente : chaque instruction s'exécute au sein d'une transaction bornée avec les délais d'expiration déclarés dans le bloc db de votre manifeste, et une instruction qui dépasse statementTimeoutMs est annulée, sans attente supplémentaire. Dimensionnez vos requêtes en conséquence. De plus, la mise en attente d'approbation, le siège de lecture et le lecteur de licence ajoutent chacun un aller-retour ou une transaction. Sur mon plugin d'examen d'anomalies, la vérification de licence ajoutait quelques millisecondes par requête jusqu'à ce que son cache de 30 secondes soit préchauffé, ce qui était un juste prix à payer pour ne jamais servir une fonctionnalité verrouillée.