AccediPrenota un briefing

Capitolo 2.27

Scenari di sviluppo

Un ricettario di tredici sviluppi, da una singola skill a una distribuzione air-gapped. Ogni ricetta indica l'obiettivo, i blocchi costitutivi, i passaggi e i comandi, il controllo che ne dimostra il funzionamento e cosa cambia in base all'edizione e alla modalità di distribuzione.

Questa pagina è stata tradotta dall'IA a partire dall'originale in inglese. In caso di dubbi, fa fede la pagina in inglese. Legga questa pagina in inglese

25 minuti di lettura

Queste sono le ricette a cui ricorro quando qualcuno in Corrán Orbital, o presso un cliente, dice "vogliamo che Nexus faccia X". Ognuna è volutamente breve. Il ragionamento alla base dei passaggi si trova nei capitoli precedenti: capitolo 2.20, Skill, e capitolo 2.21, Il Plugin SDK, che tratta il kit di sviluppo software, poi capitolo 2.23, Domain pack, e i tre capitoli successivi sulla costruzione. Qui trova l'obiettivo, quali elementi costitutivi usare, i passaggi, i comandi, il controllo che Le conferma che ha funzionato e le note su edizione e consegna.

Il controllo è ciò che conta di più. Una ricetta è completa quando il suo controllo è verde. Ogni controllo in questo capitolo è qualcosa che può eseguire Lei o che la piattaforma esegue per Lei, e ciascuno termina con un codice di uscita diverso da zero o rifiuta con un codice quando non è soddisfatto.

Scenario Elemento costitutivo principale Il controllo che lo dimostra Edizione
Una nuova skill dello Skills Engine Pacchetto SKILL.md skill:validate senza errori Community ed Enterprise
Una skill del manifest con host_callback skills[] del manifest del plugin create-nexus-plugin validate e nexus-gates Community ed Enterprise
Estendere un pack esistente pack.json con inherits Verifica delle policy delle lenti al controllo pilota Enterprise e una licenza del pack
Un nuovo pack da zero Percorso guidato per i domain pack Controlli di staging e pilota Enterprise
Un connettore di dati Skill plugin_queue validate, nexus-gates, rifiuto del traffico in uscita Community ed Enterprise
Uno strumento MCP (Model Context Protocol) mcpTools[] del manifest validate (nessun combinatore di primo livello) Community ed Enterprise
Uno storefront white-label domains e branding del manifest Regola pubblica scope-adherence Enterprise e l'add-on Storefront
Un mission pack Edge Mission pack Casi di test a bordo, due firme su tre Enterprise e l'add-on Nexus Edge
Una consegna air-gapped Bundle sigillato nexus-airgap verify Enterprise
Un modulo solo Enterprise @adverant/nexus-spi Controllo della linea di licenza, build per edizione Enterprise
Fork o estensione dell'open core Il codice sorgente Community Test, lint e controllo dei tipi Community
Un'app cloud per l'edizione Team Cluster editore Release firmata, revisione, concessione al cliente Team
Incapsulare un'app interna esistente /plugin-create migrate, validate, nexus-gates Community ed Enterprise
Un albero decisionale da leggere dall'alto verso il basso. Il primo rombo chiede "Richiede codice in esecuzione continua?". "No" porta a un rombo "Si tratta di istruzioni per un assistente?", il cui "Sì" termina in "Skill dello Skills Engine" e il cui "No" termina in "Lens su un pack esistente". "Sì" porta a un rombo "È la visione della piattaforma di un singolo settore?", il cui "Sì" termina in "Domain pack (con il relativo plugin)" e il cui "No" porta a un ultimo rombo "Deve restare chiuso e concesso in licenza?", che termina in "Modulo Enterprise" per "Sì" e "Plugin" per "No".
Da quale elemento costitutivo partire.

1. Una nuova skill dello Skills Engine

