ВходЗапазете среща

Глава 2.22

Средата за изпълнение на плъгини

Модулите на SDK (пакета за разработка на софтуер), върху които работи Вашият плъгин – от защитата на обхвата и преградата на базата данни до диспечера на UNO, четенето на маршрута за ИИ (изкуствен интелект) и проверките на лиценза. Следват тестване срещу реална база данни, регистриране на Вашите умения и въвеждане в експлоатация.

Тази страница е преведена от ИИ от английския оригинал. Ако нещо е неясно, английската страница е референтна. Прочетете тази страница на английски

21 минути за четене

Изпълнимата половина на SDK (комплект за разработка на софтуер) е набор от модули под @adverant-nexus/plugin-sdk/runtime/*, плюс помощни средства за тестване под testing/*. Вие ги импортирате; не ги пренаписвате. Това е цялата идея и ми трябваше едно отхвърлено ревю, за да я приема сериозно: бележката на проверяващия за ръчно написаната проверка на обхвата в първия ми плъгин беше един-единствен ред: „SDK вече има това, а вашата приема MFA (многофакторна автентикация) токен за предизвикателство като сесия“.

Тази глава проследява заявка през работещ плъгин по начина, по който шаблонът за пълна услуга я свързва: защитата на обхвата, оградата на базата данни, единственото разрешено пресичане, диспечирането през UNO, четенето на маршрута за ИИ (изкуствен интелект) и проверките на лиценза. След това разглежда тестването, регистрирането на уменията от вашия манифест и стъпките за въвеждане в експлоатация.

Обхват: по една защита за всяка рамка

Всеки маршрут /api носи защитата на обхвата. Тя проверява токена от тип bearer (bearer token), извлича от него трите оси (абонат, собственик, звено), отхвърля тяло на заявка, което посочва абонат, прилага правото на маршрута от регистъра на манифеста и едва тогава позволява на манипулатора (handler) да се изпълни. SDK предоставя по един адаптер за всяка работна рамка, всички от @adverant-nexus/plugin-sdk/runtime/scope и всички приемащи едни и същи опции.

Работна рамка Адаптер
Express scopeMiddleware
Fastify requireScope, като preHandler
Следваща withScope, обвиващ манипулатора; манипулатор на Next не знае своя маршрут, затова withScope го приема като трети аргумент

Ето съкратеното свързване за Express от шаблона. Верификаторът е от SDK и изисква токенът да отговаря на формата за сесия на услугата за идентичност: само HS256; задължителни iss, exp, iat и jti; валидност най-много един час; и не се допускат като сесия токени за MFA предизвикателство, имперсонация или ресурсни токени за OAuth (отвореният стандарт за делегирано упълномощаване).

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

Защитата на правата прилага правото на даден маршрут в четири стъпки. Роля в списъка never на правото отказва достъп с AUTHORITY_EXCEEDED и думите от barred, като никое работно място (seat) не може да отмени това. Роля в roles допуска заявката, също и с активно място, когато правото указва seat: true. В противен случай активно място, носещо правото, допуска заявката. В противен случай заявката се отхвърля с AUTHORITY_EXCEEDED, като се посочват хората, които биха могли да предоставят място. Подайте на защитата хранилище (rights: { manifest, store: { pool, schema } }) и тя ще чете местата в собствения обхват на извикващия; право, което посочва licence, се нуждае и от четец на лицензи, разгледан по-долу.

Вътре в манипулатора scopeOf(req) е единственият начин за четене на разрешения обхват и хвърля грешка, ако защитата не се е изпълнила. Защита, регистрирана на префикс и изпълняваща се преди да е съвпаднал който и да е маршрут, отговаря с 500 MIDDLEWARE_ORDERING_ERROR; маршрут, който вашият код регистрира, но манифестът не декларира, отговаря с 500 UNHANDLED_ERROR. И двете прекъсват безопасно (fail closed).

Маршрутите /internal на шаблона, които платформата извиква, използват другия режим. Сервизната защита проверява X-Service-Key за константно време и взима абоната от X-Organization-ID на платформата, като отхвърля MISSING_SERVICE_KEY, INVALID_SERVICE_KEY или MISSING_ORG_ID_HEADER. За подписания токен на платформата за всяко отделно извикване SDK разполага с requireService (Fastify) и serviceMiddleware (Express), които също така проверяват за кое умение и маршрут е издаден токенът и отхвърлят токен, използван два пъти.

Оградата на базата данни: tenantFence и withScopedTx

Всяка заявка към таблица с обхват съставя оградата и се изпълнява в рамките на транзакция с обхват:

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) изгражда предиката и неговите параметри от разрешения обхват. Подайте owner за лични таблици; пропуснете го за организационни артефакти, където собственикът указва произход. Когато заявката вече има параметри, startIndex казва на оградата откъде да започне номерирането. Операцията за вмъкване (insert) никога не приема осите като входни данни: тя записва scope.tenant, scope.owner и scope.unit от обхвата.

withScopedTx обвързва и трите оси за една транзакция чрез единствената функция за обвързване на схемата, след което изпълнява вашата функция за обратно извикване (callback). Второ обвързване в същата транзакция предизвиква SCOPE_ALREADY_BOUND (500: вашият код е обвързал два пъти; извикващият не е направил нищо нередно). Липсващ или нулев абонат или собственик предизвиква SCOPE_PREDICATE_INVALID (403). Настройката е локална за транзакцията, така че връзка от пула не може да пренесе един абонат в следващата заявка.

Две сродни функции покриват случаите, които не са заявка от човек. withTenantScopedTx обвързва абонат и звено без собственик за редове, които се четат от машина (регистъра на устройствата), и отхвърля обхват, който съдържа собственик. maintenanceScope(reason) принуждава операция за цялата организация да обяви изрично каква е, преди да се отвори транзакцията на собственика. Кодовата ограда и принудителната сигурност на ниво ред (RLS) са два механизма за един закон; проверката при стартиране отказва да слуша, докато базата данни не докаже, че вторият е в сила (в противен случай връща DB_ROLE_BYPASSES_ISOLATION).

Всеки отказ е запис

Шаблонът инсталира още един междинен софтуер (middleware), еднократно, между парсера на тялото и рутерите: регистъра на отказите.

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

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

Той обвива отговора така, че всеки отказ, който човек получава — независимо дали от защитата на правата, манипулатор или хранилище — се записва в таблицата refusal на вашата схема в рамките на собствената транзакция с обхват на този човек, преди тялото да бъде изпратено. Анонимна грешка 401 не записва нищо. Ако редът не може да бъде записан, отговорът става UNHANDLED_ERROR: едно „не“, което продуктът не може да регистрира, не се изпраща така, сякаш е било регистрирано. При стартиране се изпълнява assertRefusalLedger, за да се провери дали таблицата може да приеме реда от регистъра, а хранилището може да извика noteSubject({ recordId, isDemo }), така че всеки отказ да посочва записа, за който се е отнасял. Когато клиент попита защо някой е бил върнат миналия вторник, отговорът е заявка към базата данни, а не предположение.

Единственото пресичане: записано разрешение само за четене

Когато един от вашите клиенти извършва работа за друг и другият има право да я инспектира, има един-единствен разрешен начин за преминаване на границата. Организацията, притежаваща редовете, записва разрешение (grant). Организацията на четящия допуска лице чрез място, носещо правото granted.read, което трябва да посочва owner и admin в never. Четенето се изпълнява като шеста роля в базата данни — мястото за четене (read seat), което може да прави select само върху таблиците, изброени в 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 първо записва прегледа в собствения абонат на четящия, след което обвързва мястото за четене с разрешението, което записва прегледа в абоната на притежателя. Собствената политика на базата данни проверява дали разрешението посочва организацията на четящия, покрива таблицата, започнало е, не е приключило и не е било оттеглено, както и дали тази транзакция е записала своя преглед. Четене, което прескочи записа на прегледа, не вижда нищо. При стартиране assertSeatAtBoot(seatPool, schema) проверява дали пулът, отворен от seat.url, наистина е мястото за четене и нищо повече, като в противен случай отказва с DB_SEAT_ROLE_INVALID.

Диспечиране чрез UNO

Всички изчисления преминават през един клиент, изграден в един файл, със затворен списък на разрешените (allow-list):

import { UnoClient } from "@adverant-nexus/plugin-sdk/runtime/uno";

/** The namespaced job types this surface may dispatch. Closed; edit in code. */
export const DISPATCHABLE = Object.freeze([`${manifest.name}.sentiment_score`] as const);

