ConnexionPlanifier un briefing

Chapitre 2.27

Scénarios de développement

Un recueil de treize réalisations, d'une simple compétence à une livraison en environnement isolé (air-gapped). Chaque recette indique l'objectif, les briques de base, les étapes et les commandes, la porte de contrôle qui prouve son bon fonctionnement, et ce qui change selon l'édition et le mode de livraison.

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

25 minutes de lecture

Voici les recettes auxquelles j'ai recours lorsque quelqu'un chez Corrán Orbital, ou chez un client, dit « nous voulons que Nexus fasse X ». Chacune est volontairement courte. Le raisonnement derrière les étapes figure dans les chapitres qui précèdent celui-ci : le chapitre 2.20, Skills, et le chapitre 2.21, Le Plugin SDK, qui traite du kit de développement logiciel, puis le chapitre 2.23, Domain packs, et les trois chapitres suivants consacrés à la construction. Vous trouverez ici l'objectif, les briques à utiliser, les étapes, les commandes, le contrôle qui vous indique que cela a fonctionné, ainsi que les remarques sur l'édition et la livraison.

Le contrôle est ce qui compte le plus. Une recette est terminée lorsque son contrôle est au vert. Chaque contrôle de ce chapitre est quelque chose que vous pouvez exécuter ou que la plateforme exécute pour vous, et chacun se termine avec un code de sortie non nul ou refuse avec un code lorsqu'il n'est pas satisfait.

Scénario Brique principale Le contrôle qui le prouve Édition
Un nouveau skill du Skills Engine Package SKILL.md skill:validate sans aucune erreur Community et Enterprise
Un skill de manifeste avec host_callback Manifeste de plugin skills[] create-nexus-plugin validate et nexus-gates Community et Enterprise
Étendre un pack existant pack.json avec inherits Vérification de la politique des lentilles au contrôle pilote Enterprise et une licence de pack
Un nouveau pack à partir de zéro Parcours de référence des domain packs Contrôles de préproduction et pilote Enterprise
Un connecteur de données Skill plugin_queue validate, nexus-gates, refus de sortie réseau Community et Enterprise
Un outil MCP (Model Context Protocol) Manifeste mcpTools[] validate (aucun combinateur de premier niveau) Community et Enterprise
Une vitrine en marque blanche Manifeste domains et branding Règle publique scope-adherence Enterprise et le module complémentaire Storefront
Un pack de mission Edge Pack de mission Cas de test embarqués, deux signatures sur trois Enterprise et le module complémentaire Nexus Edge
Une livraison en environnement isolé Bundle scellé nexus-airgap verify Enterprise
Un module réservé à Enterprise @adverant/nexus-spi Contrôle de la ligne de licence, builds par édition Enterprise
Forker ou étendre le cœur open source Le code source Community Tests, lint et vérification des types Community
Une application cloud de l'édition Team Cluster d'éditeur Version signée, revue, autorisation client Team
Encapsuler une application interne existante /plugin-create migrate, validate, nexus-gates Community et Enterprise
Un arbre de décision qui se lit de haut en bas. Le premier losange demande « Faut-il du code qui s'exécute en permanence ? ». « Non » mène à un losange « S'agit-il d'instructions pour un assistant ? », dont le « Oui » aboutit à « Compétence Skills Engine » et le « Non » à « Lens sur un pack existant ». « Oui » mène à un losange « S'agit-il de la vue d'un secteur sur la plateforme ? », dont le « Oui » aboutit à « Pack de domaine (avec son plugin) » et le « Non » mène à un dernier losange « Doit-il rester fermé et sous licence ? », qui aboutit à « Module Enterprise » pour « Oui » et à « Plugin » pour « Non ».
Par quelle brique commencer.

1. Une nouvelle compétence du Skills Engine