L'obiettivo è un'istruzione riutilizzabile che l'assistente, gli agenti, i workflow e gli strumenti per sviluppatori possono tutti eseguire, come la verifica di una dichiarazione doganale rispetto alle sue regole. I Suoi elementi costitutivi sono un pacchetto SKILL.md in una cartella con il nome della skill, un skill.yaml facoltativo per trigger e tag, e una cartella scripts/ facoltativa inclusa nel pacchetto.

  1. Crei skills/<slug>/ e scriva SKILL.md con il frontmatter: name (kebab-case, uguale al nome della cartella), description (fino a 500 caratteri), allowed-tools e, facoltativamente, triggers, capabilities e version.
  2. Scriva il corpo per il modello: quando usare la skill, i suoi passaggi, esempi e ciò che non deve mai fare.
  3. Aggiunga casi di test. Ne includa uno con un'istruzione inserita nell'input che la skill non deve seguire.
  4. Esegua la validazione, esamini il piano di caricamento, quindi carichi.
  5. Pubblichi. Una skill che aggiunge uno strumento di scrittura resta in attesa finché due persone designate non la approvano con passkey, e chi propone la modifica non può approvarla.
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

Il controllo è skill:validate, che deve riportare zero errori prima che qualsiasi cosa possa essere pubblicata. Gli errori bloccanti sono un nome o una descrizione mancanti e uno slug o un tipo di job duplicati. Caricare contenuti già pubblicati restituisce la versione esistente (CONTENT_HASH_ALREADY_PUBLISHED), quindi il caricamento può essere ripetuto senza rischi.

Community dispone dell'intero editor, della libreria, delle versioni, del ripristino, dell'importazione e dei test. Su Enterprise, la pubblicazione passa anche per shadow e canary: la versione approvata viene eseguita in shadow, poi per un'unità dietro controlli designati, poi per tutti, e si arresta da sola se un controllo non è soddisfatto. Per un cliente air-gapped, le skill viaggiano prefirmate all'interno del bundle sigillato (scenario 9).

2. Una skill del manifest con host_callback

L'obiettivo è un calcolo deterministico nel Suo plugin che la piattaforma possa avviare, come l'apertura di un record di escursione a partire da una lettura. Utilizzerà una riga in skills[] del manifest con il livello host_callback e una route /internal nel Suo backend protetta dal service guard dell'SDK.

  1. Dichiari la skill: id in lower_snake, tier: "host_callback", un classification pari o inferiore al limite di fiducia del Suo plugin, inputSchema, outputSchema e un timeoutMs compreso tra 1 secondo e 6 ore.
  2. Compili hostCallback: il nome del Suo Service, la sua porta, un percorso relativo come /internal/skills/excursion_open, entrambi i limiti in byte (maxRequestBytes e maxResponseBytes) e tenantHeader: "X-Organization-ID".
  3. Dichiari la route in api.endpoints[] con auth: "service-key" o auth: "internal" e la protegga con requireService o serviceMiddleware, mai con lo scope guard utente.
  4. Esegua la validazione, esegua i controlli e lasci che l'onboarding sincronizzi le skill nel registro tramite compileRegistry. Non scriva mai a mano SQL per il registro.
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 applica le regole proprie della sincronizzazione del registro prima che qualsiasi cosa venga sincronizzata, e ogni rifiuto riporta il codice del destinatario. Un percorso con uno schema, // o una barra rovesciata viene rifiutato come cross-origin. Un limite in byte mancante è ENDPOINT_BYTE_CAP_REQUIRED, un campo di un altro livello è FIELD_NOT_FOR_TIER e un timeout fuori intervallo è TIMEOUT_OUT_OF_BOUNDS. Poi nexus-gates verifica che la route /internal abbia il service guard e sia dichiarata internal o service-key. Questa coppia di controlli è la prova.

La sincronizzazione è dichiarativa. Invii ogni volta l'insieme completo delle skill, perché una skill omessa viene disattivata, e faccia fallire il passaggio di deploy per qualsiasi stato diverso da 200. Su Enterprise, la sincronizzazione di un plugin viene verificata nel suo insieme: se una skill viola una regola, nulla di quella sincronizzazione viene accettato (PLUGIN_SYNC_ALL_OR_NOTHING) e la versione precedente continua a funzionare. Un plugin con fiducia community non può usare i livelli che raggiungono un modello, tool_using e llm_only; questi richiedono la fiducia core o verified.