export function createUno(deps: UnoDeps): UnoClient {
  return new UnoClient({
    baseUrl: deps.dispatchUrl,
    serviceKey: deps.serviceKey,
    callerService: manifest.name,
    dispatchable: DISPATCHABLE,
  });
}

Списъкът на разрешените умишлено е константа на ниво модул. Ако оператор можеше да го разшири от конфигурацията, маршрутът би се превърнал в прокси за диспечиране за целия регистър. Собственият тест на шаблона проверява дали списъкът посочва точно типовете задачи, до които се компилира манифестът.

Обвивката (The envelope)

Диспечирането носи шест полета в своето задължително ядро. Клиентът попълва абоната и извършителя (actor) от проверения обхват, никога от заявката:

Поле Какво съдържа
jobType Типът на задачата с пространство от имена, <plugin name>.<skill id>
organizationId Абонатът, от обхвата
userId Извършителят, от обхвата, за одит и фактуриране
inputParams Входните данни на умението. Те никога не носят идентификатор на абонат; такива, които носят, биват отхвърлени при диспечиране
priority critical, high, normal или low
pluginId Вашият манифест name. Всяко диспечиране декларира плъгина, от който произхожда

Незадължителните полета включват correlationId (UUID (универсално уникален идентификатор), или се създава нов) и callbackUrl, от което се нуждае умение от тип plugin_queue, за да знае работният процес (worker) къде да публикува своя резултат.

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, след това периодично запитване (polling)