L'objectif est une instruction réutilisable que l'assistant, les agents, les workflows et les outils de développement peuvent tous exécuter, par exemple vérifier une déclaration en douane au regard de ses règles. Vos briques sont un package SKILL.md dans un dossier portant le nom du skill, un skill.yaml facultatif pour les déclencheurs et les étiquettes, et un dossier scripts/ facultatif fourni avec.

  1. Créez skills/<slug>/ et rédigez SKILL.md avec un frontmatter : name (en kebab-case, identique au nom du dossier), description (jusqu'à 500 caractères), allowed-tools et, facultativement, triggers, capabilities et version.
  2. Rédigez le corps à l'intention du modèle : quand utiliser le skill, ses étapes, des exemples et ce qu'il ne doit jamais faire.
  3. Ajoutez des cas de test. Incluez-en un avec une instruction dissimulée dans l'entrée que le skill ne doit pas suivre.
  4. Validez, examinez le plan de téléversement, puis téléversez.
  5. Publiez. Un skill qui ajoute un outil d'écriture est retenu jusqu'à ce que deux personnes nommément désignées l'approuvent avec des passkeys, et l'auteur de la proposition ne peut pas approuver sa propre modification.
npm run skill:validate skills/check-a-customs-filing
npm run skill:upload skills/check-a-customs-filing --dry-run
npm run skill:upload skills/check-a-customs-filing

Le contrôle est skill:validate, qui doit signaler zéro erreur avant que quoi que ce soit puisse être publié. Les erreurs bloquantes sont l'absence de nom ou de description et un slug ou un type de tâche en double. Téléverser un contenu déjà publié renvoie la version existante (CONTENT_HASH_ALREADY_PUBLISHED) : le téléversement peut donc être répété sans risque.

Community dispose de l'ensemble de l'éditeur, de la bibliothèque, des versions, du retour arrière, de l'import et des tests. Sur Enterprise, la publication passe également par les phases shadow et canary : la version approuvée s'exécute en mode shadow, puis pour une unité derrière des contrôles nommés, puis pour tout le monde, et elle s'arrête d'elle-même si un contrôle n'est pas satisfait. Pour un client en environnement isolé, les skills sont transmis pré-signés à l'intérieur du bundle scellé (scénario 9).

2. Une compétence de manifeste avec host_callback

L'objectif est un calcul déterministe dans votre propre plugin que la plateforme peut distribuer, par exemple ouvrir un enregistrement d'écart à partir d'une mesure. Vous utiliserez une ligne dans le skills[] du manifeste avec le niveau host_callback, et une route /internal dans votre backend protégée par le service guard du SDK.

  1. Déclarez le skill : id en lower_snake, tier: "host_callback", un classification inférieur ou égal au plafond de confiance de votre plugin, inputSchema, outputSchema et un timeoutMs compris entre 1 seconde et 6 heures.
  2. Renseignez hostCallback : le nom de votre propre Service, son port, un chemin relatif tel que /internal/skills/excursion_open, les deux plafonds d'octets (maxRequestBytes et maxResponseBytes) et tenantHeader: "X-Organization-ID".
  3. Déclarez la route dans api.endpoints[] avec auth: "service-key" ou auth: "internal", et protégez-la avec requireService ou serviceMiddleware, jamais avec le guard de portée utilisateur.
  4. Validez, exécutez les contrôles et laissez l'intégration synchroniser les skills avec le registre via compileRegistry. Vous n'écrivez jamais de SQL de registre à la main.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-test

validate applique les propres règles de la synchronisation du registre avant toute synchronisation, chaque refus portant le code du destinataire. Un chemin comportant un schéma, // ou une barre oblique inverse est refusé comme cross-origin. Un plafond d'octets manquant donne ENDPOINT_BYTE_CAP_REQUIRED, un champ d'un autre niveau donne FIELD_NOT_FOR_TIER, et un délai hors plage donne TIMEOUT_OUT_OF_BOUNDS. Ensuite, nexus-gates vérifie que la route /internal porte le service guard et est déclarée internal ou service-key. Cette paire de contrôles constitue la preuve.

La synchronisation est déclarative. Envoyez l'ensemble complet des skills à chaque fois, car un skill omis est désactivé, et faites échouer votre étape de déploiement pour tout statut autre que 200. Sur Enterprise, la synchronisation d'un plugin est vérifiée dans son ensemble : si un skill enfreint une règle, rien de cette synchronisation n'est retenu (PLUGIN_SYNC_ALL_OR_NOTHING) et la version précédente continue de s'exécuter. Un plugin de confiance communautaire ne peut pas utiliser les niveaux qui accèdent à un modèle, tool_using et llm_only ; ceux-ci exigent la confiance core ou verified.

Plugins et synchronisation MCP
Plugins et synchronisation MCP
Les plugins qui apportent des skills, et ce sur quoi chaque synchronisation a été vérifiée. Remarquez le plugin dont la synchronisation a été entièrement refusée parce que l'un de ses cinq skills utilisait un niveau que seule la plateforme peut héberger, tandis que sa version précédente continuait de s'exécuter.

3. Étendre un pack existant

L'objectif est un nouveau secteur ou sous-secteur qui réutilise l'essentiel d'un pack existant, comme le crédit et les litiges sur cartes reposant sur la structure du pack Insurance. La brique est un pack.json qui nomme son parent dans inherits et n'ajoute que ses propres groupes de lentilles et son propre vocabulaire.

  1. Démarrez le pack avec le parcours de référence des domain packs, puis définissez inherits sur l'identifiant du pack parent.
  2. Ajoutez vos propres groupes lens, chacun avec ses postes, son objet et sa référence de lexique.
  3. Ajoutez vos termes au lexique, chacun avec une glose simple. Marquez un terme exact lorsqu'il doit être affiché tel quel.
  4. Réutilisez les lentilles partagées plutôt que de dessiner les vôtres : un régime dont plusieurs packs ont besoin, comme un registre des prestations technologiques externalisées, constitue une seule lentille partagée.
  5. Vérifiez la chaîne de licences. Votre pack hérite des exigences de modules complémentaires de son parent.
  6. Prévisualisez chaque lentille en vous mettant à la place d'une personne, sur une branche synthétique.
{ "id": "fintech", "name": "Banking and payments", "version": "0.1", "inherits": "insurance" }

La preuve est la vérification de politique du contrôle pilote, qui confirme que chaque lentille ne fait que restreindre sa base et que les champs personnels restent masqués par défaut. Une lentille qui tente d'afficher ce que sa base masque est refusée avec LENS_CANNOT_WIDEN. Côté licences, la console refuse d'émettre une licence pour votre pack sans les modules complémentaires requis par son parent ; le pack Insurance requiert les salles de décision et les enregistrements scellés.

Les domain packs relèvent d'Enterprise et sont licenciés par pack. Les écrans mobiles d'un pack nécessitent également le module complémentaire Mobile apps. Un pack enfant ne peut pas modifier le shell, les composants ni les règles de rédaction.

4. Un nouveau pack de A à Z

L'objectif est la vue d'un secteur sur Nexus : son modèle de connaissances, les lentilles de chaque rôle, les preuves exigées par ses règles et le plugin qui maintient ses données à jour. Le chapitre 2.24, Construire une verticale personnalisée de bout en bout, détaille entièrement cette construction ; en voici la version courte.

  1. Exécutez le parcours de référence des domain packs et décrivez le pack : objet, unités, modèle de base et règles qu'il couvre.
  2. Construisez le modèle de connaissances sur un modèle de base et classez chaque propriété au fur et à mesure que vous l'ajoutez.
  3. Lisez le plan, confirmez son empreinte avec votre passkey, puis créez.
  4. Façonnez les lentilles dans le Lens builder, chacune restreignant une lentille de base.
  5. Écrivez le plugin et les éventuels skills du Skills Engine dont le pack a besoin.
  6. Générez des données synthétiques à partir d'une graine, avec les cas particuliers qui vous importent, et prévisualisez chaque lentille en vous mettant à la place d'une personne.
  7. Promouvez de l'espace de développement vers la préproduction, puis vers une unité pilote, puis vers toutes les unités.

La preuve réside dans les contrôles de promotion : tous les tests réussis sur les branches synthétiques pour passer en préproduction, puis deux relecteurs qui ne sont pas l'auteur, puis 14 jours en pilote avec moins de 1 erreur sur 1,000. Aucune étape ne peut être sautée (GATE_CANNOT_BE_SKIPPED). Les packs relèvent d'Enterprise. Sur Community, le parcours de référence des domain packs n'est pas proposé.

5. Un connecteur de données

L'objectif est que des données d'un système externe alimentent les tables de votre plugin selon un calendrier, par exemple les événements de portail provenant d'un système d'exploitation de terminal. Les briques sont un skill plugin_queue, un worker qui consomme votre file, une migration pour la table cible et une adresse sortante déclarée dans le manifeste.

  1. Déclarez un skill plugin_queue avec queueName écrit <plugin name>.<name>. Aucun deux-points n'est autorisé, et le nom doit figurer dans le manifeste, car l'orchestrateur y place directement les tâches.
  2. Écrivez le worker qui consomme la file et appelle le système externe.
  3. Déclarez l'adresse du système externe comme adresse sortante. Tout ce qui n'est pas listé est bloqué.
  4. Stockez ce qui arrive dans votre propre schéma, avec organization_id, owner_user_id et business_unit_id sur chaque ligne.
  5. Lisez l'identifiant du système externe par son nom depuis l'environnement, et listez la variable dans scripts/ci/required-env.
  6. Déclenchez les récupérations via UNO, le moteur de workflows, jamais avec un minuteur qui appelle directement les moteurs.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only no-credentials --only no-direct-compute --only migrations-are-scoped
node scripts/ci/required-env

validate vérifie le nom de la file et le délai au regard des règles de la synchronisation du registre. Les trois contrôles prouvent l'absence d'identifiant de modèle, l'absence de calcul direct et une table correctement délimitée. Exécutez le nexus-gates complet avant de pousser, car --only restreint l'exécution et l'indique dans son résumé. À l'exécution, un appel vers une adresse non déclarée dans le manifeste est arrêté en périphérie avec EGRESS_NOT_DECLARED.

Les connecteurs propres à la plateforme vers les disques, wikis, messageries et systèmes hérités, avec capture des modifications et traçabilité, sont fournis avec le module complémentaire Data connectors. Un connecteur que vous construisez vous-même est un plugin et fonctionne sur toutes les éditions. L'ajout d'une adresse sortante dans une version ultérieure constitue un élargissement, retenu jusqu'à ce que deux relecteurs l'acceptent.

6. Un outil MCP

L'objectif est un outil que Claude Code, les agents et d'autres clients MCP (Model Context Protocol) peuvent appeler, par exemple pour consulter l'historique d'inspection d'un navire. La brique est une entrée dans le mcpTools[] du manifeste, avec un name, un description et un inputSchema.

  1. Nommez l'outil et décrivez-le simplement. La description est ce que lit un modèle pour décider de l'appeler ou non.
  2. Rédigez le inputSchema sous la forme d'un seul schéma d'objet. Ne placez pas oneOf, allOf ni anyOf à son premier niveau.
  3. Conservez la route qui sert l'outil derrière le garde de portée, comme toute autre route /api, afin que le locataire soit déterminé à partir du jeton de l'appelant.
  4. Validez le manifeste.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json

La preuve est validate : un combinateur de premier niveau est refusé dès la rédaction, car à l'exécution il ferait échouer l'outil pour chaque sous-agent MCP qui l'importe, et l'outil existerait sans que personne puisse l'appeler.

Sur Enterprise, chaque outil qu'un IDE (environnement de développement intégré) peut appeler est répertorié dans le catalogue d'outils du Workbench avec son niveau, le fait qu'il modifie ou non des données, une empreinte figée et les rôles autorisés à l'utiliser. Si la description de votre outil change dans une nouvelle version, le catalogue retient l'outil jusqu'à ce qu'une personne examine la modification. C'est délibéré : une description modifiée est la manière dont un outil peut commencer à demander à un modèle quelque chose qu'il ne devrait pas. Un appel à tout élément hors du laissez-passer de l'appelant est refusé avec CONNECTION_SCOPE_EXCEEDED.

7. Une vitrine en marque blanche

L'objectif est une application utilisée par les propres clients de votre client, sur le domaine du client et à sa marque, sans aucune trace d'Adverant. Les briques sont les blocs domains et branding du manifeste, les fonctions de connexion du SDK et le module complémentaire Storefront / marque blanche du client.

  1. Placez le domaine du client dans domains[] sous la forme primary, avec les éventuels aliases.
  2. Renseignez branding : appName, tagline, primaryColor, accentColor, un passkeyRpId identique au domaine, et oauthClientRef.
  3. Connectez les utilisateurs via les fonctions de connexion du SDK, et déclarez exactement leurs deux routes publiques, avec auth: "public" et allowAnonymous: true.
  4. Faites passer chaque appel du frontend par le proxy à liste d'autorisation du backend for frontend. Ne placez jamais d'adresse de service dans le client.
  5. Laissez les paiements à l'administrateur du client, qui connecte les passerelles et configure le paiement à sa marque.
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only scope-adherence --only api-contract

La preuve est scope-adherence. Il n'admet une route /api non protégée que lorsque le manifeste déclare cette méthode et ce chemin exacts comme publics et que le chemin est l'une des routes de connexion ; toute autre déclaration publique échoue et indique les deux chemins autorisés. api-contract compare ensuite les routes déclarées aux routes réelles dans les deux sens. definePlugin refuse également un frontend.basePath qui n'est pas un chemin relatif de même origine.

La marque blanche correspond au module complémentaire Storefront / marque blanche de l'offre Enterprise, qui donne également droit aux paiements. Les données de carte ne transitent jamais par Nexus. L'administrateur du client est propriétaire de la marque, et la plateforme la détermine à partir de l'organisation plutôt qu'à partir de votre code.

8. Un pack de mission Edge

L'objectif est une mission nouvelle ou mise à jour pour un satellite ou un drone exécutant Nexus Edge, par exemple l'ajout d'un adaptateur de détection de navires à une mission de veille maritime. L'élément de base est un pack de mission, construit et signé au sol.

  1. Partez du pack actuel sur la page Construire un pack de mission, qui prépare la nouvelle version à partir de l'ancienne et signale chaque modification.
  2. Ne modifiez que ce dont la mission a besoin. Conservez les éléments volumineux, le modèle de langage et l'ontologie, inchangés lorsque c'est possible.
  3. Vérifiez la table de placement à chaque étape dégradée, afin que chaque carte reste adaptée à ce qu'elle exécute.
  4. Exécutez les cas de test embarqués du pack sur un banc d'essai équipé des mêmes cartes.
  5. Envoyez-le pour signature : deux signatures sur trois sont requises.
  6. Publiez-le sur une seule plateforme. Il est placé dans l'emplacement inactif et n'est activé qu'une fois ses cas de test réussis à bord.
  7. Déployez-le sur la plateforme suivante après une semaine sans incident.
Packs de mission
Packs de mission
La bibliothèque de packs de mission, avec le contenu de chaque pack et les plateformes qui l'exécutent. Notez l'ancienne version conservée à bord pour un éventuel retour arrière, ainsi que le nombre de cas de test que chaque pack doit réussir sur son matériel.

Cette recette ne comporte aucune commande ; elle se réalise dans les pages Nexus Edge de la console. La preuve réside dans les cas de test embarqués, qui doivent tous réussir avant l'activation du pack, et dans les deux signatures. Si un test échoue à bord, la plateforme reste sur son pack précédent et l'échec est transmis lors du passage suivant. L'installation d'un pack sur un matériel pour lequel il n'a pas été vérifié est refusée avec PACK_NOT_CHECKED_FOR_HARDWARE.

Nexus Edge est un module complémentaire, sous licence par plateforme ou par flotte. Les packs restent valides lorsqu'une plateforme est hors de contact. La liaison montante est étroite ; planifiez donc les tailles en conséquence : notre version 1.5 pesait 412 MB, contre 9.8 GB pour un pack comportant un nouveau modèle de langage.

9. Une livraison en environnement isolé (air-gapped) à un client

L'objectif est l'installation de votre plugin ou de votre pack sur un site client sans réseau. Les éléments de base sont un bundle scellé issu de @adverant/nexus-sovereign, votre clé de signature de publication et les canaux de publication propres au client.

  1. Construisez le plugin et ses images exactement comme pour un client connecté, avec tous les contrôles au vert.
  2. Créez un bundle scellé avec le profil airgap, contenant les images, les migrations, les compétences pré-signées et une SBOM (nomenclature logicielle) avec les licences.
  3. Signez-le avec votre clé de publication Ed25519.
  4. Vérifiez-le vous-même sur une machine vierge.
  5. Envoyez le bundle sur un support physique, et transmettez votre clé publique et le SHA-256 du bundle par un canal distinct.
  6. L'opérateur du client vérifie le bundle avec votre clé, puis intègre la version par ses propres canaux de publication.
nexus-airgap bundle
nexus-airgap verify --bundle cold-chain-0.4.0.tar.gz --trusted-key corran-release.pub.pem --profile airgap

nexus-airgap bundle construit le bundle à partir de votre configuration de bundle. La preuve est nexus-airgap verify côté client. Il recalcule l'empreinte de chaque fichier, rejette tout fichier absent du manifeste, exige un signataire de confiance et refuse un bundle dont la liste d'autorisation réseau n'est pas vide. Un fichier modifié échoue avec BUNDLE_INTEGRITY_VIOLATION. Personne ne doit jamais désactiver la vérification stricte pour la contourner.

Les installations isolées (air-gapped) relèvent de l'offre Enterprise. Rien dans le bundle ne doit télécharger quoi que ce soit lors de l'installation, et un modèle nécessaire au plugin provient du serveur de modèles propre au client via l'AI (intelligence artificielle) Provider Router.

10. Un module réservé à l'édition Enterprise

L'objectif est une fonctionnalité fermée et sous licence qui se greffe au cœur ouvert, comme une piste d'audit à longue rétention vendue uniquement aux clients Enterprise. L'élément de base est le paquet d'interface @adverant/nexus-spi, et rien d'autre provenant de Community.

  1. Conservez dans votre dépôt une copie figée à l'octet près du paquet d'interface construit, en tant que paquet local file:, avec son épinglage SHA256SUMS.
  2. Écrivez un RouteModule (ou un ScreenModule pour les écrans de la console) qui s'appuie dessus, avec le groupe de fonctionnalités qu'il dessert.
  3. Placez chaque route derrière ctx.requireScope, et vérifiez le droit propre au module avant de répondre.
  4. Refusez avec LICENCE_LOCKED lorsque l'organisation n'y a pas droit, et affichez l'aperçu de la fonctionnalité, jamais ses données.
  5. Maintenez le dépôt dans le respect de la ligne de licence, puis construisez l'arborescence composée de chaque édition.
npm ci
npm test
npm run build

La preuve est la règle de la ligne de licence : aucun import depuis un périmètre Community à l'exception du paquet d'interface, aucun import relatif sortant du dépôt, et aucune dépendance file:, link: ou workspace: en dehors de celui-ci. Ensuite, les trois commandes ci-dessus doivent réussir dans l'arborescence composée de chaque édition, et pas seulement dans votre arborescence de travail. Le chapitre 2.25, Construire pour chaque édition, contient le squelette du module.

Un module se charge dans un service Community au démarrage, sur les installations dont la licence inclut son groupe de fonctionnalités. Sans ce droit, il refuse ; la même version est donc livrée partout et ne fait rien là où elle n'est pas sous licence.

11. Dupliquer (forker) ou étendre le cœur open source

L'objectif est une modification de Community lui-même, conservée dans votre fork ou reversée au projet. L'élément de base est le code source de Community sous Apache License, Version 2.0.

  1. Forkez le dépôt et créez une branche à partir de main.
  2. Privilégiez un plugin ou une compétence si ce que vous souhaitez peut en être un. Une modification du cœur est à votre charge de maintenance à chaque version.
  3. Effectuez la modification avec des tests qui échouent sans elle.
  4. Exécutez les vérifications du projet avant de proposer quoi que ce soit.
  5. Conservez le fichier NOTICE, et n'utilisez pas les noms ou marques d'Adverant au-delà de l'indication de l'origine du travail.
git checkout -b feature/your-change
npm test
npm run lint
npm run typecheck

La preuve est la réussite de ces trois vérifications, ainsi que la démonstration que chaque nouveau test échouait avant votre modification. Préservez dans votre fork une propriété du cœur ouvert : Community exécute un agent de bout en bout sur un modèle local, sans clé et sans réseau. Une modification qui rompt cela rompt ce qui rend Community utilisable de manière autonome.

Ceci concerne uniquement Community. Tout ce qui doit rester fermé relève plutôt d'un module Enterprise (scénario 10), afin que la ligne de licence reste à un endroit que chacun peut désigner.

12. Une application cloud pour l'édition Team

L'objectif est une application que les clients Team peuvent installer. Team fonctionne uniquement sur Adverant cloud ; l'application ne les atteint donc que par le catalogue. Les éléments de base sont un plugin et un cluster éditeur : votre propre cluster virtuel sur Adverant cloud avec des données d'exemple.

  1. Construisez et testez sur le cluster éditeur, uniquement avec des données d'exemple.
  2. Déclarez dans son manifeste tout ce dont l'application a besoin, et rien de plus.
  3. Publiez-la signée, pour examen par Adverant et inscription au catalogue.
  4. Chaque client l'installe en accordant chaque périmètre déclaré, unité par unité.

La preuve se présente en deux parties. La version signée et examinée vous donne accès au catalogue. Ensuite, l'autorisation du client détermine ce que l'application peut atteindre sur son site, et tout appel non déclaré est refusé avec CONNECTION_SCOPE_EXCEEDED. Vous ne pouvez ajouter un périmètre manquant que dans une nouvelle version examinée par le client.

Installer un plugin tiers
Installer un plugin tiers
Un administrateur installant un plugin tiers, accordant chaque périmètre déclaré par unité et en omettant un. La planche montre un appel que le plugin n'a jamais déclaré, refusé.

Un cluster éditeur n'a aucune route vers un client, et toute demande de données d'un client y est refusée avec TENANT_BOUNDARY. Les clients peuvent partager avec vous des résultats de tests, jamais leurs données. Team inclut la fonctionnalité d'opérations de workflows ; si votre application fournit des workflows, les clients Team peuvent donc les promouvoir eux-mêmes d'un environnement à l'autre.

13. Encapsuler une application interne existante sous forme de plugin

L'objectif est une application que votre entreprise exploite déjà, intégrée à Nexus afin qu'elle hérite de la connexion, de l'isolation et de la gouvernance. Les éléments de base sont la compétence /plugin-create pour la première ébauche, ainsi que les outils de manifeste et les contrôles du SDK pour la finaliser.

  1. Exécutez /plugin-create avec le dépôt. Il analyse le code et choisit une stratégie d'encapsulation, puis génère le backend, les migrations, l'interface utilisateur (UI), le manifeste et les tests.
  2. Faites passer le manifeste au contrat v2. migrate ajoute les trois phrases de règle et déplace domain vers domains[], et il refuse d'inventer un point d'entrée.
  3. Remplacez toute valeur de tenant que l'encapsulation lit dans les en-têtes par le garde de périmètre du SDK.
  4. Ajoutez organization_id, owner_user_id et business_unit_id à chaque table, avec des clés primaires commençant par le tenant.
  5. Déclarez chaque route avec son droit, et installez le registre des refus.
  6. Exécutez les contrôles jusqu'à ce qu'ils soient au vert.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin migrate nexus.manifest.json --write
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --self-test

La preuve est la sortie de nexus-gates avec le code 0, avec scope-adherence, one-fence, migrations-are-scoped, crud-adherence et api-contract tous réussis. Attendez-vous à ce que la première exécution échoue sur la plupart d'entre eux ; la nôtre a signalé chaque route comme sans périmètre, car l'ébauche faisait confiance à des en-têtes que le navigateur pouvait définir. Les contrôles n'ont volontairement aucune option de correction automatique.

Les applications encapsulées fonctionnent sur toutes les éditions. Le déploiement passe uniquement par les canaux de publication de l'installation ; ignorez donc tout fichier de déploiement écrit par l'ébauche. C'est le travail d'isolation qui prend du temps : prévoyez des jours sur une application réelle, et non des heures.