Plugin e sincronizzazione MCP
Plugin e sincronizzazione MCP
Plugin che forniscono skill e cosa è stato verificato in ciascuna sincronizzazione. Noti il plugin la cui sincronizzazione è stata rifiutata nel suo insieme perché una delle sue cinque skill usava un livello che solo la piattaforma può ospitare, mentre la sua versione precedente continuava a funzionare.

3. Estendere un pacchetto esistente

L'obiettivo è un nuovo settore o sottosettore che riutilizzi gran parte di un pack esistente, come prestiti e contestazioni delle carte basati sulla struttura del pack Insurance. L'elemento costitutivo è un pack.json che indica il proprio genitore in inherits e aggiunge solo i propri cluster di lenti e termini.

  1. Avvii il pack con il percorso guidato per i domain pack, quindi imposti inherits sull'id del pack genitore.
  2. Aggiunga i Suoi cluster lens, ciascuno con i propri posti, scopo e riferimento al lessico.
  3. Aggiunga i Suoi termini al lessico, ciascuno con una definizione semplice. Contrassegni un termine come exact quando deve essere mostrato così com'è scritto.
  4. Riutilizzi le lenti condivise anziché crearne di proprie: un regime di cui hanno bisogno più pack, come un registro della tecnologia esternalizzata, è un'unica lente condivisa.
  5. Verifichi la catena delle licenze. Il Suo pack eredita i requisiti di add-on del genitore.
  6. Visualizzi in anteprima ogni lente impersonando una persona su un branch sintetico.
{ "id": "fintech", "name": "Banking and payments", "version": "0.1", "inherits": "insurance" }

La prova è la verifica delle policy del controllo pilota, che conferma che ogni lente restringe soltanto la propria base e mantiene disattivati per impostazione predefinita i campi personali. Una lente che tenta di mostrare ciò che la sua base nasconde viene rifiutata con LENS_CANNOT_WIDEN. Sul fronte delle licenze, la console rifiuta di emettere una licenza per il Suo pack senza gli add-on richiesti dal genitore; il pack Insurance richiede Decision rooms e record sigillati.

I domain pack sono Enterprise e concessi in licenza per singolo pack. Le schermate per telefono di un pack richiedono anche l'add-on Mobile apps. Un pack figlio non può modificare la shell, i componenti o le regole di scrittura.

4. Un nuovo pacchetto da zero

L'obiettivo è la visione di Nexus propria di un settore: il suo modello di conoscenza, le lenti per ogni ruolo, le evidenze richieste dalle sue regole e il plugin che mantiene aggiornati i suoi dati. Il capitolo 2.24, Costruire un verticale personalizzato dall'inizio alla fine, illustra questa costruzione per intero; qui ne trova la forma breve.

  1. Esegua il percorso guidato per i domain pack e descriva il pack: scopo, unità, modello di base e regole che mappa.
  2. Costruisca il modello di conoscenza su un modello di base e classifichi ogni proprietà man mano che la aggiunge.
  3. Legga il piano, confermi la sua impronta con la Sua passkey e proceda alla creazione.
  4. Definisca le lenti nel Lens builder, ciascuna come restrizione di una lente di base.
  5. Scriva il plugin e tutte le skill dello Skills Engine di cui il pack ha bisogno.
  6. Generi dati sintetici con seed che includano i casi particolari che Le interessano, e visualizzi in anteprima ogni lente impersonando una persona.
  7. Promuova dallo spazio di sviluppo allo staging, a un'unità pilota, quindi a tutte le unità.

La prova sono i controlli di promozione: tutti i test superati sui branch sintetici per l'ingresso in staging, poi due revisori diversi dall'autore, poi 14 giorni in pilota con errori inferiori a 1 su 1.000. Nessun passaggio può essere saltato (GATE_CANNOT_BE_SKIPPED). I pack sono Enterprise. Su Community il percorso guidato per i domain pack non è disponibile.

5. Un connettore dati