Всяко диспечиране се поставя на опашка. Отговорът винаги е 202 с идентификатори (jobId, runId, traceId, status), никога резултат. Резултатът идва от периодично запитване на задачата или от вашето обратно извикване. uno.peek(jobId, { scope }) го чете еднократно, а awaitJob прави периодични запитвания до краен статус; и двете изпращат абоната от проверения обхват, и двете проверяват organization_id на върнатия ред спрямо абоната на извикващия от вашата страна на мрежовото извикване, като отхвърлят несъответствие с SCOPE_REFUSED.

Четете реда на изпълнението така, както е изписан. Отговорът при диспечиране казва jobId; редът казва job_id, organization_id и plugin_id. Колоните за резултат и неуспех са result, error, error_code и error_troubleshooting. completed и failed са крайни статуси. timed_out, cancelled и system_failure идват от процеса по разчистване (reaper) и закъснял резултат все още може да ги коригира. Клиент, който третира някое от тях като невъзможно за парсване, отхвърля редове, които платформата записва всеки ден.

Задържането за одобрение

Умение от манифеста, което декларира approval, бива задържано при диспечиране. Тогава 202 казва status: "awaiting_approval" и носи waitpointId с причината, посочена от манифеста. Изпълнението остава задържано, докато посочено лице не вземе решение по него. uno.approve и uno.resolveWaitpoint изпращат абоната и извикващия като извършител, а решение от някой, различен от проверения извикващ, се отхвърля. Одобрението освобождава задачата еднократно и отново изпълнява проверките за диспечиране; отхвърлянето я прекратява с failed. Второ решение се отхвърля, както и решение след изтичане на задържането. Ако вашият продукт изисква одобряващият да е различно лице от предлагащия, наложете това в маршрута, който взима решението: платформата записва и двамата.

Визуализирайте задържаната задача като задържана. Не казвайте на потребителя, че неговото щракване я е освободило, докато редът на изпълнението не покаже това.

ИИ: предпочитания в записа на умението и едно четене

Вашият плъгин никога не извиква модел. Когато умение от манифеста се нуждае от такъв (llm_only или tool_using, при ниво на доверие core или verified), вие изразявате предпочитания в неговия ред в регистъра, а рутерът взема решение от собствения пул на организацията:

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

preferredProvider и preferredModel са пожелания, които рутерът уважава само когато организацията е активирала този доставчик и е въвела идентификационни данни за него. capabilityProfile филтрира и никога не избира; неговото dataResidency (eu_only, us_only или any) е твърдо ограничение, което рутерът или удовлетворява, или отказва. Пропускането на всички тях обикновено е правилният подход. modelOverride съществува за рядкото умение, което се нуждае от един точен модел, и прави пожеланията до него неактивни; бих го избягвал, освен ако умението не е безсмислено с който и да е друг модел.

Когато вашият интерфейс трябва да покаже кой модел би използвал рутерът, прочетете го, не го предсказвайте:

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

createAIRouteClient(...).effectiveRoute() е единственото разрешено четене от AI Provider Router. То приема адреса на шлюза, собствения токен (bearer) на извикващия и краткия идентификатор (slug) на вашата платформа, и не изпраща заявка към ИИ. То отговаря с доставчика и модела, доставчиците, които политиката разрешава, и дали избраната крайна точка се изпълнява като local или external. Когато маршрутът не е използваем, то връща отказа на рутера с думи (NO_PROVIDER_FOR_ROLE, MODEL_CAPABILITY_UNAVAILABLE или NO_MODEL_FOR_ROLE_AND_PROVIDER, заедно с начина за отстраняване), никога модел по подразбиране. Покажете този отказ на човека; това говори конфигурацията на неговата организация.

Проверки на лиценза

Три механизма проверяват лицензирането, на три нива на детайлност.

Право, което посочва лиценз. Най-простият вариант. В манифеста дадено право носи licence: "<feature>" и защитата пита услугата за идентичност дали лицензът на организацията го съдържа, използвайки собствения токен на извикващия, преди да бъде прочетена която и да е роля. Изградете защитата с четец:

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

Лиценз, който не съдържа функционалността, отказва достъп на всички с LICENCE_LOCKED, като посочва какво я съдържа и казва, че собствениците и администраторите на организацията могат да я включат. Лиценз, който не може да бъде прочетен, отказва с UNHANDLED_ERROR: заключена функционалност никога не се предоставя само защото лицензът е бил недостъпен. Отговорите се запомнят за 30 секунди за всяка организация и функционалност.

Продуктовата бариера. createProductGate({ baseUrl, product }) от runtime/product-gate пита проверката за правоспособност (entitlement check) дали организацията на извикващия изобщо притежава вашия продукт, а нейният middleware() се изпълнява след защитата на обхвата. Отрицателната присъда е ENTITLEMENT_DENIED; проверка, до която не може да се достигне, е ENTITLEMENT_UNREACHABLE, и бариерата никога не третира едното като другото.

Самият лицензионен документ. Код, който трябва да вземе решение сам от подписания лиценз, като например затворения модул на домейн пакет, използва verifyLicenceDocument(docText, opts) от runtime/licence-document. Това е чиста функция: без мрежово извикване, без променлива на средата, без файл. Тя проверява и двата подписа спрямо корените на доверие, които компилацията (build) носи, и отговаря със състояние (VALID, WARN, GRACE, RESTRICT, TERMINATE или ABSENT) заедно с разрешенията, добавките и домейн пакетите. След това licenceAllows(verdict, featureGroup, action, tenantId?) казва дали имате право на use или provision под дадена група. RESTRICT позволява use и отговаря на provision с LICENCE_LOCKED, така че текущата работа продължава, а нищо ново не започва.