L'obiettivo è un flusso di dati da un sistema esterno verso le tabelle del Suo plugin secondo una pianificazione, come gli eventi di gate da un sistema operativo di terminale. Gli elementi costitutivi sono una skill plugin_queue, un worker che preleva dalla Sua coda, una migrazione per la tabella di destinazione e un indirizzo in uscita dichiarato nel manifest.

  1. Dichiari una skill plugin_queue con queueName scritto <plugin name>.<name>. I due punti non sono ammessi e il nome deve essere nel manifest, perché l'orchestratore vi accoda direttamente.
  2. Scriva il worker che preleva dalla coda e chiama il sistema esterno.
  3. Dichiari l'indirizzo del sistema esterno come indirizzo in uscita. Tutto ciò che non è elencato viene bloccato.
  4. Memorizzi ciò che arriva nel Suo schema, con organization_id, owner_user_id e business_unit_id su ogni riga.
  5. Legga la credenziale del sistema esterno per nome dall'ambiente ed elenchi la variabile in scripts/ci/required-env.
  6. Avvii i prelievi tramite UNO, il motore di workflow, mai con un timer che chiama direttamente i motori.
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 verifica il nome della coda e il timeout rispetto alle regole della sincronizzazione del registro. I tre controlli dimostrano che non ci sono credenziali del modello, né calcolo diretto, e che la tabella ha un ambito corretto. Esegua il nexus-gates completo prima del push, poiché --only restringe l'esecuzione e lo indica nel riepilogo. In fase di esecuzione, una chiamata a un indirizzo non dichiarato nel manifest viene bloccata all'edge con EGRESS_NOT_DECLARED.

I connettori propri della piattaforma verso unità di archiviazione, wiki, archivi di posta e sistemi legacy, con change capture e lineage, sono inclusi nell'add-on Data connectors. Un connettore che costruisce Lei stesso è un plugin e funziona su qualsiasi edizione. Aggiungere un indirizzo in uscita in una release successiva costituisce un ampliamento, che resta in attesa finché due revisori non lo accettano.

6. Uno strumento MCP

L'obiettivo è uno strumento che Claude Code, gli agenti e altri client MCP (Model Context Protocol) possano chiamare, come la consultazione dello storico delle ispezioni di una nave. L'elemento costitutivo è una voce in mcpTools[] del manifest, con un name, un description e un inputSchema.

  1. Dia un nome allo strumento e lo descriva in modo semplice. La descrizione è ciò che un modello legge per decidere se chiamarlo.
  2. Scriva inputSchema come un unico schema di oggetto. Non inserisca oneOf, allOf o anyOf al suo primo livello.
  3. Mantenga la route che serve lo strumento dietro lo scope guard, come ogni altra route /api, in modo che il tenant derivi dal token del chiamante.
  4. Validi il manifest.
npx -p @adverant-nexus/plugin-sdk@2.50.0 create-nexus-plugin validate nexus.manifest.json

La prova è validate: un combinatore di primo livello viene rifiutato in fase di creazione, perché in fase di esecuzione farebbe fallire lo strumento per ogni subagente MCP che lo importa, e lo strumento esisterebbe senza che nessuno possa chiamarlo.

Su Enterprise, ogni strumento che un IDE (ambiente di sviluppo integrato) può chiamare è elencato nel catalogo degli strumenti di Workbench con il suo livello, l'indicazione se apporta modifiche, un'impronta fissata e i ruoli autorizzati a usarlo. Se la descrizione del Suo strumento cambia in una nuova release, il catalogo trattiene lo strumento finché una persona non esamina la modifica. È intenzionale: una descrizione modificata è il modo in cui uno strumento può iniziare a chiedere a un modello qualcosa che non dovrebbe. Una chiamata a qualsiasi cosa al di fuori del pass del chiamante viene rifiutata con CONNECTION_SCOPE_EXCEEDED.

7. Una vetrina white-label