Тестване

Тестовете на шаблона показват модела; това са инструментите зад него.

Имитации на обхват (Scope fakes). Изградете двойника на разрешения обхват еднократно в test/scope-fakes.ts и го инжектирайте навсякъде, включително за случаите с липсващи данни: без звено, без токен, токен с нулева организация. Пътищата за отказ са самият продукт.

Имитация на транспорт за диспечиране. UnoClient приема fetch, now и sleep, така че единичният тест (unit test) никога не докосва мрежата. Проверете (assert) полетата на обвивката, формата на 202, периодичното запитване до краен ред с неговия organization_id, както и това, че ред за друг абонат бива отхвърлен.

Истински Postgres. Имитираща функция за заявки доказва само SQL низ. Тя не може да докаже, че принудителната сигурност на ниво ред е в сила или че файловете се прилагат последователно от мигратора. testing/ephemeral-postgres стартира временен сървър и изпълнява същите nexus-migrate, които се изпълняват и в продукционна среда:

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

Извън CI (непрекъсната интеграция), машина без Postgres сървър пропуска всеки тест за базата данни поименно с посочване на решението, но никога със зелен статус. В CI същата липса проваля тестовия пакет (EPHEMERAL_POSTGRES_UNAVAILABLE_IN_CI), защото пропуснат тест за сигурност на ниво ред е зелена бариера, която не е измерила нищо. Сървърът изчаква до 180 секунди, за да стартира, а наблюдател (watchdog) го спира, когато тестовият процес приключи.

Тестовата рамка за изолация. runIsolationHarness(target) от testing/isolation-harness прочита всеки маршрут, който вашето приложение монтира, и атакува всеки един като администратор на друга организация и като колега. След това атакува отново с премахната кодова ограда, с премахната ограда на базата данни и с премахнати и двете. Даден маршрут е PROVEN само когато атаката се провали при наличието на която и да е от оградите и достигне до данните на жертвата при премахнати и двете — така знаете, че тестът изобщо е способен да засече изтичане на данни. Тя изпраща декларираната заявка и примерно тяло за всеки маршрут, така че маршрут, който отхвърля празна заявка, все пак бива достигнат. Фиксирайте ledgerOf(report) в тест и задайте провал при defectsOf(report).

Регистрация: от манифеста до регистъра на уменията

Уменията от вашия манифест достигат до регистъра на уменията по един път:

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

compileRegistry превръща валидиран манифест в тяло за nexus.plugin-sync/v1. Шаблонът прави това при импортиране, така че невалиден манифест проваля компилацията:

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

Синхронизацията е декларативна: изпращайте целия набор от умения всеки път, а пропуснато умение се деактивира, като историята му се запазва. Тя е стриктна: непознато поле, поле от друго ниво или null се отхвърлят, всички нарушения се връщат заедно в един 400 SYNC_CONTRACT_VIOLATION и нищо не се записва, докато има поне едно нарушение. И тя записва по един ред в регистъра за всяко умение, с ключ типа на задачата с пространство от имена, носещ всяка колона, която диспечерът чете, така че умението е готово за изпълнение в момента, в който синхронизацията отговори с 200.