L'obiettivo è un'app usata dai clienti del Suo cliente, sul dominio del cliente e con il suo marchio, senza alcuna traccia di Adverant. Gli elementi costitutivi sono i blocchi domains e branding del manifest, gli helper di accesso dell'SDK e l'add-on Storefront / white-label del cliente.

  1. Inserisca il dominio del cliente in domains[] come primary, con eventuali aliases.
  2. Compili branding: appName, tagline, primaryColor, accentColor, un passkeyRpId uguale al dominio e oauthClientRef.
  3. Faccia accedere le persone tramite gli helper di accesso dell'SDK e dichiari esattamente le loro due route pubbliche, con auth: "public" e allowAnonymous: true.
  4. Instradi ogni chiamata del frontend attraverso il proxy con allow-list del backend for frontend. Non inserisca mai l'indirizzo di un servizio nel client.
  5. Lasci i pagamenti all'amministratore del cliente, che collega i gateway e configura il checkout con il marchio.
npx -p @adverant-nexus/plugin-sdk@2.50.0 nexus-gates --only scope-adherence --only api-contract

La prova è scope-adherence. Ammette una route /api non protetta solo quando il manifest dichiara pubblici esattamente quel metodo e quel percorso e il percorso è una delle route di accesso; qualsiasi altra dichiarazione pubblica fallisce e indica i due percorsi consentiti. api-contract confronta quindi le route dichiarate con quelle reali in entrambe le direzioni. definePlugin rifiuta inoltre un frontend.basePath che non sia un percorso relativo della stessa origine.

Il white-label è il componente aggiuntivo Storefront / white-label di Enterprise, che concede in licenza anche i pagamenti. I dati delle carte non passano mai da Nexus. L'amministratore del cliente è titolare del marchio e la piattaforma lo ricava dall'organizzazione anziché dal Suo codice.

8. Un pacchetto missione Edge

L'obiettivo è una missione nuova o aggiornata per un satellite o un drone che esegue Nexus Edge, ad esempio l'aggiunta di un adattatore di individuazione navi a una missione di sorveglianza marittima. L'elemento costitutivo è un mission pack, creato e firmato a terra.

  1. Parta dal pack attuale nella pagina Crea un mission pack, che redige la nuova versione a partire dalla precedente e contrassegna ogni modifica.
  2. Modifichi solo ciò che serve alla missione. Quando possibile, mantenga stabili le parti più grandi, ossia il modello linguistico e l'ontologia.
  3. Controlli la tabella di posizionamento a ogni livello di degrado, in modo che ogni scheda sia ancora adeguata a ciò che esegue.
  4. Esegua i casi di test di bordo del pack su un banco di prova con le stesse schede.
  5. Lo invii per la firma: sono necessarie due firme su tre.
  6. Lo rilasci su una piattaforma. Viene caricato nello slot inattivo e attivato solo dopo che i suoi casi di test sono stati superati a bordo.
  7. Lo distribuisca alla piattaforma successiva dopo una settimana senza problemi.
Mission pack
Mission pack
La libreria dei mission pack, con il contenuto di ciascun pack e le piattaforme che lo eseguono. Si noti la versione precedente conservata a bordo per poter tornare indietro e il numero di casi di test che ogni pack deve superare sul proprio hardware.

In questa procedura non ci sono comandi: si svolge nelle pagine Nexus Edge della console. La prova sono i casi di test di bordo, che devono essere tutti superati prima dell'attivazione del pack, e le due firme. Se un test fallisce a bordo, la piattaforma resta sul pack precedente e l'errore viene scaricato al passaggio successivo. L'installazione di un pack su hardware per cui non è stato verificato viene rifiutata con PACK_NOT_CHECKED_FOR_HARDWARE.

Nexus Edge è un componente aggiuntivo, concesso in licenza per piattaforma o per flotta. I pack restano validi mentre una piattaforma è fuori contatto. Il collegamento in uplink è ridotto, quindi pianifichi le dimensioni di conseguenza: la nostra release 1.5 era di 412 MB, contro 9.8 GB per un pack con un nuovo modello linguistico.

9. Una distribuzione air-gapped a un cliente