Плъгинът е удостовереният извикващ, никога поле в тялото. Извиквайте синхронизацията от собственото работно натоварване (workload) на вашия плъгин през mTLS (взаимен TLS: Transport Layer Security със сертификат от двете страни). Skills Engine чете клиентския сертификат на вашето работно натоварване, чиято SPIFFE идентичност (spiffe://<trust-domain>/ns/<namespace>/sa/<service-account>) посочва пространството от имена и сервизния акаунт, и намира плъгина и притежаващата организация, записани за това пространство от имена. Полето pluginId в тялото трябва да съвпада; то е проверка, а не селектор. Всеки ред се записва с този плъгин и тази организация.

Състояние Код Значение
200 {contract, pluginId, version, created, updated, unchanged, disabled, skills}
400 SYNC_CONTRACT_VIOLATION Всяко нарушение е изброено в violations[]; нищо не е записано
401 UNAUTHORIZED Невалиден или липсващ сервизен ключ
401 CALLER_IDENTITY_UNVERIFIED Няма четима клиентска идентичност
403 DELIVERY_IDENTITY_MISSING Извикващото пространство от имена не принадлежи на никой плъгин
403 PLUGIN_ID_MISMATCH Тялото посочва друг плъгин
409 REGISTRY_CONFLICT Тип задача е собственост на друг или е бил регистриран извън синхронизацията; нищо не е записано

Провалете стъпката си за внедряване при всеки друг статус освен 200. Никой друг статус не означава, че уменията ви са регистрирани.

Въвеждане в експлоатация

Въвеждането в експлоатация се изпълнява като десет последователни стъпки, всяка от които може да бъде стартирана отново, отменена или върната назад самостоятелно:

  1. Клониране на хранилището и неговото валидиране.
  2. Парсване на манифеста.
  3. Сканиране за проблеми със сигурността.
  4. Изграждане на образа (image).
  5. Качване (push) в регистъра на инсталацията.
  6. Настройване на имената на домейните му.
  7. Внедряване чрез каналите за издаване на инсталацията.
  8. Изчакване на проверката за изправност (health check).
  9. Регистриране на плъгина.
  10. Уведомяване на разработчика.

Преди внедряването се изпълняват пет проверки за съответствие спрямо манифеста и изградения образ: манифестът се парсва и съдържа задължителните си полета; всеки деклариран маршрут е реален регистриран маршрут; плъгинът притежава своята схема и не записва нищо извън нея; заявките за ресурси са декларирани и са в рамките на ограниченията; и образът има работещ манипулатор за проверка на изправността. Плъгин, който се саморегистрира при стартиране, изпълнява същия договор под собствените си правомощия, така че проверките стават негов собствен CI вместо този на конвейера (pipeline). Пропускането на проверка не съкращава въвеждането в експлоатация; то премества отказа по време на изпълнение.

Брандирането във вашия манифест се сервира без удостоверяване по домейн, тъй като страницата за вход се нуждае от него, преди някой да има идентификационни данни. Третирайте всичко в branding като публично.

Среди и повишаване
Среди и повишаване
„Среди и повишаване“ придвижва всяко издание от средата за разработка през тестовата среда (staging) до пилотно звено, а след това до всички звена, като всяка бариера и нейното състояние са на една страница. Повишаване, което прескача бариера, се отхвърля с GATE_CANNOT_BE_SKIPPED.
Канали и инсталации
Канали и инсталации
„Канали и инсталации“ показва кое звено коя версия изпълнява, с честота на грешките като бройки, но никога като съдържание. Връщането на едно звено към стара версия е проверена промяна, която засяга само това звено.

Какво средата за изпълнение няма да направи вместо Вас

Средата за изпълнение държи фронта по отношение на изолацията, диспечирането и достъпа до модели. Тя няма да направи продуктовата ви логика правилна и няма да направи бавната заявка бърза: всяка заявка се изпълнява в рамките на обвързана транзакция с времевите ограничения (timeouts), които блокът db на вашия манифест декларира, а заявка, която надхвърли statementTimeoutMs, се отменя, вместо да се изчаква. Оразмерявайте заявките си спрямо това. Освен това задържането за одобрение, мястото за четене и четецът на лицензи добавят мрежово обръщение или транзакция. В моя плъгин за преглед на аномалии проверката на лиценза добавяше по няколко милисекунди на заявка, докато 30-секундната ѝ памет се запълни, което беше справедлива цена за това никога да не се предоставя заключена функционалност.