L'obiettivo è il Suo plugin o pack installato presso un cliente privo di rete. Gli elementi costitutivi sono un bundle sigillato prodotto da @adverant/nexus-sovereign, la Sua chiave di firma delle release e i canali di rilascio del cliente stesso.

  1. Crei il plugin e le relative immagini esattamente come per un cliente connesso, con tutti i controlli superati.
  2. Crei un bundle sigillato con il profilo airgap, contenente le immagini, le migrazioni, le skill prefirmate e uno SBOM (software bill of materials) con le licenze.
  3. Lo firmi con la Sua chiave di release Ed25519.
  4. Lo verifichi personalmente su una macchina pulita.
  5. Invii il bundle su supporto fisico e trasmetta la Sua chiave pubblica e lo SHA-256 del bundle per una via separata.
  6. L'operatore del cliente verifica il bundle con la Sua chiave, quindi introduce la release tramite i propri canali di rilascio.
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 crea il bundle a partire dalla Sua configurazione del bundle. La prova è nexus-airgap verify lato cliente. Ricalcola l'hash di ogni file, rifiuta qualsiasi file non elencato nel manifest, richiede un firmatario attendibile e rifiuta un bundle la cui allow-list di rete non sia vuota. Un file modificato non supera la verifica con BUNDLE_INTEGRITY_VIOLATION. Nessuno dovrebbe mai disattivare la verifica rigorosa per aggirarla.

Le installazioni air-gapped sono Enterprise. Nessun elemento del bundle può scaricare alcunché durante l'installazione e un modello di cui il plugin ha bisogno proviene dal server di modelli del cliente stesso tramite l'AI (intelligenza artificiale) Provider Router.

10. Un modulo esclusivo per Enterprise

L'obiettivo è una funzionalità chiusa e concessa in licenza che si aggancia al core open, ad esempio un audit trail a lunga conservazione venduto solo ai clienti Enterprise. L'elemento costitutivo è il pacchetto di interfaccia @adverant/nexus-spi e nient'altro di Community.

  1. Conservi nel Suo repository una copia bloccata a livello di byte del pacchetto di interfaccia compilato, come pacchetto file: locale, con il relativo pin SHA256SUMS.
  2. Scriva un RouteModule (o un ScreenModule per le schermate della console) basato su di esso, con il gruppo di funzionalità a cui serve.
  3. Esegua ogni route dietro ctx.requireScope e verifichi l'autorizzazione del modulo stesso prima di rispondere.
  4. Rifiuti con LICENCE_LOCKED quando l'organizzazione non ne ha diritto e mostri l'anteprima della funzionalità, mai i suoi dati.
  5. Mantenga il repository entro la linea di licenza, quindi crei l'albero composto di ciascuna edizione.
npm ci
npm test
npm run build

La prova è la regola della linea di licenza: nessun import da uno scope Community tranne il pacchetto di interfaccia, nessun import relativo al di fuori del repository e nessuna dipendenza file:, link: o workspace: al di fuori di esso. Inoltre, i tre comandi sopra devono essere superati in ogni albero di edizione composto, non solo nel Suo albero di lavoro. Il Capitolo 2.25, Creare per ciascuna edizione, contiene lo scheletro del modulo.

Un modulo viene caricato in un servizio Community all'avvio, nelle installazioni la cui licenza include il suo gruppo di funzionalità. Senza tale autorizzazione si rifiuta, quindi la stessa build viene distribuita ovunque e non fa nulla dove non è concessa in licenza.

11. Effettuare il fork o estendere l'open core

L'obiettivo è una modifica a Community stesso, mantenuta nel Suo fork o restituita come contributo. L'elemento costitutivo è il codice sorgente di Community con Apache License, Version 2.0.

  1. Esegua il fork del repository e crei un branch da main.
  2. Preferisca un plugin o una skill, se ciò che desidera può esserlo. Una modifica al core spetta a Lei mantenerla a ogni release.
  3. Apporti la modifica con test che falliscono senza di essa.
  4. Esegua i controlli che esegue il progetto prima di proporre qualsiasi cosa.
  5. Conservi il file NOTICE e non usi i nomi o i marchi di Adverant oltre a indicare la provenienza del lavoro.
git checkout -b feature/your-change
npm test
npm run lint
npm run typecheck

La prova è il superamento di questi tre controlli, oltre all'evidenza che ogni nuovo test falliva prima della Sua modifica. Mantenga valida nel Suo fork una proprietà del core open: Community esegue un agente end-to-end su un modello locale, senza chiave e senza rete. Una modifica che la compromette compromette ciò che rende Community utilizzabile in autonomia.

Questo vale solo per Community. Tutto ciò che deve restare chiuso appartiene invece a un modulo Enterprise (scenario 10), così la linea di licenza resta in un punto che chiunque può indicare.

12. Un'app cloud per l'edizione Team

L'obiettivo è un'app che i clienti Team possano installare. Team funziona solo su Adverant cloud, quindi l'app li raggiunge solo tramite il catalogo. Gli elementi costitutivi sono un plugin e un cluster publisher: il Suo cluster virtuale su Adverant cloud con dati di esempio.

  1. Crei e testi sul cluster publisher, solo con dati di esempio.
  2. Dichiari nel manifest tutto ciò di cui l'app ha bisogno, e nulla di più.
  3. La rilasci firmata, per la revisione di Adverant e l'inserimento nel catalogo.
  4. Ogni cliente la installa, concedendo ogni scope dichiarato unità per unità.

La prova si articola in due parti. La release firmata e revisionata Le consente di entrare nel catalogo. Poi l'autorizzazione del cliente stabilisce ciò che l'app può raggiungere presso di lui e qualsiasi chiamata non dichiarata viene rifiutata con CONNECTION_SCOPE_EXCEEDED. Uno scope mancante può essere aggiunto solo in una nuova release che il cliente revisiona.

Installa un plugin di terze parti
Installa un plugin di terze parti
Un amministratore che installa un plugin di terze parti, concedendo ogni scope dichiarato per unità e tralasciandone uno. La tavola mostra una chiamata mai dichiarata dal plugin, rifiutata.

Un cluster publisher non ha alcun percorso verso i clienti e qualsiasi richiesta di dati di un cliente da lì viene rifiutata con TENANT_BOUNDARY. I clienti possono condividere con Lei i risultati dei test, mai i propri dati. Team include la funzionalità di operazioni sui workflow, quindi se la Sua app distribuisce workflow, i clienti Team possono promuoverli autonomamente tra gli ambienti.

13. Incapsulare un'app interna esistente come plugin

L'obiettivo è un'app che la Sua azienda già utilizza, portata in Nexus perché erediti accesso, isolamento e governance. Gli elementi costitutivi sono la skill /plugin-create per la prima bozza e gli strumenti per il manifest e i controlli dell'SDK per completarla.

  1. Esegua /plugin-create con il repository. Analizza il codice e sceglie una strategia di wrapping, quindi genera il backend, le migrazioni, l'interfaccia utente (UI), il manifest e i test.
  2. Porti il manifest al contratto v2. migrate aggiunge le tre frasi di legge e sposta domain in domains[], e si rifiuta di inventare un entrypoint.
  3. Sostituisca qualsiasi valore di tenant che il wrapper legge dalle intestazioni con lo scope guard dell'SDK.
  4. Aggiunga organization_id, owner_user_id e business_unit_id a ogni tabella, con chiavi primarie che iniziano con il tenant.
  5. Dichiari ogni route con il relativo diritto e installi il registro dei rifiuti.
  6. Esegua i controlli finché non vengono tutti superati.
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 prova è l'uscita di nexus-gates con codice 0, con scope-adherence, one-fence, migrations-are-scoped, crud-adherence e api-contract tutti superati. Si aspetti che la prima esecuzione fallisca sulla maggior parte di essi; la nostra ha segnalato ogni route come priva di scope, perché la bozza si fidava di intestazioni che il browser poteva impostare. I controlli non hanno un'opzione di correzione automatica, di proposito.

Le app sottoposte a wrapping funzionano su qualsiasi edizione. Il deployment avviene solo tramite i canali di rilascio dell'installazione, quindi ignori eventuali file di deployment scritti dalla bozza. Il lavoro sull'isolamento è quello che richiede più tempo: per un'app reale preveda giorni, non ore.